pyuno/source/module/pyuno_impl.hxx

   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 #ifndef INCLUDED_PYUNO_SOURCE_MODULE_PYUNO_IMPL_HXX
  20 #define INCLUDED_PYUNO_SOURCE_MODULE_PYUNO_IMPL_HXX
  21
  22 #if defined(_MSC_VER)
  23 // Workaround for some horrible hypot() mess
  24 #include <math.h>
  25 #endif
  26
  27 #include <Python.h>
  28
  29 #if PY_VERSION_HEX < 0x03020000
  30 typedef long Py_hash_t;
  31 #endif
  32
  33 //Must define PyVarObject_HEAD_INIT for Python 2.5 or older
  34 #ifndef PyVarObject_HEAD_INIT
  35 #define PyVarObject_HEAD_INIT(type, size)  PyObject_HEAD_INIT(type) size,
  36 #endif
  37
  38 //Python 3.0 and newer don't have these flags
  39 #ifndef Py_TPFLAGS_HAVE_ITER
  40 #  define Py_TPFLAGS_HAVE_ITER 0
  41 #endif
  42 #ifndef Py_TPFLAGS_HAVE_RICHCOMPARE
  43 #  define Py_TPFLAGS_HAVE_RICHCOMPARE 0
  44 #endif
  45 #ifndef Py_TPFLAGS_HAVE_SEQUENCE_IN
  46 #  define Py_TPFLAGS_HAVE_SEQUENCE_IN 0
  47 #endif
  48
  49 #include <pyuno/pyuno.hxx>
  50
  51 #include <unordered_map>
  52 #include <unordered_set>
  53
  54 #include <com/sun/star/beans/XIntrospection.hpp>
  55 #include <com/sun/star/script/XTypeConverter.hpp>
  56 #include <com/sun/star/script/XInvocation2.hpp>
  57 #include <com/sun/star/script/XInvocationAdapterFactory2.hpp>
  58
  59 #include <com/sun/star/reflection/XIdlReflection.hpp>
  60
  61 #include <com/sun/star/container/XEnumeration.hpp>
  62 #include <com/sun/star/container/XIndexAccess.hpp>
  63 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  64
  65 #include <com/sun/star/lang/XUnoTunnel.hpp>
  66 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  67
  68 #include <cppuhelper/implbase.hxx>
  69 #include <cppuhelper/weakref.hxx>
  70
  71 #include <osl/module.hxx>
  72
  73 // In Python 3, the PyString_* functions have been replaced by PyBytes_*
  74 // and PyUnicode_* functions.
  75 #if PY_MAJOR_VERSION >= 3
  76
  77 // compatibility wrappers for Python "str" type (PyUnicode in 3, PyString in 2)
  78 inline PyObject* PyStr_FromString(const char *string)
  79 {
  80     return PyUnicode_FromString(string);
  81 }
  82
  83 inline char * PyStr_AsString(PyObject *object)
  84 {
  85     return PyUnicode_AsUTF8(object);
  86 }
  87
  88 inline bool PyStr_Check(PyObject *object)
  89 {
  90     return PyUnicode_Check(object);
  91 }
  92
  93 // compatibility wrappers for Python non-Unicode string/buffer type
  94 // (PyBytes in 3, PyString in 2)
  95 inline bool PyStrBytes_Check(PyObject *object)
  96 {
  97     return PyBytes_Check(object);
  98 }
  99
 100 inline char* PyStrBytes_AsString(PyObject *object)
 101 {
 102     return PyBytes_AsString(object);
 103 }
 104
 105 inline Py_ssize_t PyStrBytes_Size(PyObject *object)
 106 {
 107     return PyBytes_Size(object);
 108 }
 109
 110 inline PyObject* PyStrBytes_FromStringAndSize(const char *string, Py_ssize_t len)
 111 {
 112     return PyBytes_FromStringAndSize(string, len);
 113 }
 114 #else
 115 inline char * PyStr_AsString(PyObject *object)
 116 {
 117     return PyString_AsString(object);
 118 }
 119
 120 inline PyObject* PyStr_FromString(const char *string)
 121 {
 122     return PyString_FromString(string);
 123 }
 124
 125 inline bool PyStr_Check(PyObject *object)
 126 {
 127     return PyString_Check(object);
 128 }
 129 inline bool PyStrBytes_Check(PyObject *object)
 130 {
 131     return PyString_Check(object);
 132 }
 133
 134 inline char* PyStrBytes_AsString(PyObject *object)
 135 {
 136     return PyString_AsString(object);
 137 }
 138
 139 inline Py_ssize_t PyStrBytes_Size(PyObject *object)
 140 {
 141     return PyString_Size(object);
 142 }
 143
 144 inline PyObject* PyStrBytes_FromStringAndSize(const char *string, Py_ssize_t len)
 145 {
 146     return PyString_FromStringAndSize(string, len);
 147 }
 148 #endif /* PY_MAJOR_VERSION >= 3 */
 149
 150 namespace pyuno
 151 {
 152
 153
 154 // Logging API - implementation can be found in pyuno_util
 155
 156 struct RuntimeCargo;
 157 namespace LogLevel
 158 {
 159 // when you add a loglevel, extend the log function !
 160 static const sal_Int32 NONE = 0;
 161 static const sal_Int32 CALL = 1;
 162 static const sal_Int32 ARGS = 2;
 163 }
 164
 165 bool isLog( RuntimeCargo *cargo, sal_Int32 loglevel );
 166 void log( RuntimeCargo *cargo, sal_Int32 level, const OUString &logString );
 167 void log( RuntimeCargo *cargo, sal_Int32 level, const char *str );
 168 void logCall( RuntimeCargo *cargo, const char *intro,
 169               void * ptr, const OUString & aFunctionName,
 170               const css::uno::Sequence< css::uno::Any > & args );
 171 void logReply( RuntimeCargo *cargo, const char *intro,
 172               void * ptr, const OUString & aFunctionName,
 173               const css::uno::Any &returnValue,
 174               const css::uno::Sequence< css::uno::Any > & args );
 175 void logException( RuntimeCargo *cargo, const char *intro,
 176                    void * ptr, const OUString &aFunctionName,
 177                    const void * data, const css::uno::Type & type );
 178 static const sal_Int32 VAL2STR_MODE_DEEP = 0;
 179 static const sal_Int32 VAL2STR_MODE_SHALLOW = 1;
 180 OUString val2str( const void * pVal, typelib_TypeDescriptionReference * pTypeRef, sal_Int32 mode = VAL2STR_MODE_DEEP );
 181
 182
 183 typedef std::unordered_map
 184 <
 185     PyRef,
 186     css::uno::WeakReference< css::script::XInvocation >,
 187     PyRef::Hash
 188 > PyRef2Adapter;
 189
 190
 191 typedef std::unordered_map
 192 <
 193 OUString,
 194 PyRef,
 195 OUStringHash
 196 > ExceptionClassMap;
 197
 198 typedef std::unordered_map
 199 <
 200     OUString,
 201     css::uno::Sequence< sal_Int16 >,
 202     OUStringHash
 203 > MethodOutIndexMap;
 204
 205 typedef std::unordered_set< PyRef , PyRef::Hash > ClassSet;
 206
 207 int PyUNO_initType();
 208 int PyUNOStruct_initType();
 209
 210 PyRef PyUNO_new (
 211     const css::uno::Any & targetInterface,
 212     const css::uno::Reference<css::lang::XSingleServiceFactory> & ssf );
 213
 214 PyRef PyUNOStruct_new (
 215     const css::uno::Any &targetInterface,
 216     const  css::uno::Reference<css::lang::XSingleServiceFactory> &ssf );
 217
 218 typedef struct
 219 {
 220     css::uno::Reference <css::script::XInvocation2> xInvocation;
 221     css::uno::Any wrappedObject;
 222 } PyUNOInternals;
 223
 224 typedef struct
 225 {
 226     PyObject_HEAD
 227     PyUNOInternals* members;
 228 } PyUNO;
 229
 230 PyObject* PyUNO_iterator_new (
 231     const css::uno::Reference<css::container::XEnumeration>& xEnumeration);
 232
 233 typedef struct
 234 {
 235     css::uno::Reference <css::container::XEnumeration> xEnumeration;
 236 } PyUNO_iterator_Internals;
 237
 238 typedef struct
 239 {
 240         PyObject_HEAD
 241         PyUNO_iterator_Internals* members;
 242 } PyUNO_iterator;
 243
 244 PyObject* PyUNO_list_iterator_new (
 245     const css::uno::Reference<css::container::XIndexAccess> &xIndexAccess);
 246
 247 typedef struct
 248 {
 249     css::uno::Reference <css::container::XIndexAccess> xIndexAccess;
 250     int index;
 251 } PyUNO_list_iterator_Internals;
 252
 253 typedef struct
 254 {
 255         PyObject_HEAD
 256         PyUNO_list_iterator_Internals* members;
 257 } PyUNO_list_iterator;
 258
 259 PyRef ustring2PyUnicode( const OUString &source );
 260 PyRef ustring2PyString( const OUString & source );
 261 OUString pyString2ustring( PyObject *str );
 262
 263
 264 void raiseInvocationTargetExceptionWhenNeeded( const Runtime &runtime )
 265     throw ( css::reflection::InvocationTargetException );
 266
 267 PyRef PyUNO_callable_new (
 268     const css::uno::Reference<css::script::XInvocation2> &xInv,
 269     const OUString &methodName,
 270     ConversionMode mode = REJECT_UNO_ANY );
 271
 272 PyObject* PyUNO_Type_new (const char *typeName , css::uno::TypeClass t , const Runtime &r );
 273 PyObject* PyUNO_Enum_new( const char *enumBase, const char *enumValue, const Runtime &r );
 274 PyObject* PyUNO_char_new (sal_Unicode c , const Runtime &r);
 275 PyObject *PyUNO_ByteSequence_new( const css::uno::Sequence< sal_Int8 > &, const Runtime &r );
 276
 277 PyRef getTypeClass( const Runtime &);
 278 PyRef getEnumClass( const Runtime &);
 279 PyRef getCharClass( const Runtime &);
 280 PyRef getByteSequenceClass( const Runtime & );
 281 PyRef getPyUnoClass();
 282 PyRef getPyUnoStructClass();
 283 PyRef getClass( const OUString & name , const Runtime & runtime );
 284 PyRef getAnyClass( const Runtime &);
 285 PyObject *PyUNO_invoke( PyObject *object, const char *name , PyObject *args );
 286
 287 css::uno::Any PyEnum2Enum( PyObject *obj )
 288     throw ( css::uno::RuntimeException );
 289 sal_Unicode PyChar2Unicode( PyObject *o )
 290     throw ( css::uno::RuntimeException );
 291 css::uno::Type PyType2Type( PyObject * o )
 292     throw( css::uno::RuntimeException );
 293
 294 void raisePyExceptionWithAny( const css::uno::Any &a );
 295 const char *typeClassToString( css::uno::TypeClass t );
 296
 297 PyRef getObjectFromUnoModule( const Runtime &runtime, const char * object )
 298     throw ( css::uno::RuntimeException );
 299
 300 bool isInterfaceClass( const Runtime &, PyObject *obj );
 301 bool isInstanceOfStructOrException( PyObject *obj);
 302
 303 struct RuntimeCargo
 304 {
 305     css::uno::Reference< css::lang::XSingleServiceFactory > xInvocation;
 306     css::uno::Reference< css::script::XTypeConverter> xTypeConverter;
 307     css::uno::Reference< css::uno::XComponentContext > xContext;
 308     css::uno::Reference< css::reflection::XIdlReflection > xCoreReflection;
 309     css::uno::Reference< css::container::XHierarchicalNameAccess > xTdMgr;
 310     css::uno::Reference< css::script::XInvocationAdapterFactory2 > xAdapterFactory;
 311     css::uno::Reference< css::beans::XIntrospection > xIntrospection;
 312     PyRef dictUnoModule;
 313     osl::Module testModule;
 314     bool valid;
 315     ExceptionClassMap exceptionMap;
 316     ClassSet interfaceSet;
 317     PyRef2Adapter mappedObjects;
 318     FILE *logFile;
 319     sal_Int32 logLevel;
 320
 321     PyRef getUnoModule();
 322 };
 323
 324 struct stRuntimeImpl
 325 {
 326     PyObject_HEAD
 327     struct RuntimeCargo *cargo;
 328 public:
 329     static void del( PyObject *self );
 330
 331     static PyRef create(
 332         const css::uno::Reference< css::uno::XComponentContext > & xContext )
 333         throw ( css::uno::RuntimeException, std::exception );
 334 };
 335
 336
 337 class Adapter : public cppu::WeakImplHelper<
 338     css::script::XInvocation, css::lang::XUnoTunnel >
 339 {
 340     PyRef mWrappedObject;
 341     PyInterpreterState *mInterpreter;  // interpreters don't seem to be refcounted !
 342     css::uno::Sequence< css::uno::Type > mTypes;
 343     MethodOutIndexMap m_methodOutIndexMap;
 344
 345 private:
 346     css::uno::Sequence< sal_Int16 > getOutIndexes( const OUString & functionName );
 347
 348 public:
 349 public:
 350     Adapter( const PyRef &obj,
 351              const css::uno::Sequence< css::uno::Type > & types );
 352
 353     static css::uno::Sequence< sal_Int8 > getUnoTunnelImplementationId();
 354     const PyRef& getWrappedObject() const { return mWrappedObject; }
 355     const css::uno::Sequence< css::uno::Type >& getWrappedTypes() const { return mTypes; }
 356     virtual ~Adapter();
 357
 358     // XInvocation
 359     virtual css::uno::Reference< css::beans::XIntrospectionAccess >
 360            SAL_CALL getIntrospection(  ) throw (css::uno::RuntimeException, std::exception) override;
 361     virtual css::uno::Any SAL_CALL invoke(
 362         const OUString& aFunctionName,
 363         const css::uno::Sequence< css::uno::Any >& aParams,
 364         css::uno::Sequence< sal_Int16 >& aOutParamIndex,
 365         css::uno::Sequence< css::uno::Any >& aOutParam )
 366         throw (css::lang::IllegalArgumentException,
 367                css::script::CannotConvertException,
 368                css::reflection::InvocationTargetException,
 369                css::uno::RuntimeException, std::exception) override;
 370
 371     virtual void SAL_CALL setValue(
 372         const OUString& aPropertyName,
 373         const css::uno::Any& aValue )
 374         throw (css::beans::UnknownPropertyException,
 375                css::script::CannotConvertException,
 376                css::reflection::InvocationTargetException,
 377                css::uno::RuntimeException, std::exception) override;
 378
 379     virtual css::uno::Any SAL_CALL getValue( const OUString& aPropertyName )
 380         throw (css::beans::UnknownPropertyException,
 381                css::uno::RuntimeException, std::exception) override;
 382     virtual sal_Bool SAL_CALL hasMethod( const OUString& aName )
 383         throw (css::uno::RuntimeException, std::exception) override;
 384     virtual sal_Bool SAL_CALL hasProperty( const OUString& aName )
 385         throw (css::uno::RuntimeException, std::exception) override;
 386
 387     // XUnoTunnel
 388     virtual sal_Int64 SAL_CALL getSomething(
 389         const css::uno::Sequence< sal_Int8 >& aIdentifier )
 390         throw (css::uno::RuntimeException, std::exception) override;
 391 };
 392
 393
 394 /** releases a refcount on the interpreter object and on another given python object.
 395
 396    The function can be called from any thread regardless of whether the global
 397    interpreter lock is held.
 398
 399  */
 400 void decreaseRefCount( PyInterpreterState *interpreter, PyObject *object );
 401
 402 }
 403
 404 #endif
 405
 406 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */