From 940b4d1848e8c70ab7642901a68594e8016caffc Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 18:51:28 +0200 Subject: Adding upstream version 1:7.0.4. Signed-off-by: Daniel Baumann --- cppuhelper/source/exc_thrower.cxx | 312 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 312 insertions(+) create mode 100644 cppuhelper/source/exc_thrower.cxx (limited to 'cppuhelper/source/exc_thrower.cxx') diff --git a/cppuhelper/source/exc_thrower.cxx b/cppuhelper/source/exc_thrower.cxx new file mode 100644 index 000000000..7c40d12db --- /dev/null +++ b/cppuhelper/source/exc_thrower.cxx @@ -0,0 +1,312 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +using namespace ::osl; +using namespace ::cppu; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; + +namespace +{ + +using cppuhelper::detail::XExceptionThrower; + + +struct ExceptionThrower : public uno_Interface, XExceptionThrower +{ + ExceptionThrower(); + + virtual ~ExceptionThrower() {} + + static Type const & getCppuType() + { + return cppu::UnoType::get(); + } + + // XInterface + virtual Any SAL_CALL queryInterface( Type const & type ) override; + virtual void SAL_CALL acquire() throw () override; + virtual void SAL_CALL release() throw () override; + + // XExceptionThrower + virtual void SAL_CALL throwException( Any const & exc ) override; + virtual void SAL_CALL rethrowException() override; +}; + +extern "C" +{ + + +void ExceptionThrower_acquire_release_nop( + SAL_UNUSED_PARAMETER uno_Interface * ) +{} + + +void ExceptionThrower_dispatch( + uno_Interface * pUnoI, typelib_TypeDescription const * pMemberType, + void * pReturn, void * pArgs [], uno_Any ** ppException ) +{ + OSL_ASSERT( pMemberType->eTypeClass == typelib_TypeClass_INTERFACE_METHOD ); + + switch (reinterpret_cast< typelib_InterfaceMemberTypeDescription * >( + const_cast< typelib_TypeDescription * >( pMemberType ) )-> + nPosition) + { + case 0: // queryInterface() + { + Type const & rType_demanded = + *static_cast< Type const * >( pArgs[ 0 ] ); + if (rType_demanded.equals( cppu::UnoType::get() ) || + rType_demanded.equals( ExceptionThrower::getCppuType() )) + { + typelib_TypeDescription * pTD = nullptr; + TYPELIB_DANGER_GET( &pTD, rType_demanded.getTypeLibType() ); + uno_any_construct( + static_cast< uno_Any * >( pReturn ), &pUnoI, pTD, nullptr ); + TYPELIB_DANGER_RELEASE( pTD ); + } + else + { + uno_any_construct( + static_cast< uno_Any * >( pReturn ), nullptr, nullptr, nullptr ); + } + *ppException = nullptr; + break; + } + case 1: // acquire() + case 2: // release() + *ppException = nullptr; + break; + case 3: // throwException() + { + uno_Any * pAny = static_cast< uno_Any * >( pArgs[ 0 ] ); + OSL_ASSERT( pAny->pType->eTypeClass == typelib_TypeClass_EXCEPTION ); + uno_type_any_construct( *ppException, pAny->pData, pAny->pType, nullptr ); + break; + } + default: + { + OSL_ASSERT( false ); + RuntimeException exc( "not implemented!" ); + uno_type_any_construct( + *ppException, &exc, cppu::UnoType::get().getTypeLibType(), nullptr ); + break; + } + } +} + +} // extern "C" + + +Any ExceptionThrower::queryInterface( Type const & type ) +{ + if (type.equals( cppu::UnoType::get() ) || + type.equals( ExceptionThrower::getCppuType() )) + { + XExceptionThrower * that = this; + return Any( &that, type ); + } + return Any(); +} + + +void ExceptionThrower::acquire() throw () +{ +} + +void ExceptionThrower::release() throw () +{ +} + + +void ExceptionThrower::throwException( Any const & exc ) +{ + OSL_FAIL( "unexpected!" ); + cppu::throwException( exc ); +} + + +void ExceptionThrower::rethrowException() +{ + throw; +} + + +ExceptionThrower::ExceptionThrower() +{ + uno_Interface::acquire = ExceptionThrower_acquire_release_nop; + uno_Interface::release = ExceptionThrower_acquire_release_nop; + uno_Interface::pDispatcher = ExceptionThrower_dispatch; +} + +class theExceptionThrower : public rtl::Static {}; + +#if defined(IOS) || (defined(__aarch64__) && defined(ANDROID)) +// In the native iOS / Android app, where we don't have any Java, Python, +// BASIC, or other scripting, the only thing that would use the C++/UNO bridge +// functionality that invokes codeSnippet() was cppu::throwException(). +// +// codeSnippet() is part of what corresponds to the code that uses +// run-time-generated machine code on other platforms. We can't generate code +// at run-time on iOS, that has been known forever. +// +// Instead of digging in and trying to understand what is wrong, another +// solution was chosen. It turns out that the number of types of exception +// objects thrown by cppu::throwException() is fairly small. During startup of +// the LibreOffice code, and loading of an .odt document, only one kind of +// exception is thrown this way... (The lovely +// css::ucb:InteractiveAugmentedIOException.) +// +// So we can simply have code that checks what the type of object being thrown +// is, and explicitly throws such an object then with a normal C++ throw +// statement. Seems to work. +template void tryThrow(css::uno::Any const& aException) +{ + E aSpecificException; + if (aException >>= aSpecificException) + throw aSpecificException; +} + +void lo_mobile_throwException(css::uno::Any const& aException) +{ + assert(aException.getValueTypeClass() == css::uno::TypeClass_EXCEPTION); + + tryThrow(aException); + tryThrow(aException); + tryThrow(aException); + + SAL_WARN("cppuhelper", "lo_mobile_throwException: Unhandled exception type: " << aException.getValueTypeName()); + + assert(false); +} +#endif // defined(IOS) || (defined(__aarch64__) && defined(ANDROID)) + +} // anonymous namespace + + +namespace cppu +{ + + +void SAL_CALL throwException( Any const & exc ) +{ + if (exc.getValueTypeClass() != TypeClass_EXCEPTION) + { + throw RuntimeException( + "no UNO exception given " + "(must be derived from com::sun::star::uno::Exception)!" ); + } + +#if defined(IOS) || (defined(__aarch64__) && defined(ANDROID)) + lo_mobile_throwException(exc); +#else + Mapping uno2cpp(Environment(UNO_LB_UNO), Environment::getCurrent()); + if (! uno2cpp.is()) + { + throw RuntimeException( + "cannot get binary UNO to C++ mapping!" ); + } + + Reference< XExceptionThrower > xThrower; + uno2cpp.mapInterface( + reinterpret_cast< void ** >( &xThrower ), + static_cast< uno_Interface * >( &theExceptionThrower::get() ), + ExceptionThrower::getCppuType() ); + OSL_ASSERT( xThrower.is() ); + xThrower->throwException( exc ); +#endif +} + + +Any SAL_CALL getCaughtException() +{ +#if defined(__aarch64__) && defined(ANDROID) + // FIXME This stuff works on 32bit ARM, let's use the shortcut only for + // the 64bit ARM. + return Any(); +#else + Mapping cpp2uno(Environment::getCurrent(), Environment(UNO_LB_UNO)); + if (! cpp2uno.is()) + { + throw RuntimeException( + "cannot get C++ to binary UNO mapping!" ); + } + Mapping uno2cpp(Environment(UNO_LB_UNO), Environment::getCurrent()); + if (! uno2cpp.is()) + { + throw RuntimeException( + "cannot get binary UNO to C++ mapping!" ); + } + + typelib_TypeDescription * pTD = nullptr; + TYPELIB_DANGER_GET( + &pTD, ExceptionThrower::getCppuType().getTypeLibType() ); + + UnoInterfaceReference unoI; + cpp2uno.mapInterface( + reinterpret_cast< void ** >( &unoI.m_pUnoI ), + static_cast< XExceptionThrower * >( &theExceptionThrower::get() ), pTD ); + OSL_ASSERT( unoI.is() ); + + typelib_TypeDescription * pMemberTD = nullptr; + TYPELIB_DANGER_GET( + &pMemberTD, + reinterpret_cast< typelib_InterfaceTypeDescription * >( pTD )-> + ppMembers[ 1 ] /* rethrowException() */ ); + + uno_Any exc_mem; + uno_Any * exc = &exc_mem; + unoI.dispatch( pMemberTD, nullptr, nullptr, &exc ); + + TYPELIB_DANGER_RELEASE( pMemberTD ); + TYPELIB_DANGER_RELEASE( pTD ); + + if (exc == nullptr) + { + throw RuntimeException( "rethrowing C++ exception failed!" ); + } + + Any ret; + uno_any_destruct( &ret, reinterpret_cast< uno_ReleaseFunc >(cpp_release) ); + uno_type_any_constructAndConvert( + &ret, exc->pData, exc->pType, uno2cpp.get() ); + uno_any_destruct( exc, nullptr ); + return ret; +#endif +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3