cppu/source/uno/data.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <cstddef>
  22 #include <stdio.h>
  23
  24 #include "cppu/macros.hxx"
  25
  26 #include "osl/mutex.hxx"
  27
  28 #include "constr.hxx"
  29 #include "destr.hxx"
  30 #include "copy.hxx"
  31 #include "assign.hxx"
  32 #include "eq.hxx"
  33
  34 #include "boost/static_assert.hpp"
  35
  36
  37 using namespace ::cppu;
  38 using namespace ::rtl;
  39 using namespace ::osl;
  40
  41
  42 namespace cppu
  43 {
  44
  45 // Sequence<>() (default ctor) relies on this being static:
  46 uno_Sequence g_emptySeq = { 1, 0, { 0 } };
  47 typelib_TypeDescriptionReference * g_pVoidType = 0;
  48
  49 //--------------------------------------------------------------------------------------------------
  50 void * binuno_queryInterface( void * pUnoI, typelib_TypeDescriptionReference * pDestType )
  51 {
  52     // init queryInterface() td
  53     static typelib_TypeDescription * g_pQITD = 0;
  54     if (0 == g_pQITD)
  55     {
  56         MutexGuard aGuard( Mutex::getGlobalMutex() );
  57         if (0 == g_pQITD)
  58         {
  59             typelib_TypeDescriptionReference * type_XInterface =
  60                 * typelib_static_type_getByTypeClass( typelib_TypeClass_INTERFACE );
  61             typelib_InterfaceTypeDescription * pTXInterfaceDescr = 0;
  62             TYPELIB_DANGER_GET( (typelib_TypeDescription **) &pTXInterfaceDescr, type_XInterface );
  63             OSL_ASSERT( pTXInterfaceDescr->ppAllMembers );
  64             typelib_typedescriptionreference_getDescription(
  65                 &g_pQITD, pTXInterfaceDescr->ppAllMembers[ 0 ] );
  66             TYPELIB_DANGER_RELEASE( (typelib_TypeDescription *) pTXInterfaceDescr );
  67         }
  68     }
  69
  70     uno_Any aRet, aExc;
  71     uno_Any * pExc = &aExc;
  72     void * aArgs[ 1 ];
  73     aArgs[ 0 ] = &pDestType;
  74     (*((uno_Interface *) pUnoI)->pDispatcher)(
  75         (uno_Interface *) pUnoI, g_pQITD, &aRet, aArgs, &pExc );
  76
  77     uno_Interface * ret = 0;
  78     if (0 == pExc)
  79     {
  80         typelib_TypeDescriptionReference * ret_type = aRet.pType;
  81         switch (ret_type->eTypeClass)
  82         {
  83         case typelib_TypeClass_VOID: // common case
  84             typelib_typedescriptionreference_release( ret_type );
  85             break;
  86         case typelib_TypeClass_INTERFACE:
  87             // tweaky... avoiding acquire/ release pair
  88             typelib_typedescriptionreference_release( ret_type );
  89             ret = (uno_Interface *) aRet.pReserved; // serving acquired interface
  90             break;
  91         default:
  92             _destructAny( &aRet, 0 );
  93             break;
  94         }
  95     }
  96     else
  97     {
  98 #if OSL_DEBUG_LEVEL > 1
  99         OUStringBuffer buf( 128 );
 100         buf.appendAscii(
 101             RTL_CONSTASCII_STRINGPARAM("### exception occurred querying for interface ") );
 102         buf.append( * reinterpret_cast< OUString const * >( &pDestType->pTypeName ) );
 103         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(": [") );
 104         buf.append( * reinterpret_cast< OUString const * >( &pExc->pType->pTypeName ) );
 105         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("] ") );
 106         // Message is very first member
 107         buf.append( * reinterpret_cast< OUString const * >( pExc->pData ) );
 108         OString cstr(
 109             OUStringToOString( buf.makeStringAndClear(), RTL_TEXTENCODING_ASCII_US ) );
 110         OSL_FAIL( cstr.getStr() );
 111 #endif
 112         uno_any_destruct( pExc, 0 );
 113     }
 114     return ret;
 115 }
 116
 117 //==================================================================================================
 118 void defaultConstructStruct(
 119     void * pMem,
 120     typelib_CompoundTypeDescription * pCompType )
 121     SAL_THROW(())
 122 {
 123     _defaultConstructStruct( pMem, pCompType );
 124 }
 125 //==================================================================================================
 126 void copyConstructStruct(
 127     void * pDest, void * pSource,
 128     typelib_CompoundTypeDescription * pTypeDescr,
 129     uno_AcquireFunc acquire, uno_Mapping * mapping )
 130     SAL_THROW(())
 131 {
 132     _copyConstructStruct( pDest, pSource, pTypeDescr, acquire, mapping );
 133 }
 134 //==================================================================================================
 135 void destructStruct(
 136     void * pValue,
 137     typelib_CompoundTypeDescription * pTypeDescr,
 138     uno_ReleaseFunc release )
 139     SAL_THROW(())
 140 {
 141     _destructStruct( pValue, pTypeDescr, release );
 142 }
 143 //==================================================================================================
 144 sal_Bool equalStruct(
 145     void * pDest, void *pSource,
 146     typelib_CompoundTypeDescription * pTypeDescr,
 147     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
 148     SAL_THROW(())
 149 {
 150     return _equalStruct( pDest, pSource, pTypeDescr, queryInterface, release );
 151 }
 152 //==================================================================================================
 153 sal_Bool assignStruct(
 154     void * pDest, void * pSource,
 155     typelib_CompoundTypeDescription * pTypeDescr,
 156     uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
 157     SAL_THROW(())
 158 {
 159     return _assignStruct( pDest, pSource, pTypeDescr, queryInterface, acquire, release );
 160 }
 161
 162 //==============================================================================
 163 uno_Sequence * copyConstructSequence(
 164     uno_Sequence * pSource,
 165     typelib_TypeDescriptionReference * pElementType,
 166     uno_AcquireFunc acquire, uno_Mapping * mapping )
 167 {
 168     return icopyConstructSequence( pSource, pElementType, acquire, mapping );
 169 }
 170
 171 //==============================================================================
 172 void destructSequence(
 173     uno_Sequence * pSequence,
 174     typelib_TypeDescriptionReference * pType,
 175     typelib_TypeDescription * pTypeDescr,
 176     uno_ReleaseFunc release )
 177 {
 178     idestructSequence( pSequence, pType, pTypeDescr, release );
 179 }
 180
 181 //==================================================================================================
 182 sal_Bool equalSequence(
 183     uno_Sequence * pDest, uno_Sequence * pSource,
 184     typelib_TypeDescriptionReference * pElementType,
 185     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
 186     SAL_THROW(())
 187 {
 188     return _equalSequence( pDest, pSource, pElementType, queryInterface, release );
 189 }
 190
 191 extern "C"
 192 {
 193 //##################################################################################################
 194 CPPU_DLLPUBLIC void SAL_CALL uno_type_constructData(
 195     void * pMem, typelib_TypeDescriptionReference * pType )
 196     SAL_THROW_EXTERN_C()
 197 {
 198     _defaultConstructData( pMem, pType, 0 );
 199 }
 200 //##################################################################################################
 201 CPPU_DLLPUBLIC void SAL_CALL uno_constructData(
 202     void * pMem, typelib_TypeDescription * pTypeDescr )
 203     SAL_THROW_EXTERN_C()
 204 {
 205     _defaultConstructData( pMem, pTypeDescr->pWeakRef, pTypeDescr );
 206 }
 207 //##################################################################################################
 208 CPPU_DLLPUBLIC void SAL_CALL uno_type_destructData(
 209     void * pValue, typelib_TypeDescriptionReference * pType,
 210     uno_ReleaseFunc release )
 211     SAL_THROW_EXTERN_C()
 212 {
 213     _destructData( pValue, pType, 0, release );
 214 }
 215 //##################################################################################################
 216 CPPU_DLLPUBLIC void SAL_CALL uno_destructData(
 217     void * pValue,
 218     typelib_TypeDescription * pTypeDescr,
 219     uno_ReleaseFunc release )
 220     SAL_THROW_EXTERN_C()
 221 {
 222     _destructData( pValue, pTypeDescr->pWeakRef, pTypeDescr, release );
 223 }
 224 //##################################################################################################
 225 CPPU_DLLPUBLIC void SAL_CALL uno_type_copyData(
 226     void * pDest, void * pSource,
 227     typelib_TypeDescriptionReference * pType,
 228     uno_AcquireFunc acquire )
 229     SAL_THROW_EXTERN_C()
 230 {
 231     _copyConstructData( pDest, pSource, pType, 0, acquire, 0 );
 232 }
 233 //##################################################################################################
 234 CPPU_DLLPUBLIC void SAL_CALL uno_copyData(
 235     void * pDest, void * pSource,
 236     typelib_TypeDescription * pTypeDescr,
 237     uno_AcquireFunc acquire )
 238     SAL_THROW_EXTERN_C()
 239 {
 240     _copyConstructData( pDest, pSource, pTypeDescr->pWeakRef, pTypeDescr, acquire, 0 );
 241 }
 242 //##################################################################################################
 243 CPPU_DLLPUBLIC void SAL_CALL uno_type_copyAndConvertData(
 244     void * pDest, void * pSource,
 245     typelib_TypeDescriptionReference * pType,
 246     uno_Mapping * mapping )
 247     SAL_THROW_EXTERN_C()
 248 {
 249     _copyConstructData( pDest, pSource, pType, 0, 0, mapping );
 250 }
 251 //##################################################################################################
 252 CPPU_DLLPUBLIC void SAL_CALL uno_copyAndConvertData(
 253     void * pDest, void * pSource,
 254     typelib_TypeDescription * pTypeDescr,
 255     uno_Mapping * mapping )
 256     SAL_THROW_EXTERN_C()
 257 {
 258     _copyConstructData( pDest, pSource, pTypeDescr->pWeakRef, pTypeDescr, 0, mapping );
 259 }
 260 //##################################################################################################
 261 CPPU_DLLPUBLIC sal_Bool SAL_CALL uno_type_equalData(
 262     void * pVal1, typelib_TypeDescriptionReference * pVal1Type,
 263     void * pVal2, typelib_TypeDescriptionReference * pVal2Type,
 264     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
 265     SAL_THROW_EXTERN_C()
 266 {
 267     return _equalData(
 268         pVal1, pVal1Type, 0,
 269         pVal2, pVal2Type,
 270         queryInterface, release );
 271 }
 272 //##################################################################################################
 273 CPPU_DLLPUBLIC sal_Bool SAL_CALL uno_equalData(
 274     void * pVal1, typelib_TypeDescription * pVal1TD,
 275     void * pVal2, typelib_TypeDescription * pVal2TD,
 276     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
 277     SAL_THROW_EXTERN_C()
 278 {
 279     return _equalData(
 280         pVal1, pVal1TD->pWeakRef, pVal1TD,
 281         pVal2, pVal2TD->pWeakRef,
 282         queryInterface, release );
 283 }
 284 //##################################################################################################
 285 CPPU_DLLPUBLIC sal_Bool SAL_CALL uno_type_assignData(
 286     void * pDest, typelib_TypeDescriptionReference * pDestType,
 287     void * pSource, typelib_TypeDescriptionReference * pSourceType,
 288     uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
 289     SAL_THROW_EXTERN_C()
 290 {
 291     return _assignData(
 292         pDest, pDestType, 0,
 293         pSource, pSourceType, 0,
 294         queryInterface, acquire, release );
 295 }
 296 //##################################################################################################
 297 CPPU_DLLPUBLIC sal_Bool SAL_CALL uno_assignData(
 298     void * pDest, typelib_TypeDescription * pDestTD,
 299     void * pSource, typelib_TypeDescription * pSourceTD,
 300     uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
 301     SAL_THROW_EXTERN_C()
 302 {
 303     return _assignData(
 304         pDest, pDestTD->pWeakRef, pDestTD,
 305         pSource, pSourceTD->pWeakRef, pSourceTD,
 306         queryInterface, acquire, release );
 307 }
 308 //##################################################################################################
 309 CPPU_DLLPUBLIC sal_Bool SAL_CALL uno_type_isAssignableFromData(
 310     typelib_TypeDescriptionReference * pAssignable,
 311     void * pFrom, typelib_TypeDescriptionReference * pFromType,
 312     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
 313     SAL_THROW_EXTERN_C()
 314 {
 315     if (::typelib_typedescriptionreference_isAssignableFrom( pAssignable, pFromType ))
 316         return sal_True;
 317     if (typelib_TypeClass_INTERFACE != pFromType->eTypeClass ||
 318         typelib_TypeClass_INTERFACE != pAssignable->eTypeClass)
 319     {
 320         return sal_False;
 321     }
 322
 323     // query
 324     if (0 == pFrom)
 325         return sal_False;
 326     void * pInterface = *(void **)pFrom;
 327     if (0 == pInterface)
 328         return sal_False;
 329
 330     if (0 == queryInterface)
 331         queryInterface = binuno_queryInterface;
 332     void * p = (*queryInterface)( pInterface, pAssignable );
 333     _release( p, release );
 334     return (0 != p);
 335 }
 336 }
 337
 338
 339 //##################################################################################################
 340 //##################################################################################################
 341 //##################################################################################################
 342
 343
 344 #if OSL_DEBUG_LEVEL > 1
 345
 346 #if defined( SAL_W32)
 347 #pragma pack(push, 8)
 348 #endif
 349
 350 // Why hardcode like this instead of using the (generated)
 351 // <sal/typesizes.h> ?
 352
 353 #if (defined(INTEL) \
 354     && (defined(__GNUC__) && (defined(LINUX) || defined(FREEBSD) || defined(NETBSD) || defined(OPENBSD)) \
 355         || defined(MACOSX) || defined(DRAGONFLY) || (defined(__SUNPRO_CC) && defined(SOLARIS)))) \
 356     || defined(IOS)
 357 #define MAX_ALIGNMENT_4
 358 #endif
 359
 360 #define OFFSET_OF( s, m ) reinterpret_cast< size_t >((char *)&((s *)16)->m -16)
 361
 362 #define BINTEST_VERIFY( c ) \
 363     if (! (c))      \
 364     {               \
 365         fprintf( stderr, "### binary compatibility test failed: %s [line %d]!!!\n", #c, __LINE__ ); \
 366         abort();    \
 367     }
 368
 369 #define BINTEST_VERIFYOFFSET( s, m, n ) \
 370     if (OFFSET_OF(s, m) != static_cast<size_t>(n))  \
 371     {                                               \
 372         fprintf(stderr, "### OFFSET_OF(" #s ", "  #m ") = %" SAL_PRI_SIZET "u instead of expected %" SAL_PRI_SIZET "u!!!\n", \
 373             OFFSET_OF(s, m), static_cast<size_t>(n));                    \
 374         abort();                                    \
 375     }
 376
 377 #define BINTEST_VERIFYSIZE( s, n ) \
 378     if (sizeof(s) != static_cast<size_t>(n))        \
 379     {                                               \
 380         fprintf(stderr, "### sizeof(" #s ") = %" SAL_PRI_SIZET "u instead of expected %" SAL_PRI_SIZET "u!!!\n", \
 381             sizeof(s), static_cast<size_t>(n));    \
 382         abort(); \
 383     }
 384
 385 struct C1
 386 {
 387     sal_Int16 n1;
 388 };
 389 struct C2 : public C1
 390 {
 391     sal_Int32 n2 CPPU_GCC3_ALIGN( C1 );
 392 };
 393 struct C3 : public C2
 394 {
 395     double d3;
 396     sal_Int32 n3;
 397 };
 398 struct C4 : public C3
 399 {
 400     sal_Int32 n4 CPPU_GCC3_ALIGN( C3 );
 401     double d4;
 402 };
 403 struct C5 : public C4
 404 {
 405     sal_Int64 n5;
 406     sal_Bool b5;
 407 };
 408 struct C6 : public C1
 409 {
 410     C5 c6 CPPU_GCC3_ALIGN( C1 );
 411     sal_Bool b6;
 412 };
 413
 414 struct D
 415 {
 416     sal_Int16 d;
 417     sal_Int32 e;
 418 };
 419 struct E
 420 {
 421     sal_Bool a;
 422     sal_Bool b;
 423     sal_Bool c;
 424     sal_Int16 d;
 425     sal_Int32 e;
 426 };
 427
 428 struct M
 429 {
 430     sal_Int32   n;
 431     sal_Int16   o;
 432 };
 433
 434 struct N : public M
 435 {
 436     sal_Int16   p CPPU_GCC3_ALIGN( M );
 437 };
 438 struct N2
 439 {
 440     M m;
 441     sal_Int16   p;
 442 };
 443
 444 struct O : public M
 445 {
 446     double  p;
 447     sal_Int16 q;
 448 };
 449 struct O2 : public O
 450 {
 451     sal_Int16 p2 CPPU_GCC3_ALIGN( O );
 452 };
 453
 454 struct P : public N
 455 {
 456     double  p2;
 457 };
 458
 459 struct empty
 460 {
 461 };
 462 struct second : public empty
 463 {
 464     int a;
 465 };
 466
 467 struct AlignSize_Impl
 468 {
 469     sal_Int16   nInt16;
 470     double      dDouble;
 471 };
 472
 473 struct Char1
 474 {
 475     char c1;
 476 };
 477 struct Char2 : public Char1
 478 {
 479     char c2 CPPU_GCC3_ALIGN( Char1 );
 480 };
 481 struct Char3 : public Char2
 482 {
 483     char c3 CPPU_GCC3_ALIGN( Char2 );
 484 };
 485 struct Char4
 486 {
 487     Char3 chars;
 488     char c;
 489 };
 490 class Ref
 491 {
 492     void * p;
 493 };
 494 enum Enum
 495 {
 496     v = SAL_MAX_ENUM
 497 };
 498
 499
 500 class BinaryCompatible_Impl
 501 {
 502 public:
 503     BinaryCompatible_Impl();
 504 };
 505 BinaryCompatible_Impl::BinaryCompatible_Impl()
 506 {
 507     BOOST_STATIC_ASSERT( ((sal_Bool) true) == sal_True &&
 508                          (1 != 0) == sal_True );
 509     BOOST_STATIC_ASSERT( ((sal_Bool) false) == sal_False &&
 510                          (1 == 0) == sal_False );
 511 #ifdef MAX_ALIGNMENT_4
 512     // max alignment is 4
 513     BINTEST_VERIFYOFFSET( AlignSize_Impl, dDouble, 4 );
 514     BINTEST_VERIFYSIZE( AlignSize_Impl, 12 );
 515 #else
 516     // max alignment is 8
 517     BINTEST_VERIFYOFFSET( AlignSize_Impl, dDouble, 8 );
 518     BINTEST_VERIFYSIZE( AlignSize_Impl, 16 );
 519 #endif
 520
 521     // sequence
 522     BINTEST_VERIFY( (SAL_SEQUENCE_HEADER_SIZE % 8) == 0 );
 523     // enum
 524     BINTEST_VERIFY( sizeof( Enum ) == sizeof( sal_Int32 ) );
 525     // any
 526     BINTEST_VERIFY( sizeof(void *) >= sizeof(sal_Int32) );
 527     BINTEST_VERIFY( sizeof( uno_Any ) == sizeof( void * ) * 3 );
 528     BINTEST_VERIFYOFFSET( uno_Any, pType, 0 );
 529     BINTEST_VERIFYOFFSET( uno_Any, pData, 1 * sizeof (void *) );
 530     BINTEST_VERIFYOFFSET( uno_Any, pReserved, 2 * sizeof (void *) );
 531     // interface
 532     BINTEST_VERIFY( sizeof( Ref ) == sizeof( void * ) );
 533     // string
 534     BINTEST_VERIFY( sizeof( OUString ) == sizeof( rtl_uString * ) );
 535     // struct
 536     BINTEST_VERIFYSIZE( M, 8 );
 537     BINTEST_VERIFYOFFSET( M, o, 4 );
 538     BINTEST_VERIFYSIZE( N, 12 );
 539     BINTEST_VERIFYOFFSET( N, p, 8 );
 540     BINTEST_VERIFYSIZE( N2, 12 );
 541     BINTEST_VERIFYOFFSET( N2, p, 8 );
 542 #ifdef MAX_ALIGNMENT_4
 543     BINTEST_VERIFYSIZE( O, 20 );
 544 #else
 545     BINTEST_VERIFYSIZE( O, 24 );
 546 #endif
 547     BINTEST_VERIFYSIZE( D, 8 );
 548     BINTEST_VERIFYOFFSET( D, e, 4 );
 549     BINTEST_VERIFYOFFSET( E, d, 4 );
 550     BINTEST_VERIFYOFFSET( E, e, 8 );
 551
 552     BINTEST_VERIFYSIZE( C1, 2 );
 553     BINTEST_VERIFYSIZE( C2, 8 );
 554     BINTEST_VERIFYOFFSET( C2, n2, 4 );
 555
 556 #ifdef MAX_ALIGNMENT_4
 557     BINTEST_VERIFYSIZE( C3, 20 );
 558     BINTEST_VERIFYOFFSET( C3, d3, 8 );
 559     BINTEST_VERIFYOFFSET( C3, n3, 16 );
 560     BINTEST_VERIFYSIZE( C4, 32 );
 561     BINTEST_VERIFYOFFSET( C4, n4, 20 );
 562     BINTEST_VERIFYOFFSET( C4, d4, 24 );
 563     BINTEST_VERIFYSIZE( C5, 44 );
 564     BINTEST_VERIFYOFFSET( C5, n5, 32 );
 565     BINTEST_VERIFYOFFSET( C5, b5, 40 );
 566     BINTEST_VERIFYSIZE( C6, 52 );
 567     BINTEST_VERIFYOFFSET( C6, c6, 4 );
 568     BINTEST_VERIFYOFFSET( C6, b6, 48 );
 569
 570     BINTEST_VERIFYSIZE( O2, 24 );
 571     BINTEST_VERIFYOFFSET( O2, p2, 20 );
 572 #else
 573     BINTEST_VERIFYSIZE( C3, 24 );
 574     BINTEST_VERIFYOFFSET( C3, d3, 8 );
 575     BINTEST_VERIFYOFFSET( C3, n3, 16 );
 576     BINTEST_VERIFYSIZE( C4, 40 );
 577     BINTEST_VERIFYOFFSET( C4, n4, 24 );
 578     BINTEST_VERIFYOFFSET( C4, d4, 32 );
 579     BINTEST_VERIFYSIZE( C5, 56 );
 580     BINTEST_VERIFYOFFSET( C5, n5, 40 );
 581     BINTEST_VERIFYOFFSET( C5, b5, 48 );
 582     BINTEST_VERIFYSIZE( C6, 72 );
 583     BINTEST_VERIFYOFFSET( C6, c6, 8 );
 584     BINTEST_VERIFYOFFSET( C6, b6, 64 );
 585
 586     BINTEST_VERIFYSIZE( O2, 32 );
 587     BINTEST_VERIFYOFFSET( O2, p2, 24 );
 588 #endif
 589
 590     BINTEST_VERIFYSIZE( Char3, 3 );
 591     BINTEST_VERIFYOFFSET( Char4, c, 3 );
 592
 593 #ifdef MAX_ALIGNMENT_4
 594     // max alignment is 4
 595     BINTEST_VERIFYSIZE( P, 20 );
 596 #else
 597     // alignment of P is 8, because of P[] ...
 598     BINTEST_VERIFYSIZE( P, 24 );
 599     BINTEST_VERIFYSIZE( second, sizeof( int ) );
 600 #endif
 601 }
 602
 603 #ifdef SAL_W32
 604 #   pragma pack(pop)
 605 #endif
 606
 607 static BinaryCompatible_Impl aTest;
 608
 609 #endif
 610
 611 }
 612
 613 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */