cli_ure/source/uno_bridge/cli_uno.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 #include <sal/alloca.h>
  21 #include "rtl/ustrbuf.hxx"
  22 #include "cli_base.h"
  23 #include "cli_bridge.h"
  24
  25 namespace sr=System::Reflection;
  26
  27
  28 namespace cli_uno
  29 {
  30
  31 union largest
  32 {
  33     sal_Int64 n;
  34     double d;
  35     void * p;
  36     uno_Any a;
  37 };
  38
  39 System::Object^ Bridge::call_uno(uno_Interface * pUnoI,
  40                       typelib_TypeDescription* member_td,
  41                       typelib_TypeDescriptionReference * return_type,
  42                       sal_Int32 nParams, typelib_MethodParameter const * pParams,
  43                       array<System::Object^>^ args, array<System::Type^>^ argTypes,
  44                       System::Object^* ppExc) const
  45 {
  46     // return mem
  47     sal_Int32 return_size = sizeof (largest);
  48     if ((0 != return_type) &&
  49         (typelib_TypeClass_STRUCT == return_type->eTypeClass ||
  50          typelib_TypeClass_EXCEPTION == return_type->eTypeClass))
  51     {
  52         TypeDescr return_td( return_type );
  53         if (return_td.get()->nSize > sizeof (largest))
  54             return_size = return_td.get()->nSize;
  55     }
  56     //Prepare memory that contains all converted arguments and return valuse
  57     //The memory block contains first pointers to the arguments which are in the same block
  58     // For example, 2 arguments, 1 ret.
  59     //
  60     //      | Pointer
  61     //      | Pointer
  62     //      | Return value
  63     //      | Arg 1
  64     //      | Arg 2
  65     //
  66     // If an argument is larger then union largest, such as some structures, then the pointer
  67     // points to an extra block of memory. The same goes for a big return value.
  68
  69     char * mem = (char *)alloca(
  70         (nParams * sizeof (void *)) + return_size + (nParams * sizeof (largest)) );
  71     //array of pointers to args
  72     void ** uno_args = (void **)mem;
  73     //If an attribute is set, then uno_ret must be null, e.g void setAttribute(int )
  74     void * uno_ret= NULL;
  75     if ( !(member_td->eTypeClass == typelib_TypeClass_INTERFACE_ATTRIBUTE && nParams == 1))
  76         uno_ret = (mem + (nParams * sizeof (void *)));
  77     largest * uno_args_mem = (largest *)(mem + (nParams * sizeof (void *)) + return_size);
  78
  79     OSL_ASSERT( (0 == nParams) || (nParams == args->Length) );
  80     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
  81     {
  82         typelib_MethodParameter const & param = pParams[ nPos ];
  83         typelib_TypeDescriptionReference * type = param.pTypeRef;
  84
  85         uno_args[ nPos ] = &uno_args_mem[ nPos ];
  86         if (typelib_TypeClass_STRUCT == type->eTypeClass ||
  87             typelib_TypeClass_EXCEPTION == type->eTypeClass)
  88         {
  89             TypeDescr td( type );
  90             if (td.get()->nSize > sizeof (largest))
  91                 uno_args[ nPos ] = alloca( td.get()->nSize );
  92         }
  93
  94         if (param.bIn)
  95         {
  96             try
  97             {
  98                 // in, in/out params
  99                 map_to_uno(
 100                     uno_args[ nPos ],args[nPos] , type, false /* no assign */);
 101             }
 102             catch (...)
 103             {
 104                 // cleanup uno in args
 105                 for (sal_Int32 n = 0; n < nPos; ++n)
 106                 {
 107                     typelib_MethodParameter const & param = pParams[n];
 108                     if (param.bIn)
 109                     {
 110                         uno_type_destructData(uno_args[n], param.pTypeRef, 0);
 111                     }
 112                 }
 113                 throw;
 114             }
 115         }
 116     }
 117     uno_Any uno_exc_holder;
 118     uno_Any * uno_exc = &uno_exc_holder;
 119     // call binary uno
 120
 121     (*pUnoI->pDispatcher)( pUnoI, member_td, uno_ret, uno_args, &uno_exc );
 122
 123     if (0 == uno_exc)
 124     {
 125         // convert out args; destruct uno args
 126         for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
 127         {
 128             typelib_MethodParameter const & param = pParams[ nPos ];
 129             typelib_TypeDescriptionReference * type = param.pTypeRef;
 130             if (param.bOut)
 131             {
 132                 try
 133                 {
 134                     pin_ptr<System::Object^> ptr = &args[nPos];
 135                     map_to_cli(
 136                         ptr, uno_args[nPos], param.pTypeRef,
 137                         argTypes != nullptr ? argTypes[nPos] : nullptr, false );
 138                 }
 139                 catch (...)
 140                 {
 141                     // cleanup further uno args
 142                     for ( sal_Int32 n = nPos; n < nParams; ++n )
 143                     {
 144                         uno_type_destructData( uno_args[n], pParams[n].pTypeRef, 0 );
 145                     }
 146                     // cleanup uno return value
 147                     uno_type_destructData( uno_ret, return_type, 0 );
 148                     throw;
 149                 }
 150             }
 151             //cleanup args
 152             if (typelib_TypeClass_DOUBLE < type->eTypeClass &&
 153                 typelib_TypeClass_ENUM != type->eTypeClass) // opt
 154             {
 155                 uno_type_destructData(uno_args[nPos], type, 0);
 156             }
 157         }
 158
 159         if ((0 != return_type) &&
 160             (typelib_TypeClass_VOID != return_type->eTypeClass))
 161         {
 162             // convert uno return value
 163             try
 164             {
 165                 System::Object^ cli_ret;
 166                  map_to_cli(
 167                      &cli_ret, uno_ret, return_type, nullptr, false);
 168                  uno_type_destructData(uno_ret, return_type, 0);
 169                 return cli_ret;
 170             }
 171             catch (...)
 172             {
 173                 uno_type_destructData(uno_ret, return_type, 0);
 174                 throw;
 175             }
 176         }
 177         return nullptr; // void return
 178     }
 179     else // exception occurred
 180     {
 181         // destruct uno in args
 182         for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
 183         {
 184             typelib_MethodParameter const & param = pParams[ nPos ];
 185             if (param.bIn)
 186             {
 187                 uno_type_destructData( uno_args[ nPos ], param.pTypeRef, 0 );
 188             }
 189         }
 190         map_to_cli(ppExc, uno_exc_holder.pData,
 191                 uno_exc_holder.pType, nullptr, false);
 192         return nullptr;
 193     }
 194 }
 195
 196 void Bridge::call_cli(
 197     System::Object^ cliI,
 198     sr::MethodInfo^ method,
 199     typelib_TypeDescriptionReference * return_type,
 200     typelib_MethodParameter * params, int nParams,
 201     void * uno_ret, void * uno_args [], uno_Any ** uno_exc ) const
 202 {
 203     array<System::Object^>^ args=  gcnew array<System::Object^>(nParams);
 204     for (int nPos= 0; nPos < nParams; nPos++)
 205     {
 206         typelib_MethodParameter const & param= params[nPos];
 207         if (param.bIn)
 208         {
 209             pin_ptr<System::Object^> ptr = &args[nPos];
 210             map_to_cli( ptr,
 211                 uno_args[nPos], param.pTypeRef, nullptr, false);
 212         }
 213     }
 214     System::Object^ retInvoke= nullptr;
 215     try
 216     {
 217         retInvoke= method->Invoke(cliI, args);
 218     }
 219     catch (sr::TargetInvocationException^ e)
 220     {
 221         System::Exception^ exc= e->InnerException;
 222         css::uno::TypeDescription td(mapCliType(exc->GetType()));
 223         // memory for exception
 224         std::auto_ptr< rtl_mem > memExc(rtl_mem::allocate(td.get()->nSize));
 225         map_to_uno(memExc.get(), exc, td.get()->pWeakRef, false);
 226         (*uno_exc)->pType= td.get()->pWeakRef;
 227         (*uno_exc)->pData= memExc.release();
 228         return;
 229     }
 230     catch (System::Exception^ e)
 231     {
 232         OUStringBuffer buf( 128 );
 233         buf.append( "Unexpected exception during invocation of cli object. "
 234                     "Original message is: \n" );
 235         buf.append(mapCliString(e->Message));
 236         throw BridgeRuntimeError( buf.makeStringAndClear() );
 237     }
 238
 239     //convert out, in/out params
 240     for (int nPos = 0; nPos < nParams; ++nPos )
 241     {
 242         typelib_MethodParameter const & param = params[ nPos ];
 243
 244         if (param.bOut)
 245         {
 246             try
 247             {
 248                 map_to_uno(
 249                     uno_args[ nPos ], args[ nPos ], param.pTypeRef,
 250                          sal_True == param.bIn /* assign if inout */);
 251                      // out array
 252             }
 253             catch (...)
 254             {
 255                 // cleanup uno pure out
 256                 for ( sal_Int32 n = 0; n < nPos; ++n )
 257                 {
 258                     typelib_MethodParameter const & param = params[ n ];
 259                     if (! param.bIn)
 260                         uno_type_destructData( uno_args[ n ], param.pTypeRef, 0 );
 261                 }
 262                 throw;
 263             }
 264         }
 265     }
 266     // return value
 267     if (0 != return_type)
 268     {
 269         map_to_uno(
 270             uno_ret, retInvoke, return_type, false /* no assign */);
 271     }
 272     // no exception occurred
 273     *uno_exc = 0;
 274 }
 275
 276
 277
 278
 279 }
 280
 281 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */