| /************************************************************** | |
| * | |
| * 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 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| #include "pyuno_impl.hxx" | |
| #include <osl/thread.h> | |
| #include <osl/module.h> | |
| #include <osl/process.h> | |
| #include <rtl/strbuf.hxx> | |
| #include <rtl/ustrbuf.hxx> | |
| #include <rtl/bootstrap.hxx> | |
| #include <locale.h> | |
| #include <typelib/typedescription.hxx> | |
| #include <com/sun/star/beans/XMaterialHolder.hpp> | |
| #include <vector> | |
| using rtl::OUString; | |
| using rtl::OUStringToOString; | |
| using rtl::OUStringBuffer; | |
| using rtl::OStringBuffer; | |
| using rtl::OString; | |
| using com::sun::star::uno::Reference; | |
| using com::sun::star::uno::XInterface; | |
| using com::sun::star::uno::Any; | |
| using com::sun::star::uno::TypeDescription; | |
| using com::sun::star::uno::Sequence; | |
| using com::sun::star::uno::Type; | |
| using com::sun::star::uno::UNO_QUERY; | |
| using com::sun::star::uno::RuntimeException; | |
| using com::sun::star::uno::XComponentContext; | |
| using com::sun::star::lang::XSingleServiceFactory; | |
| using com::sun::star::lang::XUnoTunnel; | |
| using com::sun::star::reflection::XIdlReflection; | |
| using com::sun::star::script::XTypeConverter; | |
| using com::sun::star::script::XInvocationAdapterFactory2; | |
| using com::sun::star::script::XInvocation; | |
| using com::sun::star::beans::XMaterialHolder; | |
| using com::sun::star::beans::XIntrospection; | |
| namespace pyuno | |
| { | |
| #define USTR_ASCII(x) OUString( RTL_CONSTASCII_USTRINGPARAM( x ) ) | |
| static PyTypeObject RuntimeImpl_Type = | |
| { | |
| PyVarObject_HEAD_INIT(&PyType_Type, 0) | |
| const_cast< char * >("pyuno_runtime"), | |
| sizeof (RuntimeImpl), | |
| 0, | |
| (destructor) RuntimeImpl::del, | |
| (printfunc) 0, | |
| (getattrfunc) 0, | |
| (setattrfunc) 0, | |
| 0, | |
| (reprfunc) 0, | |
| 0, | |
| 0, | |
| 0, | |
| (hashfunc) 0, | |
| (ternaryfunc) 0, | |
| (reprfunc) 0, | |
| (getattrofunc)0, | |
| (setattrofunc)0, | |
| NULL, | |
| 0, | |
| NULL, | |
| (traverseproc)0, | |
| (inquiry)0, | |
| (richcmpfunc)0, | |
| 0, | |
| (getiterfunc)0, | |
| (iternextfunc)0, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| (descrgetfunc)0, | |
| (descrsetfunc)0, | |
| 0, | |
| (initproc)0, | |
| (allocfunc)0, | |
| (newfunc)0, | |
| (freefunc)0, | |
| (inquiry)0, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| (destructor)0, | |
| 0 | |
| }; | |
| /*---------------------------------------------------------------------- | |
| Runtime implementation | |
| -----------------------------------------------------------------------*/ | |
| static void getRuntimeImpl( PyRef & globalDict, PyRef &runtimeImpl ) | |
| { | |
| PyThreadState * state = PyThreadState_Get(); | |
| if( ! state ) | |
| { | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "python global interpreter must be held (thread must be attached)" )), | |
| Reference< XInterface > () ); | |
| } | |
| globalDict = PyRef( PyModule_GetDict(PyImport_AddModule(const_cast< char * >("__main__")))); | |
| if( ! globalDict.is() ) // FATAL ! | |
| { | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "can't find __main__ module" )), Reference< XInterface > ()); | |
| } | |
| runtimeImpl = PyDict_GetItemString( globalDict.get() , "pyuno_runtime" ); | |
| } | |
| static PyRef importUnoModule( ) | |
| { | |
| PyRef globalDict = PyRef( PyModule_GetDict(PyImport_AddModule(const_cast< char * >("__main__")))); | |
| // import the uno module | |
| PyRef module( PyImport_ImportModule( const_cast< char * >("uno") ), SAL_NO_ACQUIRE ); | |
| if( PyErr_Occurred() ) | |
| { | |
| PyRef excType, excValue, excTraceback; | |
| PyErr_Fetch( (PyObject **)&excType, (PyObject**)&excValue,(PyObject**)&excTraceback); | |
| PyRef str( PyObject_Repr( excTraceback.get() ), SAL_NO_ACQUIRE ); | |
| OUStringBuffer buf; | |
| buf.appendAscii( "python object raised an unknown exception (" ); | |
| PyRef valueRep( PyObject_Repr( excValue.get() ), SAL_NO_ACQUIRE ); | |
| buf.append( pyString2ustring( valueRep.get() ) ).appendAscii( ", traceback follows\n" ); | |
| buf.append( pyString2ustring( str.get() ) ); | |
| throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface > () ); | |
| } | |
| PyRef dict( PyModule_GetDict( module.get() ) ); | |
| return dict; | |
| } | |
| static void readLoggingConfig( sal_Int32 *pLevel, FILE **ppFile ) | |
| { | |
| *pLevel = LogLevel::NONE; | |
| *ppFile = 0; | |
| OUString fileName; | |
| osl_getModuleURLFromFunctionAddress( | |
| reinterpret_cast< oslGenericFunction >(readLoggingConfig), | |
| (rtl_uString **) &fileName ); | |
| fileName = OUString( fileName.getStr(), fileName.lastIndexOf( '/' )+1 ); | |
| fileName += OUString::createFromAscii( SAL_CONFIGFILE("pyuno") ); | |
| rtl::Bootstrap bootstrapHandle( fileName ); | |
| OUString str; | |
| if( bootstrapHandle.getFrom( USTR_ASCII( "PYUNO_LOGLEVEL" ), str ) ) | |
| { | |
| if( str.equalsAscii( "NONE" ) ) | |
| *pLevel = LogLevel::NONE; | |
| else if( str.equalsAscii( "CALL" ) ) | |
| *pLevel = LogLevel::CALL; | |
| else if( str.equalsAscii( "ARGS" ) ) | |
| *pLevel = LogLevel::ARGS; | |
| else | |
| { | |
| fprintf( stderr, "unknown loglevel %s\n", | |
| OUStringToOString( str, RTL_TEXTENCODING_UTF8 ).getStr() ); | |
| } | |
| } | |
| if( *pLevel > LogLevel::NONE ) | |
| { | |
| *ppFile = stdout; | |
| if( bootstrapHandle.getFrom( USTR_ASCII( "PYUNO_LOGTARGET" ), str ) ) | |
| { | |
| if( str.equalsAscii( "stdout" ) ) | |
| *ppFile = stdout; | |
| else if( str.equalsAscii( "stderr" ) ) | |
| *ppFile = stderr; | |
| else | |
| { | |
| oslProcessInfo data; | |
| data.Size = sizeof( data ); | |
| osl_getProcessInfo( | |
| 0 , osl_Process_IDENTIFIER , &data ); | |
| osl_getSystemPathFromFileURL( str.pData, &str.pData); | |
| OString o = OUStringToOString( str, osl_getThreadTextEncoding() ); | |
| o += "."; | |
| o += OString::valueOf( (sal_Int32)data.Ident ); | |
| *ppFile = fopen( o.getStr() , "w" ); | |
| if ( *ppFile ) | |
| { | |
| // do not buffer (useful if e.g. analyzing a crash) | |
| setvbuf( *ppFile, 0, _IONBF, 0 ); | |
| } | |
| else | |
| { | |
| fprintf( stderr, "couldn't create file %s\n", | |
| OUStringToOString( str, RTL_TEXTENCODING_UTF8 ).getStr() ); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| /*------------------------------------------------------------------- | |
| RuntimeImpl implementations | |
| *-------------------------------------------------------------------*/ | |
| PyRef stRuntimeImpl::create( const Reference< XComponentContext > &ctx ) | |
| { | |
| RuntimeImpl *me = PyObject_New (RuntimeImpl, &RuntimeImpl_Type); | |
| if( ! me ) | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "cannot instantiate pyuno::RuntimeImpl" ) ), | |
| Reference< XInterface > () ); | |
| me->cargo = 0; | |
| // must use a different struct here, as the PyObject_New | |
| // makes C++ unusable | |
| RuntimeCargo *c = new RuntimeCargo(); | |
| readLoggingConfig( &(c->logLevel) , &(c->logFile) ); | |
| log( c, LogLevel::CALL, "Instantiating pyuno bridge" ); | |
| c->valid = 1; | |
| c->xContext = ctx; | |
| c->xInvocation = Reference< XSingleServiceFactory > ( | |
| ctx->getServiceManager()->createInstanceWithContext( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.script.Invocation" ) ), | |
| ctx ), | |
| UNO_QUERY ); | |
| if( ! c->xInvocation.is() ) | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "pyuno: couldn't instantiate invocation service" ) ), | |
| Reference< XInterface > () ); | |
| c->xTypeConverter = Reference< XTypeConverter > ( | |
| ctx->getServiceManager()->createInstanceWithContext( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.script.Converter" ) ), | |
| ctx ), | |
| UNO_QUERY ); | |
| if( ! c->xTypeConverter.is() ) | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "pyuno: couldn't instantiate typeconverter service" )), | |
| Reference< XInterface > () ); | |
| c->xCoreReflection = Reference< XIdlReflection > ( | |
| ctx->getServiceManager()->createInstanceWithContext( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.reflection.CoreReflection" ) ), | |
| ctx ), | |
| UNO_QUERY ); | |
| if( ! c->xCoreReflection.is() ) | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "pyuno: couldn't instantiate corereflection service" )), | |
| Reference< XInterface > () ); | |
| c->xAdapterFactory = Reference< XInvocationAdapterFactory2 > ( | |
| ctx->getServiceManager()->createInstanceWithContext( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.script.InvocationAdapterFactory" ) ), | |
| ctx ), | |
| UNO_QUERY ); | |
| if( ! c->xAdapterFactory.is() ) | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "pyuno: couldn't instantiate invocation adapter factory service" )), | |
| Reference< XInterface > () ); | |
| c->xIntrospection = Reference< XIntrospection > ( | |
| ctx->getServiceManager()->createInstanceWithContext( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.beans.Introspection" ) ), | |
| ctx ), | |
| UNO_QUERY ); | |
| if( ! c->xIntrospection.is() ) | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "pyuno: couldn't instantiate introspection service" )), | |
| Reference< XInterface > () ); | |
| Any a = ctx->getValueByName(OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theTypeDescriptionManager" )) ); | |
| a >>= c->xTdMgr; | |
| if( ! c->xTdMgr.is() ) | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "pyuno: couldn't retrieve typedescriptionmanager" )), | |
| Reference< XInterface > () ); | |
| me->cargo =c; | |
| return PyRef( reinterpret_cast< PyObject * > ( me ), SAL_NO_ACQUIRE ); | |
| } | |
| void stRuntimeImpl::del(PyObject* self) | |
| { | |
| RuntimeImpl *me = reinterpret_cast< RuntimeImpl * > ( self ); | |
| if( me->cargo->logFile ) | |
| fclose( me->cargo->logFile ); | |
| delete me->cargo; | |
| PyObject_Del (self); | |
| } | |
| void Runtime::initialize( const Reference< XComponentContext > & ctx ) | |
| { | |
| PyRef globalDict, runtime; | |
| getRuntimeImpl( globalDict , runtime ); | |
| RuntimeImpl *impl = reinterpret_cast< RuntimeImpl * > (runtime.get()); | |
| if( runtime.is() && impl->cargo->valid ) | |
| { | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "pyuno runtime has already been initialized before" ) ), | |
| Reference< XInterface > () ); | |
| } | |
| PyRef keep( RuntimeImpl::create( ctx ) ); | |
| PyDict_SetItemString( globalDict.get(), "pyuno_runtime" , keep.get() ); | |
| Py_XINCREF( keep.get() ); | |
| } | |
| bool Runtime::isInitialized() | |
| { | |
| PyRef globalDict, runtime; | |
| getRuntimeImpl( globalDict , runtime ); | |
| RuntimeImpl *impl = reinterpret_cast< RuntimeImpl * > (runtime.get()); | |
| return runtime.is() && impl->cargo->valid; | |
| } | |
| void Runtime::finalize() | |
| { | |
| PyRef globalDict, runtime; | |
| getRuntimeImpl( globalDict , runtime ); | |
| RuntimeImpl *impl = reinterpret_cast< RuntimeImpl * > (runtime.get()); | |
| if( !runtime.is() || ! impl->cargo->valid ) | |
| { | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "pyuno bridge must have been initialized before finalizing" )), | |
| Reference< XInterface > () ); | |
| } | |
| impl->cargo->valid = false; | |
| impl->cargo->xInvocation.clear(); | |
| impl->cargo->xContext.clear(); | |
| impl->cargo->xTypeConverter.clear(); | |
| } | |
| Runtime::Runtime() | |
| : impl( 0 ) | |
| { | |
| PyRef globalDict, runtime; | |
| getRuntimeImpl( globalDict , runtime ); | |
| if( ! runtime.is() ) | |
| { | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("pyuno runtime is not initialized, " | |
| "(the pyuno.bootstrap needs to be called before using any uno classes)")), | |
| Reference< XInterface > () ); | |
| } | |
| impl = reinterpret_cast< RuntimeImpl * > (runtime.get()); | |
| Py_XINCREF( runtime.get() ); | |
| } | |
| Runtime::Runtime( const Runtime & r ) | |
| { | |
| impl = r.impl; | |
| Py_XINCREF( reinterpret_cast< PyObject * >(impl) ); | |
| } | |
| Runtime::~Runtime() | |
| { | |
| Py_XDECREF( reinterpret_cast< PyObject * >(impl) ); | |
| } | |
| Runtime & Runtime::operator = ( const Runtime & r ) | |
| { | |
| PyRef temp( reinterpret_cast< PyObject * >(r.impl) ); | |
| Py_XINCREF( temp.get() ); | |
| Py_XDECREF( reinterpret_cast< PyObject * >(impl) ); | |
| impl = r.impl; | |
| return *this; | |
| } | |
| PyRef Runtime::any2PyObject (const Any &a ) const | |
| { | |
| if( ! impl->cargo->valid ) | |
| { | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "pyuno runtime must be initialized before calling any2PyObject" )), | |
| Reference< XInterface > () ); | |
| } | |
| switch (a.getValueTypeClass ()) | |
| { | |
| case typelib_TypeClass_VOID: | |
| { | |
| Py_INCREF (Py_None); | |
| return PyRef(Py_None); | |
| } | |
| case typelib_TypeClass_CHAR: | |
| { | |
| sal_Unicode c = *(sal_Unicode*)a.getValue(); | |
| return PyRef( PyUNO_char_new( c , *this ), SAL_NO_ACQUIRE ); | |
| } | |
| case typelib_TypeClass_BOOLEAN: | |
| { | |
| sal_Bool b = sal_Bool(); | |
| if ((a >>= b) && b) | |
| return Py_True; | |
| else | |
| return Py_False; | |
| } | |
| case typelib_TypeClass_BYTE: | |
| case typelib_TypeClass_SHORT: | |
| case typelib_TypeClass_UNSIGNED_SHORT: | |
| case typelib_TypeClass_LONG: | |
| { | |
| sal_Int32 l = 0; | |
| a >>= l; | |
| return PyRef( PyLong_FromLong (l), SAL_NO_ACQUIRE ); | |
| } | |
| case typelib_TypeClass_UNSIGNED_LONG: | |
| { | |
| sal_uInt32 l = 0; | |
| a >>= l; | |
| return PyRef( PyLong_FromUnsignedLong (l), SAL_NO_ACQUIRE ); | |
| } | |
| case typelib_TypeClass_HYPER: | |
| { | |
| sal_Int64 l = 0; | |
| a >>= l; | |
| return PyRef( PyLong_FromLongLong (l), SAL_NO_ACQUIRE); | |
| } | |
| case typelib_TypeClass_UNSIGNED_HYPER: | |
| { | |
| sal_uInt64 l = 0; | |
| a >>= l; | |
| return PyRef( PyLong_FromUnsignedLongLong (l), SAL_NO_ACQUIRE); | |
| } | |
| case typelib_TypeClass_FLOAT: | |
| { | |
| float f = 0.0; | |
| a >>= f; | |
| return PyRef(PyFloat_FromDouble (f), SAL_NO_ACQUIRE); | |
| } | |
| case typelib_TypeClass_DOUBLE: | |
| { | |
| double d = 0.0; | |
| a >>= d; | |
| return PyRef( PyFloat_FromDouble (d), SAL_NO_ACQUIRE); | |
| } | |
| case typelib_TypeClass_STRING: | |
| { | |
| OUString tmp_ostr; | |
| a >>= tmp_ostr; | |
| return ustring2PyUnicode( tmp_ostr ); | |
| } | |
| case typelib_TypeClass_TYPE: | |
| { | |
| Type t; | |
| a >>= t; | |
| OString o = OUStringToOString( t.getTypeName(), RTL_TEXTENCODING_ASCII_US ); | |
| return PyRef( | |
| PyUNO_Type_new ( | |
| o.getStr(), (com::sun::star::uno::TypeClass)t.getTypeClass(), *this), | |
| SAL_NO_ACQUIRE); | |
| } | |
| case typelib_TypeClass_ANY: | |
| { | |
| //I don't think this can happen. | |
| Py_INCREF (Py_None); | |
| return Py_None; | |
| } | |
| case typelib_TypeClass_ENUM: | |
| { | |
| sal_Int32 l = *(sal_Int32 *) a.getValue(); | |
| TypeDescription desc( a.getValueType() ); | |
| if( desc.is() ) | |
| { | |
| desc.makeComplete(); | |
| typelib_EnumTypeDescription *pEnumDesc = | |
| (typelib_EnumTypeDescription *) desc.get(); | |
| for( int i = 0 ; i < pEnumDesc->nEnumValues ; i ++ ) | |
| { | |
| if( pEnumDesc->pEnumValues[i] == l ) | |
| { | |
| OString v = OUStringToOString( pEnumDesc->ppEnumNames[i], RTL_TEXTENCODING_ASCII_US); | |
| OString e = OUStringToOString( pEnumDesc->aBase.pTypeName, RTL_TEXTENCODING_ASCII_US); | |
| return PyRef( PyUNO_Enum_new(e.getStr(),v.getStr(), *this ), SAL_NO_ACQUIRE ); | |
| } | |
| } | |
| } | |
| OUStringBuffer buf; | |
| buf.appendAscii( "Any carries enum " ); | |
| buf.append( a.getValueType().getTypeName()); | |
| buf.appendAscii( " with invalid value " ).append( l ); | |
| throw RuntimeException( buf.makeStringAndClear() , Reference< XInterface > () ); | |
| } | |
| case typelib_TypeClass_EXCEPTION: | |
| case typelib_TypeClass_STRUCT: | |
| { | |
| PyRef excClass = getClass( a.getValueType().getTypeName(), *this ); | |
| PyRef value = PyRef( PyUNO_new_UNCHECKED (a, getImpl()->cargo->xInvocation), SAL_NO_ACQUIRE); | |
| PyRef argsTuple( PyTuple_New( 1 ) , SAL_NO_ACQUIRE ); | |
| PyTuple_SetItem( argsTuple.get() , 0 , value.getAcquired() ); | |
| PyRef ret( PyObject_CallObject( excClass.get() , argsTuple.get() ), SAL_NO_ACQUIRE ); | |
| if( ! ret.is() ) | |
| { | |
| OUStringBuffer buf; | |
| buf.appendAscii( "Couldn't instantiate python representation of structured UNO type " ); | |
| buf.append( a.getValueType().getTypeName() ); | |
| throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface > () ); | |
| } | |
| if( com::sun::star::uno::TypeClass_EXCEPTION == a.getValueTypeClass() ) | |
| { | |
| // add the message in a standard python way ! | |
| PyRef args( PyTuple_New( 1 ), SAL_NO_ACQUIRE ); | |
| // assuming that the Message is always the first member, wuuuu | |
| void *pData = (void*)a.getValue(); | |
| OUString message = *(OUString * )pData; | |
| PyRef pymsg = USTR_TO_PYSTR( message ); | |
| PyTuple_SetItem( args.get(), 0 , pymsg.getAcquired() ); | |
| // the exception base functions want to have an "args" tuple, | |
| // which contains the message | |
| PyObject_SetAttrString( ret.get(), const_cast< char * >("args"), args.get() ); | |
| } | |
| return ret; | |
| } | |
| case typelib_TypeClass_SEQUENCE: | |
| { | |
| Sequence<Any> s; | |
| Sequence< sal_Int8 > byteSequence; | |
| if( a >>= byteSequence ) | |
| { | |
| // byte sequence is treated in a special way because of peformance reasons | |
| // @since 0.9.2 | |
| return PyRef( PyUNO_ByteSequence_new( byteSequence, *this ), SAL_NO_ACQUIRE ); | |
| } | |
| else | |
| { | |
| Reference< XTypeConverter > tc = getImpl()->cargo->xTypeConverter; | |
| Reference< XSingleServiceFactory > ssf = getImpl()->cargo->xInvocation; | |
| tc->convertTo (a, ::getCppuType (&s)) >>= s; | |
| PyRef tuple( PyTuple_New (s.getLength()), SAL_NO_ACQUIRE); | |
| int i=0; | |
| OUString errMsg; | |
| try | |
| { | |
| for ( i = 0; i < s.getLength (); i++) | |
| { | |
| PyRef element; | |
| element = any2PyObject (tc->convertTo (s[i], s[i].getValueType() )); | |
| OSL_ASSERT( element.is() ); | |
| PyTuple_SetItem( tuple.get(), i, element.getAcquired() ); | |
| } | |
| } | |
| catch( com::sun::star::uno::Exception & ) | |
| { | |
| for( ; i < s.getLength() ; i ++ ) | |
| { | |
| Py_INCREF( Py_None ); | |
| PyTuple_SetItem( tuple.get(), i, Py_None ); | |
| } | |
| throw; | |
| } | |
| return tuple; | |
| } | |
| } | |
| case typelib_TypeClass_INTERFACE: | |
| { | |
| Reference< XUnoTunnel > tunnel; | |
| a >>= tunnel; | |
| if( tunnel.is() ) | |
| { | |
| sal_Int64 that = tunnel->getSomething( ::pyuno::Adapter::getUnoTunnelImplementationId() ); | |
| if( that ) | |
| return ((Adapter*)sal::static_int_cast< sal_IntPtr >(that))->getWrappedObject(); | |
| } | |
| //This is just like the struct case: | |
| return PyRef( PyUNO_new (a, getImpl()->cargo->xInvocation), SAL_NO_ACQUIRE ); | |
| } | |
| default: | |
| { | |
| OUStringBuffer buf; | |
| buf.appendAscii( "Unknown UNO type class " ); | |
| buf.append( (sal_Int32 ) a.getValueTypeClass() ); | |
| throw RuntimeException(buf.makeStringAndClear( ), Reference< XInterface > () ); | |
| } | |
| } | |
| //We shouldn't be here... | |
| Py_INCREF( Py_None ); | |
| return Py_None; | |
| } | |
| static Sequence< Type > invokeGetTypes( const Runtime & r , PyObject * o ) | |
| { | |
| Sequence< Type > ret; | |
| PyRef method( PyObject_GetAttrString( o , const_cast< char * >("getTypes") ), SAL_NO_ACQUIRE ); | |
| raiseInvocationTargetExceptionWhenNeeded( r ); | |
| if( method.is() && PyCallable_Check( method.get() ) ) | |
| { | |
| PyRef types( PyObject_CallObject( method.get(), 0 ) , SAL_NO_ACQUIRE ); | |
| raiseInvocationTargetExceptionWhenNeeded( r ); | |
| if( types.is() && PyTuple_Check( types.get() ) ) | |
| { | |
| int size = PyTuple_Size( types.get() ); | |
| // add the XUnoTunnel interface for uno object identity concept (hack) | |
| ret.realloc( size + 1 ); | |
| for( int i = 0 ; i < size ; i ++ ) | |
| { | |
| Any a = r.pyObject2Any(PyTuple_GetItem(types.get(),i)); | |
| a >>= ret[i]; | |
| } | |
| ret[size] = getCppuType( (Reference< com::sun::star::lang::XUnoTunnel> *) 0 ); | |
| } | |
| } | |
| return ret; | |
| } | |
| Any Runtime::pyObject2Any ( const PyRef & source, enum ConversionMode mode ) const | |
| { | |
| if( ! impl->cargo->valid ) | |
| { | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "pyuno runtime must be initialized before calling any2PyObject" )), | |
| Reference< XInterface > () ); | |
| } | |
| Any a; | |
| PyObject *o = source.get(); | |
| if( Py_None == o ) | |
| { | |
| } | |
| else if (PyBool_Check(o)) | |
| { | |
| if( o == Py_True ) | |
| { | |
| sal_Bool b = sal_True; | |
| a = Any( &b, getBooleanCppuType() ); | |
| } | |
| else | |
| { | |
| sal_Bool b = sal_False; | |
| a = Any( &b, getBooleanCppuType() ); | |
| } | |
| } | |
| else if (PyLong_Check (o)) | |
| { | |
| sal_Int64 l = (sal_Int64)PyLong_AsLong (o); | |
| if( l < 128 && l >= -128 ) | |
| { | |
| sal_Int8 b = (sal_Int8 ) l; | |
| a <<= b; | |
| } | |
| else if( l <= 0x7fff && l >= -0x8000 ) | |
| { | |
| sal_Int16 s = (sal_Int16) l; | |
| a <<= s; | |
| } | |
| else if( l <= SAL_CONST_INT64(0x7fffffff) && | |
| l >= -SAL_CONST_INT64(0x80000000) ) | |
| { | |
| sal_Int32 l32 = (sal_Int32) l; | |
| a <<= l32; | |
| } | |
| else | |
| { | |
| a <<= l; | |
| } | |
| } | |
| else if (PyFloat_Check (o)) | |
| { | |
| double d = PyFloat_AsDouble (o); | |
| a <<= d; | |
| } | |
| else if( PyUnicode_Check( o ) ) | |
| a <<= pyString2ustring(o); | |
| else if (PyTuple_Check (o)) | |
| { | |
| Sequence<Any> s (PyTuple_Size (o)); | |
| for (int i = 0; i < PyTuple_Size (o); i++) | |
| { | |
| s[i] = pyObject2Any (PyTuple_GetItem (o, i), mode ); | |
| } | |
| a <<= s; | |
| } | |
| else | |
| { | |
| Runtime runtime; | |
| // should be removed, in case ByteSequence gets derived from String | |
| if( PyObject_IsInstance( o, getByteSequenceClass( runtime ).get() ) ) | |
| { | |
| PyRef str(PyObject_GetAttrString( o , const_cast< char * >("value") ),SAL_NO_ACQUIRE); | |
| Sequence< sal_Int8 > seq; | |
| if( PyBytes_Check( str.get() ) ) | |
| { | |
| seq = Sequence<sal_Int8 > ( | |
| (sal_Int8*) PyBytes_AsString(str.get()), PyBytes_Size(str.get())); | |
| } | |
| else if ( PyByteArray_Check( str.get() ) ) | |
| { | |
| seq = Sequence< sal_Int8 >( | |
| (sal_Int8 *) PyByteArray_AS_STRING(str.get()), PyByteArray_GET_SIZE(str.get())); | |
| } | |
| a <<= seq; | |
| } | |
| else | |
| if( PyObject_IsInstance( o, getTypeClass( runtime ).get() ) ) | |
| { | |
| Type t = PyType2Type( o ); | |
| a <<= t; | |
| } | |
| else if( PyObject_IsInstance( o, getEnumClass( runtime ).get() ) ) | |
| { | |
| a = PyEnum2Enum( o ); | |
| } | |
| else if( isInstanceOfStructOrException( o ) ) | |
| { | |
| PyRef struc(PyObject_GetAttrString( o , const_cast< char * >("value") ),SAL_NO_ACQUIRE); | |
| PyUNO * obj = (PyUNO*)struc.get(); | |
| Reference< XMaterialHolder > holder( obj->members->xInvocation, UNO_QUERY ); | |
| if( holder.is( ) ) | |
| a = holder->getMaterial(); | |
| else | |
| { | |
| throw RuntimeException( | |
| USTR_ASCII( "struct or exception wrapper does not support XMaterialHolder" ), | |
| Reference< XInterface > () ); | |
| } | |
| } | |
| else if( PyObject_IsInstance( o, getPyUnoClass().get() ) ) | |
| { | |
| PyUNO* o_pi; | |
| o_pi = (PyUNO*) o; | |
| if (o_pi->members->wrappedObject.getValueTypeClass () == | |
| com::sun::star::uno::TypeClass_STRUCT || | |
| o_pi->members->wrappedObject.getValueTypeClass () == | |
| com::sun::star::uno::TypeClass_EXCEPTION) | |
| { | |
| Reference<XMaterialHolder> my_mh (o_pi->members->xInvocation, UNO_QUERY); | |
| if (!my_mh.is ()) | |
| { | |
| throw RuntimeException( | |
| USTR_ASCII( "struct wrapper does not support XMaterialHolder" ), | |
| Reference< XInterface > () ); | |
| } | |
| else | |
| a = my_mh->getMaterial (); | |
| } | |
| else | |
| { | |
| a = o_pi->members->wrappedObject; | |
| } | |
| } | |
| else if( PyObject_IsInstance( o, getCharClass( runtime ).get() ) ) | |
| { | |
| sal_Unicode c = PyChar2Unicode( o ); | |
| a.setValue( &c, getCharCppuType( )); | |
| } | |
| else if( PyObject_IsInstance( o, getAnyClass( runtime ).get() ) ) | |
| { | |
| if( ACCEPT_UNO_ANY == mode ) | |
| { | |
| a = pyObject2Any( PyRef( PyObject_GetAttrString( o , const_cast< char * >("value") ), SAL_NO_ACQUIRE) ); | |
| Type t; | |
| pyObject2Any( PyRef( PyObject_GetAttrString( o, const_cast< char * >("type") ), SAL_NO_ACQUIRE ) ) >>= t; | |
| try | |
| { | |
| a = getImpl()->cargo->xTypeConverter->convertTo( a, t ); | |
| } | |
| catch( com::sun::star::uno::Exception & e ) | |
| { | |
| throw RuntimeException( e.Message, e.Context ); | |
| } | |
| } | |
| else | |
| { | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "uno.Any instance not accepted during method call, " | |
| "use uno.invoke instead" ) ), | |
| Reference< XInterface > () ); | |
| } | |
| } | |
| else | |
| { | |
| Reference< XInterface > mappedObject; | |
| Reference< XInvocation > adapterObject; | |
| // instance already mapped out to the world ? | |
| PyRef2Adapter::iterator ii = impl->cargo->mappedObjects.find( PyRef( o ) ); | |
| if( ii != impl->cargo->mappedObjects.end() ) | |
| { | |
| adapterObject = ii->second; | |
| } | |
| if( adapterObject.is() ) | |
| { | |
| // object got already bridged ! | |
| Reference< com::sun::star::lang::XUnoTunnel > tunnel( adapterObject, UNO_QUERY ); | |
| Adapter *pAdapter = ( Adapter * ) | |
| sal::static_int_cast< sal_IntPtr >( | |
| tunnel->getSomething( | |
| ::pyuno::Adapter::getUnoTunnelImplementationId() ) ); | |
| mappedObject = impl->cargo->xAdapterFactory->createAdapter( | |
| adapterObject, pAdapter->getWrappedTypes() ); | |
| } | |
| else | |
| { | |
| Sequence< Type > interfaces = invokeGetTypes( *this, o ); | |
| if( interfaces.getLength() ) | |
| { | |
| Adapter *pAdapter = new Adapter( o, interfaces ); | |
| mappedObject = | |
| getImpl()->cargo->xAdapterFactory->createAdapter( | |
| pAdapter, interfaces ); | |
| // keep a list of exported objects to ensure object identity ! | |
| impl->cargo->mappedObjects[ PyRef(o) ] = | |
| com::sun::star::uno::WeakReference< XInvocation > ( pAdapter ); | |
| } | |
| } | |
| if( mappedObject.is() ) | |
| { | |
| a = com::sun::star::uno::makeAny( mappedObject ); | |
| } | |
| else | |
| { | |
| OUStringBuffer buf; | |
| buf.appendAscii( "Couldn't convert " ); | |
| PyRef reprString( PyObject_Str( o ) , SAL_NO_ACQUIRE ); | |
| buf.append( pyString2ustring( reprString.get() ) ); | |
| buf.appendAscii( " to a UNO type" ); | |
| throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface > () ); | |
| } | |
| } | |
| } | |
| return a; | |
| } | |
| Any Runtime::extractUnoException( const PyRef & excType, const PyRef &excValue, const PyRef &excTraceback) const | |
| { | |
| PyRef str; | |
| Any ret; | |
| if( excTraceback.is() ) | |
| { | |
| PyRef unoModule( impl ? impl->cargo->getUnoModule() : 0 ); | |
| if( unoModule.is() ) | |
| { | |
| PyRef extractTraceback( | |
| PyDict_GetItemString(unoModule.get(),"_uno_extract_printable_stacktrace" ) ); | |
| if( extractTraceback.is() ) | |
| { | |
| PyRef args( PyTuple_New( 1), SAL_NO_ACQUIRE ); | |
| PyTuple_SetItem( args.get(), 0, excTraceback.getAcquired() ); | |
| str = PyRef( PyObject_CallObject( extractTraceback.get(),args.get() ), SAL_NO_ACQUIRE); | |
| } | |
| else | |
| { | |
| str = PyRef( | |
| PyBytes_FromString( "Couldn't find uno._uno_extract_printable_stacktrace" ), | |
| SAL_NO_ACQUIRE ); | |
| } | |
| } | |
| else | |
| { | |
| str = PyRef( | |
| PyBytes_FromString( "Couldn't find uno.py, no stacktrace available" ), | |
| SAL_NO_ACQUIRE ); | |
| } | |
| } | |
| else | |
| { | |
| // it may occur, that no traceback is given (e.g. only native code below) | |
| str = PyRef( PyBytes_FromString( "no traceback available" ), SAL_NO_ACQUIRE); | |
| } | |
| if( isInstanceOfStructOrException( excValue.get() ) ) | |
| { | |
| ret = pyObject2Any( excValue ); | |
| } | |
| else | |
| { | |
| OUStringBuffer buf; | |
| PyRef typeName( PyObject_Str( excType.get() ), SAL_NO_ACQUIRE ); | |
| if( typeName.is() ) | |
| { | |
| buf.append( pyString2ustring( typeName.get() ) ); | |
| } | |
| else | |
| { | |
| buf.appendAscii( "no typename available" ); | |
| } | |
| buf.appendAscii( ": " ); | |
| PyRef valueRep( PyObject_Str( excValue.get() ), SAL_NO_ACQUIRE ); | |
| if( valueRep.is() ) | |
| { | |
| buf.append( pyString2ustring( valueRep.get())); | |
| } | |
| else | |
| { | |
| buf.appendAscii( "Couldn't convert exception value to a string" ); | |
| } | |
| buf.appendAscii( ", traceback follows\n" ); | |
| if( str.is() ) | |
| { | |
| buf.append( pyString2ustring( str.get() ) ); | |
| } | |
| else | |
| { | |
| buf.appendAscii( ", no traceback available\n" ); | |
| } | |
| RuntimeException e; | |
| e.Message = buf.makeStringAndClear(); | |
| ret = com::sun::star::uno::makeAny( e ); | |
| } | |
| return ret; | |
| } | |
| static const char * g_NUMERICID = "pyuno.lcNumeric"; | |
| static ::std::vector< rtl::OString > g_localeList; | |
| static const char *ensureUnlimitedLifetime( const char *str ) | |
| { | |
| int size = g_localeList.size(); | |
| int i; | |
| for( i = 0 ; i < size ; i ++ ) | |
| { | |
| if( 0 == strcmp( g_localeList[i].getStr(), str ) ) | |
| break; | |
| } | |
| if( i == size ) | |
| { | |
| g_localeList.push_back( str ); | |
| } | |
| return g_localeList[i].getStr(); | |
| } | |
| PyThreadAttach::PyThreadAttach( PyInterpreterState *interp) | |
| { | |
| tstate = PyThreadState_New( interp ); | |
| if( !tstate ) | |
| throw RuntimeException( | |
| OUString(RTL_CONSTASCII_USTRINGPARAM( "Couldn't create a pythreadstate" ) ), | |
| Reference< XInterface > () ); | |
| PyEval_AcquireThread( tstate); | |
| // set LC_NUMERIC to "C" | |
| const char * oldLocale = | |
| ensureUnlimitedLifetime( setlocale( LC_NUMERIC, 0 ) ); | |
| setlocale( LC_NUMERIC, "C" ); | |
| PyRef locale( // python requires C locale | |
| PyLong_FromVoidPtr( (void*)oldLocale ), SAL_NO_ACQUIRE); | |
| PyDict_SetItemString( | |
| PyThreadState_GetDict(), g_NUMERICID, locale.get() ); | |
| } | |
| PyThreadAttach::~PyThreadAttach() | |
| { | |
| PyObject *value = | |
| PyDict_GetItemString( PyThreadState_GetDict( ), g_NUMERICID ); | |
| if( value ) | |
| setlocale( LC_NUMERIC, (const char * ) PyLong_AsVoidPtr( value ) ); | |
| PyThreadState_Clear( tstate ); | |
| PyEval_ReleaseThread( tstate ); | |
| PyThreadState_Delete( tstate ); | |
| } | |
| PyThreadDetach::PyThreadDetach() | |
| { | |
| tstate = PyThreadState_Get(); | |
| PyObject *value = | |
| PyDict_GetItemString( PyThreadState_GetDict( ), g_NUMERICID ); | |
| if( value ) | |
| setlocale( LC_NUMERIC, (const char * ) PyLong_AsVoidPtr( value ) ); | |
| PyEval_ReleaseThread( tstate ); | |
| } | |
| /** Acquires the global interpreter lock again | |
| */ | |
| PyThreadDetach::~PyThreadDetach() | |
| { | |
| PyEval_AcquireThread( tstate ); | |
| // PyObject *value = | |
| // PyDict_GetItemString( PyThreadState_GetDict( ), g_NUMERICID ); | |
| // python requires C LC_NUMERIC locale, | |
| // always set even when it is already "C" | |
| setlocale( LC_NUMERIC, "C" ); | |
| } | |
| PyRef RuntimeCargo::getUnoModule() | |
| { | |
| if( ! dictUnoModule.is() ) | |
| { | |
| dictUnoModule = importUnoModule(); | |
| } | |
| return dictUnoModule; | |
| } | |
| } |