LibreOffice Module bridges (master)  1
gcc3_linux_alpha/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 
43 using namespace ::com::sun::star::uno;
44 
45 void MapReturn(long r0, typelib_TypeClass eTypeClass, sal_uInt64* pRegisterReturn)
46 {
47  register float fret asm("$f0");
48  register double dret asm("$f0");
49 
50 #if OSL_DEBUG_LEVEL > 2
51  fprintf(stderr,"Mapping Return with %lx %ld %f\n", r0, r0, dret);
52 #endif
53  switch (eTypeClass)
54  {
55  case typelib_TypeClass_HYPER:
56  case typelib_TypeClass_UNSIGNED_HYPER:
57  *pRegisterReturn = r0;
58  break;
59  case typelib_TypeClass_LONG:
60  case typelib_TypeClass_UNSIGNED_LONG:
61  case typelib_TypeClass_ENUM:
62  *(unsigned int*)pRegisterReturn = (unsigned int)r0;
63  break;
64  case typelib_TypeClass_CHAR:
65  case typelib_TypeClass_SHORT:
66  case typelib_TypeClass_UNSIGNED_SHORT:
67  *(unsigned short*)pRegisterReturn = (unsigned short)r0;
68  break;
69  case typelib_TypeClass_BOOLEAN:
70  case typelib_TypeClass_BYTE:
71  *(unsigned char*)pRegisterReturn = (unsigned char)r0;
72  break;
73  case typelib_TypeClass_FLOAT:
74  *reinterpret_cast<float *>( pRegisterReturn ) = fret;
75  break;
76  case typelib_TypeClass_DOUBLE:
77  *reinterpret_cast<double *>( pRegisterReturn ) = dret;
78  break;
79  default:
80  break;
81  }
82 #if OSL_DEBUG_LEVEL > 2
83  fprintf(stderr, "end of MapReturn with %x\n", pRegisterReturn ? *pRegisterReturn : 0);
84 #endif
85 }
86 
87 #define INSERT_FLOAT( pSV, nr, pFPR, pDS ) \
88  { \
89  if ( nr < axp::MAX_WORDS_IN_REGS ) \
90  { \
91  pFPR[nr++] = *reinterpret_cast<float *>( pSV ); \
92  } \
93  else \
94  *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV ); \
95  }
96 
97 #define INSERT_DOUBLE( pSV, nr, pFPR, pDS ) \
98  if ( nr < axp::MAX_WORDS_IN_REGS ) \
99  pFPR[nr++] = *reinterpret_cast<double *>( pSV ); \
100  else \
101  *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV ); // verbatim!
102 
103 #define INSERT_INT64( pSV, nr, pGPR, pDS ) \
104  if ( nr < axp::MAX_WORDS_IN_REGS ) \
105  pGPR[nr++] = *reinterpret_cast<sal_uInt64 *>( pSV ); \
106  else \
107  *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV );
108 
109 #define INSERT_INT32( pSV, nr, pGPR, pDS ) \
110  if ( nr < axp::MAX_WORDS_IN_REGS ) \
111  pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \
112  else \
113  *pDS++ = *reinterpret_cast<sal_uInt32 *>( pSV );
114 
115 #define INSERT_INT16( pSV, nr, pGPR, pDS ) \
116  if ( nr < axp::MAX_WORDS_IN_REGS ) \
117  pGPR[nr++] = *reinterpret_cast<sal_uInt16 *>( pSV ); \
118  else \
119  *pDS++ = *reinterpret_cast<sal_uInt16 *>( pSV );
120 
121 #define INSERT_INT8( pSV, nr, pGPR, pDS ) \
122  if ( nr < axp::MAX_WORDS_IN_REGS ) \
123  pGPR[nr++] = *reinterpret_cast<sal_uInt8 *>( pSV ); \
124  else \
125  *pDS++ = *reinterpret_cast<sal_uInt8 *>( pSV );
126 
127 namespace
128 {
129 
130 void callVirtualMethod(
131  void * pThis, sal_Int32 nVtableIndex,
132  void * pRegisterReturn, typelib_TypeDescription * pReturnTypeDescr,
133  sal_uInt64 *pStack, sal_uInt32 nStack,
134  sal_uInt64 *pGPR, sal_uInt32 nGPR,
135  double *pFPR, sal_uInt32 nFPR)
136 {
137  // Should not happen, but...
138  if ( nFPR > axp::MAX_SSE_REGS )
139  nFPR = axp::MAX_SSE_REGS;
140  if ( nGPR > axp::MAX_GPR_REGS )
141  nGPR = axp::MAX_GPR_REGS;
142 
143 #if OSL_DEBUG_LEVEL > 2
144  // Let's figure out what is really going on here
145  {
146  fprintf( stderr, "= nStack is %d\n", nStack );
147  fprintf( stderr, "= callVirtualMethod() =\nGPR's (%d): ", nGPR );
148  for ( unsigned int i = 0; i < nGPR; ++i )
149  fprintf( stderr, "0x%lx, ", pGPR[i] );
150  fprintf( stderr, "\nFPR's (%d): ", nFPR );
151  for ( unsigned int i = 0; i < nFPR; ++i )
152  fprintf( stderr, "0x%lx (%f), ", pFPR[i], pFPR[i] );
153  fprintf( stderr, "\nStack (%d): ", nStack );
154  for ( unsigned int i = 0; i < nStack; ++i )
155  fprintf( stderr, "0x%lx, ", pStack[i] );
156  fprintf( stderr, "\n" );
157  fprintf( stderr, "pRegisterReturn is %p\n", pRegisterReturn);
158  }
159 #endif
160 
161  // Load parameters to stack, if necessary
162  // Stack, if used, must be 8-bytes aligned
163  sal_uInt64 *stack = (sal_uInt64 *) __builtin_alloca( nStack * 8 );
164  memcpy( stack, pStack, nStack * 8 );
165 
166  // To get pointer to method
167  // a) get the address of the vtable
168  sal_uInt64 pMethod = *((sal_uInt64 *)pThis);
169  // b) get the address from the vtable entry at offset
170  pMethod += 8 * nVtableIndex;
171  pMethod = *((sal_uInt64 *)pMethod);
172 
173  typedef void (* FunctionCall )( sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64 );
174  FunctionCall pFunc = (FunctionCall)pMethod;
175 
176  switch (nFPR) //deliberate fall through
177  {
178  case 6:
179  asm volatile("ldt $f16,%0" :: "m"(pFPR[5]) : "$f16");
180  case 5:
181  asm volatile("ldt $f17,%0" :: "m"(pFPR[4]) : "$f17");
182  case 4:
183  asm volatile("ldt $f18,%0" :: "m"(pFPR[3]) : "$f18");
184  case 3:
185  asm volatile("ldt $f19,%0" :: "m"(pFPR[2]) : "$f19");
186  case 2:
187  asm volatile("ldt $f20,%0" :: "m"(pFPR[1]) : "$f20");
188  case 1:
189  asm volatile("ldt $f21,%0" :: "m"(pFPR[0]) : "$f21");
190  default:
191  break;
192  }
193 
194  (*pFunc)(pGPR[0], pGPR[1], pGPR[2], pGPR[3], pGPR[4], pGPR[5]);
195  register sal_uInt64 r0 __asm__("$0");
196  MapReturn(r0, pReturnTypeDescr->eTypeClass, (sal_uInt64*)pRegisterReturn);
197 }
198 
199 
200 static void cpp_call(
203  typelib_TypeDescriptionReference * pReturnTypeRef,
204  sal_Int32 nParams, typelib_MethodParameter * pParams,
205  void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
206 {
207  // max space for: [complex ret ptr], values|ptr ...
208  sal_uInt64 * pStack = (sal_uInt64 *)alloca( (nParams+3) * sizeof(sal_Int64) );
209  sal_uInt64 * pStackStart = pStack;
210 
211  sal_uInt64 pGPR[axp::MAX_GPR_REGS];
212  double pFPR[axp::MAX_SSE_REGS];
213  sal_uInt32 nRegs = 0;
214 
215  // return
216  typelib_TypeDescription * pReturnTypeDescr = 0;
217  TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
218  assert(pReturnTypeDescr);
219 
220  void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
221 
222  if (pReturnTypeDescr)
223  {
224  if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
225  {
226  pCppReturn = pUnoReturn; // direct way for simple types
227  }
228  else
229  {
230  // complex return via ptr
231  pCppReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
232  ? alloca( pReturnTypeDescr->nSize )
233  : pUnoReturn); // direct way
234  INSERT_INT64( &pCppReturn, nRegs, pGPR, pStack );
235  }
236  }
237  // push "this" pointer
238  void * pAdjustedThisPtr = reinterpret_cast< void ** >( pThis->getCppI() ) + aVtableSlot.offset;
239 
240  INSERT_INT64( &pAdjustedThisPtr, nRegs, pGPR, pStack );
241 
242  // stack space
243  static_assert(sizeof(void *) == sizeof(sal_Int64), "### unexpected size!");
244  // args
245  void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );
246  // indices of values this have to be converted (interface conversion cpp<=>uno)
247  sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
248  // type descriptions for reconversions
249  typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
250 
251  sal_Int32 nTempIndices = 0;
252 
253  for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
254  {
255  const typelib_MethodParameter & rParam = pParams[nPos];
256  typelib_TypeDescription * pParamTypeDescr = 0;
257  TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
258 
259  if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
260  {
261  uno_copyAndConvertData( pCppArgs[nPos] = alloca( 8 ), pUnoArgs[nPos], pParamTypeDescr,
262  pThis->getBridge()->getUno2Cpp() );
263 
264  switch (pParamTypeDescr->eTypeClass)
265  {
266  case typelib_TypeClass_HYPER:
267  case typelib_TypeClass_UNSIGNED_HYPER:
268  INSERT_INT64( pCppArgs[nPos], nRegs, pGPR, pStack );
269  break;
270  case typelib_TypeClass_LONG:
271  case typelib_TypeClass_UNSIGNED_LONG:
272  case typelib_TypeClass_ENUM:
273  INSERT_INT32( pCppArgs[nPos], nRegs, pGPR, pStack );
274  break;
275  case typelib_TypeClass_SHORT:
276  case typelib_TypeClass_CHAR:
277  case typelib_TypeClass_UNSIGNED_SHORT:
278  INSERT_INT16( pCppArgs[nPos], nRegs, pGPR, pStack );
279  break;
280  case typelib_TypeClass_BOOLEAN:
281  case typelib_TypeClass_BYTE:
282  INSERT_INT8( pCppArgs[nPos], nRegs, pGPR, pStack );
283  break;
284  case typelib_TypeClass_FLOAT:
285  INSERT_FLOAT( pCppArgs[nPos], nRegs, pFPR, pStack );
286  break;
287  case typelib_TypeClass_DOUBLE:
288  INSERT_DOUBLE( pCppArgs[nPos], nRegs, pFPR, pStack );
289  break;
290  default:
291  break;
292  }
293 
294  // no longer needed
295  TYPELIB_DANGER_RELEASE( pParamTypeDescr );
296  }
297  else // ptr to complex value | ref
298  {
299  if (! rParam.bIn) // is pure out
300  {
301  // cpp out is constructed mem, uno out is not!
303  pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
304  pParamTypeDescr );
305  pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
306  // will be released at reconversion
307  ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
308  }
309  // is in/inout
310  else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
311  {
313  pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
314  pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
315 
316  pTempIndices[nTempIndices] = nPos; // has to be reconverted
317  // will be released at reconversion
318  ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
319  }
320  else // direct way
321  {
322  pCppArgs[nPos] = pUnoArgs[nPos];
323  // no longer needed
324  TYPELIB_DANGER_RELEASE( pParamTypeDescr );
325  }
326  INSERT_INT64( &(pCppArgs[nPos]), nRegs, pGPR, pStack );
327  }
328  }
329 
330  try
331  {
332  try {
334  pAdjustedThisPtr, aVtableSlot.index,
335  pCppReturn, pReturnTypeDescr,
336  pStackStart, (pStack - pStackStart),
337  pGPR, nRegs,
338  pFPR, nRegs );
339  } catch (css::uno::Exception &) {
340  throw;
341  } catch (std::exception & e) {
342  throw css::uno::RuntimeException(
343  "C++ code threw " + o3tl::runtimeToOUString(typeid(e).name()) + ": "
344  + o3tl::runtimeToOUString(e.what()));
345  } catch (...) {
346  throw css::uno::RuntimeException("C++ code threw unknown exception");
347  }
348  // NO exception occurred...
349  *ppUnoExc = 0;
350 
351  // reconvert temporary params
352  for ( ; nTempIndices--; )
353  {
354  sal_Int32 nIndex = pTempIndices[nTempIndices];
355  typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
356 
357  if (pParams[nIndex].bIn)
358  {
359  if (pParams[nIndex].bOut) // inout
360  {
361  uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
362  uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
363  pThis->getBridge()->getCpp2Uno() );
364  }
365  }
366  else // pure out
367  {
368  uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
369  pThis->getBridge()->getCpp2Uno() );
370  }
371  // destroy temp cpp param => cpp: every param was constructed
372  uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
373 
374  TYPELIB_DANGER_RELEASE( pParamTypeDescr );
375  }
376  // return value
377  if (pCppReturn && pUnoReturn != pCppReturn)
378  {
379  uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
380  pThis->getBridge()->getCpp2Uno() );
381  uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
382  }
383  }
384  catch (...)
385  {
386  // fill uno exception
388 
389 
390  // temporary params
391  for ( ; nTempIndices--; )
392  {
393  sal_Int32 nIndex = pTempIndices[nTempIndices];
394  // destroy temp cpp param => cpp: every param was constructed
395  uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
396  TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
397  }
398  // return type
399  if (pReturnTypeDescr)
400  TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
401  }
402 }
403 }
404 
405 namespace bridges::cpp_uno::shared {
406 
408  uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
409  void * pReturn, void * pArgs[], uno_Any ** ppException )
410 {
411 #if OSL_DEBUG_LEVEL > 2
412  fprintf(stderr, "unoInterfaceProxyDispatch\n");
413 #endif
414 
415 
416  // is my surrogate
418  = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy *> (pUnoI);
419 
420  switch (pMemberDescr->eTypeClass)
421  {
422  case typelib_TypeClass_INTERFACE_ATTRIBUTE:
423  {
424 
425  VtableSlot aVtableSlot(
427  reinterpret_cast<
428  typelib_InterfaceAttributeTypeDescription const * >(
429  pMemberDescr)));
430 
431  if (pReturn)
432  {
433  // dependent dispatch
434  cpp_call(
435  pThis, aVtableSlot,
436  ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
437  0, 0, // no params
438  pReturn, pArgs, ppException );
439  }
440  else
441  {
442  // is SET
443  typelib_MethodParameter aParam;
444  aParam.pTypeRef =
445  ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;
446  aParam.bIn = sal_True;
447  aParam.bOut = sal_False;
448 
449  typelib_TypeDescriptionReference * pReturnTypeRef = 0;
450  OUString aVoidName("void");
452  &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
453 
454  // dependent dispatch
455  aVtableSlot.index += 1; //get then set method
456  cpp_call(
457  pThis, aVtableSlot,
458  pReturnTypeRef,
459  1, &aParam,
460  pReturn, pArgs, ppException );
461 
463  }
464 
465  break;
466  }
467  case typelib_TypeClass_INTERFACE_METHOD:
468  {
469 
470  VtableSlot aVtableSlot(
472  reinterpret_cast<
473  typelib_InterfaceMethodTypeDescription const * >(
474  pMemberDescr)));
475  switch (aVtableSlot.index)
476  {
477  // standard calls
478  case 1: // acquire uno interface
479  (*pUnoI->acquire)( pUnoI );
480  *ppException = 0;
481  break;
482  case 2: // release uno interface
483  (*pUnoI->release)( pUnoI );
484  *ppException = 0;
485  break;
486  case 0: // queryInterface() opt
487  {
488  typelib_TypeDescription * pTD = 0;
489  TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() );
490  if (pTD)
491  {
492  uno_Interface * pInterface = 0;
493  (*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(
494  pThis->pBridge->getUnoEnv(),
495  (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
496 
497  if (pInterface)
498  {
499  ::uno_any_construct(
500  reinterpret_cast< uno_Any * >( pReturn ),
501  &pInterface, pTD, 0 );
502  (*pInterface->release)( pInterface );
503  TYPELIB_DANGER_RELEASE( pTD );
504  *ppException = 0;
505  break;
506  }
507  TYPELIB_DANGER_RELEASE( pTD );
508  }
509  } // else perform queryInterface()
510  default:
511  // dependent dispatch
512  cpp_call(
513  pThis, aVtableSlot,
514  ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
515  ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
516  ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
517  pReturn, pArgs, ppException );
518  }
519  break;
520  }
521  default:
522  {
523  ::com::sun::star::uno::RuntimeException aExc(
524  "illegal member type description!",
526 
527  Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
528  // binary identical null reference
529  ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
530  }
531  }
532 }
533 
534 }
535 
536 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Type
sal_Int32 nIndex
void SAL_CALL uno_destructData(void *pValue, typelib_TypeDescription *pTypeDescr, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
#define INSERT_FLOAT(pSV, nr, pFPR, pDS)
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.
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))
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)
uno_ExtEnvironment * getUnoEnv()
Definition: bridge.hxx:70
struct _uno_Any uno_Any
Definition: msvc/except.hxx:31
uno_Mapping * getUno2Cpp()
Definition: bridge.hxx:73
#define INSERT_INT32(pSV, nr, pGPR, pDS)
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 offset
The offset of the vtable.
Definition: vtables.hxx:68
int i
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()
#define INSERT_INT64(pSV, nr, pGPR, pDS)
struct _typelib_TypeDescription typelib_TypeDescription
Definition: msvc/except.hxx:52
uno_Mapping * getCpp2Uno()
Definition: bridge.hxx:72
void MapReturn(long r0, typelib_TypeClass eTypeClass, sal_uInt64 *pRegisterReturn)
VtableSlot getVtableSlot(typelib_InterfaceAttributeTypeDescription const *ifcMember)
Calculates the vtable slot associated with an interface attribute member.
Definition: vtables.cxx:132
void SAL_CALL typelib_typedescriptionreference_new(typelib_TypeDescriptionReference **ppTDR, typelib_TypeClass eTypeClass, rtl_uString *pTypeName) SAL_THROW_EXTERN_C()
register sal_uInt32 r28 __asm__("%r28")
#define INSERT_INT16(pSV, nr, pGPR, pDS)
OUString runtimeToOUString(char const *runtimeString)
#define sal_False
#define INSERT_DOUBLE(pSV, nr, pFPR, pDS)
#define INSERT_INT8(pSV, nr, pGPR, pDS)
com::sun::star::uno::XInterface * getCppI()
sal_uInt16 nPos
char const * name
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo