LibreOffice Module bridges (master) 1
gcc3_linux_loongarch64/cpp2uno.cxx
Go to the documentation of this file.
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
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 <com/sun/star/uno/genfunc.hxx>
21#include <sal/log.hxx>
22#include <typelib/typedescription.hxx>
23#include <uno/data.h>
24#include <osl/endian.h>
25#include "bridge.hxx"
26#include "cppinterfaceproxy.hxx"
27#include "types.hxx"
28#include "vtablefactory.hxx"
29#include "call.hxx"
30#include "share.hxx"
31
32#include <stdio.h>
33#include <string.h>
34
35using namespace com::sun::star::uno;
36
38{
40{
41 const typelib_CompoundTypeDescription* p
42 = reinterpret_cast<const typelib_CompoundTypeDescription*>(type);
43 for (sal_Int32 i = 0; i < p->nMembers; ++i)
44 {
45 if (p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_STRUCT
46 || p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_EXCEPTION)
47 {
49 TYPELIB_DANGER_GET(&t, p->ppTypeRefs[i]);
50 bool b = is_complex_struct(t);
51 TYPELIB_DANGER_RELEASE(t);
52 if (b)
53 {
54 return true;
55 }
56 }
57 else if (!bridges::cpp_uno::shared::isSimpleType(p->ppTypeRefs[i]->eTypeClass))
58 return true;
59 }
60 if (p->pBaseTypeDescription != 0)
61 return is_complex_struct(&p->pBaseTypeDescription->aBase);
62 return false;
63}
64
65bool return_in_hidden_param(typelib_TypeDescriptionReference* pTypeRef)
66{
68 return false;
69 else if (pTypeRef->eTypeClass == typelib_TypeClass_STRUCT
70 || pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION)
71 {
72 typelib_TypeDescription* pTypeDescr = 0;
73 TYPELIB_DANGER_GET(&pTypeDescr, pTypeRef);
74
75 //A Composite Type not larger than 16 bytes is returned in up to two GPRs
76 bool bRet = pTypeDescr->nSize > 16 || is_complex_struct(pTypeDescr);
77
78 TYPELIB_DANGER_RELEASE(pTypeDescr);
79 return bRet;
80 }
81 return true;
82}
83}
84
85namespace
86{
87static typelib_TypeClass
89 const typelib_TypeDescription* pMemberTypeDescr,
90 typelib_TypeDescriptionReference* pReturnTypeRef, // 0 indicates void return
91 sal_Int32 nParams, typelib_MethodParameter* pParams, void** gpreg, void** fpreg,
92 void** ovrflw, sal_uInt64* pRegisterReturn /* space for register return */)
93{
94 unsigned int nREG = 0;
95
96 // return
97 typelib_TypeDescription* pReturnTypeDescr = 0;
98 if (pReturnTypeRef)
99 TYPELIB_DANGER_GET(&pReturnTypeDescr, pReturnTypeRef);
100
101 void* pUnoReturn = 0;
102 void* pCppReturn = 0; // complex return ptr: if != 0 && != pUnoReturn, reconversion need
103
104 if (pReturnTypeDescr)
105 {
107 {
108 pCppReturn = gpreg[nREG]; // complex return via ptr (pCppReturn)
109 nREG++;
110
111 pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType(pReturnTypeDescr)
112 ? alloca(pReturnTypeDescr->nSize)
113 : pCppReturn); // direct way
114 }
115 else
116 {
117 pUnoReturn = pRegisterReturn; // direct way for simple types
118 }
119 }
120
121 // pop this
122 nREG++;
123
124 // stack space
125 static_assert(sizeof(void*) == sizeof(sal_Int64), "### unexpected size!");
126 // parameters
127 void** pUnoArgs = (void**)alloca(4 * sizeof(void*) * nParams);
128 void** pCppArgs = pUnoArgs + nParams;
129 // indices of values this have to be converted (interface conversion cpp<=>uno)
130 sal_Int32* pTempIndices = (sal_Int32*)(pUnoArgs + (2 * nParams));
131 // type descriptions for reconversions
132 typelib_TypeDescription** ppTempParamTypeDescr
133 = (typelib_TypeDescription**)(pUnoArgs + (3 * nParams));
134
135 sal_Int32 nTempIndices = 0;
136
137 for (sal_Int32 nPos = 0; nPos < nParams; ++nPos)
138 {
139 const typelib_MethodParameter& rParam = pParams[nPos];
140
141 typelib_TypeDescription* pParamTypeDescr = 0;
142 TYPELIB_DANGER_GET(&pParamTypeDescr, rParam.pTypeRef);
143
144 if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType(pParamTypeDescr)) // value
145 {
146 switch (pParamTypeDescr->eTypeClass)
147 {
148 case typelib_TypeClass_FLOAT:
149 case typelib_TypeClass_DOUBLE:
150 if (nREG < MAX_FP_REGS)
151 {
152 pCppArgs[nPos] = &(fpreg[nREG]);
153 pUnoArgs[nPos] = &(fpreg[nREG]);
154 }
155 else
156 {
157 pCppArgs[nPos] = &(ovrflw[nREG - MAX_FP_REGS]);
158 pUnoArgs[nPos] = &(ovrflw[nREG - MAX_FP_REGS]);
159 }
160 nREG++;
161 break;
162
163 default:
164 if (nREG < MAX_GP_REGS)
165 {
166 pCppArgs[nPos] = &(gpreg[nREG]);
167 pUnoArgs[nPos] = &(gpreg[nREG]);
168 }
169 else
170 {
171 pCppArgs[nPos] = &(ovrflw[nREG - MAX_GP_REGS]);
172 pUnoArgs[nPos] = &(ovrflw[nREG - MAX_GP_REGS]);
173 }
174 nREG++;
175 break;
176 }
177 // no longer needed
178 TYPELIB_DANGER_RELEASE(pParamTypeDescr);
179 }
180 else // ptr to complex value | ref
181 {
182 void* pCppStack;
183 if (nREG < MAX_GP_REGS)
184 {
185 pCppArgs[nPos] = pCppStack = gpreg[nREG];
186 }
187 else
188 {
189 pCppArgs[nPos] = pCppStack = ovrflw[nREG - MAX_GP_REGS];
190 }
191 nREG++;
192
193 if (!rParam.bIn) // is pure out
194 {
195 // uno out is unconstructed mem!
196 pUnoArgs[nPos] = alloca(pParamTypeDescr->nSize);
197 pTempIndices[nTempIndices] = nPos;
198 // will be released at reconversion
199 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
200 }
201 // is in/inout
202 else if (bridges::cpp_uno::shared::relatesToInterfaceType(pParamTypeDescr))
203 {
204 uno_copyAndConvertData(pUnoArgs[nPos] = alloca(pParamTypeDescr->nSize), pCppStack,
205 pParamTypeDescr, pThis->getBridge()->getCpp2Uno());
206 pTempIndices[nTempIndices] = nPos; // has to be reconverted
207 // will be released at reconversion
208 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
209 }
210 else // direct way
211 {
212 pUnoArgs[nPos] = pCppStack;
213 // no longer needed
214 TYPELIB_DANGER_RELEASE(pParamTypeDescr);
215 }
216 }
217 }
218 // ExceptionHolder
219 uno_Any aUnoExc; // Any will be constructed by callee
220 uno_Any* pUnoExc = &aUnoExc;
221
222 // invoke uno dispatch call
223 (*pThis->getUnoI()->pDispatcher)(pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs,
224 &pUnoExc);
225 // in case an exception occurred...
226 if (pUnoExc)
227 {
228 // destruct temporary in/inout params
229 for (; nTempIndices--;)
230 {
231 sal_Int32 nIndex = pTempIndices[nTempIndices];
232
233 if (pParams[nIndex].bIn) // is in/inout => was constructed
234 uno_destructData(pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0);
235 TYPELIB_DANGER_RELEASE(ppTempParamTypeDescr[nTempIndices]);
236 }
237 if (pReturnTypeDescr)
238 TYPELIB_DANGER_RELEASE(pReturnTypeDescr);
239
241 // has to destruct the any
242 // is here for dummy
243 return typelib_TypeClass_VOID;
244 }
245 else // else no exception occurred...
246 {
247 // temporary params
248 for (; nTempIndices--;)
249 {
250 sal_Int32 nIndex = pTempIndices[nTempIndices];
251 typelib_TypeDescription* pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
252
253 if (pParams[nIndex].bOut) // inout/out
254 {
255 // convert and assign
256 uno_destructData(pCppArgs[nIndex], pParamTypeDescr, cpp_release);
257 uno_copyAndConvertData(pCppArgs[nIndex], pUnoArgs[nIndex], pParamTypeDescr,
258 pThis->getBridge()->getUno2Cpp());
259 }
260 // destroy temp uno param
261 uno_destructData(pUnoArgs[nIndex], pParamTypeDescr, 0);
262
263 TYPELIB_DANGER_RELEASE(pParamTypeDescr);
264 }
265 // return
266 if (pCppReturn) // has complex return
267 {
268 if (pUnoReturn != pCppReturn) // needs reconversion
269 {
270 uno_copyAndConvertData(pCppReturn, pUnoReturn, pReturnTypeDescr,
271 pThis->getBridge()->getUno2Cpp());
272 // destroy temp uno return
273 uno_destructData(pUnoReturn, pReturnTypeDescr, 0);
274 }
275 // complex return ptr is set to return reg
276 *(void**)pRegisterReturn = pCppReturn;
277 }
278 if (pReturnTypeDescr)
279 {
280 typelib_TypeClass eRet = (typelib_TypeClass)pReturnTypeDescr->eTypeClass;
281 TYPELIB_DANGER_RELEASE(pReturnTypeDescr);
282 return eRet;
283 }
284 else
285 return typelib_TypeClass_VOID;
286 }
287}
288
293typelib_TypeClass cpp_vtable_call(sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset, void** gpreg,
294 void** fpreg, void** ovrflw,
295 sal_uInt64* pRegisterReturn /* space for register return */)
296{
297 static_assert(sizeof(sal_Int64) == sizeof(void*), "### unexpected!");
298
299 // gpreg: [ret *], this, [other gpr params]
300 // fpreg: [fpr params]
301 // ovrflw: [gpr or fpr params (properly aligned)]
302 void* pThis;
303 if (nFunctionIndex & 0x80000000)
304 {
305 nFunctionIndex &= 0x7fffffff;
306 pThis = gpreg[1];
307 }
308 else
309 {
310 pThis = gpreg[0];
311 }
312 pThis = static_cast<char*>(pThis) - nVtableOffset;
315 typelib_InterfaceTypeDescription* pTypeDescr = pCppI->getTypeDescr();
316
317 if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)
318 {
319 SAL_WARN("bridges", "illegal " << OUString::unacquired(&pTypeDescr->aBase.pTypeName)
320 << " vtable index " << nFunctionIndex << "/"
321 << pTypeDescr->nMapFunctionIndexToMemberIndex);
322 throw RuntimeException(("illegal " + OUString::unacquired(&pTypeDescr->aBase.pTypeName)
323 + " vtable index " + OUString::number(nFunctionIndex) + "/"
324 + OUString::number(pTypeDescr->nMapFunctionIndexToMemberIndex)),
325 (XInterface*)pThis);
326 }
327
328 // determine called method
329 sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
330 assert(nMemberPos < pTypeDescr->nAllMembers);
331
332 TypeDescription aMemberDescr(pTypeDescr->ppAllMembers[nMemberPos]);
333
334 typelib_TypeClass eRet;
335 switch (aMemberDescr.get()->eTypeClass)
336 {
337 case typelib_TypeClass_INTERFACE_ATTRIBUTE:
338 {
339 typelib_TypeDescriptionReference* pAttrTypeRef
340 = reinterpret_cast<typelib_InterfaceAttributeTypeDescription*>(aMemberDescr.get())
341 ->pAttributeTypeRef;
342
343 if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex)
344 {
345 // is GET method
346 eRet = cpp2uno_call(pCppI, aMemberDescr.get(), pAttrTypeRef, 0, 0, // no params
347 gpreg, fpreg, ovrflw, pRegisterReturn);
348 }
349 else
350 {
351 // is SET method
352 typelib_MethodParameter aParam;
353 aParam.pTypeRef = pAttrTypeRef;
354 aParam.bIn = sal_True;
355 aParam.bOut = sal_False;
356
357 eRet = cpp2uno_call(pCppI, aMemberDescr.get(),
358 0, // indicates void return
359 1, &aParam, gpreg, fpreg, ovrflw, pRegisterReturn);
360 }
361 break;
362 }
363 case typelib_TypeClass_INTERFACE_METHOD:
364 {
365 // is METHOD
366 switch (nFunctionIndex)
367 {
368 case 1: // acquire()
369 pCppI->acquireProxy(); // non virtual call!
370 eRet = typelib_TypeClass_VOID;
371 break;
372 case 2: // release()
373 pCppI->releaseProxy(); // non virtual call!
374 eRet = typelib_TypeClass_VOID;
375 break;
376 case 0: // queryInterface() opt
377 {
379 TYPELIB_DANGER_GET(&pTD, reinterpret_cast<Type*>(gpreg[2])->getTypeLibType());
380 if (pTD)
381 {
382 XInterface* pInterface = 0;
383 (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)(
384 pCppI->getBridge()->getCppEnv(), (void**)&pInterface,
385 pCppI->getOid().pData,
386 reinterpret_cast<typelib_InterfaceTypeDescription*>(pTD));
387
388 if (pInterface)
389 {
390 ::uno_any_construct(reinterpret_cast<uno_Any*>(gpreg[0]), &pInterface,
391 pTD, cpp_acquire);
392
393 pInterface->release();
394 TYPELIB_DANGER_RELEASE(pTD);
395
396 reinterpret_cast<void**>(pRegisterReturn)[0] = gpreg[0];
397 eRet = typelib_TypeClass_ANY;
398 break;
399 }
400 TYPELIB_DANGER_RELEASE(pTD);
401 }
402 } // else perform queryInterface()
403 default:
404 typelib_InterfaceMethodTypeDescription* pMethodTD
405 = reinterpret_cast<typelib_InterfaceMethodTypeDescription*>(
406 aMemberDescr.get());
407
408 eRet = cpp2uno_call(pCppI, aMemberDescr.get(), pMethodTD->pReturnTypeRef,
409 pMethodTD->nParams, pMethodTD->pParams, gpreg, fpreg,
410 ovrflw, pRegisterReturn);
411 }
412 break;
413 }
414 default:
415 {
416 throw RuntimeException("no member description found!", (XInterface*)pThis);
417 }
418 }
419
420 return eRet;
421}
422
423extern "C" void privateSnippetExecutor(...);
424
425int const codeSnippetSize = 0x34;
426
427unsigned char* codeSnippet(unsigned char* code, sal_Int32 functionIndex, sal_Int32 vtableOffset,
428 bool bHasHiddenParam)
429{
430 if (bHasHiddenParam)
431 functionIndex |= 0x80000000;
432
433 unsigned int* p = (unsigned int*)code;
434
435 assert((((unsigned long)code) & 0x3) == 0); //aligned to 4 otherwise a mistake
436
437 /* generate this code */
438 /*
439 # index
440 0: 14000012 lu12i.w $t6,0x0
441 4: 34420000 ori $t6,$t6,0x0
442 # privateSnippetExecutor
443 8: 14000014 lu12i.w $t8,0x0
444 c: 03800294 ori $t8,$t8,0x0
445 10: 16000014 lu32i.d $t8,0x0
446 14: 03000294 lu52i.d $t8,$t8,0x0
447 # cpp_vtable_call
448 18: 14000011 lu12i.w $t5,0x0
449 1c: 03800231 ori $t5,$t5,0x0
450 20: 16000011 lu32i.d $t5,0x0
451 24: 03000231 lu52i.d $t5,$t5,0x0
452 # offset
453 28: 14000013 lu12i.w $t7,0x0
454 2c: 03800273 ori $t7,$t7,0x0
455 30: 4c000280 jr $t8
456 */
457
458 *p++ = 0x14000012 | (((functionIndex >> 12) & 0x000fffff) << 5);
459 *p++ = 0x03800252 | ((functionIndex & 0x00000fff) << 10);
460 *p++ = 0x14000014 | (((((unsigned long)privateSnippetExecutor) >> 12) & 0x000fffff) << 5);
461 *p++ = 0x03800294 | ((((unsigned long)privateSnippetExecutor) & 0x00000fff) << 10);
462 *p++ = 0x16000014 | (((((unsigned long)privateSnippetExecutor) >> 32) & 0x000fffff) << 5);
463 *p++ = 0x03000294 | (((((unsigned long)privateSnippetExecutor) >> 52) & 0x00000fff) << 10);
464 *p++ = 0x14000011 | (((((unsigned long)cpp_vtable_call) >> 12) & 0x000fffff) << 5);
465 *p++ = 0x03800231 | ((((unsigned long)cpp_vtable_call) & 0x00000fff) << 10);
466 *p++ = 0x16000011 | (((((unsigned long)cpp_vtable_call) >> 32) & 0x000fffff) << 5);
467 *p++ = 0x03000231 | (((((unsigned long)cpp_vtable_call) >> 52) & 0x00000fff) << 10);
468 *p++ = 0x14000013 | (((vtableOffset >> 12) & 0x000fffff) << 5);
469 *p++ = 0x03800273 | ((vtableOffset & 0x00000fff) << 10);
470 *p++ = 0x4c000280;
471 return (code + codeSnippetSize);
472}
473}
474
475void bridges::cpp_uno::shared::VtableFactory::flushCode(unsigned char const* bptr,
476 unsigned char const* eptr)
477{
478 asm volatile("ibar 0" :::);
479}
480
482{
483 void* fn;
484};
485
488{
489 return static_cast<Slot*>(block) + 2;
490}
491
492std::size_t bridges::cpp_uno::shared::VtableFactory::getBlockSize(sal_Int32 slotCount)
493{
494 return (slotCount + 2) * sizeof(Slot) + slotCount * codeSnippetSize;
495}
496
498bridges::cpp_uno::shared::VtableFactory::initializeBlock(void* block, sal_Int32 slotCount,
499 sal_Int32,
500 typelib_InterfaceTypeDescription*)
501{
502 Slot* slots = mapBlockToVtable(block);
503 slots[-2].fn = 0; //null
504 slots[-1].fn = 0; //destructor
505 return slots + slotCount;
506}
507
509 Slot** slots, unsigned char* code, sal_PtrDiff writetoexecdiff,
510 typelib_InterfaceTypeDescription const* type, sal_Int32 functionOffset, sal_Int32 functionCount,
511 sal_Int32 vtableOffset)
512{
513 (*slots) -= functionCount;
514 Slot* s = *slots;
515
516 for (sal_Int32 i = 0; i < type->nMembers; ++i)
517 {
518 typelib_TypeDescription* member = 0;
519 TYPELIB_DANGER_GET(&member, type->ppMembers[i]);
520 assert(member != 0);
521 switch (member->eTypeClass)
522 {
523 case typelib_TypeClass_INTERFACE_ATTRIBUTE:
524 // Getter:
525 (s++)->fn = code + writetoexecdiff;
527 code, functionOffset++, vtableOffset,
529 reinterpret_cast<typelib_InterfaceAttributeTypeDescription*>(member)
530 ->pAttributeTypeRef));
531
532 // Setter:
533 if (!reinterpret_cast<typelib_InterfaceAttributeTypeDescription*>(member)
534 ->bReadOnly)
535 {
536 (s++)->fn = code + writetoexecdiff;
537 code = codeSnippet(code, functionOffset++, vtableOffset, false);
538 }
539 break;
540
541 case typelib_TypeClass_INTERFACE_METHOD:
542 (s++)->fn = code + writetoexecdiff;
544 code, functionOffset++, vtableOffset,
546 reinterpret_cast<typelib_InterfaceMethodTypeDescription*>(member)
547 ->pReturnTypeRef));
548 break;
549
550 default:
551 assert(false);
552 break;
553 }
554 TYPELIB_DANGER_RELEASE(member);
555 }
556 return code;
557}
558
559/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
XPropertyListType t
uno_Mapping * getUno2Cpp()
Definition: bridge.hxx:73
uno_ExtEnvironment * getCppEnv()
Definition: bridge.hxx:69
uno_Mapping * getCpp2Uno()
Definition: bridge.hxx:72
A cpp proxy wrapping a uno interface.
static CppInterfaceProxy * castInterfaceToProxy(void *pInterface)
typelib_InterfaceTypeDescription * getTypeDescr()
static Slot * mapBlockToVtable(void *block)
Given a pointer to a block, turn it into a vtable pointer.
static void flushCode(unsigned char const *begin, unsigned char const *end)
Flush all the generated code snippets of a vtable, on platforms that require it.
static unsigned char * addLocalFunctions(Slot **slots, unsigned char *code, sal_PtrDiff writetoexecdiff, typelib_InterfaceTypeDescription const *type, sal_Int32 functionOffset, sal_Int32 functionCount, sal_Int32 vtableOffset)
Fill the vtable slots corresponding to all local (i.e., not inherited) functions of a given interface...
static Slot * initializeBlock(void *block, sal_Int32 slotCount, sal_Int32 vtableNumber, typelib_InterfaceTypeDescription *type)
Initialize a raw vtable block.
static std::size_t getBlockSize(sal_Int32 slotCount)
Calculate the size of a raw vtable block.
void SAL_CALL uno_destructData(void *pValue, typelib_TypeDescription *pTypeDescr, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
void SAL_CALL uno_copyAndConvertData(void *pDest, void *pSource, typelib_TypeDescription *pTypeDescr, uno_Mapping *mapping) SAL_THROW_EXTERN_C()
void cpp_vtable_call(sal_Int32 func, sal_Int32 offset, void **pStack)
is called on incoming vtable calls (called by asm snippets)
void(* privateSnippetExecutor)()
#define MAX_FP_REGS
#define MAX_GP_REGS
const int codeSnippetSize
static unsigned char * codeSnippet(unsigned char *code, sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset, bool bHasHiddenParam)
static int cpp2uno_call(bridges::cpp_uno::shared::CppInterfaceProxy *pThis, const typelib_TypeDescription *pMemberTypeDescr, typelib_TypeDescriptionReference *pReturnTypeRef, sal_Int32 nParams, typelib_MethodParameter *pParams, void **gpreg, void **fpreg, void **ovrflw, sal_uInt64 *pRegisterReturn)
sal_Int32 nIndex
void * p
sal_uInt16 nPos
#define SAL_WARN(area, stream)
struct _typelib_TypeDescription typelib_TypeDescription
Definition: msvc/except.hxx:52
struct _uno_Any uno_Any
Definition: msvc/except.hxx:31
bool return_in_hidden_param(typelib_TypeDescriptionReference *pTypeRef)
void raiseException(uno_Any *pUnoExc, uno_Mapping *pUno2Cpp)
bool is_complex_struct(const typelib_TypeDescription *type)
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
sal_Unicode code
#define sal_True
#define sal_False
ResultType type