Attachment #13597 for issue #24507

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

Lines 15-21 Link Here

(-)prj/build.lst (-1 / +1 lines)
15	br bridges\source\cpp_uno\gcc2_linux_powerpc nmake - u br_gcclp br_unotypes NULL	15	br bridges\source\cpp_uno\gcc2_linux_powerpc nmake - u br_gcclp br_unotypes NULL
16	br bridges\source\cpp_uno\gcc3_linux_powerpc nmake - u br_gcclp3 br_unotypes NULL	16	br bridges\source\cpp_uno\gcc3_linux_powerpc nmake - u br_gcclp3 br_unotypes NULL
17	br bridges\source\cpp_uno\gcc3_linux_s390 nmake - u br_gccl33 br_unotypes NULL	17	br bridges\source\cpp_uno\gcc3_linux_s390 nmake - u br_gccl33 br_unotypes NULL
18	br bridges\source\cpp_uno\gcc3_linux_sparc nmake - u br_gccl3s br_unotypes NULL	18	br bridges\source\cpp_uno\gcc3_linux_sparc nmake - u br_gccl3s br_unotypes br_cppuno_shared NULL
19	br bridges\source\cpp_uno\gcc2_macosx_powerpc nmake - u br_gccmacoxp br_unotypes NULL	19	br bridges\source\cpp_uno\gcc2_macosx_powerpc nmake - u br_gccmacoxp br_unotypes NULL
20	br bridges\source\cpp_uno\gcc3_macosx_powerpc nmake - u br_gcc3macoxp br_unotypes NULL	20	br bridges\source\cpp_uno\gcc3_macosx_powerpc nmake - u br_gcc3macoxp br_unotypes NULL
21	br bridges\source\cpp_uno\cc50_solaris_sparc nmake - u br_cc50sols br_unotypes br_cppuno_shared NULL	21	br bridges\source\cpp_uno\cc50_solaris_sparc nmake - u br_cc50sols br_unotypes br_cppuno_shared NULL




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

#define LEAK_STATIC_DATA
#define TRACE(x) OSL_TRACE(x)
#define TRACE(x)

#include <malloc.h>
#include <list>
#include <map>
#include <typeinfo>
#include <com/sun/star/uno/genfunc.hxx>
#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>
#endif
#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"
#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] = pUnoArgs[nPos] =
				CPPU_CURRENT_NAMESPACE::adjustPointer( pCppStack, pParamTypeDescr );
			switch (pParamTypeDescr->eTypeClass)
			{
			case typelib_TypeClass_HYPER:
			case typelib_TypeClass_UNSIGNED_HYPER:
            		case typelib_TypeClass_DOUBLE:
            		{
			if ((reinterpret_cast< long >(pCppStack) & 7) != 0)
              		{
		   		OSL_ASSERT( sizeof (double) == sizeof (sal_Int64) );
                   		void * pDest = alloca( sizeof (sal_Int64) );
                  	 	*reinterpret_cast< sal_Int32 * >(pDest) =
                   		*reinterpret_cast< sal_Int32 const * >(pCppStack);
                   		*(reinterpret_cast< sal_Int32 * >(pDest) + 1) =
                   		*(reinterpret_cast< sal_Int32 const * >(pCppStack) + 1);
                   		pCppArgs[nPos] = pUnoArgs[nPos] = pDest;
			}
		   	pCppStack += sizeof (sal_Int32); // extra long
                   	break;
			}
			}
			// no longer needed
			TYPELIB_DANGER_RELEASE( pParamTypeDescr );

				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
void * pThis;

 if( (nFunctionIndex & 0x80000000) )
	{
		nFunctionIndex &= 0x7fffffff;
		 pThis = pCallStack[1];
	}
else
	{
		pThis = pCallStack[0];
		nVtableCall &= 0x7fffffff;
	}
	pThis = static_cast< char * >(pThis) - nVtableOffset;
	bridges::cpp_uno::shared::CppInterfaceProxy * pCppI
		= bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(
		pThis);

	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;

	return eRet;
public:
	const ClassDataBuffer* getClassData( typelib_InterfaceTypeDescription* );
	
	MediateClassData() {}
	~MediateClassData();
};
//__________________________________________________________________________________________________
MediateClassData::ClassDataBuffer::~ClassDataBuffer()
{
	delete m_pVTable;
}

//__________________________________________________________________________________________________
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
	}

}
//__________________________________________________________________________________________________
namespace {

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

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;
	{
		MutexGuard aGuard( Mutex::getGlobalMutex() );
		if (! s_pMediateClassData)
		{
#ifdef LEAK_STATIC_DATA
			s_pMediateClassData = new MediateClassData();
#else
			static MediateClassData s_aMediateClassData;
			s_pMediateClassData = &s_aMediateClassData;
#endif
		}
	}
	*(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 );
}

        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: flush the instruction cache (there probably is OS support for this)
	}

Lines 69-75 Link Here

(-)source/cpp_uno/gcc3_linux_sparc/except.cxx (-1 / +1 lines)
69	#include <osl/diagnose.h>	69	#include <osl/diagnose.h>
70	#include <osl/mutex.hxx>	70	#include <osl/mutex.hxx>
71		71
72	#include <bridges/cpp_uno/bridge.hxx>	72	#include <com/sun/star/uno/genfunc.hxx>
73	#include <typelib/typedescription.hxx>	73	#include <typelib/typedescription.hxx>
74	#include <uno/any2.h>	74	#include <uno/any2.h>
75		75





.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) \




 *
 *
 ************************************************************************/
#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




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

#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);
                          *reinterpret_cast< sal_Int32 * >(pCppStack) =
                          *(reinterpret_cast< sal_Int32 const * >(pUnoArgs[ nPos ] ) + 1);
                          break;
            		default:
                          uno_copyAndConvertData(
                             pCppArgs[nPos], pUnoArgs[nPos], pParamTypeDescr,
                            pThis->getBridge()->getUno2Cpp() );
                          break;
                        }
			// no longer needed
			TYPELIB_DANGER_RELEASE( pParamTypeDescr );
		}

				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
	{
		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,

		::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
	}
	}
}

}


Return to issue 24507

Lines 78-88 Link Here

(-)source/cpp_uno/gcc3_linux_sparc/makefile.mk (-9 / +9 lines)
78		78
79	.IF "$(COM)$(OS)$(CPU)" == "GCCLINUXS"	79	.IF "$(COM)$(OS)$(CPU)" == "GCCLINUXS"
80		80
81	.IF "$(bridges_debug)" != ""	81	.IF "$(cppu_no_leak)" == ""
82	CFLAGS += -DBRIDGES_DEBUG	82	CFLAGS += -DLEAK_STATIC_DATA
83	.ENDIF	83	.ENDIF
84		84
85	CFLAGSNOOPT=-O0	85	CFLAGSNOOPT=-O0
		86
86	NOOPTFILES = \	87	NOOPTFILES = \
87	$(SLO)$/uno2cpp.obj \	88	$(SLO)$/uno2cpp.obj \
88	$(SLO)$/cpp2uno.obj	89	$(SLO)$/cpp2uno.obj
Lines 92-107 Link Here
92	$(SLO)$/cpp2uno.obj \	93	$(SLO)$/cpp2uno.obj \
93	$(SLO)$/uno2cpp.obj	94	$(SLO)$/uno2cpp.obj
94		95
95	SHL1TARGET= $(TARGET)
96		96
97	SHL1DEF= $(MISC)$/$(SHL1TARGET).def	97	SHL1TARGET=$(TARGET)
98	SHL1IMPLIB= i$(TARGET)	98
		99	SHL1DEF=$(MISC)$/$(SHL1TARGET).def
		100	SHL1IMPLIB=i$(TARGET)
99	SHL1VERSIONMAP=..$/..$/bridge_exports.map	101	SHL1VERSIONMAP=..$/..$/bridge_exports.map
100		102
101	SHL1OBJS= \	103	SHL1OBJS= $(SLOFILES)
102	$(SLO)$/except.obj \	104	SHL1LIBS =$(SLB)$/cpp_uno_shared.lib
103	$(SLO)$/cpp2uno.obj \
104	$(SLO)$/uno2cpp.obj
105		105
106	SHL1STDLIBS= \	106	SHL1STDLIBS= \
107	$(CPPULIB) \	107	$(CPPULIB) \

Lines 58-71 Link Here

(-)source/cpp_uno/gcc3_linux_sparc/share.hxx (-2 / +2 lines)
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		65
66	namespace CPPU_CURRENT_NAMESPACE	66	namespace CPPU_CURRENT_NAMESPACE
67	{	67	{
68		68	void dummy_can_throw_anything( char const * );
69	// ----- following decl from libstdc++-v3/libsupc++/unwind-cxx.h and unwind.h	69	// ----- following decl from libstdc++-v3/libsupc++/unwind-cxx.h and unwind.h
70		70
71	struct _Unwind_Exception	71	struct _Unwind_Exception

Lines 60-91 Link Here

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