|
Lines 1-9
Link Here
|
| 1 |
--- bridges/source/cpp_uno/gcc3_freebsd_powerpc64/uno2cpp.cxx.orig 2019-09-17 22:55:10 UTC |
1 |
--- bridges/source/cpp_uno/gcc3_freebsd_powerpc64/uno2cpp.cxx.orig |
| 2 |
+++ bridges/source/cpp_uno/gcc3_freebsd_powerpc64/uno2cpp.cxx |
2 |
+++ bridges/source/cpp_uno/gcc3_freebsd_powerpc64/uno2cpp.cxx |
| 3 |
@@ -42,6 +42,14 @@ using namespace ::com::sun::star::uno; |
3 |
@@ -26,6 +26,12 @@ |
| 4 |
|
4 |
|
|
|
5 |
#include <stdlib.h> |
| 6 |
|
| 7 |
+#include <exception> |
| 8 |
+#include <malloc.h> |
| 9 |
+#include <typeinfo> |
| 10 |
+ |
| 11 |
+#include <com/sun/star/uno/Exception.hpp> |
| 12 |
+#include <com/sun/star/uno/RuntimeException.hpp> |
| 13 |
#include <com/sun/star/uno/genfunc.hxx> |
| 14 |
#include <uno/data.h> |
| 15 |
|
| 16 |
@@ -42,10 +48,68 @@ |
| 17 |
|
| 5 |
using namespace ::rtl; |
18 |
using namespace ::rtl; |
| 6 |
using namespace ::com::sun::star::uno; |
19 |
using namespace ::com::sun::star::uno; |
|
|
20 |
- |
| 21 |
-void MapReturn(long r3, double dret, typelib_TypeClass eTypeClass, void *pRegisterReturn) |
| 7 |
+#ifdef __GLIBCXX__ |
22 |
+#ifdef __GLIBCXX__ |
| 8 |
+using CPPU_CURRENT_NAMESPACE::__cxa_exception; |
23 |
+using CPPU_CURRENT_NAMESPACE::__cxa_exception; |
| 9 |
+using CPPU_CURRENT_NAMESPACE::__cxa_get_globals; |
24 |
+using CPPU_CURRENT_NAMESPACE::__cxa_get_globals; |
|
Lines 12-21
+#endif
Link Here
|
| 12 |
+using __cxxabiv1::__cxa_current_primary_exception; |
27 |
+using __cxxabiv1::__cxa_current_primary_exception; |
| 13 |
+using __cxxabiv1::__cxa_decrement_exception_refcount; |
28 |
+using __cxxabiv1::__cxa_decrement_exception_refcount; |
| 14 |
+#endif |
29 |
+#endif |
| 15 |
|
30 |
+ |
| 16 |
void MapReturn(long r3, double dret, typelib_TypeClass eTypeClass, void *pRegisterReturn) |
31 |
+namespace ppc64 |
| 17 |
{ |
32 |
{ |
| 18 |
@@ -448,9 +456,18 @@ static void cpp_call( |
33 |
- switch (eTypeClass) |
|
|
34 |
+#if defined(_CALL_ELF) && _CALL_ELF == 2 |
| 35 |
+ bool is_complex_struct(const typelib_TypeDescription * type) |
| 36 |
+ { |
| 37 |
+ const typelib_CompoundTypeDescription * p |
| 38 |
+ = reinterpret_cast< const typelib_CompoundTypeDescription * >(type); |
| 39 |
+ for (sal_Int32 i = 0; i < p->nMembers; ++i) |
| 40 |
+ { |
| 41 |
+ if (p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_STRUCT || |
| 42 |
+ p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_EXCEPTION) |
| 43 |
+ { |
| 44 |
+ typelib_TypeDescription * t = 0; |
| 45 |
+ TYPELIB_DANGER_GET(&t, p->ppTypeRefs[i]); |
| 46 |
+ bool b = is_complex_struct(t); |
| 47 |
+ TYPELIB_DANGER_RELEASE(t); |
| 48 |
+ if (b) { |
| 49 |
+ return true; |
| 50 |
+ } |
| 51 |
+ } |
| 52 |
+ else if (!bridges::cpp_uno::shared::isSimpleType(p->ppTypeRefs[i]->eTypeClass)) |
| 53 |
+ return true; |
| 54 |
+ } |
| 55 |
+ if (p->pBaseTypeDescription != 0) |
| 56 |
+ return is_complex_struct(&p->pBaseTypeDescription->aBase); |
| 57 |
+ return false; |
| 58 |
+ } |
| 59 |
+#endif |
| 60 |
+ |
| 61 |
+ bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef ) |
| 62 |
+ { |
| 63 |
+ if (bridges::cpp_uno::shared::isSimpleType(pTypeRef)) |
| 64 |
+ return false; |
| 65 |
+#if defined(_CALL_ELF) && _CALL_ELF == 2 |
| 66 |
+ else if (pTypeRef->eTypeClass == typelib_TypeClass_STRUCT || pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION) |
| 67 |
+ { |
| 68 |
+ typelib_TypeDescription * pTypeDescr = 0; |
| 69 |
+ TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef ); |
| 70 |
+ |
| 71 |
+ //A Composite Type not larger than 16 bytes is returned in up to two GPRs |
| 72 |
+ bool bRet = pTypeDescr->nSize > 16 || is_complex_struct(pTypeDescr); |
| 73 |
+ |
| 74 |
+ TYPELIB_DANGER_RELEASE( pTypeDescr ); |
| 75 |
+ return bRet; |
| 76 |
+ } |
| 77 |
+#endif |
| 78 |
+ return true; |
| 79 |
+ } |
| 80 |
+} |
| 81 |
+ |
| 82 |
+extern "C" void MapReturn(long r3, long r4, double dret, typelib_TypeDescriptionReference* pReturnType, void *pRegisterReturn) |
| 83 |
+{ |
| 84 |
+ switch (pReturnType->eTypeClass) |
| 85 |
{ |
| 86 |
case typelib_TypeClass_HYPER: |
| 87 |
case typelib_TypeClass_UNSIGNED_HYPER: |
| 88 |
@@ -67,10 +131,23 @@ |
| 89 |
break; |
| 90 |
case typelib_TypeClass_FLOAT: |
| 91 |
*reinterpret_cast<float *>( pRegisterReturn ) = dret; |
| 92 |
- break; |
| 93 |
+ break; |
| 94 |
case typelib_TypeClass_DOUBLE: |
| 95 |
*reinterpret_cast<double *>( pRegisterReturn ) = dret; |
| 96 |
break; |
| 97 |
+#if defined(_CALL_ELF) && _CALL_ELF == 2 |
| 98 |
+ case typelib_TypeClass_STRUCT: |
| 99 |
+ case typelib_TypeClass_EXCEPTION: |
| 100 |
+ if (!ppc64::return_in_hidden_param(pReturnType)) |
| 101 |
+ { |
| 102 |
+ sal_uInt64 *pRegisters = reinterpret_cast<sal_uInt64*>(pRegisterReturn); |
| 103 |
+ pRegisters[0] = r3; |
| 104 |
+ if (pReturnType->pType->nSize > 8) |
| 105 |
+ pRegisters[1] = r4; |
| 106 |
+ } |
| 107 |
+#else |
| 108 |
+ (void)r4; |
| 109 |
+#endif |
| 110 |
default: |
| 111 |
break; |
| 112 |
} |
| 113 |
@@ -79,11 +156,13 @@ |
| 114 |
namespace |
| 115 |
{ |
| 116 |
//================================================================================================== |
| 117 |
-static void callVirtualMethod(void * pThis, sal_uInt32 nVtableIndex, |
| 118 |
- void * pRegisterReturn, typelib_TypeDescription * pReturnTypeDescr, |
| 119 |
+extern "C" void callVirtualMethod(void * pThis, sal_uInt32 nVtableIndex, |
| 120 |
+ void * pRegisterReturn, typelib_TypeDescription * pReturnTypeDescr, |
| 121 |
sal_uInt64 *pStack, sal_uInt32 nStack, |
| 122 |
sal_uInt64 *pGPR, sal_uInt32 nGPR, |
| 123 |
- double *pFPR, sal_uInt32 nFPR) |
| 124 |
+ double *pFPR, sal_uInt32 nFPR); |
| 125 |
+ |
| 126 |
+#if 0 |
| 127 |
{ |
| 128 |
// Stack, if used, must be 16-bytes aligned |
| 129 |
if ( nStack ) |
| 130 |
@@ -99,13 +178,13 @@ |
| 131 |
// Let's figure out what is really going on here |
| 132 |
{ |
| 133 |
fprintf( stderr, "= callVirtualMethod() =\nGPR's (%d): ", nGPR ); |
| 134 |
- for ( int i = 0; i < nGPR; ++i ) |
| 135 |
+ for ( sal_uInt32 i = 0; i < nGPR; ++i ) |
| 136 |
fprintf( stderr, "0x%lx, ", pGPR[i] ); |
| 137 |
fprintf( stderr, "\nFPR's (%d): ", nFPR ); |
| 138 |
- for ( int i = 0; i < nFPR; ++i ) |
| 139 |
- fprintf( stderr, "0x%lx (%f), ", pFPR[i], pFPR[i] ); |
| 140 |
+ for ( sal_uInt32 i = 0; i < nFPR; ++i ) |
| 141 |
+ fprintf( stderr, "0x%lx (%lf), ", (sal_Int64)pFPR[i], pFPR[i] ); |
| 142 |
fprintf( stderr, "\nStack (%d): ", nStack ); |
| 143 |
- for ( int i = 0; i < nStack; ++i ) |
| 144 |
+ for ( sal_uInt32 i = 0; i < nStack; ++i ) |
| 145 |
fprintf( stderr, "0x%lx, ", pStack[i] ); |
| 146 |
fprintf( stderr, "\n" ); |
| 147 |
} |
| 148 |
@@ -120,52 +199,40 @@ |
| 149 |
pMethod += 8 * nVtableIndex; |
| 150 |
pMethod = *((sal_uInt64 *)pMethod); |
| 151 |
|
| 152 |
+#if defined(_CALL_ELF) && _CALL_ELF == 2 |
| 153 |
+ typedef void (* FunctionCall )(...); |
| 154 |
+#else |
| 155 |
typedef void (* FunctionCall )( sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64 ); |
| 156 |
+#endif |
| 157 |
FunctionCall pFunc = (FunctionCall)pMethod; |
| 158 |
|
| 159 |
volatile double dret; |
| 160 |
|
| 161 |
// fill registers |
| 162 |
__asm__ __volatile__ ( |
| 163 |
- "ld 3, 0(%0)\n\t" |
| 164 |
- "ld 4, 8(%0)\n\t" |
| 165 |
- "ld 5, 16(%0)\n\t" |
| 166 |
- "ld 6, 24(%0)\n\t" |
| 167 |
- "ld 7, 32(%0)\n\t" |
| 168 |
- "ld 8, 40(%0)\n\t" |
| 169 |
- "ld 9, 48(%0)\n\t" |
| 170 |
- "ld 10, 56(%0)\n\t" |
| 171 |
- "lfd 1, 0(%1)\n\t" |
| 172 |
- "lfd 2, 8(%1)\n\t" |
| 173 |
- "lfd 3, 16(%1)\n\t" |
| 174 |
- "lfd 4, 24(%1)\n\t" |
| 175 |
- "lfd 5, 32(%1)\n\t" |
| 176 |
- "lfd 6, 40(%1)\n\t" |
| 177 |
- "lfd 7, 48(%1)\n\t" |
| 178 |
- "lfd 8, 56(%1)\n\t" |
| 179 |
- "lfd 9, 64(%1)\n\t" |
| 180 |
- "lfd 10, 72(%1)\n\t" |
| 181 |
- "lfd 11, 80(%1)\n\t" |
| 182 |
- "lfd 12, 88(%1)\n\t" |
| 183 |
- "lfd 13, 96(%1)\n\t" |
| 184 |
- : : "r" (pGPR), "r" (pFPR) |
| 185 |
- : "r0", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", |
| 186 |
- "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7", "fr8", "fr9", |
| 187 |
- "fr10", "fr11", "fr12", "fr13" |
| 188 |
+ "lfd 1, 0(%0)\n\t" |
| 189 |
+ "lfd 2, 8(%0)\n\t" |
| 190 |
+ "lfd 3, 16(%0)\n\t" |
| 191 |
+ "lfd 4, 24(%0)\n\t" |
| 192 |
+ "lfd 5, 32(%0)\n\t" |
| 193 |
+ "lfd 6, 40(%0)\n\t" |
| 194 |
+ "lfd 7, 48(%0)\n\t" |
| 195 |
+ "lfd 8, 56(%0)\n\t" |
| 196 |
+ "lfd 9, 64(%0)\n\t" |
| 197 |
+ "lfd 10, 72(%0)\n\t" |
| 198 |
+ "lfd 11, 80(%0)\n\t" |
| 199 |
+ "lfd 12, 88(%0)\n\t" |
| 200 |
+ "lfd 13, 96(%0)\n\t" |
| 201 |
+ : : "r" (pFPR) |
| 202 |
+ : "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7", "fr8", "fr9", |
| 203 |
+ "fr10", "fr11", "fr12", "fr13" |
| 204 |
); |
| 205 |
|
| 206 |
// tell gcc that r3 to r11 are not available to it for doing the TOC and exception munge on the func call |
| 207 |
register sal_uInt64 r3 asm("r3"); |
| 208 |
register sal_uInt64 r4 asm("r4"); |
| 209 |
- register sal_uInt64 r5 asm("r5"); |
| 210 |
- register sal_uInt64 r6 asm("r6"); |
| 211 |
- register sal_uInt64 r7 asm("r7"); |
| 212 |
- register sal_uInt64 r8 asm("r8"); |
| 213 |
- register sal_uInt64 r9 asm("r9"); |
| 214 |
- register sal_uInt64 r10 asm("r10"); |
| 215 |
- register sal_uInt64 r11 asm("r11"); |
| 216 |
- |
| 217 |
- (*pFunc)(r3, r4, r5, r6, r7, r8, r9, r10); |
| 218 |
+ |
| 219 |
+ (*pFunc)(pGPR[0], pGPR[1], pGPR[2], pGPR[3], pGPR[4], pGPR[5], pGPR[6], pGPR[7]); |
| 220 |
|
| 221 |
// get return value |
| 222 |
__asm__ __volatile__ ( |
| 223 |
@@ -174,8 +241,9 @@ |
| 224 |
"fmr %0, 1\n\t" |
| 225 |
: "=f" (dret), "=r" (r3), "=r" (r4) : ); |
| 226 |
|
| 227 |
- MapReturn(r3, dret, pReturnTypeDescr->eTypeClass, pRegisterReturn); |
| 228 |
+ MapReturn(r3, r4, dret, reinterpret_cast<typelib_TypeDescriptionReference *>(pReturnTypeDescr), pRegisterReturn); |
| 229 |
} |
| 230 |
+#endif |
| 231 |
|
| 232 |
// Macros for easier insertion of values to registers or stack |
| 233 |
// pSV - pointer to the source |
| 234 |
@@ -185,23 +253,35 @@ |
| 235 |
|
| 236 |
// The value in %xmm register is already prepared to be retrieved as a float, |
| 237 |
// thus we treat float and double the same |
| 238 |
-#define INSERT_FLOAT( pSV, nr, pFPR, pDS, bOverflow ) \ |
| 239 |
- if ( nr < ppc64::MAX_SSE_REGS ) \ |
| 240 |
+#define INSERT_FLOAT( pSV, nr, pFPR, nGPR, pDS, bOverFlow ) \ |
| 241 |
+ if ( nGPR < ppc64::MAX_GPR_REGS ) \ |
| 242 |
+ ++nGPR; \ |
| 243 |
+ if ( nr < ppc64::MAX_SSE_REGS ) \ |
| 244 |
pFPR[nr++] = *reinterpret_cast<float *>( pSV ); \ |
| 245 |
else \ |
| 246 |
- bOverFlow = true; \ |
| 247 |
+ bOverFlow = true; \ |
| 248 |
if (bOverFlow) \ |
| 249 |
*pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV ); // verbatim! |
| 250 |
|
| 251 |
-#define INSERT_DOUBLE( pSV, nr, pFPR, pDS, bOverflow ) \ |
| 252 |
- if ( nr < ppc64::MAX_SSE_REGS ) \ |
| 253 |
+#define INSERT_DOUBLE( pSV, nr, pFPR, nGPR, pDS, bOverFlow ) \ |
| 254 |
+ if ( nGPR < ppc64::MAX_GPR_REGS ) \ |
| 255 |
+ ++nGPR; \ |
| 256 |
+ if ( nr < ppc64::MAX_SSE_REGS ) \ |
| 257 |
pFPR[nr++] = *reinterpret_cast<double *>( pSV ); \ |
| 258 |
else \ |
| 259 |
- bOverFlow = true; \ |
| 260 |
+ bOverFlow = true; \ |
| 261 |
if (bOverFlow) \ |
| 262 |
*pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV ); // verbatim! |
| 263 |
|
| 264 |
-#define INSERT_INT64( pSV, nr, pGPR, pDS, bOverflow ) \ |
| 265 |
+#define INSERT_INT64( pSV, nr, pGPR, pDS, bOverFlow ) \ |
| 266 |
+ if ( nr < ppc64::MAX_GPR_REGS ) \ |
| 267 |
+ pGPR[nr++] = *reinterpret_cast<sal_Int64 *>( pSV ); \ |
| 268 |
+ else \ |
| 269 |
+ bOverFlow = true; \ |
| 270 |
+ if (bOverFlow) \ |
| 271 |
+ *pDS++ = *reinterpret_cast<sal_Int64 *>( pSV ); |
| 272 |
+ |
| 273 |
+#define INSERT_UINT64( pSV, nr, pGPR, pDS, bOverFlow ) \ |
| 274 |
if ( nr < ppc64::MAX_GPR_REGS ) \ |
| 275 |
pGPR[nr++] = *reinterpret_cast<sal_uInt64 *>( pSV ); \ |
| 276 |
else \ |
| 277 |
@@ -209,7 +289,15 @@ |
| 278 |
if (bOverFlow) \ |
| 279 |
*pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV ); |
| 280 |
|
| 281 |
-#define INSERT_INT32( pSV, nr, pGPR, pDS, bOverflow ) \ |
| 282 |
+#define INSERT_INT32( pSV, nr, pGPR, pDS, bOverFlow ) \ |
| 283 |
+ if ( nr < ppc64::MAX_GPR_REGS ) \ |
| 284 |
+ pGPR[nr++] = *reinterpret_cast<sal_Int32 *>( pSV ); \ |
| 285 |
+ else \ |
| 286 |
+ bOverFlow = true; \ |
| 287 |
+ if (bOverFlow) \ |
| 288 |
+ *pDS++ = *reinterpret_cast<sal_Int32 *>( pSV ); |
| 289 |
+ |
| 290 |
+#define INSERT_UINT32( pSV, nr, pGPR, pDS, bOverFlow ) \ |
| 291 |
if ( nr < ppc64::MAX_GPR_REGS ) \ |
| 292 |
pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \ |
| 293 |
else \ |
| 294 |
@@ -217,7 +305,15 @@ |
| 295 |
if (bOverFlow) \ |
| 296 |
*pDS++ = *reinterpret_cast<sal_uInt32 *>( pSV ); |
| 297 |
|
| 298 |
-#define INSERT_INT16( pSV, nr, pGPR, pDS, bOverflow ) \ |
| 299 |
+#define INSERT_INT16( pSV, nr, pGPR, pDS, bOverFlow ) \ |
| 300 |
+ if ( nr < ppc64::MAX_GPR_REGS ) \ |
| 301 |
+ pGPR[nr++] = *reinterpret_cast<sal_Int16 *>( pSV ); \ |
| 302 |
+ else \ |
| 303 |
+ bOverFlow = true; \ |
| 304 |
+ if (bOverFlow) \ |
| 305 |
+ *pDS++ = *reinterpret_cast<sal_Int16 *>( pSV ); |
| 306 |
+ |
| 307 |
+#define INSERT_UINT16( pSV, nr, pGPR, pDS, bOverFlow ) \ |
| 308 |
if ( nr < ppc64::MAX_GPR_REGS ) \ |
| 309 |
pGPR[nr++] = *reinterpret_cast<sal_uInt16 *>( pSV ); \ |
| 310 |
else \ |
| 311 |
@@ -225,7 +321,15 @@ |
| 312 |
if (bOverFlow) \ |
| 313 |
*pDS++ = *reinterpret_cast<sal_uInt16 *>( pSV ); |
| 314 |
|
| 315 |
-#define INSERT_INT8( pSV, nr, pGPR, pDS, bOverflow ) \ |
| 316 |
+#define INSERT_INT8( pSV, nr, pGPR, pDS, bOverFlow ) \ |
| 317 |
+ if ( nr < ppc64::MAX_GPR_REGS ) \ |
| 318 |
+ pGPR[nr++] = *reinterpret_cast<sal_Int8 *>( pSV ); \ |
| 319 |
+ else \ |
| 320 |
+ bOverFlow = true; \ |
| 321 |
+ if (bOverFlow) \ |
| 322 |
+ *pDS++ = *reinterpret_cast<sal_Int8 *>( pSV ); |
| 323 |
+ |
| 324 |
+#define INSERT_UINT8( pSV, nr, pGPR, pDS, bOverFlow ) \ |
| 325 |
if ( nr < ppc64::MAX_GPR_REGS ) \ |
| 326 |
pGPR[nr++] = *reinterpret_cast<sal_uInt8 *>( pSV ); \ |
| 327 |
else \ |
| 328 |
@@ -337,19 +441,23 @@ |
| 329 |
INSERT_INT32( pCppArgs[nPos], nGPR, pGPR, pStack, bOverFlow ); |
| 330 |
break; |
| 331 |
case typelib_TypeClass_SHORT: |
| 332 |
+ INSERT_INT16( pCppArgs[nPos], nGPR, pGPR, pStack, bOverFlow ); |
| 333 |
+ break; |
| 334 |
case typelib_TypeClass_CHAR: |
| 335 |
case typelib_TypeClass_UNSIGNED_SHORT: |
| 336 |
INSERT_INT16( pCppArgs[nPos], nGPR, pGPR, pStack, bOverFlow ); |
| 337 |
break; |
| 338 |
case typelib_TypeClass_BOOLEAN: |
| 339 |
+ INSERT_UINT8( pCppArgs[nPos], nGPR, pGPR, pStack, bOverFlow ); |
| 340 |
+ break; |
| 341 |
case typelib_TypeClass_BYTE: |
| 342 |
INSERT_INT8( pCppArgs[nPos], nGPR, pGPR, pStack, bOverFlow ); |
| 343 |
break; |
| 344 |
case typelib_TypeClass_FLOAT: |
| 345 |
- INSERT_FLOAT( pCppArgs[nPos], nFPR, pFPR, pStack, bOverFlow ); |
| 346 |
- break; |
| 347 |
+ INSERT_FLOAT( pCppArgs[nPos], nFPR, pFPR, nGPR, pStack, bOverFlow ); |
| 348 |
+ break; |
| 349 |
case typelib_TypeClass_DOUBLE: |
| 350 |
- INSERT_DOUBLE( pCppArgs[nPos], nFPR, pFPR, pStack, bOverFlow ); |
| 351 |
+ INSERT_DOUBLE( pCppArgs[nPos], nFPR, pFPR, nGPR, pStack, bOverFlow ); |
| 352 |
break; |
| 353 |
} |
| 354 |
|
| 355 |
@@ -448,9 +556,18 @@ |
| 19 |
} |
356 |
} |
| 20 |
catch (...) |
357 |
catch (...) |
| 21 |
{ |
358 |
{ |
|
Lines 36-38
+ CPPU_CURRENT_NAMESPACE::fillUnoException( header, *
Link Here
|
| 36 |
|
373 |
|
| 37 |
// temporary params |
374 |
// temporary params |
| 38 |
for ( ; nTempIndizes--; ) |
375 |
for ( ; nTempIndizes--; ) |
|
|
376 |
@@ -475,8 +592,8 @@ |
| 377 |
void * pReturn, void * pArgs[], uno_Any ** ppException ) |
| 378 |
{ |
| 379 |
// is my surrogate |
| 380 |
- bridges::cpp_uno::shared::UnoInterfaceProxy * pThis |
| 381 |
- = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy *> (pUnoI); |
| 382 |
+ ::bridges::cpp_uno::shared::UnoInterfaceProxy * pThis |
| 383 |
+ = static_cast< ::bridges::cpp_uno::shared::UnoInterfaceProxy *> (pUnoI); |
| 384 |
typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr; |
| 385 |
|
| 386 |
switch (pMemberDescr->eTypeClass) |
| 387 |
@@ -484,8 +601,8 @@ |
| 388 |
case typelib_TypeClass_INTERFACE_ATTRIBUTE: |
| 389 |
{ |
| 390 |
|
| 391 |
- VtableSlot aVtableSlot( |
| 392 |
- getVtableSlot( |
| 393 |
+ ::bridges::cpp_uno::shared::VtableSlot aVtableSlot( |
| 394 |
+ ::bridges::cpp_uno::shared::getVtableSlot( |
| 395 |
reinterpret_cast< |
| 396 |
typelib_InterfaceAttributeTypeDescription const * >( |
| 397 |
pMemberDescr))); |
| 398 |
@@ -529,8 +646,8 @@ |
| 399 |
case typelib_TypeClass_INTERFACE_METHOD: |
| 400 |
{ |
| 401 |
|
| 402 |
- VtableSlot aVtableSlot( |
| 403 |
- getVtableSlot( |
| 404 |
+ ::bridges::cpp_uno::shared::VtableSlot aVtableSlot( |
| 405 |
+ ::bridges::cpp_uno::shared::getVtableSlot( |
| 406 |
reinterpret_cast< |
| 407 |
typelib_InterfaceMethodTypeDescription const * >( |
| 408 |
pMemberDescr))); |
| 409 |
|