LibreOffice Module bridges (master)  1
gcc3_linux_mips/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 //#define BRDEBUG
40 #ifdef BRDEBUG
41 #include <stdio.h>
42 #endif
43 
44 
45 using namespace ::com::sun::star::uno;
46 
47 namespace
48 {
49 
50 
51  static void callVirtualMethod(
52  void * pAdjustedThisPtr,
53  sal_Int32 nVtableIndex,
54  void * pRegisterReturn,
55  typelib_TypeClass eReturnType,
56  char * pPT,
57  sal_Int32 * pStackLongs,
58  sal_Int32 /*nStackLongs*/)
59  {
60 
61  // parameter list is mixed list of * and values
62  // reference parameters are pointers
63 
64  unsigned long * mfunc; // actual function to be invoked
65  void (*ptr)();
66  int gpr[4]; // storage for gpregisters, map to a0-a3
67  int off; // offset used to find function
68  int nw; // number of words mapped
69  long *p; // pointer to parameter overflow area
70  int iret, iret2; // temporary function return values
71 
72  // never called
73  if (! pAdjustedThisPtr ) CPPU_CURRENT_NAMESPACE::dummy_can_throw_anything("xxx"); // address something
74 
75 #ifdef BRDEBUG
76  fprintf(stderr,"in CallVirtualMethod\n");
77 #endif
78 
79  // Because of the MIPS O32 calling conventions we could be passing
80  // parameters in both register types and on the stack. To create the
81  // stack parameter area we need we now simply allocate local
82  // variable storage param[] that is at least the size of the parameter stack
83  // (more than enough space) which we can overwrite the parameters into.
84 
85  /* p = sp - 512; new sp will be p - 16, but we don't change sp
86  * at this time to avoid breaking ABI--not sure whether changing sp will break
87  * references to local variables. For the same reason, we use absolute value.
88  */
89  __asm__ __volatile__ (
90  "addiu $2,$29,-512\n\t"
91  "move %0,$2\n\t"
92  :"=r"(p): : "$2","$29" );
93 
94 #ifdef BRDEBUG
95  if (nStackLongs * 4 > 512 )
96  fprintf(stderr,"too many arguments");
97 #endif
98 
99  // now begin to load the C++ function arguments into storage
100  nw = 0;
101 
102  // now we need to parse the entire signature string */
103  // until we get the END indicator */
104 
105  // treat complex return pointer like any other parameter
106 
107 #ifdef BRDEBUG
108  fprintf(stderr,"overflow area pointer p=%p\n",p);
109 
110  /* Let's figure out what is really going on here*/
111  fprintf(stderr,"callVirtualMethod parameters string is %s\n",pPT);
112  int k = nStackLongs;
113  long * q = (long *)pStackLongs;
114  while (k > 0) {
115  fprintf(stderr,"uno stack is: %x\n",(unsigned int)*q);
116  k--;
117  q++;
118  }
119 #endif
120 
121  /* parse the argument list up to the ending ) */
122  while (*pPT != 'X') {
123  int c = *pPT; // character of parameter type being decoded
124  switch (c) {
125  case 'D': /* type is double */
126  /* treat the same as long long */
127  case 'H': /* type is long long */
128  if (nw & 1) nw++; /* note even elements gpr[] will map to
129  odd registers*/
130  if (nw < 4) {
131  gpr[nw++] = *pStackLongs;
132  gpr[nw++] = *(pStackLongs+1);
133  } else {
134  if (((long) p) & 4)
135  p++;
136  *p++ = *pStackLongs;
137  *p++ = *(pStackLongs+1);
138  }
139  pStackLongs += 2;
140  break;
141 
142  case 'S':
143  if (nw < 4) {
144  gpr[nw++] = *((unsigned short*)pStackLongs);
145  } else {
146  *p++ = *((unsigned short *)pStackLongs);
147  }
148  pStackLongs += 1;
149  break;
150 
151  case 'B':
152  if (nw < 4) {
153  gpr[nw++] = *((char *)pStackLongs);
154  } else {
155  *p++ = *((char *)pStackLongs);
156  }
157  pStackLongs += 1;
158  break;
159 
160  default:
161  if (nw < 4) {
162  gpr[nw++] = *pStackLongs;
163  } else {
164  *p++ = *pStackLongs;
165  }
166  pStackLongs += 1;
167  break;
168  }
169  pPT++;
170  }
171 
172  /* figure out the address of the function we need to invoke */
173  off = nVtableIndex;
174  off = off * 4; // 4 bytes per slot
175  mfunc = *((unsigned long **)pAdjustedThisPtr); // get the address of the vtable
176  mfunc = (unsigned long *)((char *)mfunc + off); // get the address from the vtable entry at offset
177  mfunc = *((unsigned long **)mfunc); // the function is stored at the address
178  ptr = (void (*)())mfunc;
179 
180 #ifdef BRDEBUG
181  fprintf(stderr,"calling function %p\n",mfunc);
182 #endif
183 
184  /* Set up the machine registers and invoke the function */
185 
186  __asm__ __volatile__ (
187  "lw $4, 0(%0)\n\t"
188  "lw $5, 4(%0)\n\t"
189  "lw $6, 8(%0)\n\t"
190  "lw $7, 12(%0)\n\t"
191  : : "r" (gpr)
192  : "$4", "$5", "$6", "$7"
193  );
194 
195  __asm__ __volatile__ ("addiu $29,$29,-528\r\n":::"$29");
196 
197  (*ptr)();
198 
199  __asm__ __volatile__ ("addiu $29,$29,528\r\n":::"$29");
200 
201  __asm__ __volatile__ (
202  "sw $2,%0 \n\t"
203  "sw $3,%1 \n\t"
204  : "=m" (iret), "=m" (iret2) : );
205  register float fret asm("$f0");
206  register double dret asm("$f0");
207 
208  switch( eReturnType )
209  {
210  case typelib_TypeClass_HYPER:
211  case typelib_TypeClass_UNSIGNED_HYPER:
212  ((long*)pRegisterReturn)[1] = iret2; // fall through
213  case typelib_TypeClass_LONG:
214  case typelib_TypeClass_UNSIGNED_LONG:
215  case typelib_TypeClass_ENUM:
216  ((long*)pRegisterReturn)[0] = iret;
217  break;
218  case typelib_TypeClass_CHAR:
219  case typelib_TypeClass_SHORT:
220  case typelib_TypeClass_UNSIGNED_SHORT:
221  *(unsigned short*)pRegisterReturn = (unsigned short)iret;
222  break;
223  case typelib_TypeClass_BOOLEAN:
224  case typelib_TypeClass_BYTE:
225  *(unsigned char*)pRegisterReturn = (unsigned char)iret;
226  break;
227  case typelib_TypeClass_FLOAT:
228  *(float*)pRegisterReturn = fret;
229  break;
230  case typelib_TypeClass_DOUBLE:
231  *(double*)pRegisterReturn = dret;
232  break;
233  default:
234  break;
235  }
236  }
237 
238 
239  static void cpp_call(
242  typelib_TypeDescriptionReference * pReturnTypeRef,
243  sal_Int32 nParams, typelib_MethodParameter * pParams,
244  void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
245  {
246  // max space for: [complex ret ptr], values|ptr ...
247  char * pCppStack =
248  (char *)alloca( sizeof(sal_Int32) + ((nParams+2) * sizeof(sal_Int64)) );
249  char * pCppStackStart = pCppStack;
250 
251  // need to know parameter types for callVirtualMethod so generate a signature string
252  char * pParamType = (char *) alloca(nParams+2);
253  char * pPT = pParamType;
254 
255 #ifdef BRDEBUG
256  fprintf(stderr,"in cpp_call\n");
257 #endif
258 
259  // return
260  typelib_TypeDescription * pReturnTypeDescr = 0;
261  TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
262  // assert(pReturnTypeDescr);
263 
264  void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
265 
266  if (pReturnTypeDescr)
267  {
268  if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
269  {
270  pCppReturn = pUnoReturn; // direct way for simple types
271  }
272  else
273  {
274  // complex return via ptr
275  pCppReturn = *(void **)pCppStack =
277  ? alloca( pReturnTypeDescr->nSize ): pUnoReturn); // direct way
278  *pPT++ = 'I'; //signify that a complex return type on stack
279  pCppStack += sizeof(void *);
280  }
281  }
282  // push this
283  void* pAdjustedThisPtr = reinterpret_cast< void **>(pThis->getCppI()) + aVtableSlot.offset;
284  *(void**)pCppStack = pAdjustedThisPtr;
285  pCppStack += sizeof( void* );
286  *pPT++ = 'I';
287 
288  // stack space
289  // static_assert(sizeof(void *) == sizeof(sal_Int32), "### unexpected size!");
290  // args
291  void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );
292  // indices of values this have to be converted (interface conversion cpp<=>uno)
293  sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
294  // type descriptions for reconversions
295  typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
296 
297  sal_Int32 nTempIndices = 0;
298 
299  for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
300  {
301  const typelib_MethodParameter & rParam = pParams[nPos];
302  typelib_TypeDescription * pParamTypeDescr = 0;
303  TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
304 
305  if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
306  {
307  uno_copyAndConvertData( pCppArgs[nPos] = pCppStack, pUnoArgs[nPos], pParamTypeDescr,
308  pThis->getBridge()->getUno2Cpp() );
309 
310  switch (pParamTypeDescr->eTypeClass)
311  {
312 
313  // we need to know type of each param so that we know whether to use
314  // gpr or fpr to pass in parameters:
315  // Key: I - int, long, pointer, etc means pass in gpr
316  // B - byte value passed in gpr
317  // S - short value passed in gpr
318  // F - float value pass in fpr
319  // D - double value pass in fpr
320  // H - long long int pass in proper pairs of gpr (3,4) (5,6), etc
321  // X - indicates end of parameter description string
322 
323  case typelib_TypeClass_LONG:
324  case typelib_TypeClass_UNSIGNED_LONG:
325  case typelib_TypeClass_ENUM:
326  *pPT++ = 'I';
327  break;
328  case typelib_TypeClass_SHORT:
329  case typelib_TypeClass_CHAR:
330  case typelib_TypeClass_UNSIGNED_SHORT:
331  *pPT++ = 'S';
332  break;
333  case typelib_TypeClass_BOOLEAN:
334  case typelib_TypeClass_BYTE:
335  *pPT++ = 'B';
336  break;
337  case typelib_TypeClass_FLOAT:
338  *pPT++ = 'F';
339  break;
340  case typelib_TypeClass_DOUBLE:
341  *pPT++ = 'D';
342  pCppStack += sizeof(sal_Int32); // extra long
343  break;
344  case typelib_TypeClass_HYPER:
345  case typelib_TypeClass_UNSIGNED_HYPER:
346  *pPT++ = 'H';
347  pCppStack += sizeof(sal_Int32); // extra long
348  break;
349  default:
350  break;
351  }
352 
353  // no longer needed
354  TYPELIB_DANGER_RELEASE( pParamTypeDescr );
355  }
356  else // ptr to complex value | ref
357  {
358  if (! rParam.bIn) // is pure out
359  {
360  // cpp out is constructed mem, uno out is not!
362  *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
363  pParamTypeDescr );
364  pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
365  // will be released at reconversion
366  ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
367  }
368  // is in/inout
369  else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
370  {
372  *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
373  pUnoArgs[nPos], pParamTypeDescr,
374  pThis->getBridge()->getUno2Cpp() );
375 
376  pTempIndices[nTempIndices] = nPos; // has to be reconverted
377  // will be released at reconversion
378  ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
379  }
380  else // direct way
381  {
382  *(void **)pCppStack = pCppArgs[nPos] = pUnoArgs[nPos];
383  // no longer needed
384  TYPELIB_DANGER_RELEASE( pParamTypeDescr );
385  }
386  // KBH: FIXME: is this the right way to pass these
387  *pPT++='I';
388  }
389  pCppStack += sizeof(sal_Int32); // standard parameter length
390  }
391 
392  // terminate the signature string
393  *pPT++='X';
394  *pPT=0;
395 
396  try
397  {
398  assert( !( (pCppStack - pCppStackStart ) & 3) && "UNALIGNED STACK !!! (Please DO panic)" );
399  try {
401  pAdjustedThisPtr, aVtableSlot.index,
402  pCppReturn, pReturnTypeDescr->eTypeClass, pParamType,
403  (sal_Int32 *)pCppStackStart, (pCppStack - pCppStackStart) / sizeof(sal_Int32) );
404  } catch (css::uno::Exception &) {
405  throw;
406  } catch (std::exception & e) {
407  throw css::uno::RuntimeException(
408  "C++ code threw " + o3tl::runtimeToOUString(typeid(e).name()) + ": "
409  + o3tl::runtimeToOUString(e.what()));
410  } catch (...) {
411  throw css::uno::RuntimeException("C++ code threw unknown exception");
412  }
413  // NO exception occurred...
414  *ppUnoExc = 0;
415 
416  // reconvert temporary params
417  for ( ; nTempIndices--; )
418  {
419  sal_Int32 nIndex = pTempIndices[nTempIndices];
420  typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
421 
422  if (pParams[nIndex].bIn)
423  {
424  if (pParams[nIndex].bOut) // inout
425  {
426  uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
427  uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
428  pThis->getBridge()->getCpp2Uno() );
429  }
430  }
431  else // pure out
432  {
433  uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
434  pThis->getBridge()->getCpp2Uno() );
435  }
436  // destroy temp cpp param => cpp: every param was constructed
437  uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
438 
439  TYPELIB_DANGER_RELEASE( pParamTypeDescr );
440  }
441  // return value
442  if (pCppReturn && pUnoReturn != pCppReturn)
443  {
444  uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
445  pThis->getBridge()->getCpp2Uno() );
446  uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
447  }
448  }
449  catch (...)
450  {
451  // fill uno exception
453 
454  // temporary params
455  for ( ; nTempIndices--; )
456  {
457  sal_Int32 nIndex = pTempIndices[nTempIndices];
458  // destroy temp cpp param => cpp: every param was constructed
459  uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
460  TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
461  }
462  // return type
463  if (pReturnTypeDescr)
464  TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
465  }
466  }
467 
468 }
469 
470 
471 namespace bridges::cpp_uno::shared {
472 
474  uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
475  void * pReturn, void * pArgs[], uno_Any ** ppException )
476 {
477  // is my surrogate
479  = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy *> (pUnoI);
480  //typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;
481 
482 #ifdef BRDEBUG
483  fprintf(stderr,"in dispatch\n");
484 #endif
485 
486  switch (pMemberDescr->eTypeClass)
487  {
488  case typelib_TypeClass_INTERFACE_ATTRIBUTE:
489  {
490 
491  VtableSlot aVtableSlot(
493  reinterpret_cast<
494  typelib_InterfaceAttributeTypeDescription const * >(
495  pMemberDescr)));
496 
497  if (pReturn)
498  {
499  // dependent dispatch
500  cpp_call(
501  pThis, aVtableSlot,
502  ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
503  0, 0, // no params
504  pReturn, pArgs, ppException );
505  }
506  else
507  {
508  // is SET
509  typelib_MethodParameter aParam;
510  aParam.pTypeRef =
511  ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;
512  aParam.bIn = sal_True;
513  aParam.bOut = sal_False;
514 
515  typelib_TypeDescriptionReference * pReturnTypeRef = 0;
516  OUString aVoidName("void");
518  &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
519 
520  // dependent dispatch
521  aVtableSlot.index += 1; //get then set method
522  cpp_call(
523  pThis, aVtableSlot,
524  pReturnTypeRef,
525  1, &aParam,
526  pReturn, pArgs, ppException );
527 
529  }
530 
531  break;
532  }
533  case typelib_TypeClass_INTERFACE_METHOD:
534  {
535 
536  VtableSlot aVtableSlot(
538  reinterpret_cast<
539  typelib_InterfaceMethodTypeDescription const * >(
540  pMemberDescr)));
541  switch (aVtableSlot.index)
542  {
543  // standard calls
544  case 1: // acquire uno interface
545  (*pUnoI->acquire)( pUnoI );
546  *ppException = 0;
547  break;
548  case 2: // release uno interface
549  (*pUnoI->release)( pUnoI );
550  *ppException = 0;
551  break;
552  case 0: // queryInterface() opt
553  {
554  typelib_TypeDescription * pTD = 0;
555  TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() );
556  if (pTD)
557  {
558  uno_Interface * pInterface = 0;
559  (*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(
560  pThis->pBridge->getUnoEnv(),
561  (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
562 
563  if (pInterface)
564  {
565  ::uno_any_construct(
566  reinterpret_cast< uno_Any * >( pReturn ),
567  &pInterface, pTD, 0 );
568  (*pInterface->release)( pInterface );
569  TYPELIB_DANGER_RELEASE( pTD );
570  *ppException = 0;
571  break;
572  }
573  TYPELIB_DANGER_RELEASE( pTD );
574  }
575  } // else perform queryInterface()
576  default:
577  // dependent dispatch
578  cpp_call(
579  pThis, aVtableSlot,
580  ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
581  ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
582  ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
583  pReturn, pArgs, ppException );
584  }
585  break;
586  }
587  default:
588  {
589  ::com::sun::star::uno::RuntimeException aExc(
590  "illegal member type description!",
592 
593  Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
594  // binary identical null reference
595  ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
596  }
597  }
598 }
599 
600 }
601 
602 /* 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()
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
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
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
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
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")
OUString runtimeToOUString(char const *runtimeString)
#define sal_False
void * p
void dummy_can_throw_anything(char const *)
com::sun::star::uno::XInterface * getCppI()
sal_uInt16 nPos
char const * name
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo