Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 901 insertions, 0 deletions

diff --git a/pyuno/source/module/pyuno_module.cxx b/pyuno/source/module/pyuno_module.cxx
new file mode 100644
index 000000000..579da0a58
--- /dev/null
+++ b/pyuno/source/module/pyuno_module.cxx
@@ -0,0 +1,901 @@
+/* -*- Mode: C++; eval:(c-set-style "bsd"); tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <config_folders.h>
+
+#include "pyuno_impl.hxx"
+
+#include <cassert>
+#include <unordered_map>
+
+#include <osl/module.hxx>
+#include <osl/thread.h>
+#include <osl/file.hxx>
+#include <sal/log.hxx>
+
+#include <typelib/typedescription.hxx>
+
+#include <rtl/ustring.hxx>
+#include <rtl/strbuf.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/uuid.h>
+#include <rtl/bootstrap.hxx>
+
+#include <uno/current_context.hxx>
+#include <cppuhelper/bootstrap.hxx>
+
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/reflection/XConstantTypeDescription.hpp>
+#include <com/sun/star/reflection/XIdlClass.hpp>
+#include <com/sun/star/registry/InvalidRegistryException.hpp>
+#include <com/sun/star/script/CannotConvertException.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/script/XInvocation2.hpp>
+#include <com/sun/star/reflection/XIdlReflection.hpp>
+#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
+
+using osl::Module;
+
+
+using com::sun::star::uno::Sequence;
+using com::sun::star::uno::Reference;
+using com::sun::star::uno::Any;
+using com::sun::star::uno::makeAny;
+using com::sun::star::uno::RuntimeException;
+using com::sun::star::uno::TypeDescription;
+using com::sun::star::uno::XComponentContext;
+using com::sun::star::container::NoSuchElementException;
+using com::sun::star::reflection::XIdlClass;
+using com::sun::star::script::XInvocation2;
+
+using namespace pyuno;
+
+namespace {
+
+/**
+   @ index of the next to be used member in the initializer list !
+ */
+// LEM TODO: export member names as keyword arguments in initialiser?
+// Python supports very flexible variadic functions. By marking
+// variables with one asterisk (e.g. *var) the given variable is
+// defined to be a tuple of all the extra arguments. By marking
+// variables with two asterisks (e.g. **var) the given variable is a
+// dictionary of all extra keyword arguments; the keys are strings,
+// which are the names that were used to identify the arguments. If
+// they exist, these arguments must be the last one in the list.
+
+class fillStructState
+{
+    // Keyword arguments used
+    PyObject *used;
+    // Which structure members are initialised
+    std::unordered_map <OUString, bool> initialised;
+    // How many positional arguments are consumed
+    // This is always the so-many first ones
+    sal_Int32 nPosConsumed;
+
+public:
+    fillStructState()
+        : used (PyDict_New())
+        , initialised ()
+        , nPosConsumed (0)
+    {
+        if ( ! used )
+            throw RuntimeException("pyuno._createUnoStructHelper failed to create new dictionary");
+    }
+    ~fillStructState()
+    {
+        Py_DECREF(used);
+    }
+    void setUsed(PyObject *key)
+    {
+        PyDict_SetItem(used, key, Py_True);
+    }
+    void setInitialised(const OUString& key, sal_Int32 pos = -1)
+    {
+        if (initialised[key])
+        {
+            OUStringBuffer buf;
+            buf.append( "pyuno._createUnoStructHelper: member '" + key + "'");
+            if ( pos >= 0 )
+            {
+                buf.append( " at position " + OUString::number(pos));
+            }
+            buf.append( " initialised multiple times.");
+            throw RuntimeException(buf.makeStringAndClear());
+        }
+        initialised[key] = true;
+        if ( pos >= 0 )
+            ++nPosConsumed;
+    }
+    bool isInitialised(const OUString& key)
+    {
+        return initialised[key];
+    }
+    PyObject *getUsed() const
+    {
+        return used;
+    }
+    sal_Int32 getCntConsumed() const
+    {
+        return nPosConsumed;
+    }
+};
+
+/// @throws RuntimeException
+void fillStruct(
+    const Reference< XInvocation2 > &inv,
+    typelib_CompoundTypeDescription *pCompType,
+    PyObject *initializer,
+    PyObject *kwinitializer,
+    fillStructState &state,
+    const Runtime &runtime)
+{
+    if( pCompType->pBaseTypeDescription )
+        fillStruct( inv, pCompType->pBaseTypeDescription, initializer, kwinitializer, state, runtime );
+
+    const sal_Int32 nMembers = pCompType->nMembers;
+    {
+        for( int i = 0 ; i < nMembers ; i ++ )
+        {
+            const OUString OUMemberName (pCompType->ppMemberNames[i]);
+            PyObject *pyMemberName =
+                PyUnicode_FromString(OUStringToOString(OUMemberName,
+                        RTL_TEXTENCODING_UTF8).getStr());
+            if ( PyObject *element = PyDict_GetItem(kwinitializer, pyMemberName ) )
+            {
+                state.setInitialised(OUMemberName);
+                state.setUsed(pyMemberName);
+                Any a = runtime.pyObject2Any( element, ACCEPT_UNO_ANY );
+                inv->setValue( OUMemberName, a );
+            }
+        }
+    }
+    {
+        const int remainingPosInitialisers = PyTuple_Size(initializer) - state.getCntConsumed();
+        for( int i = 0 ; i < remainingPosInitialisers && i < nMembers ; i ++ )
+        {
+            const int tupleIndex = state.getCntConsumed();
+            const OUString& rMemberName (pCompType->ppMemberNames[i]);
+            state.setInitialised(rMemberName, tupleIndex);
+            PyObject *element = PyTuple_GetItem( initializer, tupleIndex );
+            Any a = runtime.pyObject2Any( element, ACCEPT_UNO_ANY );
+            inv->setValue( rMemberName, a );
+        }
+    }
+    if ( PyTuple_Size( initializer ) <= 0 )
+        return;
+
+    // Allow partial initialisation when only keyword arguments are given
+    for ( int i = 0; i < nMembers ; ++i)
+    {
+        const OUString memberName (pCompType->ppMemberNames[i]);
+        if ( ! state.isInitialised( memberName ) )
+        {
+            OUString buf = "pyuno._createUnoStructHelper: member '" +
+                memberName +
+                "' of struct type '" +
+                OUString::unacquired(&pCompType->aBase.pTypeName) +
+                "' not given a value.";
+            throw RuntimeException(buf);
+        }
+    }
+}
+
+OUString getLibDir()
+{
+    static OUString sLibDir = []() {
+        OUString libDir;
+
+        // workarounds the $(ORIGIN) until it is available
+        if (Module::getUrlFromAddress(reinterpret_cast<oslGenericFunction>(getLibDir), libDir))
+        {
+            libDir = libDir.copy(0, libDir.lastIndexOf('/'));
+            OUString name("PYUNOLIBDIR");
+            rtl_bootstrap_set(name.pData, libDir.pData);
+        }
+        return libDir;
+    }();
+
+    return sLibDir;
+}
+
+void raisePySystemException( const char * exceptionType, const OUString & message )
+{
+    OString buf = OStringLiteral("Error during bootstrapping uno (") +
+            exceptionType +
+            "):" +
+            OUStringToOString( message, osl_getThreadTextEncoding() );
+    PyErr_SetString( PyExc_SystemError, buf.getStr() );
+}
+
+extern "C" {
+
+static PyObject* getComponentContext(
+    SAL_UNUSED_PARAMETER PyObject*, SAL_UNUSED_PARAMETER PyObject*)
+{
+    PyRef ret;
+    try
+    {
+        Reference<XComponentContext> ctx;
+
+        // getLibDir() must be called in order to set bootstrap variables correctly !
+        OUString path( getLibDir());
+        if( Runtime::isInitialized() )
+        {
+            Runtime runtime;
+            ctx = runtime.getImpl()->cargo->xContext;
+        }
+        else
+        {
+            if( path.isEmpty() )
+            {
+                PyErr_SetString(
+                    PyExc_RuntimeError, "osl_getUrlFromAddress fails, that's why I cannot find ini "
+                    "file for bootstrapping python uno bridge\n" );
+                return nullptr;
+            }
+
+            OUString iniFile = path +
+#ifdef MACOSX
+                    "/../" LIBO_ETC_FOLDER
+#endif
+                    "/" SAL_CONFIGFILE( "pyuno" );
+            osl::DirectoryItem item;
+            if( osl::DirectoryItem::get( iniFile, item ) == osl::FileBase::E_None )
+            {
+                // in case pyuno.ini exists, use this file for bootstrapping
+                PyThreadDetach antiguard;
+                ctx = cppu::defaultBootstrap_InitialComponentContext (iniFile);
+            }
+            else
+            {
+                // defaulting to the standard bootstrapping
+                PyThreadDetach antiguard;
+                ctx = cppu::defaultBootstrap_InitialComponentContext ();
+            }
+
+        }
+
+        if( ! Runtime::isInitialized() )
+        {
+            Runtime::initialize( ctx );
+        }
+        Runtime runtime;
+        ret = runtime.any2PyObject( makeAny( ctx ) );
+    }
+    catch (const css::registry::InvalidRegistryException &e)
+    {
+        // can't use raisePyExceptionWithAny() here, because the function
+        // does any conversions, which will not work with a
+        // wrongly bootstrapped pyuno!
+        raisePySystemException( "InvalidRegistryException", e.Message );
+    }
+    catch(const css::lang::IllegalArgumentException & e)
+    {
+        raisePySystemException( "IllegalArgumentException", e.Message );
+    }
+    catch(const css::script::CannotConvertException & e)
+    {
+        raisePySystemException( "CannotConvertException", e.Message );
+    }
+    catch (const css::uno::RuntimeException & e)
+    {
+        raisePySystemException( "RuntimeException", e.Message );
+    }
+    catch (const css::uno::Exception & e)
+    {
+        raisePySystemException( "uno::Exception", e.Message );
+    }
+    return ret.getAcquired();
+}
+
+// While pyuno.private_initTestEnvironment is called from individual Python tests (e.g., from
+// UnoInProcess in unotest/source/python/org/libreoffice/unotest.py, which makes sure to call it
+// only once), pyuno.private_deinitTestEnvironment is called centrally from
+// unotest/source/python/org/libreoffice/unittest.py at the end of every PythonTest (to DeInitVCL
+// exactly once near the end of the process, if InitVCL has ever been called via
+// pyuno.private_initTestEnvironment):
+
+static osl::Module * testModule = nullptr;
+
+static PyObject* initTestEnvironment(
+    SAL_UNUSED_PARAMETER PyObject*, SAL_UNUSED_PARAMETER PyObject*)
+{
+    // this tries to bootstrap enough of the soffice from python to run
+    // unit tests, which is only possible indirectly because pyuno is URE
+    // so load "test" library and invoke a function there to do the work
+    assert(testModule == nullptr);
+    try
+    {
+        PyObject *const ctx(getComponentContext(nullptr, nullptr));
+        if (!ctx) { abort(); }
+        Runtime const runtime;
+        Any const a(runtime.pyObject2Any(ctx));
+        Reference<XComponentContext> xContext;
+        a >>= xContext;
+        if (!xContext.is()) { abort(); }
+        using css::lang::XMultiServiceFactory;
+        Reference<XMultiServiceFactory> const xMSF(
+            xContext->getServiceManager(),
+            css::uno::UNO_QUERY_THROW);
+        char *const testlib = getenv("TEST_LIB");
+        if (!testlib) { abort(); }
+#ifdef _WIN32
+        OString const libname = OString(testlib, strlen(testlib))
+            .replaceAll(OString('/'), OString('\\'));
+#else
+        OString const libname(testlib, strlen(testlib));
+#endif
+
+        osl::Module &mod = runtime.getImpl()->cargo->testModule;
+        mod.load(OStringToOUString(libname, osl_getThreadTextEncoding()),
+                                SAL_LOADMODULE_LAZY | SAL_LOADMODULE_GLOBAL);
+        if (!mod.is()) { abort(); }
+        oslGenericFunction const pFunc(
+                mod.getFunctionSymbol("test_init"));
+        if (!pFunc) { abort(); }
+        reinterpret_cast<void (SAL_CALL *)(XMultiServiceFactory*)>(pFunc)(xMSF.get());
+        testModule = &mod;
+    }
+    catch (const css::uno::Exception &)
+    {
+        abort();
+    }
+    return Py_None;
+}
+
+static PyObject* deinitTestEnvironment(
+    SAL_UNUSED_PARAMETER PyObject*, SAL_UNUSED_PARAMETER PyObject*)
+{
+    if (testModule != nullptr)
+    {
+        try
+        {
+            oslGenericFunction const pFunc(
+                    testModule->getFunctionSymbol("test_deinit"));
+            if (!pFunc) { abort(); }
+            reinterpret_cast<void (SAL_CALL *)()>(pFunc)();
+        }
+        catch (const css::uno::Exception &)
+        {
+            abort();
+        }
+    }
+    return Py_None;
+}
+
+PyObject * extractOneStringArg( PyObject *args, char const *funcName )
+{
+    if( !PyTuple_Check( args ) || PyTuple_Size( args) != 1 )
+    {
+        OString buf = funcName + OStringLiteral(": expecting one string argument");
+        PyErr_SetString( PyExc_RuntimeError, buf.getStr() );
+        return nullptr;
+    }
+    PyObject *obj = PyTuple_GetItem( args, 0 );
+    if (!PyUnicode_Check(obj))
+    {
+        OString buf = funcName + OStringLiteral(": expecting one string argument");
+        PyErr_SetString( PyExc_TypeError, buf.getStr());
+        return nullptr;
+    }
+    return obj;
+}
+
+static PyObject *createUnoStructHelper(
+    SAL_UNUSED_PARAMETER PyObject *, PyObject* args, PyObject* keywordArgs)
+{
+    Any IdlStruct;
+    PyRef ret;
+    try
+    {
+        Runtime runtime;
+        if( PyTuple_Size( args ) == 2 )
+        {
+            PyObject *structName = PyTuple_GetItem(args, 0);
+            PyObject *initializer = PyTuple_GetItem(args, 1);
+
+            if (PyUnicode_Check(structName))
+            {
+                if( PyTuple_Check( initializer ) && PyDict_Check ( keywordArgs ) )
+                {
+                    OUString typeName( OUString::createFromAscii(PyUnicode_AsUTF8(structName)));
+                    RuntimeCargo *c = runtime.getImpl()->cargo;
+                    Reference<XIdlClass> idl_class = c->xCoreReflection->forName (typeName);
+                    if (idl_class.is ())
+                    {
+                        idl_class->createObject (IdlStruct);
+                        PyRef returnCandidate( PyUNOStruct_new( IdlStruct, c->xInvocation ) );
+                        PyUNO *me = reinterpret_cast<PyUNO*>( returnCandidate.get() );
+                        TypeDescription desc( typeName );
+                        OSL_ASSERT( desc.is() ); // could already instantiate an XInvocation2 !
+
+                        typelib_CompoundTypeDescription *pCompType =
+                            reinterpret_cast<typelib_CompoundTypeDescription *>(desc.get());
+                        fillStructState state;
+                        if ( PyTuple_Size( initializer ) > 0 || PyDict_Size( keywordArgs ) > 0 )
+                            fillStruct( me->members->xInvocation, pCompType, initializer, keywordArgs, state, runtime );
+                        if( state.getCntConsumed() != PyTuple_Size(initializer) )
+                        {
+                            throw RuntimeException( "pyuno._createUnoStructHelper: too many "
+                                "elements in the initializer list, expected " +
+                                OUString::number(state.getCntConsumed()) + ", got " +
+                                OUString::number( PyTuple_Size(initializer) ) );
+                        }
+                        ret = PyRef( PyTuple_Pack(2, returnCandidate.get(), state.getUsed()), SAL_NO_ACQUIRE);
+                    }
+                    else
+                    {
+                        OStringBuffer buf;
+                        buf.append( "UNO struct " );
+                        buf.append( PyUnicode_AsUTF8(structName) );
+                        buf.append( " is unknown" );
+                        PyErr_SetString (PyExc_RuntimeError, buf.getStr());
+                    }
+                }
+                else
+                {
+                    PyErr_SetString(
+                        PyExc_RuntimeError,
+                        "pyuno._createUnoStructHelper: 2nd argument (initializer sequence) is no tuple" );
+                }
+            }
+            else
+            {
+                PyErr_SetString (PyExc_AttributeError, "createUnoStruct: first argument wasn't a string");
+            }
+        }
+        else
+        {
+            PyErr_SetString (PyExc_AttributeError, "pyuno._createUnoStructHelper: expects exactly two non-keyword arguments:\n\tStructure Name\n\tinitialiser tuple; may be the empty tuple");
+        }
+    }
+    catch( const css::uno::RuntimeException & e )
+    {
+        raisePyExceptionWithAny( makeAny( e ) );
+    }
+    catch( const css::script::CannotConvertException & e )
+    {
+        raisePyExceptionWithAny( makeAny( e ) );
+    }
+    catch( const css::uno::Exception & e )
+    {
+        raisePyExceptionWithAny( makeAny( e ) );
+    }
+    return ret.getAcquired();
+}
+
+static PyObject *getTypeByName(
+    SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
+{
+    PyObject * ret = nullptr;
+
+    try
+    {
+        char *name;
+
+        if (PyArg_ParseTuple (args, "s", &name))
+        {
+            OUString typeName ( OUString::createFromAscii( name ) );
+            TypeDescription typeDesc( typeName );
+            if( typeDesc.is() )
+            {
+                Runtime runtime;
+                ret = PyUNO_Type_new(
+                    name, static_cast<css::uno::TypeClass>(typeDesc.get()->eTypeClass), runtime );
+            }
+            else
+            {
+                OString buf = OStringLiteral("Type ") + name +  " is unknown";
+                PyErr_SetString( PyExc_RuntimeError, buf.getStr() );
+            }
+        }
+    }
+    catch ( const RuntimeException & e )
+    {
+        raisePyExceptionWithAny( makeAny( e ) );
+    }
+    return ret;
+}
+
+static PyObject *getConstantByName(
+    SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
+{
+    PyObject *ret = nullptr;
+    try
+    {
+        char *name;
+
+        if (PyArg_ParseTuple (args, "s", &name))
+        {
+            OUString typeName ( OUString::createFromAscii( name ) );
+            Runtime runtime;
+            css::uno::Reference< css::reflection::XConstantTypeDescription > td;
+            if (!(runtime.getImpl()->cargo->xTdMgr->getByHierarchicalName(
+                      typeName)
+                  >>= td))
+            {
+                throw RuntimeException( "pyuno.getConstantByName: " + typeName + "is not a constant" );
+            }
+            PyRef constant = runtime.any2PyObject( td->getConstantValue() );
+            ret = constant.getAcquired();
+        }
+    }
+    catch( const NoSuchElementException & e )
+    {
+        // to the python programmer, this is a runtime exception,
+        // do not support tweakings with the type system
+        RuntimeException runExc( e.Message );
+        raisePyExceptionWithAny( makeAny( runExc ) );
+    }
+    catch(const css::script::CannotConvertException & e)
+    {
+        raisePyExceptionWithAny( makeAny( e ) );
+    }
+    catch(const css::lang::IllegalArgumentException & e)
+    {
+        raisePyExceptionWithAny( makeAny( e ) );
+    }
+    catch( const RuntimeException & e )
+    {
+        raisePyExceptionWithAny( makeAny(e) );
+    }
+    return ret;
+}
+
+static PyObject *checkType( SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
+{
+    if( !PyTuple_Check( args ) || PyTuple_Size( args) != 1 )
+    {
+        OString buf = "pyuno.checkType : expecting one uno.Type argument";
+        PyErr_SetString( PyExc_RuntimeError, buf.getStr() );
+        return nullptr;
+    }
+    PyObject *obj = PyTuple_GetItem( args, 0 );
+
+    try
+    {
+        PyType2Type( obj );
+    }
+    catch(const  RuntimeException & e)
+    {
+        raisePyExceptionWithAny( makeAny( e ) );
+        return nullptr;
+    }
+    Py_INCREF( Py_None );
+    return Py_None;
+}
+
+static PyObject *checkEnum( SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
+{
+    if( !PyTuple_Check( args ) || PyTuple_Size( args) != 1 )
+    {
+        OString buf = "pyuno.checkType : expecting one uno.Type argument";
+        PyErr_SetString( PyExc_RuntimeError, buf.getStr() );
+        return nullptr;
+    }
+    PyObject *obj = PyTuple_GetItem( args, 0 );
+
+    try
+    {
+        PyEnum2Enum( obj );
+    }
+    catch(const RuntimeException & e)
+    {
+        raisePyExceptionWithAny( makeAny( e) );
+        return nullptr;
+    }
+    Py_INCREF( Py_None );
+    return Py_None;
+}
+
+static PyObject *getClass( SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
+{
+    PyObject *obj = extractOneStringArg( args, "pyuno.getClass");
+    if( ! obj )
+        return nullptr;
+
+    try
+    {
+        Runtime runtime;
+        PyRef ret = getClass(pyString2ustring(obj), runtime);
+        Py_XINCREF( ret.get() );
+        return ret.get();
+    }
+    catch(const RuntimeException & e)
+    {
+        raisePyExceptionWithAny( makeAny(e) );
+    }
+    return nullptr;
+}
+
+static PyObject *isInterface( SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
+{
+
+    if( PyTuple_Check( args ) && PyTuple_Size( args ) == 1 )
+    {
+        PyObject *obj = PyTuple_GetItem( args, 0 );
+        Runtime r;
+        return PyLong_FromLong( isInterfaceClass( r, obj ) );
+    }
+    return PyLong_FromLong( 0 );
+}
+
+static PyObject * generateUuid(
+    SAL_UNUSED_PARAMETER PyObject *, SAL_UNUSED_PARAMETER PyObject * )
+{
+    Sequence< sal_Int8 > seq( 16 );
+    rtl_createUuid( reinterpret_cast<sal_uInt8*>(seq.getArray()) , nullptr , false );
+    PyRef ret;
+    try
+    {
+        Runtime runtime;
+        ret = runtime.any2PyObject( makeAny( seq ) );
+    }
+    catch( const RuntimeException & e )
+    {
+        raisePyExceptionWithAny( makeAny(e) );
+    }
+    return ret.getAcquired();
+}
+
+static PyObject *systemPathToFileUrl(
+    SAL_UNUSED_PARAMETER PyObject *, PyObject * args )
+{
+    PyObject *obj = extractOneStringArg( args, "pyuno.systemPathToFileUrl" );
+    if( ! obj )
+        return nullptr;
+
+    OUString sysPath = pyString2ustring( obj );
+    OUString url;
+    osl::FileBase::RC e = osl::FileBase::getFileURLFromSystemPath( sysPath, url );
+
+    if( e != osl::FileBase::E_None )
+    {
+        OUString buf = "Couldn't convert " +
+                sysPath +
+                " to a file url for reason (" +
+                OUString::number( static_cast<sal_Int32>(e) ) +
+                ")";
+        raisePyExceptionWithAny(
+            makeAny( RuntimeException( buf )));
+        return nullptr;
+    }
+    return ustring2PyUnicode( url ).getAcquired();
+}
+
+static PyObject * fileUrlToSystemPath(
+    SAL_UNUSED_PARAMETER PyObject *, PyObject * args )
+{
+    PyObject *obj = extractOneStringArg( args, "pyuno.fileUrlToSystemPath" );
+    if( ! obj )
+        return nullptr;
+
+    OUString url = pyString2ustring( obj );
+    OUString sysPath;
+    osl::FileBase::RC e = osl::FileBase::getSystemPathFromFileURL( url, sysPath );
+
+    if( e != osl::FileBase::E_None )
+    {
+        OUString buf = "Couldn't convert file url " +
+                sysPath +
+                " to a system path for reason (" +
+                OUString::number( static_cast<sal_Int32>(e) ) +
+                ")";
+        raisePyExceptionWithAny(
+            makeAny( RuntimeException( buf )));
+        return nullptr;
+    }
+    return ustring2PyUnicode( sysPath ).getAcquired();
+}
+
+static PyObject * absolutize( SAL_UNUSED_PARAMETER PyObject *, PyObject * args )
+{
+    if( PyTuple_Check( args ) && PyTuple_Size( args ) == 2 )
+    {
+        OUString ouPath = pyString2ustring( PyTuple_GetItem( args , 0 ) );
+        OUString ouRel = pyString2ustring( PyTuple_GetItem( args, 1 ) );
+        OUString ret;
+        oslFileError e = osl_getAbsoluteFileURL( ouPath.pData, ouRel.pData, &(ret.pData) );
+        if( e != osl_File_E_None )
+        {
+            OUString buf =
+                    "Couldn't absolutize " +
+                    ouRel +
+                    " using root " +
+                    ouPath +
+                    " for reason (" +
+                    OUString::number(static_cast<sal_Int32>(e) ) +
+                    ")";
+
+            PyErr_SetString(
+                PyExc_OSError,
+                OUStringToOString(buf,osl_getThreadTextEncoding()).getStr());
+            return nullptr;
+        }
+        return ustring2PyUnicode( ret ).getAcquired();
+    }
+    return nullptr;
+}
+
+static PyObject * invoke(SAL_UNUSED_PARAMETER PyObject *, PyObject *args)
+{
+    PyObject *ret = nullptr;
+    if(PyTuple_Check(args) && PyTuple_Size(args) == 3)
+    {
+        PyObject *object = PyTuple_GetItem(args, 0);
+        PyObject *item1 = PyTuple_GetItem(args, 1);
+        if (PyUnicode_Check(item1))
+        {
+            const char *name = PyUnicode_AsUTF8(item1);
+            PyObject *item2 = PyTuple_GetItem(args, 2);
+            if(PyTuple_Check(item2))
+            {
+                ret = PyUNO_invoke(object, name, item2);
+            }
+            else
+            {
+                OStringBuffer buf;
+                buf.append("uno.invoke expects a tuple as 3rd argument, got ");
+                buf.append(PyUnicode_AsUTF8(PyObject_Str(item2)));
+                PyErr_SetString(
+                    PyExc_RuntimeError, buf.makeStringAndClear().getStr());
+            }
+        }
+        else
+        {
+            OStringBuffer buf;
+            buf.append("uno.invoke expected a string as 2nd argument, got ");
+            buf.append(PyUnicode_AsUTF8(PyObject_Str(item1)));
+            PyErr_SetString(
+                PyExc_RuntimeError, buf.makeStringAndClear().getStr());
+        }
+    }
+    else
+    {
+        OString buf = "uno.invoke expects object, name, (arg1, arg2, ... )\n";
+        PyErr_SetString(PyExc_RuntimeError, buf.getStr());
+    }
+    return ret;
+}
+
+static PyObject *getCurrentContext(
+    SAL_UNUSED_PARAMETER PyObject *, SAL_UNUSED_PARAMETER PyObject * )
+{
+    PyRef ret;
+    try
+    {
+        Runtime runtime;
+        ret = runtime.any2PyObject(
+            makeAny( css::uno::getCurrentContext() ) );
+    }
+    catch( const css::uno::Exception & e )
+    {
+        raisePyExceptionWithAny( makeAny( e ) );
+    }
+    return ret.getAcquired();
+}
+
+static PyObject *setCurrentContext(
+    SAL_UNUSED_PARAMETER PyObject *, SAL_UNUSED_PARAMETER PyObject * args )
+{
+    PyRef ret;
+    try
+    {
+        if( PyTuple_Check( args ) && PyTuple_Size( args ) == 1 )
+        {
+
+            Runtime runtime;
+            Any a = runtime.pyObject2Any( PyTuple_GetItem( args, 0 ) );
+
+            Reference< css::uno::XCurrentContext > context;
+
+            if( (a.hasValue() && (a >>= context)) || ! a.hasValue() )
+            {
+                ret = css::uno::setCurrentContext( context ) ? Py_True : Py_False;
+            }
+            else
+            {
+                OStringBuffer buf;
+                buf.append( "uno.setCurrentContext expects an XComponentContext implementation, got " );
+                buf.append(
+                    PyUnicode_AsUTF8(PyObject_Str(PyTuple_GetItem(args, 0))));
+                PyErr_SetString(
+                    PyExc_RuntimeError, buf.makeStringAndClear().getStr() );
+            }
+        }
+        else
+        {
+            OString buf = "uno.setCurrentContext expects exactly one argument (the current Context)\n";
+            PyErr_SetString(
+                PyExc_RuntimeError, buf.getStr() );
+        }
+    }
+    catch( const css::uno::Exception & e )
+    {
+        raisePyExceptionWithAny( makeAny( e ) );
+    }
+    return ret.getAcquired();
+}
+
+static PyObject *sal_debug(
+    SAL_UNUSED_PARAMETER PyObject *, SAL_UNUSED_PARAMETER PyObject * args )
+{
+    Py_INCREF( Py_None );
+    if( !PyTuple_Check( args ) || PyTuple_Size( args) != 1 )
+        return Py_None;
+
+    OUString line = pyString2ustring( PyTuple_GetItem( args, 0 ) );
+
+    SAL_DEBUG(line);
+
+    return Py_None;
+}
+
+}
+
+struct PyMethodDef PyUNOModule_methods [] =
+{
+    {"private_initTestEnvironment", initTestEnvironment, METH_VARARGS, nullptr},
+    {"private_deinitTestEnvironment", deinitTestEnvironment, METH_VARARGS, nullptr},
+    {"getComponentContext", getComponentContext, METH_VARARGS, nullptr},
+    {"_createUnoStructHelper", reinterpret_cast<PyCFunction>(createUnoStructHelper), METH_VARARGS | METH_KEYWORDS, nullptr},
+    {"getTypeByName", getTypeByName, METH_VARARGS, nullptr},
+    {"getConstantByName", getConstantByName, METH_VARARGS, nullptr},
+    {"getClass", getClass, METH_VARARGS, nullptr},
+    {"checkEnum", checkEnum, METH_VARARGS, nullptr},
+    {"checkType", checkType, METH_VARARGS, nullptr},
+    {"generateUuid", generateUuid, METH_VARARGS, nullptr},
+    {"systemPathToFileUrl", systemPathToFileUrl, METH_VARARGS, nullptr},
+    {"fileUrlToSystemPath", fileUrlToSystemPath, METH_VARARGS, nullptr},
+    {"absolutize", absolutize, METH_VARARGS | METH_KEYWORDS, nullptr},
+    {"isInterface", isInterface, METH_VARARGS, nullptr},
+    {"invoke", invoke, METH_VARARGS | METH_KEYWORDS, nullptr},
+    {"setCurrentContext", setCurrentContext, METH_VARARGS, nullptr},
+    {"getCurrentContext", getCurrentContext, METH_VARARGS, nullptr},
+    {"sal_debug", sal_debug, METH_VARARGS, nullptr},
+    {nullptr, nullptr, 0, nullptr}
+};
+
+}
+
+extern "C"
+PyObject* PyInit_pyuno()
+{
+    PyUNO_initType();
+    PyUNOStruct_initType();
+    // noop when called already, otherwise needed to allow multiple threads
+    PyEval_InitThreads();
+    static struct PyModuleDef moduledef =
+    {
+        PyModuleDef_HEAD_INIT,
+        "pyuno",             // module name
+        nullptr,                   // module documentation
+        -1,                  // module keeps state in global variables,
+        PyUNOModule_methods, // modules methods
+        nullptr,                   // m_reload (must be 0)
+        nullptr,                   // m_traverse
+        nullptr,                   // m_clear
+        nullptr,                   // m_free
+    };
+    return PyModule_Create(&moduledef);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */