Attachment #14746 for issue #28110

View | Details | Raw Unified | Return to issue 28110
Collapse All | Expand All




 *
 *  $RCSfile: cpp2uno.cxx,v $
 *
 *  $Revision: 1.4 $
 *
 *  last change: $Author: svesik $ $Date: 2004/04/21 13:40:45 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses

 *
 *
 ************************************************************************/
#include <com/sun/star/uno/genfunc.hxx>
#define LEAK_STATIC_DATA
//  #define TRACE(x) OSL_TRACE(x)
#define TRACE(x)

#include <malloc.h>
#include <list>
#include <map>
#include <typeinfo>
#ifndef _RTL_ALLOC_H_
#include <rtl/alloc.h>
#endif
#ifndef _OSL_MUTEX_HXX_
#include <osl/mutex.hxx>
#endif

#ifndef _TYPELIB_TYPEDESCRIPTION_HXX_
#include <typelib/typedescription.hxx>
#endif
#ifndef _UNO_DATA_H_
#include <uno/data.h>
#include "bridges/cpp_uno/shared/bridge.hxx"
#include "bridges/cpp_uno/shared/cppinterfaceproxy.hxx"
#include "bridges/cpp_uno/shared/types.hxx"
#include "bridges/cpp_uno/shared/vtablefactory.hxx"
#ifndef _BRIDGES_CPP_UNO_TYPE_MISC_HXX_
#include <bridges/cpp_uno/type_misc.hxx>
#endif

#include "share.hxx"

using namespace com::sun::star::uno;
using namespace std;
using namespace osl;
using namespace rtl;

namespace
{

//==================================================================================================
rtl_StandardModuleCount g_moduleCount = MODULE_COUNT_INIT;

//==================================================================================================
static typelib_TypeClass cpp2uno_call(
	 bridges::cpp_uno::shared::CppInterfaceProxy * pThis,
	const typelib_TypeDescription * pMemberTypeDescr,
	typelib_TypeDescriptionReference * pReturnTypeRef, // 0 indicates void return
	sal_Int32 nParams, typelib_MethodParameter * pParams,

	
	if (pReturnTypeDescr)
	{
	if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
	{
			pUnoReturn = pRegisterReturn; // direct way for simple types
	}
		else // complex return via ptr (pCppReturn)
		{
			pCppReturn = *(void**)pCppStack;
			pCppStack += sizeof( void* );
			pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType(
  	                             pReturnTypeDescr )
						  ? alloca( pReturnTypeDescr->nSize )
						  : pCppReturn); // direct way

		}
	}
	// pop this

		typelib_TypeDescription * pParamTypeDescr = 0;
		TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );

	 	if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))  // value
		{
			pCppArgs[nPos] = pCppStack;
			pUnoArgs[nPos] = pCppStack;
			switch (pParamTypeDescr->eTypeClass)
			{
			case typelib_TypeClass_HYPER:

				ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
			}
			// is in/inout
			else if (bridges::cpp_uno::shared::relatesToInterfaceType(
  	                        pParamTypeDescr ))
			{
				uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
										*(void **)pCppStack, pParamTypeDescr,
										  pThis->getBridge()->getCpp2Uno() );
				pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
				// will be released at reconversion
				ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;

	uno_Any * pUnoExc = &aUnoExc;

	// invoke uno dispatch call
	(*pThis->getUnoI()->pDispatcher)(pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
	
	// in case an exception occured...
	if (pUnoExc)
	{

		}
		if (pReturnTypeDescr)
			TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
		CPPU_CURRENT_NAMESPACE::raiseException(
  	           &aUnoExc, pThis->getBridge()->getUno2Cpp() );
  	           // has to destruct the any
               // is here for dummy
		return typelib_TypeClass_VOID;
	}
	else // else no exception occured...

				// convert and assign
				uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
				uno_copyAndConvertData( pCppArgs[nIndex], pUnoArgs[nIndex], pParamTypeDescr,
									pThis->getBridge()->getUno2Cpp() );
			}
			// destroy temp uno param
			uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 );

			if (pUnoReturn != pCppReturn) // needs reconversion
			{
				uno_copyAndConvertData( pCppReturn, pUnoReturn, pReturnTypeDescr,
					pThis->getBridge()->getUno2Cpp() );
				// destroy temp uno return
				uno_destructData( pUnoReturn, pReturnTypeDescr, 0 );
			}


//==================================================================================================
static typelib_TypeClass cpp_mediate(
	sal_Int32		nFunctionIndex,
	sal_Int32		nVtableOffset,
	void **		pCallStack,
	sal_Int64 *	pRegisterReturn /* space for register return */ )
{
	OSL_ENSURE( sizeof(sal_Int32)==sizeof(void *), "### unexpected!" );

	// pCallStack: this, params
	// eventual [ret*] lies at pCallStack -1
	// so count down pCallStack by one to keep it simple
	if ((nFunctionIndex & 0x80000000) != 0) {
		nFunctionIndex &= 0x7FFFFFFF;
		--pCallStack;
	if( nVtableCall & 0x80000000 )
	{
		pCallStack--;
		nVtableCall &= 0x7fffffff;
	}

	typelib_InterfaceTypeDescription * pTypeDescr = pCppI->pTypeDescr;
	
	bridges::cpp_uno::shared::CppInterfaceProxy * pCppI
		= bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(
		static_cast< char * >(*pCallStack) - nVtableOffset);
	
  	typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();

	OSL_ENSURE( nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex,
				 "### illegal vtable index!" );
	if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)
	{
		throw RuntimeException( OUString::createFromAscii("illegal vtable index!"), (XInterface *)pCppI );
	}

	// determine called method
	sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
	sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nVtableCall];
	OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### illegal member index!" );

	TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );

//#if defined BRIDGES_DEBUG
//    OString cstr( OUStringToOString( aMemberDescr.get()->pTypeName, RTL_TEXTENCODING_ASCII_US ) );
//    fprintf( stderr, "calling %s, nVtableCall=%d\n", cstr.getStr(), nVtableCall );
//#endif

	typelib_TypeClass eRet;
	switch (aMemberDescr.get()->eTypeClass)
	{
	case typelib_TypeClass_INTERFACE_ATTRIBUTE:
	{
	if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex)
		{
			// is GET method
			eRet = cpp2uno_call(

	case typelib_TypeClass_INTERFACE_METHOD:
	{
		// is METHOD
		switch (nFunctionIndex)
		{
		case 1: // acquire()
			pCppI->acquireProxy(); // non virtual call!

			if (pTD)
			{
                XInterface * pInterface = 0;
		(*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)(
		pCppI->getBridge()->getCppEnv(),
		(void **)&pInterface, pCppI->getOid().pData,
		(typelib_InterfaceTypeDescription *)pTD );
			
                if (pInterface)
                {

		}
		break;
	}
//	default:
//	{
//		throw RuntimeException(
//		rtl::OUString::createFromAscii("no member description found!"),
//		(XInterface *)pThis );
//		// is here for dummy
//		eRet = typelib_TypeClass_VOID;
//	}
	}
    
	return eRet;
}

//==================================================================================================
class MediateClassData
{
public:
	struct ClassDataBuffer
	{
		void*			m_pVTable;

		~ClassDataBuffer();
	};
private:

	map< OUString, ClassDataBuffer* >		m_aClassData;
	Mutex									m_aMutex;

	void createVTable( ClassDataBuffer*, typelib_InterfaceTypeDescription* );
public:
	const ClassDataBuffer* getClassData( typelib_InterfaceTypeDescription* );
	
	MediateClassData() {}
	~MediateClassData();
};
//__________________________________________________________________________________________________
MediateClassData::ClassDataBuffer::~ClassDataBuffer()
{
	delete m_pVTable;
}

	return eRet;
MediateClassData::~MediateClassData()
{
	TRACE( "> calling ~MediateClassData(): freeing mediate vtables... <\n" );
	
	// this MUST be the absolute last one which is called!
	for ( map< OUString, ClassDataBuffer* >::iterator iPos( m_aClassData.begin() ); iPos != m_aClassData.end(); ++iPos )
	{
		// todo
//  		delete (*iPos).second;
	}
}

//__________________________________________________________________________________________________

const MediateClassData::ClassDataBuffer* MediateClassData::getClassData( typelib_InterfaceTypeDescription* pType )
{
	MutexGuard aGuard( m_aMutex );

	map< OUString, ClassDataBuffer* >::iterator element = m_aClassData.find( pType->aBase.pTypeName );
	if( element != m_aClassData.end() )
		return (*element).second;

	ClassDataBuffer* pBuffer = new ClassDataBuffer();
	createVTable( pBuffer, pType );
	m_aClassData[ pType->aBase.pTypeName ] = pBuffer;
	return pBuffer;
}


//==================================================================================================

 * is called on incoming vtable calls
 * (called by asm snippets)
 */
int cpp_vtable_call(
	sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset, void** pCallStack)
{
	int nTableEntry;
	void** pCallStack;
	volatile sal_Int64 nRegReturn;

	// nTableEntry and pCallStack are delivered in registers as usual
	// but cpp_vtable_call is declared void.
	// the reason is that this way the compiler won't clobber the
	// call stack prepared by the assembler snippet to save its input
	// registers
	// also restore %i2 here which was clobbered to jump here
	__asm__( "st %%i0, %0\n\t"
			 "st %%i1, %1\n\t"
			 "ld [%%fp+68], %%i0\n\t"
			 "ld [%%fp+72], %%i1\n\t"
			 "ld [%%fp+76], %%i2\n\t"
			 : : "m"(nTableEntry), "m"(pCallStack) );

	sal_Bool bComplex = nTableEntry & 0x80000000 ? sal_True : sal_False;

	typelib_TypeClass aType =
		cpp_mediate( nFunctionIndex, nVtableOffset, pCallStack,  (sal_Int64*)&nRegReturn );
    OSL_ASSERT( sizeof(void *) == sizeof(sal_Int32) );
	switch( aType )
	{
	// move return value into register space
	// (will be loaded by machine code snippet)
        // Use pCallStack[1/2] instead of pCallStack[0/1], because the former is
        // properly dword aligned:
		case typelib_TypeClass_BOOLEAN:
		case typelib_TypeClass_BYTE:
			pCallStack[1] = (void*)*(char*)&nRegReturn;
					 "ldsb [%%l0], %%i0\n"
					 : : "m"(&nRegReturn) );
			break;
		case typelib_TypeClass_CHAR:
		case typelib_TypeClass_SHORT:
		case typelib_TypeClass_UNSIGNED_SHORT:
			pCallStack[1] = (void*)*(short*)&nRegReturn;
					 "ldsh [%%l0], %%i0\n"
					 : : "m"(&nRegReturn) );
			break;
		case typelib_TypeClass_DOUBLE:
		case typelib_TypeClass_HYPER:
		case typelib_TypeClass_UNSIGNED_HYPER:
                        // move long to %i1
			pCallStack[2] = ((void **)&nRegReturn)[ 1 ];
					 "ld [%%l0], %%i0\n\t"
					 "ld %1, %%l0\n\t"
					 "ld [%%l0], %%i1\n\t"
					 : : "m"(&nRegReturn), "m"(((long*)&nRegReturn) +1) );

			break;
		case typelib_TypeClass_FLOAT:
			__asm__( "ld %0, %%l0\n\t"
					 "ld [%%l0], %%f0\n"
					 : : "m"(&nRegReturn) );
			break;
		case typelib_TypeClass_DOUBLE:
			__asm__( "ld %0, %%l0\n\t"
					 "ldd [%%l0], %%f0\n"
					 : : "m"(&nRegReturn) );
			break;
		case typelib_TypeClass_VOID:
			break;
		default:
			// move long to %i0
			pCallStack[1] = ((void **)&nRegReturn)[ 0 ];
					 : : "m"(&nRegReturn) );
			break;
	}
	return aType;
	if( bComplex )
	{
		__asm__( "add %i7, 4, %i7\n\t" );
		// after call to complex return valued funcion there is an unimp instruction
	}

}
//__________________________________________________________________________________________________

int const codeSnippetSize = 56;
{
	// get all member functions
	list< sal_Bool > aComplexReturn;

	for( int n = 0; n < pType->nAllMembers; n++ )
	{
		typelib_TypeDescription* pMember = NULL;
		TYPELIB_DANGER_GET( &pMember, pType->ppAllMembers[n] );
		if( pMember->eTypeClass == typelib_TypeClass_INTERFACE_ATTRIBUTE )
		{
			typelib_TypeDescription * pRetTD = 0;
			TYPELIB_DANGER_GET( &pRetTD, ((typelib_InterfaceAttributeTypeDescription *)pMember)->pAttributeTypeRef );
			// get method
			aComplexReturn.push_back( !cppu_isSimpleType( pRetTD ) );
			// set method
			if( ! ((typelib_InterfaceAttributeTypeDescription*)pMember)->bReadOnly )
				aComplexReturn.push_back( sal_False );
			TYPELIB_DANGER_RELEASE( pRetTD );
		}
		else
		{
			typelib_TypeDescription * pRetTD = 0;
			TYPELIB_DANGER_GET( &pRetTD, ((typelib_InterfaceMethodTypeDescription *)pMember)->pReturnTypeRef );
			aComplexReturn.push_back( !cppu_isSimpleType( pRetTD ) );
			TYPELIB_DANGER_RELEASE( pRetTD );
		}
		TYPELIB_DANGER_RELEASE( pMember );
	}

unsigned char * codeSnippet(
    unsigned char * code, sal_Int32 functionIndex, sal_Int32 vtableOffset,
    bool simpleRetType)
{

	sal_uInt32 index = functionIndex;
	if (!simpleRetType) {
        index |= 0x80000000;
    }
    unsigned int * p = reinterpret_cast< unsigned int * >(code);
    OSL_ASSERT(sizeof (unsigned int) == 4);
    // st %o0, [%sp+68]:
    *p++ = 0xD023A044;
    // st %o1, [%sp+72]:
    *p++ = 0xD223A048;
    // st %o2, [%sp+76]:
    *p++ = 0xD423A04C;
    // st %o3, [%sp+80]:
    *p++ = 0xD623A050;
    // st %o4, [%sp+84]:
    *p++ = 0xD823A054;
    // st %o5, [%sp+88]:
    *p++ = 0xDA23A058;
    // sethi %hi(index), %o0:
    *p++ = 0x11000000 | (index >> 10);
    // or %o0, %lo(index), %o0:
    *p++ = 0x90122000 | (index & 0x3FF);
    // sethi %hi(vtableOffset), %o2:
    *p++ = 0x15000000 | (vtableOffset >> 10);
    // or %o2, %lo(vtableOffset), %o2:
    *p++ = 0x9412A000 | (vtableOffset & 0x3FF);
    // sethi %hi(cpp_vtable_call), %o3:
    *p++ = 0x17000000 | (reinterpret_cast< unsigned int >(cpp_vtable_call) >> 10);
    // or %o3, %lo(cpp_vtable_call), %o3:
    *p++ = 0x9612E000 | (reinterpret_cast< unsigned int >(cpp_vtable_call) & 0x3FF);
    // jmpl %o3, %g0:
    *p++ = 0x81C2C000;
    // mov %sp, %o1:
    *p++ = 0x9210000E;
    OSL_ASSERT(
        reinterpret_cast< unsigned char * >(p) - code <= codeSnippetSize);
    return code + codeSnippetSize;
}

}

void ** bridges::cpp_uno::shared::VtableFactory::mapBlockToVtable(char * block)
{
    return reinterpret_cast< void ** >(block) + 1;
}

char * bridges::cpp_uno::shared::VtableFactory::createBlock(
    sal_Int32 slotCount, void *** slots)
{
    char * block = new char[
        (slotCount + 3) * sizeof (void *) + slotCount * codeSnippetSize];
    *slots = mapBlockToVtable(block) + 2;
     (*slots)[-3] = 0; //RTTI
     (*slots)[-2] = 0; //null
     (*slots)[-1] = 0; //destructor
    return block;
}

unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
    void ** slots, unsigned char * code,
    typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
    sal_Int32 functionCount, sal_Int32 vtableOffset)
{
    for (sal_Int32 i = 0; i < type->nMembers; ++i) {
        typelib_TypeDescription * member = 0;
        TYPELIB_DANGER_GET(&member, type->ppMembers[i]);
        OSL_ASSERT(member != 0);
        switch (member->eTypeClass) {
        case typelib_TypeClass_INTERFACE_ATTRIBUTE:
            // Getter:
            *slots++ = code;
            code = codeSnippet(
                code, functionOffset++, vtableOffset,
                bridges::cpp_uno::shared::isSimpleType(
                    reinterpret_cast<
		    typelib_InterfaceAttributeTypeDescription * >(
		    member)->pAttributeTypeRef));
            // Setter:
            if (!reinterpret_cast<
                typelib_InterfaceAttributeTypeDescription * >(
                    member)->bReadOnly)
            {
                *slots++ = code;
                code = codeSnippet(code, functionOffset++, vtableOffset, true);
            }
            break;

        case typelib_TypeClass_INTERFACE_METHOD:
            *slots++ = code;
            code = codeSnippet(
                code, functionOffset++, vtableOffset,
                bridges::cpp_uno::shared::isSimpleType(
                    reinterpret_cast<
                    typelib_InterfaceMethodTypeDescription * >(
                        member)->pReturnTypeRef));
            break;

        default:
            OSL_ASSERT(false);
            break;
        }
        TYPELIB_DANGER_RELEASE(member);
    }
    return code;
}

void bridges::cpp_uno::shared::VtableFactory::flushCode(
	   unsigned char const *, unsigned char const *)
  	{
        //TODO: IZ 25819  flush the instruction cache (there probably is OS support for this)
	}
	*(const void **)pCppI = s_pMediateClassData->getClassData( pTypeDescr )->m_pVTable;
}

}

//##################################################################################################
extern "C" SAL_DLLEXPORT sal_Bool SAL_CALL component_canUnload( TimeValue * pTime )
	SAL_THROW_EXTERN_C()
{
	return CPPU_CURRENT_NAMESPACE::g_moduleCount.canUnload( &CPPU_CURRENT_NAMESPACE::g_moduleCount, pTime );
}
//##################################################################################################
extern "C" SAL_DLLEXPORT void SAL_CALL uno_initEnvironment( uno_Environment * pCppEnv )
	SAL_THROW_EXTERN_C()
{
	CPPU_CURRENT_NAMESPACE::cppu_cppenv_initEnvironment( pCppEnv );
}
//##################################################################################################
extern "C" SAL_DLLEXPORT void SAL_CALL uno_ext_getMapping(
	uno_Mapping ** ppMapping, uno_Environment * pFrom, uno_Environment * pTo )
	SAL_THROW_EXTERN_C()
{
	CPPU_CURRENT_NAMESPACE::cppu_ext_getMapping( ppMapping, pFrom, pTo );
}


Lines 1-6 Link Here

(-)./CVS/Entries (-5 / +5 lines)
1	/except.cxx/1.2/Mon Apr 28 16:28:48 2003//Tcws_srx645_ooo112fix1	1	/cpp2uno.cxx/1.4/Wed Apr 21 13:40:45 2004//TSRC680_m36
2	/makefile.mk/1.2/Mon Apr 28 16:28:55 2003//Tcws_srx645_ooo112fix1	2	/except.cxx/1.3/Wed Apr 21 13:41:00 2004//TSRC680_m36
3	/share.hxx/1.2/Mon Apr 28 16:29:01 2003//Tcws_srx645_ooo112fix1	3	/makefile.mk/1.3/Wed Apr 21 13:41:21 2004//TSRC680_m36
4	/cpp2uno.cxx/1.2.64.1/Fri Apr 9 04:22:38 2004//Tcws_srx645_ooo112fix1	4	/share.hxx/1.3/Wed Apr 21 13:41:36 2004//TSRC680_m36
5	/uno2cpp.cxx/1.2.34.1.26.1/Fri Apr 9 04:22:38 2004//Tcws_srx645_ooo112fix1	5	/uno2cpp.cxx/1.4/Wed Apr 21 13:41:51 2004//TSRC680_m36
6	D	6	D

Line 1 Link Here

(-)./CVS/Tag (-1 / +1 lines)
1	Tcws_srx645_ooo112fix1	1	NSRC680_m36




 *
 *  $RCSfile: except.cxx,v $
 *
 *  $Revision: 1.3 $
 *
 *  last change: $Author: svesik $ $Date: 2004/04/21 13:41:00 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses

 *
 *
 ************************************************************************/

#include <stdio.h>
#include <dlfcn.h>
#include <cxxabi.h>

#include <osl/diagnose.h>
#include <osl/mutex.hxx>

#include <com/sun/star/uno/genfunc.hxx>
#include <typelib/typedescription.hxx>
#include <uno/any2.h>





#
#   $RCSfile: makefile.mk,v $
#
#   $Revision: 1.3 $
#
#   last change: $Author: svesik $ $Date: 2004/04/21 13:41:21 $
#
#   The Contents of this file are made available subject to the terms of
#   either of the following licenses

#
#
#*************************************************************************

PRJ=..$/..$/..

PRJNAME=bridges


.IF "$(COM)$(OS)$(CPU)" == "GCCLINUXS"

.IF "$(cppu_no_leak)" == ""
CFLAGS += -DLEAK_STATIC_DATA
.ENDIF

CFLAGSNOOPT=-O0

NOOPTFILES = \
	$(SLO)$/uno2cpp.obj	\
	$(SLO)$/cpp2uno.obj

	$(SLO)$/cpp2uno.obj		\
	$(SLO)$/uno2cpp.obj

SHL1TARGET= $(TARGET)

SHL1TARGET=$(TARGET)

SHL1DEF=$(MISC)$/$(SHL1TARGET).def
SHL1IMPLIB=i$(TARGET)
SHL1VERSIONMAP=..$/..$/bridge_exports.map

SHL1OBJS= $(SLOFILES)
SHL1LIBS =$(SLB)$/cpp_uno_shared.lib
	$(SLO)$/cpp2uno.obj		\
	$(SLO)$/uno2cpp.obj

SHL1STDLIBS= \
	$(CPPULIB) \




 *
 *  $RCSfile: share.hxx,v $
 *
 *  $Revision: 1.3 $
 *
 *  last change: $Author: svesik $ $Date: 2004/04/21 13:41:36 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses

 *
 *
 ************************************************************************/
#include "uno/mapping.h"
#include <typeinfo>
#include <exception>
#include <cstddef>

namespace CPPU_CURRENT_NAMESPACE
{
void dummy_can_throw_anything( char const * );
// ----- following decl from libstdc++-v3/libsupc++/unwind-cxx.h and unwind.h

struct _Unwind_Exception




 *
 *  $RCSfile: uno2cpp.cxx,v $
 *
 *  $Revision: 1.4 $
 *
 *  last change: $Author: svesik $ $Date: 2004/04/21 13:41:51 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses

 *
 *
 ************************************************************************/

#include <malloc.h>
#include <com/sun/star/uno/genfunc.hxx>
#include <rtl/alloc.h>
#endif

#ifndef _UNO_DATA_H_
#include <uno/data.h>
#endif

#include "bridges/cpp_uno/shared/bridge.hxx"
#include "bridges/cpp_uno/shared/types.hxx"
#include "bridges/cpp_uno/shared/unointerfaceproxy.hxx"
#include "bridges/cpp_uno/shared/vtables.hxx"
#endif

#include "share.hxx"

using namespace rtl;
using namespace com::sun::star::uno;

namespace
{

void dummy_can_throw_anything( char const * );

//==================================================================================================
static void callVirtualMethod( void * pAdjustedThisPtr,
									  sal_Int32 nVtableIndex,
									  void * pRegisterReturn,
									  typelib_TypeClass eReturnType,

	// parameter list is mixed list of * and values
	// reference parameters are pointers

	OSL_ENSURE( pStackLongs && pAdjustedThisPtr, "### null ptr!" );
	OSL_ENSURE( (sizeof(void *) == 4) &&
				 (sizeof(sal_Int32) == 4), "### unexpected size of int!" );
	OSL_ENSURE( nStackLongs && pStackLongs, "### no stack in callVirtualMethod !" );

    // never called
    if (! pAdjustedThisPtr) CPPU_CURRENT_NAMESPACE::dummy_can_throw_anything("xxx"); // address something

	volatile long o0 = 0, o1 = 0; // for register returns
	volatile double f0d = 0;

		"ld [%%i0], %%l0\n\t"		// get vtable ptr

"sll %%i1, 2, %%l6\n\t"
//         "add %%l6, 8, %%l6\n\t"
		"add %%l6, %%l0, %%l0\n\t"
// 		// vtable has 8byte wide entries,
// 		// upper half contains 2 half words, of which the first

	}
}


//==================================================================================================
static void cpp_call(
	bridges::cpp_uno::shared::UnoInterfaceProxy * pThis,
	bridges::cpp_uno::shared::VtableSlot aVtableSlot,
	typelib_TypeDescriptionReference * pReturnTypeRef,
	sal_Int32 nParams, typelib_MethodParameter * pParams,
	void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
{
  	// max space for: complex ret ptr, this, values|ptr ...
  	char * pCppStack	= (char *)alloca( (nParams+3) * sizeof(sal_Int64) );
  		(char *)alloca( (nParams+2) * sizeof(sal_Int64) );
  	char * pCppStackStart	= pCppStack;

	// return
	typelib_TypeDescription * pReturnTypeDescr = 0;
	TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );

	
	if (pReturnTypeDescr)
	{
		if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
		{
			pCppReturn = pUnoReturn; // direct way for simple types
			*(void**)pCppStack = NULL;
		}
		else
		{
			// complex return via ptr
			pCppReturn = *(void **)pCppStack
			= (bridges::cpp_uno::shared::relatesToInterfaceType(
			 pReturnTypeDescr )
			? alloca( pReturnTypeDescr->nSize )
			: pUnoReturn); // direct way
		}
		pCppStack += sizeof(void*);
	}
	// push this
	void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI())
  	       + aVtableSlot.offset;
  	       *(void**)pCppStack = pAdjustedThisPtr;
	pCppStack += sizeof( void* );

	// stack space

		const typelib_MethodParameter & rParam = pParams[nPos];
		typelib_TypeDescription * pParamTypeDescr = 0;
		TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
		if (!rParam.bOut
  	           && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
		{
			pCppArgs[ nPos ] = CPPU_CURRENT_NAMESPACE::adjustPointer(
				pCppStack, pParamTypeDescr );
			uno_copyAndConvertData( pCppArgs[nPos], pUnoArgs[nPos], pParamTypeDescr,
									pThis->getBridge()->getUno2Cpp() );

			switch (pParamTypeDescr->eTypeClass)
			{
			case typelib_TypeClass_HYPER:
			case typelib_TypeClass_UNSIGNED_HYPER:
			case typelib_TypeClass_DOUBLE:

                          OSL_ASSERT( sizeof (double) == sizeof (sal_Int64) );
                          *reinterpret_cast< sal_Int32 * >(pCppStack) =
                          *reinterpret_cast< sal_Int32 const * >(pUnoArgs[ nPos ]);
                          pCppStack += sizeof (sal_Int32);

            		default:
                          uno_copyAndConvertData(
                             pCppArgs[nPos], pUnoArgs[nPos], pParamTypeDescr,
                            pThis->getBridge()->getUno2Cpp() );
                          break;
                        }
			// no longer needed

				ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
			}
			// is in/inout
			else if (bridges::cpp_uno::shared::relatesToInterfaceType(
  	                        pParamTypeDescr ))
			{
				uno_copyAndConvertData(
					*(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                pUnoArgs[nPos], pParamTypeDescr,
  	                   pThis->getBridge()->getUno2Cpp() );

				pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
				// will be released at reconversion
				ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;


	try
	{
		int nStackLongs = (pCppStack - pCppStackStart)/sizeof(sal_Int32);
		OSL_ENSURE( !( (pCppStack - pCppStackStart ) & 3), "UNALIGNED STACK !!! (Please DO panic" );
		int nStackLongs = (pCppStack - pCppStackStart)/sizeof(sal_Int32);
		if( nStackLongs & 1 )
			// stack has to be 8 byte aligned
			nStackLongs++;
		callVirtualMethod(
			pAdjustedThisPtr,
			aVtableSlot.index,
			pCppReturn,
			pReturnTypeDescr->eTypeClass,
			(sal_Int32 *)pCppStackStart,
			nStackLongs);
		// NO exception occured...
		*ppUnoExc = 0;

		// reconvert temporary params
		for ( ; nTempIndizes--; )
		{

				{
					uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
					uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
											pThis->getBridge()->getCpp2Uno() );
				}
			}
			else // pure out
			{
				uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
										pThis->getBridge()->getCpp2Uno() );
			}
			// destroy temp cpp param => cpp: every param was constructed
			uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );

		if (pCppReturn && pUnoReturn != pCppReturn)
		{
			uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
									pThis->getBridge()->getCpp2Uno() );
			uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
		}
	}
 	catch( ... )
 	{
                printf("uno2cpp catch got exception!!!\n"); // why is the following __cxa ???
		// get exception
		   fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );

		// temporary params
		for ( ; nTempIndizes--; )
		{

	}
}

}

