cppuhelper/source/exc_thrower.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <rtl/instance.hxx>
  22 #include <osl/diagnose.h>
  23 #include <uno/dispatcher.hxx>
  24 #include <uno/lbnames.h>
  25 #include <uno/mapping.hxx>
  26 #include <cppuhelper/detail/XExceptionThrower.hpp>
  27 #include <com/sun/star/uno/RuntimeException.hpp>
  28
  29 #include <cppuhelper/exc_hlp.hxx>
  30
  31 #ifdef IOS
  32 #include <ios/ios.hxx>
  33 #endif
  34
  35 using namespace ::osl;
  36 using namespace ::cppu;
  37 using namespace ::com::sun::star;
  38 using namespace ::com::sun::star::uno;
  39
  40 namespace
  41 {
  42
  43 using cppuhelper::detail::XExceptionThrower;
  44
  45
  46 struct ExceptionThrower : public uno_Interface, XExceptionThrower
  47 {
  48     ExceptionThrower();
  49
  50     virtual ~ExceptionThrower() {}
  51
  52     static Type const & getCppuType()
  53     {
  54         return cppu::UnoType<XExceptionThrower>::get();
  55     }
  56
  57     // XInterface
  58     virtual Any SAL_CALL queryInterface( Type const & type ) override;
  59     virtual void SAL_CALL acquire() throw () override;
  60     virtual void SAL_CALL release() throw () override;
  61
  62     // XExceptionThrower
  63     virtual void SAL_CALL throwException( Any const & exc ) override;
  64     virtual void SAL_CALL rethrowException() override;
  65 };
  66
  67 extern "C"
  68 {
  69
  70
  71 void ExceptionThrower_acquire_release_nop(
  72     SAL_UNUSED_PARAMETER uno_Interface * )
  73 {}
  74
  75
  76 void ExceptionThrower_dispatch(
  77     uno_Interface * pUnoI, typelib_TypeDescription const * pMemberType,
  78     void * pReturn, void * pArgs [], uno_Any ** ppException )
  79 {
  80     OSL_ASSERT( pMemberType->eTypeClass == typelib_TypeClass_INTERFACE_METHOD );
  81
  82     switch (reinterpret_cast< typelib_InterfaceMemberTypeDescription * >(
  83                 const_cast< typelib_TypeDescription * >( pMemberType ) )->
  84             nPosition)
  85     {
  86     case 0: // queryInterface()
  87     {
  88         Type const & rType_demanded =
  89             *static_cast< Type const * >( pArgs[ 0 ] );
  90         if (rType_demanded.equals( cppu::UnoType<XInterface>::get() ) ||
  91             rType_demanded.equals( ExceptionThrower::getCppuType() ))
  92         {
  93             typelib_TypeDescription * pTD = nullptr;
  94             TYPELIB_DANGER_GET( &pTD, rType_demanded.getTypeLibType() );
  95             uno_any_construct(
  96                 static_cast< uno_Any * >( pReturn ), &pUnoI, pTD, nullptr );
  97             TYPELIB_DANGER_RELEASE( pTD );
  98         }
  99         else
 100         {
 101             uno_any_construct(
 102                 static_cast< uno_Any * >( pReturn ), nullptr, nullptr, nullptr );
 103         }
 104         *ppException = nullptr;
 105         break;
 106     }
 107     case 1: // acquire()
 108     case 2: // release()
 109         *ppException = nullptr;
 110         break;
 111     case 3: // throwException()
 112     {
 113         uno_Any * pAny = static_cast< uno_Any * >( pArgs[ 0 ] );
 114         OSL_ASSERT( pAny->pType->eTypeClass == typelib_TypeClass_EXCEPTION );
 115         uno_type_any_construct( *ppException, pAny->pData, pAny->pType, nullptr );
 116         break;
 117     }
 118     default:
 119     {
 120         OSL_ASSERT( false );
 121         RuntimeException exc( "not implemented!" );
 122         uno_type_any_construct(
 123             *ppException, &exc, cppu::UnoType<decltype(exc)>::get().getTypeLibType(), nullptr );
 124         break;
 125     }
 126     }
 127 }
 128
 129 } // extern "C"
 130
 131
 132 Any ExceptionThrower::queryInterface( Type const & type )
 133 {
 134     if (type.equals( cppu::UnoType<XInterface>::get() ) ||
 135         type.equals( ExceptionThrower::getCppuType() ))
 136     {
 137         XExceptionThrower * that = this;
 138         return Any( &that, type );
 139     }
 140     return Any();
 141 }
 142
 143
 144 void ExceptionThrower::acquire() throw ()
 145 {
 146 }
 147
 148 void ExceptionThrower::release() throw ()
 149 {
 150 }
 151
 152
 153 void ExceptionThrower::throwException( Any const & exc )
 154 {
 155     OSL_FAIL( "unexpected!" );
 156     cppu::throwException( exc );
 157 }
 158
 159
 160 void ExceptionThrower::rethrowException()
 161 {
 162     throw;
 163 }
 164
 165
 166 ExceptionThrower::ExceptionThrower()
 167 {
 168     uno_Interface::acquire = ExceptionThrower_acquire_release_nop;
 169     uno_Interface::release = ExceptionThrower_acquire_release_nop;
 170     uno_Interface::pDispatcher = ExceptionThrower_dispatch;
 171 }
 172
 173 class theExceptionThrower : public rtl::Static<ExceptionThrower, theExceptionThrower> {};
 174
 175 } // anonymous namespace
 176
 177
 178 namespace cppu
 179 {
 180
 181
 182 void SAL_CALL throwException( Any const & exc )
 183 {
 184     if (exc.getValueTypeClass() != TypeClass_EXCEPTION)
 185     {
 186         throw RuntimeException(
 187             "no UNO exception given "
 188             "(must be derived from com::sun::star::uno::Exception)!" );
 189     }
 190
 191 #ifdef IOS
 192     lo_ios_throwException(exc);
 193 #else
 194     Mapping uno2cpp(Environment(UNO_LB_UNO), Environment::getCurrent());
 195     if (! uno2cpp.is())
 196     {
 197         throw RuntimeException(
 198             "cannot get binary UNO to C++ mapping!" );
 199     }
 200
 201     Reference< XExceptionThrower > xThrower;
 202     uno2cpp.mapInterface(
 203         reinterpret_cast< void ** >( &xThrower ),
 204         static_cast< uno_Interface * >( &theExceptionThrower::get() ),
 205         ExceptionThrower::getCppuType() );
 206     OSL_ASSERT( xThrower.is() );
 207     xThrower->throwException( exc );
 208 #endif
 209 }
 210
 211
 212 Any SAL_CALL getCaughtException()
 213 {
 214     Mapping cpp2uno(Environment::getCurrent(), Environment(UNO_LB_UNO));
 215     if (! cpp2uno.is())
 216     {
 217         throw RuntimeException(
 218             "cannot get C++ to binary UNO mapping!" );
 219     }
 220     Mapping uno2cpp(Environment(UNO_LB_UNO), Environment::getCurrent());
 221     if (! uno2cpp.is())
 222     {
 223         throw RuntimeException(
 224             "cannot get binary UNO to C++ mapping!" );
 225     }
 226
 227     typelib_TypeDescription * pTD = nullptr;
 228     TYPELIB_DANGER_GET(
 229         &pTD, ExceptionThrower::getCppuType().getTypeLibType() );
 230
 231     UnoInterfaceReference unoI;
 232     cpp2uno.mapInterface(
 233         reinterpret_cast< void ** >( &unoI.m_pUnoI ),
 234         static_cast< XExceptionThrower * >( &theExceptionThrower::get() ), pTD );
 235     OSL_ASSERT( unoI.is() );
 236
 237     typelib_TypeDescription * pMemberTD = nullptr;
 238     TYPELIB_DANGER_GET(
 239         &pMemberTD,
 240         reinterpret_cast< typelib_InterfaceTypeDescription * >( pTD )->
 241         ppMembers[ 1 ] /* rethrowException() */ );
 242
 243     uno_Any exc_mem;
 244     uno_Any * exc = &exc_mem;
 245     unoI.dispatch( pMemberTD, nullptr, nullptr, &exc );
 246
 247     TYPELIB_DANGER_RELEASE( pMemberTD );
 248     TYPELIB_DANGER_RELEASE( pTD );
 249
 250     if (exc == nullptr)
 251     {
 252         throw RuntimeException( "rethrowing C++ exception failed!" );
 253     }
 254
 255     Any ret;
 256     uno_any_destruct( &ret, reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
 257     uno_type_any_constructAndConvert(
 258         &ret, exc->pData, exc->pType, uno2cpp.get() );
 259     uno_any_destruct( exc, nullptr );
 260     return ret;
 261 }
 262
 263 }
 264
 265 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */