bridges/source/cpp_uno/gcc3_ios/cpp2uno.cxx | 2
bridges/source/cpp_uno/gcc3_linux_aarch64/abi.cxx | 2
bridges/source/cpp_uno/msvc_win32_intel/cpp2uno.cxx | 391 +++++++++----------
bridges/source/cpp_uno/msvc_win32_intel/uno2cpp.cxx | 228 +++++------
bridges/source/cpp_uno/msvc_win32_x86-64/cpp2uno.cxx | 323 +++++++--------
bridges/source/cpp_uno/msvc_win32_x86-64/uno2cpp.cxx | 181 ++++----
6 files changed, 547 insertions(+), 580 deletions(-)
New commits:
commit 52ac46d798a1787baca33cdf9e1c2fd768559522
Author: Jan-Marek Glogowski <glo...@fbihome.de>
AuthorDate: Sat Jul 18 16:01:21 2020 +0200
Commit: Jan-Marek Glogowski <glo...@fbihome.de>
CommitDate: Thu Sep 17 00:01:00 2020 +0200
WIN bridges: unify bridge code layout
This just a cosmetic change to minimize the diff between the
files of the different msvc bridges, by renaming variables,
adapting comments and reordering variables.
This includes the reduction of the "using namespace" to
com::sun::star, so a few types now gain an uno:: prefix.
Change-Id: I2189d2ba223ed3fb51cfa94639c6ca03d26a83e9
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/102863
Tested-by: Jenkins
Reviewed-by: Jan-Marek Glogowski <glo...@fbihome.de>
diff --git a/bridges/source/cpp_uno/gcc3_ios/cpp2uno.cxx
b/bridges/source/cpp_uno/gcc3_ios/cpp2uno.cxx
index cc1528f53d89..21de11b5ea36 100644
--- a/bridges/source/cpp_uno/gcc3_ios/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_ios/cpp2uno.cxx
@@ -451,7 +451,7 @@ namespace
int index = functionIndex*nVtableOffsets + vtableOffset;
unsigned char *result = ((unsigned char *) &codeSnippets) +
codeSnippets[index];
- SAL_INFO( "bridges.ios", "codeSnippet(" <<
OUString(type->aBase.pTypeName) << "::" << OUString(member->pTypeName) << "):
[" << functionIndex << "," << vtableOffset << "]=" << (void *) result << " ("
<< std::hex << ((int*)result)[0] << "," << ((int*)result)[1] << "," <<
((int*)result)[2] << "," << ((int*)result)[3] << ")");
+ SAL_INFO( "bridges", "codeSnippet(" << OUString(type->aBase.pTypeName)
<< "::" << OUString(member->pTypeName) << "): [" << functionIndex << "," <<
vtableOffset << "]=" << (void *) result << " (" << std::hex <<
((int*)result)[0] << "," << ((int*)result)[1] << "," << ((int*)result)[2] <<
"," << ((int*)result)[3] << ")");
return result;
}
diff --git a/bridges/source/cpp_uno/gcc3_linux_aarch64/abi.cxx
b/bridges/source/cpp_uno/gcc3_linux_aarch64/abi.cxx
index 988502713639..f1cacf8d54ba 100644
--- a/bridges/source/cpp_uno/gcc3_linux_aarch64/abi.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_aarch64/abi.cxx
@@ -128,7 +128,7 @@ std::type_info * Rtti::getRtti(typelib_TypeDescription
const & type) {
if (ptr != nullptr)
rtti = *ptr;
else
- SAL_WARN("bridges.osx", dlerror());
+ SAL_WARN("bridges", dlerror());
}
#endif
diff --git a/bridges/source/cpp_uno/msvc_win32_intel/cpp2uno.cxx
b/bridges/source/cpp_uno/msvc_win32_intel/cpp2uno.cxx
index a5e0e53580ac..24a0837a6e30 100644
--- a/bridges/source/cpp_uno/msvc_win32_intel/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/msvc_win32_intel/cpp2uno.cxx
@@ -32,195 +32,188 @@
#include "msci.hxx"
-using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star;
namespace
{
static inline typelib_TypeClass cpp2uno_call(
bridges::cpp_uno::shared::CppInterfaceProxy * pThis,
- const typelib_TypeDescription * pMemberTypeDescr,
- typelib_TypeDescriptionReference * pReturnTypeRef, // 0 indicates void
return
- sal_Int32 nParams, typelib_MethodParameter * pParams,
+ const typelib_TypeDescription * pMemberTD,
+ typelib_TypeDescriptionReference * pReturnTypeRef, // nullptr indicates
void return
+ sal_Int32 nParams,
+ typelib_MethodParameter * pParams,
void ** pCallStack,
- sal_Int64 * pRegisterReturn /* space for register return */ )
+ sal_Int64 * pRegisterReturn /* space for register return */)
{
// pCallStack: ret, this, [complex return ptr], params
- char * pCppStack = (char *)(pCallStack +2);
+ char * pCppCallStack = (char *)(pCallStack +2);
- // return
- typelib_TypeDescription * pReturnTypeDescr = 0;
+ // return type
+ typelib_TypeDescription * pReturnTD = nullptr;
if (pReturnTypeRef)
- {
- TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
- }
+ TYPELIB_DANGER_GET(&pReturnTD, pReturnTypeRef);
void * pUnoReturn = nullptr;
- void * pCppReturn = nullptr; // complex return ptr: if != 0 && !=
pUnoReturn, reconversion need
+ void * pCppReturn = nullptr; // complex return ptr: if != nullptr && !=
pUnoReturn, reconversion need
- if (pReturnTypeDescr)
+ if (pReturnTD)
{
- if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
- {
- pUnoReturn = pRegisterReturn; // direct way for simple types
- }
- else // complex return via ptr (pCppReturn)
+ if (bridges::cpp_uno::shared::isSimpleType(pReturnTD))
+ pUnoReturn = pRegisterReturn;
+ else
{
- pCppReturn = *(void **)pCppStack;
- pCppStack += sizeof(void *);
+ pCppReturn = *(void **)pCppCallStack;
+ pCppCallStack += sizeof(void *);
- pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType(
- pReturnTypeDescr )
- ? alloca( pReturnTypeDescr->nSize )
- : pCppReturn); // direct way
+ pUnoReturn =
(bridges::cpp_uno::shared::relatesToInterfaceType(pReturnTD)
+ ? alloca(pReturnTD->nSize) : pCppReturn);
}
}
- // stack space
static_assert(sizeof(void *) == sizeof(sal_Int32), "### unexpected size!");
- // parameters
- void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
+
+ // parameters passed to the UNO function
+ void ** pUnoArgs = static_cast<void **>(alloca(4 * sizeof(void *) *
nParams));
+
+ // parameters received from C++
void ** pCppArgs = pUnoArgs + nParams;
- // indices of values this have to be converted (interface conversion
cpp<=>uno)
- sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+
+ // indexes of values this have to be converted (interface conversion
C++<=>UNO)
+ sal_Int32 * pTempIndexes = reinterpret_cast<sal_Int32 *>(pUnoArgs + (2 *
nParams));
+
// type descriptions for reconversions
- typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription
**)(pUnoArgs + (3 * nParams));
+ typelib_TypeDescription ** ppTempParamTD =
+ reinterpret_cast<typelib_TypeDescription **>(pUnoArgs + (3 * nParams));
- sal_Int32 nTempIndices = 0;
+ sal_Int32 nTempIndex = 0;
- for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
+ for (sal_Int32 nPos = 0; nPos < nParams; ++nPos)
{
const typelib_MethodParameter & rParam = pParams[nPos];
- typelib_TypeDescription * pParamTypeDescr = 0;
- TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
+ typelib_TypeDescription * pParamTD = nullptr;
+ TYPELIB_DANGER_GET(&pParamTD, rParam.pTypeRef);
- if (!rParam.bOut
- && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
- // value
+ if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType(pParamTD))
{
- pCppArgs[nPos] = pCppStack;
- pUnoArgs[nPos] = pCppStack;
- switch (pParamTypeDescr->eTypeClass)
+ pCppArgs[nPos] = pCppCallStack;
+ pUnoArgs[nPos] = pCppCallStack;
+ switch (pParamTD->eTypeClass)
{
case typelib_TypeClass_HYPER:
case typelib_TypeClass_UNSIGNED_HYPER:
case typelib_TypeClass_DOUBLE:
- pCppStack += sizeof(sal_Int32); // extra long
+ pCppCallStack += sizeof(sal_Int32); // extra long
break;
default:
break;
}
// no longer needed
- TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+ TYPELIB_DANGER_RELEASE(pParamTD);
}
else // ptr to complex value | ref
{
- pCppArgs[nPos] = *(void **)pCppStack;
+ pCppArgs[nPos] = *(void **)pCppCallStack;
- if (! rParam.bIn) // is pure out
+ if (!rParam.bIn) // is pure out
{
- // uno out is unconstructed mem!
- pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
- pTempIndices[nTempIndices] = nPos;
- // will be released at reconversion
- ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+ // UNO out is unconstructed mem
+ pUnoArgs[nPos] = alloca(pParamTD->nSize);
+ pTempIndexes[nTempIndex] = nPos;
+ // pParamTD will be released at reconversion
+ ppTempParamTD[nTempIndex++] = pParamTD;
}
// is in/inout
- else if (bridges::cpp_uno::shared::relatesToInterfaceType(
- pParamTypeDescr ))
+ else if
(bridges::cpp_uno::shared::relatesToInterfaceType(pParamTD))
{
::uno_copyAndConvertData(
- pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
- *(void **)pCppStack, pParamTypeDescr,
- pThis->getBridge()->getCpp2Uno() );
- pTempIndices[nTempIndices] = nPos; // has to be reconverted
- // will be released at reconversion
- ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+ pUnoArgs[nPos] = alloca(pParamTD->nSize),
+ *(void **)pCppCallStack, pParamTD,
+ pThis->getBridge()->getCpp2Uno());
+ pTempIndexes[nTempIndex] = nPos; // has to be reconverted
+ // pParamTD will be released at reconversion
+ ppTempParamTD[nTempIndex++] = pParamTD;
}
else // direct way
{
- pUnoArgs[nPos] = *(void **)pCppStack;
+ pUnoArgs[nPos] = *(void **)pCppCallStack;
// no longer needed
- TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+ TYPELIB_DANGER_RELEASE(pParamTD);
}
}
- pCppStack += sizeof(sal_Int32); // standard parameter length
+ pCppCallStack += sizeof(sal_Int32); // standard parameter length
}
// ExceptionHolder
uno_Any aUnoExc; // Any will be constructed by callee
uno_Any * pUnoExc = &aUnoExc;
- // invoke uno dispatch call
+ // invoke UNO dispatch call
(*pThis->getUnoI()->pDispatcher)(
- pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
+ pThis->getUnoI(), pMemberTD, pUnoReturn, pUnoArgs, &pUnoExc);
// in case an exception occurred...
if (pUnoExc)
{
// destruct temporary in/inout params
- while (nTempIndices--)
+ while (nTempIndex--)
{
- sal_Int32 nIndex = pTempIndices[nTempIndices];
+ sal_Int32 nIndex = pTempIndexes[nTempIndex];
if (pParams[nIndex].bIn) // is in/inout => was constructed
- {
- ::uno_destructData( pUnoArgs[nIndex],
ppTempParamTypeDescr[nTempIndices], 0 );
- }
- TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
- }
- if (pReturnTypeDescr)
- {
- TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
+ ::uno_destructData(pUnoArgs[nIndex],
ppTempParamTD[nTempIndex], nullptr);
+ TYPELIB_DANGER_RELEASE(ppTempParamTD[nTempIndex]);
}
+ if (pReturnTD)
+ TYPELIB_DANGER_RELEASE(pReturnTD);
CPPU_CURRENT_NAMESPACE::msci_raiseException(
- &aUnoExc, pThis->getBridge()->getUno2Cpp() );
- // has to destruct the any
+ &aUnoExc, pThis->getBridge()->getUno2Cpp()); // has to destruct
the any
+
// is here for dummy
return typelib_TypeClass_VOID;
}
- else // else no exception occurred...
+ else // no exception occurred...
{
// temporary params
- while (nTempIndices--)
+ while (nTempIndex--)
{
- sal_Int32 nIndex = pTempIndices[nTempIndices];
- typelib_TypeDescription * pParamTypeDescr =
ppTempParamTypeDescr[nTempIndices];
+ sal_Int32 nIndex = pTempIndexes[nTempIndex];
+ typelib_TypeDescription * pParamTD = ppTempParamTD[nTempIndex];
if (pParams[nIndex].bOut) // inout/out
{
// convert and assign
- ::uno_destructData(
- pCppArgs[nIndex], pParamTypeDescr, cpp_release );
+ ::uno_destructData(pCppArgs[nIndex], pParamTD,
uno::cpp_release);
::uno_copyAndConvertData(
- pCppArgs[nIndex], pUnoArgs[nIndex], pParamTypeDescr,
- pThis->getBridge()->getUno2Cpp() );
+ pCppArgs[nIndex], pUnoArgs[nIndex], pParamTD,
+ pThis->getBridge()->getUno2Cpp());
}
- // destroy temp uno param
- ::uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 );
+ // destroy temp UNO param
+ ::uno_destructData(pUnoArgs[nIndex], pParamTD, nullptr);
- TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+ TYPELIB_DANGER_RELEASE(pParamTD);
}
+
// return
if (pCppReturn) // has complex return
{
if (pUnoReturn != pCppReturn) // needs reconversion
{
::uno_copyAndConvertData(
- pCppReturn, pUnoReturn, pReturnTypeDescr,
- pThis->getBridge()->getUno2Cpp() );
- // destroy temp uno return
- ::uno_destructData(
- pUnoReturn, pReturnTypeDescr, 0 );
+ pCppReturn, pUnoReturn, pReturnTD,
+ pThis->getBridge()->getUno2Cpp());
+ // destroy temp UNO return
+ ::uno_destructData(pUnoReturn, pReturnTD, nullptr);
}
// complex return ptr is set to eax
*(void **)pRegisterReturn = pCppReturn;
}
- if (pReturnTypeDescr)
+
+ if (pReturnTD)
{
- typelib_TypeClass eRet =
(typelib_TypeClass)pReturnTypeDescr->eTypeClass;
- TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
+ typelib_TypeClass eRet = pReturnTD->eTypeClass;
+ TYPELIB_DANGER_RELEASE(pReturnTD);
return eRet;
}
else
@@ -229,132 +222,134 @@ static inline typelib_TypeClass cpp2uno_call(
}
static typelib_TypeClass __cdecl cpp_mediate(
- void ** pCallStack, sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
- sal_Int64 * pRegisterReturn /* space for register return */ )
+ void ** pCallStack,
+ sal_Int32 nFunctionIndex,
+ sal_Int32 nVtableOffset,
+ sal_Int64 * pRegisterReturn) // space for register return
{
static_assert(sizeof(sal_Int32)==sizeof(void *), "### unexpected!");
// pCallStack: ret adr, this, [ret *], params
- void * pThis = static_cast< char * >(pCallStack[1]) - nVtableOffset;
- bridges::cpp_uno::shared::CppInterfaceProxy * pCppI
- = bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(
- pThis);
+ // pRegisterReturn is either the direct "return value", or is set to
+ // "ret *" and the real return value is constructed at that pointer.
+
+ void* pThis = static_cast<char*>(pCallStack[1]) - nVtableOffset;
+ bridges::cpp_uno::shared::CppInterfaceProxy* pCppI
+ =
bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(pThis);
- typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
+ typelib_InterfaceTypeDescription * pInterfaceTD = pCppI->getTypeDescr();
- SAL_INFO( "bridges.win32", "cpp_vtable_call: pCallStack=[" <<
- std::hex << pCallStack[0] << "," << pCallStack[1] << "," <<
pCallStack[2] << ",...]" <<
- ", pThis=" << pThis << ", pCppI=" << pCppI <<
- std::dec << ", nFunctionIndex=" << nFunctionIndex << ",
nVtableOffset=" << nVtableOffset );
- SAL_INFO( "bridges.win32", "name=" <<
OUString::unacquired(&pTypeDescr->aBase.pTypeName) );
+ SAL_INFO("bridges", "cpp_vtable_call: pCallStack=["
+ << std::hex << pCallStack[0] << "," <<
pCallStack[1] << ","
+ << pCallStack[2] << ",...], pThis=" << pThis << ",
pCppI=" << pCppI
+ << std::dec << ", nFunctionIndex=" <<
nFunctionIndex
+ << ", nVtableOffset=" << nVtableOffset);
+ SAL_INFO("bridges", "name=" <<
OUString::unacquired(&pInterfaceTD->aBase.pTypeName));
- if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)
+ if (nFunctionIndex >= pInterfaceTD->nMapFunctionIndexToMemberIndex)
{
- SAL_WARN(
- "bridges",
- "illegal " << OUString::unacquired(&pTypeDescr->aBase.pTypeName)
- << " vtable index " << nFunctionIndex << "/"
- << pTypeDescr->nMapFunctionIndexToMemberIndex);
- throw RuntimeException(
- ("illegal " + OUString::unacquired(&pTypeDescr->aBase.pTypeName)
- + " vtable index " + OUString::number(nFunctionIndex) + "/"
- + OUString::number(pTypeDescr->nMapFunctionIndexToMemberIndex)),
- (XInterface *)pThis );
+ OUString sError = "illegal " +
OUString::unacquired(&pInterfaceTD->aBase.pTypeName)
+ + " vtable index " +
OUString::number(nFunctionIndex) + "/"
+ +
OUString::number(pInterfaceTD->nMapFunctionIndexToMemberIndex);
+ SAL_WARN("bridges", sError);
+ throw uno::RuntimeException(sError,
reinterpret_cast<uno::XInterface*>(pThis));
}
// determine called method
- sal_Int32 nMemberPos =
pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
- assert(nMemberPos < pTypeDescr->nAllMembers);
+ sal_Int32 nMemberPos =
pInterfaceTD->pMapFunctionIndexToMemberIndex[nFunctionIndex];
+ assert(nMemberPos < pInterfaceTD->nAllMembers);
- TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );
+ uno::TypeDescription aMemberDescr(pInterfaceTD->ppAllMembers[nMemberPos]);
- SAL_INFO( "bridges.win32", "Calling " <<
OUString::unacquired(&aMemberDescr.get()->pTypeName) );
+ SAL_INFO( "bridges", "Calling " <<
OUString::unacquired(&aMemberDescr.get()->pTypeName) );
typelib_TypeClass eRet = typelib_TypeClass_VOID;
switch (aMemberDescr.get()->eTypeClass)
{
- case typelib_TypeClass_INTERFACE_ATTRIBUTE:
- {
- if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] ==
nFunctionIndex)
- {
- // is GET method
- eRet = cpp2uno_call(
- pCppI, aMemberDescr.get(),
- ((typelib_InterfaceAttributeTypeDescription
*)aMemberDescr.get())->pAttributeTypeRef,
- 0, 0, // no params
- pCallStack, pRegisterReturn );
- }
- else
- {
- // is SET method
- typelib_MethodParameter aParam;
- aParam.pTypeRef =
- ((typelib_InterfaceAttributeTypeDescription
*)aMemberDescr.get())->pAttributeTypeRef;
- aParam.bIn = sal_True;
- aParam.bOut = sal_False;
-
- eRet = cpp2uno_call(
- pCppI, aMemberDescr.get(),
- 0, // indicates void return
- 1, &aParam,
- pCallStack, pRegisterReturn );
- }
- break;
- }
- case typelib_TypeClass_INTERFACE_METHOD:
- {
- // is METHOD
- switch (nFunctionIndex)
+ case typelib_TypeClass_INTERFACE_ATTRIBUTE:
{
- // standard XInterface vtable calls
- case 1: // acquire()
- pCppI->acquireProxy(); // non virtual call!
- eRet = typelib_TypeClass_VOID;
- break;
- case 2: // release()
- pCppI->releaseProxy(); // non virtual call!
- eRet = typelib_TypeClass_VOID;
+ typelib_TypeDescriptionReference *pAttrTypeRef
+ = reinterpret_cast<typelib_InterfaceAttributeTypeDescription
*>(aMemberDescr.get())
+ ->pAttributeTypeRef;
+
+ if (pInterfaceTD->pMapMemberIndexToFunctionIndex[nMemberPos] ==
nFunctionIndex)
+ {
+ // is GET method
+ eRet = cpp2uno_call(pCppI, aMemberDescr.get(), pAttrTypeRef,
0, nullptr, pCallStack,
+ pRegisterReturn);
+ }
+ else
+ {
+ // is SET method
+ typelib_MethodParameter aParam;
+ aParam.pTypeRef = pAttrTypeRef;
+ aParam.bIn = true;
+ aParam.bOut = false;
+
+ eRet = cpp2uno_call(pCppI, aMemberDescr.get(), nullptr, 1,
&aParam, pCallStack,
+ pRegisterReturn);
+ }
break;
- case 0: // queryInterface() opt
+ }
+ case typelib_TypeClass_INTERFACE_METHOD:
{
- typelib_TypeDescription * pTD = 0;
- TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >(
pCallStack[3] )->getTypeLibType() );
- if (pTD)
+ // is METHOD
+ switch (nFunctionIndex)
{
- XInterface * pInterface = 0;
- (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)(
- pCppI->getBridge()->getCppEnv(),
- (void **)&pInterface, pCppI->getOid().pData,
- (typelib_InterfaceTypeDescription *)pTD );
-
- if (pInterface)
- {
- ::uno_any_construct(
- reinterpret_cast< uno_Any * >( pCallStack[2] ),
- &pInterface, pTD, cpp_acquire );
- pInterface->release();
- TYPELIB_DANGER_RELEASE( pTD );
- *(void **)pRegisterReturn = pCallStack[2];
- eRet = typelib_TypeClass_ANY;
+ // standard XInterface vtable calls
+ case 1: // acquire()
+ pCppI->acquireProxy(); // non virtual call!
+ eRet = typelib_TypeClass_VOID;
+ break;
+ case 2: // release()
+ pCppI->releaseProxy(); // non virtual call!
+ eRet = typelib_TypeClass_VOID;
break;
+ case 0: // queryInterface() opt
+ {
+ typelib_TypeDescription* pQueryTD = nullptr;
+ TYPELIB_DANGER_GET(&pQueryTD,
+
static_cast<uno::Type*>(pCallStack[3])->getTypeLibType());
+ if (pQueryTD)
+ {
+ uno::XInterface* pInterface = nullptr;
+
+
pCppI->getBridge()->getCppEnv()->getRegisteredInterface(
+ pCppI->getBridge()->getCppEnv(),
reinterpret_cast<void**>(&pInterface),
+ pCppI->getOid().pData,
+
reinterpret_cast<typelib_InterfaceTypeDescription*>(pQueryTD));
+
+ if (pInterface)
+ {
+
::uno_any_construct(static_cast<uno_Any*>(pCallStack[2]), &pInterface,
+ pQueryTD, uno::cpp_acquire);
+ pInterface->release();
+ TYPELIB_DANGER_RELEASE(pQueryTD);
+
+ *(void **)pRegisterReturn = pCallStack[2];
+ eRet = typelib_TypeClass_ANY;
+ break;
+ }
+ TYPELIB_DANGER_RELEASE(pQueryTD);
+ }
+ [[fallthrough]];
+ }
+ default: // perform queryInterface()
+ {
+ typelib_InterfaceMethodTypeDescription* pMethodTD
+ =
reinterpret_cast<typelib_InterfaceMethodTypeDescription*>(
+ aMemberDescr.get());
+
+ eRet = cpp2uno_call(pCppI, aMemberDescr.get(),
pMethodTD->pReturnTypeRef,
+ pMethodTD->nParams,
pMethodTD->pParams, pCallStack,
+ pRegisterReturn);
}
- TYPELIB_DANGER_RELEASE( pTD );
}
- } // else perform queryInterface()
- default:
- eRet = cpp2uno_call(
- pCppI, aMemberDescr.get(),
- ((typelib_InterfaceMethodTypeDescription
*)aMemberDescr.get())->pReturnTypeRef,
- ((typelib_InterfaceMethodTypeDescription
*)aMemberDescr.get())->nParams,
- ((typelib_InterfaceMethodTypeDescription
*)aMemberDescr.get())->pParams,
- pCallStack, pRegisterReturn );
+ break;
}
- break;
- }
- default:
- {
- throw RuntimeException( "no member description found!", (XInterface
*)pThis );
- }
+ default:
+ throw uno::RuntimeException("no member description found!",
+
reinterpret_cast<uno::XInterface*>(pThis));
}
return eRet;
@@ -457,7 +452,7 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock(
Rtti():
n0(0), n1(0), n2(0),
rtti(CPPU_CURRENT_NAMESPACE::msci_getRTTI(
- OUString("com.sun.star.uno.XInterface")))
+ "com.sun.star.uno.XInterface"))
{}
};
static Rtti rtti;
@@ -482,7 +477,9 @@ unsigned char *
bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
}
void bridges::cpp_uno::shared::VtableFactory::flushCode(
- unsigned char const *, unsigned char const *)
-{}
+ unsigned char const *,
+ unsigned char const *)
+{
+}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/msvc_win32_intel/uno2cpp.cxx
b/bridges/source/cpp_uno/msvc_win32_intel/uno2cpp.cxx
index 7c05112c41bf..bd7e5046d209 100644
--- a/bridges/source/cpp_uno/msvc_win32_intel/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/msvc_win32_intel/uno2cpp.cxx
@@ -23,19 +23,19 @@
#include <com/sun/star/uno/genfunc.hxx>
#include <uno/data.h>
-#include "bridge.hxx"
-#include "types.hxx"
-#include "unointerfaceproxy.hxx"
-#include "vtables.hxx"
+#include <bridge.hxx>
+#include <types.hxx>
+#include <unointerfaceproxy.hxx>
+#include <vtables.hxx>
#include "msci.hxx"
-using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star;
namespace
{
-inline static void callVirtualMethod(
+inline void callVirtualMethod(
void * pAdjustedThisPtr, sal_Int32 nVtableIndex,
void * pRegisterReturn, typelib_TypeClass eReturnTypeClass,
sal_Int32 * pStackLongs, sal_Int32 nStackLongs )
@@ -134,27 +134,30 @@ Lcleanup:
}
}
-static void cpp_call(
+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 ) throw ()
+ sal_Int32 nParams,
+ typelib_MethodParameter * pParams,
+ void * pUnoReturn,
+ void * pUnoArgs[],
+ uno_Any ** ppUnoExc ) throw ()
{
// max space for: [complex ret ptr], values|ptr ...
char * pCppStack = (char *)alloca( sizeof(sal_Int32) + (nParams *
sizeof(sal_Int64)) );
char * pCppStackStart = pCppStack;
- // return
- typelib_TypeDescription * pReturnTypeDescr = 0;
- TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
- assert(pReturnTypeDescr);
+ // return type
+ typelib_TypeDescription * pReturnTD = nullptr;
+ TYPELIB_DANGER_GET( &pReturnTD, pReturnTypeRef );
+ assert(pReturnTD);
void * pCppReturn = nullptr; // if != 0 && != pUnoReturn, needs
reconversion
- if (pReturnTypeDescr)
+ if (pReturnTD)
{
- if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
+ if (bridges::cpp_uno::shared::isSimpleType( pReturnTD ))
{
pCppReturn = pUnoReturn; // direct way for simple types
}
@@ -163,8 +166,8 @@ static void cpp_call(
// complex return via ptr
pCppReturn = *(void **)pCppStack
= (bridges::cpp_uno::shared::relatesToInterfaceType(
- pReturnTypeDescr )
- ? alloca( pReturnTypeDescr->nSize )
+ pReturnTD )
+ ? alloca( pReturnTD->nSize )
: pUnoReturn); // direct way
pCppStack += sizeof(void *);
}
@@ -176,26 +179,25 @@ static void cpp_call(
// args
void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );
// indices of values this have to be converted (interface conversion
cpp<=>uno)
- sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
+ sal_Int32 * pTempIndexes = (sal_Int32 *)(pCppArgs + nParams);
// type descriptions for reconversions
- typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription
**)(pCppArgs + (2 * nParams));
+ typelib_TypeDescription ** pTempParamTD = (typelib_TypeDescription
**)(pCppArgs + (2 * nParams));
- sal_Int32 nTempIndices = 0;
+ sal_Int32 nTempIndexes = 0;
- for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
+ for (int nPos = 0; nPos < nParams; ++nPos)
{
const typelib_MethodParameter & rParam = pParams[nPos];
- typelib_TypeDescription * pParamTypeDescr = 0;
- TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
+ typelib_TypeDescription * pParamTD = nullptr;
+ TYPELIB_DANGER_GET( &pParamTD, rParam.pTypeRef );
- if (!rParam.bOut
- && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
+ if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType(pParamTD))
{
::uno_copyAndConvertData(
- pCppArgs[nPos] = pCppStack, pUnoArgs[nPos], pParamTypeDescr,
+ pCppArgs[nPos] = pCppStack, pUnoArgs[nPos], pParamTD,
pThis->getBridge()->getUno2Cpp() );
- switch (pParamTypeDescr->eTypeClass)
+ switch (pParamTD->eTypeClass)
{
case typelib_TypeClass_HYPER:
case typelib_TypeClass_UNSIGNED_HYPER:
@@ -206,38 +208,42 @@ static void cpp_call(
break;
}
// no longer needed
- TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+ TYPELIB_DANGER_RELEASE( pParamTD );
}
else // ptr to complex value | ref
{
if (! rParam.bIn) // is pure out
{
- // cpp out is constructed mem, uno out is not!
+ // C++ out is constructed mem, UNO out is not!
::uno_constructData(
- *(void **)pCppStack = pCppArgs[nPos] = alloca(
pParamTypeDescr->nSize ),
- pParamTypeDescr );
- pTempIndices[nTempIndices] = nPos; // default constructed for
cpp call
+ *(void **)pCppStack = pCppArgs[nPos] = alloca(
pParamTD->nSize ),
+ pParamTD );
+
+ // default constructed for C++ call
+ pTempIndexes[nTempIndexes] = nPos;
+
// will be released at reconversion
- ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+ pTempParamTD[nTempIndexes++] = pParamTD;
}
// is in/inout
- else if (bridges::cpp_uno::shared::relatesToInterfaceType(
- pParamTypeDescr ))
+ else if
(bridges::cpp_uno::shared::relatesToInterfaceType(pParamTD))
{
::uno_copyAndConvertData(
- *(void **)pCppStack = pCppArgs[nPos] = alloca(
pParamTypeDescr->nSize ),
- pUnoArgs[nPos], pParamTypeDescr,
+ *(void **)pCppStack = pCppArgs[nPos] = alloca(
pParamTD->nSize ),
+ pUnoArgs[nPos], pParamTD,
pThis->getBridge()->getUno2Cpp() );
- pTempIndices[nTempIndices] = nPos; // has to be reconverted
+ // has to be reconverted
+ pTempIndexes[nTempIndexes] = nPos;
+
// will be released at reconversion
- ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+ pTempParamTD[nTempIndexes++] = pParamTD;
}
else // direct way
{
*(void **)pCppStack = pCppArgs[nPos] = pUnoArgs[nPos];
// no longer needed
- TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+ TYPELIB_DANGER_RELEASE( pParamTD );
}
}
pCppStack += sizeof(sal_Int32); // standard parameter length
@@ -249,7 +255,7 @@ static void cpp_call(
callVirtualMethod(
reinterpret_cast< void ** >(pThis->getCppI()) + aVtableSlot.offset,
aVtableSlot.index,
- pCppReturn, pReturnTypeDescr->eTypeClass,
+ pCppReturn, pReturnTD->eTypeClass,
(sal_Int32 *)pCppStackStart,
(pCppStack - pCppStackStart) / sizeof(sal_Int32) );
}
@@ -259,86 +265,89 @@ static void cpp_call(
{
// *ppUnoExc was constructed by filter function
// temporary params
- while (nTempIndices--)
+ while (nTempIndexes--)
{
- sal_Int32 nIndex = pTempIndices[nTempIndices];
- // destroy temp cpp param => cpp: every param was constructed
+ sal_Int32 nIndex = pTempIndexes[nTempIndexes];
+ // destroy temp C++ param => C++: every param was constructed
::uno_destructData(
- pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices],
- cpp_release );
- TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
+ pCppArgs[nIndex], pTempParamTD[nTempIndexes],
+ uno::cpp_release );
+ TYPELIB_DANGER_RELEASE( pTempParamTD[nTempIndexes] );
}
+
// return type
- if (pReturnTypeDescr)
- {
- TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
- }
- // end here
+ if (pReturnTD)
+ TYPELIB_DANGER_RELEASE( pReturnTD );
+
return;
}
// NO exception occurred
- *ppUnoExc = 0;
+ *ppUnoExc = nullptr;
// reconvert temporary params
- while (nTempIndices--)
+ while (nTempIndexes--)
{
- sal_Int32 nIndex = pTempIndices[nTempIndices];
- typelib_TypeDescription * pParamTypeDescr =
- ppTempParamTypeDescr[nTempIndices];
+ int nIndex = pTempIndexes[nTempIndexes];
+ typelib_TypeDescription * pParamTD =
+ pTempParamTD[nTempIndexes];
if (pParams[nIndex].bIn)
{
if (pParams[nIndex].bOut) // inout
{
::uno_destructData(
- pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno
value
+ pUnoArgs[nIndex], pParamTD, nullptr ); // destroy UNO value
::uno_copyAndConvertData(
- pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
+ pUnoArgs[nIndex], pCppArgs[nIndex], pParamTD,
pThis->getBridge()->getCpp2Uno() );
}
}
else // pure out
{
::uno_copyAndConvertData(
- pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
+ pUnoArgs[nIndex], pCppArgs[nIndex], pParamTD,
pThis->getBridge()->getCpp2Uno() );
}
- // destroy temp cpp param => cpp: every param was constructed
+
+ // destroy temp C++ param => C++: every param was constructed
::uno_destructData(
- pCppArgs[nIndex], pParamTypeDescr, cpp_release );
+ pCppArgs[nIndex], pParamTD, uno::cpp_release );
- TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+ TYPELIB_DANGER_RELEASE( pParamTD );
}
+
// return value
if (pCppReturn && pUnoReturn != pCppReturn)
{
::uno_copyAndConvertData(
- pUnoReturn, pCppReturn, pReturnTypeDescr,
+ pUnoReturn, pCppReturn, pReturnTD,
pThis->getBridge()->getCpp2Uno() );
::uno_destructData(
- pCppReturn, pReturnTypeDescr, cpp_release );
+ pCppReturn, pReturnTD, uno::cpp_release );
}
+
// return type
- if (pReturnTypeDescr)
- {
- TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
- }
+ if ( pReturnTD )
+ TYPELIB_DANGER_RELEASE( pReturnTD );
}
-}
+} // namespace
namespace bridges::cpp_uno::shared {
void unoInterfaceProxyDispatch(
- uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
- void * pReturn, void * pArgs[], uno_Any ** ppException )
+ uno_Interface * pUnoI,
+ const typelib_TypeDescription * pMemberTD,
+ void * pReturn,
+ void * pArgs[],
+ uno_Any ** ppException )
{
// is my surrogate
bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
= static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
- switch (pMemberDescr->eTypeClass)
+ switch (pMemberTD->eTypeClass)
{
case typelib_TypeClass_INTERFACE_ATTRIBUTE:
{
@@ -346,14 +355,14 @@ void unoInterfaceProxyDispatch(
getVtableSlot(
reinterpret_cast<
typelib_InterfaceAttributeTypeDescription const * >(
- pMemberDescr)));
- if (pReturn)
+ pMemberTD)));
+ if ( pReturn )
{
- // dependent dispatch
+ // is GET
cpp_call(
pThis, aVtableSlot,
- ((typelib_InterfaceAttributeTypeDescription
*)pMemberDescr)->pAttributeTypeRef,
- 0, 0, // no params
+ reinterpret_cast<typelib_InterfaceAttributeTypeDescription
const *>(pMemberTD)->pAttributeTypeRef,
+ 0, nullptr, // no params
pReturn, pArgs, ppException );
}
else
@@ -361,16 +370,15 @@ void unoInterfaceProxyDispatch(
// is SET
typelib_MethodParameter aParam;
aParam.pTypeRef =
- ((typelib_InterfaceAttributeTypeDescription
*)pMemberDescr)->pAttributeTypeRef;
+ reinterpret_cast<typelib_InterfaceAttributeTypeDescription
const *>(pMemberTD)->pAttributeTypeRef;
aParam.bIn = sal_True;
aParam.bOut = sal_False;
- typelib_TypeDescriptionReference * pReturnTypeRef = 0;
+ typelib_TypeDescriptionReference * pReturnTypeRef = nullptr;
OUString aVoidName("void");
typelib_typedescriptionreference_new(
&pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
- // dependent dispatch
aVtableSlot.index += 1; // get, then set method
cpp_call(
pThis, aVtableSlot,
@@ -389,62 +397,60 @@ void unoInterfaceProxyDispatch(
getVtableSlot(
reinterpret_cast<
typelib_InterfaceMethodTypeDescription const * >(
- pMemberDescr)));
+ pMemberTD)));
+
switch (aVtableSlot.index)
{
- // standard calls
- case 1: // acquire uno interface
+ case 1: // acquire UNO interface
(*pUnoI->acquire)( pUnoI );
- *ppException = 0;
+ *ppException = nullptr;
break;
- case 2: // release uno interface
+ 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() );
- if (pTD)
+ typelib_TypeDescription * pTD = nullptr;
+ TYPELIB_DANGER_GET( &pTD, static_cast< uno::Type * >( pArgs[0]
)->getTypeLibType() );
+
+ if ( pTD )
{
- uno_Interface * pInterface = 0;
- (*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(
- pThis->pBridge->getUnoEnv(),
- (void **)&pInterface, pThis->oid.pData,
(typelib_InterfaceTypeDescription *)pTD );
+ uno_Interface * pInterface = nullptr;
+ (*pThis->getBridge()->getUnoEnv()->getRegisteredInterface)(
+ pThis->getBridge()->getUnoEnv(),
+ reinterpret_cast<void **>(&pInterface), pThis->oid.pData,
reinterpret_cast<typelib_InterfaceTypeDescription *>(pTD) );
- if (pInterface)
+ 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 );
}
- } // else perform queryInterface()
+ [[fallthrough]]; // else perform queryInterface()
+ }
default:
- // dependent dispatch
- cpp_call(
- pThis, aVtableSlot,
- ((typelib_InterfaceMethodTypeDescription
*)pMemberDescr)->pReturnTypeRef,
- ((typelib_InterfaceMethodTypeDescription
*)pMemberDescr)->nParams,
- ((typelib_InterfaceMethodTypeDescription
*)pMemberDescr)->pParams,
- pReturn, pArgs, ppException );
+ typelib_InterfaceMethodTypeDescription const* pMethodTD
+ = reinterpret_cast<typelib_InterfaceMethodTypeDescription
const *>(pMemberTD);
+
+ cpp_call(pThis, aVtableSlot, pMethodTD->pReturnTypeRef,
pMethodTD->nParams, pMethodTD->pParams,
+ pReturn, pArgs, ppException);
}
break;
}
default:
{
- ::com::sun::star::uno::RuntimeException aExc(
- "illegal member type description!",
- ::com::sun::star::uno::Reference<
::com::sun::star::uno::XInterface >() );
+ uno::RuntimeException aExc("Illegal member type description!",
uno::Reference<uno::XInterface>());
- Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
+ uno::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);
}
}
}
diff --git a/bridges/source/cpp_uno/msvc_win32_x86-64/cpp2uno.cxx
b/bridges/source/cpp_uno/msvc_win32_x86-64/cpp2uno.cxx
index d8b2220fc94c..a229db4c2ffe 100644
--- a/bridges/source/cpp_uno/msvc_win32_x86-64/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/msvc_win32_x86-64/cpp2uno.cxx
@@ -33,108 +33,100 @@
#include "call.hxx"
#include "mscx.hxx"
-using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star;
static typelib_TypeClass cpp2uno_call(
bridges::cpp_uno::shared::CppInterfaceProxy * pThis,
const typelib_TypeDescription * pMemberTD,
- typelib_TypeDescriptionReference * pReturnTypeRef, // NULL indicates void
return
+ typelib_TypeDescriptionReference * pReturnTypeRef, // nullptr indicates
void return
sal_Int32 nParams,
typelib_MethodParameter * pParams,
- void ** pStack )
+ void ** pCallStack)
{
- // Return type
+ // return type
typelib_TypeDescription * pReturnTD = nullptr;
- if ( pReturnTypeRef )
- TYPELIB_DANGER_GET( &pReturnTD, pReturnTypeRef );
+ if (pReturnTypeRef)
+ TYPELIB_DANGER_GET(&pReturnTD, pReturnTypeRef);
- int nFirstRealParam = 3; // Index into pStack, past return
+ int nFirstRealParam = 3; // Index into pCallStack, past return
// value, return address and 'this'
// pointer.
void * pUnoReturn = nullptr;
- void * pCppReturn = nullptr; // Complex return ptr: if != NULL && !=
pUnoReturn, reconversion need
+ void * pCppReturn = nullptr; // complex return ptr: if != nullptr && !=
pUnoReturn, reconversion need
- if ( pReturnTD )
+ if (pReturnTD)
{
- if ( bridges::cpp_uno::shared::isSimpleType( pReturnTD ) )
- {
- pUnoReturn = pStack;
- }
+ if (bridges::cpp_uno::shared::isSimpleType(pReturnTD))
+ pUnoReturn = pCallStack;
else
{
- pCppReturn = pStack[nFirstRealParam++];
-
- pUnoReturn = ( bridges::cpp_uno::shared::relatesToInterfaceType(
pReturnTD )
- ? alloca( pReturnTD->nSize )
- : pCppReturn ); // direct way
+ pCppReturn = pCallStack[nFirstRealParam++];
+ pUnoReturn =
(bridges::cpp_uno::shared::relatesToInterfaceType(pReturnTD)
+ ? alloca(pReturnTD->nSize) : pCppReturn);
}
}
- void ** pCppIncomingParams = pStack + nFirstRealParam;
+ void ** pCppIncomingParams = pCallStack + nFirstRealParam;
// Unlike this method for other archs, prefer clarity to
// micro-optimization, and allocate these array separately
- // Parameters passed to the UNO function
- void ** pUnoArgs = static_cast<void **>(alloca( sizeof(void *) * nParams
));
+ // parameters passed to the UNO function
+ void ** pUnoArgs = static_cast<void **>(alloca(sizeof(void *) * nParams));
- // Parameters received from C++
- void ** pCppArgs = static_cast<void **>(alloca( sizeof(void *) * nParams
));
+ // parameters received from C++
+ void ** pCppArgs = static_cast<void **>(alloca(sizeof(void *) * nParams));
- // Indexes of values this have to be converted (interface conversion
C++<=>UNO)
- int * pTempIndexes =
- static_cast<int *>(alloca( sizeof(int) * nParams ));
+ // indexes of values this have to be converted (interface conversion
C++<=>UNO)
+ sal_Int32 * pTempIndexes = static_cast<sal_Int32
*>(alloca(sizeof(sal_Int32) * nParams));
- // Type descriptions for reconversions
+ // type descriptions for reconversions
typelib_TypeDescription ** ppTempParamTD =
- static_cast<typelib_TypeDescription **>(alloca( sizeof(void *) *
nParams ));
+ static_cast<typelib_TypeDescription **>(alloca(sizeof(void *) *
nParams));
- int nTempIndexes = 0;
+ sal_Int32 nTempIndex = 0;
- for ( int nPos = 0; nPos < nParams; ++nPos )
+ for (sal_Int32 nPos = 0; nPos < nParams; ++nPos)
{
const typelib_MethodParameter & rParam = pParams[nPos];
-
typelib_TypeDescription * pParamTD = nullptr;
- TYPELIB_DANGER_GET( &pParamTD, rParam.pTypeRef );
+ TYPELIB_DANGER_GET(&pParamTD, rParam.pTypeRef);
- if ( !rParam.bOut &&
- bridges::cpp_uno::shared::isSimpleType( pParamTD ) )
+ if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType(pParamTD))
{
pCppArgs[nPos] = pUnoArgs[nPos] = pCppIncomingParams++;
-
- TYPELIB_DANGER_RELEASE( pParamTD );
+ TYPELIB_DANGER_RELEASE(pParamTD);
}
else // ptr to complex value | ref
{
- void * pCppStack;
+ void * pCppCallStack;
- pCppArgs[nPos] = pCppStack = *pCppIncomingParams++;
+ pCppArgs[nPos] = pCppCallStack = *pCppIncomingParams++;
- if ( !rParam.bIn ) // Pure out
+ if (!rParam.bIn) // is pure out
{
// UNO out is unconstructed mem
- pUnoArgs[nPos] = alloca( pParamTD->nSize );
- pTempIndexes[nTempIndexes] = nPos;
+ pUnoArgs[nPos] = alloca(pParamTD->nSize);
+ pTempIndexes[nTempIndex] = nPos;
// pParamTD will be released at reconversion
- ppTempParamTD[nTempIndexes++] = pParamTD;
+ ppTempParamTD[nTempIndex++] = pParamTD;
}
- else if ( bridges::cpp_uno::shared::relatesToInterfaceType(
pParamTD ) )
+ else if
(bridges::cpp_uno::shared::relatesToInterfaceType(pParamTD))
{
::uno_copyAndConvertData(
- pUnoArgs[nPos] = alloca( pParamTD->nSize ),
- pCppStack, pParamTD,
- pThis->getBridge()->getCpp2Uno() );
- pTempIndexes[nTempIndexes] = nPos; // Has to be reconverted
+ pUnoArgs[nPos] = alloca(pParamTD->nSize),
+ pCppCallStack, pParamTD,
+ pThis->getBridge()->getCpp2Uno());
+ pTempIndexes[nTempIndex] = nPos; // has to be reconverted
// pParamTD will be released at reconversion
- ppTempParamTD[nTempIndexes++] = pParamTD;
+ ppTempParamTD[nTempIndex++] = pParamTD;
}
else // direct way
{
- pUnoArgs[nPos] = pCppStack;
- // No longer needed
- TYPELIB_DANGER_RELEASE( pParamTD );
+ pUnoArgs[nPos] = pCppCallStack;
+ // no longer needed
+ TYPELIB_DANGER_RELEASE(pParamTD);
}
}
}
@@ -145,71 +137,70 @@ static typelib_TypeClass cpp2uno_call(
// invoke UNO dispatch call
(*pThis->getUnoI()->pDispatcher)(
- pThis->getUnoI(), pMemberTD, pUnoReturn, pUnoArgs, &pUnoExc );
+ pThis->getUnoI(), pMemberTD, pUnoReturn, pUnoArgs, &pUnoExc);
// in case an exception occurred...
- if ( pUnoExc )
+ if (pUnoExc)
{
- // Destruct temporary in/inout params
- while ( nTempIndexes-- )
+ // destruct temporary in/inout params
+ while (nTempIndex--)
{
- int nIndex = pTempIndexes[nTempIndexes];
+ sal_Int32 nIndex = pTempIndexes[nTempIndex];
- if ( pParams[nIndex].bIn ) // Is in/inout => was constructed
- {
- ::uno_destructData( pUnoArgs[nIndex],
ppTempParamTD[nTempIndexes], nullptr );
- }
- TYPELIB_DANGER_RELEASE( ppTempParamTD[nTempIndexes] );
+ if (pParams[nIndex].bIn) // is in/inout => was constructed
+ ::uno_destructData(pUnoArgs[nIndex],
ppTempParamTD[nTempIndex], nullptr);
+ TYPELIB_DANGER_RELEASE(ppTempParamTD[nTempIndex]);
}
- if ( pReturnTD )
- TYPELIB_DANGER_RELEASE( pReturnTD );
+ if (pReturnTD)
+ TYPELIB_DANGER_RELEASE(pReturnTD);
CPPU_CURRENT_NAMESPACE::mscx_raiseException(
- &aUnoExc, pThis->getBridge()->getUno2Cpp() ); // Has to destruct
the any
+ &aUnoExc, pThis->getBridge()->getUno2Cpp()); // has to destruct
the any
- // Is here for dummy
+ // is here for dummy
return typelib_TypeClass_VOID;
}
- else // Else, no exception occurred...
+ else // no exception occurred...
{
- // Temporary params
- while (nTempIndexes--)
+ // temporary params
+ while (nTempIndex--)
{
- int nIndex = pTempIndexes[nTempIndexes];
- typelib_TypeDescription * pParamTD = ppTempParamTD[nTempIndexes];
+ sal_Int32 nIndex = pTempIndexes[nTempIndex];
+ typelib_TypeDescription * pParamTD = ppTempParamTD[nTempIndex];
- if ( pParams[nIndex].bOut ) // inout/out
+ if (pParams[nIndex].bOut) // inout/out
{
- // Convert and assign
- ::uno_destructData(
- pCppArgs[nIndex], pParamTD, cpp_release );
+ // convert and assign
+ ::uno_destructData(pCppArgs[nIndex], pParamTD,
uno::cpp_release);
::uno_copyAndConvertData(
pCppArgs[nIndex], pUnoArgs[nIndex], pParamTD,
- pThis->getBridge()->getUno2Cpp() );
+ pThis->getBridge()->getUno2Cpp());
}
- // Destroy temp UNO param
- ::uno_destructData( pUnoArgs[nIndex], pParamTD, nullptr );
+ // destroy temp UNO param
+ ::uno_destructData(pUnoArgs[nIndex], pParamTD, nullptr);
- TYPELIB_DANGER_RELEASE( pParamTD );
+ TYPELIB_DANGER_RELEASE(pParamTD);
}
- // Return
- if ( pCppReturn ) // Has complex return
+
+ // return
+ if (pCppReturn) // has complex return
{
- if ( pUnoReturn != pCppReturn ) // Needs reconversion
+ if (pUnoReturn != pCppReturn) // needs reconversion
{
::uno_copyAndConvertData(
pCppReturn, pUnoReturn, pReturnTD,
- pThis->getBridge()->getUno2Cpp() );
- // Destroy temp UNO return
- ::uno_destructData( pUnoReturn, pReturnTD, nullptr );
+ pThis->getBridge()->getUno2Cpp());
+ // destroy temp UNO return
+ ::uno_destructData(pUnoReturn, pReturnTD, nullptr);
}
- // Complex return ptr is set to eax
- pStack[0] = pCppReturn;
+ // complex return ptr is set to eax
+ pCallStack[0] = pCppReturn;
}
- if ( pReturnTD )
+
+ if (pReturnTD)
{
typelib_TypeClass eRet = pReturnTD->eTypeClass;
- TYPELIB_DANGER_RELEASE( pReturnTD );
+ TYPELIB_DANGER_RELEASE(pReturnTD);
return eRet;
}
else
@@ -219,93 +210,78 @@ static typelib_TypeClass cpp2uno_call(
extern "C" typelib_TypeClass cpp_vtable_call(
sal_Int64 nOffsetAndIndex,
- void ** pStack )
+ void ** pCallStack)
{
sal_Int32 nFunctionIndex = (nOffsetAndIndex & 0xFFFFFFFF);
sal_Int32 nVtableOffset = ((nOffsetAndIndex >> 32) & 0xFFFFFFFF);
- // pStack points to space for return value allocated by
- // privateSnippetExecutor() in call.asm, after which follows our
- // return address (uninteresting), then the integer or
- // floating-point register parameters (spilled by
- // privateSnippetExecutor()) from the call to the trampoline,
- // followed by stacked parameters. The first parameter is the
- // 'this' pointer. If the callee returns a large value, the
- // parameter after that is actually a pointer to where the callee
- // should store its return value.
-
- void * pThis = static_cast<char *>( pStack[2] ) - nVtableOffset;
+ // pCallStack: ret value, ret adr, this, [ret *], params
+ // pCallStack[0] is either the direct "return value", or is set to "ret *"
and
+ // the real return value is constructed at that memory.
- bridges::cpp_uno::shared::CppInterfaceProxy * pCppI =
- bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(
pThis );
+ void* pThis = static_cast<char*>(pCallStack[2]) - nVtableOffset;
+ bridges::cpp_uno::shared::CppInterfaceProxy* pCppI
+ =
bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(pThis);
- typelib_InterfaceTypeDescription * pTD = pCppI->getTypeDescr();
+ typelib_InterfaceTypeDescription * pInterfaceTD = pCppI->getTypeDescr();
- SAL_INFO( "bridges", "cpp_vtable_call: pCallStack=[" <<
- std::hex << pStack[0] << "," << pStack[1] << "," << pStack[2] <<
",...], pThis=" <<
- pThis << ", pCppI=" << pCppI <<
- std::dec << ", nFunctionIndex=" << nFunctionIndex << ",
nVtableOffset=" << nVtableOffset );
- SAL_INFO( "bridges", "name=" <<
OUString::unacquired(&pTD->aBase.pTypeName) );
+ SAL_INFO("bridges", "cpp_vtable_call: pCallStack=["
+ << std::hex << pCallStack[0] << "," <<
pCallStack[1] << ","
+ << pCallStack[2] << ",...], pThis=" << pThis << ",
pCppI=" << pCppI
+ << std::dec << ", nFunctionIndex=" <<
nFunctionIndex
+ << ", nVtableOffset=" << nVtableOffset);
+ SAL_INFO("bridges", "name=" <<
OUString::unacquired(&pInterfaceTD->aBase.pTypeName));
- if ( nFunctionIndex >= pTD->nMapFunctionIndexToMemberIndex )
+ if (nFunctionIndex >= pInterfaceTD->nMapFunctionIndexToMemberIndex)
{
- SAL_WARN(
- "bridges",
- "illegal " << OUString::unacquired(&pTD->aBase.pTypeName)
- << " vtable index " << nFunctionIndex << "/"
- << pTD->nMapFunctionIndexToMemberIndex);
- throw RuntimeException(
- ("illegal " + OUString::unacquired(&pTD->aBase.pTypeName)
- + " vtable index " + OUString::number(nFunctionIndex) + "/"
- + OUString::number(pTD->nMapFunctionIndexToMemberIndex)),
- reinterpret_cast<XInterface *>( pCppI ) );
+ OUString sError = "illegal " +
OUString::unacquired(&pInterfaceTD->aBase.pTypeName)
+ + " vtable index " +
OUString::number(nFunctionIndex) + "/"
+ +
OUString::number(pInterfaceTD->nMapFunctionIndexToMemberIndex);
+ SAL_WARN("bridges", sError);
+ throw uno::RuntimeException(sError,
reinterpret_cast<uno::XInterface*>(pThis));
}
- // Determine called method
- int nMemberPos = pTD->pMapFunctionIndexToMemberIndex[nFunctionIndex];
- assert(nMemberPos < pTD->nAllMembers);
+ // determine called method
+ sal_Int32 nMemberPos =
pInterfaceTD->pMapFunctionIndexToMemberIndex[nFunctionIndex];
+ assert(nMemberPos < pInterfaceTD->nAllMembers);
- TypeDescription aMemberDescr( pTD->ppAllMembers[nMemberPos] );
+ uno::TypeDescription aMemberDescr(pInterfaceTD->ppAllMembers[nMemberPos]);
SAL_INFO( "bridges", "Calling " <<
OUString::unacquired(&aMemberDescr.get()->pTypeName) );
- typelib_TypeClass eRet;
- switch ( aMemberDescr.get()->eTypeClass )
+ typelib_TypeClass eRet = typelib_TypeClass_VOID;
+ switch (aMemberDescr.get()->eTypeClass)
{
case typelib_TypeClass_INTERFACE_ATTRIBUTE:
{
- typelib_TypeDescriptionReference *pAttrTypeRef =
- reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>(
aMemberDescr.get() )->pAttributeTypeRef;
+ typelib_TypeDescriptionReference *pAttrTypeRef
+ = reinterpret_cast<typelib_InterfaceAttributeTypeDescription
*>(aMemberDescr.get())
+ ->pAttributeTypeRef;
- if ( pTD->pMapMemberIndexToFunctionIndex[nMemberPos] ==
nFunctionIndex )
+ if (pInterfaceTD->pMapMemberIndexToFunctionIndex[nMemberPos] ==
nFunctionIndex)
{
// is GET method
- eRet = cpp2uno_call( pCppI, aMemberDescr.get(), pAttrTypeRef,
- 0, nullptr, // No params
- pStack );
+ eRet = cpp2uno_call(pCppI, aMemberDescr.get(), pAttrTypeRef,
0, nullptr, pCallStack);
}
else
{
// is SET method
typelib_MethodParameter aParam;
aParam.pTypeRef = pAttrTypeRef;
- aParam.bIn = true;
- aParam.bOut = false;
+ aParam.bIn = true;
+ aParam.bOut = false;
- eRet = cpp2uno_call( pCppI, aMemberDescr.get(),
- nullptr, // Indicates void return
- 1, &aParam,
- pStack );
+ eRet = cpp2uno_call(pCppI, aMemberDescr.get(), nullptr, 1,
&aParam, pCallStack);
}
break;
}
case typelib_TypeClass_INTERFACE_METHOD:
{
// is METHOD
- switch ( nFunctionIndex )
+ switch (nFunctionIndex)
{
case 1: // acquire()
- pCppI->acquireProxy(); // Non virtual call!
+ pCppI->acquireProxy(); // non virtual call!
eRet = typelib_TypeClass_VOID;
break;
case 2: // release()
@@ -314,60 +290,51 @@ extern "C" typelib_TypeClass cpp_vtable_call(
break;
case 0: // queryInterface() opt
{
- typelib_TypeDescription * pTD2 = nullptr;
+ typelib_TypeDescription* pQueryTD = nullptr;
- // the incoming C++ parameters are: The this
- // pointer, the hidden return value pointer, and
- // then the actual queryInterface() only
- // parameter. Thus pStack[4]..
+ TYPELIB_DANGER_GET(&pQueryTD,
+
static_cast<uno::Type*>(pCallStack[4])->getTypeLibType());
- TYPELIB_DANGER_GET( &pTD2, static_cast<Type *>( pStack[4]
)->getTypeLibType() );
-
- if ( pTD2 )
+ if (pQueryTD)
{
- XInterface * pInterface = nullptr;
-
(*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)
- ( pCppI->getBridge()->getCppEnv(),
- reinterpret_cast<void **>(&pInterface),
- pCppI->getOid().pData,
-
reinterpret_cast<typelib_InterfaceTypeDescription *>( pTD2 ) );
-
- if ( pInterface )
- {
- // pStack[3] = hidden return value pointer
- ::uno_any_construct( static_cast<uno_Any *>(
pStack[3] ),
- &pInterface, pTD2,
cpp_acquire );
+ uno::XInterface* pInterface = nullptr;
+
pCppI->getBridge()->getCppEnv()->getRegisteredInterface(
+ pCppI->getBridge()->getCppEnv(),
reinterpret_cast<void**>(&pInterface),
+ pCppI->getOid().pData,
+
reinterpret_cast<typelib_InterfaceTypeDescription*>(pQueryTD));
+
+ if (pInterface)
+ {
+ // pCallStack[3] = hidden return value pointer
+
::uno_any_construct(static_cast<uno_Any*>(pCallStack[3]), &pInterface,
+ pQueryTD, uno::cpp_acquire);
pInterface->release();
- TYPELIB_DANGER_RELEASE( pTD2 );
+ TYPELIB_DANGER_RELEASE(pQueryTD);
- pStack[0] = pStack[3];
+ pCallStack[0] = pCallStack[3];
eRet = typelib_TypeClass_ANY;
break;
}
- TYPELIB_DANGER_RELEASE( pTD2 );
+ TYPELIB_DANGER_RELEASE(pQueryTD);
}
[[fallthrough]];
}
- default:
+ default: // perform queryInterface()
{
- typelib_InterfaceMethodTypeDescription * pMethodTD =
-
reinterpret_cast<typelib_InterfaceMethodTypeDescription *>( aMemberDescr.get()
);
-
- eRet = cpp2uno_call( pCppI, aMemberDescr.get(),
- pMethodTD->pReturnTypeRef,
- pMethodTD->nParams,
- pMethodTD->pParams,
- pStack );
+ typelib_InterfaceMethodTypeDescription* pMethodTD
+ =
reinterpret_cast<typelib_InterfaceMethodTypeDescription*>(
+ aMemberDescr.get());
+
+ eRet = cpp2uno_call(pCppI, aMemberDescr.get(),
pMethodTD->pReturnTypeRef,
+ pMethodTD->nParams,
pMethodTD->pParams, pCallStack);
}
}
break;
}
default:
- {
- throw RuntimeException("No member description found!",
- reinterpret_cast<XInterface *>( pCppI ) );
- }
+ throw uno::RuntimeException("No member description found!",
+
reinterpret_cast<uno::XInterface*>(pThis));
}
return eRet;
@@ -460,7 +427,7 @@ bridges::cpp_uno::shared::VtableFactory::mapBlockToVtable(
}
std::size_t bridges::cpp_uno::shared::VtableFactory::getBlockSize(
- sal_Int32 slotCount )
+ sal_Int32 slotCount)
{
return (slotCount + 1) * sizeof (Slot) + slotCount * codeSnippetSize;
}
@@ -469,7 +436,7 @@ bridges::cpp_uno::shared::VtableFactory::Slot *
bridges::cpp_uno::shared::VtableFactory::initializeBlock(
void * block,
sal_Int32 slotCount,
- sal_Int32, typelib_InterfaceTypeDescription * )
+ sal_Int32, typelib_InterfaceTypeDescription *)
{
struct Rtti {
sal_Int32 n0, n1, n2;
@@ -582,7 +549,7 @@ unsigned char *
bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
void bridges::cpp_uno::shared::VtableFactory::flushCode(
unsigned char const *,
- unsigned char const * )
+ unsigned char const *)
{
}
diff --git a/bridges/source/cpp_uno/msvc_win32_x86-64/uno2cpp.cxx
b/bridges/source/cpp_uno/msvc_win32_x86-64/uno2cpp.cxx
index 99f87e23d216..aa0cdda9de3d 100644
--- a/bridges/source/cpp_uno/msvc_win32_x86-64/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/msvc_win32_x86-64/uno2cpp.cxx
@@ -37,7 +37,7 @@
#include <stdio.h>
#endif
-using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star;
namespace
{
@@ -68,17 +68,17 @@ bool cpp_call(
sal_Int64 i;
void *p;
double d;
- } aCppParams[MAXPARAMS+2], uRetVal;
+ } aCppArgs[MAXPARAMS+2], uRetVal;
int nCppParamIndex = 0;
- // Return type
+ // return type
typelib_TypeDescription * pReturnTD = nullptr;
TYPELIB_DANGER_GET( &pReturnTD, pReturnTypeRef );
assert(pReturnTD);
// 'this'
void * pAdjustedThisPtr = reinterpret_cast<void **>( pThis->getCppI() ) +
aVtableSlot.offset;
- aCppParams[nCppParamIndex++].p = pAdjustedThisPtr;
+ aCppArgs[nCppParamIndex++].p = pAdjustedThisPtr;
enum class ReturnKind { Void, Simple, Complex, ComplexConvert };
ReturnKind retKind;
@@ -91,73 +91,73 @@ bool cpp_call(
} else if (bridges::cpp_uno::shared::relatesToInterfaceType(pReturnTD))
{
retKind = ReturnKind::ComplexConvert;
- aCppParams[nCppParamIndex++].p = alloca(pReturnTD->nSize);
+ aCppArgs[nCppParamIndex++].p = alloca(pReturnTD->nSize);
} else {
retKind = ReturnKind::Complex;
- aCppParams[nCppParamIndex++].p = pUnoReturn;
+ aCppArgs[nCppParamIndex++].p = pUnoReturn;
}
}
- // Indexes of values this have to be converted (interface conversion
C++<=>UNO)
+ // indexes of values this have to be converted (interface conversion
C++<=>UNO)
int pTempCppIndexes[MAXPARAMS];
int pTempIndexes[MAXPARAMS];
int nTempIndexes = 0;
- // Type descriptions for reconversions
- typelib_TypeDescription *pTempParamTypeDescr[MAXPARAMS];
+ // type descriptions for reconversions
+ typelib_TypeDescription *pTempParamTD[MAXPARAMS];
- for ( int nPos = 0; nPos < nParams; ++nPos, ++nCppParamIndex )
+ for (int nPos = 0; nPos < nParams; ++nPos, ++nCppParamIndex)
{
const typelib_MethodParameter & rParam = pParams[nPos];
-
typelib_TypeDescription * pParamTD = nullptr;
TYPELIB_DANGER_GET( &pParamTD, rParam.pTypeRef );
- if ( !rParam.bOut &&
- bridges::cpp_uno::shared::isSimpleType( pParamTD ) )
+ if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType(pParamTD))
{
::uno_copyAndConvertData(
- &aCppParams[nCppParamIndex], pUnoArgs[nPos], pParamTD,
+ &aCppArgs[nCppParamIndex], pUnoArgs[nPos], pParamTD,
pThis->getBridge()->getUno2Cpp() );
- // No longer needed
+ // no longer needed
TYPELIB_DANGER_RELEASE( pParamTD );
}
- else // Ptr to complex value | ref
+ else // ptr to complex value | ref
{
- if ( !rParam.bIn ) // Is pure out
+ if (!rParam.bIn) // Is pure out
{
// C++ out is constructed mem, UNO out is not!
::uno_constructData(
- aCppParams[nCppParamIndex].p = alloca( pParamTD->nSize ),
+ aCppArgs[nCppParamIndex].p = alloca( pParamTD->nSize ),
pParamTD );
pTempCppIndexes[nTempIndexes] = nCppParamIndex;
- pTempIndexes[nTempIndexes] = nPos;
- // Will be released at reconversion
- pTempParamTypeDescr[nTempIndexes++] = pParamTD;
+ // default constructed for C++ call
+ pTempIndexes[nTempIndexes] = nPos;
+ // will be released at reconversion
+ pTempParamTD[nTempIndexes++] = pParamTD;
}
- // Is in/inout
- else if ( bridges::cpp_uno::shared::relatesToInterfaceType(
pParamTD ) )
+ // is in/inout
+ else if
(bridges::cpp_uno::shared::relatesToInterfaceType(pParamTD))
{
::uno_copyAndConvertData(
- aCppParams[nCppParamIndex].p = alloca( pParamTD->nSize ),
+ aCppArgs[nCppParamIndex].p = alloca( pParamTD->nSize ),
pUnoArgs[nPos], pParamTD,
pThis->getBridge()->getUno2Cpp() );
pTempCppIndexes[nTempIndexes] = nCppParamIndex;
+
+ // has to be reconverted
pTempIndexes[nTempIndexes] = nPos;
- // Will be released at reconversion
- pTempParamTypeDescr[nTempIndexes++] = pParamTD;
+ // will be released at reconversion
+ pTempParamTD[nTempIndexes++] = pParamTD;
}
else // direct way
{
- aCppParams[nCppParamIndex].p = pUnoArgs[nPos];
-
- // No longer needed
+ aCppArgs[nCppParamIndex].p = pUnoArgs[nPos];
+ // no longer needed
TYPELIB_DANGER_RELEASE( pParamTD );
}
}
@@ -202,85 +202,85 @@ bool cpp_call(
(pReturnTD->eTypeClass == typelib_TypeClass_FLOAT ||
pReturnTD->eTypeClass == typelib_TypeClass_DOUBLE) )
uRetVal.d =
- pFMethod (aCppParams[0].i, aCppParams[1].d, aCppParams[2].d,
aCppParams[3].d,
- aCppParams[4].i, aCppParams[5].i, aCppParams[6].i,
aCppParams[7].i,
- aCppParams[8].i, aCppParams[9].i, aCppParams[10].i,
aCppParams[11].i,
- aCppParams[12].i, aCppParams[13].i,
aCppParams[14].i, aCppParams[15].i,
- aCppParams[16].i, aCppParams[17].i,
aCppParams[18].i, aCppParams[19].i,
- aCppParams[20].i, aCppParams[21].i,
aCppParams[22].i, aCppParams[23].i,
- aCppParams[24].i, aCppParams[25].i,
aCppParams[26].i, aCppParams[27].i,
- aCppParams[28].i, aCppParams[29].i,
aCppParams[30].i, aCppParams[31].i );
+ pFMethod (aCppArgs[0].i, aCppArgs[1].d, aCppArgs[2].d,
aCppArgs[3].d,
+ aCppArgs[4].i, aCppArgs[5].i, aCppArgs[6].i,
aCppArgs[7].i,
+ aCppArgs[8].i, aCppArgs[9].i, aCppArgs[10].i,
aCppArgs[11].i,
+ aCppArgs[12].i, aCppArgs[13].i, aCppArgs[14].i,
aCppArgs[15].i,
+ aCppArgs[16].i, aCppArgs[17].i, aCppArgs[18].i,
aCppArgs[19].i,
+ aCppArgs[20].i, aCppArgs[21].i, aCppArgs[22].i,
aCppArgs[23].i,
+ aCppArgs[24].i, aCppArgs[25].i, aCppArgs[26].i,
aCppArgs[27].i,
+ aCppArgs[28].i, aCppArgs[29].i, aCppArgs[30].i,
aCppArgs[31].i );
else
uRetVal.i =
- pIMethod (aCppParams[0].i, aCppParams[1].d, aCppParams[2].d,
aCppParams[3].d,
- aCppParams[4].i, aCppParams[5].i, aCppParams[6].i,
aCppParams[7].i,
- aCppParams[8].i, aCppParams[9].i, aCppParams[10].i,
aCppParams[11].i,
- aCppParams[12].i, aCppParams[13].i,
aCppParams[14].i, aCppParams[15].i,
- aCppParams[16].i, aCppParams[17].i,
aCppParams[18].i, aCppParams[19].i,
- aCppParams[20].i, aCppParams[21].i,
aCppParams[22].i, aCppParams[23].i,
- aCppParams[24].i, aCppParams[25].i,
aCppParams[26].i, aCppParams[27].i,
- aCppParams[28].i, aCppParams[29].i,
aCppParams[30].i, aCppParams[31].i );
+ pIMethod (aCppArgs[0].i, aCppArgs[1].d, aCppArgs[2].d,
aCppArgs[3].d,
+ aCppArgs[4].i, aCppArgs[5].i, aCppArgs[6].i,
aCppArgs[7].i,
+ aCppArgs[8].i, aCppArgs[9].i, aCppArgs[10].i,
aCppArgs[11].i,
+ aCppArgs[12].i, aCppArgs[13].i, aCppArgs[14].i,
aCppArgs[15].i,
+ aCppArgs[16].i, aCppArgs[17].i, aCppArgs[18].i,
aCppArgs[19].i,
+ aCppArgs[20].i, aCppArgs[21].i, aCppArgs[22].i,
aCppArgs[23].i,
+ aCppArgs[24].i, aCppArgs[25].i, aCppArgs[26].i,
aCppArgs[27].i,
+ aCppArgs[28].i, aCppArgs[29].i, aCppArgs[30].i,
aCppArgs[31].i );
}
__except (CPPU_CURRENT_NAMESPACE::mscx_filterCppException(
GetExceptionInformation(),
*ppUnoExc, pThis->getBridge()->getCpp2Uno() ))
{
- // *ppUnoExc was constructed by filter function.
- // Temporary params
- while ( nTempIndexes-- )
+ // *ppUnoExc was constructed by filter function
+ // temporary params
+ while (nTempIndexes--)
{
int nCppIndex = pTempCppIndexes[nTempIndexes];
- // Destroy temp C++ param => C++: every param was constructed
+ // destroy temp C++ param => C++: every param was constructed
::uno_destructData(
- aCppParams[nCppIndex].p, pTempParamTypeDescr[nTempIndexes],
- cpp_release );
- TYPELIB_DANGER_RELEASE( pTempParamTypeDescr[nTempIndexes] );
+ aCppArgs[nCppIndex].p, pTempParamTD[nTempIndexes],
+ uno::cpp_release );
+ TYPELIB_DANGER_RELEASE( pTempParamTD[nTempIndexes] );
}
- // Return type
- if ( pReturnTD )
+
+ // return type
+ if (pReturnTD)
TYPELIB_DANGER_RELEASE( pReturnTD );
- // End here
return true;
}
- // No exception occurred
+ // NO exception occurred
*ppUnoExc = nullptr;
- // Reconvert temporary params
- while ( nTempIndexes-- )
+ // reconvert temporary params
+ while (nTempIndexes--)
{
int nCppIndex = pTempCppIndexes[nTempIndexes];
int nIndex = pTempIndexes[nTempIndexes];
typelib_TypeDescription * pParamTD =
- pTempParamTypeDescr[nTempIndexes];
+ pTempParamTD[nTempIndexes];
- if ( pParams[nIndex].bIn )
+ if (pParams[nIndex].bIn)
{
- if ( pParams[nIndex].bOut ) // Inout
+ if (pParams[nIndex].bOut) // inout
{
::uno_destructData(
- pUnoArgs[nIndex], pParamTD, nullptr ); // Destroy UNO value
+ pUnoArgs[nIndex], pParamTD, nullptr ); // destroy UNO value
::uno_copyAndConvertData(
- pUnoArgs[nIndex], aCppParams[nCppIndex].p, pParamTD,
+ pUnoArgs[nIndex], aCppArgs[nCppIndex].p, pParamTD,
pThis->getBridge()->getCpp2Uno() );
}
}
- else // Pure out
+ else // pure out
{
::uno_copyAndConvertData(
- pUnoArgs[nIndex], aCppParams[nCppIndex].p, pParamTD,
+ pUnoArgs[nIndex], aCppArgs[nCppIndex].p, pParamTD,
pThis->getBridge()->getCpp2Uno() );
}
- // Destroy temp C++ param => C++: every param was constructed
+ // destroy temp C++ param => C++: every param was constructed
::uno_destructData(
- aCppParams[nCppIndex].p, pParamTD, cpp_release );
+ aCppArgs[nCppIndex].p, pParamTD, uno::cpp_release );
TYPELIB_DANGER_RELEASE( pParamTD );
}
- // Return value
+ // return value
switch (retKind) {
case ReturnKind::Void:
break;
@@ -291,22 +291,23 @@ bool cpp_call(
assert(uRetVal.p == pUnoReturn);
break;
case ReturnKind::ComplexConvert:
- assert(uRetVal.p == aCppParams[1].p);
+ assert(uRetVal.p == aCppArgs[1].p);
::uno_copyAndConvertData(
pUnoReturn, uRetVal.p, pReturnTD,
pThis->getBridge()->getCpp2Uno() );
::uno_destructData(
- uRetVal.p, pReturnTD, cpp_release );
+ uRetVal.p, pReturnTD, uno::cpp_release );
break;
}
+ // return type
if ( pReturnTD )
TYPELIB_DANGER_RELEASE( pReturnTD );
return true;
}
-}
+} // namespace
namespace bridges::cpp_uno::shared {
@@ -340,7 +341,7 @@ void unoInterfaceProxyDispatch(
pMemberTD)));
if ( pReturn )
{
- // Is GET
+ // is GET
cpp_call(
pThis, aVtableSlot,
reinterpret_cast<typelib_InterfaceAttributeTypeDescription
const *>(pMemberTD)->pAttributeTypeRef,
@@ -349,7 +350,7 @@ void unoInterfaceProxyDispatch(
}
else
{
- // Is SET
+ // is SET
typelib_MethodParameter aParam;
aParam.pTypeRef =
reinterpret_cast<typelib_InterfaceAttributeTypeDescription
const *>(pMemberTD)->pAttributeTypeRef;
@@ -388,19 +389,18 @@ void unoInterfaceProxyDispatch(
switch (aVtableSlot.index)
{
- // Standard calls
- case 1: // Acquire UNO interface
+ case 1: // acquire UNO interface
(*pUnoI->acquire)( pUnoI );
*ppException = nullptr;
break;
- case 2: // Release UNO interface
+ case 2: // release UNO interface
(*pUnoI->release)( pUnoI );
*ppException = nullptr;
break;
case 0: // queryInterface() opt
{
typelib_TypeDescription * pTD = nullptr;
- TYPELIB_DANGER_GET( &pTD, static_cast< Type * >( pArgs[0]
)->getTypeLibType() );
+ TYPELIB_DANGER_GET( &pTD, static_cast< uno::Type * >( pArgs[0]
)->getTypeLibType() );
if ( pTD )
{
@@ -415,9 +415,7 @@ void unoInterfaceProxyDispatch(
static_cast< uno_Any * >( pReturn ),
&pInterface, pTD, nullptr );
(*pInterface->release)( pInterface );
-
TYPELIB_DANGER_RELEASE( pTD );
-
*ppException = nullptr;
break;
}
@@ -426,28 +424,27 @@ void unoInterfaceProxyDispatch(
[[fallthrough]]; // else perform queryInterface()
}
default:
- if ( ! cpp_call(
- pThis, aVtableSlot,
- reinterpret_cast<typelib_InterfaceMethodTypeDescription
const *>(pMemberTD)->pReturnTypeRef,
- reinterpret_cast<typelib_InterfaceMethodTypeDescription
const *>(pMemberTD)->nParams,
- reinterpret_cast<typelib_InterfaceMethodTypeDescription
const *>(pMemberTD)->pParams,
- pReturn, pArgs, ppException ) )
+ typelib_InterfaceMethodTypeDescription const* pMethodTD
+ = reinterpret_cast<typelib_InterfaceMethodTypeDescription
const *>(pMemberTD);
+
+ if (!cpp_call(pThis, aVtableSlot, pMethodTD->pReturnTypeRef,
pMethodTD->nParams,
+ pMethodTD->pParams, pReturn, pArgs, ppException))
{
- RuntimeException aExc( "Too many parameters!" );
+ uno::RuntimeException aExc( "Too many parameters!" );
- Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
- ::uno_type_any_construct( *ppException, &aExc,
rExcType.getTypeLibType(), nullptr );
+ uno::Type const & rExcType =
cppu::UnoType<decltype(aExc)>::get();
+ ::uno_type_any_construct(*ppException, &aExc,
rExcType.getTypeLibType(), nullptr);
}
}
break;
}
default:
{
- RuntimeException aExc( "Illegal member type description!" );
+ uno::RuntimeException aExc("Illegal member type description!",
uno::Reference<uno::XInterface>());
- Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
- // Binary identical null reference (whatever that comment means...)
- ::uno_type_any_construct( *ppException, &aExc,
rExcType.getTypeLibType(), nullptr );
+ uno::Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
+ // binary identical null reference
+ ::uno_type_any_construct(*ppException, &aExc,
rExcType.getTypeLibType(), nullptr);
}
}
}
_______________________________________________
Libreoffice-commits mailing list
libreoffice-comm...@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/libreoffice-commits
