diff --git a/editors/openoffice3/Makefile b/editors/openoffice3/Makefile index 687a393ca0f..8542f3e2e81 100644 --- a/editors/openoffice3/Makefile +++ b/editors/openoffice3/Makefile @@ -1,4 +1,4 @@ -# $OpenBSD: Makefile,v 1.70 2010/12/02 09:29:25 ajacoutot Exp $ +# $OpenBSD: Makefile,v 1.71 2010/12/10 23:25:35 robert Exp $ ONLY_FOR_ARCHS= amd64 i386 @@ -16,7 +16,7 @@ PKGNAME-kde= openoffice-kde-${VERSION} PKGNAME-java= openoffice-java-${VERSION} CATEGORIES= editors productivity -REVISION-main= 2 +REVISION-main= 3 REVISION-kde= 0 REVISION-java= 0 @@ -106,12 +106,6 @@ PSEUDO_FLAVORS= normal_build parallel no_lang FLAVORS= debug no_java FLAVOR?= -.if ${FLAVOR:L:Mparallel} -EDISTFILES+= nbcat-0.1.tar.gz:0 -.else -SUPDISTFILES+= nbcat-0.1.tar.gz:0 -.endif - .if !${FLAVOR:L:Mno_java} MULTI_PACKAGES+= -java .endif @@ -139,7 +133,9 @@ BUILD_DEPENDS+= archivers/zip \ archivers/p5-Archive-Zip \ print/cups \ boost->=1.41.0:devel/boost \ - misc/fileutils + misc/fileutils \ + misc/findutils \ + textproc/textutils MODULES+= lang/python \ devel/gconf2 @@ -303,10 +299,9 @@ BUILD_CMD= cd instsetoo_native && build.pl ${NCPUFLAG} --all --dlv_switch -link SUBST_VARS+= MR pre-patch: - ln -fs ${LOCALBASE}/bin/gcp ${WRKDIR}/bin/cp -.if ${FLAVOR:L:Mparallel} - ln -fs ${WRKDIR}/cat.${ARCH} ${WRKDIR}/bin/cat -.endif + @ln -fs ${LOCALBASE}/bin/gcat ${WRKDIR}/bin/cat + @ln -fs ${LOCALBASE}/bin/gcp ${WRKDIR}/bin/cp + @ln -fs ${LOCALBASE}/bin/gfind ${WRKDIR}/bin/find do-build: @cd ${WRKBUILD} && \ diff --git a/editors/openoffice3/patches/patch-bridges_source_cpp_uno_gcc3_linux_intel_cpp2uno_cxx b/editors/openoffice3/patches/patch-bridges_source_cpp_uno_gcc3_linux_intel_cpp2uno_cxx new file mode 100644 index 00000000000..11c924496b9 --- /dev/null +++ b/editors/openoffice3/patches/patch-bridges_source_cpp_uno_gcc3_linux_intel_cpp2uno_cxx @@ -0,0 +1,653 @@ +$OpenBSD: patch-bridges_source_cpp_uno_gcc3_linux_intel_cpp2uno_cxx,v 1.1 2010/12/10 23:25:35 robert Exp $ +--- bridges/source/cpp_uno/gcc3_linux_intel/cpp2uno.cxx.orig.port Fri Dec 10 11:00:36 2010 ++++ bridges/source/cpp_uno/gcc3_linux_intel/cpp2uno.cxx Fri Dec 10 11:00:39 2010 +@@ -1,3 +1,4 @@ ++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + /************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +@@ -47,179 +48,179 @@ namespace + + //================================================================================================== + void 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, +- void * pReturnValue ) ++ 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, ++ void * pReturnValue ) + { +- // pCallStack: ret, [return ptr], this, params +- char * pCppStack = (char *)(pCallStack +1); ++ // pCallStack: ret, [return ptr], this, params ++ char * pCppStack = (char *)(pCallStack +1); + +- // 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 = pReturnValue; // direct way for simple types +- } +- else // complex return via ptr (pCppReturn) +- { +- pCppReturn = *(void **)pCppStack; +- pCppStack += sizeof(void *); +- +- pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( ++ // 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 (x86::isSimpleReturnType( pReturnTypeDescr )) ++ { ++ pUnoReturn = pReturnValue; // 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 +- pCppStack += sizeof( void* ); ++ ? alloca( pReturnTypeDescr->nSize ) ++ : pCppReturn); // direct way ++ } ++ } ++ // 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 ); ++ // 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 ++ if (!rParam.bOut + && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr )) + // value +- { +- pCppArgs[nPos] = pCppStack; +- pUnoArgs[nPos] = pCppStack; +- switch (pParamTypeDescr->eTypeClass) +- { +- case typelib_TypeClass_HYPER: +- case typelib_TypeClass_UNSIGNED_HYPER: +- case typelib_TypeClass_DOUBLE: +- pCppStack += sizeof(sal_Int32); // extra long ++ { ++ pCppArgs[nPos] = pCppStack; ++ pUnoArgs[nPos] = pCppStack; ++ switch (pParamTypeDescr->eTypeClass) ++ { ++ case typelib_TypeClass_HYPER: ++ case typelib_TypeClass_UNSIGNED_HYPER: ++ case typelib_TypeClass_DOUBLE: ++ pCppStack += sizeof(sal_Int32); // extra long + break; + default: + break; +- } +- // no longer needed +- TYPELIB_DANGER_RELEASE( pParamTypeDescr ); +- } +- else // ptr to complex value | ref +- { +- pCppArgs[nPos] = *(void **)pCppStack; ++ } ++ // 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( ++ 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; ++ { ++ 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)( ++ // 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( ++ ++ // 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 +- } +- 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 +- *static_cast< void ** >(pReturnValue) = pCppReturn; +- } +- if (pReturnTypeDescr) +- { +- TYPELIB_DANGER_RELEASE( pReturnTypeDescr ); +- } +- } ++ } ++ 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 ++ *static_cast< void ** >(pReturnValue) = pCppReturn; ++ } ++ if (pReturnTypeDescr) ++ { ++ TYPELIB_DANGER_RELEASE( pReturnTypeDescr ); ++ } ++ } + } + + +@@ -228,93 +229,93 @@ extern "C" void cpp_vtable_call( + int nFunctionIndex, int nVtableOffset, void** pCallStack, + void * pReturnValue ) + { +- OSL_ENSURE( sizeof(sal_Int32)==sizeof(void *), "### unexpected!" ); +- +- // pCallStack: ret adr, [ret *], this, params ++ OSL_ENSURE( sizeof(sal_Int32)==sizeof(void *), "### unexpected!" ); ++ ++ // pCallStack: ret adr, [ret *], this, params + void * pThis; +- if( nFunctionIndex & 0x80000000 ) +- { +- nFunctionIndex &= 0x7fffffff; ++ if( nFunctionIndex & 0x80000000 ) ++ { ++ nFunctionIndex &= 0x7fffffff; + pThis = pCallStack[2]; +- } +- else ++ } ++ else + { + pThis = pCallStack[1]; + } + pThis = static_cast< char * >(pThis) - nVtableOffset; +- bridges::cpp_uno::shared::CppInterfaceProxy * pCppI ++ 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( ++ 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 *)pThis ); +- } +- +- // determine called method +- sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex]; +- OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### illegal member index!" ); ++ } ++ ++ // determine called method ++ sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex]; ++ OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### illegal member index!" ); + +- TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] ); ++ TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] ); + +- switch (aMemberDescr.get()->eTypeClass) +- { +- case typelib_TypeClass_INTERFACE_ATTRIBUTE: +- { +- if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex) +- { +- // is GET method +- cpp2uno_call( +- pCppI, aMemberDescr.get(), +- ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef, +- 0, 0, // no params +- pCallStack, pReturnValue ); +- } +- else +- { +- // is SET method +- typelib_MethodParameter aParam; +- aParam.pTypeRef = +- ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef; +- aParam.bIn = sal_True; +- aParam.bOut = sal_False; +- +- cpp2uno_call( +- pCppI, aMemberDescr.get(), +- 0, // indicates void return +- 1, &aParam, +- pCallStack, pReturnValue ); +- } +- break; +- } +- case typelib_TypeClass_INTERFACE_METHOD: +- { +- // is METHOD +- switch (nFunctionIndex) +- { +- case 1: // acquire() +- pCppI->acquireProxy(); // non virtual call! +- break; +- case 2: // release() +- pCppI->releaseProxy(); // non virtual call! +- break; +- case 0: // queryInterface() opt +- { +- typelib_TypeDescription * pTD = 0; +- TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pCallStack[3] )->getTypeLibType() ); +- if (pTD) +- { ++ switch (aMemberDescr.get()->eTypeClass) ++ { ++ case typelib_TypeClass_INTERFACE_ATTRIBUTE: ++ { ++ if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex) ++ { ++ // is GET method ++ cpp2uno_call( ++ pCppI, aMemberDescr.get(), ++ ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef, ++ 0, 0, // no params ++ pCallStack, pReturnValue ); ++ } ++ else ++ { ++ // is SET method ++ typelib_MethodParameter aParam; ++ aParam.pTypeRef = ++ ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef; ++ aParam.bIn = sal_True; ++ aParam.bOut = sal_False; ++ ++ cpp2uno_call( ++ pCppI, aMemberDescr.get(), ++ 0, // indicates void return ++ 1, &aParam, ++ pCallStack, pReturnValue ); ++ } ++ break; ++ } ++ case typelib_TypeClass_INTERFACE_METHOD: ++ { ++ // is METHOD ++ switch (nFunctionIndex) ++ { ++ case 1: // acquire() ++ pCppI->acquireProxy(); // non virtual call! ++ break; ++ case 2: // release() ++ pCppI->releaseProxy(); // non virtual call! ++ break; ++ case 0: // queryInterface() opt ++ { ++ typelib_TypeDescription * pTD = 0; ++ TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pCallStack[3] )->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( +@@ -327,24 +328,24 @@ extern "C" void cpp_vtable_call( + } + TYPELIB_DANGER_RELEASE( pTD ); + } +- } // else perform queryInterface() +- default: +- cpp2uno_call( +- pCppI, aMemberDescr.get(), +- ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pReturnTypeRef, +- ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->nParams, +- ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pParams, +- pCallStack, pReturnValue ); +- } +- break; +- } +- default: +- { +- throw RuntimeException( ++ } // else perform queryInterface() ++ default: ++ cpp2uno_call( ++ pCppI, aMemberDescr.get(), ++ ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pReturnTypeRef, ++ ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->nParams, ++ ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pParams, ++ pCallStack, pReturnValue ); ++ } ++ break; ++ } ++ default: ++ { ++ throw RuntimeException( + rtl::OUString::createFromAscii("no member description found!"), + (XInterface *)pThis ); +- } +- } ++ } ++ } + } + + //================================================================================================== +@@ -358,15 +359,39 @@ extern "C" typedef void (*PrivateSnippetExecutor)(); + + int const codeSnippetSize = 16; + ++#if defined (FREEBSD) || defined(NETBSD) || defined(OPENBSD) || defined(MACOSX) ++namespace ++{ ++ PrivateSnippetExecutor returnsInRegister(typelib_TypeDescriptionReference * pReturnTypeRef) ++ { ++ //These archs apparently are returning small structs in registers, while Linux ++ //doesn't ++ PrivateSnippetExecutor exec=NULL; ++ ++ typelib_TypeDescription * pReturnTypeDescr = 0; ++ TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef ); ++ const bool bSimpleReturnStruct = x86::isSimpleReturnType(pReturnTypeDescr); ++ const sal_Int32 nRetSize = pReturnTypeDescr->nSize; ++ TYPELIB_DANGER_RELEASE( pReturnTypeDescr ); ++ if (bSimpleReturnStruct) ++ { ++ exec = privateSnippetExecutorGeneral; // fills eax ++ if (nRetSize > 4) ++ exec = privateSnippetExecutorHyper; // fills eax/edx ++ } ++ return exec; ++ } ++} ++#endif ++ + unsigned char * codeSnippet( + unsigned char * code, sal_PtrDiff writetoexecdiff, sal_Int32 functionIndex, sal_Int32 vtableOffset, +- typelib_TypeClass returnTypeClass) ++ typelib_TypeDescriptionReference * pReturnTypeRef) + { +- if (!bridges::cpp_uno::shared::isSimpleType(returnTypeClass)) { +- functionIndex |= 0x80000000; +- } + PrivateSnippetExecutor exec; +- switch (returnTypeClass) { ++ typelib_TypeClass eReturnClass = pReturnTypeRef ? pReturnTypeRef->eTypeClass : typelib_TypeClass_VOID; ++ switch (eReturnClass) ++ { + case typelib_TypeClass_VOID: + exec = privateSnippetExecutorVoid; + break; +@@ -380,13 +405,24 @@ unsigned char * codeSnippet( + case typelib_TypeClass_DOUBLE: + exec = privateSnippetExecutorDouble; + break; ++ case typelib_TypeClass_STRUCT: ++ case typelib_TypeClass_EXCEPTION: ++#if defined (FREEBSD) || defined(NETBSD) || defined(OPENBSD) || defined(MACOSX) ++ exec = returnsInRegister(pReturnTypeRef); ++ if (!exec) ++ { ++ exec = privateSnippetExecutorClass; ++ functionIndex |= 0x80000000; ++ } ++ break; ++#endif + case typelib_TypeClass_STRING: + case typelib_TypeClass_TYPE: + case typelib_TypeClass_ANY: + case typelib_TypeClass_SEQUENCE: +- case typelib_TypeClass_STRUCT: + case typelib_TypeClass_INTERFACE: + exec = privateSnippetExecutorClass; ++ functionIndex |= 0x80000000; + break; + default: + exec = privateSnippetExecutorGeneral; +@@ -454,7 +490,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactor + code = codeSnippet( + code, writetoexecdiff, functionOffset++, vtableOffset, + reinterpret_cast< typelib_InterfaceAttributeTypeDescription * >( +- member)->pAttributeTypeRef->eTypeClass); ++ member)->pAttributeTypeRef); + // Setter: + if (!reinterpret_cast< + typelib_InterfaceAttributeTypeDescription * >( +@@ -463,7 +499,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactor + (s++)->fn = code + writetoexecdiff; + code = codeSnippet( + code, writetoexecdiff, functionOffset++, vtableOffset, +- typelib_TypeClass_VOID); ++ NULL); + } + break; + +@@ -472,7 +508,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactor + code = codeSnippet( + code, writetoexecdiff, functionOffset++, vtableOffset, + reinterpret_cast< typelib_InterfaceMethodTypeDescription * >( +- member)->pReturnTypeRef->eTypeClass); ++ member)->pReturnTypeRef); + break; + + default: +@@ -487,3 +523,5 @@ unsigned char * bridges::cpp_uno::shared::VtableFactor + void bridges::cpp_uno::shared::VtableFactory::flushCode( + unsigned char const *, unsigned char const *) + {} ++ ++/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/editors/openoffice3/patches/patch-bridges_source_cpp_uno_gcc3_linux_intel_share_hxx b/editors/openoffice3/patches/patch-bridges_source_cpp_uno_gcc3_linux_intel_share_hxx new file mode 100644 index 00000000000..0609c897f05 --- /dev/null +++ b/editors/openoffice3/patches/patch-bridges_source_cpp_uno_gcc3_linux_intel_share_hxx @@ -0,0 +1,14 @@ +$OpenBSD: patch-bridges_source_cpp_uno_gcc3_linux_intel_share_hxx,v 1.1 2010/12/10 23:25:35 robert Exp $ +--- bridges/source/cpp_uno/gcc3_linux_intel/share.hxx.orig.port Fri Nov 26 13:19:10 2010 ++++ bridges/source/cpp_uno/gcc3_linux_intel/share.hxx Fri Dec 10 10:59:25 2010 +@@ -87,4 +87,10 @@ void raiseException( + //================================================================================================== + void fillUnoException( + __cxa_exception * header, uno_Any *, uno_Mapping * pCpp2Uno ); ++ ++} ++ ++namespace x86 ++{ ++ bool isSimpleReturnType(typelib_TypeDescription * pTD, bool recursive = false); + } diff --git a/editors/openoffice3/patches/patch-bridges_source_cpp_uno_gcc3_linux_intel_uno2cpp_cxx b/editors/openoffice3/patches/patch-bridges_source_cpp_uno_gcc3_linux_intel_uno2cpp_cxx new file mode 100644 index 00000000000..4e0dc38b45f --- /dev/null +++ b/editors/openoffice3/patches/patch-bridges_source_cpp_uno_gcc3_linux_intel_uno2cpp_cxx @@ -0,0 +1,747 @@ +$OpenBSD: patch-bridges_source_cpp_uno_gcc3_linux_intel_uno2cpp_cxx,v 1.1 2010/12/10 23:25:35 robert Exp $ +--- bridges/source/cpp_uno/gcc3_linux_intel/uno2cpp.cxx.orig.port Fri Dec 10 11:01:04 2010 ++++ bridges/source/cpp_uno/gcc3_linux_intel/uno2cpp.cxx Fri Dec 10 11:01:12 2010 +@@ -1,3 +1,4 @@ ++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + /************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +@@ -58,7 +59,7 @@ void callVirtualMethod( + void * pAdjustedThisPtr, + sal_Int32 nVtableIndex, + void * pRegisterReturn, +- typelib_TypeClass eReturnType, ++ typelib_TypeDescription * pReturnTypeDescr, bool bSimpleReturn, + sal_Int32 * pStackLongs, + sal_Int32 nStackLongs ) __attribute__((noinline)); + +@@ -66,23 +67,23 @@ void callVirtualMethod( + void * pAdjustedThisPtr, + sal_Int32 nVtableIndex, + void * pRegisterReturn, +- typelib_TypeClass eReturnType, ++ typelib_TypeDescription * pReturnTypeDescr, bool bSimpleReturn, + sal_Int32 * pStackLongs, + sal_Int32 nStackLongs ) + { +- // parameter list is mixed list of * and values +- // reference parameters are pointers ++ // 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 !" ); ++ 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 edx = 0, eax = 0; // for register returns ++ volatile long edx = 0, eax = 0; // for register returns + void * stackptr; +- asm volatile ( ++ asm volatile ( + "mov %%esp, %6\n\t" + // preserve potential 128bit stack alignment + "and $0xfffffff0, %%esp\n\t" +@@ -91,326 +92,375 @@ void callVirtualMethod( + "and $0xf, %%eax\n\t" + "sub $0xc, %%eax\n\t" + "add %%eax, %%esp\n\t" +- // copy values +- "mov %0, %%eax\n\t" +- "mov %%eax, %%edx\n\t" +- "dec %%edx\n\t" +- "shl $2, %%edx\n\t" +- "add %1, %%edx\n" +- "Lcopy:\n\t" +- "pushl 0(%%edx)\n\t" +- "sub $4, %%edx\n\t" +- "dec %%eax\n\t" +- "jne Lcopy\n\t" +- // do the actual call +- "mov %2, %%edx\n\t" +- "mov 0(%%edx), %%edx\n\t" +- "mov %3, %%eax\n\t" +- "shl $2, %%eax\n\t" +- "add %%eax, %%edx\n\t" +- "mov 0(%%edx), %%edx\n\t" +- "call *%%edx\n\t" +- // save return registers +- "mov %%eax, %4\n\t" +- "mov %%edx, %5\n\t" +- // cleanup stack ++ // copy values ++ "mov %0, %%eax\n\t" ++ "mov %%eax, %%edx\n\t" ++ "dec %%edx\n\t" ++ "shl $2, %%edx\n\t" ++ "add %1, %%edx\n" ++ "Lcopy:\n\t" ++ "pushl 0(%%edx)\n\t" ++ "sub $4, %%edx\n\t" ++ "dec %%eax\n\t" ++ "jne Lcopy\n\t" ++ // do the actual call ++ "mov %2, %%edx\n\t" ++ "mov 0(%%edx), %%edx\n\t" ++ "mov %3, %%eax\n\t" ++ "shl $2, %%eax\n\t" ++ "add %%eax, %%edx\n\t" ++ "mov 0(%%edx), %%edx\n\t" ++ "call *%%edx\n\t" ++ // save return registers ++ "mov %%eax, %4\n\t" ++ "mov %%edx, %5\n\t" ++ // cleanup stack + "mov %6, %%esp\n\t" +- : ++ : + : "m"(nStackLongs), "m"(pStackLongs), "m"(pAdjustedThisPtr), + "m"(nVtableIndex), "m"(eax), "m"(edx), "m"(stackptr) + : "eax", "edx" ); +- switch( eReturnType ) +- { +- case typelib_TypeClass_HYPER: +- case typelib_TypeClass_UNSIGNED_HYPER: +- ((long*)pRegisterReturn)[1] = edx; +- case typelib_TypeClass_LONG: +- case typelib_TypeClass_UNSIGNED_LONG: +- case typelib_TypeClass_CHAR: +- case typelib_TypeClass_ENUM: +- ((long*)pRegisterReturn)[0] = eax; +- break; +- case typelib_TypeClass_SHORT: +- case typelib_TypeClass_UNSIGNED_SHORT: +- *(unsigned short*)pRegisterReturn = eax; +- break; +- case typelib_TypeClass_BOOLEAN: +- case typelib_TypeClass_BYTE: +- *(unsigned char*)pRegisterReturn = eax; +- break; +- case typelib_TypeClass_FLOAT: +- asm ( "fstps %0" : : "m"(*(char *)pRegisterReturn) ); +- break; +- case typelib_TypeClass_DOUBLE: +- asm ( "fstpl %0\n\t" : : "m"(*(char *)pRegisterReturn) ); +- break; ++ switch( pReturnTypeDescr->eTypeClass ) ++ { ++ case typelib_TypeClass_VOID: ++ break; ++ case typelib_TypeClass_HYPER: ++ case typelib_TypeClass_UNSIGNED_HYPER: ++ ((long*)pRegisterReturn)[1] = edx; ++ case typelib_TypeClass_LONG: ++ case typelib_TypeClass_UNSIGNED_LONG: ++ case typelib_TypeClass_CHAR: ++ case typelib_TypeClass_ENUM: ++ ((long*)pRegisterReturn)[0] = eax; ++ break; ++ case typelib_TypeClass_SHORT: ++ case typelib_TypeClass_UNSIGNED_SHORT: ++ *(unsigned short*)pRegisterReturn = eax; ++ break; ++ case typelib_TypeClass_BOOLEAN: ++ case typelib_TypeClass_BYTE: ++ *(unsigned char*)pRegisterReturn = eax; ++ break; ++ case typelib_TypeClass_FLOAT: ++ asm ( "fstps %0" : : "m"(*(char *)pRegisterReturn) ); ++ break; ++ case typelib_TypeClass_DOUBLE: ++ asm ( "fstpl %0\n\t" : : "m"(*(char *)pRegisterReturn) ); ++ break; + default: ++ { ++#if defined (FREEBSD) || defined(NETBSD) || defined(OPENBSD) || defined(MACOSX) ++ sal_Int32 const nRetSize = pReturnTypeDescr->nSize; ++ if (bSimpleReturn && nRetSize <= 8 && nRetSize > 0) ++ { ++ if (nRetSize > 4) ++ static_cast(pRegisterReturn)[1] = edx; ++ static_cast(pRegisterReturn)[0] = eax; ++ } ++#else ++ (void)bSimpleReturn; ++#endif + break; +- } ++ } ++ } + } + + //================================================================================================== + static void cpp_call( +- bridges::cpp_uno::shared::UnoInterfaceProxy * pThis, ++ 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 ) ++ typelib_TypeDescriptionReference * pReturnTypeRef, ++ sal_Int32 nParams, typelib_MethodParameter * pParams, ++ void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc ) + { +- // max space for: [complex ret ptr], values|ptr ... +- char * pCppStack = +- (char *)alloca( sizeof(sal_Int32) + ((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 +- } +- else +- { +- // complex return via ptr +- pCppReturn = *(void **)pCppStack ++ // max space for: [complex ret ptr], values|ptr ... ++ char * pCppStack = ++ (char *)alloca( sizeof(sal_Int32) + ((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 ++ bool bSimpleReturn = true; ++ ++ if (pReturnTypeDescr) ++ { ++ bSimpleReturn = x86::isSimpleReturnType(pReturnTypeDescr); ++ if (bSimpleReturn) ++ { ++ pCppReturn = pUnoReturn; // direct way for simple types ++ } ++ 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 ++ pCppStack += sizeof(void *); ++ } ++ } ++ // push this + void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI()) + + aVtableSlot.offset; +- *(void**)pCppStack = pAdjustedThisPtr; +- pCppStack += sizeof( void* ); ++ *(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 ++ // 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 )) +- { +- uno_copyAndConvertData( pCppArgs[nPos] = pCppStack, pUnoArgs[nPos], pParamTypeDescr, +- pThis->getBridge()->getUno2Cpp() ); +- +- switch (pParamTypeDescr->eTypeClass) +- { +- case typelib_TypeClass_HYPER: +- case typelib_TypeClass_UNSIGNED_HYPER: +- case typelib_TypeClass_DOUBLE: +- pCppStack += sizeof(sal_Int32); // extra long ++ { ++ uno_copyAndConvertData( pCppArgs[nPos] = pCppStack, pUnoArgs[nPos], pParamTypeDescr, ++ pThis->getBridge()->getUno2Cpp() ); ++ ++ switch (pParamTypeDescr->eTypeClass) ++ { ++ case typelib_TypeClass_HYPER: ++ case typelib_TypeClass_UNSIGNED_HYPER: ++ case typelib_TypeClass_DOUBLE: ++ pCppStack += sizeof(sal_Int32); // extra long + break; + default: + 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( ++ } ++ // 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, ++ { ++ 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 +- } ++ ++ 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 +- { +- 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... +- *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 (...) +- { +- // fill uno exception +- fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() ); ++ try ++ { ++ OSL_ENSURE( !( (pCppStack - pCppStackStart ) & 3), "UNALIGNED STACK !!! (Please DO panic)" ); ++ callVirtualMethod( ++ pAdjustedThisPtr, aVtableSlot.index, ++ pCppReturn, pReturnTypeDescr, bSimpleReturn, ++ (sal_Int32 *)pCppStackStart, (pCppStack - pCppStackStart) / sizeof(sal_Int32) ); ++ // NO exception occured... ++ *ppUnoExc = 0; + +- // 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 ); +- } ++ // 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 (...) ++ { ++ // fill uno 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 ); ++ } + } + + } + ++namespace x86 ++{ ++ bool isSimpleReturnType(typelib_TypeDescription * pTD, bool recursive) ++ { ++ if (bridges::cpp_uno::shared::isSimpleType( pTD )) ++ return true; ++#if defined (FREEBSD) || defined(NETBSD) || defined(OPENBSD) || defined(MACOSX) ++ // Only structs of exactly 1, 2, 4, or 8 bytes are returned through ++ // registers, see : ++ if (pTD->eTypeClass == typelib_TypeClass_STRUCT && ++ (recursive || pTD->nSize <= 2 || pTD->nSize == 4 || pTD->nSize == 8)) ++ { ++ typelib_CompoundTypeDescription *const pCompTD = ++ (typelib_CompoundTypeDescription *) pTD; ++ for ( sal_Int32 pos = pCompTD->nMembers; pos--; ) { ++ typelib_TypeDescription * pMemberTD = 0; ++ TYPELIB_DANGER_GET( &pMemberTD, pCompTD->ppTypeRefs[pos] ); ++ bool const b = isSimpleReturnType(pMemberTD, true); ++ TYPELIB_DANGER_RELEASE( pMemberTD ); ++ if (! b) ++ return false; ++ } ++ return true; ++ } ++#else ++ (void)recursive; ++#endif ++ return false; ++ } ++} ++ + namespace bridges { namespace cpp_uno { namespace shared { + + void unoInterfaceProxyDispatch( +- uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr, ++ uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr, + void * pReturn, void * pArgs[], uno_Any ** ppException ) + { +- // is my surrogate +- bridges::cpp_uno::shared::UnoInterfaceProxy * pThis ++ // is my surrogate ++ bridges::cpp_uno::shared::UnoInterfaceProxy * pThis + = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI); +- +- switch (pMemberDescr->eTypeClass) +- { +- case typelib_TypeClass_INTERFACE_ATTRIBUTE: +- { ++ ++ 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; ++ 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 ++ 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: +- { ++ 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) +- { ++ 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( +@@ -423,29 +473,31 @@ void unoInterfaceProxyDispatch( + } + 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 ); +- } +- } ++ } // 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 ); ++ } ++ } + } + + } } } ++ ++/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/editors/openoffice3/patches/patch-odk_configure_pl b/editors/openoffice3/patches/patch-odk_configure_pl index 5ee1ac500c6..2292d4c9fef 100644 --- a/editors/openoffice3/patches/patch-odk_configure_pl +++ b/editors/openoffice3/patches/patch-odk_configure_pl @@ -1,7 +1,7 @@ -$OpenBSD: patch-odk_configure_pl,v 1.4 2010/06/26 15:48:12 robert Exp $ ---- odk/configure.pl.orig.port Wed May 26 20:25:01 2010 -+++ odk/configure.pl Fri Jun 25 23:56:13 2010 -@@ -46,6 +46,10 @@ if ( $main::operatingSystem =~ m/solaris/ || +$OpenBSD: patch-odk_configure_pl,v 1.5 2010/12/10 23:25:35 robert Exp $ +--- odk/configure.pl.orig.port Fri Nov 26 13:29:19 2010 ++++ odk/configure.pl Fri Dec 10 10:55:06 2010 +@@ -47,6 +47,10 @@ if ( $main::operatingSystem =~ m/solaris/ || { $main::makeName = "gmake"; } diff --git a/editors/openoffice3/patches/patch-solenv_inc_settings_mk b/editors/openoffice3/patches/patch-solenv_inc_settings_mk index 277801313d6..195d0895fab 100644 --- a/editors/openoffice3/patches/patch-solenv_inc_settings_mk +++ b/editors/openoffice3/patches/patch-solenv_inc_settings_mk @@ -1,33 +1,12 @@ -$OpenBSD: patch-solenv_inc_settings_mk,v 1.6 2010/11/09 18:40:04 robert Exp $ ---- solenv/inc/settings.mk.orig.port Thu Oct 21 14:04:10 2010 -+++ solenv/inc/settings.mk Sun Oct 24 18:34:59 2010 -@@ -1024,9 +1024,9 @@ LNTFLAGSOUTOBJ=-os - # work at the start of a recipe line that is not prefixed by "+" as well as in - # the middle of an existing && chain: - AUGMENT_LIBRARY_PATH = : && \ -- $(OOO_LIBRARY_PATH_VAR)=$${{$(OOO_LIBRARY_PATH_VAR)+$${{$(OOO_LIBRARY_PATH_VAR)}}:}}$(normpath, $(SOLARSHAREDBIN)) -+ $(OOO_LIBRARY_PATH_VAR)=$${{$(OOO_LIBRARY_PATH_VAR)+$${{$(OOO_LIBRARY_PATH_VAR)}}:}}$(normpath, $(SOLARSHAREDBIN)):. - AUGMENT_LIBRARY_PATH_LOCAL = : && \ -- $(OOO_LIBRARY_PATH_VAR)=$${{$(OOO_LIBRARY_PATH_VAR)+$${{$(OOO_LIBRARY_PATH_VAR)}}:}}$(normpath, $(PWD)/$(DLLDEST)):$(normpath, $(SOLARSHAREDBIN)) -+ $(OOO_LIBRARY_PATH_VAR)=$${{$(OOO_LIBRARY_PATH_VAR)+$${{$(OOO_LIBRARY_PATH_VAR)}}:}}$(normpath, $(PWD)/$(DLLDEST)):$(normpath, $(SOLARSHAREDBIN)):. - .END - - # remove if .Net 2003 support has expired -@@ -1135,6 +1135,8 @@ CDEFS+=-DOSL_DEBUG_LEVEL=$(DBG_LEVEL) - RSCDEFS+=-DOSL_DEBUG_LEVEL=$(DBG_LEVEL) - .ENDIF - -+CFLAGS+= $(ENVCFLAGS) -+ - .IF "$(optimize)"!="" - CDEFS+=$(CDEFSOPT) - CFLAGS+=$(CFLAGSOPT) -@@ -1258,7 +1260,7 @@ CFLAGSAPPEND+=$(ENVWARNFLAGS) - - CDEFS+= $(ADDCDEFS) - CDEFS+= $(ENVCDEFS) --CFLAGS+= $(CFLAGSCALL) $(ENVCFLAGS) -+CFLAGS+= $(CFLAGSCALL) - CFLAGSCXX+= $(ENVCFLAGSCXX) - # andersrum wg. -TPxxxx - CFLAGSINCXX+:=$(ENVCFLAGSINCXX) +$OpenBSD: patch-solenv_inc_settings_mk,v 1.7 2010/12/10 23:25:35 robert Exp $ +--- solenv/inc/settings.mk.orig.port Fri Nov 26 13:33:40 2010 ++++ solenv/inc/settings.mk Fri Dec 10 10:58:50 2010 +@@ -1048,7 +1048,7 @@ EXTMAXPROCESS*=$(MAXPROCESS) + IDLC*=$(AUGMENT_LIBRARY_PATH) $(SOLARBINDIR)/idlc + REGMERGE*=$(AUGMENT_LIBRARY_PATH) $(SOLARBINDIR)/regmerge + REGCOMPARE*=$(AUGMENT_LIBRARY_PATH) $(SOLARBINDIR)/regcompare +-REGCOMP*=$(AUGMENT_LIBRARY_PATH) $(SOLARBINDIR)/regcomp ++REGCOMP*=$(AUGMENT_LIBRARY_PATH_LOCAL) $(SOLARBINDIR)/regcomp + CPPUMAKER*=$(AUGMENT_LIBRARY_PATH) $(SOLARBINDIR)/cppumaker + JAVAMAKER*=$(AUGMENT_LIBRARY_PATH) $(SOLARBINDIR)/javamaker + RDBMAKER*=$(AUGMENT_LIBRARY_PATH) $(SOLARBINDIR)/rdbmaker diff --git a/editors/openoffice3/patches/patch-testtools_source_bridgetest_makefile_mk b/editors/openoffice3/patches/patch-testtools_source_bridgetest_makefile_mk deleted file mode 100644 index 76103d4d676..00000000000 --- a/editors/openoffice3/patches/patch-testtools_source_bridgetest_makefile_mk +++ /dev/null @@ -1,12 +0,0 @@ -$OpenBSD: patch-testtools_source_bridgetest_makefile_mk,v 1.1 2010/11/09 18:40:04 robert Exp $ ---- testtools/source/bridgetest/makefile.mk.orig.port Thu Oct 28 10:56:53 2010 -+++ testtools/source/bridgetest/makefile.mk Thu Oct 28 10:57:23 2010 -@@ -131,7 +131,7 @@ ALLTAR: \ - ################################################################# - - runtest : $(DLLDEST)$/uno_types.rdb $(DLLDEST)$/uno_services.rdb makefile.mk --.IF "$(COM)$(OS)$(CPU)" == "GCCMACOSXP" -+.IF "$(COM)$(OS)$(CPU)" == "GCCMACOSXP" || "$(OS)" == "OPENBSD" - @echo "Mac OSX PPC GCC fails this test!, likely broken UNO bridge. Fix me." - .ELSE - cd $(DLLDEST) && $(AUGMENT_LIBRARY_PATH) $(SOLARBINDIR)/uno \