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

 *

 *  $RCSfile: cpp2uno.cxx,v $

 *

 *  $Revision: 1.6 $

 *

 *  last change: $Author: obo $ $Date: 2005/01/25 13:11:46 $

 *

 *  The Contents of this file are made available subject to the terms of

 *  either of the following licenses

 *

 *         - GNU Lesser General Public License Version 2.1

 *         - Sun Industry Standards Source License Version 1.1

 *

 *  Sun Microsystems Inc., October, 2000

 *

 *  GNU Lesser General Public License Version 2.1

 *  =============================================

 *  Copyright 2000 by Sun Microsystems, Inc.

 *  901 San Antonio Road, Palo Alto, CA 94303, USA

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser General Public

 *  License version 2.1, as published by the Free Software Foundation.

 *

 *  This library is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *  Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,

 *  MA  02111-1307  USA

 *

 *

 *  Sun Industry Standards Source License Version 1.1

 *  =================================================

 *  The contents of this file are subject to the Sun Industry Standards

 *  Source License Version 1.1 (the "License"); You may not use this file

 *  except in compliance with the License. You may obtain a copy of the

 *  License at http://www.openoffice.org/license.html.

 *

 *  Software provided under this License is provided on an "AS IS" basis,

 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,

 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,

 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.

 *  See the License for the specific provisions governing your rights and

 *  obligations concerning the Software.

 *

 *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.

 *

 *  Copyright: 2000 by Sun Microsystems, Inc.

 *

 *  All Rights Reserved.

 *

 *  Contributor(s): _______________________________________

 *

 *

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

#include <com/sun/star/uno/genfunc.hxx>

#include <typelib/typedescription.hxx>

#include <uno/data.h>

#include "bridges/cpp_uno/shared/bridge.hxx"

#include "bridges/cpp_uno/shared/cppinterfaceproxy.hxx"

#include "bridges/cpp_uno/shared/types.hxx"

#include "bridges/cpp_uno/shared/vtablefactory.hxx"

#include "share.hxx"

#include <alloca.h>

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

namespace

{

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

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,

	void ** pCallStack,

	sal_Int64 * pRegisterReturn /* space for register return */ )

{

	// pCallStack: [ret ptr], this, params

	char * pCppStack = (char *)pCallStack;

	// return

	typelib_TypeDescription * pReturnTypeDescr = 0;

	if (pReturnTypeRef)

		TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );

	void * pUnoReturn = 0;

	void * pCppReturn = 0; // complex return ptr: if != 0 && != pUnoReturn, reconversion need

	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;

			pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType(

  	                             pReturnTypeDescr )

						  ? alloca( pReturnTypeDescr->nSize )

						  : pCppReturn); // direct way

			pCppStack += sizeof( void* );

		}

	}

	// pop this

	pCppStack += sizeof( void* );

	// stack space

	OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );

	// parameters

	void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );

	void ** pCppArgs = pUnoArgs + nParams;

	// indizes of values this have to be converted (interface conversion cpp<=>uno)

	sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));

	// type descriptions for reconversions

	typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));

	sal_Int32 nTempIndizes   = 0;

	for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )

	{

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

		}

		else // ptr to complex value | ref

		{

			pCppArgs[nPos] = *(void **)pCppStack;

			if (! rParam.bIn) // is pure out

			{

				// uno out is unconstructed mem!

				pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );

				pTempIndizes[nTempIndizes] = nPos;

				// will be released at reconversion

				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;

			}

			else // direct way

			{

				pUnoArgs[nPos] = *(void **)pCppStack;

				// no longer needed

				TYPELIB_DANGER_RELEASE( pParamTypeDescr );

			}

		}

		pCppStack += sizeof(sal_Int32); // standard parameter length

	}

	// ExceptionHolder

	uno_Any aUnoExc; // Any will be constructed by callee

	uno_Any * pUnoExc = &aUnoExc;

	// invoke uno dispatch call

	(*pThis->getUnoI()->pDispatcher)(pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );

	// in case an exception occured...

	if (pUnoExc)

	{

		// destruct temporary in/inout params

		for ( ; nTempIndizes--; )

		{

			sal_Int32 nIndex = pTempIndizes[nTempIndizes];

			if (pParams[nIndex].bIn) // is in/inout => was constructed

				uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );

			TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );

		}

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

	{

		// temporary params

		for ( ; nTempIndizes--; )

		{

			sal_Int32 nIndex = pTempIndizes[nTempIndizes];

			typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];

			if (pParams[nIndex].bOut) // inout/out

			{

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

			TYPELIB_DANGER_RELEASE( pParamTypeDescr );

		}

		// return

		if (pCppReturn) // has complex return

		{

			if (pUnoReturn != pCppReturn) // needs reconversion

			{

				uno_copyAndConvertData( pCppReturn, pUnoReturn, pReturnTypeDescr,

										pThis->getBridge()->getUno2Cpp() );

				// destroy temp uno return

				uno_destructData( pUnoReturn, pReturnTypeDescr, 0 );

			}

			// complex return ptr is set to eax

			*(void **)pRegisterReturn = pCppReturn;

		}

		if (pReturnTypeDescr)

		{

			typelib_TypeClass eRet = (typelib_TypeClass)pReturnTypeDescr->eTypeClass;

			TYPELIB_DANGER_RELEASE( pReturnTypeDescr );

			return eRet;

		}

		else

			return typelib_TypeClass_VOID;

	}

}

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

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

	// pCallStack: this, params

	// eventual [ret*] lies at pCallStack -1

	// so count down pCallStack by one to keep it simple

	bridges::cpp_uno::shared::CppInterfaceProxy * pCppI

		= bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(

	static_cast< char * >(*pCallStack) - nVtableOffset);

	if ((nFunctionIndex & 0x80000000) != 0) {

		nFunctionIndex &= 0x7FFFFFFF;

		--pCallStack;

	}

	typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();

	OSL_ENSURE( nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex,

				 "### illegal vtable index!" );

	if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)

	{

		throw RuntimeException( rtl::OUString::createFromAscii("illegal vtable index!"), (XInterface *)pCppI );

	}

	// determine called method

	sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];

	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, nFunctionIndex=%d\n", cstr.getStr(), nFunctionIndex );

#endif

	typelib_TypeClass eRet;

	switch (aMemberDescr.get()->eTypeClass)

	{

	case typelib_TypeClass_INTERFACE_ATTRIBUTE:

	{

		if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex)

		{

			// is GET method

			eRet = cpp2uno_call(

				pCppI, aMemberDescr.get(),

				((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef,

				0, 0, // no params

				pCallStack, pRegisterReturn );

		}

		else

		{

			// is SET method

			typelib_MethodParameter aParam;

			aParam.pTypeRef =

				((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef;

			aParam.bIn		= sal_True;

			aParam.bOut		= sal_False;

			eRet = cpp2uno_call(

				pCppI, aMemberDescr.get(),

				0, // indicates void return

				1, &aParam,

				pCallStack, pRegisterReturn );

		}

		break;

	}

	case typelib_TypeClass_INTERFACE_METHOD:

	{

		// is METHOD

		switch (nFunctionIndex)

		{

		case 1: // acquire()

			pCppI->acquireProxy(); // non virtual call!

			eRet = typelib_TypeClass_VOID;

			break;

		case 2: // release()

			pCppI->releaseProxy(); // non virtual call!

			eRet = typelib_TypeClass_VOID;

			break;

		case 0: // queryInterface() opt

		{

			typelib_TypeDescription * pTD = 0;

			TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pCallStack[2] )->getTypeLibType() );

			if (pTD)

			{

                XInterface * pInterface = 0;

		(*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)(

		    pCppI->getBridge()->getCppEnv(),

		    (void **)&pInterface, pCppI->getOid().pData, (typelib_InterfaceTypeDescription *)pTD );

                if (pInterface)

                {

                    ::uno_any_construct(

                        reinterpret_cast< uno_Any * >( pCallStack[0] ),

                        &pInterface, pTD, cpp_acquire );

                    pInterface->release();

                    TYPELIB_DANGER_RELEASE( pTD );

                    *(void **)pRegisterReturn = pCallStack[0];

                    eRet = typelib_TypeClass_ANY;

                    break;

                }

                TYPELIB_DANGER_RELEASE( pTD );

            }

		} // else perform queryInterface()

		default:

			eRet = cpp2uno_call(

				pCppI, aMemberDescr.get(),

				((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pReturnTypeRef,

				((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->nParams,

				((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pParams,

				pCallStack, pRegisterReturn );

		}

		break;

	}

	default:

	{

		throw RuntimeException(rtl::OUString::createFromAscii("no member description found!"), (XInterface *)pCppI );

		// is here for dummy

		eRet = typelib_TypeClass_VOID;

	}

	}

	return eRet;

}

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

/**

 * is called on incoming vtable calls

 * (called by asm snippets)

 */

static void cpp_vtable_call()

{

	volatile sal_Int64 nRegReturn;

	int nFunctionIndex;

	void** pCallStack;

	int vTableOffset;

	__asm__( "st %%i0, %0\n\t"

			"st %%i1, %1\n\t"

 			"st %%i2, %2\n\t"

			: : "m"(nFunctionIndex), "m"(pCallStack), "m"(vTableOffset) );

//	fprintf(stderr,"cpp_mediate nFunctionIndex=%x\n",nFunctionIndex);

//	fflush(stderr);

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

	typelib_TypeClass aType =

		cpp_mediate( nFunctionIndex, vTableOffset, pCallStack+17, (sal_Int64*)&nRegReturn );

	switch( aType )

	{

		case typelib_TypeClass_BOOLEAN:

		case typelib_TypeClass_BYTE:

			__asm__( "ld %0, %%l0\n\t"

					 "ldsb [%%l0], %%i0\n"

					 : : "m"(&nRegReturn) );

			break;

		case typelib_TypeClass_CHAR:

		case typelib_TypeClass_SHORT:

		case typelib_TypeClass_UNSIGNED_SHORT:

			__asm__( "ld %0, %%l0\n\t"

					 "ldsh [%%l0], %%i0\n"

					 : : "m"(&nRegReturn) );

			break;

		case typelib_TypeClass_HYPER:

		case typelib_TypeClass_UNSIGNED_HYPER:

			__asm__( "ld %0, %%l0\n\t"

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

			__asm__( "ld %0, %%l0\n\t"

					 "ld [%%l0], %%i0\n"

					 : : "m"(&nRegReturn) );

			break;

	}

	if( bComplex )

	{

		__asm__( "add %i7, 4, %i7\n\t" );

		// after call to complex return valued funcion there is an unimp instruction

	}

}

//__________________________________________________________________________________________________

int const codeSnippetSize = 56;

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;

}

} //end of namespace

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; //null

     (*slots)[-1] = 0; //destructor

    return block;

}

unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(

    void ** slots, unsigned char * code,

    typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,

    sal_Int32 functionCount, sal_Int32 vTableOffset)

{

	for (sal_Int32 i = 0; i < type->nMembers; ++i) {

        typelib_TypeDescription * member = 0;

        TYPELIB_DANGER_GET(&member, type->ppMembers[i]);

        OSL_ASSERT(member != 0);

        switch (member->eTypeClass) {

        case typelib_TypeClass_INTERFACE_ATTRIBUTE:

            // Getter:

            *slots++ = code;

            code = codeSnippet(

                code, functionOffset++, vTableOffset,

                bridges::cpp_uno::shared::isSimpleType(

                    reinterpret_cast<

		    typelib_InterfaceAttributeTypeDescription * >(

		    member)->pAttributeTypeRef));

            // Setter:

            if (!reinterpret_cast<

                typelib_InterfaceAttributeTypeDescription * >(

                    member)->bReadOnly)

            {

                *slots++ = code;

                code = codeSnippet(code, functionOffset++, vTableOffset, true);

            }

            break;

        case typelib_TypeClass_INTERFACE_METHOD:

            *slots++ = code;

            code = codeSnippet(

                code, functionOffset++, vTableOffset,

                bridges::cpp_uno::shared::isSimpleType(

                    reinterpret_cast<

                    typelib_InterfaceMethodTypeDescription * >(

                        member)->pReturnTypeRef));

            break;

        default:

            OSL_ASSERT(false);

            break;

        }

        TYPELIB_DANGER_RELEASE(member);

    }

    return code;

}

void bridges::cpp_uno::shared::VtableFactory::flushCode(

	   unsigned char const *, unsigned char const *)

  	{

        //TODO: IZ 25819  flush the instruction cache (there probably is OS support for this)

	}

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

 *

 *  $RCSfile: except.cxx,v $

 *

 *  $Revision: 1.3 $

 *

 *  last change: $Author: svesik $ $Date: 2004/04/21 13:41:00 $

 *

 *  The Contents of this file are made available subject to the terms of

 *  either of the following licenses

 *

 *         - GNU Lesser General Public License Version 2.1

 *         - Sun Industry Standards Source License Version 1.1

 *

 *  Sun Microsystems Inc., October, 2000

 *

 *  GNU Lesser General Public License Version 2.1

 *  =============================================

 *  Copyright 2000 by Sun Microsystems, Inc.

 *  901 San Antonio Road, Palo Alto, CA 94303, USA

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser General Public

 *  License version 2.1, as published by the Free Software Foundation.

 *

 *  This library is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *  Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,

 *  MA  02111-1307  USA

 *

 *

 *  Sun Industry Standards Source License Version 1.1

 *  =================================================

 *  The contents of this file are subject to the Sun Industry Standards

 *  Source License Version 1.1 (the "License"); You may not use this file

 *  except in compliance with the License. You may obtain a copy of the

 *  License at http://www.openoffice.org/license.html.

 *

 *  Software provided under this License is provided on an "AS IS" basis,

 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,

 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,

 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.

 *  See the License for the specific provisions governing your rights and

 *  obligations concerning the Software.

 *

 *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.

 *

 *  Copyright: 2000 by Sun Microsystems, Inc.

 *

 *  All Rights Reserved.

 *

 *  Contributor(s): _______________________________________

 *

 *

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

#include <stdio.h>

#include <dlfcn.h>

#include <cxxabi.h>

#include <hash_map>

#include <rtl/strbuf.hxx>

#include <rtl/ustrbuf.hxx>

#include <osl/diagnose.h>

#include <osl/mutex.hxx>

#include <com/sun/star/uno/genfunc.hxx>

#include <typelib/typedescription.hxx>

#include <uno/any2.h>

#include "share.hxx"

using namespace ::std;

using namespace ::osl;

using namespace ::rtl;

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

using namespace ::__cxxabiv1;

namespace CPPU_CURRENT_NAMESPACE

{

void dummy_can_throw_anything( char const * )

{

}

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

static OUString toUNOname( char const * p ) SAL_THROW( () )

{

#if defined BRIDGES_DEBUG

    char const * start = p;

#endif

    // example: N3com3sun4star4lang24IllegalArgumentExceptionE

	OUStringBuffer buf( 64 );

    OSL_ASSERT( 'N' == *p );

    ++p; // skip N

    while ('E' != *p)

    {

        // read chars count

        long n = (*p++ - '0');

        while ('0' <= *p && '9' >= *p)

        {

            n *= 10;

            n += (*p++ - '0');

        }

        buf.appendAscii( p, n );

        p += n;

        if ('E' != *p)

            buf.append( (sal_Unicode)'.' );

    }

#if defined BRIDGES_DEBUG

    OUString ret( buf.makeStringAndClear() );

    OString c_ret( OUStringToOString( ret, RTL_TEXTENCODING_ASCII_US ) );

    fprintf( stderr, "> toUNOname(): %s => %s\n", start, c_ret.getStr() );

    return ret;

#else

    return buf.makeStringAndClear();

#endif

}

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

class RTTI

{

    typedef hash_map< OUString, type_info *, OUStringHash > t_rtti_map;

    Mutex m_mutex;

	t_rtti_map m_rttis;

    t_rtti_map m_generatedRttis;

    void * m_hApp;

public:

    RTTI() SAL_THROW( () );

    ~RTTI() SAL_THROW( () );

    type_info * getRTTI( typelib_CompoundTypeDescription * ) SAL_THROW( () );

};

//__________________________________________________________________________________________________

RTTI::RTTI() SAL_THROW( () )

    : m_hApp( dlopen( 0, RTLD_LAZY ) )

{

}

//__________________________________________________________________________________________________

RTTI::~RTTI() SAL_THROW( () )

{

    dlclose( m_hApp );

}

//__________________________________________________________________________________________________

type_info * RTTI::getRTTI( typelib_CompoundTypeDescription *pTypeDescr ) SAL_THROW( () )

{

    type_info * rtti;

    OUString const & unoName = *(OUString const *)&pTypeDescr->aBase.pTypeName;

    MutexGuard guard( m_mutex );

    t_rtti_map::const_iterator iFind( m_rttis.find( unoName ) );

    if (iFind == m_rttis.end())

    {

        // RTTI symbol

        OStringBuffer buf( 64 );

        buf.append( RTL_CONSTASCII_STRINGPARAM("_ZTIN") );

        sal_Int32 index = 0;

        do

        {

            OUString token( unoName.getToken( 0, '.', index ) );

            buf.append( token.getLength() );

            OString c_token( OUStringToOString( token, RTL_TEXTENCODING_ASCII_US ) );

            buf.append( c_token );

        }

        while (index >= 0);

        buf.append( 'E' );

        OString symName( buf.makeStringAndClear() );

        rtti = (type_info *)dlsym( m_hApp, symName.getStr() );

        if (rtti)

        {

            pair< t_rtti_map::iterator, bool > insertion(

                m_rttis.insert( t_rtti_map::value_type( unoName, rtti ) ) );

            OSL_ENSURE( insertion.second, "### inserting new rtti failed?!" );

        }

        else

        {

            // try to lookup the symbol in the generated rtti map

            t_rtti_map::const_iterator iFind( m_generatedRttis.find( unoName ) );

            if (iFind == m_generatedRttis.end())

            {

                // we must generate it !

                // symbol and rtti-name is nearly identical,

                // the symbol is prefixed with _ZTI

                char const * rttiName = symName.getStr() +4;

#if defined BRIDGES_DEBUG

                fprintf( stderr,"generated rtti for %s\n", rttiName );

#endif

                if (pTypeDescr->pBaseTypeDescription)

                {

                    // ensure availability of base

                    type_info * base_rtti = getRTTI(

                        (typelib_CompoundTypeDescription *)pTypeDescr->pBaseTypeDescription );

                    rtti = new __si_class_type_info(

                        strdup( rttiName ), (__class_type_info *)base_rtti );

                }

                else

                {

                    // this class has no base class

                    rtti = new __class_type_info( strdup( rttiName ) );

                }

                pair< t_rtti_map::iterator, bool > insertion(

                    m_generatedRttis.insert( t_rtti_map::value_type( unoName, rtti ) ) );

                OSL_ENSURE( insertion.second, "### inserting new generated rtti failed?!" );

            }

            else // taking already generated rtti

            {

                rtti = iFind->second;

            }

        }

    }

    else

    {

        rtti = iFind->second;

    }

    return rtti;

}

//--------------------------------------------------------------------------------------------------

static void deleteException( void * pExc )

{

    __cxa_exception const * header = ((__cxa_exception const *)pExc - 1);

    typelib_TypeDescription * pTD = 0;

    OUString unoName( toUNOname( header->exceptionType->name() ) );

    ::typelib_typedescription_getByName( &pTD, unoName.pData );

    OSL_ENSURE( pTD, "### unknown exception type! leaving out destruction => leaking!!!" );

    if (pTD)

    {

		::uno_destructData( pExc, pTD, cpp_release );

		::typelib_typedescription_release( pTD );

	}

}

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

void raiseException( uno_Any * pUnoExc, uno_Mapping * pUno2Cpp )

{

#if defined BRIDGES_DEBUG

    OString cstr(

        OUStringToOString(

            *reinterpret_cast< OUString const * >( &pUnoExc->pType->pTypeName ),

            RTL_TEXTENCODING_ASCII_US ) );

    fprintf( stderr, "> uno exception occured: %s\n", cstr.getStr() );

#endif

    void * pCppExc;

    type_info * rtti;

    {

    // construct cpp exception object

	typelib_TypeDescription * pTypeDescr = 0;

	TYPELIB_DANGER_GET( &pTypeDescr, pUnoExc->pType );

    OSL_ASSERT( pTypeDescr );

    if (! pTypeDescr)

    {

        throw RuntimeException(

            OUString( RTL_CONSTASCII_USTRINGPARAM("cannot get typedescription for type ") ) +

            *reinterpret_cast< OUString const * >( &pUnoExc->pType->pTypeName ),

            Reference< XInterface >() );

    }

	pCppExc = __cxa_allocate_exception( pTypeDescr->nSize );

	::uno_copyAndConvertData( pCppExc, pUnoExc->pData, pTypeDescr, pUno2Cpp );

	// destruct uno exception

	::uno_any_destruct( pUnoExc, 0 );

    // avoiding locked counts

    static RTTI * s_rtti = 0;

    if (! s_rtti)

    {

        MutexGuard guard( Mutex::getGlobalMutex() );

        if (! s_rtti)

        {

#ifdef LEAK_STATIC_DATA

            s_rtti = new RTTI();

#else

            static RTTI rtti_data;

            s_rtti = &rtti_data;

#endif

        }

    }

	rtti = (type_info *)s_rtti->getRTTI( (typelib_CompoundTypeDescription *) pTypeDescr );

    TYPELIB_DANGER_RELEASE( pTypeDescr );

    OSL_ENSURE( rtti, "### no rtti for throwing exception!" );

    if (! rtti)

    {

        throw RuntimeException(

            OUString( RTL_CONSTASCII_USTRINGPARAM("no rtti for type ") ) +

            *reinterpret_cast< OUString const * >( &pUnoExc->pType->pTypeName ),

            Reference< XInterface >() );

    }

    }

	__cxa_throw( pCppExc, rtti, deleteException );

}

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

void fillUnoException( __cxa_exception * header, uno_Any * pUnoExc, uno_Mapping * pCpp2Uno )

{

    if (! header)

    {

        RuntimeException aRE(

            OUString( RTL_CONSTASCII_USTRINGPARAM("no exception header!") ),

            Reference< XInterface >() );

        Type const & rType = ::getCppuType( &aRE );

        uno_type_any_constructAndConvert( pUnoExc, &aRE, rType.getTypeLibType(), pCpp2Uno );

#if defined _DEBUG

        OString cstr( OUStringToOString( aRE.Message, RTL_TEXTENCODING_ASCII_US ) );

        OSL_ENSURE( 0, cstr.getStr() );

#endif

        return;

    }

	typelib_TypeDescription * pExcTypeDescr = 0;

    OUString unoName( toUNOname( header->exceptionType->name() ) );

#if defined BRIDGES_DEBUG

    OString cstr_unoName( OUStringToOString( unoName, RTL_TEXTENCODING_ASCII_US ) );

    fprintf( stderr, "> c++ exception occured: %s\n", cstr_unoName.getStr() );

#endif

	typelib_typedescription_getByName( &pExcTypeDescr, unoName.pData );

    if (0 == pExcTypeDescr)

    {

        RuntimeException aRE(

            OUString( RTL_CONSTASCII_USTRINGPARAM("exception type not found: ") ) + unoName,

            Reference< XInterface >() );

        Type const & rType = ::getCppuType( &aRE );

        uno_type_any_constructAndConvert( pUnoExc, &aRE, rType.getTypeLibType(), pCpp2Uno );

#if defined _DEBUG

        OString cstr( OUStringToOString( aRE.Message, RTL_TEXTENCODING_ASCII_US ) );

        OSL_ENSURE( 0, cstr.getStr() );

#endif

    }

    else

    {

        // construct uno exception any

        uno_any_constructAndConvert( pUnoExc, header->adjustedPtr, pExcTypeDescr, pCpp2Uno );

        typelib_typedescription_release( pExcTypeDescr );

    }

}

}

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

#

#   $RCSfile: makefile.mk,v $

#

#   $Revision: 1.3 $

#

#   last change: $Author: svesik $ $Date: 2004/04/21 13:41:21 $

#

#   The Contents of this file are made available subject to the terms of

#   either of the following licenses

#

#          - GNU Lesser General Public License Version 2.1

#          - Sun Industry Standards Source License Version 1.1

#

#   Sun Microsystems Inc., October, 2000

#

#   GNU Lesser General Public License Version 2.1

#   =============================================

#   Copyright 2000 by Sun Microsystems, Inc.

#   901 San Antonio Road, Palo Alto, CA 94303, USA

#

#   This library is free software; you can redistribute it and/or

#   modify it under the terms of the GNU Lesser General Public

#   License version 2.1, as published by the Free Software Foundation.

#

#   This library is distributed in the hope that it will be useful,

#   but WITHOUT ANY WARRANTY; without even the implied warranty of

#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

#   Lesser General Public License for more details.

#

#   You should have received a copy of the GNU Lesser General Public

#   License along with this library; if not, write to the Free Software

#   Foundation, Inc., 59 Temple Place, Suite 330, Boston,

#   MA  02111-1307  USA

#

#

#   Sun Industry Standards Source License Version 1.1

#   =================================================

#   The contents of this file are subject to the Sun Industry Standards

#   Source License Version 1.1 (the "License"); You may not use this file

#   except in compliance with the License. You may obtain a copy of the

#   License at http://www.openoffice.org/license.html.

#

#   Software provided under this License is provided on an "AS IS" basis,

#   WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,

#   WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,

#   MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.

#   See the License for the specific provisions governing your rights and

#   obligations concerning the Software.

#

#   The Initial Developer of the Original Code is: Sun Microsystems, Inc.

#

#   Copyright: 2000 by Sun Microsystems, Inc.

#

#   All Rights Reserved.

#

#   Contributor(s): _______________________________________

#

#

#

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

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

PRJNAME=bridges

TARGET=gcc3_uno

LIBTARGET=no

ENABLE_EXCEPTIONS=TRUE

NO_BSYMBOLIC=TRUE

# --- Settings -----------------------------------------------------

.INCLUDE :  svpre.mk

.INCLUDE :  settings.mk

.INCLUDE :  sv.mk

# --- Files --------------------------------------------------------

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

.IF "$(cppu_no_leak)" == ""

CFLAGS += -DLEAK_STATIC_DATA

.ENDIF

CFLAGSNOOPT=-O0

NOOPTFILES = \

	$(SLO)$/uno2cpp.obj	\

	$(SLO)$/cpp2uno.obj

SLOFILES= \

	$(SLO)$/except.obj		\

	$(SLO)$/cpp2uno.obj		\

	$(SLO)$/uno2cpp.obj

SHL1TARGET=$(TARGET)

SHL1DEF=$(MISC)$/$(SHL1TARGET).def

SHL1IMPLIB=i$(TARGET)

SHL1VERSIONMAP=..$/..$/bridge_exports.map

SHL1OBJS= $(SLOFILES)

SHL1LIBS =$(SLB)$/cpp_uno_shared.lib

SHL1STDLIBS= \

	$(CPPULIB) \

	$(SALLIB)

.ENDIF

# --- Targets ------------------------------------------------------

.INCLUDE :  target.mk

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

 *

 *  $RCSfile: share.hxx,v $

 *

 *  $Revision: 1.3 $

 *

 *  last change: $Author: svesik $ $Date: 2004/04/21 13:41:36 $

 *

 *  The Contents of this file are made available subject to the terms of

 *  either of the following licenses

 *

 *         - GNU Lesser General Public License Version 2.1

 *         - Sun Industry Standards Source License Version 1.1

 *

 *  Sun Microsystems Inc., October, 2000

 *

 *  GNU Lesser General Public License Version 2.1

 *  =============================================

 *  Copyright 2000 by Sun Microsystems, Inc.

 *  901 San Antonio Road, Palo Alto, CA 94303, USA

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser General Public

 *  License version 2.1, as published by the Free Software Foundation.

 *

 *  This library is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *  Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,

 *  MA  02111-1307  USA

 *

 *

 *  Sun Industry Standards Source License Version 1.1

 *  =================================================

 *  The contents of this file are subject to the Sun Industry Standards

 *  Source License Version 1.1 (the "License"); You may not use this file

 *  except in compliance with the License. You may obtain a copy of the

 *  License at http://www.openoffice.org/license.html.

 *

 *  Software provided under this License is provided on an "AS IS" basis,

 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,

 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,

 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.

 *  See the License for the specific provisions governing your rights and

 *  obligations concerning the Software.

 *

 *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.

 *

 *  Copyright: 2000 by Sun Microsystems, Inc.

 *

 *  All Rights Reserved.

 *

 *  Contributor(s): _______________________________________

 *

 *

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

#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

{

    unsigned exception_class __attribute__((__mode__(__DI__)));

    void * exception_cleanup;

    unsigned private_1 __attribute__((__mode__(__word__)));

    unsigned private_2 __attribute__((__mode__(__word__)));

} __attribute__((__aligned__));

struct __cxa_exception

{ 

    ::std::type_info *exceptionType;

    void (*exceptionDestructor)(void *); 

    ::std::unexpected_handler unexpectedHandler;

    ::std::terminate_handler terminateHandler;

    __cxa_exception *nextException;

    int handlerCount;

    int handlerSwitchValue;

    const unsigned char *actionRecord;

    const unsigned char *languageSpecificData;

    void *catchTemp;

    void *adjustedPtr;

    _Unwind_Exception unwindHeader;

};    

extern "C" void *__cxa_allocate_exception(

    std::size_t thrown_size ) throw();

extern "C" void __cxa_throw (

    void *thrown_exception, std::type_info *tinfo, void (*dest) (void *) ) __attribute__((noreturn));

struct __cxa_eh_globals

{

    __cxa_exception *caughtExceptions;

    unsigned int uncaughtExceptions;

};

extern "C" __cxa_eh_globals *__cxa_get_globals () throw();

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

void raiseException(

    uno_Any * pUnoExc, uno_Mapping * pUno2Cpp );

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

void fillUnoException(

    __cxa_exception * header, uno_Any *, uno_Mapping * pCpp2Uno );

inline char* adjustPointer( char* pIn, typelib_TypeDescription* pType )

{

	switch( pType->nSize )

	{

		case 1: return pIn + 3;

		case 2: return pIn + 2;

		case 3: return pIn + 1;

			// Huh ? perhaps a char[3] ? Though that would be a pointer

			// well, we have it anyway for symmetry

	}

	return pIn;

}

}

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

 *

 *  $RCSfile: uno2cpp.cxx,v $

 *

 *  $Revision: 1.6 $

 *

 *  last change: $Author: obo $ $Date: 2005/01/25 13:12:00 $

 *

 *  The Contents of this file are made available subject to the terms of

 *  either of the following licenses

 *

 *         - GNU Lesser General Public License Version 2.1

 *         - Sun Industry Standards Source License Version 1.1

 *

 *  Sun Microsystems Inc., October, 2000

 *

 *  GNU Lesser General Public License Version 2.1

 *  =============================================

 *  Copyright 2000 by Sun Microsystems, Inc.

 *  901 San Antonio Road, Palo Alto, CA 94303, USA

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser General Public

 *  License version 2.1, as published by the Free Software Foundation.

 *

 *  This library is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *  Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,

 *  MA  02111-1307  USA

 *

 *

 *  Sun Industry Standards Source License Version 1.1

 *  =================================================

 *  The contents of this file are subject to the Sun Industry Standards

 *  Source License Version 1.1 (the "License"); You may not use this file

 *  except in compliance with the License. You may obtain a copy of the

 *  License at http://www.openoffice.org/license.html.

 *

 *  Software provided under this License is provided on an "AS IS" basis,

 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,

 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,

 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.

 *  See the License for the specific provisions governing your rights and

 *  obligations concerning the Software.

 *

 *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.

 *

 *  Copyright: 2000 by Sun Microsystems, Inc.

 *

 *  All Rights Reserved.

 *

 *  Contributor(s): _______________________________________

 *

 *

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

#include <malloc.h>

#include <com/sun/star/uno/genfunc.hxx>

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

#include "share.hxx"

#include <alloca.h>

using namespace rtl;

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

namespace

{

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

// The call instruction within the asm section of callVirtualMethod may throw

// exceptions.  So that the compiler handles this correctly, it is important

// that (a) callVirtualMethod might call dummy_can_throw_anything (although this

// never happens at runtime), which in turn can throw exceptions, and (b)

// callVirtualMethod is not inlined at its call site (so that any exceptions are

// caught which are thrown from the instruction calling callVirtualMethod):

void callVirtualMethod( void * pAdjustedThisPtr,

                        sal_Int32 nVtableIndex,

                        void * pRegisterReturn,

                        typelib_TypeClass eReturnType,

                        sal_Int32 * pStackLongs,

                        sal_Int32 nStackLongs ) __attribute__((noinline));

void callVirtualMethod( void * pAdjustedThisPtr,

                        sal_Int32 nVtableIndex,

                        void * pRegisterReturn,

                        typelib_TypeClass eReturnType,

                        sal_Int32 * pStackLongs,

                        sal_Int32 nStackLongs )

{

	// 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;

	volatile float f0f = 0;

	volatile long long saveReg[7];

	__asm__ (

		// save registers

		"std %%l0, [%4]\n\t"

		"mov %4, %%l0\n\t"

		"mov %%l0, %%l1\n\t"

		"add %%l0, 8, %%l0\n\t"

		"std %%l2, [%%l0]\n\t"

		"add %%l0, 8, %%l0\n\t"

		"std %%l4, [%%l0]\n\t"

		"add %%l0, 8, %%l0\n\t"

		"std %%o0, [%%l0]\n\t"

		"add %%l0, 8, %%l0\n\t"

		"std %%o2, [%%l0]\n\t"

		"add %%l0, 8, %%l0\n\t"

		"std %%o4, [%%l0]\n\t"

		"add %%l0, 8, %%l0\n\t"

		"std %%l6, [%%l0]\n\t"

		"mov %%l1, %%l7\n\t"

		// increase our own stackframe if necessary

		"mov %%sp, %%l3\n\t"		// save stack ptr for readjustment

		"subcc %%i5, 7, %%l0\n\t"

		"ble .LmoveOn\n\t"

		"nop\n\t"

		"sll %%l0, 2, %%l0\n\t"

		"add %%l0, 96, %%l0\n\t"

		"mov %%sp, %%l1\n\t"		// old stack ptr

		"sub %%sp, %%l0, %%l0\n\t"	// future stack ptr

		"andcc %%l0, 7, %%g0\n\t"	// align stack to 8

		"be .LisAligned\n\t"

		"nop\n\t"

		"sub %%l0, 4, %%l0\n"

	".LisAligned:\n\t"

		"mov %%l0, %%o5\n\t"			// save newly computed stack ptr

		"add %%g0, 16, %%o4\n"

		// now copy longs down to save register window

		// and local variables

	".LcopyDown:\n\t"

		"ld [%%l1], %%l2\n\t"

		"st %%l2,[%%l0]\n\t"

		"add %%l0, 4, %%l0\n\t"

		"add %%l1, 4, %%l1\n\t"

		"subcc %%o4, 1, %%o4\n\t"

		"bne .LcopyDown\n\t"

		"mov %%o5, %%sp\n\t"		// move new stack ptr (hopefully) atomically

		// while register window is valid in both spaces

		// (scheduling might hit in copyDown loop)

		"sub %%i5, 7, %%l0\n\t"		// copy parameters past the sixth to stack

		"add %%i4, 28, %%l1\n\t"

		"add %%sp, 92, %%l2\n"

	".LcopyLong:\n\t"

		"ld [%%l1], %%o0\n\t"

		"st %%o0, [%%l2]\n\t"

		"add %%l1, 4, %%l1\n\t"

		"add %%l2, 4, %%l2\n\t"

		"subcc %%l0, 1, %%l0\n\t"

		"bne .LcopyLong\n\t"

		"nop\n"

	".LmoveOn:\n\t"

		"mov %%i5, %%l0\n\t"		// prepare out registers

		"mov %%i4, %%l1\n\t"

		"ld [%%l1], %%o0\n\t"		// prepare complex return ptr

		"st %%o0, [%%sp+64]\n\t"

		"sub %%l0, 1, %%l0\n\t"

		"add %%l1, 4, %%l1\n\t"

		"ld [%%l1], %%o0\n\t"

		"subcc %%l0, 1, %%l0\n\t"

		"be .LdoCall\n\t"

		"nop\n\t"

		"add %%l1, 4, %%l1\n\t"

		"ld [%%l1], %%o1\n\t"

		"subcc %%l0, 1, %%l0\n\t"

		"be .LdoCall\n\t"

		"nop\n\t"

		"add %%l1, 4, %%l1\n\t"

		"ld [%%l1], %%o2\n\t"

		"subcc %%l0, 1, %%l0\n\t"

		"be .LdoCall\n\t"

		"nop\n\t"

		"add %%l1, 4, %%l1\n\t"

		"ld [%%l1], %%o3\n\t"

		"subcc %%l0, 1, %%l0\n\t"

		"be .LdoCall\n\t"

		"nop\n\t"

		"add %%l1, 4, %%l1\n\t"

		"ld [%%l1], %%o4\n\t"

		"subcc %%l0, 1, %%l0\n\t"

		"be .LdoCall\n\t"

		"nop\n\t"

		"add %%l1, 4, %%l1\n\t"

		"ld [%%l1], %%o5\n"

	".LdoCall:\n\t"

		"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

// 		// is the this ptr patch !

// 		// first entry is (or __tf)

// 		"ldsh [%%l0], %%l6\n\t"		// load this ptr patch

// 		"add %%l6, %%o0, %%o0\n\t"	// patch this ptr

// 		"add %%l0, 4, %%l0\n\t"		// get virtual function ptr

		"ld [%%l0], %%l0\n\t"

		"ld [%%i4], %%l2\n\t"

		"subcc %%l2, %%g0, %%l2\n\t"

		"bne .LcomplexCall\n\t"

		"nop\n\t"

		"call %%l0\n\t"

		"nop\n\t"

		"ba .LcallReturned\n\t"

		"nop\n"

	".LcomplexCall:\n\t"

		"call %%l0\n\t"

		"nop\n\t"

		"unimp\n"

	".LcallReturned:\n\t"

		"mov %%l3, %%sp\n\t"		// readjust stack so that our locals are where they belong

		"st %%o0, %0\n\t"			// save possible return registers into our locals

		"st %%o1, %1\n\t"

		"std %%f0, %2\n\t"

		"st %%f0, %3\n\t"

		// restore registers

		"ldd [%%l7], %%l0\n\t"

		"add %%l7, 8, %%l7\n\t"

		"ldd [%%l7], %%l2\n\t"

		"add %%l7, 8, %%l7\n\t"

		"ldd [%%l7], %%l4\n\t"

		"add %%l7, 8, %%l7\n\t"

		"ldd [%%l7], %%o0\n\t"

		"add %%l7, 8, %%l7\n\t"

		"ldd [%%l7], %%o2\n\t"

		"add %%l7, 8, %%l7\n\t"

		"ldd [%%l7], %%o4\n\t"

		"add %%l7, 8, %%l7\n\t"

		"ldd [%%l7], %%l6\n\t"

		: :

		"m"(o0),

		"m"(o1),

		"m"(f0d),

		"m"(f0f),

		"r"(&saveReg[0])

		);

	switch( eReturnType )

	{

		case typelib_TypeClass_HYPER:

		case typelib_TypeClass_UNSIGNED_HYPER:

			((long*)pRegisterReturn)[1] = o1;

		case typelib_TypeClass_LONG:

		case typelib_TypeClass_UNSIGNED_LONG:

		case typelib_TypeClass_ENUM:

			((long*)pRegisterReturn)[0] = o0;

			break;

		case typelib_TypeClass_CHAR:

		case typelib_TypeClass_SHORT:

		case typelib_TypeClass_UNSIGNED_SHORT:

			*(unsigned short*)pRegisterReturn = (unsigned short)o0;

			break;

		case typelib_TypeClass_BOOLEAN:

		case typelib_TypeClass_BYTE:

			*(unsigned char*)pRegisterReturn = (unsigned char)o0;

			break;

		case typelib_TypeClass_FLOAT:

			*(float*)pRegisterReturn = f0f;

			break;

		case typelib_TypeClass_DOUBLE:

			*(double*)pRegisterReturn = f0d;

			break;

	}

}

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

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+2) * sizeof(sal_Int64) );

  	char * pCppStackStart	= pCppStack;

	// return

	typelib_TypeDescription * pReturnTypeDescr = 0;

	TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );

	OSL_ENSURE( pReturnTypeDescr, "### expected return type description!" );

	void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion

	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

	OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );

	// args

	void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );

	// indizes of values this have to be converted (interface conversion cpp<=>uno)

	sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);

	// type descriptions for reconversions

	typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));

	sal_Int32 nTempIndizes   = 0;

	for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )

	{

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

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

		}

		else // ptr to complex value | ref

		{

			if (! rParam.bIn) // is pure out

			{

				// cpp out is constructed mem, uno out is not!

				uno_constructData(

					*(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),

					pParamTypeDescr );

				pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call

				// will be released at reconversion

				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;

			}

			else // direct way

			{

				*(void **)pCppStack = pCppArgs[nPos] = pUnoArgs[nPos];

				// no longer needed

				TYPELIB_DANGER_RELEASE( pParamTypeDescr );

			}

		}

		pCppStack += sizeof(sal_Int32); // standard parameter length

	}

	try

	{

		int nStackLongs = (pCppStack - pCppStackStart)/sizeof(sal_Int32);

		OSL_ENSURE( !( (pCppStack - pCppStackStart ) & 3), "UNALIGNED STACK !!! (Please DO panic" );

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

		{

			sal_Int32 nIndex = pTempIndizes[nTempIndizes];

			typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];

			if (pParams[nIndex].bIn)

			{

				if (pParams[nIndex].bOut) // inout

				{

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

			TYPELIB_DANGER_RELEASE( pParamTypeDescr );

		}

		// return value

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

		{

			sal_Int32 nIndex = pTempIndizes[nTempIndizes];

			// destroy temp cpp param => cpp: every param was constructed

			uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );

			TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );

		}

		// return type

		if (pReturnTypeDescr)

			TYPELIB_DANGER_RELEASE( pReturnTypeDescr );

	}

}

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

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

    fprintf( stderr, "received dispatch( %s )\n", cstr.getStr() );

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

		if (pReturn)

		{

			// dependent dispatch

			cpp_call(

				pThis, aVtableSlot,

				((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,

				0, 0, // no params

				pReturn, pArgs, ppException );

		}

		else

		{

			// is SET

			typelib_MethodParameter aParam;

			aParam.pTypeRef =

				((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;

			aParam.bIn		= sal_True;

			aParam.bOut		= sal_False;

			typelib_TypeDescriptionReference * pReturnTypeRef = 0;

			OUString aVoidName( RTL_CONSTASCII_USTRINGPARAM("void") );

			typelib_typedescriptionreference_new(

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

		}

		break;

	}

	case typelib_TypeClass_INTERFACE_METHOD:

	{

		VtableSlot aVtableSlot(

		getVtableSlot(

		 reinterpret_cast<

		  typelib_InterfaceMethodTypeDescription const * >(

		  pMemberDescr)));

		switch (aVtableSlot.index)

		{

			// standard calls

		case 1: // acquire uno interface

			(*pUnoI->acquire)( pUnoI );

			*ppException = 0;

			break;

		case 2: // release uno interface

			(*pUnoI->release)( pUnoI );

			*ppException = 0;

			break;

		case 0: // queryInterface() opt

		{

			typelib_TypeDescription * pTD = 0;

			TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() );

			if (pTD)

			{

                uno_Interface * pInterface = 0;

 		(*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(

 		  pThis->pBridge->getUnoEnv(),

				   (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );

                if (pInterface)

                {

                    ::uno_any_construct(

                        reinterpret_cast< uno_Any * >( pReturn ),

                        &pInterface, pTD, 0 );

                    (*pInterface->release)( pInterface );

                    TYPELIB_DANGER_RELEASE( pTD );

                    *ppException = 0;

                    break;

                }

                TYPELIB_DANGER_RELEASE( pTD );

            }

		} // else perform queryInterface()

		default:

			// dependent dispatch

			cpp_call(

				pThis, aVtableSlot,

				((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,

				((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,

				((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,

				pReturn, pArgs, ppException );

		}

		break;

	}

	default:

	{

		::com::sun::star::uno::RuntimeException aExc(

			OUString( RTL_CONSTASCII_USTRINGPARAM("illegal member type description!") ),

			::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >() );

		Type const & rExcType = ::getCppuType( &aExc );

		// binary identical null reference

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

	}

	}

}

}