pyuno/source/module/pyuno_callable.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 #include "pyuno_impl.hxx"
  20
  21 #include <osl/diagnose.h>
  22
  23 #include <com/sun/star/script/CannotConvertException.hpp>
  24 #include <com/sun/star/script/XInvocation2.hpp>
  25
  26 using com::sun::star::uno::Sequence;
  27 using com::sun::star::uno::Reference;
  28 using com::sun::star::uno::Any;
  29 using com::sun::star::uno::RuntimeException;
  30 using com::sun::star::script::XInvocation2;
  31
  32 namespace pyuno
  33 {
  34 struct PyUNO_callable_Internals
  35 {
  36     Reference<XInvocation2> xInvocation;
  37     OUString methodName;
  38     ConversionMode mode;
  39 };
  40
  41 struct PyUNO_callable
  42 {
  43     PyObject_HEAD
  44     PyUNO_callable_Internals* members;
  45 };
  46
  47 static void PyUNO_callable_del (PyObject* self)
  48 {
  49     PyUNO_callable* me;
  50
  51     me = reinterpret_cast<PyUNO_callable*>(self);
  52     delete me->members;
  53     PyObject_Del (self);
  54 }
  55
  56 static PyObject* PyUNO_callable_call(
  57     PyObject* self, PyObject* args, SAL_UNUSED_PARAMETER PyObject*)
  58 {
  59     PyUNO_callable* me;
  60
  61     Sequence<short> aOutParamIndex;
  62     Sequence<Any> aOutParam;
  63     Sequence<Any> aParams;
  64     Any any_params;
  65     Any ret_value;
  66     RuntimeCargo *cargo = nullptr;
  67     me = reinterpret_cast<PyUNO_callable*>(self);
  68
  69     PyRef ret;
  70     try
  71     {
  72         Runtime runtime;
  73         cargo = runtime.getImpl()->cargo;
  74         any_params = runtime.pyObject2Any (args, me->members->mode);
  75
  76         if (any_params.getValueTypeClass () == css::uno::TypeClass_SEQUENCE)
  77         {
  78             any_params >>= aParams;
  79         }
  80         else
  81         {
  82             aParams.realloc (1);
  83             aParams [0] = any_params;
  84         }
  85
  86         {
  87             PyThreadDetach antiguard; //python free zone
  88
  89             // do some logging if desired ...
  90             if( isLog( cargo, LogLevel::CALL ) )
  91             {
  92                 logCall( cargo, "try     py->uno[0x", me->members->xInvocation.get(),
  93                          me->members->methodName, aParams );
  94             }
  95
  96             // do the call
  97             ret_value = me->members->xInvocation->invoke (
  98                 me->members->methodName, aParams, aOutParamIndex, aOutParam);
  99
 100             // log the reply, if desired
 101             if( isLog( cargo, LogLevel::CALL ) )
 102             {
 103                 logReply( cargo, "success py->uno[0x", me->members->xInvocation.get(),
 104                           me->members->methodName, ret_value, aOutParam);
 105             }
 106         }
 107
 108
 109         PyRef temp = runtime.any2PyObject (ret_value);
 110         if( aOutParam.getLength() )
 111         {
 112             PyRef return_list( PyTuple_New (1+aOutParam.getLength()), SAL_NO_ACQUIRE, NOT_NULL );
 113             PyTuple_SetItem (return_list.get(), 0, temp.getAcquired());
 114
 115             // initialize with defaults in case of exceptions
 116             int i;
 117             for( i = 1 ; i < 1+aOutParam.getLength() ; i ++ )
 118             {
 119                 Py_INCREF( Py_None );
 120                 PyTuple_SetItem( return_list.get() , i , Py_None );
 121             }
 122
 123             for( i = 0 ; i < aOutParam.getLength() ; i ++ )
 124             {
 125                 PyRef ref = runtime.any2PyObject( aOutParam[i] );
 126                 PyTuple_SetItem (return_list.get(), 1+i, ref.getAcquired());
 127             }
 128             ret = return_list;
 129         }
 130         else
 131         {
 132             ret = temp;
 133         }
 134     }
 135     catch( const css::reflection::InvocationTargetException & e )
 136     {
 137
 138         if( isLog( cargo, LogLevel::CALL ) )
 139         {
 140             logException( cargo, "except  py->uno[0x", me->members->xInvocation.get() ,
 141                           me->members->methodName, e.TargetException.getValue(), e.TargetException.getValueTypeRef());
 142         }
 143         raisePyExceptionWithAny( e.TargetException );
 144     }
 145     catch( const css::script::CannotConvertException &e )
 146     {
 147         if( isLog( cargo, LogLevel::CALL ) )
 148         {
 149             logException( cargo, "error  py->uno[0x", me->members->xInvocation.get() ,
 150                           me->members->methodName, &e, cppu::UnoType<decltype(e)>::get().getTypeLibType());
 151         }
 152         raisePyExceptionWithAny( css::uno::makeAny( e ) );
 153     }
 154     catch( const css::lang::IllegalArgumentException &e )
 155     {
 156         if( isLog( cargo, LogLevel::CALL ) )
 157         {
 158             logException( cargo, "error  py->uno[0x", me->members->xInvocation.get() ,
 159                           me->members->methodName, &e, cppu::UnoType<decltype(e)>::get().getTypeLibType());
 160         }
 161         raisePyExceptionWithAny( css::uno::makeAny( e ) );
 162     }
 163     catch (const css::uno::RuntimeException &e)
 164     {
 165         if( cargo && isLog( cargo, LogLevel::CALL ) )
 166         {
 167             logException( cargo, "error  py->uno[0x", me->members->xInvocation.get() ,
 168                           me->members->methodName, &e, cppu::UnoType<decltype(e)>::get().getTypeLibType());
 169         }
 170         raisePyExceptionWithAny( css::uno::makeAny( e ) );
 171     }
 172
 173     return ret.getAcquired();
 174 }
 175
 176
 177 static PyTypeObject PyUNO_callable_Type =
 178 {
 179     PyVarObject_HEAD_INIT( &PyType_Type, 0 )
 180     "PyUNO_callable",
 181     sizeof (PyUNO_callable),
 182     0,
 183     ::pyuno::PyUNO_callable_del,
 184 #if PY_VERSION_HEX >= 0x03080000
 185     0, // Py_ssize_t tp_vectorcall_offset
 186 #else
 187     nullptr, // printfunc tp_print
 188 #endif
 189     nullptr,
 190     nullptr,
 191     nullptr,
 192     nullptr,
 193     nullptr,
 194     nullptr,
 195     nullptr,
 196     nullptr,
 197     ::pyuno::PyUNO_callable_call,
 198     nullptr,
 199     nullptr,
 200     nullptr,
 201     nullptr,
 202     0,
 203     nullptr,
 204     nullptr,
 205     nullptr,
 206     nullptr,
 207     0,
 208     nullptr,
 209     nullptr,
 210     nullptr,
 211     nullptr,
 212     nullptr,
 213     nullptr,
 214     nullptr,
 215     nullptr,
 216     nullptr,
 217     0,
 218     nullptr,
 219     nullptr,
 220     nullptr,
 221     nullptr,
 222     nullptr,
 223     nullptr,
 224     nullptr,
 225     nullptr,
 226     nullptr,
 227     nullptr,
 228     nullptr
 229     , 0
 230 #if PY_VERSION_HEX >= 0x03040000
 231     , nullptr
 232 #if PY_VERSION_HEX >= 0x03080000
 233     , nullptr // vectorcallfunc tp_vectorcall
 234 #endif
 235 #endif
 236 };
 237
 238 PyRef PyUNO_callable_new (
 239     const Reference<XInvocation2> &my_inv,
 240     const OUString & methodName,
 241     enum ConversionMode mode )
 242 {
 243     PyUNO_callable* self;
 244
 245     OSL_ENSURE (my_inv.is(), "XInvocation must be valid");
 246
 247     self = PyObject_New (PyUNO_callable, &PyUNO_callable_Type);
 248     if (self == nullptr)
 249         return nullptr; //NULL == Error!
 250
 251     self->members = new PyUNO_callable_Internals;
 252     self->members->xInvocation = my_inv;
 253     self->members->methodName = methodName;
 254     self->members->mode = mode;
 255
 256     return PyRef( reinterpret_cast<PyObject*>(self), SAL_NO_ACQUIRE );
 257 }
 258
 259 }
 260
 261 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */