bridges/source/cpp_uno/gcc3_linux_s390x/cpp2uno.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: cpp2uno.cxx,v $
  10  *
  11  * $Revision: 1.3 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_bridges.hxx"
  34
  35 #include <com/sun/star/uno/genfunc.hxx>
  36 #include <uno/data.h>
  37 #include <typelib/typedescription.hxx>
  38
  39 #include "bridges/cpp_uno/shared/bridge.hxx"
  40 #include "bridges/cpp_uno/shared/cppinterfaceproxy.hxx"
  41 #include "bridges/cpp_uno/shared/types.hxx"
  42 #include "bridges/cpp_uno/shared/vtablefactory.hxx"
  43
  44 #include "share.hxx"
  45 #include <stdio.h>
  46
  47 using namespace ::com::sun::star::uno;
  48
  49 namespace
  50 {
  51 static typelib_TypeClass cpp2uno_call(
  52     bridges::cpp_uno::shared::CppInterfaceProxy * pThis,
  53     const typelib_TypeDescription * pMemberTypeDescr,
  54     typelib_TypeDescriptionReference * pReturnTypeRef, // 0 indicates void return
  55     sal_Int32 nParams, typelib_MethodParameter * pParams,
  56         void ** gpreg, void ** fpreg, void ** ovrflw,
  57     sal_Int64 * pRegisterReturn /* space for register return */ )
  58 {
  59 #ifdef CMC_DEBUG
  60     fprintf(stderr, "as far as cpp2uno_call\n");
  61 #endif
  62     int ng = 0; //number of gpr registers used
  63     int nf = 0; //number of fpr regsiters used
  64
  65     // gpreg:  [ret *], this, [gpr params]
  66     // fpreg:  [fpr params]
  67     // ovrflw: [gpr or fpr params (properly aligned)]
  68
  69     // return
  70     typelib_TypeDescription * pReturnTypeDescr = 0;
  71     if (pReturnTypeRef)
  72         TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
  73
  74     void * pUnoReturn = 0;
  75     void * pCppReturn = 0; // complex return ptr: if != 0 && != pUnoReturn, reconversion need
  76
  77     if (pReturnTypeDescr)
  78     {
  79         if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
  80         {
  81             pUnoReturn = pRegisterReturn; // direct way for simple types
  82         }
  83         else // complex return via ptr (pCppReturn)
  84         {
  85             pCppReturn = *(void **)gpreg;
  86             gpreg++;
  87             ng++;
  88
  89             pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
  90                           ? alloca( pReturnTypeDescr->nSize )
  91                           : pCppReturn); // direct way
  92         }
  93     }
  94     // pop this
  95     gpreg++;
  96     ng++;
  97
  98     // stack space
  99     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int64), "### unexpected size!" );
 100     // parameters
 101     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
 102     void ** pCppArgs = pUnoArgs + nParams;
 103     // indizes of values this have to be converted (interface conversion cpp<=>uno)
 104     sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
 105     // type descriptions for reconversions
 106     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 107
 108     sal_Int32 nTempIndizes   = 0;
 109     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
 110     {
 111         const typelib_MethodParameter & rParam = pParams[nPos];
 112         typelib_TypeDescription * pParamTypeDescr = 0;
 113         TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
 114
 115 #ifdef CMC_DEBUG
 116         fprintf(stderr, "arg %d of %d\n", nPos, nParams);
 117 #endif
 118
 119         if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr )) // value
 120         {
 121 #ifdef CMC_DEBUG
 122             fprintf(stderr, "simple\n");
 123 #endif
 124
 125             switch (pParamTypeDescr->eTypeClass)
 126             {
 127                 case typelib_TypeClass_FLOAT:
 128                 case typelib_TypeClass_DOUBLE:
 129                     if (nf < s390x::MAX_SSE_REGS)
 130                     {
 131                         if (pParamTypeDescr->eTypeClass == typelib_TypeClass_FLOAT)
 132                         {
 133                             float tmp = (float) (*((double *)fpreg));
 134                             (*((float *) fpreg)) = tmp;
 135                         }
 136
 137                         pCppArgs[nPos] = pUnoArgs[nPos] = fpreg++;
 138                         nf++;
 139                     }
 140                     else
 141                     {
 142                         pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw;
 143                         ovrflw++;
 144                     }
 145                     break;
 146                 case typelib_TypeClass_BYTE:
 147                 case typelib_TypeClass_BOOLEAN:
 148                     if (ng < s390x::MAX_GPR_REGS)
 149                     {
 150                         pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)gpreg) + (sizeof(void*)-1));
 151                         ng++;
 152                         gpreg++;
 153                     }
 154                     else
 155                     {
 156                         pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)ovrflw) + (sizeof(void*)-1));
 157                         ovrflw++;
 158                     }
 159                     break;
 160                 case typelib_TypeClass_CHAR:
 161                 case typelib_TypeClass_SHORT:
 162                 case typelib_TypeClass_UNSIGNED_SHORT:
 163                     if (ng < s390x::MAX_GPR_REGS)
 164                     {
 165                         pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)gpreg) + (sizeof(void*)-2));
 166                         ng++;
 167                         gpreg++;
 168                     }
 169                     else
 170                     {
 171                         pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)ovrflw) + (sizeof(void*)-2));
 172                         ovrflw++;
 173                     }
 174                     break;
 175                 case typelib_TypeClass_ENUM:
 176                 case typelib_TypeClass_LONG:
 177                 case typelib_TypeClass_UNSIGNED_LONG:
 178                     if (ng < s390x::MAX_GPR_REGS)
 179                     {
 180                         pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)gpreg) + (sizeof(void*)-4));
 181                         ng++;
 182                         gpreg++;
 183                     }
 184                     else
 185                     {
 186                         pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)ovrflw) + (sizeof(void*)-4));
 187                         ovrflw++;
 188                     }
 189                     break;
 190                 default:
 191                     if (ng < s390x::MAX_GPR_REGS)
 192                     {
 193                         pCppArgs[nPos] = pUnoArgs[nPos] = gpreg++;
 194                         ng++;
 195                     }
 196                     else
 197                     {
 198                         pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw;
 199                         ovrflw++;
 200                     }
 201                     break;
 202             }
 203
 204             // no longer needed
 205             TYPELIB_DANGER_RELEASE( pParamTypeDescr );
 206         }
 207         else // ptr to complex value | ref
 208         {
 209 #ifdef CMC_DEBUG
 210             fprintf(stderr, "complex, ng is %d\n", ng);
 211 #endif
 212
 213             void *pCppStack; //temporary stack pointer
 214
 215             if (ng < s390x::MAX_GPR_REGS)
 216             {
 217                 pCppArgs[nPos] = pCppStack = *gpreg++;
 218                 ng++;
 219             }
 220             else
 221             {
 222                 pCppArgs[nPos] = pCppStack = *ovrflw;
 223                 ovrflw++;
 224             }
 225
 226             if (! rParam.bIn) // is pure out
 227             {
 228                 // uno out is unconstructed mem!
 229                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
 230                 pTempIndizes[nTempIndizes] = nPos;
 231                 // will be released at reconversion
 232                 ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
 233             }
 234             // is in/inout
 235             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
 236             {
 237                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
 238                                         pCppStack, pParamTypeDescr,
 239                                         pThis->getBridge()->getCpp2Uno() );
 240                 pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
 241                 // will be released at reconversion
 242                 ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
 243             }
 244             else // direct way
 245             {
 246                 pUnoArgs[nPos] = pCppStack;
 247                 // no longer needed
 248                 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
 249             }
 250         }
 251     }
 252
 253 #ifdef CMC_DEBUG
 254     fprintf(stderr, "end of params\n");
 255 #endif
 256
 257     // ExceptionHolder
 258     uno_Any aUnoExc; // Any will be constructed by callee
 259     uno_Any * pUnoExc = &aUnoExc;
 260
 261     // invoke uno dispatch call
 262     (*pThis->getUnoI()->pDispatcher)( pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
 263
 264     // in case an exception occured...
 265     if (pUnoExc)
 266     {
 267         // destruct temporary in/inout params
 268         for ( ; nTempIndizes--; )
 269         {
 270             sal_Int32 nIndex = pTempIndizes[nTempIndizes];
 271
 272             if (pParams[nIndex].bIn) // is in/inout => was constructed
 273                 uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
 274             TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
 275         }
 276         if (pReturnTypeDescr)
 277             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
 278
 279         CPPU_CURRENT_NAMESPACE::raiseException( &aUnoExc, pThis->getBridge()->getUno2Cpp() ); // has to destruct the any
 280         // is here for dummy
 281         return typelib_TypeClass_VOID;
 282     }
 283     else // else no exception occured...
 284     {
 285         // temporary params
 286         for ( ; nTempIndizes--; )
 287         {
 288             sal_Int32 nIndex = pTempIndizes[nTempIndizes];
 289             typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
 290
 291             if (pParams[nIndex].bOut) // inout/out
 292             {
 293                 // convert and assign
 294                 uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
 295                 uno_copyAndConvertData( pCppArgs[nIndex], pUnoArgs[nIndex], pParamTypeDescr,
 296                                         pThis->getBridge()->getUno2Cpp() );
 297             }
 298             // destroy temp uno param
 299             uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 );
 300
 301             TYPELIB_DANGER_RELEASE( pParamTypeDescr );
 302         }
 303         // return
 304         if (pCppReturn) // has complex return
 305         {
 306             if (pUnoReturn != pCppReturn) // needs reconversion
 307             {
 308                 uno_copyAndConvertData( pCppReturn, pUnoReturn, pReturnTypeDescr,
 309                                         pThis->getBridge()->getUno2Cpp() );
 310                 // destroy temp uno return
 311                 uno_destructData( pUnoReturn, pReturnTypeDescr, 0 );
 312             }
 313             // complex return ptr is set to return reg
 314             *(void **)pRegisterReturn = pCppReturn;
 315         }
 316         if (pReturnTypeDescr)
 317         {
 318             typelib_TypeClass eRet = (typelib_TypeClass)pReturnTypeDescr->eTypeClass;
 319             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
 320             return eRet;
 321         }
 322         else
 323             return typelib_TypeClass_VOID;
 324     }
 325 }
 326
 327
 328 //============================================================================
 329 static typelib_TypeClass cpp_mediate(
 330     sal_uInt64 nOffsetAndIndex,
 331     void ** gpreg, void ** fpreg, void ** ovrflw,
 332     sal_Int64 * pRegisterReturn /* space for register return */ )
 333 {
 334     OSL_ENSURE( sizeof(sal_Int64)==sizeof(void *), "### unexpected!" );
 335
 336     sal_Int32 nVtableOffset = (nOffsetAndIndex >> 32);
 337     sal_Int32 nFunctionIndex = (nOffsetAndIndex & 0xFFFFFFFF);
 338
 339 #ifdef CMC_DEBUG
 340     fprintf(stderr, "nVTableOffset, nFunctionIndex are %x %x\n", nVtableOffset, nFunctionIndex);
 341 #endif
 342
 343 #ifdef CMC_DEBUG
 344         // Let's figure out what is really going on here
 345         {
 346             fprintf( stderr, "= cpp_mediate () =\nGPR's (%d): ", 5 );
 347             for ( unsigned int i = 0; i < 5; ++i )
 348                 fprintf( stderr, "0x%lx, ", gpreg[i] );
 349             fprintf( stderr, "\n");
 350             fprintf( stderr, "\nFPR's (%d): ", 4 );
 351             for ( unsigned int i = 0; i < 4; ++i )
 352                 fprintf( stderr, "0x%lx (%f), ", fpreg[i], fpreg[i] );
 353             fprintf( stderr, "\n");
 354         }
 355 #endif
 356
 357
 358     // gpreg:  [ret *], this, [other gpr params]
 359     // fpreg:  [fpr params]
 360     // ovrflw: [gpr or fpr params (properly aligned)]
 361
 362     // _this_ ptr is patched cppu_XInterfaceProxy object
 363     void * pThis;
 364     if( nFunctionIndex & 0x80000000 )
 365     {
 366         nFunctionIndex &= 0x7fffffff;
 367         pThis = gpreg[1];
 368     }
 369     else
 370     {
 371         pThis = gpreg[0];
 372     }
 373
 374     pThis = static_cast< char * >(pThis) - nVtableOffset;
 375
 376     bridges::cpp_uno::shared::CppInterfaceProxy * pCppI
 377         = bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(
 378             pThis);
 379
 380     typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
 381
 382
 383     OSL_ENSURE( nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
 384     if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)
 385     {
 386         throw RuntimeException(
 387             rtl::OUString::createFromAscii("illegal vtable index!"),
 388             (XInterface *)pCppI );
 389     }
 390
 391     // determine called method
 392     OSL_ENSURE( nVtableCall < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
 393     sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
 394     OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### illegal member index!" );
 395
 396     TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );
 397
 398     typelib_TypeClass eRet;
 399     switch (aMemberDescr.get()->eTypeClass)
 400     {
 401     case typelib_TypeClass_INTERFACE_ATTRIBUTE:
 402     {
 403         if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex)
 404         {
 405             // is GET method
 406             eRet = cpp2uno_call(
 407                 pCppI, aMemberDescr.get(),
 408                 ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef,
 409                 0, 0, // no params
 410                 gpreg, fpreg, ovrflw, pRegisterReturn );
 411         }
 412         else
 413         {
 414             // is SET method
 415             typelib_MethodParameter aParam;
 416             aParam.pTypeRef =
 417                 ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef;
 418             aParam.bIn      = sal_True;
 419             aParam.bOut     = sal_False;
 420
 421             eRet = cpp2uno_call(
 422                 pCppI, aMemberDescr.get(),
 423                 0, // indicates void return
 424                 1, &aParam,
 425                 gpreg, fpreg, ovrflw, pRegisterReturn );
 426         }
 427         break;
 428     }
 429     case typelib_TypeClass_INTERFACE_METHOD:
 430     {
 431         // is METHOD
 432         switch (nFunctionIndex)
 433         {
 434         case 1: // acquire()
 435             pCppI->acquireProxy(); // non virtual call!
 436             eRet = typelib_TypeClass_VOID;
 437             break;
 438         case 2: // release()
 439             pCppI->releaseProxy(); // non virtual call!
 440             eRet = typelib_TypeClass_VOID;
 441             break;
 442         case 0: // queryInterface() opt
 443         {
 444             typelib_TypeDescription * pTD = 0;
 445             TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( gpreg[2] )->getTypeLibType() );
 446             if (pTD)
 447             {
 448                 XInterface * pInterface = 0;
 449                 (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)(
 450                     pCppI->getBridge()->getCppEnv(),
 451                     (void **)&pInterface, pCppI->getOid().pData,
 452                     (typelib_InterfaceTypeDescription *)pTD );
 453
 454                 if (pInterface)
 455                 {
 456                     ::uno_any_construct(
 457                         reinterpret_cast< uno_Any * >( gpreg[0] ),
 458                         &pInterface, pTD, cpp_acquire );
 459                     pInterface->release();
 460                     TYPELIB_DANGER_RELEASE( pTD );
 461                     *(void **)pRegisterReturn = gpreg[0];
 462                     eRet = typelib_TypeClass_ANY;
 463                     break;
 464                 }
 465                 TYPELIB_DANGER_RELEASE( pTD );
 466             }
 467         } // else perform queryInterface()
 468         default:
 469             eRet = cpp2uno_call(
 470                 pCppI, aMemberDescr.get(),
 471                 ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pReturnTypeRef,
 472                 ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->nParams,
 473                 ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pParams,
 474                 gpreg, fpreg, ovrflw, pRegisterReturn );
 475         }
 476         break;
 477     }
 478     default:
 479     {
 480         throw RuntimeException(
 481             rtl::OUString::createFromAscii("no member description found!"),
 482             (XInterface *)pCppI );
 483         // is here for dummy
 484         eRet = typelib_TypeClass_VOID;
 485     }
 486     }
 487
 488     return eRet;
 489 }
 490
 491 long privateSnippetExecutor(long r2, long r3, long r4, long r5, long r6, long firstonstack)
 492 {
 493     register long r0 asm("r0");
 494     sal_uInt32 nOffsetAndIndex = r0;
 495
 496     long sp = (long)&firstonstack;
 497
 498     sal_uInt64 gpreg[s390x::MAX_GPR_REGS];
 499     gpreg[0] = r2;
 500     gpreg[1] = r3;
 501     gpreg[2] = r4;
 502     gpreg[3] = r5;
 503     gpreg[4] = r6;
 504
 505     double fpreg[s390x::MAX_SSE_REGS];
 506     register double f0  asm("f0");  fpreg[0] = f0;
 507     register double f2  asm("f2");  fpreg[1] = f2;
 508     register double f4  asm("f4");  fpreg[2] = f4;
 509     register double f6  asm("f6");  fpreg[3] = f6;
 510
 511     volatile long nRegReturn[1];
 512 #ifdef CMC_DEBUG
 513     fprintf(stderr, "before mediate with %lx\n",nOffsetAndIndex);
 514     fprintf(stderr, "doubles are %f %f %f %f\n", fpreg[0], fpreg[1], fpreg[2], fpreg[3]);
 515 #endif
 516     typelib_TypeClass aType =
 517         cpp_mediate( nOffsetAndIndex, (void**)gpreg, (void**)fpreg, (void**)sp,
 518             (sal_Int64*)nRegReturn );
 519 #ifdef CMC_DEBUG
 520     fprintf(stderr, "after mediate ret is %lx %ld\n", nRegReturn[0], nRegReturn[0]);
 521 #endif
 522
 523     switch( aType )
 524     {
 525         case typelib_TypeClass_VOID:
 526         case typelib_TypeClass_BOOLEAN:
 527         case typelib_TypeClass_BYTE:
 528         case typelib_TypeClass_CHAR:
 529         case typelib_TypeClass_UNSIGNED_SHORT:
 530         case typelib_TypeClass_SHORT:
 531         case typelib_TypeClass_ENUM:
 532         case typelib_TypeClass_UNSIGNED_LONG:
 533         case typelib_TypeClass_LONG:
 534         default:
 535             break;
 536         case typelib_TypeClass_FLOAT:
 537             {
 538                 double tmp = (double) (*((float *)nRegReturn));
 539                 (*((double *) nRegReturn)) = tmp;
 540             }
 541             //deliberate fall through
 542         case typelib_TypeClass_DOUBLE:
 543             __asm__ ( "ld 0,%0\n\t"
 544                 : : "m" (*((double*)nRegReturn)) );
 545             break;
 546     }
 547     return nRegReturn[0];
 548 }
 549
 550 const int codeSnippetSize = 32;
 551
 552 unsigned char *codeSnippet( unsigned char * code, sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset, bool simple_ret_type )
 553 {
 554     sal_uInt64 nOffsetAndIndex = ( ( (sal_uInt64) nVtableOffset ) << 32 ) | ( (sal_Int64) nFunctionIndex );
 555
 556     if (! simple_ret_type)
 557         nOffsetAndIndex |= 0x80000000;
 558
 559     unsigned char * p = code;
 560     *(short *)&p[0] = 0x0d10;   /* basr %r1,0 */
 561     *(short *)&p[2] = 0xeb01;   /* lmg %r0,%r1,14(%r1) */
 562     *(short *)&p[4] = 0x100e;
 563     *(short *)&p[6] = 0x0004;
 564     *(short *)&p[8] = 0x07f1;   /* br %r1 */
 565     *(long  *)&p[16] = (long)nOffsetAndIndex;
 566     *(long  *)&p[24] = (long)&privateSnippetExecutor;
 567     return (code + codeSnippetSize);
 568 }
 569 }
 570
 571 void bridges::cpp_uno::shared::VtableFactory::flushCode(unsigned char const *, unsigned char const *)
 572 {
 573 }
 574
 575 struct bridges::cpp_uno::shared::VtableFactory::Slot { void * fn; };
 576
 577 bridges::cpp_uno::shared::VtableFactory::Slot *
 578 bridges::cpp_uno::shared::VtableFactory::mapBlockToVtable(void * block)
 579 {
 580     return static_cast< Slot * >(block) + 2;
 581 }
 582
 583 sal_Size bridges::cpp_uno::shared::VtableFactory::getBlockSize(
 584     sal_Int32 slotCount)
 585 {
 586     return (slotCount + 2) * sizeof (Slot) + slotCount * codeSnippetSize;
 587 }
 588
 589 bridges::cpp_uno::shared::VtableFactory::Slot *
 590 bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 591     void * block, sal_Int32 slotCount)
 592 {
 593     Slot * slots = mapBlockToVtable(block);
 594     slots[-2].fn = 0;
 595     slots[-1].fn = 0;
 596     return slots + slotCount;
 597 }
 598
 599 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
 600     Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
 601     typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
 602     sal_Int32 functionCount, sal_Int32 vtableOffset)
 603 {
 604     (*slots) -= functionCount;
 605     Slot * s = *slots;
 606 #ifdef CMC_DEBUG
 607     fprintf(stderr, "in addLocalFunctions functionOffset is %x\n",functionOffset);
 608     fprintf(stderr, "in addLocalFunctions vtableOffset is %x\n",vtableOffset);
 609 #endif
 610
 611     for (sal_Int32 i = 0; i < type->nMembers; ++i) {
 612         typelib_TypeDescription * member = 0;
 613         TYPELIB_DANGER_GET(&member, type->ppMembers[i]);
 614         OSL_ASSERT(member != 0);
 615         switch (member->eTypeClass) {
 616         case typelib_TypeClass_INTERFACE_ATTRIBUTE:
 617             // Getter:
 618             (s++)->fn = code + writetoexecdiff;
 619             code = codeSnippet(
 620                 code, functionOffset++, vtableOffset,
 621                 bridges::cpp_uno::shared::isSimpleType(
 622                     reinterpret_cast<
 623                     typelib_InterfaceAttributeTypeDescription * >(
 624                         member)->pAttributeTypeRef));
 625
 626             // Setter:
 627             if (!reinterpret_cast<
 628                 typelib_InterfaceAttributeTypeDescription * >(
 629                     member)->bReadOnly)
 630             {
 631                 (s++)->fn = code + writetoexecdiff;
 632                 code = codeSnippet(code, functionOffset++, vtableOffset, true);
 633             }
 634             break;
 635
 636         case typelib_TypeClass_INTERFACE_METHOD:
 637             (s++)->fn = code + writetoexecdiff;
 638             code = codeSnippet(
 639                 code, functionOffset++, vtableOffset,
 640                 bridges::cpp_uno::shared::isSimpleType(
 641                     reinterpret_cast<
 642                     typelib_InterfaceMethodTypeDescription * >(
 643                         member)->pReturnTypeRef));
 644             break;
 645
 646         default:
 647             OSL_ASSERT(false);
 648             break;
 649         }
 650         TYPELIB_DANGER_RELEASE(member);
 651     }
 652     return code;
 653 }
 654
 655 /* vi:set tabstop=4 shiftwidth=4 expandtab: */