//==================================================================================================
void bridges::cpp_uno::shared::UnoInterfaceProxy::dispatch(
	uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
void * pReturn, void * pArgs[], uno_Any ** ppException ) SAL_THROW(())
{
#if defined BRIDGES_DEBUG
    OString cstr( OUStringToOString( pMemberDescr->pTypeName, RTL_TEXTENCODING_ASCII_US ) );

#endif
    
	// is my surrogate
	bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
       = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
	typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;

	switch (pMemberDescr->eTypeClass)
	{
	case typelib_TypeClass_INTERFACE_ATTRIBUTE:
	{
	 VtableSlot aVtableSlot(
  	           getVtableSlot(
  	               reinterpret_cast<
  	                   typelib_InterfaceAttributeTypeDescription const * >(
  	                       pMemberDescr)));
		OSL_ENSURE( nVtableCall < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
		
		if (pReturn)
		{
			// dependent dispatch
			cpp_call(
				pThis, aVtableSlot,
				((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
				0, 0, // no params
				pReturn, pArgs, ppException );

				&pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
			
			// dependent dispatch
			aVtableSlot.index += 1; // get, then set method
			cpp_call(
				pThis, aVtableSlot,
				pReturnTypeRef,
				1, &aParam,
				pReturn, pArgs, ppException );

			typelib_typedescriptionreference_release( pReturnTypeRef );
		}
		

	}
	case typelib_TypeClass_INTERFACE_METHOD:
	{
		VtableSlot aVtableSlot(
		getVtableSlot(
		 reinterpret_cast<
		  typelib_InterfaceMethodTypeDescription const * >(
		  pMemberDescr)));
		switch (aVtableSlot.index)
		
		switch (nVtableCall)
		{
			// standard calls
		case 1: // acquire uno interface

			if (pTD)
			{
                uno_Interface * pInterface = 0;
 		(*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(
 		  pThis->pBridge->getUnoEnv(),
				   (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
			
                if (pInterface)
                {

		default:
			// dependent dispatch
			cpp_call(
				pThis, aVtableSlot,
				((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
				((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
				((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,

	}
}

}


Return to issue 28110

Lines 2-10 Link Here

(-)./except.cxx (-4 / +3 lines)
2	*	2	*
3	* $RCSfile: except.cxx,v $	3	* $RCSfile: except.cxx,v $
4	*	4	*
5	* $Revision: 1.2 $	5	* $Revision: 1.3 $
6	*	6	*
7	* last change: $Author: hr $ $Date: 2003/04/28 16:28:48 $	7	* last change: $Author: svesik $ $Date: 2004/04/21 13:41:00 $
8	*	8	*
9	* The Contents of this file are made available subject to the terms of	9	* The Contents of this file are made available subject to the terms of
10	* either of the following licenses	10	* either of the following licenses
Lines 58-64 Link Here
58	*	58	*
59	*	59	*
60	************************************************************************/	60	************************************************************************/
61
62	#include <stdio.h>	61	#include <stdio.h>
63	#include <dlfcn.h>	62	#include <dlfcn.h>
64	#include <cxxabi.h>	63	#include <cxxabi.h>
Lines 69-75 Link Here
69	#include <osl/diagnose.h>	68	#include <osl/diagnose.h>
70	#include <osl/mutex.hxx>	69	#include <osl/mutex.hxx>
71		70
72	#include <bridges/cpp_uno/bridge.hxx>	71	#include <com/sun/star/uno/genfunc.hxx>
73	#include <typelib/typedescription.hxx>	72	#include <typelib/typedescription.hxx>
74	#include <uno/any2.h>	73	#include <uno/any2.h>
75		74

Lines 2-10 Link Here

(-)./makefile.mk (-12 / +11 lines)
2	#	2	#
3	# $RCSfile: makefile.mk,v $	3	# $RCSfile: makefile.mk,v $
4	#	4	#
5	# $Revision: 1.2 $	5	# $Revision: 1.3 $
6	#	6	#
7	# last change: $Author: hr $ $Date: 2003/04/28 16:28:55 $	7	# last change: $Author: svesik $ $Date: 2004/04/21 13:41:21 $
8	#	8	#
9	# The Contents of this file are made available subject to the terms of	9	# The Contents of this file are made available subject to the terms of
10	# either of the following licenses	10	# either of the following licenses
Lines 59-65 Link Here
59	#	59	#
60	#	60	#
61	#*************************************************************************	61	#*************************************************************************
62
63	PRJ=..$/..$/..	62	PRJ=..$/..$/..
64		63
65	PRJNAME=bridges	64	PRJNAME=bridges
Lines 78-88 Link Here
78		77
79	.IF "$(COM)$(OS)$(CPU)" == "GCCLINUXS"	78	.IF "$(COM)$(OS)$(CPU)" == "GCCLINUXS"
80		79
81	.IF "$(bridges_debug)" != ""	80	.IF "$(cppu_no_leak)" == ""
82	CFLAGS += -DBRIDGES_DEBUG	81	CFLAGS += -DLEAK_STATIC_DATA
83	.ENDIF	82	.ENDIF
84		83
85	CFLAGSNOOPT=-O0	84	CFLAGSNOOPT=-O0
		85
86	NOOPTFILES = \	86	NOOPTFILES = \
87	$(SLO)$/uno2cpp.obj \	87	$(SLO)$/uno2cpp.obj \
88	$(SLO)$/cpp2uno.obj	88	$(SLO)$/cpp2uno.obj
Lines 92-107 Link Here
92	$(SLO)$/cpp2uno.obj \	92	$(SLO)$/cpp2uno.obj \
93	$(SLO)$/uno2cpp.obj	93	$(SLO)$/uno2cpp.obj
94		94
95	SHL1TARGET= $(TARGET)
96		95
97	SHL1DEF= $(MISC)$/$(SHL1TARGET).def	96	SHL1TARGET=$(TARGET)
98	SHL1IMPLIB= i$(TARGET)	97
		98	SHL1DEF=$(MISC)$/$(SHL1TARGET).def
		99	SHL1IMPLIB=i$(TARGET)
99	SHL1VERSIONMAP=..$/..$/bridge_exports.map	100	SHL1VERSIONMAP=..$/..$/bridge_exports.map
100		101
101	SHL1OBJS= \	102	SHL1OBJS= $(SLOFILES)
102	$(SLO)$/except.obj \	103	SHL1LIBS =$(SLB)$/cpp_uno_shared.lib
103	$(SLO)$/cpp2uno.obj \
104	$(SLO)$/uno2cpp.obj
105		104
106	SHL1STDLIBS= \	105	SHL1STDLIBS= \
107	$(CPPULIB) \	106	$(CPPULIB) \

Lines 2-10 Link Here

(-)./share.hxx (-5 / +4 lines)
2	*	2	*
3	* $RCSfile: share.hxx,v $	3	* $RCSfile: share.hxx,v $
4	*	4	*
5	* $Revision: 1.2 $	5	* $Revision: 1.3 $
6	*	6	*
7	* last change: $Author: hr $ $Date: 2003/04/28 16:29:01 $	7	* last change: $Author: svesik $ $Date: 2004/04/21 13:41:36 $
8	*	8	*
9	* The Contents of this file are made available subject to the terms of	9	* The Contents of this file are made available subject to the terms of
10	* either of the following licenses	10	* either of the following licenses
Lines 58-71 Link Here
58	*	58	*
59	*	59	*
60	************************************************************************/	60	************************************************************************/
61		61	#include "uno/mapping.h"
62	#include <typeinfo>	62	#include <typeinfo>
63	#include <exception>	63	#include <exception>
64	#include <cstddef>	64	#include <cstddef>
65
66	namespace CPPU_CURRENT_NAMESPACE	65	namespace CPPU_CURRENT_NAMESPACE
67	{	66	{
68		67	void dummy_can_throw_anything( char const * );
69	// ----- following decl from libstdc++-v3/libsupc++/unwind-cxx.h and unwind.h	68	// ----- following decl from libstdc++-v3/libsupc++/unwind-cxx.h and unwind.h
70		69
71	struct _Unwind_Exception	70	struct _Unwind_Exception

Lines 2-10 Link Here

(-)./uno2cpp.cxx (-81 / +83 lines)
2	*	2	*
3	* $RCSfile: uno2cpp.cxx,v $	3	* $RCSfile: uno2cpp.cxx,v $
4	*	4	*
5	* $Revision: 1.2.34.1.26.1 $	5	* $Revision: 1.4 $
6	*	6	*
7	* last change: $Author: sparcmoz $ $Date: 2004/04/09 04:22:38 $	7	* last change: $Author: svesik $ $Date: 2004/04/21 13:41:51 $
8	*	8	*
9	* The Contents of this file are made available subject to the terms of	9	* The Contents of this file are made available subject to the terms of
10	* either of the following licenses	10	* either of the following licenses
Lines 58-91 Link Here
58	*	58	*
59	*	59	*
60	************************************************************************/	60	************************************************************************/
61
62	#include <malloc.h>	61	#include <malloc.h>
63	#ifndef _RTL_ALLOC_H_	62	#include <com/sun/star/uno/genfunc.hxx>
64	#include <rtl/alloc.h>
65	#endif
66
67	#ifndef _UNO_DATA_H_	63	#ifndef _UNO_DATA_H_
68	#include <uno/data.h>	64	#include <uno/data.h>
69	#endif	65	#endif
70	#ifndef _BRIDGES_CPP_UNO_BRIDGE_HXX_	66
71	#include <bridges/cpp_uno/bridge.hxx>	67	#include "bridges/cpp_uno/shared/bridge.hxx"
72	#endif	68	#include "bridges/cpp_uno/shared/types.hxx"
73	#ifndef _BRIDGES_CPP_UNO_TYPE_MISC_HXX_	69	#include "bridges/cpp_uno/shared/unointerfaceproxy.hxx"
74	#include <bridges/cpp_uno/type_misc.hxx>	70	#include "bridges/cpp_uno/shared/vtables.hxx"
75	#endif
76		71
77	#include "share.hxx"	72	#include "share.hxx"
78		73
79	using namespace rtl;	74	using namespace rtl;
80	using namespace com::sun::star::uno;	75	using namespace com::sun::star::uno;
81		76
82	namespace CPPU_CURRENT_NAMESPACE	77	namespace
83	{	78	{
84
85	void dummy_can_throw_anything( char const * );
86
87	//==================================================================================================	79	//==================================================================================================
88	static void callVirtualMethod( void * pThis,	80	static void callVirtualMethod( void * pAdjustedThisPtr,
89	sal_Int32 nVtableIndex,	81	sal_Int32 nVtableIndex,
90	void * pRegisterReturn,	82	void * pRegisterReturn,
91	typelib_TypeClass eReturnType,	83	typelib_TypeClass eReturnType,
Lines 95-107 Link Here
95	// parameter list is mixed list of * and values	87	// parameter list is mixed list of * and values
96	// reference parameters are pointers	88	// reference parameters are pointers
97		89
98	OSL_ENSURE( pStackLongs && pThis, "### null ptr!" );	90	OSL_ENSURE( pStackLongs && pAdjustedThisPtr, "### null ptr!" );
99	OSL_ENSURE( (sizeof(void *) == 4) &&	91	OSL_ENSURE( (sizeof(void *) == 4) &&
100	(sizeof(sal_Int32) == 4), "### unexpected size of int!" );	92	(sizeof(sal_Int32) == 4), "### unexpected size of int!" );
101	OSL_ENSURE( nStackLongs && pStackLongs, "### no stack in callVirtualMethod !" );	93	OSL_ENSURE( nStackLongs && pStackLongs, "### no stack in callVirtualMethod !" );
102		94
103	// never called	95	// never called
104	if (! pThis) dummy_can_throw_anything("xxx"); // address something	96	if (! pAdjustedThisPtr) CPPU_CURRENT_NAMESPACE::dummy_can_throw_anything("xxx"); // address something
105		97
106	volatile long o0 = 0, o1 = 0; // for register returns	98	volatile long o0 = 0, o1 = 0; // for register returns
107	volatile double f0d = 0;	99	volatile double f0d = 0;
Lines 217-223 Link Here
217	"ld [%%i0], %%l0\n\t" // get vtable ptr	209	"ld [%%i0], %%l0\n\t" // get vtable ptr
218		210
219	"sll %%i1, 2, %%l6\n\t"	211	"sll %%i1, 2, %%l6\n\t"
220	// "add %%l6, 8, %%l6\n\t"	212	// "add %%l6, 8, %%l6\n\t"
221	"add %%l6, %%l0, %%l0\n\t"	213	"add %%l6, %%l0, %%l0\n\t"
222	// // vtable has 8byte wide entries,	214	// // vtable has 8byte wide entries,
223	// // upper half contains 2 half words, of which the first	215	// // upper half contains 2 half words, of which the first
Lines 299-317 Link Here
299	}	291	}
300	}	292	}
301		293
302	//==================================================================================================	294
		295	//==================================================================================================
303	static void cpp_call(	296	static void cpp_call(
304	cppu_unoInterfaceProxy * pThis,	297	bridges::cpp_uno::shared::UnoInterfaceProxy * pThis,
305	sal_Int32 nVtableCall,	298	bridges::cpp_uno::shared::VtableSlot aVtableSlot,
306	typelib_TypeDescriptionReference * pReturnTypeRef,	299	typelib_TypeDescriptionReference * pReturnTypeRef,
307	sal_Int32 nParams, typelib_MethodParameter * pParams,	300	sal_Int32 nParams, typelib_MethodParameter * pParams,
308	void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )	301	void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
309	{	302	{
310	// max space for: complex ret ptr, this, values\|ptr ...	303	// max space for: complex ret ptr, this, values\|ptr ...
311	char * pCppStack =	304	char * pCppStack = (char )alloca( (nParams+3) sizeof(sal_Int64) );
312	(char )alloca( (nParams+2) sizeof(sal_Int64) );
313	char * pCppStackStart = pCppStack;	305	char * pCppStackStart = pCppStack;
314		306
315	// return	307	// return
316	typelib_TypeDescription * pReturnTypeDescr = 0;	308	typelib_TypeDescription * pReturnTypeDescr = 0;
317	TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );	309	TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
Lines 321-342 Link Here
321		313
322	if (pReturnTypeDescr)	314	if (pReturnTypeDescr)
323	{	315	{
324	if (cppu_isSimpleType( pReturnTypeDescr ))	316	if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
325	{	317	{
326	pCppReturn = pUnoReturn; // direct way for simple types	318	pCppReturn = pUnoReturn; // direct way for simple types
327	(void*)pCppStack = NULL;
328	}	319	}
329	else	320	else
330	{	321	{
331	// complex return via ptr	322	// complex return via ptr
332	pCppReturn = (void *)pCppStack = (cppu_relatesToInterface( pReturnTypeDescr )	323	pCppReturn = (void *)pCppStack
333	? alloca( pReturnTypeDescr->nSize )	324	= (bridges::cpp_uno::shared::relatesToInterfaceType(
334	: pUnoReturn); // direct way	325	pReturnTypeDescr )
		326	? alloca( pReturnTypeDescr->nSize )
		327	: pUnoReturn); // direct way
335	}	328	}
336	pCppStack += sizeof(void*);	329	pCppStack += sizeof(void*);
337	}	330	}
338	// push this	331	// push this
339	(void*)pCppStack = pThis->pCppI;	332	void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI())
		333	+ aVtableSlot.offset;
		334	(void*)pCppStack = pAdjustedThisPtr;
340	pCppStack += sizeof( void* );	335	pCppStack += sizeof( void* );
341		336
342	// stack space	337	// stack space
Lines 355-370 Link Here
355	const typelib_MethodParameter & rParam = pParams[nPos];	350	const typelib_MethodParameter & rParam = pParams[nPos];
356	typelib_TypeDescription * pParamTypeDescr = 0;	351	typelib_TypeDescription * pParamTypeDescr = 0;
357	TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );	352	TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
358		353	if (!rParam.bOut
359	if (!rParam.bOut && cppu_isSimpleType( pParamTypeDescr ))	354	&& bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
360	{	355	{
361	pCppArgs[ nPos ] = adjustPointer( pCppStack, pParamTypeDescr );	356	pCppArgs[ nPos ] = CPPU_CURRENT_NAMESPACE::adjustPointer(
		357	pCppStack, pParamTypeDescr );
		358	uno_copyAndConvertData( pCppArgs[nPos], pUnoArgs[nPos], pParamTypeDescr,
		359	pThis->getBridge()->getUno2Cpp() );
		360
362	switch (pParamTypeDescr->eTypeClass)	361	switch (pParamTypeDescr->eTypeClass)
363	{	362	{
364	case typelib_TypeClass_HYPER:	363	case typelib_TypeClass_HYPER:
365	case typelib_TypeClass_UNSIGNED_HYPER:	364	case typelib_TypeClass_UNSIGNED_HYPER:
366	case typelib_TypeClass_DOUBLE:	365	case typelib_TypeClass_DOUBLE:
367	OSL_ASSERT( sizeof (double) == sizeof (sal_Int64) );	366
		367	OSL_ASSERT( sizeof (double) == sizeof (sal_Int64) );
368	reinterpret_cast< sal_Int32 >(pCppStack) =	368	reinterpret_cast< sal_Int32 >(pCppStack) =
369	reinterpret_cast< sal_Int32 const >(pUnoArgs[ nPos ]);	369	reinterpret_cast< sal_Int32 const >(pUnoArgs[ nPos ]);
370	pCppStack += sizeof (sal_Int32);	370	pCppStack += sizeof (sal_Int32);
Lines 374-380 Link Here
374	default:	374	default:
375	uno_copyAndConvertData(	375	uno_copyAndConvertData(
376	pCppArgs[nPos], pUnoArgs[nPos], pParamTypeDescr,	376	pCppArgs[nPos], pUnoArgs[nPos], pParamTypeDescr,
377	&pThis->pBridge->aUno2Cpp );	377	pThis->getBridge()->getUno2Cpp() );
378	break;	378	break;
379	}	379	}
380	// no longer needed	380	// no longer needed
Lines 393-404 Link Here
393	ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;	393	ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
394	}	394	}
395	// is in/inout	395	// is in/inout
396	else if (cppu_relatesToInterface( pParamTypeDescr ))	396	else if (bridges::cpp_uno::shared::relatesToInterfaceType(
		397	pParamTypeDescr ))
397	{	398	{
398	uno_copyAndConvertData(	399	uno_copyAndConvertData(
399	(void *)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),	400	(void *)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
400	pUnoArgs[nPos], pParamTypeDescr, &pThis->pBridge->aUno2Cpp );	401	pUnoArgs[nPos], pParamTypeDescr,
401		402	pThis->getBridge()->getUno2Cpp() );
		403
402	pTempIndizes[nTempIndizes] = nPos; // has to be reconverted	404	pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
403	// will be released at reconversion	405	// will be released at reconversion
404	ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;	406	ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
Lines 415-432 Link Here
415		417
416	try	418	try
417	{	419	{
418	int nStackLongs = (pCppStack - pCppStackStart)/sizeof(sal_Int32);
419	OSL_ENSURE( !( (pCppStack - pCppStackStart ) & 3), "UNALIGNED STACK !!! (Please DO panic" );	420	OSL_ENSURE( !( (pCppStack - pCppStackStart ) & 3), "UNALIGNED STACK !!! (Please DO panic" );
		421	int nStackLongs = (pCppStack - pCppStackStart)/sizeof(sal_Int32);
		422	if( nStackLongs & 1 )
		423	// stack has to be 8 byte aligned
		424	nStackLongs++;
420	callVirtualMethod(	425	callVirtualMethod(
421	pThis->pCppI,	426	pAdjustedThisPtr,
422	nVtableCall,	427	aVtableSlot.index,
423	pCppReturn,	428	pCppReturn,
424	pReturnTypeDescr->eTypeClass,	429	pReturnTypeDescr->eTypeClass,
425	(sal_Int32 *)pCppStackStart,	430	(sal_Int32 *)pCppStackStart,
426	nStackLongs);	431	nStackLongs);
427	// NO exception occured...	432	// NO exception occured...
428	*ppUnoExc = 0;	433	*ppUnoExc = 0;
429		434
430	// reconvert temporary params	435	// reconvert temporary params
431	for ( ; nTempIndizes--; )	436	for ( ; nTempIndizes--; )
432	{	437	{
Lines 439-451 Link Here
439	{	444	{
440	uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value	445	uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
441	uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,	446	uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
442	&pThis->pBridge->aCpp2Uno );	447	pThis->getBridge()->getCpp2Uno() );
443	}	448	}
444	}	449	}
445	else // pure out	450	else // pure out
446	{	451	{
447	uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,	452	uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
448	&pThis->pBridge->aCpp2Uno );	453	pThis->getBridge()->getCpp2Uno() );
449	}	454	}
450	// destroy temp cpp param => cpp: every param was constructed	455	// destroy temp cpp param => cpp: every param was constructed
451	uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );	456	uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
Lines 456-471 Link Here
456	if (pCppReturn && pUnoReturn != pCppReturn)	461	if (pCppReturn && pUnoReturn != pCppReturn)
457	{	462	{
458	uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,	463	uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
459	&pThis->pBridge->aCpp2Uno );	464	pThis->getBridge()->getCpp2Uno() );
460	uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );	465	uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
461	}	466	}
462	}	467	}
463	catch( ... )	468	catch( ... )
464	{	469	{
465	// get exception	470	printf("uno2cpp catch got exception!!!\n"); // why is the following __cxa ???
466	fillUnoException(	471	// get exception
467	__cxa_get_globals()->caughtExceptions, *ppUnoExc, &pThis->pBridge->aCpp2Uno );	472	fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
468		473
469	// temporary params	474	// temporary params
470	for ( ; nTempIndizes--; )	475	for ( ; nTempIndizes--; )
471	{	476	{
Lines 480-490 Link Here
480	}	485	}
481	}	486	}
482		487
		488	}
483		489
484	//==================================================================================================	490	//==================================================================================================
485	void SAL_CALL cppu_unoInterfaceProxy_dispatch(	491	void bridges::cpp_uno::shared::UnoInterfaceProxy::dispatch(
486	uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,	492	uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
487	void * pReturn, void * pArgs[], uno_Any ** ppException ) throw ()	493	void * pReturn, void * pArgs[], uno_Any ** ppException ) SAL_THROW(())
488	{	494	{
489	#if defined BRIDGES_DEBUG	495	#if defined BRIDGES_DEBUG
490	OString cstr( OUStringToOString( pMemberDescr->pTypeName, RTL_TEXTENCODING_ASCII_US ) );	496	OString cstr( OUStringToOString( pMemberDescr->pTypeName, RTL_TEXTENCODING_ASCII_US ) );
Lines 492-516 Link Here
492	#endif	498	#endif
493		499
494	// is my surrogate	500	// is my surrogate
495	cppu_unoInterfaceProxy * pThis = (cppu_unoInterfaceProxy *)pUnoI;	501	bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
		502	= static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
496	typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;	503	typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;
497		504
498	switch (pMemberDescr->eTypeClass)	505	switch (pMemberDescr->eTypeClass)
499	{	506	{
500	case typelib_TypeClass_INTERFACE_ATTRIBUTE:	507	case typelib_TypeClass_INTERFACE_ATTRIBUTE:
501	{	508	{
502	// determine vtable call index	509	VtableSlot aVtableSlot(
503	sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;	510	getVtableSlot(
504	OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### member pos out of range!" );	511	reinterpret_cast<
505		512	typelib_InterfaceAttributeTypeDescription const * >(
506	sal_Int32 nVtableCall = pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos];	513	pMemberDescr)));
507	OSL_ENSURE( nVtableCall < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
508
509	if (pReturn)	514	if (pReturn)
510	{	515	{
511	// dependent dispatch	516	// dependent dispatch
512	cpp_call(	517	cpp_call(
513	pThis, nVtableCall,	518	pThis, aVtableSlot,
514	((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,	519	((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
515	0, 0, // no params	520	0, 0, // no params
516	pReturn, pArgs, ppException );	521	pReturn, pArgs, ppException );
Lines 530-541 Link Here
530	&pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );	535	&pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
531		536
532	// dependent dispatch	537	// dependent dispatch
		538	aVtableSlot.index += 1; // get, then set method
533	cpp_call(	539	cpp_call(
534	pThis, nVtableCall +1, // get, then set method	540	pThis, aVtableSlot,
535	pReturnTypeRef,	541	pReturnTypeRef,
536	1, &aParam,	542	1, &aParam,
537	pReturn, pArgs, ppException );	543	pReturn, pArgs, ppException );
538		544
539	typelib_typedescriptionreference_release( pReturnTypeRef );	545	typelib_typedescriptionreference_release( pReturnTypeRef );
540	}	546	}
541		547
Lines 543-556 Link Here
543	}	549	}
544	case typelib_TypeClass_INTERFACE_METHOD:	550	case typelib_TypeClass_INTERFACE_METHOD:
545	{	551	{
546	// determine vtable call index	552	VtableSlot aVtableSlot(
547	sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;	553	getVtableSlot(
548	OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### member pos out of range!" );	554	reinterpret_cast<
549		555	typelib_InterfaceMethodTypeDescription const * >(
550	sal_Int32 nVtableCall = pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos];	556	pMemberDescr)));
551	OSL_ENSURE( nVtableCall < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );	557	switch (aVtableSlot.index)
552
553	switch (nVtableCall)
554	{	558	{
555	// standard calls	559	// standard calls
556	case 1: // acquire uno interface	560	case 1: // acquire uno interface
Lines 568-576 Link Here
568	if (pTD)	572	if (pTD)
569	{	573	{
570	uno_Interface * pInterface = 0;	574	uno_Interface * pInterface = 0;
571	(*pThis->pBridge->pUnoEnv->getRegisteredInterface)(	575	(*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(
572	pThis->pBridge->pUnoEnv,	576	pThis->pBridge->getUnoEnv(),
573	(void *)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription )pTD );	577	(void *)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription )pTD );
574		578
575	if (pInterface)	579	if (pInterface)
576	{	580	{
Lines 588-594 Link Here
588	default:	592	default:
589	// dependent dispatch	593	// dependent dispatch
590	cpp_call(	594	cpp_call(
591	pThis, nVtableCall,	595	pThis, aVtableSlot,
592	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,	596	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
593	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,	597	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
594	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,	598	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
Lines 609-613 Link Here
609	}	613	}
610	}	614	}
611		615
612	}
613