1*61dff127SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*61dff127SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*61dff127SAndrew Rist * or more contributor license agreements. See the NOTICE file
5*61dff127SAndrew Rist * distributed with this work for additional information
6*61dff127SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*61dff127SAndrew Rist * to you under the Apache License, Version 2.0 (the
8*61dff127SAndrew Rist * "License"); you may not use this file except in compliance
9*61dff127SAndrew Rist * with the License. You may obtain a copy of the License at
10*61dff127SAndrew Rist *
11*61dff127SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*61dff127SAndrew Rist *
13*61dff127SAndrew Rist * Unless required by applicable law or agreed to in writing,
14*61dff127SAndrew Rist * software distributed under the License is distributed on an
15*61dff127SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*61dff127SAndrew Rist * KIND, either express or implied. See the License for the
17*61dff127SAndrew Rist * specific language governing permissions and limitations
18*61dff127SAndrew Rist * under the License.
19*61dff127SAndrew Rist *
20*61dff127SAndrew Rist *************************************************************/
21*61dff127SAndrew Rist
22*61dff127SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir #include <malloc.h>
25cdf0e10cSrcweir #include <hash_map>
26cdf0e10cSrcweir
27cdf0e10cSrcweir #include <rtl/alloc.h>
28cdf0e10cSrcweir #include <osl/mutex.hxx>
29cdf0e10cSrcweir
30cdf0e10cSrcweir #include <com/sun/star/uno/genfunc.hxx>
31cdf0e10cSrcweir #include "com/sun/star/uno/RuntimeException.hpp"
32cdf0e10cSrcweir #include <uno/data.h>
33cdf0e10cSrcweir #include <typelib/typedescription.hxx>
34cdf0e10cSrcweir
35cdf0e10cSrcweir #include "bridges/cpp_uno/shared/bridge.hxx"
36cdf0e10cSrcweir #include "bridges/cpp_uno/shared/cppinterfaceproxy.hxx"
37cdf0e10cSrcweir #include "bridges/cpp_uno/shared/types.hxx"
38cdf0e10cSrcweir #include "bridges/cpp_uno/shared/vtablefactory.hxx"
39cdf0e10cSrcweir
40cdf0e10cSrcweir #include "share.hxx"
41cdf0e10cSrcweir
42cdf0e10cSrcweir #include <dlfcn.h>
43cdf0e10cSrcweir
44cdf0e10cSrcweir
45cdf0e10cSrcweir using namespace ::osl;
46cdf0e10cSrcweir using namespace ::rtl;
47cdf0e10cSrcweir using namespace ::com::sun::star::uno;
48cdf0e10cSrcweir
49cdf0e10cSrcweir namespace
50cdf0e10cSrcweir {
51cdf0e10cSrcweir
cpp2uno_call(bridges::cpp_uno::shared::CppInterfaceProxy * pThis,const typelib_TypeDescription * pMemberTypeDescr,typelib_TypeDescriptionReference * pReturnTypeRef,sal_Int32 nParams,typelib_MethodParameter * pParams,long r8,void ** pCallStack,sal_Int64 * pRegisterReturn)52cdf0e10cSrcweir static typelib_TypeClass cpp2uno_call(
53cdf0e10cSrcweir bridges::cpp_uno::shared::CppInterfaceProxy* pThis,
54cdf0e10cSrcweir const typelib_TypeDescription * pMemberTypeDescr,
55cdf0e10cSrcweir typelib_TypeDescriptionReference * pReturnTypeRef,
56cdf0e10cSrcweir sal_Int32 nParams, typelib_MethodParameter * pParams,
57cdf0e10cSrcweir long r8, void ** pCallStack,
58cdf0e10cSrcweir sal_Int64 * pRegisterReturn /* space for register return */ )
59cdf0e10cSrcweir {
60cdf0e10cSrcweir // pCallStack: ret, [return ptr], this, params
61cdf0e10cSrcweir char * pTopStack = (char *)(pCallStack + 0);
62cdf0e10cSrcweir char * pCppStack = pTopStack;
63cdf0e10cSrcweir #ifdef CMC_DEBUG
64cdf0e10cSrcweir fprintf(stderr, "cpp2uno_call\n");
65cdf0e10cSrcweir #endif
66cdf0e10cSrcweir // return
67cdf0e10cSrcweir typelib_TypeDescription * pReturnTypeDescr = 0;
68cdf0e10cSrcweir if (pReturnTypeRef)
69cdf0e10cSrcweir TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
70cdf0e10cSrcweir
71cdf0e10cSrcweir void * pUnoReturn = 0;
72cdf0e10cSrcweir // complex return ptr: if != 0 && != pUnoReturn, reconversion need
73cdf0e10cSrcweir void * pCppReturn = 0;
74cdf0e10cSrcweir
75cdf0e10cSrcweir if (pReturnTypeDescr)
76cdf0e10cSrcweir {
77cdf0e10cSrcweir if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
78cdf0e10cSrcweir {
79cdf0e10cSrcweir #ifdef CMC_DEBUG
80cdf0e10cSrcweir fprintf(stderr, "simple return\n");
81cdf0e10cSrcweir #endif
82cdf0e10cSrcweir pUnoReturn = pRegisterReturn; // direct way for simple types
83cdf0e10cSrcweir }
84cdf0e10cSrcweir else // complex return via ptr (pCppReturn)
85cdf0e10cSrcweir {
86cdf0e10cSrcweir #ifdef CMC_DEBUG
87cdf0e10cSrcweir fprintf(stderr, "complex return\n");
88cdf0e10cSrcweir #endif
89cdf0e10cSrcweir pCppReturn = (void *)r8;
90cdf0e10cSrcweir
91cdf0e10cSrcweir pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
92cdf0e10cSrcweir ? alloca( pReturnTypeDescr->nSize )
93cdf0e10cSrcweir : pCppReturn); // direct way
94cdf0e10cSrcweir }
95cdf0e10cSrcweir }
96cdf0e10cSrcweir // pop this
97cdf0e10cSrcweir pCppStack += sizeof( void* );
98cdf0e10cSrcweir
99cdf0e10cSrcweir // stack space
100cdf0e10cSrcweir OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32),
101cdf0e10cSrcweir "### unexpected size!" );
102cdf0e10cSrcweir // parameters
103cdf0e10cSrcweir void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
104cdf0e10cSrcweir void ** pCppArgs = pUnoArgs + nParams;
105cdf0e10cSrcweir // indizes of values this have to be converted (interface conversion
106cdf0e10cSrcweir // cpp<=>uno)
107cdf0e10cSrcweir sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
108cdf0e10cSrcweir // type descriptions for reconversions
109cdf0e10cSrcweir typelib_TypeDescription ** ppTempParamTypeDescr =
110cdf0e10cSrcweir (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
111cdf0e10cSrcweir
112cdf0e10cSrcweir sal_Int32 nTempIndizes = 0;
113cdf0e10cSrcweir
114cdf0e10cSrcweir for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
115cdf0e10cSrcweir {
116cdf0e10cSrcweir const typelib_MethodParameter & rParam = pParams[nPos];
117cdf0e10cSrcweir typelib_TypeDescription * pParamTypeDescr = 0;
118cdf0e10cSrcweir TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
119cdf0e10cSrcweir
120cdf0e10cSrcweir if (!rParam.bOut &&
121cdf0e10cSrcweir bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
122cdf0e10cSrcweir {
123cdf0e10cSrcweir switch (pParamTypeDescr->eTypeClass)
124cdf0e10cSrcweir {
125cdf0e10cSrcweir case typelib_TypeClass_BYTE:
126cdf0e10cSrcweir case typelib_TypeClass_BOOLEAN:
127cdf0e10cSrcweir pCppArgs[nPos] = pCppStack + 3;
128cdf0e10cSrcweir pUnoArgs[nPos] = pCppStack + 3;
129cdf0e10cSrcweir break;
130cdf0e10cSrcweir case typelib_TypeClass_CHAR:
131cdf0e10cSrcweir case typelib_TypeClass_SHORT:
132cdf0e10cSrcweir case typelib_TypeClass_UNSIGNED_SHORT:
133cdf0e10cSrcweir pCppArgs[nPos] = pCppStack + 2;
134cdf0e10cSrcweir pUnoArgs[nPos] = pCppStack + 2;
135cdf0e10cSrcweir break;
136cdf0e10cSrcweir case typelib_TypeClass_HYPER:
137cdf0e10cSrcweir case typelib_TypeClass_UNSIGNED_HYPER:
138cdf0e10cSrcweir case typelib_TypeClass_DOUBLE:
139cdf0e10cSrcweir pCppArgs[nPos] = pCppStack;
140cdf0e10cSrcweir pUnoArgs[nPos] = pCppStack;
141cdf0e10cSrcweir pCppStack += sizeof(sal_Int32); // extra long
142cdf0e10cSrcweir break;
143cdf0e10cSrcweir default:
144cdf0e10cSrcweir pCppArgs[nPos] = pCppStack;
145cdf0e10cSrcweir pUnoArgs[nPos] = pCppStack;
146cdf0e10cSrcweir break;
147cdf0e10cSrcweir }
148cdf0e10cSrcweir // no longer needed
149cdf0e10cSrcweir TYPELIB_DANGER_RELEASE( pParamTypeDescr );
150cdf0e10cSrcweir }
151cdf0e10cSrcweir else // ptr to complex value | ref
152cdf0e10cSrcweir {
153cdf0e10cSrcweir pCppArgs[nPos] = *(void **)pCppStack;
154cdf0e10cSrcweir
155cdf0e10cSrcweir if (! rParam.bIn) // is pure out
156cdf0e10cSrcweir {
157cdf0e10cSrcweir // uno out is unconstructed mem!
158cdf0e10cSrcweir pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
159cdf0e10cSrcweir pTempIndizes[nTempIndizes] = nPos;
160cdf0e10cSrcweir // will be released at reconversion
161cdf0e10cSrcweir ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
162cdf0e10cSrcweir }
163cdf0e10cSrcweir // is in/inout
164cdf0e10cSrcweir else if (bridges::cpp_uno::shared::relatesToInterfaceType(
165cdf0e10cSrcweir pParamTypeDescr ))
166cdf0e10cSrcweir {
167cdf0e10cSrcweir uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
168cdf0e10cSrcweir *(void **)pCppStack, pParamTypeDescr,
169cdf0e10cSrcweir pThis->getBridge()->getCpp2Uno() );
170cdf0e10cSrcweir pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
171cdf0e10cSrcweir // will be released at reconversion
172cdf0e10cSrcweir ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
173cdf0e10cSrcweir }
174cdf0e10cSrcweir else // direct way
175cdf0e10cSrcweir {
176cdf0e10cSrcweir pUnoArgs[nPos] = *(void **)pCppStack;
177cdf0e10cSrcweir // no longer needed
178cdf0e10cSrcweir TYPELIB_DANGER_RELEASE( pParamTypeDescr );
179cdf0e10cSrcweir }
180cdf0e10cSrcweir }
181cdf0e10cSrcweir pCppStack += sizeof(sal_Int32); // standard parameter length
182cdf0e10cSrcweir }
183cdf0e10cSrcweir
184cdf0e10cSrcweir // ExceptionHolder
185cdf0e10cSrcweir uno_Any aUnoExc; // Any will be constructed by callee
186cdf0e10cSrcweir uno_Any * pUnoExc = &aUnoExc;
187cdf0e10cSrcweir
188cdf0e10cSrcweir #ifdef CMC_DEBUG
189cdf0e10cSrcweir fprintf(stderr, "before dispatch\n");
190cdf0e10cSrcweir #endif
191cdf0e10cSrcweir // invoke uno dispatch call
192cdf0e10cSrcweir (*pThis->getUnoI()->pDispatcher)(
193cdf0e10cSrcweir pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
194cdf0e10cSrcweir
195cdf0e10cSrcweir #ifdef CMC_DEBUG
196cdf0e10cSrcweir fprintf(stderr, "after dispatch\n");
197cdf0e10cSrcweir #endif
198cdf0e10cSrcweir
199cdf0e10cSrcweir // in case an exception occured...
200cdf0e10cSrcweir if (pUnoExc)
201cdf0e10cSrcweir {
202cdf0e10cSrcweir // destruct temporary in/inout params
203cdf0e10cSrcweir for ( ; nTempIndizes--; )
204cdf0e10cSrcweir {
205cdf0e10cSrcweir sal_Int32 nIndex = pTempIndizes[nTempIndizes];
206cdf0e10cSrcweir
207cdf0e10cSrcweir if (pParams[nIndex].bIn) // is in/inout => was constructed
208cdf0e10cSrcweir uno_destructData( pUnoArgs[nIndex],
209cdf0e10cSrcweir ppTempParamTypeDescr[nTempIndizes], 0 );
210cdf0e10cSrcweir TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
211cdf0e10cSrcweir }
212cdf0e10cSrcweir if (pReturnTypeDescr)
213cdf0e10cSrcweir TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
214cdf0e10cSrcweir
215cdf0e10cSrcweir CPPU_CURRENT_NAMESPACE::raiseException( &aUnoExc,
216cdf0e10cSrcweir pThis->getBridge()->getUno2Cpp() ); // has to destruct the any
217cdf0e10cSrcweir // is here for dummy
218cdf0e10cSrcweir return typelib_TypeClass_VOID;
219cdf0e10cSrcweir }
220cdf0e10cSrcweir else // else no exception occured...
221cdf0e10cSrcweir {
222cdf0e10cSrcweir // temporary params
223cdf0e10cSrcweir for ( ; nTempIndizes--; )
224cdf0e10cSrcweir {
225cdf0e10cSrcweir sal_Int32 nIndex = pTempIndizes[nTempIndizes];
226cdf0e10cSrcweir typelib_TypeDescription * pParamTypeDescr =
227cdf0e10cSrcweir ppTempParamTypeDescr[nTempIndizes];
228cdf0e10cSrcweir
229cdf0e10cSrcweir if (pParams[nIndex].bOut) // inout/out
230cdf0e10cSrcweir {
231cdf0e10cSrcweir // convert and assign
232cdf0e10cSrcweir uno_destructData( pCppArgs[nIndex], pParamTypeDescr,
233cdf0e10cSrcweir cpp_release );
234cdf0e10cSrcweir uno_copyAndConvertData( pCppArgs[nIndex], pUnoArgs[nIndex],
235cdf0e10cSrcweir pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
236cdf0e10cSrcweir }
237cdf0e10cSrcweir // destroy temp uno param
238cdf0e10cSrcweir uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 );
239cdf0e10cSrcweir
240cdf0e10cSrcweir TYPELIB_DANGER_RELEASE( pParamTypeDescr );
241cdf0e10cSrcweir }
242cdf0e10cSrcweir // return
243cdf0e10cSrcweir if (pCppReturn) // has complex return
244cdf0e10cSrcweir {
245cdf0e10cSrcweir if (pUnoReturn != pCppReturn) // needs reconversion
246cdf0e10cSrcweir {
247cdf0e10cSrcweir uno_copyAndConvertData( pCppReturn, pUnoReturn,
248cdf0e10cSrcweir pReturnTypeDescr, pThis->getBridge()->getUno2Cpp() );
249cdf0e10cSrcweir // destroy temp uno return
250cdf0e10cSrcweir uno_destructData( pUnoReturn, pReturnTypeDescr, 0 );
251cdf0e10cSrcweir }
252cdf0e10cSrcweir // complex return ptr is set to return reg
253cdf0e10cSrcweir *(void **)pRegisterReturn = pCppReturn;
254cdf0e10cSrcweir }
255cdf0e10cSrcweir if (pReturnTypeDescr)
256cdf0e10cSrcweir {
257cdf0e10cSrcweir typelib_TypeClass eRet =
258cdf0e10cSrcweir (typelib_TypeClass)pReturnTypeDescr->eTypeClass;
259cdf0e10cSrcweir TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
260cdf0e10cSrcweir return eRet;
261cdf0e10cSrcweir }
262cdf0e10cSrcweir else
263cdf0e10cSrcweir return typelib_TypeClass_VOID;
264cdf0e10cSrcweir }
265cdf0e10cSrcweir }
266cdf0e10cSrcweir
267cdf0e10cSrcweir
268cdf0e10cSrcweir //=====================================================================
cpp_mediate(sal_Int32 nFunctionIndex,sal_Int32 nVtableOffset,long sp,long r8,sal_Int64 * pRegisterReturn)269cdf0e10cSrcweir static typelib_TypeClass cpp_mediate(
270cdf0e10cSrcweir sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
271cdf0e10cSrcweir long sp, long r8,
272cdf0e10cSrcweir sal_Int64 * pRegisterReturn /* space for register return */ )
273cdf0e10cSrcweir {
274cdf0e10cSrcweir void ** pCallStack = (void**)(sp);
275cdf0e10cSrcweir #ifdef CMC_DEBUG
276cdf0e10cSrcweir fprintf(stderr, "cpp_mediate with\n");
277cdf0e10cSrcweir fprintf(stderr, "%x %x\n", nFunctionIndex, nVtableOffset);
278cdf0e10cSrcweir fprintf(stderr, "and %x %x\n", pCallStack, pRegisterReturn);
279cdf0e10cSrcweir fprintf(stderr, "and %x %x\n", pCallStack[0], pCallStack[1]);
280cdf0e10cSrcweir #endif
281cdf0e10cSrcweir OSL_ENSURE( sizeof(sal_Int32)==sizeof(void *), "### unexpected!" );
282cdf0e10cSrcweir
283cdf0e10cSrcweir void *pThis = pCallStack[0];
284cdf0e10cSrcweir
285cdf0e10cSrcweir pThis = static_cast< char * >(pThis) - nVtableOffset;
286cdf0e10cSrcweir
287cdf0e10cSrcweir bridges::cpp_uno::shared::CppInterfaceProxy * pCppI =
288cdf0e10cSrcweir bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(
289cdf0e10cSrcweir pThis);
290cdf0e10cSrcweir
291cdf0e10cSrcweir typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
292cdf0e10cSrcweir
293cdf0e10cSrcweir OSL_ENSURE( nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex,
294cdf0e10cSrcweir "### illegal vtable index!" );
295cdf0e10cSrcweir if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)
296cdf0e10cSrcweir {
297cdf0e10cSrcweir throw RuntimeException(
298cdf0e10cSrcweir OUString::createFromAscii("illegal vtable index!"),
299cdf0e10cSrcweir (XInterface *)pCppI );
300cdf0e10cSrcweir }
301cdf0e10cSrcweir
302cdf0e10cSrcweir // determine called method
303cdf0e10cSrcweir OSL_ENSURE( nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex,
304cdf0e10cSrcweir "### illegal vtable index!" );
305cdf0e10cSrcweir sal_Int32 nMemberPos =
306cdf0e10cSrcweir pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
307cdf0e10cSrcweir OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers,
308cdf0e10cSrcweir "### illegal member index!" );
309cdf0e10cSrcweir
310cdf0e10cSrcweir TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );
311cdf0e10cSrcweir
312cdf0e10cSrcweir typelib_TypeClass eRet;
313cdf0e10cSrcweir switch (aMemberDescr.get()->eTypeClass)
314cdf0e10cSrcweir {
315cdf0e10cSrcweir case typelib_TypeClass_INTERFACE_ATTRIBUTE:
316cdf0e10cSrcweir {
317cdf0e10cSrcweir if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] ==
318cdf0e10cSrcweir nFunctionIndex)
319cdf0e10cSrcweir {
320cdf0e10cSrcweir // is GET method
321cdf0e10cSrcweir eRet = cpp2uno_call(
322cdf0e10cSrcweir pCppI, aMemberDescr.get(),
323cdf0e10cSrcweir ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef,
324cdf0e10cSrcweir 0, 0, // no params
325cdf0e10cSrcweir r8, pCallStack, pRegisterReturn );
326cdf0e10cSrcweir }
327cdf0e10cSrcweir else
328cdf0e10cSrcweir {
329cdf0e10cSrcweir // is SET method
330cdf0e10cSrcweir typelib_MethodParameter aParam;
331cdf0e10cSrcweir aParam.pTypeRef =
332cdf0e10cSrcweir ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef;
333cdf0e10cSrcweir aParam.bIn = sal_True;
334cdf0e10cSrcweir aParam.bOut = sal_False;
335cdf0e10cSrcweir
336cdf0e10cSrcweir eRet = cpp2uno_call(
337cdf0e10cSrcweir pCppI, aMemberDescr.get(),
338cdf0e10cSrcweir 0, // indicates void return
339cdf0e10cSrcweir 1, &aParam,
340cdf0e10cSrcweir r8, pCallStack, pRegisterReturn );
341cdf0e10cSrcweir }
342cdf0e10cSrcweir break;
343cdf0e10cSrcweir }
344cdf0e10cSrcweir case typelib_TypeClass_INTERFACE_METHOD:
345cdf0e10cSrcweir {
346cdf0e10cSrcweir // is METHOD
347cdf0e10cSrcweir switch (nFunctionIndex)
348cdf0e10cSrcweir {
349cdf0e10cSrcweir case 1: // acquire()
350cdf0e10cSrcweir pCppI->acquireProxy(); // non virtual call!
351cdf0e10cSrcweir eRet = typelib_TypeClass_VOID;
352cdf0e10cSrcweir break;
353cdf0e10cSrcweir case 2: // release()
354cdf0e10cSrcweir pCppI->releaseProxy(); // non virtual call!
355cdf0e10cSrcweir eRet = typelib_TypeClass_VOID;
356cdf0e10cSrcweir break;
357cdf0e10cSrcweir case 0: // queryInterface() opt
358cdf0e10cSrcweir {
359cdf0e10cSrcweir typelib_TypeDescription * pTD = 0;
360cdf0e10cSrcweir TYPELIB_DANGER_GET(&pTD,
361cdf0e10cSrcweir reinterpret_cast<Type *>(pCallStack[1])->getTypeLibType());
362cdf0e10cSrcweir if (pTD)
363cdf0e10cSrcweir {
364cdf0e10cSrcweir XInterface * pInterface = 0;
365cdf0e10cSrcweir (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)(
366cdf0e10cSrcweir pCppI->getBridge()->getCppEnv(),
367cdf0e10cSrcweir (void **)&pInterface, pCppI->getOid().pData,
368cdf0e10cSrcweir (typelib_InterfaceTypeDescription *)pTD );
369cdf0e10cSrcweir
370cdf0e10cSrcweir if (pInterface)
371cdf0e10cSrcweir {
372cdf0e10cSrcweir ::uno_any_construct(
373cdf0e10cSrcweir reinterpret_cast< uno_Any * >( r8 ),
374cdf0e10cSrcweir &pInterface, pTD, cpp_acquire );
375cdf0e10cSrcweir pInterface->release();
376cdf0e10cSrcweir TYPELIB_DANGER_RELEASE( pTD );
377cdf0e10cSrcweir *(void **)pRegisterReturn = (void*)r8;
378cdf0e10cSrcweir eRet = typelib_TypeClass_ANY;
379cdf0e10cSrcweir break;
380cdf0e10cSrcweir }
381cdf0e10cSrcweir TYPELIB_DANGER_RELEASE( pTD );
382cdf0e10cSrcweir }
383cdf0e10cSrcweir } // else perform queryInterface()
384cdf0e10cSrcweir default:
385cdf0e10cSrcweir eRet = cpp2uno_call(
386cdf0e10cSrcweir pCppI, aMemberDescr.get(),
387cdf0e10cSrcweir ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pReturnTypeRef,
388cdf0e10cSrcweir ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->nParams,
389cdf0e10cSrcweir ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pParams,
390cdf0e10cSrcweir r8, pCallStack, pRegisterReturn );
391cdf0e10cSrcweir }
392cdf0e10cSrcweir break;
393cdf0e10cSrcweir }
394cdf0e10cSrcweir default:
395cdf0e10cSrcweir {
396cdf0e10cSrcweir throw RuntimeException(
397cdf0e10cSrcweir OUString::createFromAscii("no member description found!"),
398cdf0e10cSrcweir (XInterface *)pCppI );
399cdf0e10cSrcweir // is here for dummy
400cdf0e10cSrcweir eRet = typelib_TypeClass_VOID;
401cdf0e10cSrcweir }
402cdf0e10cSrcweir }
403cdf0e10cSrcweir
404cdf0e10cSrcweir return eRet;
405cdf0e10cSrcweir }
406cdf0e10cSrcweir }
407cdf0e10cSrcweir
408cdf0e10cSrcweir //=======================================================================
409cdf0e10cSrcweir /**
410cdf0e10cSrcweir * is called on incoming vtable calls
411cdf0e10cSrcweir * (called by asm snippets)
412cdf0e10cSrcweir */
413cdf0e10cSrcweir
cpp_vtable_call(long firstonstack)414cdf0e10cSrcweir extern "C" sal_Int64 cpp_vtable_call( long firstonstack )
415cdf0e10cSrcweir {
416cdf0e10cSrcweir register long d0 asm("d0");
417cdf0e10cSrcweir long functionIndex = d0;
418cdf0e10cSrcweir
419cdf0e10cSrcweir register long a1 asm("a1");
420cdf0e10cSrcweir long r8 = a1;
421cdf0e10cSrcweir
422cdf0e10cSrcweir register long d1 asm("d1");
423cdf0e10cSrcweir long vtableOffset = d1;
424cdf0e10cSrcweir
425cdf0e10cSrcweir long sp = (long)&firstonstack;
426cdf0e10cSrcweir
427cdf0e10cSrcweir sal_Int64 nRegReturn;
428cdf0e10cSrcweir cpp_mediate( functionIndex, vtableOffset, sp, r8, &nRegReturn );
429cdf0e10cSrcweir return nRegReturn;
430cdf0e10cSrcweir }
431cdf0e10cSrcweir
432cdf0e10cSrcweir namespace
433cdf0e10cSrcweir {
434cdf0e10cSrcweir const int codeSnippetSize = 20;
435cdf0e10cSrcweir
436cdf0e10cSrcweir //some m68k info : http://www2.biglobe.ne.jp/~inaba/trampolines.html
437cdf0e10cSrcweir
codeSnippet(unsigned char * code,sal_Int32 functionIndex,sal_Int32 vtableOffset)438cdf0e10cSrcweir unsigned char *codeSnippet(unsigned char* code, sal_Int32 functionIndex,
439cdf0e10cSrcweir sal_Int32 vtableOffset)
440cdf0e10cSrcweir {
441cdf0e10cSrcweir unsigned char * p = code;
442cdf0e10cSrcweir *(short *)&p[0] = 0x203C; //movel functionIndex,d0
443cdf0e10cSrcweir *(long *)&p[2] = functionIndex;
444cdf0e10cSrcweir *(short *)&p[6] = 0x223C; //movel functionIndex,d1
445cdf0e10cSrcweir *(long *)&p[8] = vtableOffset;
446cdf0e10cSrcweir *(short *)&p[12] = 0x4EF9; //jmp cpp_vtable_call
447cdf0e10cSrcweir *(long *)&p[14] = (long)&cpp_vtable_call;
448cdf0e10cSrcweir *(short *)&p[18] = 0x4E71; //nop
449cdf0e10cSrcweir return code + codeSnippetSize;
450cdf0e10cSrcweir }
451cdf0e10cSrcweir }
452cdf0e10cSrcweir
453cdf0e10cSrcweir struct bridges::cpp_uno::shared::VtableFactory::Slot { void * fn; };
454cdf0e10cSrcweir
455cdf0e10cSrcweir bridges::cpp_uno::shared::VtableFactory::Slot *
mapBlockToVtable(void * block)456cdf0e10cSrcweir bridges::cpp_uno::shared::VtableFactory::mapBlockToVtable(void * block)
457cdf0e10cSrcweir {
458cdf0e10cSrcweir return static_cast< Slot * >(block) + 2;
459cdf0e10cSrcweir }
460cdf0e10cSrcweir
getBlockSize(sal_Int32 slotCount)461cdf0e10cSrcweir sal_Size bridges::cpp_uno::shared::VtableFactory::getBlockSize(
462cdf0e10cSrcweir sal_Int32 slotCount)
463cdf0e10cSrcweir {
464cdf0e10cSrcweir return (slotCount + 2) * sizeof (Slot) + slotCount * codeSnippetSize;
465cdf0e10cSrcweir }
466cdf0e10cSrcweir
467cdf0e10cSrcweir bridges::cpp_uno::shared::VtableFactory::Slot *
initializeBlock(void * block,sal_Int32 slotCount)468cdf0e10cSrcweir bridges::cpp_uno::shared::VtableFactory::initializeBlock(
469cdf0e10cSrcweir void * block, sal_Int32 slotCount)
470cdf0e10cSrcweir {
471cdf0e10cSrcweir Slot * slots = mapBlockToVtable(block);
472cdf0e10cSrcweir slots[-2].fn = 0;
473cdf0e10cSrcweir slots[-1].fn = 0;
474cdf0e10cSrcweir return slots + slotCount;
475cdf0e10cSrcweir }
476cdf0e10cSrcweir
addLocalFunctions(Slot ** slots,unsigned char * code,sal_PtrDiff writetoexecdiff,typelib_InterfaceTypeDescription const * type,sal_Int32 functionOffset,sal_Int32 functionCount,sal_Int32 vtableOffset)477cdf0e10cSrcweir unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
478cdf0e10cSrcweir Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
479cdf0e10cSrcweir typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
480cdf0e10cSrcweir sal_Int32 functionCount, sal_Int32 vtableOffset)
481cdf0e10cSrcweir {
482cdf0e10cSrcweir (*slots) -= functionCount;
483cdf0e10cSrcweir Slot * s = *slots;
484cdf0e10cSrcweir for (sal_Int32 i = 0; i < type->nMembers; ++i)
485cdf0e10cSrcweir {
486cdf0e10cSrcweir typelib_TypeDescription * member = 0;
487cdf0e10cSrcweir TYPELIB_DANGER_GET(&member, type->ppMembers[i]);
488cdf0e10cSrcweir OSL_ASSERT(member != 0);
489cdf0e10cSrcweir switch (member->eTypeClass)
490cdf0e10cSrcweir {
491cdf0e10cSrcweir case typelib_TypeClass_INTERFACE_ATTRIBUTE:
492cdf0e10cSrcweir // Getter:
493cdf0e10cSrcweir (s++)->fn = code + writetoexecdiff;
494cdf0e10cSrcweir code = codeSnippet(code, functionOffset++, vtableOffset);
495cdf0e10cSrcweir // Setter:
496cdf0e10cSrcweir if (!reinterpret_cast<
497cdf0e10cSrcweir typelib_InterfaceAttributeTypeDescription * >(
498cdf0e10cSrcweir member)->bReadOnly)
499cdf0e10cSrcweir {
500cdf0e10cSrcweir (s++)->fn = code + writetoexecdiff;
501cdf0e10cSrcweir code = codeSnippet(code, functionOffset++, vtableOffset);
502cdf0e10cSrcweir }
503cdf0e10cSrcweir break;
504cdf0e10cSrcweir case typelib_TypeClass_INTERFACE_METHOD:
505cdf0e10cSrcweir {
506cdf0e10cSrcweir (s++)->fn = code + writetoexecdiff;
507cdf0e10cSrcweir
508cdf0e10cSrcweir typelib_InterfaceMethodTypeDescription *pMethodTD =
509cdf0e10cSrcweir reinterpret_cast<
510cdf0e10cSrcweir typelib_InterfaceMethodTypeDescription * >(member);
511cdf0e10cSrcweir
512cdf0e10cSrcweir bool issimple = bridges::cpp_uno::shared::isSimpleType(
513cdf0e10cSrcweir pMethodTD->pReturnTypeRef);
514cdf0e10cSrcweir
515cdf0e10cSrcweir code = codeSnippet(code, functionOffset++, vtableOffset);
516cdf0e10cSrcweir break;
517cdf0e10cSrcweir }
518cdf0e10cSrcweir default:
519cdf0e10cSrcweir OSL_ASSERT(false);
520cdf0e10cSrcweir break;
521cdf0e10cSrcweir }
522cdf0e10cSrcweir TYPELIB_DANGER_RELEASE(member);
523cdf0e10cSrcweir }
524cdf0e10cSrcweir return code;
525cdf0e10cSrcweir }
526cdf0e10cSrcweir
flushCode(unsigned char const *,unsigned char const *)527cdf0e10cSrcweir void bridges::cpp_uno::shared::VtableFactory::flushCode(
528cdf0e10cSrcweir unsigned char const * /*beg*/, unsigned char const * /*end*/)
529cdf0e10cSrcweir {
530cdf0e10cSrcweir }
531cdf0e10cSrcweir
532cdf0e10cSrcweir /* vi:set tabstop=4 shiftwidth=4 expandtab: */
533