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 
41 using namespace ::com::sun::star::uno;
42 
43 void 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 
126 namespace 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 
173 namespace {
174 
175 static 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 
387 namespace 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: */
bool is_complex_struct(const typelib_TypeDescription *type)
Type
sal_Int32 nIndex
void SAL_CALL uno_destructData(void *pValue, typelib_TypeDescription *pTypeDescr, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
Represents a vtable slot of a C++ class.
Definition: vtables.hxx:59
void fillUnoException(uno_Any *pExc, uno_Mapping *pCpp2Uno)
bool isSimpleType(typelib_TypeClass typeClass)
Determines whether a type is a "simple" type (VOID, BOOLEAN, BYTE, SHORT, UNSIGNED SHORT...
Definition: types.cxx:28
sal_Int32 index
The index within the vtable.
Definition: vtables.hxx:76
A uno proxy wrapping a cpp interface.
bool relatesToInterfaceType(typelib_TypeDescription const *type)
Determines whether a type relates to an interface type (is itself an interface type, or might contain entities of interface type).
Definition: types.cxx:41
void unoInterfaceProxyDispatch(uno_Interface *pUnoI, const typelib_TypeDescription *pMemberDescr, void *pReturn, void *pArgs[], uno_Any **ppException)
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_INT16(pSV, nr, pGPR, pDS, bOverflow)
uno_ExtEnvironment * getUnoEnv()
Definition: bridge.hxx:70
struct _uno_Any uno_Any
Definition: msvc/except.hxx:31
uno_Mapping * getUno2Cpp()
Definition: bridge.hxx:73
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)
#define INSERT_INT8( pSV, nr, pGPR, pDS, bOverflow)
sal_Int32 offset
The offset of the vtable.
Definition: vtables.hxx:68
int i
typelib_InterfaceTypeDescription * pTypeDescr
void SAL_CALL uno_constructData(void *pMem, typelib_TypeDescription *pTypeDescr) SAL_THROW_EXTERN_C()
#define sal_True
void SAL_CALL uno_copyAndConvertData(void *pDest, void *pSource, typelib_TypeDescription *pTypeDescr, uno_Mapping *mapping) SAL_THROW_EXTERN_C()
void SAL_CALL typelib_typedescriptionreference_release(typelib_TypeDescriptionReference *pRef) SAL_THROW_EXTERN_C()
struct _typelib_TypeDescription typelib_TypeDescription
Definition: msvc/except.hxx:52
#define INSERT_INT64(pSV, nr, pGPR, pDS, pStart, bOverflow)
uno_Mapping * getCpp2Uno()
Definition: bridge.hxx:72
VtableSlot getVtableSlot(typelib_InterfaceAttributeTypeDescription const *ifcMember)
Calculates the vtable slot associated with an interface attribute member.
Definition: vtables.cxx:132
XPropertyListType t
void SAL_CALL typelib_typedescriptionreference_new(typelib_TypeDescriptionReference **ppTDR, typelib_TypeClass eTypeClass, rtl_uString *pTypeName) SAL_THROW_EXTERN_C()
#define INSERT_DOUBLE(pSV, nr, pFPR, pDS, pStart, bOverflow)
OUString runtimeToOUString(char const *runtimeString)
#define INSERT_INT32(pSV, nr, pGPR, pDS, bOverflow)
#define INSERT_FLOAT(pSV, nr, pFPR, pDS, bOverflow)
#define sal_False
void * p
bool isRegisterReturn(typelib_TypeDescriptionReference *pTypeRef)
com::sun::star::uno::XInterface * getCppI()
sal_uInt16 nPos
char const * name