diff options
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_linux_arm/call.hxx | 28 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx | 95 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_linux_arm/uno2cpp.cxx | 82 |
3 files changed, 117 insertions, 88 deletions
diff --git a/bridges/source/cpp_uno/gcc3_linux_arm/call.hxx b/bridges/source/cpp_uno/gcc3_linux_arm/call.hxx new file mode 100644 index 000000000000..dde56f6f59f0 --- /dev/null +++ b/bridges/source/cpp_uno/gcc3_linux_arm/call.hxx @@ -0,0 +1,28 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include <sal/config.h> + +#include <sal/types.h> + +extern "C" sal_Int64 cpp_vtable_call(long* pFunctionAndOffset, void** pCallStack); + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx index 7abaed395488..aaba8ffb7b6d 100644 --- a/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx +++ b/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx @@ -33,6 +33,7 @@ #include <vtablefactory.hxx> #include "share.hxx" +#include "call.hxx" #include <dlfcn.h> @@ -46,7 +47,7 @@ using namespace ::com::sun::star::uno; namespace { - static typelib_TypeClass cpp2uno_call( + typelib_TypeClass cpp2uno_call( bridges::cpp_uno::shared::CppInterfaceProxy* pThis, const typelib_TypeDescription * pMemberTypeDescr, typelib_TypeDescriptionReference * pReturnTypeRef, @@ -55,21 +56,21 @@ namespace sal_Int64 * pRegisterReturn /* space for register return */ ) { // pCallStack: ret, [return ptr], this, params - char * pTopStack = (char *)(pCallStack + 0); + char * pTopStack = reinterpret_cast<char *>(pCallStack + 0); char * pCppStack = pTopStack; #ifdef __ARM_PCS_VFP int dc = 0; - char * pFloatArgs = (char *)(pCppStack - 64); + char * pFloatArgs = reinterpret_cast<char *>(pCppStack - 64); #endif // return - typelib_TypeDescription * pReturnTypeDescr = 0; + typelib_TypeDescription * pReturnTypeDescr = nullptr; if (pReturnTypeRef) TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef ); - void * pUnoReturn = 0; + void * pUnoReturn = nullptr; // complex return ptr: if != 0 && != pUnoReturn, reconversion need - void * pCppReturn = 0; + void * pCppReturn = nullptr; if (pReturnTypeDescr) { @@ -77,7 +78,7 @@ namespace pUnoReturn = pRegisterReturn; // direct way for simple types else // complex return via ptr (pCppReturn) { - pCppReturn = *(void **)pCppStack; + pCppReturn = *reinterpret_cast<void **>(pCppStack); pCppStack += sizeof(void *); pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( @@ -93,21 +94,21 @@ namespace static_assert(sizeof(void *) == sizeof(sal_Int32), "### unexpected size!"); // parameters - void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams ); + void ** pUnoArgs = static_cast<void **>(alloca( 4 * sizeof(void *) * nParams )); void ** pCppArgs = pUnoArgs + nParams; // indices of values this have to be converted (interface conversion // cpp<=>uno) - sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams)); + sal_Int32 * pTempIndices = reinterpret_cast<sal_Int32 *>(pUnoArgs + (2 * nParams)); // type descriptions for reconversions typelib_TypeDescription ** ppTempParamTypeDescr = - (typelib_TypeDescription **)(pUnoArgs + (3 * nParams)); + reinterpret_cast<typelib_TypeDescription **>(pUnoArgs + (3 * nParams)); sal_Int32 nTempIndices = 0; for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos ) { const typelib_MethodParameter & rParam = pParams[nPos]; - typelib_TypeDescription * pParamTypeDescr = 0; + typelib_TypeDescription * pParamTypeDescr = nullptr; TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef ); if (!rParam.bOut && @@ -166,7 +167,7 @@ namespace } else // ptr to complex value | ref { - pCppArgs[nPos] = *(void **)pCppStack; + pCppArgs[nPos] = *reinterpret_cast<void **>(pCppStack); if (! rParam.bIn) // is pure out { @@ -182,7 +183,7 @@ namespace { uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ), - *(void **)pCppStack, pParamTypeDescr, + *reinterpret_cast<void **>(pCppStack), pParamTypeDescr, pThis->getBridge()->getCpp2Uno() ); pTempIndices[nTempIndices] = nPos; // has to be reconverted // will be released at reconversion @@ -190,7 +191,7 @@ namespace } else // direct way { - pUnoArgs[nPos] = *(void **)pCppStack; + pUnoArgs[nPos] = *reinterpret_cast<void **>(pCppStack); // no longer needed TYPELIB_DANGER_RELEASE( pParamTypeDescr ); } @@ -223,7 +224,7 @@ namespace if (pParams[nIndex].bIn) // is in/inout => was constructed uno_destructData( pUnoArgs[nIndex], - ppTempParamTypeDescr[nTempIndices], 0 ); + ppTempParamTypeDescr[nTempIndices], nullptr ); TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] ); } if (pReturnTypeDescr) @@ -252,7 +253,7 @@ namespace pParamTypeDescr, pThis->getBridge()->getUno2Cpp() ); } // destroy temp uno param - uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); + uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, nullptr ); TYPELIB_DANGER_RELEASE( pParamTypeDescr ); } @@ -264,15 +265,15 @@ namespace uno_copyAndConvertData( pCppReturn, pUnoReturn, pReturnTypeDescr, pThis->getBridge()->getUno2Cpp() ); // destroy temp uno return - uno_destructData( pUnoReturn, pReturnTypeDescr, 0 ); + uno_destructData( pUnoReturn, pReturnTypeDescr, nullptr ); } // complex return ptr is set to eax - *(void **)pRegisterReturn = pCppReturn; + *reinterpret_cast<void **>(pRegisterReturn) = pCppReturn; } if (pReturnTypeDescr) { typelib_TypeClass eRet = - (typelib_TypeClass)pReturnTypeDescr->eTypeClass; + static_cast<typelib_TypeClass>(pReturnTypeDescr->eTypeClass); TYPELIB_DANGER_RELEASE( pReturnTypeDescr ); return eRet; } @@ -282,7 +283,7 @@ namespace } - static typelib_TypeClass cpp_mediate( + typelib_TypeClass cpp_mediate( sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset, void ** pCallStack, sal_Int64 * pRegisterReturn /* space for register return */ ) @@ -320,7 +321,7 @@ namespace ("illegal " + OUString::unacquired(&pTypeDescr->aBase.pTypeName) + " vtable index " + OUString::number(nFunctionIndex) + "/" + OUString::number(pTypeDescr->nMapFunctionIndexToMemberIndex)), - (XInterface *)pCppI); + reinterpret_cast<XInterface *>(pCppI)); } // determine called method @@ -342,8 +343,8 @@ namespace // is GET method eRet = cpp2uno_call( pCppI, aMemberDescr.get(), - ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef, - 0, 0, // no params + reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>(aMemberDescr.get())->pAttributeTypeRef, + 0, nullptr, // no params pCallStack, pRegisterReturn ); } else @@ -351,13 +352,13 @@ namespace // is SET method typelib_MethodParameter aParam; aParam.pTypeRef = - ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef; - aParam.bIn = sal_True; - aParam.bOut = sal_False; + reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>(aMemberDescr.get())->pAttributeTypeRef; + aParam.bIn = true; + aParam.bOut = false; eRet = cpp2uno_call( pCppI, aMemberDescr.get(), - 0, // indicates void return + nullptr, // indicates void return 1, &aParam, pCallStack, pRegisterReturn ); } @@ -378,16 +379,16 @@ namespace break; case 0: // queryInterface() opt { - typelib_TypeDescription * pTD = 0; + typelib_TypeDescription * pTD = nullptr; TYPELIB_DANGER_GET(&pTD, reinterpret_cast<Type *>(pCallStack[2])->getTypeLibType()); if (pTD) { - XInterface * pInterface = 0; + XInterface * pInterface = nullptr; (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)( pCppI->getBridge()->getCppEnv(), - (void **)&pInterface, pCppI->getOid().pData, - (typelib_InterfaceTypeDescription *)pTD ); + reinterpret_cast<void **>(&pInterface), pCppI->getOid().pData, + reinterpret_cast<typelib_InterfaceTypeDescription *>(pTD) ); if (pInterface) { @@ -396,7 +397,7 @@ namespace &pInterface, pTD, cpp_acquire ); pInterface->release(); TYPELIB_DANGER_RELEASE( pTD ); - *(void **)pRegisterReturn = pCallStack[0]; + *reinterpret_cast<void **>(pRegisterReturn) = pCallStack[0]; eRet = typelib_TypeClass_ANY; break; } @@ -406,16 +407,16 @@ namespace default: eRet = cpp2uno_call( pCppI, aMemberDescr.get(), - ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pReturnTypeRef, - ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->nParams, - ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pParams, + reinterpret_cast<typelib_InterfaceMethodTypeDescription *>(aMemberDescr.get())->pReturnTypeRef, + reinterpret_cast<typelib_InterfaceMethodTypeDescription *>(aMemberDescr.get())->nParams, + reinterpret_cast<typelib_InterfaceMethodTypeDescription *>(aMemberDescr.get())->pParams, pCallStack, pRegisterReturn ); } break; } default: { - throw RuntimeException( "no member description found!", (XInterface *)pCppI ); + throw RuntimeException( "no member description found!", reinterpret_cast<XInterface *>(pCppI) ); } } @@ -428,7 +429,7 @@ namespace * (called by asm snippets) */ -extern "C" sal_Int64 cpp_vtable_call( long *pFunctionAndOffset, +sal_Int64 cpp_vtable_call( long *pFunctionAndOffset, void **pCallStack ) { sal_Int64 nRegReturn; @@ -439,17 +440,17 @@ extern "C" sal_Int64 cpp_vtable_call( long *pFunctionAndOffset, { case typelib_TypeClass_BOOLEAN: case typelib_TypeClass_BYTE: - nRegReturn = (unsigned long)(*(unsigned char *)&nRegReturn); + nRegReturn = static_cast<unsigned long>(*reinterpret_cast<unsigned char *>(&nRegReturn)); break; case typelib_TypeClass_CHAR: case typelib_TypeClass_UNSIGNED_SHORT: case typelib_TypeClass_SHORT: - nRegReturn = (unsigned long)(*(unsigned short *)&nRegReturn); + nRegReturn = static_cast<unsigned long>(*reinterpret_cast<unsigned short *>(&nRegReturn)); break; case typelib_TypeClass_ENUM: case typelib_TypeClass_UNSIGNED_LONG: case typelib_TypeClass_LONG: - nRegReturn = (unsigned long)(*(unsigned int *)&nRegReturn); + nRegReturn = static_cast<unsigned long>(*reinterpret_cast<unsigned int *>(&nRegReturn)); break; case typelib_TypeClass_VOID: default: @@ -469,16 +470,16 @@ namespace if (bHasHiddenParam) functionIndex |= 0x80000000; - unsigned long * p = (unsigned long *)code; + unsigned long * p = reinterpret_cast<unsigned long *>(code); // ARM (not thumb) mode instructions // mov ip, pc *p++ = 0xE1A0C00F; // ldr pc, [pc, #4] *p++ = 0xE59FF004; - *p++ = (unsigned long)functionIndex; - *p++ = (unsigned long)vtableOffset; - *p++ = (unsigned long)privateSnippetExecutor; + *p++ = static_cast<unsigned long>(functionIndex); + *p++ = static_cast<unsigned long>(vtableOffset); + *p++ = reinterpret_cast<unsigned long>(privateSnippetExecutor); return code + codeSnippetSize; } @@ -504,8 +505,8 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock( typelib_InterfaceTypeDescription *) { Slot * slots = mapBlockToVtable(block); - slots[-2].fn = 0; - slots[-1].fn = 0; + slots[-2].fn = nullptr; + slots[-1].fn = nullptr; return slots + slotCount; } @@ -524,7 +525,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions( Slot * s = *slots; for (sal_Int32 i = 0; i < type->nMembers; ++i) { - typelib_TypeDescription * member = 0; + typelib_TypeDescription * member = nullptr; TYPELIB_DANGER_GET(&member, type->ppMembers[i]); assert(member != 0); switch (member->eTypeClass) diff --git a/bridges/source/cpp_uno/gcc3_linux_arm/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_arm/uno2cpp.cxx index bed9d7a0af96..8533415ed087 100644 --- a/bridges/source/cpp_uno/gcc3_linux_arm/uno2cpp.cxx +++ b/bridges/source/cpp_uno/gcc3_linux_arm/uno2cpp.cxx @@ -109,7 +109,7 @@ namespace arm if (p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_STRUCT || p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_EXCEPTION) { - typelib_TypeDescription * t = 0; + typelib_TypeDescription * t = nullptr; TYPELIB_DANGER_GET(&t, p->ppTypeRefs[i]); bool b = is_complex_struct(t); TYPELIB_DANGER_RELEASE(t); @@ -120,7 +120,7 @@ namespace arm else if (!bridges::cpp_uno::shared::isSimpleType(p->ppTypeRefs[i]->eTypeClass)) return true; } - if (p->pBaseTypeDescription != 0) + if (p->pBaseTypeDescription != nullptr) return is_complex_struct(&p->pBaseTypeDescription->aBase); return false; } @@ -145,7 +145,7 @@ namespace arm return false; else if (pTypeRef->eTypeClass == typelib_TypeClass_STRUCT || pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION) { - typelib_TypeDescription * pTypeDescr = 0; + typelib_TypeDescription * pTypeDescr = nullptr; TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef ); //A Composite Type not larger than 4 bytes is returned in r0 @@ -298,9 +298,9 @@ void callVirtualMethod( #define INSERT_INT32( pSV, nr, pGPR, pDS ) \ if ( nr < arm::MAX_GPR_REGS ) \ - pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \ + pGPR[nr++] = reinterpret_cast<sal_uInt32>( pSV ); \ else \ - *pDS++ = *reinterpret_cast<sal_uInt32 *>( pSV ); + *pDS++ = reinterpret_cast<sal_uInt32>( pSV ); #ifdef __ARM_EABI__ #define INSERT_INT64( pSV, nr, pGPR, pDS, pStart ) \ @@ -310,8 +310,8 @@ void callVirtualMethod( } \ if ( nr < arm::MAX_GPR_REGS ) \ { \ - pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \ - pGPR[nr++] = *(reinterpret_cast<sal_uInt32 *>( pSV ) + 1); \ + *reinterpret_cast<sal_uInt32 *>(pGPR[nr++]) = *static_cast<sal_uInt32 *>( pSV ); \ + *reinterpret_cast<sal_uInt32 *>(pGPR[nr++]) = *(static_cast<sal_uInt32 *>( pSV ) + 1); \ } \ else \ { \ @@ -319,8 +319,8 @@ void callVirtualMethod( { \ ++pDS; \ } \ - *pDS++ = reinterpret_cast<sal_uInt32 *>( pSV )[0]; \ - *pDS++ = reinterpret_cast<sal_uInt32 *>( pSV )[1]; \ + *reinterpret_cast<sal_uInt32 *>(*pDS++) = static_cast<sal_uInt32 *>( pSV )[0]; \ + *reinterpret_cast<sal_uInt32 *>(*pDS++) = static_cast<sal_uInt32 *>( pSV )[1]; \ } #else #define INSERT_INT64( pSV, nr, pGPR, pDS, pStart ) \ @@ -343,18 +343,18 @@ void callVirtualMethod( nSR = 2*nDR; \ }\ if ( nSR < arm::MAX_FPR_REGS*2 ) {\ - pSPR[nSR++] = *reinterpret_cast<float *>( pSV ); \ + pSPR[nSR++] = *static_cast<float const *>( pSV ); \ if ((nSR % 2 == 1) && (nSR > 2*nDR)) {\ nDR++; \ }\ }\ else \ {\ - *pDS++ = *reinterpret_cast<float *>( pSV );\ + *pDS++ = *static_cast<float const *>( pSV );\ } #define INSERT_DOUBLE( pSV, nr, pGPR, pDS, pStart ) \ if ( nDR < arm::MAX_FPR_REGS ) { \ - pFPR[nDR++] = *reinterpret_cast<double *>( pSV ); \ + pFPR[nDR++] = *static_cast<double const *>( pSV ); \ }\ else\ {\ @@ -362,7 +362,7 @@ void callVirtualMethod( { \ ++pDS; \ } \ - *(double *)pDS = *reinterpret_cast<double *>( pSV );\ + *reinterpret_cast<double *>(pDS) = *static_cast<double const *>( pSV );\ pDS += 2;\ } #else @@ -375,15 +375,15 @@ void callVirtualMethod( #define INSERT_INT16( pSV, nr, pGPR, pDS ) \ if ( nr < arm::MAX_GPR_REGS ) \ - pGPR[nr++] = *reinterpret_cast<sal_uInt16 *>( pSV ); \ + pGPR[nr++] = *static_cast<sal_uInt16 const *>( pSV ); \ else \ - *pDS++ = *reinterpret_cast<sal_uInt16 *>( pSV ); + *pDS++ = *static_cast<sal_uInt16 const *>( pSV ); #define INSERT_INT8( pSV, nr, pGPR, pDS ) \ if ( nr < arm::MAX_GPR_REGS ) \ - pGPR[nr++] = *reinterpret_cast<sal_uInt8 *>( pSV ); \ + pGPR[nr++] = *static_cast<sal_uInt8 const *>( pSV ); \ else \ - *pDS++ = *reinterpret_cast<sal_uInt8 *>( pSV ); + *pDS++ = *static_cast<sal_uInt8 const *>( pSV ); namespace { @@ -411,11 +411,11 @@ void cpp_call( #endif // return - typelib_TypeDescription * pReturnTypeDescr = 0; + typelib_TypeDescription * pReturnTypeDescr = nullptr; TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef ); assert(pReturnTypeDescr); - void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion + void * pCppReturn = nullptr; // if != 0 && != pUnoReturn, needs reconversion if (pReturnTypeDescr) { @@ -452,7 +452,7 @@ void cpp_call( for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos ) { const typelib_MethodParameter & rParam = pParams[nPos]; - typelib_TypeDescription * pParamTypeDescr = 0; + typelib_TypeDescription * pParamTypeDescr = nullptr; TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef ); if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr )) @@ -553,7 +553,7 @@ void cpp_call( } // NO exception occurred... - *ppUnoExc = 0; + *ppUnoExc = nullptr; // reconvert temporary params for ( ; nTempIndices--; ) @@ -565,7 +565,7 @@ void cpp_call( { if (pParams[nIndex].bOut) // inout { - uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value + uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, nullptr ); // destroy uno value uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr, pThis->getBridge()->getCpp2Uno() ); } @@ -642,8 +642,8 @@ void unoInterfaceProxyDispatch( // dependent dispatch cpp_call( pThis, aVtableSlot, - ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef, - 0, 0, // no params + reinterpret_cast<typelib_InterfaceAttributeTypeDescription const *>(pMemberDescr)->pAttributeTypeRef, + 0, nullptr, // no params pReturn, pArgs, ppException ); } else @@ -651,11 +651,11 @@ void unoInterfaceProxyDispatch( // is SET typelib_MethodParameter aParam; aParam.pTypeRef = - ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef; - aParam.bIn = sal_True; - aParam.bOut = sal_False; + reinterpret_cast<typelib_InterfaceAttributeTypeDescription const *>(pMemberDescr)->pAttributeTypeRef; + aParam.bIn = true; + aParam.bOut = false; - typelib_TypeDescriptionReference * pReturnTypeRef = 0; + typelib_TypeDescriptionReference * pReturnTypeRef = nullptr; OUString aVoidName("void"); typelib_typedescriptionreference_new( &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData ); @@ -691,31 +691,31 @@ void unoInterfaceProxyDispatch( // standard calls case 1: // acquire uno interface (*pUnoI->acquire)( pUnoI ); - *ppException = 0; + *ppException = nullptr; break; case 2: // release uno interface (*pUnoI->release)( pUnoI ); - *ppException = 0; + *ppException = nullptr; break; case 0: // queryInterface() opt { - typelib_TypeDescription * pTD = 0; - TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() ); + typelib_TypeDescription * pTD = nullptr; + TYPELIB_DANGER_GET( &pTD, static_cast< Type * >( pArgs[0] )->getTypeLibType() ); if (pTD) { - uno_Interface * pInterface = 0; + uno_Interface * pInterface = nullptr; (*pThis->getBridge()->getUnoEnv()->getRegisteredInterface)( pThis->getBridge()->getUnoEnv(), - (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD ); + reinterpret_cast<void **>(&pInterface), pThis->oid.pData, reinterpret_cast<typelib_InterfaceTypeDescription *>(pTD) ); if (pInterface) { ::uno_any_construct( - reinterpret_cast< uno_Any * >( pReturn ), - &pInterface, pTD, 0 ); + static_cast< uno_Any * >( pReturn ), + &pInterface, pTD, nullptr ); (*pInterface->release)( pInterface ); TYPELIB_DANGER_RELEASE( pTD ); - *ppException = 0; + *ppException = nullptr; break; } TYPELIB_DANGER_RELEASE( pTD ); @@ -725,9 +725,9 @@ void unoInterfaceProxyDispatch( // dependent dispatch cpp_call( pThis, aVtableSlot, - ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef, - ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams, - ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams, + reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>(pMemberDescr)->pReturnTypeRef, + reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>(pMemberDescr)->nParams, + reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>(pMemberDescr)->pParams, pReturn, pArgs, ppException ); } break; @@ -740,7 +740,7 @@ void unoInterfaceProxyDispatch( Type const & rExcType = cppu::UnoType<decltype(aExc)>::get(); // binary identical null reference - ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 ); + ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), nullptr ); } } } |