summaryrefslogtreecommitdiffstats
path: root/cli_ure/source/uno_bridge
diff options
context:
space:
mode:
Diffstat (limited to 'cli_ure/source/uno_bridge')
-rw-r--r--cli_ure/source/uno_bridge/README.txt20
-rw-r--r--cli_ure/source/uno_bridge/cli_base.h171
-rw-r--r--cli_ure/source/uno_bridge/cli_bridge.cxx321
-rw-r--r--cli_ure/source/uno_bridge/cli_bridge.h113
-rw-r--r--cli_ure/source/uno_bridge/cli_data.cxx1929
-rw-r--r--cli_ure/source/uno_bridge/cli_environment.cxx168
-rw-r--r--cli_ure/source/uno_bridge/cli_environment.h105
-rw-r--r--cli_ure/source/uno_bridge/cli_proxy.cxx1105
-rw-r--r--cli_ure/source/uno_bridge/cli_proxy.h294
-rw-r--r--cli_ure/source/uno_bridge/cli_uno.cxx277
10 files changed, 4503 insertions, 0 deletions
diff --git a/cli_ure/source/uno_bridge/README.txt b/cli_ure/source/uno_bridge/README.txt
new file mode 100644
index 000000000..39b3ce364
--- /dev/null
+++ b/cli_ure/source/uno_bridge/README.txt
@@ -0,0 +1,20 @@
+Because of the LoaderLock bug in .NET Framework 1.0 and 1.1 the cli_uno.dll is linked
+with the /NOENTRY switch, which prevent that the C-runtime is initialized when loading
+the dll.
+
+Also I removed all static c++ objects which need construction by the CRT,
+exception handling seems to need an initialised CRT. Therefore
+I added CRT initialization code in uno_initEnvironment (cli_bridge.cxx)
+However there is no deinitialization done because bridge libraries remain
+in memory until the process dies. There is actually no good place where
+this had to be called. If we would do that we would have to implement that
+the bridge can be disposed.
+
+
+Sell also:
+
+http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dv_vstechart/html/vcconmixeddllloadingproblem.asp
+http://support.microsoft.com/?id=814472
+http://www.ddj.com/dept/windows/184416689
+http://blogs.msdn.com/cbrumme/archive/2003/08/20/51504.aspx
+http://msdn2.microsoft.com/en-US/library/ms172219.aspx \ No newline at end of file
diff --git a/cli_ure/source/uno_bridge/cli_base.h b/cli_ure/source/uno_bridge/cli_base.h
new file mode 100644
index 000000000..bca780f7c
--- /dev/null
+++ b/cli_ure/source/uno_bridge/cli_base.h
@@ -0,0 +1,171 @@
+/* -*- Mode: C++; 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 .
+ */
+
+#ifndef INCLUDED_CLI_URE_SOURCE_UNO_BRIDGE_CLI_BASE_H
+#define INCLUDED_CLI_URE_SOURCE_UNO_BRIDGE_CLI_BASE_H
+
+#pragma unmanaged
+// Workaround: osl/mutex.h contains only a forward declaration of _oslMutexImpls.
+// When using the inline class in Mutex in osl/mutex.hxx, the loader needs to find
+// a declaration for the struct. If not found a TypeLoadException is being thrown.
+struct _oslMutexImpl
+{
+};
+#pragma managed
+#include <memory>
+#include "rtl/ustring.hxx"
+#include "typelib/typedescription.hxx"
+
+#using <system.dll>
+
+namespace cli_uno
+{
+System::Type^ loadCliType(System::String ^ typeName);
+System::Type^ mapUnoType(typelib_TypeDescription const * pTD);
+System::Type^ mapUnoType(typelib_TypeDescriptionReference const * pTD);
+typelib_TypeDescriptionReference* mapCliType(System::Type^ cliType);
+OUString mapCliString(System::String ^ data);
+System::String^ mapUnoString(rtl_uString const * data);
+System::String^ mapUnoTypeName(rtl_uString const * typeName);
+
+ref struct Constants
+{
+ static System::String^ sXInterfaceName= gcnew System::String(
+ "unoidl.com.sun.star.uno.XInterface");
+ static System::String^ sObject= gcnew System::String("System.Object");
+ static System::String^ sType= gcnew System::String("System.Type");
+ static System::String^ sUnoidl= gcnew System::String("unoidl.");
+ static System::String^ sVoid= gcnew System::String("System.Void");
+ static System::String^ sAny= gcnew System::String("uno.Any");
+ static System::String^ sArArray= gcnew System::String("System.Array[]");
+ static System::String^ sBoolean= gcnew System::String("System.Boolean");
+ static System::String^ sChar= gcnew System::String("System.Char");
+ static System::String^ sByte= gcnew System::String("System.Byte");
+ static System::String^ sInt16= gcnew System::String("System.Int16");
+ static System::String^ sUInt16= gcnew System::String("System.UInt16");
+ static System::String^ sInt32= gcnew System::String("System.Int32");
+ static System::String^ sUInt32= gcnew System::String("System.UInt32");
+ static System::String^ sInt64= gcnew System::String("System.Int64");
+ static System::String^ sUInt64= gcnew System::String("System.UInt64");
+ static System::String^ sString= gcnew System::String("System.String");
+ static System::String^ sSingle= gcnew System::String("System.Single");
+ static System::String^ sDouble= gcnew System::String("System.Double");
+ static System::String^ sArBoolean= gcnew System::String("System.Boolean[]");
+ static System::String^ sArChar= gcnew System::String("System.Char[]");
+ static System::String^ sArByte= gcnew System::String("System.Byte[]");
+ static System::String^ sArInt16= gcnew System::String("System.Int16[]");
+ static System::String^ sArUInt16= gcnew System::String("System.UInt16[]");
+ static System::String^ sArInt32= gcnew System::String("System.Int32[]");
+ static System::String^ sArUInt32= gcnew System::String("System.UInt32[]");
+ static System::String^ sArInt64= gcnew System::String("System.Int64[]");
+ static System::String^ sArUInt64= gcnew System::String("System.UInt64[]");
+ static System::String^ sArString= gcnew System::String("System.String[]");
+ static System::String^ sArSingle= gcnew System::String("System.Single[]");
+ static System::String^ sArDouble= gcnew System::String("System.Double[]");
+ static System::String^ sArType= gcnew System::String("System.Type[]");
+ static System::String^ sArObject= gcnew System::String("System.Object[]");
+ static System::String^ sBrackets= gcnew System::String("[]");
+ static System::String^ sAttributeSet= gcnew System::String("set_");
+ static System::String^ sAttributeGet= gcnew System::String("get_");
+
+ static System::String^ usXInterface = "com.sun.star.uno.XInterface";
+ static System::String^ usVoid = "void";
+ static System::String^ usType = "type";
+ static System::String^ usAny = "any";
+ static System::String^ usBrackets = "[]";
+ static System::String^ usBool = "boolean";
+ static System::String^ usByte = "byte";
+ static System::String^ usChar = "char";
+ static System::String^ usShort = "short";
+ static System::String^ usUShort = "unsigned short";
+ static System::String^ usLong = "long";
+ static System::String^ usULong = "unsigned long";
+ static System::String^ usHyper = "hyper";
+ static System::String^ usUHyper = "unsigned hyper";
+ static System::String^ usString = "string";
+ static System::String^ usFloat = "float";
+ static System::String^ usDouble = "double";
+};
+
+struct BridgeRuntimeError
+{
+ OUString m_message;
+
+ inline BridgeRuntimeError( OUString const & message )
+ : m_message( message )
+ {}
+};
+
+
+struct rtl_mem
+{
+ inline static void * operator new ( size_t nSize )
+ { return std::malloc( nSize ); }
+ inline static void operator delete ( void * mem )
+ { std::free( mem ); }
+ inline static void * operator new ( size_t, void * mem )
+ { return mem; }
+ inline static void operator delete ( void *, void * )
+ {}
+
+ static inline std::unique_ptr< rtl_mem > allocate( std::size_t bytes );
+};
+
+inline std::unique_ptr< rtl_mem > rtl_mem::allocate( std::size_t bytes )
+{
+ void * p = std::malloc( bytes );
+ if (0 == p)
+ throw BridgeRuntimeError("out of memory!" );
+ return std::unique_ptr< rtl_mem >( (rtl_mem *)p );
+}
+
+
+class TypeDescr
+{
+ typelib_TypeDescription * m_td;
+
+ TypeDescr( TypeDescr const & ) = delete;
+ TypeDescr& operator = ( TypeDescr const & ) = delete;
+
+public:
+ inline explicit TypeDescr( typelib_TypeDescriptionReference * td_ref );
+ inline ~TypeDescr()
+ { TYPELIB_DANGER_RELEASE( m_td ); }
+
+ inline typelib_TypeDescription * get() const
+ { return m_td; }
+};
+
+inline TypeDescr::TypeDescr( typelib_TypeDescriptionReference * td_ref )
+ : m_td( 0 )
+{
+ TYPELIB_DANGER_GET( &m_td, td_ref );
+ if (0 == m_td)
+ {
+ throw BridgeRuntimeError(
+ "cannot get comprehensive type description for " +
+ OUString::unacquired(&td_ref->pTypeName) );
+ }
+}
+
+
+} //end namespace cli_uno
+ #endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cli_ure/source/uno_bridge/cli_bridge.cxx b/cli_ure/source/uno_bridge/cli_bridge.cxx
new file mode 100644
index 000000000..d9b4cdd0b
--- /dev/null
+++ b/cli_ure/source/uno_bridge/cli_bridge.cxx
@@ -0,0 +1,321 @@
+/* -*- Mode: C++; 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 <vcclr.h>
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include "uno/environment.hxx"
+#include "uno/lbnames.h"
+#include "uno/mapping.hxx"
+#include "typelib/typedescription.hxx"
+#include "rtl/ustring.hxx"
+#include <sal/log.hxx>
+
+#include "cli_bridge.h"
+#include "cli_proxy.h"
+
+namespace sri= System::Runtime::InteropServices;
+
+namespace cli_uno
+{
+
+extern "C"
+{
+void SAL_CALL Mapping_acquire( uno_Mapping * mapping )
+ SAL_THROW_EXTERN_C()
+{
+ Mapping const * that = static_cast< Mapping const * >( mapping );
+ that->m_bridge->acquire();
+}
+
+void SAL_CALL Mapping_release( uno_Mapping * mapping )
+ SAL_THROW_EXTERN_C()
+{
+ Mapping const * that = static_cast< Mapping const * >( mapping );
+ that->m_bridge->release();
+}
+
+
+void SAL_CALL Mapping_cli2uno(
+ uno_Mapping * mapping, void ** ppOut,
+ void * pIn, typelib_InterfaceTypeDescription * td )
+ SAL_THROW_EXTERN_C()
+{
+ uno_Interface ** ppUnoI = (uno_Interface **)ppOut;
+ intptr_t cliI = (intptr_t)pIn;
+
+ OSL_ENSURE( ppUnoI && td, "### null ptr!" );
+
+ if (0 != *ppUnoI)
+ {
+ uno_Interface * pUnoI = *(uno_Interface **)ppUnoI;
+ (*pUnoI->release)( pUnoI );
+ *ppUnoI = 0;
+ }
+ try
+ {
+ Mapping const * that = static_cast< Mapping const * >( mapping );
+ Bridge * bridge = that->m_bridge;
+
+ if (0 != cliI)
+ {
+ System::Object^ cliObj= sri::GCHandle::FromIntPtr(IntPtr(cliI)).Target;
+ (*ppOut)= bridge->map_cli2uno(cliObj, (typelib_TypeDescription*) td);
+ }
+ }
+ catch (BridgeRuntimeError & err)
+ {
+ (void) err;
+ SAL_WARN( "cli", "[cli_uno bridge error] " << err.m_message );
+ }
+}
+
+void SAL_CALL Mapping_uno2cli(
+ uno_Mapping * mapping, void ** ppOut,
+ void * pIn, typelib_InterfaceTypeDescription * td )
+ SAL_THROW_EXTERN_C()
+{
+ try
+ {
+ OSL_ENSURE( td && ppOut, "### null ptr!" );
+ OSL_ENSURE( (sizeof(System::Char) == sizeof(sal_Unicode))
+ && (sizeof(System::Boolean) == sizeof(sal_Bool))
+ && (sizeof(System::SByte) == sizeof(sal_Int8))
+ && (sizeof(System::Int16) == sizeof(sal_Int16))
+ && (sizeof(System::UInt16) == sizeof(sal_uInt16))
+ && (sizeof(System::Int32) == sizeof(sal_Int32))
+ && (sizeof(System::UInt32) == sizeof(sal_uInt32))
+ && (sizeof(System::Int64) == sizeof(sal_Int64))
+ && (sizeof(System::UInt64) == sizeof(sal_uInt64))
+ && (sizeof(System::Single) == sizeof(float))
+ && (sizeof(System::Double) == sizeof(double)),
+ "[cli_uno bridge] incompatible .NET data types");
+ intptr_t * ppDNetI = (intptr_t *)ppOut;
+ uno_Interface * pUnoI = (uno_Interface *)pIn;
+
+ Mapping const * that = static_cast< Mapping const * >( mapping );
+ Bridge * bridge = that->m_bridge;
+
+ if (0 != *ppDNetI)
+ {
+ sri::GCHandle::FromIntPtr(IntPtr(ppDNetI)).Free();
+ }
+
+ if (0 != pUnoI)
+ {
+ System::Object^ cliI= bridge->map_uno2cli(pUnoI, td);
+ intptr_t ptr= NULL;
+ if(cliI)
+ {
+ ptr= sri::GCHandle::ToIntPtr(sri::GCHandle::Alloc(cliI))
+#ifdef _WIN64
+ .ToInt64();
+#else /* defined(_WIN32) */
+ .ToInt32();
+#endif
+ }
+ (*ppOut)= reinterpret_cast<void*>(ptr);
+ }
+ }
+ catch (BridgeRuntimeError & err)
+ {
+ (void) err;
+ SAL_WARN( "cli", "[cli_uno bridge error] " << err.m_message );
+ }
+}
+
+
+void SAL_CALL Bridge_free( uno_Mapping * mapping )
+ SAL_THROW_EXTERN_C()
+{
+ Mapping * that = static_cast< Mapping * >( mapping );
+ delete that->m_bridge;
+}
+
+} //extern C
+} //namespace
+
+namespace cli_uno
+{
+
+
+/** ToDo
+ I doubt that the case that the ref count raises from 0 to 1
+ can occur. uno_ext_getMapping returns an acquired mapping. Every time
+ that function is called then a new mapping is created. Following the
+ rules of ref counted objects, then if the ref count is null no one has
+ a reference to the object anymore. Hence no one can call acquire. If someone
+ calls acquire then they must have kept an unacquired pointer which is
+ illegal.
+ */
+void Bridge::acquire() const
+{
+ if (1 == osl_atomic_increment( &m_ref ))
+ {
+ if (m_registered_cli2uno)
+ {
+ uno_Mapping * mapping = const_cast<Mapping*>(&m_cli2uno);
+ uno_registerMapping(
+ const_cast<uno_Mapping**>(&mapping), Bridge_free, m_uno_cli_env, (uno_Environment *)m_uno_env, 0 );
+ }
+ else
+ {
+ uno_Mapping * mapping = const_cast<Mapping*>(&m_uno2cli);
+ uno_registerMapping(
+ &mapping, Bridge_free, (uno_Environment *)m_uno_env, m_uno_cli_env, 0 );
+ }
+ }
+}
+
+void Bridge::release() const
+{
+ if (! osl_atomic_decrement( &m_ref ))
+ {
+ uno_revokeMapping(
+ m_registered_cli2uno
+ ? const_cast<Mapping*>(&m_cli2uno)
+ : const_cast<Mapping*>(&m_uno2cli) );
+ }
+}
+
+Bridge::Bridge(
+ uno_Environment * uno_cli_env, uno_ExtEnvironment * uno_env,
+ bool registered_cli2uno )
+ : m_ref( 1 ),
+ m_uno_env( uno_env ),
+ m_uno_cli_env( uno_cli_env ),
+ m_registered_cli2uno( registered_cli2uno )
+{
+ OSL_ASSERT( 0 != m_uno_cli_env && 0 != m_uno_env );
+ (*((uno_Environment *)m_uno_env)->acquire)( (uno_Environment *)m_uno_env );
+ (*m_uno_cli_env->acquire)( m_uno_cli_env );
+
+ // cli2uno
+ m_cli2uno.acquire = Mapping_acquire;
+ m_cli2uno.release = Mapping_release;
+ m_cli2uno.mapInterface = Mapping_cli2uno;
+ m_cli2uno.m_bridge = this;
+ // uno2cli
+ m_uno2cli.acquire = Mapping_acquire;
+ m_uno2cli.release = Mapping_release;
+ m_uno2cli.mapInterface = Mapping_uno2cli;
+ m_uno2cli.m_bridge = this;
+
+}
+
+
+Bridge::~Bridge()
+{
+ //System::GC::Collect();
+ (*m_uno_cli_env->release)( m_uno_cli_env );
+ (*((uno_Environment *)m_uno_env)->release)( (uno_Environment *)m_uno_env );
+}
+
+
+} //namespace cli_uno
+
+extern "C"
+{
+
+namespace cli_uno
+{
+
+void SAL_CALL cli_env_disposing( uno_Environment * uno_cli_env )
+ SAL_THROW_EXTERN_C()
+{
+ uno_cli_env->pContext = 0;
+}
+
+
+SAL_DLLPUBLIC_EXPORT void SAL_CALL uno_initEnvironment( uno_Environment * uno_cli_env )
+ SAL_THROW_EXTERN_C()
+{
+ //ToDo: remove when compiled with .NET 2
+
+ // Unclear whether the above comment refers to this whole function
+ // or a call to __crt_dll_initialize() that used to be here for
+ // _MSC_VER < 1400
+
+ uno_cli_env->environmentDisposing= cli_env_disposing;
+ uno_cli_env->pExtEnv = 0;
+ //Set the console to print Trace messages
+#if OSL_DEBUG_LEVEL >= 1
+ System::Diagnostics::Trace::Listeners->
+ Add( gcnew System::Diagnostics::TextWriterTraceListener(System::Console::Out));
+#endif
+ OSL_ASSERT( 0 == uno_cli_env->pContext );
+
+ // We let the Cli_environment leak, since there is no good point where we could destruct it.
+ //dispose is not used because we would have then also synchronize the calls to proxies. If the
+ //Cli_environment is disposed, we must prevent all calls, otherwise we may crash at points
+ //where g_cli_env is accessed.
+ //When we compile the bridge with .NET 2 then we can again hold g_cli_env as a static gcroot
+ //member in a unmanaged class, such as Bridge.
+ CliEnvHolder::g_cli_env = gcnew Cli_environment();
+}
+
+SAL_DLLPUBLIC_EXPORT void SAL_CALL uno_ext_getMapping(
+ uno_Mapping ** ppMapping, uno_Environment * pFrom, uno_Environment * pTo )
+ SAL_THROW_EXTERN_C()
+{
+ OSL_ASSERT( 0 != ppMapping && 0 != pFrom && 0 != pTo );
+ if (*ppMapping)
+ {
+ (*(*ppMapping)->release)( *ppMapping );
+ *ppMapping = 0;
+ }
+
+
+ OUString const & from_env_typename = OUString::unacquired(
+ &pFrom->pTypeName );
+ OUString const & to_env_typename = OUString::unacquired( &pTo->pTypeName );
+
+ uno_Mapping * mapping = 0;
+
+ try
+ {
+ if ( from_env_typename == UNO_LB_CLI && to_env_typename == UNO_LB_UNO )
+ {
+ Bridge * bridge = new Bridge( pFrom, pTo->pExtEnv, true ); // ref count = 1
+ mapping = &bridge->m_cli2uno;
+ uno_registerMapping(
+ &mapping, Bridge_free, pFrom, (uno_Environment *)pTo->pExtEnv, 0 );
+ }
+ else if ( from_env_typename == UNO_LB_UNO && to_env_typename == UNO_LB_CLI )
+ {
+ Bridge * bridge = new Bridge( pTo, pFrom->pExtEnv, false ); // ref count = 1
+ mapping = &bridge->m_uno2cli;
+ uno_registerMapping(
+ &mapping, Bridge_free, (uno_Environment *)pFrom->pExtEnv, pTo, 0 );
+ }
+ }
+ catch (BridgeRuntimeError & err)
+ {
+ (void) err;
+ SAL_WARN( "cli", "[cli_uno bridge error] " << err.m_message );
+ }
+ *ppMapping = mapping;
+}
+
+}
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cli_ure/source/uno_bridge/cli_bridge.h b/cli_ure/source/uno_bridge/cli_bridge.h
new file mode 100644
index 000000000..95ddb0394
--- /dev/null
+++ b/cli_ure/source/uno_bridge/cli_bridge.h
@@ -0,0 +1,113 @@
+/* -*- Mode: C++; 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 .
+ */
+
+#ifndef INCLUDED_CLI_URE_SOURCE_UNO_BRIDGE_CLI_BRIDGE_H
+#define INCLUDED_CLI_URE_SOURCE_UNO_BRIDGE_CLI_BRIDGE_H
+#include <vcclr.h>
+#include "osl/interlck.h"
+#include "uno/mapping.h"
+#include "uno/environment.h"
+#include "uno/dispatcher.h"
+#include "cli_base.h"
+#include "cli_environment.h"
+//#using <cli_uretypes.dll>
+#using <cli_basetypes.dll>
+#using <system.dll>
+
+namespace sr = System::Reflection;
+
+namespace cli_uno
+{
+
+
+// holds environments and mappings
+struct Bridge;
+struct Mapping : public uno_Mapping
+{
+ Bridge* m_bridge;
+};
+
+// The environment will be created in uno_initEnvironment. See also the remarks there
+//Managed cli environment for cli objects a UNO proxies (which are cli
+//objects. The uno_Environment is not used for cli objects.
+ref struct CliEnvHolder {
+static Cli_environment ^ g_cli_env = nullptr;
+};
+
+
+/** An instance of Bridge represents exactly one mapping therefore either
+ m_cli2uno or m_uno2cli is valid.
+*/
+struct Bridge
+{
+ mutable oslInterlockedCount m_ref;
+ uno_ExtEnvironment * m_uno_env;
+ uno_Environment * m_uno_cli_env;
+
+ Mapping m_cli2uno;
+ Mapping m_uno2cli;
+ bool m_registered_cli2uno;
+
+ ~Bridge();
+ Bridge( uno_Environment * java_env, uno_ExtEnvironment * uno_env, bool registered_java2uno );
+
+ void acquire() const;
+ void release() const;
+
+ void map_to_uno(
+ void * uno_data, System::Object^ cli_data,
+ typelib_TypeDescriptionReference * type,
+ bool assign) const;
+
+ /**
+ @param info
+ the type of the converted data. It may be a byref type.
+ */
+ void map_to_cli(
+ System::Object^ *cli_data, void const * uno_data,
+ typelib_TypeDescriptionReference * type, System::Type^ info /* maybe 0 */,
+ bool bDontCreateObj) const;
+
+ System::Object^ map_uno2cli(uno_Interface * pUnoI, typelib_InterfaceTypeDescription* pTD) const;
+
+ System::Object^ call_uno(uno_Interface * pUnoI,
+ typelib_TypeDescription* member_td,
+ typelib_TypeDescriptionReference * return_type,
+ sal_Int32 nParams, typelib_MethodParameter const * pParams,
+ array<System::Object^>^ args, array<System::Type^>^ argTypes,
+ System::Object^* pException) const;
+
+
+ void call_cli(
+ System::Object^ cliI, sr::MethodInfo^ method,
+ typelib_TypeDescriptionReference * return_type,
+ typelib_MethodParameter * params, int nParams,
+ void * uno_ret, void * uno_args [], uno_Any ** uno_exc ) const;
+
+ uno_Interface * map_cli2uno(
+ System::Object^ cliI, typelib_TypeDescription* pTD) const;
+
+};
+
+} //namespace cli_uno
+
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cli_ure/source/uno_bridge/cli_data.cxx b/cli_ure/source/uno_bridge/cli_data.cxx
new file mode 100644
index 000000000..72b39df48
--- /dev/null
+++ b/cli_ure/source/uno_bridge/cli_data.cxx
@@ -0,0 +1,1929 @@
+/* -*- Mode: C++; 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 .
+ */
+
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include "windows.h"
+#include <ole2.h>
+
+#include <memory>
+
+#include "rtl/ustring.hxx"
+#include "rtl/ustrbuf.hxx"
+#include "uno/sequence2.h"
+#include "typelib/typedescription.hxx"
+#include "cli_proxy.h"
+#include "cli_base.h"
+#include "cli_bridge.h"
+
+#using <cli_uretypes.dll>
+
+#undef VOID
+
+namespace sri = System::Runtime::InteropServices;
+namespace sr = System::Reflection;
+namespace st = System::Text;
+namespace ucss = unoidl::com::sun::star;
+
+
+namespace cli_uno
+{
+System::String^ mapUnoPolymorphicName(System::String^ unoName);
+OUString mapCliTypeName(System::String^ typeName);
+System::String^ mapCliPolymorphicName(System::String^ unoName);
+System::String^ mapPolymorphicName(System::String^ unoName, bool bCliToUno);
+
+inline std::unique_ptr< rtl_mem > seq_allocate( sal_Int32 nElements, sal_Int32 nSize )
+{
+ std::unique_ptr< rtl_mem > seq(
+ rtl_mem::allocate( SAL_SEQUENCE_HEADER_SIZE + (nElements * nSize) ) );
+ uno_Sequence * p = (uno_Sequence *)seq.get();
+ p->nRefCount = 1;
+ p->nElements = nElements;
+ return seq;
+}
+
+System::Object^ Bridge::map_uno2cli(uno_Interface * pUnoI, typelib_InterfaceTypeDescription *pTD) const
+{
+ System::Object^ retVal= nullptr;
+ // get oid
+ rtl_uString * pOid = 0;
+ (*m_uno_env->getObjectIdentifier)( m_uno_env, &pOid, pUnoI );
+ OSL_ASSERT( 0 != pOid );
+ OUString oid(pOid, SAL_NO_ACQUIRE);
+
+ // see if the interface was already mapped
+ System::Type^ ifaceType= mapUnoType(reinterpret_cast<typelib_TypeDescription*>(pTD));
+ System::String^ sOid= mapUnoString(oid.pData);
+
+ System::Threading::Monitor::Enter( CliEnvHolder::g_cli_env );
+ try
+ {
+ retVal = CliEnvHolder::g_cli_env->getRegisteredInterface(sOid, ifaceType);
+ if (retVal)
+ {
+ // There is already a registered object. It can either be a proxy
+ // for the UNO object or a real cli object. In the first case we
+ // tell the proxy that it shall also represent the current UNO
+ // interface. If it already does that, then it does nothing
+ if (srr::RemotingServices::IsTransparentProxy(retVal))
+ {
+ UnoInterfaceProxy^ p = static_cast<UnoInterfaceProxy^>(
+ srr::RemotingServices::GetRealProxy(retVal));
+ p->addUnoInterface(pUnoI, pTD);
+ }
+ }
+ else
+ {
+ retVal = UnoInterfaceProxy::create(
+ (Bridge *) this, pUnoI, pTD, oid );
+ }
+ }
+ __finally
+ {
+ System::Threading::Monitor::Exit( CliEnvHolder::g_cli_env );
+ }
+
+ return retVal;
+}
+
+uno_Interface* Bridge::map_cli2uno(System::Object^ cliObj, typelib_TypeDescription *pTD) const
+{
+ uno_Interface* retIface = NULL;
+ // get oid from dot net environment
+ System::String^ ds_oid = CliEnvHolder::g_cli_env->getObjectIdentifier( cliObj);
+ OUString ousOid = mapCliString(ds_oid);
+ // look if interface is already mapped
+ m_uno_env->getRegisteredInterface(m_uno_env, (void**) &retIface, ousOid.pData,
+ (typelib_InterfaceTypeDescription*) pTD);
+ if ( ! retIface)
+ {
+ System::Threading::Monitor::Enter(Cli_environment::typeid);
+ try
+ {
+ m_uno_env->getRegisteredInterface(m_uno_env, (void**) &retIface, ousOid.pData,
+ (typelib_InterfaceTypeDescription*) pTD);
+ if ( ! retIface)
+ {
+ retIface = CliProxy::create((Bridge*)this, cliObj, pTD, ousOid);
+ }
+ }
+ __finally
+ {
+ System::Threading::Monitor::Exit(Cli_environment::typeid);
+ }
+ }
+ return retIface;
+}
+
+inline System::Type^ loadCliType(rtl_uString * unoName)
+{
+ return loadCliType(mapUnoTypeName(unoName));
+}
+
+System::Type^ loadCliType(System::String ^ unoName)
+{
+ System::Type^ retVal= nullptr;
+ try
+ {
+ //If unoName denotes a polymorphic type, e.g com.sun.star.beans.Defaulted<System.Char>
+ //then we remove the type list, otherwise the type could not be loaded.
+ bool bIsPolymorphic = false;
+
+ System::String ^ loadName = unoName;
+ int index = unoName->IndexOf('<');
+ if (index != -1)
+ {
+ loadName = unoName->Substring(0, index);
+ bIsPolymorphic = true;
+ }
+ System::AppDomain^ currentDomain = System::AppDomain::CurrentDomain;
+ cli::array<sr::Assembly^>^ assems = currentDomain->GetAssemblies();
+ for (int i = 0; i < assems->Length; i++)
+ {
+ retVal = assems[i]->GetType(loadName, false);
+ if (retVal)
+ break;
+ }
+
+ if (retVal == nullptr)
+ {
+ System::String ^ msg = gcnew System::String("A type could not be loaded: ");
+ msg = System::String::Concat(msg, loadName);
+ throw BridgeRuntimeError(mapCliString(msg));
+ }
+
+ if (bIsPolymorphic)
+ {
+ retVal = uno::PolymorphicType::GetType(retVal, unoName);
+ }
+ }
+ catch( System::Exception ^ e)
+ {
+ OUString ouMessage(mapCliString(e->Message));
+ throw BridgeRuntimeError(ouMessage);
+ }
+ return retVal;
+}
+
+System::Type^ mapUnoType(typelib_TypeDescription const * pTD)
+{
+ return mapUnoType(pTD->pWeakRef);
+}
+
+System::Type^ mapUnoType(typelib_TypeDescriptionReference const * pTD)
+{
+ System::Type ^ retVal = nullptr;
+ switch (pTD->eTypeClass)
+ {
+ case typelib_TypeClass_VOID:
+ retVal= void::typeid; break;
+ case typelib_TypeClass_CHAR:
+ retVal= System::Char::typeid; break;
+ case typelib_TypeClass_BOOLEAN:
+ retVal= System::Boolean::typeid; break;
+ case typelib_TypeClass_BYTE:
+ retVal= System::Byte::typeid; break;
+ case typelib_TypeClass_SHORT:
+ retVal= System::Int16::typeid; break;
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ retVal= System::UInt16::typeid; break;
+ case typelib_TypeClass_LONG:
+ retVal= System::Int32::typeid; break;
+ case typelib_TypeClass_UNSIGNED_LONG:
+ retVal= System::UInt32::typeid; break;
+ case typelib_TypeClass_HYPER:
+ retVal= System::Int64::typeid; break;
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ retVal= System::UInt64::typeid; break;
+ case typelib_TypeClass_FLOAT:
+ retVal= System::Single::typeid; break;
+ case typelib_TypeClass_DOUBLE:
+ retVal= System::Double::typeid; break;
+ case typelib_TypeClass_STRING:
+ retVal= System::String::typeid; break;
+ case typelib_TypeClass_TYPE:
+ retVal= System::Type::typeid; break;
+ case typelib_TypeClass_ANY:
+ retVal= uno::Any::typeid; break;
+ case typelib_TypeClass_ENUM:
+ case typelib_TypeClass_STRUCT:
+ case typelib_TypeClass_EXCEPTION:
+ retVal= loadCliType(pTD->pTypeName); break;
+ case typelib_TypeClass_INTERFACE:
+ {
+ //special handling for XInterface, since it does not exist in cli.
+ OUString usXInterface("com.sun.star.uno.XInterface");
+ if (usXInterface.equals(pTD->pTypeName))
+ retVal= System::Object::typeid;
+ else
+ retVal= loadCliType(pTD->pTypeName);
+ break;
+ }
+ case typelib_TypeClass_SEQUENCE:
+ {
+ css::uno::TypeDescription seqType(
+ const_cast<typelib_TypeDescriptionReference*>(pTD));
+ typelib_TypeDescriptionReference* pElementTDRef=
+ reinterpret_cast<typelib_IndirectTypeDescription*>(seqType.get())->pType;
+ switch (pElementTDRef->eTypeClass)
+ {
+ case typelib_TypeClass_CHAR:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArChar)); break;
+ case typelib_TypeClass_BOOLEAN:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArBoolean));
+ break;
+ case typelib_TypeClass_BYTE:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArByte));
+ break;
+ case typelib_TypeClass_SHORT:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArInt16));
+ break;
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArUInt16));
+ break;
+ case typelib_TypeClass_LONG:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArInt32));
+ break;
+ case typelib_TypeClass_UNSIGNED_LONG:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArUInt32));
+ break;
+ case typelib_TypeClass_HYPER:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArInt64));
+ break;
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArUInt64));
+ break;
+ case typelib_TypeClass_FLOAT:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArSingle));
+ break;
+ case typelib_TypeClass_DOUBLE:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArDouble));
+ break;
+ case typelib_TypeClass_STRING:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArString));
+ break;
+ case typelib_TypeClass_TYPE:
+ retVal= System::Type::GetType(const_cast<System::String^>(Constants::sArType));
+ break;
+ case typelib_TypeClass_ANY:
+ case typelib_TypeClass_ENUM:
+ case typelib_TypeClass_EXCEPTION:
+ case typelib_TypeClass_STRUCT:
+ case typelib_TypeClass_INTERFACE:
+ case typelib_TypeClass_SEQUENCE:
+ {
+ retVal= loadCliType(pTD->pTypeName);
+ break;
+ }
+ default:
+ //All cases should be handled by the case statements above
+ OSL_ASSERT(0);
+ break;
+ }
+ break;
+ }
+ default:
+ OSL_ASSERT(false);
+ break;
+ }
+ return retVal;
+}
+
+/** Returns an acquired td.
+ */
+typelib_TypeDescriptionReference* mapCliType(System::Type^ cliType)
+{
+ typelib_TypeDescriptionReference* retVal= NULL;
+ if (cliType == nullptr)
+ {
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_VOID );
+ typelib_typedescriptionreference_acquire( retVal );
+ return retVal;
+ }
+ //check for Enum first,
+ //because otherwise case System::TypeCode::Int32 applies
+ if (cliType->IsEnum)
+ {
+ OUString usTypeName= mapCliTypeName(cliType->FullName);
+ css::uno::Type unoType(css::uno::TypeClass_ENUM, usTypeName);
+ retVal= unoType.getTypeLibType();
+ typelib_typedescriptionreference_acquire(retVal);
+ }
+ else
+ {
+ switch (System::Type::GetTypeCode(cliType))
+ {
+ case System::TypeCode::Boolean:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_BOOLEAN );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ case System::TypeCode::Char:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_CHAR );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ case System::TypeCode::Byte:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_BYTE );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ case System::TypeCode::Int16:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_SHORT );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ case System::TypeCode::Int32:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_LONG );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ case System::TypeCode::Int64:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_HYPER );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ case System::TypeCode::UInt16:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_UNSIGNED_SHORT );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ case System::TypeCode::UInt32:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_UNSIGNED_LONG );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ case System::TypeCode::UInt64:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_UNSIGNED_HYPER );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ case System::TypeCode::Single:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_FLOAT );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ case System::TypeCode::Double:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_DOUBLE );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ case System::TypeCode::String:
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_STRING );
+ typelib_typedescriptionreference_acquire( retVal );
+ break;
+ default:
+ break;
+ }
+ }
+ if (retVal == NULL)
+ {
+ System::String^ cliTypeName= cliType->FullName;
+ // Void
+ if (const_cast<System::String^>(Constants::sVoid)->Equals(
+ cliTypeName))
+ {
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_VOID );
+ typelib_typedescriptionreference_acquire( retVal );
+ }
+ // Type
+ else if (const_cast<System::String^>(Constants::sType)->Equals(
+ cliTypeName))
+ {
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_TYPE );
+ typelib_typedescriptionreference_acquire( retVal );
+ }
+ // Any
+ else if (const_cast<System::String^>(Constants::sAny)->Equals(
+ cliTypeName))
+ {
+ retVal = * typelib_static_type_getByTypeClass(
+ typelib_TypeClass_ANY );
+ typelib_typedescriptionreference_acquire( retVal );
+ }
+ //struct, interfaces, sequences
+ else
+ {
+ OUString usTypeName;
+ uno::PolymorphicType ^ poly = dynamic_cast<uno::PolymorphicType^>(cliType);
+ if (poly != nullptr)
+ usTypeName = mapCliTypeName( poly->PolymorphicName);
+ else
+ usTypeName = mapCliTypeName(cliTypeName);
+ typelib_TypeDescription* td = NULL;
+ typelib_typedescription_getByName(&td, usTypeName.pData);
+ if (td)
+ {
+ retVal = td->pWeakRef;
+ typelib_typedescriptionreference_acquire(retVal);
+ typelib_typedescription_release(td);
+ }
+ }
+ }
+ if (retVal == NULL)
+ {
+ throw BridgeRuntimeError("[cli_uno bridge] mapCliType():could not map type: " + mapCliString(cliType->FullName));
+ }
+ return retVal;
+}
+
+/**
+ Otherwise a leading "unoidl." is removed.
+ */
+System::String^ mapUnoTypeName(rtl_uString const * typeName)
+{
+ OUString usUnoName( const_cast< rtl_uString * >( typeName ) );
+ st::StringBuilder^ buf= gcnew st::StringBuilder();
+ //determine if the type is a sequence and its dimensions
+ int dims= 0;
+ if (usUnoName[0] == '[')
+ {
+ sal_Int32 index= 1;
+ while (true)
+ {
+ if (usUnoName[index++] == ']')
+ dims++;
+ if (usUnoName[index++] != '[')
+ break;
+ }
+ usUnoName = usUnoName.copy(index - 1);
+ }
+ System::String ^ sUnoName = mapUnoString(usUnoName.pData);
+ if (sUnoName->Equals(const_cast<System::String^>(Constants::usBool)))
+ buf->Append(const_cast<System::String^>(Constants::sBoolean));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usChar)))
+ buf->Append(const_cast<System::String^>(Constants::sChar));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usByte)))
+ buf->Append(const_cast<System::String^>(Constants::sByte));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usShort)))
+ buf->Append(const_cast<System::String^>(Constants::sInt16));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usUShort)))
+ buf->Append(const_cast<System::String^>(Constants::sUInt16));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usLong)))
+ buf->Append(const_cast<System::String^>(Constants::sInt32));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usULong)))
+ buf->Append(const_cast<System::String^>(Constants::sUInt32));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usHyper)))
+ buf->Append(const_cast<System::String^>(Constants::sInt64));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usUHyper)))
+ buf->Append(const_cast<System::String^>(Constants::sUInt64));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usFloat)))
+ buf->Append(const_cast<System::String^>(Constants::sSingle));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usDouble)))
+ buf->Append(const_cast<System::String^>(Constants::sDouble));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usString)))
+ buf->Append(const_cast<System::String^>(Constants::sString));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usVoid)))
+ buf->Append(const_cast<System::String^>(Constants::sVoid));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usType)))
+ buf->Append(const_cast<System::String^>(Constants::sType));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usXInterface)))
+ buf->Append(const_cast<System::String^>(Constants::sObject));
+ else if (sUnoName->Equals(const_cast<System::String^>(Constants::usAny)))
+ {
+ buf->Append(const_cast<System::String^>(Constants::sAny));
+ }
+ else
+ {
+ //put "unoidl." at the beginning
+ buf->Append(const_cast<System::String^>(Constants::sUnoidl));
+ //for polymorphic struct types remove the brackets, e.g mystruct<bool> -> mystruct
+ System::String ^ sName = mapUnoPolymorphicName(sUnoName);
+ buf->Append(sName);
+ }
+ // append []
+ for (;dims--;)
+ buf->Append(const_cast<System::String^>(Constants::sBrackets));
+
+ return buf->ToString();
+}
+
+/** For example, there is a uno type
+ com.sun.star.Foo<char, long>.
+ The values in the type list
+ are uno types and are replaced by cli types, such as System.Char,
+ System.Int32, etc.
+ The prefix unoidl is not added.
+ */
+inline System::String^ mapUnoPolymorphicName(System::String^ unoName)
+{
+ return mapPolymorphicName(unoName, false);
+}
+
+/** For example, there is a type name such as
+ com.sun.star.Foo<System.Char, System.Int32>.
+ The values in the type list
+ are CLI types and are replaced by uno types, such as char,
+ long, etc.
+ The prefix unoidl remains.
+ */
+inline System::String^ mapCliPolymorphicName(System::String^ unoName)
+{
+ return mapPolymorphicName(unoName, true);
+}
+
+System::String^ mapPolymorphicName(System::String^ unoName, bool bCliToUno)
+{
+ int index = unoName->IndexOf('<');
+ if (index == -1)
+ return unoName;
+
+ System::Text::StringBuilder ^ builder = gcnew System::Text::StringBuilder(256);
+ builder->Append(unoName->Substring(0, index +1 ));
+
+ //Find the first occurrence of ','
+ //If the parameter is a polymorphic struct then we need to ignore everything
+ //between the brackets because it can also contain commas
+ //get the type list within < and >
+ int endIndex = unoName->Length - 1;
+ index++;
+ int cur = index;
+ int countParams = 0;
+ while (cur <= endIndex)
+ {
+ System::Char c = unoName[cur];
+ if (c == ',' || c == '>')
+ {
+ //insert a comma if needed
+ if (countParams != 0)
+ builder->Append(",");
+ countParams++;
+ System::String ^ sParam = unoName->Substring(index, cur - index);
+ //skip the comma
+ cur++;
+ //the index to the beginning of the next param
+ index = cur;
+ if (bCliToUno)
+ {
+ builder->Append(mapCliTypeName(sParam).getStr());
+ }
+ else
+ {
+ OUString s = mapCliString(sParam);
+ builder->Append(mapUnoTypeName(s.pData));
+ }
+ }
+ else if (c == '<')
+ {
+ cur++;
+ //continue until the matching '>'
+ int numNested = 0;
+ for (;;cur++)
+ {
+ System::Char curChar = unoName[cur];
+ if (curChar == '<')
+ {
+ numNested ++;
+ }
+ else if (curChar == '>')
+ {
+ if (numNested > 0)
+ numNested--;
+ else
+ break;
+ }
+ }
+ }
+ cur++;
+ }
+
+ builder->Append((System::Char) '>');
+ return builder->ToString();
+}
+
+OUString mapCliTypeName(System::String^ typeName)
+{
+ int dims= 0;
+ // Array? determine the "rank" (number of "[]")
+ // move from the rightmost end to the left, for example
+ // unoidl.PolymorphicStruct<System.Char[]>[]
+ // has only a "dimension" of 1
+ int cur = typeName->Length - 1;
+ bool bRightBracket = false;
+ while (cur >= 0)
+ {
+ System::Char c = typeName[cur];
+ if (c == ']')
+ {
+ bRightBracket = true;
+ }
+ else if (c == '[')
+ {
+ if (!bRightBracket)
+ throw BridgeRuntimeError(
+ "Typename is wrong. No matching brackets for sequence. Name is: " +
+ mapCliString(typeName));
+ bRightBracket = false;
+ dims ++;
+ }
+ else
+ {
+ if (bRightBracket)
+ throw BridgeRuntimeError(
+ "Typename is wrong. No matching brackets for sequence. Name is: " +
+ mapCliString(typeName));
+ break;
+ }
+ cur--;
+ }
+
+ if (bRightBracket || cur < 0)
+ throw BridgeRuntimeError(
+ "Typename is wrong. " +
+ mapCliString(typeName));
+
+ typeName = typeName->Substring(0, cur + 1);
+
+ System::Text::StringBuilder ^ buf = gcnew System::Text::StringBuilder(512);
+
+ //Put the "[]" at the beginning of the uno type name
+ for (;dims--;)
+ buf->Append(const_cast<System::String^>(Constants::usBrackets));
+
+ if (typeName->Equals(const_cast<System::String^>(Constants::sBoolean)))
+ buf->Append(const_cast<System::String^>(Constants::usBool));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sChar)))
+ buf->Append(const_cast<System::String^>(Constants::usChar));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sByte)))
+ buf->Append(const_cast<System::String^>(Constants::usByte));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sInt16)))
+ buf->Append(const_cast<System::String^>(Constants::usShort));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sUInt16)))
+ buf->Append(const_cast<System::String^>(Constants::usUShort));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sInt32)))
+ buf->Append(const_cast<System::String^>(Constants::usLong));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sUInt32)))
+ buf->Append(const_cast<System::String^>(Constants::usULong));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sInt64)))
+ buf->Append(const_cast<System::String^>(Constants::usHyper));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sUInt64)))
+ buf->Append(const_cast<System::String^>(Constants::usUHyper));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sSingle)))
+ buf->Append(const_cast<System::String^>(Constants::usFloat));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sDouble)))
+ buf->Append(const_cast<System::String^>(Constants::usDouble));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sString)))
+ buf->Append(const_cast<System::String^>(Constants::usString));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sVoid)))
+ buf->Append(const_cast<System::String^>(Constants::usVoid));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sType)))
+ buf->Append(const_cast<System::String^>(Constants::usType));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sObject)))
+ buf->Append(const_cast<System::String^>(Constants::usXInterface));
+ else if (typeName->Equals(const_cast<System::String^>(Constants::sAny)))
+ buf->Append(const_cast<System::String^>(Constants::usAny));
+ else
+ {
+ System::String ^ sName = mapCliPolymorphicName(typeName);
+ int i= sName->IndexOf(L'.');
+ buf->Append(sName->Substring(i + 1));
+ }
+ return mapCliString(buf->ToString());
+}
+
+/** Maps uno types to dot net types.
+ * If uno_data is null then the type description is converted to System::Type
+ */
+inline System::String^ mapUnoString( rtl_uString const * data)
+{
+ OSL_ASSERT(data);
+ return gcnew System::String((__wchar_t*) data->buffer, 0, data->length);
+}
+
+OUString mapCliString(System::String ^ data)
+{
+
+ if (data != nullptr)
+ {
+ static_assert(sizeof(wchar_t) == sizeof(sal_Unicode), "char mismatch");
+ pin_ptr<wchar_t const> pdata= PtrToStringChars(data);
+ return OUString(
+ reinterpret_cast<sal_Unicode const *>(pdata),
+ const_cast<System::String^>(data)->Length);
+ }
+ else
+ {
+ return OUString();
+ }
+}
+
+// ToDo convert cli types to expected types, e.g a long to a short where the uno type
+// is a sal_Int16. This could be necessary if a scripting language (typeless) is used
+// @param assign the uno_data has to be destructed (in/out args)
+void Bridge::map_to_uno(void * uno_data, System::Object^ cli_data,
+ typelib_TypeDescriptionReference * type,
+ bool assign) const
+{
+ try{
+ switch (type->eTypeClass)
+ {
+ case typelib_TypeClass_VOID:
+ break;
+ case typelib_TypeClass_CHAR:
+ {
+ System::Char aChar= *safe_cast<System::Char^>(cli_data);
+ *(sal_Unicode*) uno_data= aChar;
+ break;
+ }
+ case typelib_TypeClass_BOOLEAN:
+ {
+ System::Boolean aBool= *safe_cast<System::Boolean^>(cli_data);
+ *(sal_Bool*)uno_data= aBool == true ? sal_True : sal_False;
+ break;
+ }
+ case typelib_TypeClass_BYTE:
+ {
+ System::Byte aByte= *safe_cast<System::Byte^>(cli_data);
+ *(sal_Int8*) uno_data= aByte;
+ break;
+ }
+ case typelib_TypeClass_SHORT:
+ {
+ System::Int16 aShort= *safe_cast<System::Int16^>(cli_data);
+ *(sal_Int16*) uno_data= aShort;
+ break;
+ }
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ {
+ System::UInt16 aUShort= *safe_cast<System::UInt16^>(cli_data);
+ *(sal_uInt16*) uno_data= aUShort;
+ break;
+ }
+ case typelib_TypeClass_LONG:
+ {
+ System::Int32 aLong= *safe_cast<System::Int32^>(cli_data);
+ *(sal_Int32*) uno_data= aLong;
+ break;
+ }
+ case typelib_TypeClass_UNSIGNED_LONG:
+ {
+ System::UInt32 aULong= *safe_cast<System::UInt32^>(cli_data);
+ *(sal_uInt32*) uno_data= aULong;
+ break;
+ }
+ case typelib_TypeClass_HYPER:
+ {
+ System::Int64 aHyper= *safe_cast<System::Int64^>(cli_data);
+ *(sal_Int64*) uno_data= aHyper;
+ break;
+ }
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ {
+ System::UInt64 aLong= *safe_cast<System::UInt64^>(cli_data);
+ *(sal_uInt64*) uno_data= aLong;
+ break;
+ }
+ case typelib_TypeClass_FLOAT:
+ {
+ System::Single aFloat= *safe_cast<System::Single^>(cli_data);
+ *(float*) uno_data= aFloat;
+ break;
+ }
+ case typelib_TypeClass_DOUBLE:
+ {
+ System::Double aDouble= *safe_cast<System::Double^>(cli_data);
+ *(double*) uno_data= aDouble;
+ break;
+ }
+ case typelib_TypeClass_STRING:
+ {
+ if (assign && *(rtl_uString**) uno_data)
+ rtl_uString_release(*(rtl_uString**) uno_data);
+
+ *(rtl_uString **)uno_data = 0;
+ if (cli_data == nullptr)
+ {
+ rtl_uString_new((rtl_uString**) uno_data);
+ }
+ else
+ {
+ System::String ^s= safe_cast<System::String^>(cli_data);
+ pin_ptr<const wchar_t> pdata= PtrToStringChars(s);
+ rtl_uString_newFromStr_WithLength(
+ reinterpret_cast<rtl_uString **>(uno_data),
+ reinterpret_cast<sal_Unicode const *>(pdata), s->Length);
+ }
+ break;
+ }
+ case typelib_TypeClass_TYPE:
+ {
+ typelib_TypeDescriptionReference* td= mapCliType(safe_cast<System::Type^>(
+ cli_data));
+ if (assign)
+ {
+ typelib_typedescriptionreference_release(
+ *(typelib_TypeDescriptionReference **)uno_data );
+ }
+ *(typelib_TypeDescriptionReference **)uno_data = td;
+ break;
+ }
+ case typelib_TypeClass_ANY:
+ {
+ uno_Any * pAny = (uno_Any *)uno_data;
+ if (cli_data == nullptr) // null-ref or uninitialized any maps to empty any
+ {
+ if (assign)
+ uno_any_destruct( pAny, 0 );
+ uno_any_construct( pAny, 0, 0, 0 );
+ break;
+ }
+ uno::Any aAny= *safe_cast<uno::Any^>(cli_data);
+ css::uno::Type value_td( mapCliType(aAny.Type), SAL_NO_ACQUIRE);
+
+ if (assign)
+ uno_any_destruct( pAny, 0 );
+
+ try
+ {
+ switch (value_td.getTypeClass())
+ {
+ case css::uno::TypeClass_VOID:
+ pAny->pData = &pAny->pReserved;
+ break;
+ case css::uno::TypeClass_CHAR:
+ pAny->pData = &pAny->pReserved;
+ *(sal_Unicode*) &pAny->pReserved = *safe_cast<System::Char^>(aAny.Value);
+ break;
+ case css::uno::TypeClass_BOOLEAN:
+ pAny->pData = &pAny->pReserved;
+ *(sal_Bool *) &pAny->pReserved = *safe_cast<System::Boolean^>(aAny.Value);
+ break;
+ case css::uno::TypeClass_BYTE:
+ pAny->pData = &pAny->pReserved;
+ *(sal_Int8*) &pAny->pReserved = *safe_cast<System::Byte^>(aAny.Value);
+ break;
+ case css::uno::TypeClass_SHORT:
+ pAny->pData = &pAny->pReserved;
+ *(sal_Int16*) &pAny->pReserved = *safe_cast<System::Int16^>(aAny.Value);
+ break;
+ case css::uno::TypeClass_UNSIGNED_SHORT:
+ pAny->pData = &pAny->pReserved;
+ *(sal_uInt16*) &pAny->pReserved = *safe_cast<System::UInt16^>(aAny.Value);
+ break;
+ case css::uno::TypeClass_LONG:
+ pAny->pData = &pAny->pReserved;
+ *(sal_Int32*) &pAny->pReserved = *safe_cast<System::Int32^>(aAny.Value);
+ break;
+ case css::uno::TypeClass_UNSIGNED_LONG:
+ pAny->pData = &pAny->pReserved;
+ *(sal_uInt32*) &pAny->pReserved = *safe_cast<System::UInt32^>(aAny.Value);
+ break;
+ case css::uno::TypeClass_HYPER:
+ if (sizeof (sal_Int64) <= sizeof (void *))
+ {
+ pAny->pData = &pAny->pReserved;
+ *(sal_Int64*) &pAny->pReserved = *safe_cast<System::Int64^>(aAny.Value);
+ }
+ else
+ {
+ std::unique_ptr< rtl_mem > mem( rtl_mem::allocate( sizeof (sal_Int64) ) );
+ *(sal_Int64 *) mem.get()= *safe_cast<System::Int64^>(aAny.Value);
+ pAny->pData = mem.release();
+ }
+ break;
+ case css::uno::TypeClass_UNSIGNED_HYPER:
+ if (sizeof (sal_uInt64) <= sizeof (void *))
+ {
+ pAny->pData = &pAny->pReserved;
+ *(sal_uInt64*) &pAny->pReserved = *safe_cast<System::UInt64^>(aAny.Value);
+ }
+ else
+ {
+ std::unique_ptr< rtl_mem > mem( rtl_mem::allocate( sizeof (sal_uInt64) ) );
+ *(sal_uInt64 *) mem.get()= *safe_cast<System::UInt64^>(aAny.Value);
+ pAny->pData = mem.release();
+ }
+ break;
+ case css::uno::TypeClass_FLOAT:
+ if (sizeof (float) <= sizeof (void *))
+ {
+ pAny->pData = &pAny->pReserved;
+ *(float*) &pAny->pReserved = *safe_cast<System::Single^>(aAny.Value);
+ }
+ else
+ {
+ std::unique_ptr< rtl_mem > mem( rtl_mem::allocate( sizeof (float) ) );
+ *(float*) mem.get() = *safe_cast<System::Single^>(aAny.Value);
+ pAny->pData = mem.release();
+ }
+ break;
+ case css::uno::TypeClass_DOUBLE:
+ if (sizeof (double) <= sizeof (void *))
+ {
+ pAny->pData = &pAny->pReserved;
+ *(double*) &pAny->pReserved= *safe_cast<System::Double^>(aAny.Value);
+ }
+ else
+ {
+ std::unique_ptr< rtl_mem > mem( rtl_mem::allocate( sizeof (double) ) );
+ *(double*) mem.get()= *safe_cast<System::Double^>(aAny.Value);
+ pAny->pData= mem.release();
+ }
+ break;
+ case css::uno::TypeClass_STRING: // anies often contain strings; copy string directly
+ {
+ pAny->pData= &pAny->pReserved;
+ OUString _s = mapCliString(static_cast<System::String^>(aAny.Value));
+ pAny->pReserved= _s.pData;
+ rtl_uString_acquire(_s.pData);
+ break;
+ }
+ case css::uno::TypeClass_TYPE:
+ case css::uno::TypeClass_ENUM: //ToDo copy enum direct
+ case css::uno::TypeClass_SEQUENCE:
+ case css::uno::TypeClass_INTERFACE:
+ pAny->pData = &pAny->pReserved;
+ pAny->pReserved = 0;
+ map_to_uno(
+ &pAny->pReserved, aAny.Value, value_td.getTypeLibType(),
+ false /* no assign */);
+ break;
+ case css::uno::TypeClass_STRUCT:
+ case css::uno::TypeClass_EXCEPTION:
+ {
+ css::uno::Type anyType(value_td);
+ typelib_TypeDescription* td= NULL;
+ anyType.getDescription(&td);
+ std::unique_ptr< rtl_mem > mem(rtl_mem::allocate(td->nSize));
+ typelib_typedescription_release(td);
+ map_to_uno(
+ mem.get(), aAny.Value, value_td.getTypeLibType(),
+ false /* no assign */);
+ pAny->pData = mem.release();
+ break;
+ }
+ default:
+ {
+ throw BridgeRuntimeError("[map_to_uno():" + value_td.getTypeName() + "] unsupported value type of any!");
+ }
+ }
+ }
+ catch(System::InvalidCastException^ )
+ {
+// ToDo check this
+ if (assign)
+ uno_any_construct( pAny, 0, 0, 0 ); // restore some valid any
+ OUString str = "[map_to_uno():Any" + value_td.getTypeName() + "]The Any type " + value_td.getTypeName() + " does not correspond to its value type: ";
+ if(aAny.Value != nullptr)
+ {
+ css::uno::Type td(mapCliType(aAny.Value->GetType()), SAL_NO_ACQUIRE);
+ str += td.getTypeName();
+ }
+ if (assign)
+ uno_any_construct( pAny, 0, 0, 0 ); // restore some valid any
+ throw BridgeRuntimeError(str);
+ }
+ catch (BridgeRuntimeError& )
+ {
+ if (assign)
+ uno_any_construct( pAny, 0, 0, 0 ); // restore some valid any
+ throw;
+ }
+ catch (...)
+ {
+ if (assign)
+ uno_any_construct( pAny, 0, 0, 0 ); // restore some valid any
+ throw;
+ }
+
+ pAny->pType = value_td.getTypeLibType();
+ typelib_typedescriptionreference_acquire(pAny->pType);
+ break;
+ }
+ case typelib_TypeClass_ENUM:
+ {
+ // InvalidCastException is caught at the end of this method
+ System::Int32 aEnum= System::Convert::ToInt32((cli_data));
+ *(sal_Int32*) uno_data = aEnum;
+ break;
+ }
+ case typelib_TypeClass_STRUCT:
+ case typelib_TypeClass_EXCEPTION:
+ {
+ css::uno::TypeDescription td(type);
+ typelib_CompoundTypeDescription * comp_td =
+ (typelib_CompoundTypeDescription*) td.get();
+
+ typelib_StructTypeDescription * struct_td = NULL;
+ if (type->eTypeClass == typelib_TypeClass_STRUCT)
+ struct_td = (typelib_StructTypeDescription*) td.get();
+
+ if ( ! ((typelib_TypeDescription*) comp_td)->bComplete)
+ ::typelib_typedescription_complete(
+ (typelib_TypeDescription**) & comp_td );
+
+ sal_Int32 nMembers = comp_td->nMembers;
+ boolean bException= false;
+ System::Type^ cliType = nullptr;
+ if (cli_data)
+ cliType = cli_data->GetType();
+
+ if (0 != comp_td->pBaseTypeDescription)
+ {
+ map_to_uno(
+ uno_data, cli_data,
+ ((typelib_TypeDescription *)comp_td->pBaseTypeDescription)->pWeakRef,
+ assign);
+ }
+ sal_Int32 nPos = 0;
+ try
+ {
+ OUString usUnoException("com.sun.star.uno.Exception");
+ for (; nPos < nMembers; ++nPos)
+ {
+ typelib_TypeDescriptionReference * member_type= comp_td->ppTypeRefs[nPos];
+ System::Object^ val= nullptr;
+ if (cli_data != nullptr)
+ {
+ sr::FieldInfo^ aField= cliType->GetField(
+ mapUnoString(comp_td->ppMemberNames[nPos]));
+ // special case for Exception.Message property
+ // The com.sun.star.uno.Exception.Message field is mapped to the
+ // System.Exception property. Type.GetField("Message") returns null
+ if ( ! aField && usUnoException.equals(td.get()->pTypeName))
+ {// get Exception.Message property
+ OUString usMessageMember("Message");
+ if (usMessageMember.equals(comp_td->ppMemberNames[nPos]))
+ {
+ sr::PropertyInfo^ pi= cliType->GetProperty(
+ mapUnoString(comp_td->ppMemberNames[nPos]));
+ val= pi->GetValue(cli_data, nullptr);
+ }
+ else
+ {
+ throw BridgeRuntimeError("[map_to_uno(): Member: " + OUString::unacquired(&comp_td->ppMemberNames[nPos]));
+ }
+ }
+ else
+ {
+ val= aField->GetValue(cli_data);
+ }
+ }
+ void * p = (char *) uno_data + comp_td->pMemberOffsets[ nPos ];
+ //When using polymorphic structs then the parameterized members can be null.
+ //Then we set a default value.
+ bool bDefault = (struct_td != NULL
+ && struct_td->pParameterizedTypes != NULL
+ && struct_td->pParameterizedTypes[nPos] == sal_True
+ && val == nullptr)
+ || cli_data == nullptr;
+ switch (member_type->eTypeClass)
+ {
+ case typelib_TypeClass_CHAR:
+ if (bDefault)
+ *(sal_Unicode*) p = 0;
+ else
+ *(sal_Unicode*) p = *safe_cast<System::Char^>(val);
+ break;
+ case typelib_TypeClass_BOOLEAN:
+ if (bDefault)
+ *(sal_Bool*) p = sal_False;
+ else
+ *(sal_Bool*) p = *safe_cast<System::Boolean^>(val);
+ break;
+ case typelib_TypeClass_BYTE:
+ if (bDefault)
+ *(sal_Int8*) p = 0;
+ else
+ *(sal_Int8*) p = *safe_cast<System::Byte^>(val);
+ break;
+ case typelib_TypeClass_SHORT:
+ if (bDefault)
+ *(sal_Int16*) p = 0;
+ else
+ *(sal_Int16*) p = *safe_cast<System::Int16^>(val);
+ break;
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ if (bDefault)
+ *(sal_uInt16*) p = 0;
+ else
+ *(sal_uInt16*) p = *safe_cast<System::UInt16^>(val);
+ break;
+ case typelib_TypeClass_LONG:
+ if (bDefault)
+ *(sal_Int32*) p = 0;
+ else
+ *(sal_Int32*) p = *safe_cast<System::Int32^>(val);
+ break;
+ case typelib_TypeClass_UNSIGNED_LONG:
+ if (bDefault)
+ *(sal_uInt32*) p = 0;
+ else
+ *(sal_uInt32*) p = *safe_cast<System::UInt32^>(val);
+ break;
+ case typelib_TypeClass_HYPER:
+ if (bDefault)
+ *(sal_Int64*) p = 0;
+ else
+ *(sal_Int64*) p = *safe_cast<System::Int64^>(val);
+ break;
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ if (bDefault)
+ *(sal_uInt64*) p = 0;
+ else
+ *(sal_uInt64*) p= *safe_cast<System::UInt64^>(val);
+ break;
+ case typelib_TypeClass_FLOAT:
+ if (bDefault)
+ *(float*) p = 0.;
+ else
+ *(float*) p = *safe_cast<System::Single^>(val);
+ break;
+ case typelib_TypeClass_DOUBLE:
+ if (bDefault)
+ *(double*) p = 0.;
+ else
+ *(double*) p = *safe_cast<System::Double^>(val);
+ break;
+ default:
+ { // ToDo enum, should be converted here
+ map_to_uno(p, val, member_type, assign);
+ break;
+ }
+ }
+ }
+ }
+ catch (BridgeRuntimeError& e)
+ {
+ bException= true;
+ OUString str = "[map_to_uno():";
+ if (cliType)
+ {
+ str += mapCliString(cliType->FullName) + "." + OUString::unacquired(&comp_td->ppMemberNames[nPos]) + " ";
+ }
+ str += e.m_message;
+ throw BridgeRuntimeError(str);
+ }
+ catch (System::InvalidCastException^ )
+ {
+ bException= true;
+ OUString str = "[map_to_uno():";
+ if (cliType)
+ {
+ str += mapCliString(cliType->FullName) + "." + OUString::unacquired(&comp_td->ppMemberNames[nPos]);
+ }
+ str += "] Value has not the required type.";
+ throw BridgeRuntimeError(str);
+ }
+ catch (...)
+ {
+ OSL_ASSERT(0);
+ bException= true;
+ throw;
+ }
+ __finally
+ {
+ if (bException && !assign) // if assign then caller cleans up
+ {
+ // cleanup the members which we have converted so far
+ for ( sal_Int32 nCleanup = 0; nCleanup < nPos; ++nCleanup )
+ {
+ uno_type_destructData(
+ uno_data, comp_td->ppTypeRefs[ nCleanup ], 0 );
+ }
+ if (0 != comp_td->pBaseTypeDescription)
+ {
+ uno_destructData(
+ uno_data, (typelib_TypeDescription *)comp_td->pBaseTypeDescription, 0 );
+ }
+ }
+ }
+ break;
+ }
+ case typelib_TypeClass_SEQUENCE:
+ {
+ TypeDescr td( type );
+ typelib_TypeDescriptionReference * element_type =
+ ((typelib_IndirectTypeDescription *)td.get())->pType;
+
+ std::unique_ptr< rtl_mem > seq;
+
+ System::Array^ ar = nullptr;
+ if (cli_data != nullptr)
+ {
+ ar = safe_cast<System::Array^>(cli_data);
+ sal_Int32 nElements = ar->GetLength(0);
+
+ try
+ {
+ switch (element_type->eTypeClass)
+ {
+ case typelib_TypeClass_CHAR:
+ seq = seq_allocate(nElements, sizeof (sal_Unicode));
+ sri::Marshal::Copy(safe_cast<cli::array<System::Char>^>(cli_data), 0,
+ IntPtr(& ((uno_Sequence*) seq.get())->elements), nElements);
+ break;
+ case typelib_TypeClass_BOOLEAN:
+ seq = seq_allocate(nElements, sizeof (sal_Bool));
+ sri::Marshal::Copy(safe_cast<cli::array<System::Char>^>(cli_data), 0,
+ IntPtr(& ((uno_Sequence*) seq.get())->elements), nElements);
+ break;
+ case typelib_TypeClass_BYTE:
+ seq = seq_allocate( nElements, sizeof (sal_Int8) );
+ sri::Marshal::Copy(safe_cast<cli::array<System::Byte>^>(cli_data), 0,
+ IntPtr(& ((uno_Sequence*) seq.get())->elements), nElements);
+ break;
+ case typelib_TypeClass_SHORT:
+ seq = seq_allocate(nElements, sizeof (sal_Int16));
+ sri::Marshal::Copy(safe_cast<cli::array<System::Int16>^>(cli_data), 0,
+ IntPtr(& ((uno_Sequence*) seq.get())->elements), nElements);
+ break;
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ seq = seq_allocate( nElements, sizeof (sal_uInt16) );
+ sri::Marshal::Copy(dynamic_cast<cli::array<System::Int16>^>(
+ safe_cast<cli::array<System::UInt16>^>(cli_data)), 0,
+ IntPtr(& ((uno_Sequence*) seq.get())->elements), nElements);
+ break;
+ case typelib_TypeClass_LONG:
+ seq = seq_allocate(nElements, sizeof (sal_Int32));
+ sri::Marshal::Copy(safe_cast<cli::array<System::Int32>^>(cli_data), 0,
+ IntPtr(& ((uno_Sequence*) seq.get())->elements), nElements);
+ break;
+ case typelib_TypeClass_UNSIGNED_LONG:
+ seq = seq_allocate( nElements, sizeof (sal_uInt32) );
+ sri::Marshal::Copy(dynamic_cast<cli::array<System::Int32>^>(
+ safe_cast<cli::array<System::UInt32>^>(cli_data)), 0,
+ IntPtr(& ((uno_Sequence*) seq.get())->elements), nElements);
+ break;
+ case typelib_TypeClass_HYPER:
+ seq = seq_allocate(nElements, sizeof (sal_Int64));
+ sri::Marshal::Copy(safe_cast<cli::array<System::Int64>^>(cli_data), 0,
+ IntPtr(& ((uno_Sequence*) seq.get())->elements), nElements);
+ break;
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ seq = seq_allocate(nElements, sizeof (sal_uInt64));
+ sri::Marshal::Copy(dynamic_cast<cli::array<System::Int64>^>(
+ safe_cast<cli::array<System::UInt64>^>(cli_data)), 0,
+ IntPtr(& ((uno_Sequence*) seq.get())->elements), nElements);
+ break;
+ case typelib_TypeClass_FLOAT:
+ seq = seq_allocate(nElements, sizeof (float));
+ sri::Marshal::Copy(safe_cast<cli::array<System::Single>^>(cli_data), 0,
+ IntPtr(& ((uno_Sequence*) seq.get())->elements), nElements);
+ break;
+ case typelib_TypeClass_DOUBLE:
+ seq = seq_allocate(nElements, sizeof (double));
+ sri::Marshal::Copy(safe_cast<cli::array<System::Double>^>(cli_data), 0,
+ IntPtr(& ((uno_Sequence*) seq.get())->elements), nElements);
+ break;
+ case typelib_TypeClass_STRING:
+ {
+ seq = seq_allocate(nElements, sizeof (rtl_uString*));
+ cli::array<System::String^>^ arStr= safe_cast<cli::array<System::String^>^>(cli_data);
+ for (int i= 0; i < nElements; i++)
+ {
+ pin_ptr<const wchar_t> pdata= PtrToStringChars(arStr[i]);
+ rtl_uString** pStr= & ((rtl_uString**) &
+ ((uno_Sequence*) seq.get())->elements)[i];
+ *pStr= NULL;
+ rtl_uString_newFromStr_WithLength(
+ pStr,
+ reinterpret_cast<sal_Unicode const *>(pdata),
+ arStr[i]->Length);
+ }
+ break;
+ }
+ case typelib_TypeClass_ENUM:
+ seq = seq_allocate(nElements, sizeof (sal_Int32));
+ for (int i= 0; i < nElements; i++)
+ {
+ ((sal_Int32*) &((uno_Sequence*) seq.get())->elements)[i]=
+ System::Convert::ToInt32(ar->GetValue(i));
+ }
+ break;
+ case typelib_TypeClass_TYPE:
+ case typelib_TypeClass_ANY:
+ case typelib_TypeClass_STRUCT:
+ case typelib_TypeClass_EXCEPTION:
+ case typelib_TypeClass_SEQUENCE:
+ case typelib_TypeClass_INTERFACE:
+ {
+ TypeDescr element_td( element_type );
+ seq = seq_allocate( nElements, element_td.get()->nSize );
+
+ for (sal_Int32 nPos = 0; nPos < nElements; ++nPos)
+ {
+ try
+ {
+ void * p= ((uno_Sequence *) seq.get())->elements +
+ (nPos * element_td.get()->nSize);
+ System::Object^ elemData= safe_cast<System::Array^>(cli_data)->GetValue(System::Int32(nPos));
+ map_to_uno(
+ p, elemData, element_td.get()->pWeakRef,
+ false /* no assign */);
+ }
+ catch (...)
+ {
+ // cleanup
+ for ( sal_Int32 nCleanPos = 0; nCleanPos < nPos; ++nCleanPos )
+ {
+ void * p =
+ ((uno_Sequence *)seq.get())->elements +
+ (nCleanPos * element_td.get()->nSize);
+ uno_destructData( p, element_td.get(), 0 );
+ }
+ throw;
+ }
+ }
+ break;
+ }
+ default:
+ {
+ throw BridgeRuntimeError("[map_to_uno():" + OUString::unacquired( &type->pTypeName ) +
+ "] unsupported sequence element type: " + OUString::unacquired( &element_type->pTypeName ));
+ }
+ }
+ }
+ catch (BridgeRuntimeError& e)
+ {
+ throw BridgeRuntimeError("[map_to_uno():" + OUString::unacquired( &type->pTypeName ) + "] conversion failed\n " + e.m_message);
+ }
+ catch (System::InvalidCastException^ )
+ {
+ // Ok, checked
+ throw BridgeRuntimeError("[map_to_uno():" + OUString::unacquired( &type->pTypeName) +
+ "] could not convert sequence element type: " + OUString::unacquired( &element_type->pTypeName ));
+ }
+ catch (...)
+ {
+ OSL_ASSERT(0);
+ throw;
+ }
+ __finally
+ {
+ if (assign)
+ uno_destructData( uno_data, td.get(), 0 );
+ }
+ }
+ else
+ {
+ seq = seq_allocate(0, sizeof (sal_Int32));
+ }
+ *(uno_Sequence **)uno_data = (uno_Sequence *)seq.release();
+ break;
+ }
+ case typelib_TypeClass_INTERFACE:
+ {
+ if (assign)
+ {
+ uno_Interface * p = *(uno_Interface **)uno_data;
+ if (0 != p)
+ (*p->release)( p );
+ }
+ if (nullptr == cli_data) // null-ref
+ {
+ *(uno_Interface **)uno_data = 0;
+ }
+ else
+ {
+ TypeDescr td( type );
+ uno_Interface * pUnoI = map_cli2uno(cli_data, td.get());
+ *(uno_Interface **)uno_data = pUnoI;
+ }
+ break;
+ }
+ default:
+ {
+ //ToDo check
+ throw BridgeRuntimeError("[map_to_uno():" + OUString::unacquired( &type->pTypeName ) + "] unsupported type!");
+ }
+ }
+ }
+ // BridgeRuntimeError are allowed to be thrown
+ catch (System::InvalidCastException^ )
+ {
+ //ToDo check
+ throw BridgeRuntimeError("[map_to_uno():" + OUString::unacquired( &type->pTypeName ) + "] could not convert type!");
+ }
+ catch (System::NullReferenceException ^ e)
+ {
+ throw BridgeRuntimeError("[map_to_uno()] Illegal null reference passed!\n" + mapCliString(e->StackTrace));
+ }
+ catch (BridgeRuntimeError& )
+ {
+ throw;
+ }
+ catch (...)
+ {
+ OSL_ASSERT(0);
+ throw;
+ }
+}
+
+/**
+ @param info
+ The expected target type. Currently info is provided when this method is called
+ to convert the in/out and out parameters of a call from cli to uno. Then info
+ is always a byref type, e.g. "System.String&". info is used for Any and Enum conversion.
+ @param bDontCreateObj
+ false - a new object is created which holds the mapped uno value and is assigned to
+ cli_data.
+ true - cli_data already contains the newly constructed object. This is the case if
+ a struct is converted then on the first call to map_to_cli the new object is created.
+ If the struct inherits another struct then this function is called recursively while the
+ newly created object is passed in cli_data.
+ */
+void Bridge::map_to_cli(
+ System::Object^ *cli_data, void const * uno_data,
+ typelib_TypeDescriptionReference * type, System::Type^ info,
+ bool bDontCreateObj) const
+{
+ switch (type->eTypeClass)
+ {
+ case typelib_TypeClass_CHAR:
+ *cli_data= *(__wchar_t const*)uno_data;
+ break;
+ case typelib_TypeClass_BOOLEAN:
+ *cli_data = (*(bool const*)uno_data) == sal_True;
+ break;
+ case typelib_TypeClass_BYTE:
+ *cli_data = *(unsigned char const*) uno_data;
+ break;
+ case typelib_TypeClass_SHORT:
+ *cli_data= *(short const*) uno_data;
+ break;
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ *cli_data= *(unsigned short const*) uno_data;
+ break;
+ case typelib_TypeClass_LONG:
+ *cli_data= *(int const*) uno_data;
+ break;
+ case typelib_TypeClass_UNSIGNED_LONG:
+ *cli_data= *(unsigned int const*) uno_data;
+ break;
+ case typelib_TypeClass_HYPER:
+ *cli_data= *(__int64 const*) uno_data;
+ break;
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ *cli_data= *(unsigned __int64 const*) uno_data;
+ break;
+ case typelib_TypeClass_FLOAT:
+ *cli_data= *(float const*) uno_data;
+ break;
+ case typelib_TypeClass_DOUBLE:
+ *cli_data= *(double const*) uno_data;
+ break;
+ case typelib_TypeClass_STRING:
+ {
+ rtl_uString const* sVal= NULL;
+ sVal= *(rtl_uString* const*) uno_data;
+ *cli_data= gcnew System::String((__wchar_t*) sVal->buffer,0, sVal->length);
+ break;
+ }
+ case typelib_TypeClass_TYPE:
+ {
+ *cli_data= mapUnoType( *(typelib_TypeDescriptionReference * const *)uno_data );
+ break;
+ }
+ case typelib_TypeClass_ANY:
+ {
+ uno_Any const * pAny = (uno_Any const *)uno_data;
+ if (typelib_TypeClass_VOID != pAny->pType->eTypeClass)
+ {
+ System::Object^ objCli= nullptr;
+ map_to_cli(
+ &objCli, pAny->pData, pAny->pType, nullptr,
+ false);
+
+ uno::Any anyVal(mapUnoType(pAny->pType), objCli);
+ *cli_data= anyVal;
+ }
+ else
+ { // void any
+ *cli_data= uno::Any::VOID;
+ }
+ break;
+ }
+ case typelib_TypeClass_ENUM:
+ {
+ if (info != nullptr)
+ {
+ OSL_ASSERT(info->IsByRef);
+ info= info->GetElementType();
+ *cli_data= System::Enum::ToObject(info, *(System::Int32*) uno_data);
+ }
+ else
+ *cli_data= System::Enum::ToObject(
+ mapUnoType(type), *(System::Int32*) uno_data);
+ break;
+ }
+ case typelib_TypeClass_STRUCT:
+ case typelib_TypeClass_EXCEPTION:
+ {
+ TypeDescr td( type );
+ typelib_CompoundTypeDescription * comp_td =
+ (typelib_CompoundTypeDescription *) td.get();
+ if ( ! ((typelib_TypeDescription*) comp_td)->bComplete)
+ ::typelib_typedescription_complete(
+ (typelib_TypeDescription**) & comp_td );
+
+
+ //create the type
+ System::Type^ cliType= loadCliType(td.get()->pTypeName);
+ //detect if we recursively convert inherited structures
+ //If this point is reached because of a recursive call during covering a
+ //struct then we must not create a new object rather we use the one in
+ // cli_data argument.
+ System::Object^ cliObj;
+ if (bDontCreateObj)
+ cliObj = *cli_data; // recursive call
+ else
+ {
+ //Special handling for Exception conversion. We must call constructor System::Exception
+ //to pass the message string
+ if (ucss::uno::Exception::typeid->IsAssignableFrom(cliType))
+ {
+ //We need to get the Message field. Therefore we must obtain the offset from
+ //the typedescription. The base interface of all exceptions is
+ //com::sun::star::uno::Exception which contains the message
+ typelib_CompoundTypeDescription* pCTD = comp_td;
+ while (pCTD->pBaseTypeDescription)
+ pCTD = pCTD->pBaseTypeDescription;
+ int nPos = -1;
+
+ OUString usMessageMember("Message");
+ for (int i = 0; i < pCTD->nMembers; i ++)
+ {
+ if (usMessageMember.equals(pCTD->ppMemberNames[i]))
+ {
+ nPos = i;
+ break;
+ }
+ }
+ OSL_ASSERT (nPos != -1);
+ int offset = pCTD->pMemberOffsets[nPos];
+ //With the offset within the exception we can get the message string
+ System::String^ sMessage = mapUnoString(*(rtl_uString**)
+ ((char*) uno_data + offset));
+ //We need to find a constructor for the exception that takes the message string
+ //We assume that the first argument is the message string
+ cli::array<sr::ConstructorInfo^>^ arCtorInfo = cliType->GetConstructors();
+ sr::ConstructorInfo^ ctorInfo = nullptr;
+ int numCtors = arCtorInfo->Length;
+ //Constructor must at least have 2 params for the base
+ //unoidl.com.sun.star.uno.Exception (String, Object);
+ cli::array<sr::ParameterInfo^>^ arParamInfo;
+ for (int i = 0; i < numCtors; i++)
+ {
+ arParamInfo = arCtorInfo[i]->GetParameters();
+ if (arParamInfo->Length < 2)
+ continue;
+ ctorInfo = arCtorInfo[i];
+ break;
+ }
+ OSL_ASSERT(arParamInfo[0]->ParameterType->Equals(System::String::typeid)
+ && arParamInfo[1]->ParameterType->Equals(System::Object::typeid)
+ && arParamInfo[0]->Position == 0
+ && arParamInfo[1]->Position == 1);
+ //Prepare parameters for constructor
+ int numArgs = arParamInfo->Length;
+ cli::array<System::Object^>^ args = gcnew cli::array<System::Object^>(numArgs);
+ //only initialize the first argument with the message
+ args[0] = sMessage;
+ cliObj = ctorInfo->Invoke(args);
+ }
+ else
+ cliObj = System::Activator::CreateInstance(cliType);
+ }
+ sal_Int32 * pMemberOffsets = comp_td->pMemberOffsets;
+
+ if (comp_td->pBaseTypeDescription)
+ {
+ //convert inherited struct
+ //cliObj is passed inout (args in_param, out_param are true), hence the passed
+ // cliObj is used by the callee instead of a newly created struct
+ map_to_cli(
+ &cliObj, uno_data,
+ ((typelib_TypeDescription *)comp_td->pBaseTypeDescription)->pWeakRef, nullptr,
+ true);
+ }
+ OUString usUnoException("com.sun.star.uno.Exception");
+ for (sal_Int32 nPos = comp_td->nMembers; nPos--; )
+ {
+ typelib_TypeDescriptionReference * member_type = comp_td->ppTypeRefs[ nPos ];
+ System::String^ sMemberName= mapUnoString(comp_td->ppMemberNames[nPos]);
+ sr::FieldInfo^ aField= cliType->GetField(sMemberName);
+ // special case for Exception.Message. The field has already been
+ // set while constructing cli object
+ if ( ! aField && usUnoException.equals(td.get()->pTypeName))
+ {
+ continue;
+ }
+ void const * p = (char const *)uno_data + pMemberOffsets[ nPos ];
+ switch (member_type->eTypeClass)
+ {
+ case typelib_TypeClass_CHAR:
+ aField->SetValue(cliObj, *(System::Char*) p);
+ break;
+ case typelib_TypeClass_BOOLEAN:
+ aField->SetValue(cliObj, *(System::Boolean*) p);
+ break;
+ case typelib_TypeClass_BYTE:
+ aField->SetValue(cliObj, *(System::Byte*) p);
+ break;
+ case typelib_TypeClass_SHORT:
+ aField->SetValue(cliObj, *(System::Int16*) p);
+ break;
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ aField->SetValue(cliObj, *(System::UInt16*) p);
+ break;
+ case typelib_TypeClass_LONG:
+ aField->SetValue(cliObj, *(System::Int32*) p);
+ break;
+ case typelib_TypeClass_UNSIGNED_LONG:
+ aField->SetValue(cliObj, *(System::UInt32*) p);
+ break;
+ case typelib_TypeClass_HYPER:
+ aField->SetValue(cliObj, *(System::Int64*) p);
+ break;
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ aField->SetValue(cliObj, *(System::UInt64*) p);
+ break;
+ case typelib_TypeClass_FLOAT:
+ aField->SetValue(cliObj, *(System::Single*) p);
+ break;
+ case typelib_TypeClass_DOUBLE:
+ aField->SetValue(cliObj, *(System::Double*) p);
+ break;
+ default:
+ {
+ System::Object^ cli_val;
+ map_to_cli(
+ &cli_val, p, member_type, nullptr,
+ false);
+ aField->SetValue(cliObj, cli_val);
+ break;
+ }
+ }
+ }
+ *cli_data= cliObj;
+ break;
+ }
+ case typelib_TypeClass_SEQUENCE:
+ {
+ sal_Int32 nElements;
+ uno_Sequence const * seq = 0;
+ seq = *(uno_Sequence * const *)uno_data;
+ nElements = seq->nElements;
+
+ TypeDescr td( type );
+ typelib_TypeDescriptionReference * element_type =
+ ((typelib_IndirectTypeDescription *)td.get())->pType;
+
+ switch (element_type->eTypeClass)
+ {
+ case typelib_TypeClass_CHAR:
+ {
+ cli::array<System::Char>^ arChar= gcnew cli::array<System::Char>(nElements);
+ sri::Marshal::Copy( IntPtr((void*) &seq->elements), arChar, 0, nElements);
+ *cli_data= arChar;
+ break;
+ }
+ case typelib_TypeClass_BOOLEAN:
+ {
+ cli::array<System::Byte>^ arBool= gcnew cli::array<System::Byte>(nElements);
+ sri::Marshal::Copy( IntPtr((void*) &seq->elements), arBool, 0, nElements);
+ *cli_data= dynamic_cast<cli::array<System::Boolean>^>(arBool);
+ break;
+ }
+ case typelib_TypeClass_BYTE:
+ {
+ cli::array<System::Byte>^ arByte= gcnew cli::array<System::Byte>(nElements);
+ sri::Marshal::Copy( IntPtr((void*) &seq->elements), arByte, 0, nElements);
+ *cli_data= arByte;
+ break;
+ }
+ case typelib_TypeClass_SHORT:
+ {
+ cli::array<System::Int16>^ arShort= gcnew cli::array<System::Int16>(nElements);
+ sri::Marshal::Copy( IntPtr((void*) &seq->elements), arShort, 0, nElements);
+ *cli_data= arShort;
+ break;
+ }
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ {
+ cli::array<System::UInt16>^ arUInt16= gcnew cli::array<System::UInt16>(nElements);
+ sri::Marshal::Copy( IntPtr((void*) &seq->elements), dynamic_cast<cli::array<System::Int16>^>(arUInt16),
+ 0, nElements);
+ *cli_data= arUInt16;
+ break;
+ }
+ case typelib_TypeClass_LONG:
+ {
+ cli::array<System::Int32>^ arInt32= gcnew cli::array<System::Int32>(nElements);
+ sri::Marshal::Copy( IntPtr((void*) &seq->elements), arInt32, 0, nElements);
+ *cli_data= arInt32;
+ break;
+ }
+ case typelib_TypeClass_UNSIGNED_LONG:
+ {
+ cli::array<System::UInt32>^ arUInt32= gcnew cli::array<System::UInt32>(nElements);
+ sri::Marshal::Copy( IntPtr((void*) &seq->elements), dynamic_cast<cli::array<System::Int32>^>(arUInt32),
+ 0, nElements);
+ *cli_data= arUInt32;
+ break;
+ }
+ case typelib_TypeClass_HYPER:
+ {
+ cli::array<System::Int64>^ arInt64= gcnew cli::array<System::Int64>(nElements);
+ sri::Marshal::Copy( IntPtr((void*) &seq->elements), arInt64, 0, nElements);
+ *cli_data= arInt64;
+ break;
+ }
+ //FIXME: Marshal::Copy of UInt64?
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ {
+ cli::array<System::IntPtr>^ arUInt64= gcnew cli::array<System::IntPtr>(nElements);
+ sri::Marshal::Copy( IntPtr((void*) &seq->elements), arUInt64, 0, nElements);
+ *cli_data= dynamic_cast<cli::array<System::UInt64>^>(arUInt64);
+ break;
+ }
+ case typelib_TypeClass_FLOAT:
+ {
+ cli::array<System::Single>^ arSingle= gcnew cli::array<System::Single>(nElements);
+ sri::Marshal::Copy( IntPtr((void*) &seq->elements), arSingle, 0, nElements);
+ *cli_data= arSingle;
+ break;
+ }
+ case typelib_TypeClass_DOUBLE:
+ {
+ cli::array<System::Double>^ arDouble= gcnew cli::array<System::Double>(nElements);
+ sri::Marshal::Copy( IntPtr((void*) &seq->elements), arDouble, 0, nElements);
+ *cli_data= arDouble;
+ break;
+ }
+ case typelib_TypeClass_STRING:
+ {
+ cli::array<System::String^>^ arString= gcnew cli::array<System::String^>(nElements);
+ for (int i= 0; i < nElements; i++)
+ {
+ rtl_uString *aStr= ((rtl_uString**)(&seq->elements))[i];
+ arString[i]= gcnew System::String( (__wchar_t *) &aStr->buffer, 0, aStr->length);
+ }
+ *cli_data= arString;
+ break;
+ }
+ case typelib_TypeClass_TYPE:
+ {
+ cli::array<System::Type^>^ arType= gcnew cli::array<System::Type^>(nElements);
+ for (int i= 0; i < nElements; i++)
+ {
+ arType[i]=
+ mapUnoType( ((typelib_TypeDescriptionReference**) seq->elements)[i]);
+ }
+ *cli_data= arType;
+ break;
+ }
+ case typelib_TypeClass_ANY:
+ {
+ cli::array<uno::Any>^ arCli= gcnew cli::array<uno::Any>(nElements);
+ uno_Any const * p = (uno_Any const *)seq->elements;
+ for (sal_Int32 nPos = 0; nPos < nElements; ++nPos )
+ {
+ System::Object^ cli_obj = nullptr;
+ map_to_cli(
+ &cli_obj, &p[ nPos ], element_type, nullptr, false);
+ arCli[nPos]= *safe_cast<uno::Any^>(cli_obj);
+ }
+ *cli_data= arCli;
+ break;
+ }
+ case typelib_TypeClass_ENUM:
+ {
+ //get the Enum type
+ System::Type^ enumType= nullptr;
+ if (info != nullptr)
+ {
+ //info is EnumType[]&, remove &
+ OSL_ASSERT(info->IsByRef);
+ enumType = info->GetElementType();
+ //enumType is EnumType[], remove []
+ enumType = enumType->GetElementType();
+ }
+ else
+ enumType= mapUnoType(element_type);
+
+ System::Array^ arEnum = System::Array::CreateInstance(
+ enumType, nElements);
+ for (int i= 0; i < nElements; i++)
+ {
+ arEnum->SetValue(System::Enum::ToObject(enumType,
+ System::Int32(((sal_Int32*) seq->elements)[i])), i);
+ }
+ *cli_data = arEnum;
+ break;
+ }
+ case typelib_TypeClass_STRUCT:
+ case typelib_TypeClass_EXCEPTION:
+ {
+ TypeDescr element_td( element_type );
+ System::Array^ ar= System::Array::CreateInstance(
+ mapUnoType(element_type),nElements);
+ if (0 < nElements)
+ {
+ // ToDo check this
+ char * p = (char *) &seq->elements;
+ sal_Int32 nSize = element_td.get()->nSize;
+ for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
+ {
+ System::Object^ val;
+ map_to_cli(
+ &val, p + (nSize * nPos), element_type, nullptr, false);
+ ar->SetValue(val, System::Int32(nPos));
+ }
+ }
+ *cli_data = ar;
+ break;
+ }
+// ToDo, verify
+ case typelib_TypeClass_SEQUENCE:
+ {
+ System::Array ^ar= System::Array::CreateInstance(
+ mapUnoType(element_type), nElements);
+ if (0 < nElements)
+ {
+ TypeDescr element_td( element_type );
+ uno_Sequence ** elements = (uno_Sequence**) seq->elements;
+ for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
+ {
+ System::Object^ val;
+ map_to_cli(
+ &val, &elements[nPos], element_type, nullptr, false);
+ ar->SetValue(val, System::Int32(nPos));
+ }
+ }
+ *cli_data = ar;
+ break;
+ }
+ case typelib_TypeClass_INTERFACE:
+ {
+ TypeDescr element_td( element_type );
+ System::Type ^ ifaceType= mapUnoType(element_type);
+ System::Array^ ar= System::Array::CreateInstance(ifaceType, nElements);
+
+ char * p = (char *)seq->elements;
+ sal_Int32 nSize = element_td.get()->nSize;
+ for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
+ {
+ System::Object^ val;
+ map_to_cli(
+ &val, p + (nSize * nPos), element_type, nullptr, false);
+
+ ar->SetValue(val, System::Int32(nPos));
+ }
+ *cli_data= ar;
+ break;
+ }
+ default:
+ {
+ throw BridgeRuntimeError("[map_to_cli():" + OUString::unacquired( &type->pTypeName ) +
+ "] unsupported element type: " + OUString::unacquired( &element_type->pTypeName ));
+ }
+ }
+ break;
+ }
+ case typelib_TypeClass_INTERFACE:
+ {
+ uno_Interface * pUnoI = *(uno_Interface * const *)uno_data;
+ if (0 != pUnoI)
+ {
+ TypeDescr td( type );
+ *cli_data= map_uno2cli( pUnoI, reinterpret_cast<
+ typelib_InterfaceTypeDescription*>(td.get())) ;
+ }
+ else
+ *cli_data= nullptr;
+ break;
+ }
+ default:
+ {
+ //ToDo check this exception. The String is probably crippled
+ throw BridgeRuntimeError("[map_to_cli():" + OUString::unacquired( &type->pTypeName ) + "] unsupported type!");
+ }
+ } //switch
+} // method
+} // namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cli_ure/source/uno_bridge/cli_environment.cxx b/cli_ure/source/uno_bridge/cli_environment.cxx
new file mode 100644
index 000000000..3c054b5be
--- /dev/null
+++ b/cli_ure/source/uno_bridge/cli_environment.cxx
@@ -0,0 +1,168 @@
+/* -*- Mode: C++; 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 "Cli_environment.h"
+
+#using <cli_ure.dll>
+#using <system.dll>
+#include "osl/diagnose.h"
+#include "cli_proxy.h"
+
+using namespace System::Runtime::Remoting;
+using namespace System::Runtime::Remoting::Proxies;
+using namespace System::Collections;
+using namespace System::Text;
+using namespace System::Diagnostics;
+using namespace System::Threading;
+
+namespace cli_uno
+{
+
+inline System::String^ Cli_environment::createKey(System::String^ oid, System::Type^ t)
+{
+ return System::String::Concat(oid, t->FullName);
+}
+
+
+inline Cli_environment::Cli_environment()
+{
+#if OSL_DEBUG_LEVEL >= 2
+ _numRegisteredObjects = 0;
+#endif
+}
+
+Cli_environment::~Cli_environment() ///< IDisposable Cli_environment::Dispose()
+{
+ this->!Cli_environment(); // call finalizer
+}
+
+Cli_environment::!Cli_environment() ///< Cli_environment::Finalize()
+{
+#if OSL_DEBUG_LEVEL >= 2
+ OSL_ENSURE(_numRegisteredObjects == 0,
+ "cli uno bridge: CLI environment contains unrevoked objects");
+#endif
+}
+
+System::Object^ Cli_environment::registerInterface(
+ System::Object^ obj, System::String^ oid)
+{
+#if OSL_DEBUG_LEVEL >= 1
+ //obj must be a transparent proxy
+ OSL_ASSERT(RemotingServices::IsTransparentProxy(obj));
+ _numRegisteredObjects ++;
+#endif
+ OSL_ASSERT( ! m_objects->ContainsKey(oid));
+ m_objects->Add(oid, gcnew WeakReference(obj));
+ return obj;
+}
+System::Object^ Cli_environment::registerInterface (
+ System::Object^ obj, System::String^ oid, System::Type^ type)
+{
+#if OSL_DEBUG_LEVEL >= 1
+ //obj must be a real cli object
+ OSL_ASSERT( ! RemotingServices::IsTransparentProxy(obj));
+ _numRegisteredObjects ++;
+#endif
+ System::String^ key = createKey(oid, type);
+ //see synchronization in map_uno2cli in cli_data.cxx
+ OSL_ASSERT( ! m_objects->ContainsKey(key));
+ m_objects->Add(key, gcnew WeakReference(obj));
+ return obj;
+}
+
+void Cli_environment::revokeInterface(System::String^ oid, System::Type^ type)
+{
+ System::String^ key = type != nullptr ? createKey(oid, type) : oid;
+#if OSL_DEBUG_LEVEL >= 1
+ _numRegisteredObjects --;
+#endif
+#if OSL_DEBUG_LEVEL >= 2
+ int i = 1;
+ if (m_objects->ContainsKey(key) == false)
+ {
+ Trace::WriteLine("cli uno bridge: try to revoke unregistered interface");
+ Trace::WriteLine(oid);
+ i = 0;
+ }
+ Trace::WriteLine(System::String::Format(
+ gcnew System::String("cli uno bridge: {0} remaining registered interfaces"),
+ m_objects->Count - 1));
+#endif
+ m_objects->Remove(key);
+}
+
+inline void Cli_environment::revokeInterface(System::String^ oid)
+{
+ return revokeInterface(oid, nullptr);
+}
+
+System::Object^ Cli_environment::getRegisteredInterface(System::String^ oid,
+ System::Type^ type)
+{
+ //try if it is a UNO interface
+ System::Object^ ret = m_objects[oid];
+ if (! ret)
+ {
+ //try if it is a proxy for a cli object
+ oid = createKey(oid, type);
+ ret = m_objects[ oid ];
+ }
+ if (ret != nullptr)
+ {
+ System::WeakReference^ weakIface =
+ static_cast< System::WeakReference ^ >( ret );
+ ret = weakIface->Target;
+ }
+ if (ret == nullptr)
+ m_objects->Remove( oid );
+ return ret;
+}
+
+System::String^ Cli_environment::getObjectIdentifier(System::Object^ obj)
+{
+ System::String^ oId= nullptr;
+ RealProxy^ aProxy= RemotingServices::GetRealProxy(obj);
+ if (aProxy)
+ {
+ UnoInterfaceProxy^ proxyImpl= dynamic_cast<UnoInterfaceProxy^>(aProxy);
+ if (proxyImpl)
+ oId= proxyImpl->getOid();
+ }
+
+ if (oId == nullptr)
+ {
+ StringBuilder ^ buf= gcnew StringBuilder(256);
+ bool bFirst = new bool(false);
+ System::Threading::Monitor::Enter(Cli_environment::typeid);
+ try {
+ buf->Append(m_IDGen->GetId(obj, bFirst));
+ } finally
+ {
+ System::Threading::Monitor::Exit(Cli_environment::typeid);
+ }
+
+ buf->Append(sOidPart);
+ oId= buf->ToString();
+ }
+ return oId;
+}
+} //namespace cli_uno
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cli_ure/source/uno_bridge/cli_environment.h b/cli_ure/source/uno_bridge/cli_environment.h
new file mode 100644
index 000000000..3828d971c
--- /dev/null
+++ b/cli_ure/source/uno_bridge/cli_environment.h
@@ -0,0 +1,105 @@
+/* -*- Mode: C++; 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 .
+ */
+
+#ifndef INCLUDED_CLI_URE_SOURCE_UNO_BRIDGE_CLI_ENVIRONMENT_H
+#define INCLUDED_CLI_URE_SOURCE_UNO_BRIDGE_CLI_ENVIRONMENT_H
+
+#include "cli_base.h"
+
+using namespace System;
+using namespace System::Collections;
+using namespace System::Runtime::Serialization;
+
+namespace cli_uno
+{
+public
+ref class Cli_environment
+{
+ static System::String ^ sOidPart;
+ static Hashtable ^ m_objects;
+ static System::Runtime::Serialization::ObjectIDGenerator ^ m_IDGen;
+ inline static System::String ^ createKey(System::String ^ oid, System::Type ^ t);
+
+#if OSL_DEBUG_LEVEL >= 1
+ int _numRegisteredObjects;
+#endif
+
+ static Cli_environment()
+ {
+ m_objects = Hashtable::Synchronized(gcnew Hashtable());
+ m_IDGen = gcnew System::Runtime::Serialization::ObjectIDGenerator();
+ System::Text::StringBuilder ^ buffer = gcnew System::Text::StringBuilder(256);
+ Guid gd = Guid::NewGuid();
+ buffer->Append(";cli[0];");
+ buffer->Append(gd.ToString());
+ sOidPart = buffer->ToString();
+ }
+
+public:
+ inline Cli_environment();
+
+ ~Cli_environment();
+ !Cli_environment();
+
+ /**
+ Registers a UNO object as being mapped by this bridge. The resulting
+ cli object is represents all interfaces of the UNO object. Therefore the
+ object can be registered only with its OID; a type is not necessary.
+ */
+ Object ^ registerInterface(Object ^ obj, System::String ^ oid);
+ /**
+ Registers a CLI object as being mapped by this bridge. The resulting
+ object represents exactly one UNO interface.
+ */
+ Object ^ registerInterface(Object ^ obj, System::String ^ oid, System::Type ^ type);
+
+ /**
+ By revoking an interface it is declared that the respective interface has
+ not been mapped. The proxy implementations call revoke interface in their
+ destructors.
+ */
+ inline void revokeInterface(System::String ^ oid);
+
+ void revokeInterface(System::String ^ oid, System::Type ^ type);
+ /**
+ * Retrieves an interface identified by its object id and type from this
+ * environment.
+ *
+ * @param oid object id of interface to be retrieved
+ * @param type the type description of the interface to be retrieved
+ * @see com.sun.star.uno.IEnvironment#getRegisteredInterface
+ */
+ Object ^ getRegisteredInterface(System::String ^ oid, System::Type ^ type);
+
+ /**
+ * Generates a worldwide unique object identifier (oid) for the given object. It is
+ * guaranteed, that subsequent calls to the method with the same object
+ * will give the same id.
+ * <p>
+ * @return the generated oid.
+ * @param object the object for which an Oid should be generated.
+ */
+ static System::String ^ getObjectIdentifier(Object ^ obj);
+};
+
+} //namespace cli_uno
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cli_ure/source/uno_bridge/cli_proxy.cxx b/cli_ure/source/uno_bridge/cli_proxy.cxx
new file mode 100644
index 000000000..22c478177
--- /dev/null
+++ b/cli_ure/source/uno_bridge/cli_proxy.cxx
@@ -0,0 +1,1105 @@
+/* -*- Mode: C++; 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 "typelib/typedescription.h"
+#include "rtl/ustrbuf.hxx"
+#include <sal/log.hxx>
+#include "com/sun/star/uno/RuntimeException.hpp"
+#include "cli_proxy.h"
+#include "cli_base.h"
+#include "cli_bridge.h"
+
+#using <cli_ure.dll>
+#using <cli_uretypes.dll>
+
+namespace sr = System::Reflection;
+namespace st = System::Text;
+namespace sc = System::Collections;
+namespace srrm = System::Runtime::Remoting::Messaging;
+namespace srr = System::Runtime::Remoting;
+namespace srrp = System::Runtime::Remoting::Proxies;
+namespace sd = System::Diagnostics;
+namespace ucss = unoidl::com::sun::star;
+
+using namespace cli_uno;
+
+extern "C"
+{
+
+void SAL_CALL cli_proxy_free( uno_ExtEnvironment * env, void * proxy )
+ SAL_THROW_EXTERN_C();
+
+void SAL_CALL cli_proxy_acquire( uno_Interface * pUnoI )
+ SAL_THROW_EXTERN_C();
+
+void SAL_CALL cli_proxy_release( uno_Interface * pUnoI )
+ SAL_THROW_EXTERN_C();
+
+void SAL_CALL cli_proxy_dispatch(
+ uno_Interface * pUnoI, typelib_TypeDescription const * member_td,
+ void * uno_ret, void * uno_args[], uno_Any ** uno_exc )
+ SAL_THROW_EXTERN_C();
+
+
+}
+
+namespace cli_uno
+{
+
+UnoInterfaceInfo::UnoInterfaceInfo(Bridge const * bridge, uno_Interface* unoI,
+ typelib_InterfaceTypeDescription* td):
+
+ m_unoI(unoI),
+ m_typeDesc(td),
+ m_bridge(bridge)
+{
+ m_bridge->acquire();
+ m_type = mapUnoType(reinterpret_cast<typelib_TypeDescription*>(td));
+ m_unoI->acquire(m_unoI);
+ typelib_typedescription_acquire(&m_typeDesc->aBase);
+ if ( ! m_typeDesc->aBase.bComplete)
+ {
+ typelib_TypeDescription* _pt = &m_typeDesc->aBase;
+ sal_Bool bComplete = ::typelib_typedescription_complete( & _pt);
+ if( ! bComplete)
+ {
+ throw BridgeRuntimeError("cannot make type complete: " + OUString::unacquired(& m_typeDesc->aBase.pTypeName));
+ }
+ }
+}
+
+UnoInterfaceInfo::~UnoInterfaceInfo() ///< IDisposable UnoInterfaceInfo::Dispose()
+{
+ this->!UnoInterfaceInfo(); // call finalizer
+}
+
+UnoInterfaceInfo::!UnoInterfaceInfo() ///< UnoInterfaceInfo::Finalize()
+{
+ //accessing unmanaged objects is ok.
+ m_bridge->m_uno_env->revokeInterface(
+ m_bridge->m_uno_env, m_unoI );
+ m_bridge->release();
+
+ m_unoI->release(m_unoI);
+ typelib_typedescription_release(
+ reinterpret_cast<typelib_TypeDescription*>(m_typeDesc));
+}
+
+UnoInterfaceProxy::UnoInterfaceProxy(
+ Bridge * bridge,
+ uno_Interface * pUnoI,
+ typelib_InterfaceTypeDescription* pTD,
+ const OUString& oid )
+ :RealProxy(MarshalByRefObject::typeid),
+ m_bridge(bridge),
+ m_oid(mapUnoString(oid.pData)),
+ m_sTypeName(m_system_Object_String)
+{
+ m_bridge->acquire();
+ // create the list that holds all UnoInterfaceInfos
+ m_listIfaces = gcnew ArrayList(10);
+ m_numUnoIfaces = 0;
+ m_listAdditionalProxies = gcnew ArrayList();
+ m_nlistAdditionalProxies = 0;
+ //put the information of the first UNO interface into the arraylist
+#if OSL_DEBUG_LEVEL >= 2
+ _numInterfaces = 0;
+ _sInterfaces = NULL;
+#endif
+ addUnoInterface(pUnoI, pTD);
+
+}
+
+UnoInterfaceProxy::~UnoInterfaceProxy() ///< IDisposable UnoInterfaceProxy::Dispose()
+{
+ this->!UnoInterfaceProxy(); // call finalizer
+}
+
+UnoInterfaceProxy::!UnoInterfaceProxy() ///< UnoInterfaceProxy::Finalize()
+{
+#if OSL_DEBUG_LEVEL >= 2
+ sd::Trace::WriteLine(System::String::Format(
+ gcnew System::String("cli uno bridge: Destroying proxy "
+ "for UNO object, OID: \n\t{0} \n\twith uno interfaces: "),
+ m_oid));
+
+ sd::Trace::WriteLine( mapUnoString(_sInterfaces));
+ rtl_uString_release(_sInterfaces);
+#endif
+ //m_bridge is unmanaged, therefore we can access it in this finalizer
+ CliEnvHolder::g_cli_env->revokeInterface(m_oid);
+ m_bridge->release();
+}
+
+System::Object^ UnoInterfaceProxy::create(
+ Bridge * bridge,
+ uno_Interface * pUnoI,
+ typelib_InterfaceTypeDescription* pTD,
+ const OUString& oid)
+{
+ UnoInterfaceProxy^ proxyHandler=
+ gcnew UnoInterfaceProxy(bridge, pUnoI, pTD, oid);
+ System::Object^ proxy= proxyHandler->GetTransparentProxy();
+ CliEnvHolder::g_cli_env->registerInterface(proxy, mapUnoString(oid.pData));
+ return proxy;
+}
+
+
+void UnoInterfaceProxy::addUnoInterface(uno_Interface* pUnoI,
+ typelib_InterfaceTypeDescription* pTd)
+{
+ sc::IEnumerator^ enumInfos = m_listIfaces->GetEnumerator();
+ System::Threading::Monitor::Enter(this);
+ try
+ {
+ while (enumInfos->MoveNext())
+ {
+ UnoInterfaceInfo^ info = static_cast<UnoInterfaceInfo^>(
+ enumInfos->Current);
+ if (typelib_typedescription_equals(
+ reinterpret_cast<typelib_TypeDescription*>(info->m_typeDesc),
+ reinterpret_cast<typelib_TypeDescription*>(pTd)))
+ {
+ return;
+ }
+ }
+ OUString oid(mapCliString(m_oid));
+ (*m_bridge->m_uno_env->registerInterface)(
+ m_bridge->m_uno_env, reinterpret_cast< void ** >( &pUnoI ),
+ oid.pData, pTd);
+ //This proxy does not contain the uno_Interface. Add it.
+ m_listIfaces->Add(gcnew UnoInterfaceInfo(m_bridge, pUnoI, pTd));
+ m_numUnoIfaces = m_listIfaces->Count;
+#if OSL_DEBUG_LEVEL >= 2
+ System::String^ sInterfaceName = static_cast<UnoInterfaceInfo^>(
+ m_listIfaces[m_numUnoIfaces - 1])->m_type->FullName;
+ sd::Trace::WriteLine(System::String::Format(
+ gcnew System::String("cli uno bridge: Creating proxy for uno object, "
+ "id:\n\t{0}\n\t{1}"), m_oid, sInterfaceName));
+ // add to the string that contains all interface names
+ _numInterfaces++;
+ OUString _sNewInterface = "\t" + OUString::number(_numInterfaces) + ". " + mapCliString(sInterfaceName) + "\n";
+ pin_ptr<rtl_uString *> pp_sInterfaces = &_sInterfaces;
+ rtl_uString_newConcat( pp_sInterfaces, * pp_sInterfaces,
+ _sNewInterface.pData);
+#endif
+ }
+ __finally {
+ System::Threading::Monitor::Exit(this);
+ }
+}
+
+
+// IRemotingTypeInfo
+bool UnoInterfaceProxy::CanCastTo(System::Type^ fromType,
+ System::Object^)
+{
+ if (fromType == System::Object::typeid) // trivial case
+ return true;
+
+ System::Threading::Monitor::Enter(this);
+ try
+ {
+ if (nullptr != findInfo( fromType )) // proxy supports demanded interface
+ return true;
+
+ //query a uno interface for the required type
+
+ // we use the first interface in the list (m_listIfaces) to make
+ // the queryInterface call
+ UnoInterfaceInfo^ info =
+ static_cast<UnoInterfaceInfo^>(m_listIfaces[0]);
+ css::uno::TypeDescription membertd(
+ reinterpret_cast<typelib_InterfaceTypeDescription*>(
+ info->m_typeDesc)->ppAllMembers[0]);
+ array<System::Object^>^ args = gcnew array<System::Object^>(1);
+
+ args[0] = fromType;
+ uno::Any ^ pAny;
+ System::Object^ pException = nullptr;
+
+ pAny= static_cast<uno::Any ^>(
+ m_bridge->call_uno(
+ info->m_unoI,
+ membertd.get(),
+ ((typelib_InterfaceMethodTypeDescription*)
+ membertd.get())->pReturnTypeRef,
+ 1,
+ ((typelib_InterfaceMethodTypeDescription*)
+ membertd.get())->pParams,
+ args, nullptr, &pException) );
+
+ // handle regular exception from target
+ OSL_ENSURE(
+ nullptr == pException,
+ OUStringToOString(
+ mapCliString( pException->ToString()),
+ RTL_TEXTENCODING_UTF8 ).getStr() );
+
+ if (pAny->Type != void::typeid) // has value?
+ {
+ if (nullptr != findInfo( fromType ))
+ {
+ // proxy now supports demanded interface
+ return true;
+ }
+
+ // via aggregation: it is possible that queryInterface() returns
+ // and interface with a different oid.
+ // That way, this type is supported for the CLI
+ // interpreter (CanCastTo() returns true)
+ ::System::Object ^ obj = pAny->Value;
+ OSL_ASSERT( srr::RemotingServices::IsTransparentProxy( obj ) );
+ if (srr::RemotingServices::IsTransparentProxy( obj ))
+ {
+ UnoInterfaceProxy ^ proxy =
+ static_cast< UnoInterfaceProxy ^ >(
+ srr::RemotingServices::GetRealProxy( obj ) );
+ OSL_ASSERT( nullptr != proxy->findInfo( fromType ) );
+ m_listAdditionalProxies->Add( proxy );
+ m_nlistAdditionalProxies = m_listAdditionalProxies->Count;
+ OSL_ASSERT( nullptr != findInfo( fromType ) );
+ return true;
+ }
+ }
+ }
+ catch (BridgeRuntimeError& e)
+ {
+ (void) e; // avoid warning
+ OSL_FAIL(
+ OUStringToOString(
+ e.m_message, RTL_TEXTENCODING_UTF8 ).getStr() );
+ }
+ catch (System::Exception^ e)
+ {
+ System::String^ msg= gcnew System::String(
+ "An unexpected CLI exception occurred in "
+ "UnoInterfaceProxy::CanCastTo(). Original"
+ "message: \n");
+ msg= System::String::Concat(msg, e->Message);
+ OSL_FAIL(
+ OUStringToOString(
+ mapCliString(msg), RTL_TEXTENCODING_UTF8 ).getStr() );
+ }
+ catch (...)
+ {
+ OSL_FAIL(
+ "An unexpected native C++ exception occurred in "
+ "UnoInterfaceProxy::CanCastTo()" );
+ }
+ __finally
+ {
+ System::Threading::Monitor::Exit(this);
+ }
+ return false;
+}
+
+srrm::IMessage^ UnoInterfaceProxy::invokeObject(
+ sc::IDictionary^ props,
+ srrm::LogicalCallContext^ context,
+ srrm::IMethodCallMessage^ mcm)
+{
+ System::Object^ retMethod = nullptr;
+ System::String^ sMethod = static_cast<System::String^>
+ (props[m_methodNameString]);
+ array<System::Object^>^ args = static_cast<array<System::Object^>^>(
+ props[m_ArgsString]);
+ if (m_Equals_String->Equals(sMethod))
+ {
+ // Object.Equals
+ OSL_ASSERT(args->Length == 1);
+ srrp::RealProxy^ rProxy = srr::RemotingServices::GetRealProxy(args[0]);
+ bool bDone = false;
+ if (rProxy)
+ {
+ UnoInterfaceProxy^ unoProxy =
+ dynamic_cast<UnoInterfaceProxy^>(rProxy);
+ if (unoProxy)
+ {
+ bool b = m_oid->Equals(unoProxy->getOid());
+ retMethod = b;
+ bDone = true;
+ }
+ }
+ if (bDone == false)
+ {
+ //no proxy or not our proxy, therefore Equals must be false
+ retMethod = false;
+ }
+ }
+ else if (m_GetHashCode_String->Equals(sMethod))
+ {
+ // Object.GetHashCode
+ int nHash = m_oid->GetHashCode();
+ retMethod = nHash;
+ }
+ else if (m_GetType_String->Equals(sMethod))
+ {
+ // Object.GetType
+ retMethod = System::Object::typeid;
+ }
+ else if (m_ToString_String->Equals(sMethod))
+ {
+ // Object.ToString
+ st::StringBuilder^ sb = gcnew st::StringBuilder(256);
+// sb->AppendFormat("Uno object proxy. Implemented interface: {0}"
+// ". OID: {1}", m_type->ToString(), m_oid);
+ sb->AppendFormat("Uno object proxy. OID: {0}", m_oid);
+ retMethod = sb->ToString();
+ }
+ else
+ {
+ //Either Object has new functions or a protected method was called
+ //which should not be possible
+ OSL_ASSERT(0);
+ }
+ srrm::IMessage^ retVal= gcnew srrm::ReturnMessage(
+ retMethod, gcnew array<System::Object^>(0), 0, context, mcm);
+ return retVal;
+}
+
+UnoInterfaceInfo ^ UnoInterfaceProxy::findInfo( ::System::Type ^ type )
+{
+ for (int i = 0; i < m_numUnoIfaces; i++)
+ {
+ UnoInterfaceInfo^ tmpInfo = static_cast<UnoInterfaceInfo^>(
+ m_listIfaces[i]);
+ if (type->IsAssignableFrom(tmpInfo->m_type))
+ return tmpInfo;
+ }
+ for ( int i = 0; i < m_nlistAdditionalProxies; ++i )
+ {
+ UnoInterfaceProxy ^ proxy =
+ static_cast< UnoInterfaceProxy ^ >(
+ m_listAdditionalProxies[ i ] );
+ UnoInterfaceInfo ^ info = proxy->findInfo( type );
+ if (nullptr != info)
+ return info;
+ }
+ return nullptr;
+}
+
+srrm::IMessage^ UnoInterfaceProxy::Invoke(srrm::IMessage^ callmsg)
+{
+ try
+ {
+ sc::IDictionary^ props= callmsg->Properties;
+ srrm::LogicalCallContext^ context=
+ static_cast<srrm::LogicalCallContext^>(
+ props[m_CallContextString]);
+ srrm::IMethodCallMessage^ mcm=
+ static_cast<srrm::IMethodCallMessage^>(callmsg);
+
+ //Find out which UNO interface is being called
+ System::String^ sTypeName = static_cast<System::String^>(
+ props[m_typeNameString]);
+ sTypeName = sTypeName->Substring(0, sTypeName->IndexOf(','));
+
+ // Special Handling for System.Object methods
+ if(sTypeName->IndexOf(m_system_Object_String) != -1)
+ {
+ return invokeObject(props, context, mcm);
+ }
+
+ System::Type^ typeBeingCalled = loadCliType(sTypeName);
+ UnoInterfaceInfo^ info = findInfo( typeBeingCalled );
+ OSL_ASSERT( nullptr != info );
+
+ // ToDo do without string conversion, an OUString is not needed here
+ // get the type description of the call
+ OUString usMethodName(mapCliString(static_cast<System::String^>(
+ props[m_methodNameString])));
+ typelib_TypeDescriptionReference ** ppAllMembers =
+ info->m_typeDesc->ppAllMembers;
+ sal_Int32 numberMembers = info->m_typeDesc->nAllMembers;
+ for ( sal_Int32 nPos = numberMembers; nPos--; )
+ {
+ typelib_TypeDescriptionReference * member_type = ppAllMembers[nPos];
+
+ // check usMethodName against fully qualified usTypeName
+ // of member_type; usTypeName is of the form
+ // <name> "::" <usMethodName> *(":@" <idx> "," <idx> ":" <name>)
+ OUString const & usTypeName =
+ OUString::unacquired( & member_type->pTypeName );
+
+#if OSL_DEBUG_LEVEL >= 2
+ System::String^ pTypeName;
+ pTypeName = mapUnoString(usTypeName.pData);
+#endif
+ sal_Int32 offset = usTypeName.indexOf( ':' ) + 2;
+ OSL_ASSERT(
+ offset >= 2 && offset < usTypeName.getLength()
+ && usTypeName[offset - 1] == ':' );
+ sal_Int32 remainder = usTypeName.getLength() - offset;
+
+ if (typelib_TypeClass_INTERFACE_METHOD == member_type->eTypeClass)
+ {
+ if ((usMethodName.getLength() == remainder
+ || (usMethodName.getLength() < remainder
+ && usTypeName[offset + usMethodName.getLength()] == ':'))
+ && usTypeName.match(usMethodName, offset))
+ {
+ TypeDescr member_td( member_type );
+ typelib_InterfaceMethodTypeDescription * method_td =
+ (typelib_InterfaceMethodTypeDescription *)
+ member_td.get();
+
+ array<System::Object^>^ args = static_cast<array<System::Object^>^>(
+ props[m_ArgsString]);
+ array<System::Type^>^ argTypes = static_cast<array<System::Type^>^>(
+ props[m_methodSignatureString]);
+ System::Object^ pExc = nullptr;
+ System::Object ^ cli_ret = m_bridge->call_uno(
+ info->m_unoI, member_td.get(),
+ method_td->pReturnTypeRef, method_td->nParams,
+ method_td->pParams, args, argTypes, &pExc);
+ return constructReturnMessage(cli_ret, args, method_td,
+ callmsg, pExc);
+ }
+ }
+ else
+ {
+ OSL_ASSERT( typelib_TypeClass_INTERFACE_ATTRIBUTE ==
+ member_type->eTypeClass );
+ if (usMethodName.getLength() > 4
+ && (usMethodName.getLength() - 4 == remainder
+ || (usMethodName.getLength() - 4 < remainder
+ && usTypeName[
+ offset + (usMethodName.getLength() - 4)] == ':'))
+ && usMethodName[1] == 'e' && usMethodName[2] == 't'
+ && rtl_ustr_compare_WithLength(
+ usTypeName.getStr() + offset,
+ usMethodName.getLength() - 4,
+ usMethodName.getStr() + 4,
+ usMethodName.getLength() - 4) == 0)
+ {
+ if ('g' == usMethodName[0])
+ {
+ TypeDescr member_td( member_type );
+ typelib_InterfaceAttributeTypeDescription * attribute_td =
+ (typelib_InterfaceAttributeTypeDescription*)
+ member_td.get();
+
+ System::Object^ pExc = nullptr;
+ System::Object^ cli_ret= m_bridge->call_uno(
+ info->m_unoI, member_td.get(),
+ attribute_td->pAttributeTypeRef,
+ 0, 0,
+ nullptr, nullptr, &pExc);
+ return constructReturnMessage(cli_ret, nullptr, NULL,
+ callmsg, pExc);
+ }
+ else if ('s' == usMethodName[0])
+ {
+ TypeDescr member_td( member_type );
+ typelib_InterfaceAttributeTypeDescription * attribute_td =
+ (typelib_InterfaceAttributeTypeDescription *)
+ member_td.get();
+ if (! attribute_td->bReadOnly)
+ {
+ typelib_MethodParameter param;
+ param.pTypeRef = attribute_td->pAttributeTypeRef;
+ param.bIn = sal_True;
+ param.bOut = sal_False;
+
+ array<System::Object^>^ args =
+ static_cast<array<System::Object^>^>(
+ props[m_ArgsString]);
+ System::Object^ pExc = nullptr;
+ m_bridge->call_uno(
+ info->m_unoI, member_td.get(),
+ cppu::UnoType<void>::get().getTypeLibType(),
+ 1, &param, args, nullptr, &pExc);
+ return constructReturnMessage(nullptr, nullptr, NULL,
+ callmsg, pExc);
+ }
+ else
+ {
+ return constructReturnMessage(nullptr, nullptr, NULL,
+ callmsg, nullptr);
+ }
+ }
+ break;
+ }
+ }
+ }
+ // ToDo check if the message of the exception is not crippled
+ // the thing that should not be... no method info found!
+ throw BridgeRuntimeError("[cli_uno bridge]calling undeclared function on interface " +
+ OUString::unacquired(& ((typelib_TypeDescription *)info->m_typeDesc)->pTypeName) +
+ ": " + usMethodName);
+ }
+ catch (BridgeRuntimeError & err)
+ {
+ srrm::IMethodCallMessage^ mcm =
+ static_cast<srrm::IMethodCallMessage^>(callmsg);
+ return gcnew srrm::ReturnMessage(gcnew ucss::uno::RuntimeException(
+ mapUnoString(err.m_message.pData), nullptr), mcm);
+ }
+ catch (System::Exception^ e)
+ {
+ st::StringBuilder ^ sb = gcnew st::StringBuilder(512);
+ sb->Append(gcnew System::String(
+ "An unexpected CLI exception occurred in "
+ "UnoInterfaceProxy::Invoke. Original"
+ "message: \n"));
+ sb->Append(e->Message);
+ sb->Append((__wchar_t) '\n');
+ sb->Append(e->StackTrace);
+ srrm::IMethodCallMessage^ mcm =
+ static_cast<srrm::IMethodCallMessage^>(callmsg);
+ return gcnew srrm::ReturnMessage(gcnew ucss::uno::RuntimeException(
+ sb->ToString(), nullptr), mcm);
+ }
+ catch (...)
+ {
+ System::String^ msg = gcnew System::String(
+ "An unexpected native C++ exception occurred in "
+ "UnoInterfaceProxy::Invoke.");
+ srrm::IMethodCallMessage^ mcm =
+ static_cast<srrm::IMethodCallMessage^>(callmsg);
+ return gcnew srrm::ReturnMessage(gcnew ucss::uno::RuntimeException(
+ msg, nullptr), mcm);
+ }
+ return nullptr;
+}
+/** If the argument args is NULL then this function is called for an attribute
+ method (either setXXX or getXXX).
+ For attributes the argument mtd is also NULL.
+*/
+srrm::IMessage^ UnoInterfaceProxy::constructReturnMessage(
+ System::Object^ cliReturn,
+ array<System::Object^>^ args,
+ typelib_InterfaceMethodTypeDescription* mtd,
+ srrm::IMessage^ msg, System::Object^ exc)
+{
+ srrm::IMessage ^ retVal= nullptr;
+ srrm::IMethodCallMessage^ mcm = static_cast<srrm::IMethodCallMessage^>(msg);
+ if (exc)
+ {
+ retVal = gcnew srrm::ReturnMessage(
+ dynamic_cast<System::Exception^>(exc), mcm);
+ }
+ else
+ {
+ sc::IDictionary^ props= msg->Properties;
+ srrm::LogicalCallContext^ context=
+ static_cast<srrm::LogicalCallContext^>(
+ props[m_CallContextString]);
+ if (args != nullptr)
+ {
+ // Method
+ //build the array of out parameters, allocate max length
+ array<System::Object^>^ arOut= gcnew array<System::Object^>(mtd->nParams);
+ int nOut = 0;
+ for (int i= 0; i < mtd->nParams; i++)
+ {
+ if (mtd->pParams[i].bOut)
+ {
+ arOut[i]= args[i];
+ nOut++;
+ }
+ }
+ retVal= gcnew srrm::ReturnMessage(cliReturn, arOut, nOut,
+ context, mcm);
+ }
+ else
+ {
+ // Attribute (getXXX)
+ retVal= gcnew srrm::ReturnMessage(cliReturn, nullptr, 0,
+ context, mcm);
+ }
+ }
+ return retVal;
+}
+
+
+CliProxy::CliProxy(Bridge const* bridge, System::Object^ cliI,
+ typelib_TypeDescription const* td,
+ const OUString& usOid):
+ m_ref(1),
+ m_bridge(bridge),
+ m_cliI(cliI),
+ m_unoType(const_cast<typelib_TypeDescription*>(td)),
+ m_usOid(usOid),
+ m_oid(mapUnoString(usOid.pData)),
+ m_nInheritedInterfaces(0)
+{
+ m_bridge->acquire();
+ uno_Interface::acquire = cli_proxy_acquire;
+ uno_Interface::release = cli_proxy_release;
+ uno_Interface::pDispatcher = cli_proxy_dispatch;
+
+ m_unoType.makeComplete();
+ m_type= mapUnoType(m_unoType.get());
+
+ makeMethodInfos();
+#if OSL_DEBUG_LEVEL >= 2
+ sd::Trace::WriteLine(System::String::Format(
+ gcnew System::String("cli uno bridge: Creating proxy for cli object, "
+ "id:\n\t{0}\n\t{1}"), m_oid, m_type));
+#endif
+
+}
+
+void CliProxy::makeMethodInfos()
+{
+#if OSL_DEBUG_LEVEL >= 2
+ System::Object^ cliI;
+ System::Type^ type;
+ cliI = m_cliI;
+ type = m_type;
+#endif
+
+ if (m_type->IsInterface == false)
+ return;
+ array<sr::MethodInfo^>^ arThisMethods = m_type->GetMethods();
+ //get the inherited interfaces
+ array<System::Type^>^ arInheritedIfaces = m_type->GetInterfaces();
+ m_nInheritedInterfaces = arInheritedIfaces->Length;
+ //array containing the number of methods for the interface and its
+ //inherited interfaces
+ m_arInterfaceMethodCount = gcnew array<int^>(m_nInheritedInterfaces + 1);
+ //determine the number of all interface methods, including the inherited
+ //interfaces
+ int numMethods = arThisMethods->Length;
+ for (int i= 0; i < m_nInheritedInterfaces; i++)
+ {
+ numMethods += arInheritedIfaces[i]->GetMethods()->Length;
+ }
+ //array containing MethodInfos of the cli object
+ m_arMethodInfos = gcnew array<sr::MethodInfo^>(numMethods);
+ //array containing MethodInfos of the interface
+ m_arInterfaceMethodInfos = gcnew array<sr::MethodInfo^>(numMethods);
+ //array containing the mapping of Uno interface pos to pos in
+ //m_arMethodInfos
+ m_arUnoPosToCliPos = gcnew array<System::Int32>(numMethods);
+ // initialize with -1
+ for (int i = 0; i < numMethods; i++)
+ m_arUnoPosToCliPos[i] = -1;
+
+ //fill m_arMethodInfos with the mappings
+ // !!! InterfaceMapping.TargetMethods should be MethodInfo*[] according
+ // to documentation
+ // but it is Type*[] instead. Bug in the framework?
+ System::Type^ objType = m_cliI->GetType();
+ try
+ {
+ int index = 0;
+ // now get the methods from the inherited interface
+ //arInheritedIfaces[0] is the direct base interface
+ //arInheritedIfaces[n] is the furthest inherited interface
+ //Start with the base interface
+ int nArLength = arInheritedIfaces->Length;
+ for (;nArLength > 0; nArLength--)
+ {
+ sr::InterfaceMapping mapInherited = objType->GetInterfaceMap(
+ arInheritedIfaces[nArLength - 1]);
+ int numMethods = mapInherited.TargetMethods->Length;
+ m_arInterfaceMethodCount[nArLength - 1] = numMethods;
+ for (int i = 0; i < numMethods; i++, index++)
+ {
+ m_arMethodInfos[index] = safe_cast<sr::MethodInfo^>(
+ mapInherited.TargetMethods[i]);
+
+ m_arInterfaceMethodInfos[index] = safe_cast<sr::MethodInfo^>(
+ mapInherited.InterfaceMethods[i]);
+ }
+ }
+ //At last come the methods of the furthest derived interface
+ sr::InterfaceMapping map = objType->GetInterfaceMap(m_type);
+ nArLength = map.TargetMethods->Length;
+ m_arInterfaceMethodCount[m_nInheritedInterfaces] = nArLength;
+ for (int i = 0; i < nArLength; i++,index++)
+ {
+ m_arMethodInfos[index]= safe_cast<sr::MethodInfo^>(
+ map.TargetMethods[i]);
+ m_arInterfaceMethodInfos[index]= safe_cast<sr::MethodInfo^>(
+ map.InterfaceMethods[i]);
+ }
+ }
+ catch (System::InvalidCastException^ )
+ {
+ throw BridgeRuntimeError("[cli_uno bridge] preparing proxy for cli interface: " + mapCliString(m_type->ToString()) + " \nfailed!");
+ }
+}
+
+sr::MethodInfo^ CliProxy::getMethodInfo(int nUnoFunctionPos,
+ const OUString& usMethodName, MethodKind methodKind)
+{
+ sr::MethodInfo^ ret = nullptr;
+ //deduct 3 for XInterface methods
+ nUnoFunctionPos -= 3;
+ System::Threading::Monitor::Enter(m_arUnoPosToCliPos);
+ try
+ {
+ int cliPos = m_arUnoPosToCliPos[nUnoFunctionPos];
+ if (cliPos != -1)
+ return m_arMethodInfos[cliPos];
+
+ //create the method function name
+ System::String^ sMethodName = mapUnoString(usMethodName.pData);
+ switch (methodKind)
+ {
+ case MK_METHOD:
+ break;
+ case MK_SET:
+ sMethodName = System::String::Concat(
+ const_cast<System::String^>(Constants::sAttributeSet),
+ sMethodName);
+ break;
+ case MK_GET:
+ sMethodName = System::String::Concat(
+ const_cast<System::String^>(Constants::sAttributeGet),
+ sMethodName);
+ break;
+ default:
+ OSL_ASSERT(0);
+ }
+ //Find the cli interface method that corresponds to the Uno method
+// System::String* sMethodName= mapUnoString(usMethodName.pData);
+ int indexCliMethod = -1;
+ //If the cli interfaces and their methods are in the same order
+ //as they were declared (inheritance chain and within the interface)
+ //then nUnoFunctionPos should lead to the correct method. However,
+ //the documentation does not say that this ordering is given.
+ if (sMethodName->Equals(m_arInterfaceMethodInfos[nUnoFunctionPos]->Name))
+ indexCliMethod = nUnoFunctionPos;
+ else
+ {
+ int cMethods = m_arInterfaceMethodInfos->Length;
+ for (int i = 0; i < cMethods; i++)
+ {
+ System::String^ cliMethod = m_arInterfaceMethodInfos[i]->Name;
+ if (cliMethod->Equals(sMethodName))
+ {
+ indexCliMethod = i;
+ break;
+ }
+ }
+ }
+ if (indexCliMethod == -1)
+ {
+ throw BridgeRuntimeError("[cli_uno bridge] CliProxy::getMethodInfo():cli object does not implement interface method: " + usMethodName);
+ }
+ m_arUnoPosToCliPos[nUnoFunctionPos] = indexCliMethod;
+ ret = m_arMethodInfos[indexCliMethod];
+ }
+ __finally
+ {
+ System::Threading::Monitor::Exit(m_arUnoPosToCliPos);
+ }
+
+ return ret;
+}
+
+CliProxy::~CliProxy()
+{
+#if OSL_DEBUG_LEVEL >= 2
+ sd::Trace::WriteLine(System::String::Format(
+ gcnew System::String(
+ "cli uno bridge: Destroying proxy for cli object, "
+ "id:\n\t{0}\n\t{1}\n"),
+ m_oid, m_type));
+#endif
+ CliEnvHolder::g_cli_env->revokeInterface(m_oid, mapUnoType(m_unoType.get()));
+ m_bridge->release();
+}
+
+uno_Interface* CliProxy::create(Bridge const * bridge,
+ System::Object^ cliI,
+ typelib_TypeDescription const* pTD,
+ const OUString& ousOid)
+{
+ uno_Interface* proxy= static_cast<uno_Interface*>(
+ new CliProxy(bridge, cliI, pTD, ousOid));
+
+ //register proxy with target environment (uno)
+ (*bridge->m_uno_env->registerProxyInterface)(
+ bridge->m_uno_env,
+ reinterpret_cast<void**>(&proxy),
+ cli_proxy_free,
+ ousOid.pData, (typelib_InterfaceTypeDescription*) pTD);
+ //register original interface
+ CliEnvHolder::g_cli_env->registerInterface(cliI, mapUnoString(ousOid.pData),
+ mapUnoType((pTD)));
+
+ return proxy;
+}
+
+
+void SAL_CALL CliProxy::uno_DispatchMethod(
+ struct _uno_Interface *,
+ const struct _typelib_TypeDescription *,
+ void *,
+ void **,
+ uno_Any ** )
+{
+}
+inline void CliProxy::acquire() const
+{
+ if (1 == osl_atomic_increment( &m_ref ))
+ {
+ // rebirth of proxy zombie
+ void * that = const_cast< CliProxy * >( this );
+ // register at uno env
+ (*m_bridge->m_uno_env->registerProxyInterface)(
+ m_bridge->m_uno_env, &that,
+ cli_proxy_free, m_usOid.pData,
+ (typelib_InterfaceTypeDescription *)m_unoType.get() );
+#if OSL_DEBUG_LEVEL >= 2
+ OSL_ASSERT( this == (void const * const)that );
+#endif
+ }
+}
+
+inline void CliProxy::release() const
+{
+ if (0 == osl_atomic_decrement( &m_ref ))
+ {
+ // revoke from uno env on last release,
+ // The proxy can be resurrected if acquire is called before the uno
+ // environment calls cli_proxy_free. cli_proxy_free will
+ //delete the proxy. The environment does not acquire a registered
+ //proxy.
+ (*m_bridge->m_uno_env->revokeInterface)(
+ m_bridge->m_uno_env, const_cast< CliProxy * >( this ) );
+ }
+}
+}
+
+
+extern "C"
+void SAL_CALL cli_proxy_free( uno_ExtEnvironment *, void * proxy )
+ SAL_THROW_EXTERN_C()
+{
+ cli_uno::CliProxy * cliProxy = reinterpret_cast<
+ cli_uno::CliProxy * >( proxy );
+
+ delete cliProxy;
+}
+
+extern "C"
+void SAL_CALL cli_proxy_acquire( uno_Interface * pUnoI )
+ SAL_THROW_EXTERN_C()
+{
+ CliProxy const * cliProxy = static_cast< CliProxy const * >( pUnoI );
+ cliProxy->acquire();
+}
+
+extern "C"
+void SAL_CALL cli_proxy_release( uno_Interface * pUnoI )
+ SAL_THROW_EXTERN_C()
+{
+ CliProxy * cliProxy = static_cast< CliProxy * >( pUnoI );
+ cliProxy->release();
+}
+
+
+extern "C"
+
+void SAL_CALL cli_proxy_dispatch(
+ uno_Interface * pUnoI, typelib_TypeDescription const * member_td,
+ void * uno_ret, void * uno_args [], uno_Any ** uno_exc )
+ SAL_THROW_EXTERN_C()
+{
+ CliProxy * proxy = static_cast< CliProxy* >( pUnoI );
+ try
+ {
+ Bridge const* bridge = proxy->m_bridge;
+
+ switch (member_td->eTypeClass)
+ {
+ case typelib_TypeClass_INTERFACE_ATTRIBUTE:
+ {
+
+ sal_Int32 member_pos = ((typelib_InterfaceMemberTypeDescription *)
+ member_td)->nPosition;
+ typelib_InterfaceTypeDescription * iface_td =
+ (typelib_InterfaceTypeDescription *)proxy->m_unoType.get();
+ OSL_ENSURE(
+ member_pos < iface_td->nAllMembers,
+ "### member pos out of range!" );
+ sal_Int32 function_pos =
+ iface_td->pMapMemberIndexToFunctionIndex[ member_pos ];
+ OSL_ENSURE(
+ function_pos < iface_td->nMapFunctionIndexToMemberIndex,
+ "### illegal function index!" );
+
+ if (uno_ret) // is getter method
+ {
+ OUString const& usAttrName= *(rtl_uString**)&
+ ((typelib_InterfaceMemberTypeDescription*) member_td)
+ ->pMemberName;
+ sr::MethodInfo^ info = proxy->getMethodInfo(function_pos,
+ usAttrName, CliProxy::MK_GET);
+ bridge->call_cli(
+ proxy->m_cliI,
+ info,
+ ((typelib_InterfaceAttributeTypeDescription *)member_td)
+ ->pAttributeTypeRef,
+ 0, 0, // no params
+ uno_ret, 0, uno_exc );
+ }
+ else // is setter method
+ {
+ OUString const& usAttrName= *(rtl_uString**) &
+ ((typelib_InterfaceMemberTypeDescription*) member_td)
+ ->pMemberName;
+ sr::MethodInfo^ info = proxy->getMethodInfo(function_pos + 1,
+ usAttrName, CliProxy::MK_SET);
+ typelib_MethodParameter param;
+ param.pTypeRef =
+ ((typelib_InterfaceAttributeTypeDescription *)member_td)
+ ->pAttributeTypeRef;
+ param.bIn = sal_True;
+ param.bOut = sal_False;
+
+ bridge->call_cli(
+ proxy->m_cliI,
+ // set follows get method
+ info,
+ 0 /* indicates void return */, &param, 1,
+ 0, uno_args, uno_exc );
+ }
+ break;
+ }
+ case typelib_TypeClass_INTERFACE_METHOD:
+ {
+ sal_Int32 member_pos = ((typelib_InterfaceMemberTypeDescription *)
+ member_td)->nPosition;
+ typelib_InterfaceTypeDescription * iface_td =
+ (typelib_InterfaceTypeDescription *)proxy->m_unoType.get();
+ OSL_ENSURE(
+ member_pos < iface_td->nAllMembers,
+ "### member pos out of range!" );
+ sal_Int32 function_pos =
+ iface_td->pMapMemberIndexToFunctionIndex[ member_pos ];
+ OSL_ENSURE(
+ function_pos < iface_td->nMapFunctionIndexToMemberIndex,
+ "### illegal function index!" );
+
+ switch (function_pos)
+ {
+ case 0: // queryInterface()
+ {
+ TypeDescr demanded_td(
+ *reinterpret_cast<typelib_TypeDescriptionReference **>(
+ uno_args[0]));
+ if (typelib_TypeClass_INTERFACE
+ != demanded_td.get()->eTypeClass)
+ {
+ throw BridgeRuntimeError(
+ "queryInterface() call demands an INTERFACE type!");
+ }
+
+ uno_Interface * pInterface = 0;
+ (*bridge->m_uno_env->getRegisteredInterface)(
+ bridge->m_uno_env,
+ (void **)&pInterface, proxy->m_usOid.pData,
+ (typelib_InterfaceTypeDescription *)demanded_td.get() );
+
+ if (0 == pInterface)
+ {
+ System::Type^ mgdDemandedType =
+ mapUnoType(demanded_td.get());
+ if (mgdDemandedType->IsInstanceOfType( proxy->m_cliI ))
+ {
+#if OSL_DEBUG_LEVEL > 0
+ OUString usOid(
+ mapCliString(
+ CliEnvHolder::g_cli_env->getObjectIdentifier(
+ proxy->m_cliI )));
+ OSL_ENSURE(usOid.equals( proxy->m_usOid ),
+ "### different oids!");
+#endif
+ uno_Interface* pUnoI = bridge->map_cli2uno(
+ proxy->m_cliI, demanded_td.get() );
+ uno_any_construct(
+ (uno_Any *)uno_ret, &pUnoI, demanded_td.get(), 0 );
+ (*pUnoI->release)( pUnoI );
+ }
+ else // object does not support demanded interface
+ {
+ uno_any_construct( (uno_Any *)uno_ret, 0, 0, 0 );
+ }
+ // no exception occurred
+ *uno_exc = 0;
+ }
+ else
+ {
+ uno_any_construct(
+ reinterpret_cast< uno_Any * >( uno_ret ),
+ &pInterface, demanded_td.get(), 0 );
+ (*pInterface->release)( pInterface );
+ *uno_exc = 0;
+ }
+ break;
+ }
+ case 1: // acquire this proxy
+ cli_proxy_acquire(proxy);
+ *uno_exc = 0;
+ break;
+ case 2: // release this proxy
+ cli_proxy_release(proxy);
+ *uno_exc = 0;
+ break;
+ default: // arbitrary method call
+ {
+ typelib_InterfaceMethodTypeDescription * method_td =
+ (typelib_InterfaceMethodTypeDescription *)member_td;
+ OUString const& usMethodName= *(rtl_uString**) &
+ ((typelib_InterfaceMemberTypeDescription*) member_td)
+ ->pMemberName;
+
+ sr::MethodInfo^ info = proxy->getMethodInfo(function_pos,
+ usMethodName, CliProxy::MK_METHOD);
+ bridge->call_cli(
+ proxy->m_cliI,
+ info,
+ method_td->pReturnTypeRef, method_td->pParams,
+ method_td->nParams,
+ uno_ret, uno_args, uno_exc);
+ return;
+ }
+ }
+ break;
+ }
+ default:
+ {
+ throw BridgeRuntimeError(
+ "illegal member type description!" );
+ }
+ }
+ }
+ catch (BridgeRuntimeError & err)
+ {
+ // binary identical struct
+ css::uno::RuntimeException exc(
+ "[cli_uno bridge error] " + err.m_message,
+ css::uno::Reference<
+ css::uno::XInterface >() );
+ css::uno::Type const & exc_type = cppu::UnoType<decltype(exc)>::get();
+ uno_type_any_construct( *uno_exc, &exc, exc_type.getTypeLibType(), 0);
+ SAL_WARN( "cli", exc);
+ }
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cli_ure/source/uno_bridge/cli_proxy.h b/cli_ure/source/uno_bridge/cli_proxy.h
new file mode 100644
index 000000000..25f7d2801
--- /dev/null
+++ b/cli_ure/source/uno_bridge/cli_proxy.h
@@ -0,0 +1,294 @@
+/* -*- Mode: C++; 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 .
+ */
+
+#ifndef INCLUDED_CLI_URE_SOURCE_UNO_BRIDGE_CLI_PROXY_H
+#define INCLUDED_CLI_URE_SOURCE_UNO_BRIDGE_CLI_PROXY_H
+
+#include "uno/environment.hxx"
+#include "uno/mapping.hxx"
+#include "uno/dispatcher.h"
+#include "cli_bridge.h"
+#include "cli_environment.h"
+
+#using <cli_ure.dll>
+
+namespace srrp = System::Runtime::Remoting::Proxies;
+namespace srrm = System::Runtime::Remoting::Messaging;
+namespace srr = System::Runtime::Remoting;
+namespace sr = System::Reflection;
+namespace sc = System::Collections;
+using namespace uno;
+
+namespace cli_uno
+{
+
+public ref class UnoInterfaceInfo
+{
+public:
+ UnoInterfaceInfo(Bridge const * bridge, uno_Interface* unoI,
+ typelib_InterfaceTypeDescription* td);
+ ~UnoInterfaceInfo();
+ !UnoInterfaceInfo();
+
+ uno_Interface * m_unoI; // wrapped interface
+ System::Type ^ m_type;
+ typelib_InterfaceTypeDescription* m_typeDesc;
+
+ Bridge const* m_bridge;
+};
+
+public ref class UnoInterfaceProxy: public srrp::RealProxy,
+ public srr::IRemotingTypeInfo
+{
+ /** used for IRemotingTypeInfo.TypeName
+ */
+ System::String^ m_sTypeName;
+ /** The list is filled with UnoInterfaceInfo objects. The list can only
+ grow and elements are never changed. If an element was added it
+ must not be changed!
+ */
+ sc::ArrayList^ m_listIfaces;
+ /** The number of UNO interfaces this proxy represents. It corresponds
+ to the number of elements in m_listIfaces.
+ */
+ int m_numUnoIfaces;
+ /** The list is filled with additional UnoInterfaceProxy object due
+ to aggregation via bridges. Though the latter is strongly
+ discouraged, this has to be supported.
+ */
+ sc::ArrayList^ m_listAdditionalProxies;
+ int m_nlistAdditionalProxies;
+
+ UnoInterfaceInfo ^ findInfo( ::System::Type ^ type );
+
+ Bridge const* m_bridge;
+ System::String^ m_oid;
+
+#if OSL_DEBUG_LEVEL >= 2
+ /** The string contains all names of UNO interfaces which are
+ represented by this proxy. It is used to print out the interfaces
+ when this proxy dies. In the destructor it is not allowed to
+ access m_listIfaces or any other managed object.
+ */
+ rtl_uString * _sInterfaces;
+// /** Count of interfaces. Used in conjunction with _sInterfaces.
+// */
+ int _numInterfaces;
+#endif
+
+public:
+
+ /** Creates a proxy and registers it on the dot NET side.
+ */
+ static System::Object^ create(Bridge * bridge,
+ uno_Interface * pUnoI,
+ typelib_InterfaceTypeDescription* pTd,
+ const OUString& oid);
+
+ /** RealProxy::Invoke */
+ virtual srrm::IMessage^ Invoke(srrm::IMessage^ msg) override;
+
+ /** Must be called from within a synchronized section.
+ Add only the interface if it is not already contained.
+ This method is called from the constructor and as a result
+ of IRemotingTypeInfo::CanCastTo
+ */
+ void addUnoInterface(uno_Interface* pUnoI,
+ typelib_InterfaceTypeDescription* pTd);
+ ~UnoInterfaceProxy();
+ !UnoInterfaceProxy();
+
+ inline System::String ^ getOid()
+ { return m_oid; }
+
+ //IRemotingTypeInfo ----------------------------------------------
+ virtual bool CanCastTo(System::Type^ fromType, System::Object^ o);
+
+ virtual property System::String^ TypeName
+ {
+ System::String^ get()
+ {
+ return m_sTypeName;
+ };
+ void set(System::String^ name)
+ {
+ m_sTypeName = name;
+ };
+ }
+
+
+private:
+ UnoInterfaceProxy(
+ Bridge * bridge,
+ uno_Interface * pUnoI,
+ typelib_InterfaceTypeDescription* pTD,
+ const OUString& oid );
+
+ static srrm::IMessage^ constructReturnMessage(System::Object^ retVal,
+ array<System::Object^>^ outArgs,
+ typelib_InterfaceMethodTypeDescription* mtd,
+ srrm::IMessage^ msg, System::Object^ exc);
+
+ static System::String^ m_methodNameString =
+ gcnew System::String("__MethodName");
+ static System::String^ m_typeNameString = gcnew System::String("__TypeName");
+ static System::String^ m_ArgsString = gcnew System::String("__Args");
+ static System::String^ m_CallContextString =
+ gcnew System::String("__CallContext");
+ static System::String^ m_system_Object_String =
+ gcnew System::String("System.Object");
+ static System::String^ m_methodSignatureString =
+ gcnew System::String("__MethodSignature");
+ static System::String^ m_Equals_String = gcnew System::String("Equals");
+ static System::String^ m_GetHashCode_String =
+ gcnew System::String("GetHashCode");
+ static System::String^ m_GetType_String = gcnew System::String("GetType");
+ static System::String^ m_ToString_String = gcnew System::String("ToString");
+
+protected:
+ srrm::IMessage^ invokeObject(sc::IDictionary^ properties,
+ srrm::LogicalCallContext^ context,
+ srrm::IMethodCallMessage^ mcm);
+};
+
+
+//Cannot make this __gc because a managed type cannot derive from unmanaged type
+struct CliProxy: public uno_Interface
+{
+ mutable oslInterlockedCount m_ref;
+ const Bridge* m_bridge;
+ const gcroot<System::Object^> m_cliI;
+ gcroot<System::Type^> m_type;
+ const css::uno::TypeDescription m_unoType;
+ const gcroot<System::String^> m_oid;
+ const OUString m_usOid;
+
+ enum MethodKind {MK_METHOD = 0, MK_SET, MK_GET};
+ /** The array contains MethodInfos of the cli object. Each one reflects an
+ implemented interface method of the interface for which this proxy was
+ created. The MethodInfos are from the object's method and not from the
+ interface type. That is, they can be used to invoke the methods. The
+ order of the MethodInfo objects corresponds to the order of the
+ interface methods (see member m_type). Position 0 contains the
+ MethodInfo of the first method of the interface which represents the
+ root of the inheritance chain. The last MethodInfo represents the last
+ method of the furthest derived interface.
+
+ The array is completely initialized in the constructor of this object.
+
+ When the uno_DispatchMethod is called for this proxy then it receives
+ a typelib_TypeDescription of the member which is either an attribute
+ (setter or getter) or method. After determining the position of the
+ method within the UNO interface one can use the position to obtain the
+ MethodInfo of the corresponding cli method. To obtain the index for the
+ m_arMethodInfos array the function position has to be decreased by 3.
+ This is because, the cli interface does not contain the XInterface
+ methods.
+ */
+ gcroot<array<sr::MethodInfo^>^> m_arMethodInfos;
+
+ /** This array is similar to m_arMethodInfos but it contains the MethodInfo
+ objects of the interface (not the object). When a call is made from uno
+ to cli then the uno method name is compared to the cli method name. The
+ cli method name can be obtained from the MethodInfo object in this
+ array. The name of the actual implemented method may not be the same as
+ the interface method.
+ */
+ gcroot<array<sr::MethodInfo^>^> m_arInterfaceMethodInfos;
+
+ /** Maps the position of the method in the UNO interface to the position of
+ the corresponding MethodInfo in m_arMethodInfos. The Uno position must
+ not include the XInterface methods. For example,
+ pos 0 = XInterface::queryInterface
+ pos 1 = XInterface::acquire
+ pos 2 = XInterface::release
+
+ That is the real Uno position has to be deducted by 3. Then
+ arUnoPosToCliPos[pos] contains the index for m_arMethodInfos.
+
+ */
+ gcroot<array<System::Int32>^> m_arUnoPosToCliPos;
+
+ /** Count of inherited interfaces of the cli interface.
+ */
+ int m_nInheritedInterfaces;
+ /** Contains the number of methods of each interface.
+ */
+ gcroot<array<System::Int32^>^> m_arInterfaceMethodCount;
+
+ CliProxy( Bridge const* bridge, System::Object^ cliI,
+ typelib_TypeDescription const* pTD,
+ const OUString& usOid);
+ ~CliProxy();
+
+ static uno_Interface* create(Bridge const * bridge,
+ System::Object^ cliI,
+ typelib_TypeDescription const * TD,
+ OUString const & usOid );
+
+ /** Prepares an array (m_arMethoInfos) containing MethodInfo object of the
+ interface and all inherited interfaces. At index null is the first
+ method of the base interface and at the last position is the last method
+ of the furthest derived interface.
+ If a UNO call is received then one can determine the position of the
+ method (or getter or setter for an attribute) from the passed type
+ information. The position minus 3 (there is no XInterface in the cli
+ mapping) corresponds to the index of the cli interface method in the
+ array.
+ */
+ void makeMethodInfos();
+
+ /**Obtains a MethodInfo which can be used to invoke the cli object.
+ Internally it maps nUnoFunctionPos to an index that is used to get the
+ corresponding MethodInfo object from m_arMethoInfos. The mapping table
+ is dynamically initialized. If the cli interface has no base interface
+ or exactly one then the mapping table is initialized in one go at the
+ first call. In all ensuing calls the MethodInfo object is immediately
+ retrieved through the mapping table.
+
+ If the interface has more than one interface in its inheritance chain,
+ that is Type.GetInterfaces return more than one Type, then the mapping
+ table is partially initialized. On the first call the mappings for the
+ methods of the belonging interface are created.
+
+ The implementation assumes that the order of interface methods as
+ provided by InterfaceMapping.InterfaceMethods corresponds to the order
+ of methods in the interface declaration.
+
+ @param nUnoFunctionPos
+ Position of the method in the uno interface.
+ */
+ sr::MethodInfo^ getMethodInfo(int nUnoFunctionPos,
+ const OUString & usMethodName,
+ MethodKind mk);
+
+ void SAL_CALL uno_DispatchMethod(
+ struct _uno_Interface * pUnoI,
+ const struct _typelib_TypeDescription * pMemberType,
+ void * pReturn,
+ void * pArgs[],
+ uno_Any ** ppException );
+
+ inline void acquire() const;
+ inline void release() const;
+};
+}
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cli_ure/source/uno_bridge/cli_uno.cxx b/cli_ure/source/uno_bridge/cli_uno.cxx
new file mode 100644
index 000000000..6af17e065
--- /dev/null
+++ b/cli_ure/source/uno_bridge/cli_uno.cxx
@@ -0,0 +1,277 @@
+/* -*- Mode: C++; 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 <memory>
+#include <sal/alloca.h>
+#include <osl/diagnose.h>
+#include "rtl/ustrbuf.hxx"
+#include "cli_base.h"
+#include "cli_bridge.h"
+
+namespace sr=System::Reflection;
+
+
+namespace cli_uno
+{
+
+union largest
+{
+ sal_Int64 n;
+ double d;
+ void * p;
+ uno_Any a;
+};
+
+System::Object^ Bridge::call_uno(uno_Interface * pUnoI,
+ typelib_TypeDescription* member_td,
+ typelib_TypeDescriptionReference * return_type,
+ sal_Int32 nParams, typelib_MethodParameter const * pParams,
+ array<System::Object^>^ args, array<System::Type^>^ argTypes,
+ System::Object^* ppExc) const
+{
+ // return mem
+ sal_Int32 return_size = sizeof (largest);
+ if ((0 != return_type) &&
+ (typelib_TypeClass_STRUCT == return_type->eTypeClass ||
+ typelib_TypeClass_EXCEPTION == return_type->eTypeClass))
+ {
+ TypeDescr return_td( return_type );
+ if (return_td.get()->nSize > sizeof (largest))
+ return_size = return_td.get()->nSize;
+ }
+ //Prepare memory that contains all converted arguments and return value
+ //The memory block contains first pointers to the arguments which are in the same block
+ // For example, 2 arguments, 1 ret.
+ //
+ // | Pointer
+ // | Pointer
+ // | Return value
+ // | Arg 1
+ // | Arg 2
+ //
+ // If an argument is larger then union largest, such as some structures, then the pointer
+ // points to an extra block of memory. The same goes for a big return value.
+
+ char * mem = (char *)alloca(
+ (nParams * sizeof (void *)) + return_size + (nParams * sizeof (largest)) );
+ //array of pointers to args
+ void ** uno_args = (void **)mem;
+ //If an attribute is set, then uno_ret must be null, e.g void setAttribute(int )
+ void * uno_ret= NULL;
+ if ( !(member_td->eTypeClass == typelib_TypeClass_INTERFACE_ATTRIBUTE && nParams == 1))
+ uno_ret = (mem + (nParams * sizeof (void *)));
+ largest * uno_args_mem = (largest *)(mem + (nParams * sizeof (void *)) + return_size);
+
+ OSL_ASSERT( (0 == nParams) || (nParams == args->Length) );
+ for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
+ {
+ typelib_MethodParameter const & param = pParams[ nPos ];
+ typelib_TypeDescriptionReference * type = param.pTypeRef;
+
+ uno_args[ nPos ] = &uno_args_mem[ nPos ];
+ if (typelib_TypeClass_STRUCT == type->eTypeClass ||
+ typelib_TypeClass_EXCEPTION == type->eTypeClass)
+ {
+ TypeDescr td( type );
+ if (td.get()->nSize > sizeof (largest))
+ uno_args[ nPos ] = alloca( td.get()->nSize );
+ }
+
+ if (param.bIn)
+ {
+ try
+ {
+ // in, in/out params
+ map_to_uno(
+ uno_args[ nPos ],args[nPos] , type, false /* no assign */);
+ }
+ catch (...)
+ {
+ // cleanup uno in args
+ for (sal_Int32 n = 0; n < nPos; ++n)
+ {
+ typelib_MethodParameter const & param = pParams[n];
+ if (param.bIn)
+ {
+ uno_type_destructData(uno_args[n], param.pTypeRef, 0);
+ }
+ }
+ throw;
+ }
+ }
+ }
+ uno_Any uno_exc_holder;
+ uno_Any * uno_exc = &uno_exc_holder;
+ // call binary uno
+
+ (*pUnoI->pDispatcher)( pUnoI, member_td, uno_ret, uno_args, &uno_exc );
+
+ if (0 == uno_exc)
+ {
+ // convert out args; destruct uno args
+ for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
+ {
+ typelib_MethodParameter const & param = pParams[ nPos ];
+ typelib_TypeDescriptionReference * type = param.pTypeRef;
+ if (param.bOut)
+ {
+ try
+ {
+ pin_ptr<System::Object^> ptr = &args[nPos];
+ map_to_cli(
+ ptr, uno_args[nPos], param.pTypeRef,
+ argTypes != nullptr ? argTypes[nPos] : nullptr, false );
+ }
+ catch (...)
+ {
+ // cleanup further uno args
+ for ( sal_Int32 n = nPos; n < nParams; ++n )
+ {
+ uno_type_destructData( uno_args[n], pParams[n].pTypeRef, 0 );
+ }
+ // cleanup uno return value
+ uno_type_destructData( uno_ret, return_type, 0 );
+ throw;
+ }
+ }
+ //cleanup args
+ if (typelib_TypeClass_DOUBLE < type->eTypeClass &&
+ typelib_TypeClass_ENUM != type->eTypeClass) // opt
+ {
+ uno_type_destructData(uno_args[nPos], type, 0);
+ }
+ }
+
+ if ((0 != return_type) &&
+ (typelib_TypeClass_VOID != return_type->eTypeClass))
+ {
+ // convert uno return value
+ try
+ {
+ System::Object^ cli_ret;
+ map_to_cli(
+ &cli_ret, uno_ret, return_type, nullptr, false);
+ uno_type_destructData(uno_ret, return_type, 0);
+ return cli_ret;
+ }
+ catch (...)
+ {
+ uno_type_destructData(uno_ret, return_type, 0);
+ throw;
+ }
+ }
+ return nullptr; // void return
+ }
+ else // exception occurred
+ {
+ // destruct uno in args
+ for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
+ {
+ typelib_MethodParameter const & param = pParams[ nPos ];
+ if (param.bIn)
+ {
+ uno_type_destructData( uno_args[ nPos ], param.pTypeRef, 0 );
+ }
+ }
+ map_to_cli(ppExc, uno_exc_holder.pData,
+ uno_exc_holder.pType, nullptr, false);
+ return nullptr;
+ }
+}
+
+void Bridge::call_cli(
+ System::Object^ cliI,
+ sr::MethodInfo^ method,
+ typelib_TypeDescriptionReference * return_type,
+ typelib_MethodParameter * params, int nParams,
+ void * uno_ret, void * uno_args [], uno_Any ** uno_exc ) const
+{
+ array<System::Object^>^ args= gcnew array<System::Object^>(nParams);
+ for (int nPos= 0; nPos < nParams; nPos++)
+ {
+ typelib_MethodParameter const & param= params[nPos];
+ if (param.bIn)
+ {
+ pin_ptr<System::Object^> ptr = &args[nPos];
+ map_to_cli( ptr,
+ uno_args[nPos], param.pTypeRef, nullptr, false);
+ }
+ }
+ System::Object^ retInvoke= nullptr;
+ try
+ {
+ retInvoke= method->Invoke(cliI, args);
+ }
+ catch (sr::TargetInvocationException^ e)
+ {
+ System::Exception^ exc= e->InnerException;
+ css::uno::TypeDescription td(mapCliType(exc->GetType()));
+ // memory for exception
+ std::unique_ptr< rtl_mem > memExc(rtl_mem::allocate(td.get()->nSize));
+ map_to_uno(memExc.get(), exc, td.get()->pWeakRef, false);
+ (*uno_exc)->pType= td.get()->pWeakRef;
+ (*uno_exc)->pData= memExc.release();
+ return;
+ }
+ catch (System::Exception^ e)
+ {
+ throw BridgeRuntimeError("Unexpected exception during invocation of cli object. Original message is: \n" + mapCliString(e->Message));
+ }
+
+ //convert out, in/out params
+ for (int nPos = 0; nPos < nParams; ++nPos )
+ {
+ typelib_MethodParameter const & param = params[ nPos ];
+
+ if (param.bOut)
+ {
+ try
+ {
+ map_to_uno(
+ uno_args[ nPos ], args[ nPos ], param.pTypeRef,
+ sal_True == param.bIn /* assign if inout */);
+ // out array
+ }
+ catch (...)
+ {
+ // cleanup uno pure out
+ for ( sal_Int32 n = 0; n < nPos; ++n )
+ {
+ typelib_MethodParameter const & param = params[ n ];
+ if (! param.bIn)
+ uno_type_destructData( uno_args[ n ], param.pTypeRef, 0 );
+ }
+ throw;
+ }
+ }
+ }
+ // return value
+ if (0 != return_type)
+ {
+ map_to_uno(
+ uno_ret, retInvoke, return_type, false /* no assign */);
+ }
+ // no exception occurred
+ *uno_exc = 0;
+}
+
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-11 20:59:55 +0000