351 lines
14 KiB
C++
351 lines
14 KiB
C++
/* -*- 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 .
|
|
*/
|
|
|
|
#include <malloc.h>
|
|
|
|
#include <com/sun/star/uno/genfunc.hxx>
|
|
#include <sal/log.hxx>
|
|
#include <uno/data.h>
|
|
#include <typelib/typedescription.hxx>
|
|
|
|
#include <bridge.hxx>
|
|
#include <cppinterfaceproxy.hxx>
|
|
#include <types.hxx>
|
|
#include <vtablefactory.hxx>
|
|
|
|
#include <msvc/except.hxx>
|
|
#include <msvc/cpp2uno.hxx>
|
|
|
|
using namespace ::com::sun::star;
|
|
|
|
static typelib_TypeClass
|
|
cpp2uno_call(bridges::cpp_uno::shared::CppInterfaceProxy* pThis,
|
|
const typelib_TypeDescription* pMemberTD,
|
|
typelib_TypeDescriptionReference* pReturnTypeRef, // nullptr indicates void return
|
|
const sal_Int32 nParams, typelib_MethodParameter* pParams, void** pCallStack,
|
|
void** const pReturnAddr)
|
|
{
|
|
// return type
|
|
typelib_TypeDescription* pReturnTD = nullptr;
|
|
if (pReturnTypeRef)
|
|
TYPELIB_DANGER_GET(&pReturnTD, pReturnTypeRef);
|
|
|
|
// if we don't return via register, the first stack parameter is the return value
|
|
int nFirstRealParam = 2;
|
|
if (pReturnAddr == pCallStack)
|
|
++nFirstRealParam;
|
|
|
|
void* pUnoReturn = nullptr;
|
|
// complex return ptr: if != nullptr && != pUnoReturn, reconversion needed
|
|
void* pCppReturn = nullptr;
|
|
|
|
if (pReturnTD)
|
|
{
|
|
if (bridges::cpp_uno::shared::isSimpleType(pReturnTD))
|
|
pUnoReturn = pReturnAddr;
|
|
else
|
|
{
|
|
pCppReturn = pCallStack[nFirstRealParam++];
|
|
pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType(pReturnTD)
|
|
? alloca(pReturnTD->nSize)
|
|
: pCppReturn);
|
|
}
|
|
}
|
|
|
|
// 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));
|
|
|
|
// TODO: switch to typedef std::pair<sal_Int32, typelib_TypeDescription*> ReconversationInfo;
|
|
sal_Int32 nTempIndex = 0;
|
|
// 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
|
|
typelib_TypeDescription** ppTempParamTD
|
|
= static_cast<typelib_TypeDescription**>(alloca(sizeof(void*) * nParams));
|
|
|
|
for (std::pair<sal_Int32, void**> p(0, pCallStack + nFirstRealParam); p.first < nParams;
|
|
++p.first, ++p.second)
|
|
{
|
|
const auto& nPos = p.first;
|
|
auto& pCppIncomingParams = p.second;
|
|
|
|
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))
|
|
{
|
|
pCppArgs[nPos] = pCppIncomingParams;
|
|
pUnoArgs[nPos] = pCppIncomingParams;
|
|
if (sizeof(void*) == sizeof(sal_Int32)) // account 64bit types on 32bit arch
|
|
{
|
|
switch (pParamTD->eTypeClass)
|
|
{
|
|
case typelib_TypeClass_HYPER:
|
|
case typelib_TypeClass_UNSIGNED_HYPER:
|
|
case typelib_TypeClass_DOUBLE:
|
|
++pCppIncomingParams;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
TYPELIB_DANGER_RELEASE(pParamTD);
|
|
}
|
|
else // ptr to complex value | ref
|
|
{
|
|
pCppArgs[nPos] = *pCppIncomingParams;
|
|
|
|
if (!rParam.bIn) // is pure out
|
|
{
|
|
// UNO out is unconstructed memory
|
|
pUnoArgs[nPos] = alloca(pParamTD->nSize);
|
|
// pParamTD will be released at reconversion
|
|
pTempIndexes[nTempIndex] = nPos;
|
|
ppTempParamTD[nTempIndex++] = pParamTD;
|
|
}
|
|
// is in/inout
|
|
else if (bridges::cpp_uno::shared::relatesToInterfaceType(pParamTD))
|
|
{
|
|
::uno_copyAndConvertData(pUnoArgs[nPos] = alloca(pParamTD->nSize),
|
|
*pCppIncomingParams, pParamTD,
|
|
pThis->getBridge()->getCpp2Uno());
|
|
// pParamTD will be released at reconversion
|
|
pTempIndexes[nTempIndex] = nPos;
|
|
ppTempParamTD[nTempIndex++] = pParamTD;
|
|
}
|
|
else // direct way
|
|
{
|
|
pUnoArgs[nPos] = *pCppIncomingParams;
|
|
TYPELIB_DANGER_RELEASE(pParamTD);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ExceptionHolder
|
|
uno_Any aUnoExc; // Any will be constructed by callee
|
|
uno_Any* pUnoExc = &aUnoExc;
|
|
|
|
// invoke UNO dispatch call
|
|
pThis->getUnoI()->pDispatcher(pThis->getUnoI(), pMemberTD, pUnoReturn, pUnoArgs, &pUnoExc);
|
|
|
|
// in case an exception occurred...
|
|
if (pUnoExc)
|
|
{
|
|
// destruct temporary in/inout params
|
|
while (nTempIndex--)
|
|
{
|
|
const sal_Int32 nIndex = pTempIndexes[nTempIndex];
|
|
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);
|
|
|
|
msvc_raiseException(&aUnoExc, pThis->getBridge()->getUno2Cpp()); // has to destruct the any
|
|
}
|
|
else // no exception occurred...
|
|
{
|
|
// handle temporary params
|
|
while (nTempIndex--)
|
|
{
|
|
const sal_Int32 nIndex = pTempIndexes[nTempIndex];
|
|
typelib_TypeDescription* pParamTD = ppTempParamTD[nTempIndex];
|
|
|
|
if (pParams[nIndex].bOut) // inout/out
|
|
{
|
|
// convert and assign
|
|
::uno_destructData(pCppArgs[nIndex], pParamTD, uno::cpp_release);
|
|
::uno_copyAndConvertData(pCppArgs[nIndex], pUnoArgs[nIndex], pParamTD,
|
|
pThis->getBridge()->getUno2Cpp());
|
|
}
|
|
// destroy temp UNO param
|
|
::uno_destructData(pUnoArgs[nIndex], pParamTD, nullptr);
|
|
|
|
TYPELIB_DANGER_RELEASE(pParamTD);
|
|
}
|
|
|
|
// handle return
|
|
if (pCppReturn) // has complex return
|
|
{
|
|
if (pUnoReturn != pCppReturn) // needs reconversion
|
|
{
|
|
::uno_copyAndConvertData(pCppReturn, pUnoReturn, pReturnTD,
|
|
pThis->getBridge()->getUno2Cpp());
|
|
// destroy temp UNO return
|
|
::uno_destructData(pUnoReturn, pReturnTD, nullptr);
|
|
}
|
|
*pReturnAddr = pCppReturn;
|
|
}
|
|
|
|
if (!pReturnTD)
|
|
return typelib_TypeClass_VOID;
|
|
else
|
|
{
|
|
typelib_TypeClass eRet = pReturnTD->eTypeClass;
|
|
TYPELIB_DANGER_RELEASE(pReturnTD);
|
|
return eRet;
|
|
}
|
|
}
|
|
}
|
|
|
|
typelib_TypeClass __cdecl cpp_mediate(void** pCallStack, const sal_Int32 nFunctionIndex,
|
|
const sal_Int32 nVtableOffset,
|
|
sal_Int64* const pRegisterReturn)
|
|
{
|
|
// pCallStack:
|
|
// x64: ret value, ret adr, this, [complex ret *], cpp params
|
|
// x86: ret adr, this, [complex ret *], cpp params
|
|
//
|
|
// pRegisterReturn is just set on x86
|
|
// the return value is either the direct set for simply types, or it is set
|
|
// to "complex ret *" and the real return value is constructed at that memory.
|
|
|
|
// if we don't return via register, the first stack parameter is the return value
|
|
void** const pReturnAddr
|
|
= pRegisterReturn ? reinterpret_cast<void**>(pRegisterReturn) : pCallStack;
|
|
|
|
void* const pThis = static_cast<char*>(pCallStack[pRegisterReturn ? 1 : 2]) - nVtableOffset;
|
|
bridges::cpp_uno::shared::CppInterfaceProxy* pCppI
|
|
= bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(pThis);
|
|
|
|
typelib_InterfaceTypeDescription* pInterfaceTD = pCppI->getTypeDescr();
|
|
|
|
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 >= pInterfaceTD->nMapFunctionIndexToMemberIndex)
|
|
{
|
|
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, static_cast<uno::XInterface*>(pThis));
|
|
}
|
|
|
|
// determine called method
|
|
sal_Int32 nMemberPos = pInterfaceTD->pMapFunctionIndexToMemberIndex[nFunctionIndex];
|
|
assert(nMemberPos < pInterfaceTD->nAllMembers);
|
|
|
|
uno::TypeDescription aMemberDescr(pInterfaceTD->ppAllMembers[nMemberPos]);
|
|
|
|
SAL_INFO("bridges", "Calling " << OUString::unacquired(&aMemberDescr.get()->pTypeName));
|
|
|
|
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;
|
|
|
|
if (pInterfaceTD->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex)
|
|
{ // is GET method
|
|
eRet = cpp2uno_call(pCppI, aMemberDescr.get(), pAttrTypeRef, 0, nullptr, pCallStack,
|
|
pReturnAddr);
|
|
}
|
|
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,
|
|
pReturnAddr);
|
|
}
|
|
break;
|
|
}
|
|
case typelib_TypeClass_INTERFACE_METHOD:
|
|
{
|
|
// is METHOD
|
|
switch (nFunctionIndex)
|
|
{
|
|
// 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
|
|
{
|
|
const unsigned int nCppStackPos = (pReturnAddr == pCallStack) ? 4 : 3;
|
|
typelib_TypeDescription* pQueryTD = nullptr;
|
|
TYPELIB_DANGER_GET(
|
|
&pQueryTD,
|
|
static_cast<uno::Type*>(pCallStack[nCppStackPos])->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)
|
|
{
|
|
const unsigned int nReturnAddrPos = nCppStackPos - 1;
|
|
::uno_any_construct(static_cast<uno_Any*>(pCallStack[nReturnAddrPos]),
|
|
&pInterface, pQueryTD, uno::cpp_acquire);
|
|
pInterface->release();
|
|
TYPELIB_DANGER_RELEASE(pQueryTD);
|
|
|
|
*pReturnAddr = pCallStack[nReturnAddrPos];
|
|
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,
|
|
pReturnAddr);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
throw uno::RuntimeException("no member description found!",
|
|
static_cast<uno::XInterface*>(pThis));
|
|
}
|
|
|
|
return eRet;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|