Attachment #13123 for issue #24507

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




 *
 *  $RCSfile: cpp2uno.cxx,v $
 *
 *  $Revision: 1.2.62.1 $
 *
 *  last change: $Author: waratah $ $Date: 2003/12/27 09:50:06 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses

//  #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,
	void ** pCallStack,
	sal_Int32 nVtableOffset,
	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 )
	if( nVtableCall & 0x80000000 )
	{
		nFunctionIndex &= 0x7fffffff;
		 pThis = pCallStack[1];  //jw: from solaris/sparc, linux/intel has 2
	}
else
	{
		pThis = pCallStack[0]; //jw: from solaris/sparc, linux/intel has 1
	}
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] );

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

	}
	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:

	return eRet;
	Mutex									m_aMutex;

	void createVTable( ClassDataBuffer*, typelib_InterfaceTypeDescription* );
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)
 */
 static void cpp_vtable_call()
{
	sal_Int32 functionIndex;
   	void** pCallStack;
	sal_Int32 vtableOffset;
	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"
	"st %%i2, %2\n\t"
	: : "m"(functionIndex), "m"(pCallStack), "m"(vtableOffset) );
			 "ld [%%fp+76], %%i2\n\t"
			 : : "m"(nTableEntry), "m"(pCallStack) );

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

	typelib_TypeClass aType =
		cpp_mediate( functionIndex, pCallStack+17, vtableOffset, (sal_Int64*)&nRegReturn );

	switch( aType )
	{

					 "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"


}
//__________________________________________________________________________________________________
namespace {

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 );
	}

	int nSize = aComplexReturn.size();
	const int nSnippetSize = 64;
	char * pSpace = (char *)rtl_allocateMemory( (2*(nSize+2)*sizeof(void *)) + (nSize*nSnippetSize) );
	pBuffer->m_pVTable = (void*)pSpace;
	
	char * pCode	= pSpace + (2*(nSize+2)*sizeof(void *));
	void ** pvft	= (void **)pSpace;

	// setup vft and code
	for ( sal_Int32 nPos = 0; nPos < nSize; ++nPos )
	{
		unsigned long * codeSnip = (unsigned long *)(pCode + (nPos*nSnippetSize));
		pvft[ nPos ] = codeSnip;
		unsigned long nTablePos = nPos;
		sal_Bool bComplex = aComplexReturn.front();
		if( bComplex )
			nTablePos |= 0x80000000;
		aComplexReturn.pop_front();

		/*
		 *	generate this code
		 * 
		 *	st %o0, [%sp+68]				save registers
 		 *	st %o1, [%sp+72]
 		 *	st %o2, [%sp+76]
 		 *	st %o3, [%sp+80]
 		 *	st %o4, [%sp+84]
 		 *	st %o5, [%sp+88]
		 *
		 *	mov %sp, %o1					prepare stack ptr for cpp_vtable_call
		 *	sethi %hi( nTablePos ), %o0		prepare table entry
		 *	or %lo( nTablePos ), %o0		(on complex return set high bit
		 *
		 *	sethi $hi( cpp_vtable_call ), %l0
		 *	or %l0, %lo( cpp_vtable_call ), %l0
		 *	jmp %l0
		 *	nop
		 *
		 *	Note: %o0 should be restored by cpp_vtable_call if void returned
		 *	%o1 should be restored if not hyper returned
		 *	%o2 must be restored
		 *
		 */
		*codeSnip++	= 0xd023a044;
		*codeSnip++ = 0xd223a048;
		*codeSnip++ = 0xd423a04c;
		*codeSnip++ = 0xd623a050;
		*codeSnip++ = 0xd823a054;
		*codeSnip++ = 0xda23a058;

		*codeSnip++ = 0x9210000e;
		*codeSnip++ = 0x11000000 | ( nTablePos >> 10 );
		*codeSnip++ = 0x90122000 | ( nTablePos & 1023 );
		*codeSnip++ = 0x15000000 | ( ((unsigned long)cpp_vtable_call) >> 10 );
		*codeSnip++	= 0x9412a000 | ( ((unsigned long)cpp_vtable_call) & 1023 );
		*codeSnip++ = 0x81c28000;
		*codeSnip++ = 0x01000000;		
	}
}

//==================================================================================================
void SAL_CALL cppu_cppInterfaceProxy_patchVtable(
	XInterface * pCppI, typelib_InterfaceTypeDescription * pTypeDescr ) throw ()
{
	static MediateClassData * s_pMediateClassData = 0;
	if (! s_pMediateClassData)
	{
		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;
}

unsigned char * codeSnippet(
	unsigned char *codeSnip,
	sal_Int32 functionIndex,
	sal_Int32 vtableOffset,
	bool simpleReturnType)
{
	if( !simpleReturnType )
			functionIndex |= 0x80000000;  // is this correct??

	// st %o0, [%sp+68]:
	*codeSnip++ = 0xd023a044;
	// st %o1, [%sp+72]:
	*codeSnip++ = 0xd223a048;
	// st %o2, [%sp+76]:
	*codeSnip++ = 0xd423a04c;
	// st %o3, [%sp+80]:
	*codeSnip++ = 0xd623a050;
	// st %o4, [%sp+84]:
	*codeSnip++ = 0xd823a054;
	// st %o5, [%sp+88]:
	*codeSnip++ = 0xda23a058;
	// sethi %hi(functionIndex), %o0:
	*codeSnip++ = 0x11000000 | (static_cast< unsigned long >(functionIndex) >> 10);
	// or %o0, %lo(functionIndex), %o0:
	*codeSnip++ = 0x90122000 | (static_cast< unsigned long >(functionIndex) & 0x3FF);
	// sethi %hi(vtableOffset), %o2:
	*codeSnip++ = 0x15000000 | (static_cast< unsigned long >(vtableOffset) >> 10);
	// or %o2, %lo(vtableOffset), %o2:
	*codeSnip++ = 0x9412a000 | (static_cast< unsigned long >(vtableOffset) & 0x3FF);
	// sethi %hi(cpp_vtable_call), %o3:
	*codeSnip++ = 0x17000000 | (((unsigned long) cpp_vtable_call) >> 10);
	// or %o3, %lo(cpp_vtable_call), %o3:
	*codeSnip++ = 0x9612e000 | (((unsigned long) cpp_vtable_call) & 0x3FF);
	// jmp %o3:
	*codeSnip++ = 0x81c2c000;
	// mov %sp, %o1:
	*codeSnip++ = 0x9210000e;
}
}

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

char * bridges::cpp_uno::shared::VtableFactory::createBlock(
    sal_Int32 slotCount, void *** slots)
{
    char * block = new char[
        (slotCount + 2) * sizeof (void *) + slotCount * codeSnippetSize];
    *slots = mapBlockToVtable(block);
    (*slots)[-2] = 0;
    (*slots)[-1] = 0;
    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;
	CPPU_CURRENT_NAMESPACE::cppu_ext_getMapping( ppMapping, pFrom, pTo );
}

}

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;


//================================================================================================== 
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 )

	
	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;

	{
		OSL_ENSURE( !( (pCppStack - pCppStackStart ) & 3), "UNALIGNED STACK !!! (Please DO panic" );
		callVirtualMethod(
			pAdjustedThisPtr, aVtableSlot.index,
			pCppReturn, pReturnTypeDescr->eTypeClass,
			(sal_Int32 *)pCppStackStart, (pCppStack - pCppStackStart) / sizeof(sal_Int32) );
		// NO exception occured...

				{
					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( ... )
 	{
  		// 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 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 (-68 / +74 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 301-308 Link Here
301		294
302	//==================================================================================================	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 )
Lines 321-327 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;	320	(void*)pCppStack = NULL;
Lines 329-342 Link Here
329	else	322	else
330	{	323	{
331	// complex return via ptr	324	// complex return via ptr
332	pCppReturn = (void *)pCppStack = (cppu_relatesToInterface( pReturnTypeDescr )	325	pCppReturn = (void *)pCppStack
		326	= (bridges::cpp_uno::shared::relatesToInterfaceType(
		327	pReturnTypeDescr )
333	? alloca( pReturnTypeDescr->nSize )	328	? alloca( pReturnTypeDescr->nSize )
334	: pUnoReturn); // direct way	329	: pUnoReturn); // direct way
335	}	330	}
336	pCppStack += sizeof(void*);	331	pCppStack += sizeof(void*);
337	}	332	}
338	// push this	333	// push this
339	(void*)pCppStack = pThis->pCppI;	334	void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI())
		335	+ aVtableSlot.offset;
		336	(void*)pCppStack = pAdjustedThisPtr;
340	pCppStack += sizeof( void* );	337	pCppStack += sizeof( void* );
341		338
342	// stack space	339	// stack space
Lines 355-374 Link Here
355	const typelib_MethodParameter & rParam = pParams[nPos];	352	const typelib_MethodParameter & rParam = pParams[nPos];
356	typelib_TypeDescription * pParamTypeDescr = 0;	353	typelib_TypeDescription * pParamTypeDescr = 0;
357	TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );	354	TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
358		355	if (!rParam.bOut
359	if (!rParam.bOut && cppu_isSimpleType( pParamTypeDescr ))	356	&& bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
360	{	357	{
361	pCppArgs[ nPos ] = adjustPointer( pCppStack, pParamTypeDescr );	358	pCppArgs[ nPos ] = CPPU_CURRENT_NAMESPACE::adjustPointer( 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 409-415 Link Here
409	{	420	{
410	OSL_ENSURE( !( (pCppStack - pCppStackStart ) & 3), "UNALIGNED STACK !!! (Please DO panic" );	421	OSL_ENSURE( !( (pCppStack - pCppStackStart ) & 3), "UNALIGNED STACK !!! (Please DO panic" );
411	callVirtualMethod(	422	callVirtualMethod(
412	pThis->pCppI, nVtableCall,	423	pAdjustedThisPtr, aVtableSlot.index,
413	pCppReturn, pReturnTypeDescr->eTypeClass,	424	pCppReturn, pReturnTypeDescr->eTypeClass,
414	(sal_Int32 *)pCppStackStart, (pCppStack - pCppStackStart) / sizeof(sal_Int32) );	425	(sal_Int32 *)pCppStackStart, (pCppStack - pCppStackStart) / sizeof(sal_Int32) );
415	// NO exception occured...	426	// NO exception occured...
Lines 427-439 Link Here
427	{	438	{
428	uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value	439	uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
429	uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,	440	uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
430	&pThis->pBridge->aCpp2Uno );	441	pThis->getBridge()->getCpp2Uno() );
431	}	442	}
432	}	443	}
433	else // pure out	444	else // pure out
434	{	445	{
435	uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,	446	uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
436	&pThis->pBridge->aCpp2Uno );	447	pThis->getBridge()->getCpp2Uno() );
437	}	448	}
438	// destroy temp cpp param => cpp: every param was constructed	449	// destroy temp cpp param => cpp: every param was constructed
439	uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );	450	uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
Lines 444-459 Link Here
444	if (pCppReturn && pUnoReturn != pCppReturn)	455	if (pCppReturn && pUnoReturn != pCppReturn)
445	{	456	{
446	uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,	457	uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
447	&pThis->pBridge->aCpp2Uno );	458	pThis->getBridge()->getCpp2Uno() );
448	uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );	459	uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
449	}	460	}
450	}	461	}
451	catch( ... )	462	catch( ... )
452	{	463	{
453	// get exception	464	// get exception
454	fillUnoException(	465	fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
455	__cxa_get_globals()->caughtExceptions, *ppUnoExc, &pThis->pBridge->aCpp2Uno );	466
456
457	// temporary params	467	// temporary params
458	for ( ; nTempIndizes--; )	468	for ( ; nTempIndizes--; )
459	{	469	{
Lines 470-478 Link Here
470		480
471		481
472	//==================================================================================================	482	//==================================================================================================
473	void SAL_CALL cppu_unoInterfaceProxy_dispatch(	483	void bridges::cpp_uno::shared::UnoInterfaceProxy::dispatch(
474	uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,	484	uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
475	void * pReturn, void * pArgs[], uno_Any ** ppException ) throw ()	485	void * pReturn, void * pArgs[], uno_Any ** ppException ) SAL_THROW(())
476	{	486	{
477	#if defined BRIDGES_DEBUG	487	#if defined BRIDGES_DEBUG
478	OString cstr( OUStringToOString( pMemberDescr->pTypeName, RTL_TEXTENCODING_ASCII_US ) );	488	OString cstr( OUStringToOString( pMemberDescr->pTypeName, RTL_TEXTENCODING_ASCII_US ) );
Lines 480-504 Link Here
480	#endif	490	#endif
481		491
482	// is my surrogate	492	// is my surrogate
483	cppu_unoInterfaceProxy * pThis = (cppu_unoInterfaceProxy *)pUnoI;	493	bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
		494	= static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
484	typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;	495	typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;
485		496
486	switch (pMemberDescr->eTypeClass)	497	switch (pMemberDescr->eTypeClass)
487	{	498	{
488	case typelib_TypeClass_INTERFACE_ATTRIBUTE:	499	case typelib_TypeClass_INTERFACE_ATTRIBUTE:
489	{	500	{
490	// determine vtable call index	501	VtableSlot aVtableSlot(
491	sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;	502	getVtableSlot(
492	OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### member pos out of range!" );	503	reinterpret_cast<
493		504	typelib_InterfaceAttributeTypeDescription const * >(
494	sal_Int32 nVtableCall = pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos];	505	pMemberDescr)));
495	OSL_ENSURE( nVtableCall < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
496
497	if (pReturn)	506	if (pReturn)
498	{	507	{
499	// dependent dispatch	508	// dependent dispatch
500	cpp_call(	509	cpp_call(
501	pThis, nVtableCall,	510	pThis, aVtableSlot,
502	((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,	511	((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
503	0, 0, // no params	512	0, 0, // no params
504	pReturn, pArgs, ppException );	513	pReturn, pArgs, ppException );
Lines 518-529 Link Here
518	&pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );	527	&pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
519		528
520	// dependent dispatch	529	// dependent dispatch
		530	aVtableSlot.index += 1; // get, then set method
521	cpp_call(	531	cpp_call(
522	pThis, nVtableCall +1, // get, then set method	532	pThis, aVtableSlot,
523	pReturnTypeRef,	533	pReturnTypeRef,
524	1, &aParam,	534	1, &aParam,
525	pReturn, pArgs, ppException );	535	pReturn, pArgs, ppException );
526		536
527	typelib_typedescriptionreference_release( pReturnTypeRef );	537	typelib_typedescriptionreference_release( pReturnTypeRef );
528	}	538	}
529		539
Lines 531-544 Link Here
531	}	541	}
532	case typelib_TypeClass_INTERFACE_METHOD:	542	case typelib_TypeClass_INTERFACE_METHOD:
533	{	543	{
534	// determine vtable call index	544	VtableSlot aVtableSlot(
535	sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;	545	getVtableSlot(
536	OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### member pos out of range!" );	546	reinterpret_cast<
537		547	typelib_InterfaceMethodTypeDescription const * >(
538	sal_Int32 nVtableCall = pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos];	548	pMemberDescr)));
539	OSL_ENSURE( nVtableCall < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );	549	switch (aVtableSlot.index)
540
541	switch (nVtableCall)
542	{	550	{
543	// standard calls	551	// standard calls
544	case 1: // acquire uno interface	552	case 1: // acquire uno interface
Lines 556-564 Link Here
556	if (pTD)	564	if (pTD)
557	{	565	{
558	uno_Interface * pInterface = 0;	566	uno_Interface * pInterface = 0;
559	(*pThis->pBridge->pUnoEnv->getRegisteredInterface)(	567	(*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(
560	pThis->pBridge->pUnoEnv,	568	pThis->pBridge->getUnoEnv(),
561	(void *)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription )pTD );	569	(void *)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription )pTD );
562		570
563	if (pInterface)	571	if (pInterface)
564	{	572	{
Lines 576-582 Link Here
576	default:	584	default:
577	// dependent dispatch	585	// dependent dispatch
578	cpp_call(	586	cpp_call(
579	pThis, nVtableCall,	587	pThis, aVtableSlot,
580	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,	588	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
581	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,	589	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
582	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,	590	((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
Lines 596-601 Link Here
596	}	604	}
597	}	605	}
598	}	606	}
599		607	}
600	}
601