LCOV - code coverage report
Current view: top level - libreoffice/cppu/source/uno - data.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 71 93 76.3 %
Date: 2012-12-27 Functions: 19 22 86.4 %
Legend: Lines: hit not hit

          Line data    Source code
       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        1662 : void * binuno_queryInterface( void * pUnoI, typelib_TypeDescriptionReference * pDestType )
      51             : {
      52             :     // init queryInterface() td
      53             :     static typelib_TypeDescription * g_pQITD = 0;
      54        1662 :     if (0 == g_pQITD)
      55             :     {
      56          18 :         MutexGuard aGuard( Mutex::getGlobalMutex() );
      57          18 :         if (0 == g_pQITD)
      58             :         {
      59             :             typelib_TypeDescriptionReference * type_XInterface =
      60          18 :                 * typelib_static_type_getByTypeClass( typelib_TypeClass_INTERFACE );
      61          18 :             typelib_InterfaceTypeDescription * pTXInterfaceDescr = 0;
      62          18 :             TYPELIB_DANGER_GET( (typelib_TypeDescription **) &pTXInterfaceDescr, type_XInterface );
      63             :             OSL_ASSERT( pTXInterfaceDescr->ppAllMembers );
      64             :             typelib_typedescriptionreference_getDescription(
      65          18 :                 &g_pQITD, pTXInterfaceDescr->ppAllMembers[ 0 ] );
      66          18 :             TYPELIB_DANGER_RELEASE( (typelib_TypeDescription *) pTXInterfaceDescr );
      67          18 :         }
      68             :     }
      69             : 
      70             :     uno_Any aRet, aExc;
      71        1662 :     uno_Any * pExc = &aExc;
      72             :     void * aArgs[ 1 ];
      73        1662 :     aArgs[ 0 ] = &pDestType;
      74             :     (*((uno_Interface *) pUnoI)->pDispatcher)(
      75        1662 :         (uno_Interface *) pUnoI, g_pQITD, &aRet, aArgs, &pExc );
      76             : 
      77        1662 :     uno_Interface * ret = 0;
      78        1662 :     if (0 == pExc)
      79             :     {
      80        1662 :         typelib_TypeDescriptionReference * ret_type = aRet.pType;
      81        1662 :         switch (ret_type->eTypeClass)
      82             :         {
      83             :         case typelib_TypeClass_VOID: // common case
      84           0 :             typelib_typedescriptionreference_release( ret_type );
      85           0 :             break;
      86             :         case typelib_TypeClass_INTERFACE:
      87             :             // tweaky... avoiding acquire/ release pair
      88        1662 :             typelib_typedescriptionreference_release( ret_type );
      89        1662 :             ret = (uno_Interface *) aRet.pReserved; // serving acquired interface
      90        1662 :             break;
      91             :         default:
      92           0 :             _destructAny( &aRet, 0 );
      93           0 :             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           0 :         uno_any_destruct( pExc, 0 );
     113             :     }
     114        1662 :     return ret;
     115             : }
     116             : 
     117             : //==================================================================================================
     118       23496 : void defaultConstructStruct(
     119             :     void * pMem,
     120             :     typelib_CompoundTypeDescription * pCompType )
     121             :     SAL_THROW(())
     122             : {
     123       23496 :     _defaultConstructStruct( pMem, pCompType );
     124       23496 : }
     125             : //==================================================================================================
     126       59120 : void copyConstructStruct(
     127             :     void * pDest, void * pSource,
     128             :     typelib_CompoundTypeDescription * pTypeDescr,
     129             :     uno_AcquireFunc acquire, uno_Mapping * mapping )
     130             :     SAL_THROW(())
     131             : {
     132       59120 :     _copyConstructStruct( pDest, pSource, pTypeDescr, acquire, mapping );
     133       59120 : }
     134             : //==================================================================================================
     135       83274 : void destructStruct(
     136             :     void * pValue,
     137             :     typelib_CompoundTypeDescription * pTypeDescr,
     138             :     uno_ReleaseFunc release )
     139             :     SAL_THROW(())
     140             : {
     141       83274 :     _destructStruct( pValue, pTypeDescr, release );
     142       83274 : }
     143             : //==================================================================================================
     144          32 : sal_Bool equalStruct(
     145             :     void * pDest, void *pSource,
     146             :     typelib_CompoundTypeDescription * pTypeDescr,
     147             :     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
     148             :     SAL_THROW(())
     149             : {
     150          32 :     return _equalStruct( pDest, pSource, pTypeDescr, queryInterface, release );
     151             : }
     152             : //==================================================================================================
     153        9433 : 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        9433 :     return _assignStruct( pDest, pSource, pTypeDescr, queryInterface, acquire, release );
     160             : }
     161             : 
     162             : //==============================================================================
     163      213593 : uno_Sequence * copyConstructSequence(
     164             :     uno_Sequence * pSource,
     165             :     typelib_TypeDescriptionReference * pElementType,
     166             :     uno_AcquireFunc acquire, uno_Mapping * mapping )
     167             : {
     168      213593 :     return icopyConstructSequence( pSource, pElementType, acquire, mapping );
     169             : }
     170             : 
     171             : //==============================================================================
     172      226687 : void destructSequence(
     173             :     uno_Sequence * pSequence,
     174             :     typelib_TypeDescriptionReference * pType,
     175             :     typelib_TypeDescription * pTypeDescr,
     176             :     uno_ReleaseFunc release )
     177             : {
     178      226687 :     idestructSequence( pSequence, pType, pTypeDescr, release );
     179      226687 : }
     180             : 
     181             : //==================================================================================================
     182        1271 : 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        1271 :     return _equalSequence( pDest, pSource, pElementType, queryInterface, release );
     189             : }
     190             : 
     191             : extern "C"
     192             : {
     193             : //##################################################################################################
     194     3975130 : CPPU_DLLPUBLIC void SAL_CALL uno_type_constructData(
     195             :     void * pMem, typelib_TypeDescriptionReference * pType )
     196             :     SAL_THROW_EXTERN_C()
     197             : {
     198     3975130 :     _defaultConstructData( pMem, pType, 0 );
     199     3975130 : }
     200             : //##################################################################################################
     201          52 : CPPU_DLLPUBLIC void SAL_CALL uno_constructData(
     202             :     void * pMem, typelib_TypeDescription * pTypeDescr )
     203             :     SAL_THROW_EXTERN_C()
     204             : {
     205          52 :     _defaultConstructData( pMem, pTypeDescr->pWeakRef, pTypeDescr );
     206          52 : }
     207             : //##################################################################################################
     208     8717755 : 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     8717755 :     _destructData( pValue, pType, 0, release );
     214     8717755 : }
     215             : //##################################################################################################
     216        3827 : 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        3827 :     _destructData( pValue, pTypeDescr->pWeakRef, pTypeDescr, release );
     223        3827 : }
     224             : //##################################################################################################
     225     3138850 : 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     3138850 :     _copyConstructData( pDest, pSource, pType, 0, acquire, 0 );
     232     3138850 : }
     233             : //##################################################################################################
     234           0 : 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           0 :     _copyConstructData( pDest, pSource, pTypeDescr->pWeakRef, pTypeDescr, acquire, 0 );
     241           0 : }
     242             : //##################################################################################################
     243       45950 : 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       45950 :     _copyConstructData( pDest, pSource, pType, 0, 0, mapping );
     250       45950 : }
     251             : //##################################################################################################
     252        4022 : 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        4022 :     _copyConstructData( pDest, pSource, pTypeDescr->pWeakRef, pTypeDescr, 0, mapping );
     259        4022 : }
     260             : //##################################################################################################
     261      172686 : 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      172686 :         queryInterface, release );
     271             : }
     272             : //##################################################################################################
     273           0 : 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           0 :         queryInterface, release );
     283             : }
     284             : //##################################################################################################
     285      503815 : 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      503815 :         queryInterface, acquire, release );
     295             : }
     296             : //##################################################################################################
     297           0 : 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           0 :         queryInterface, acquire, release );
     307             : }
     308             : //##################################################################################################
     309        3330 : 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        3330 :     if (::typelib_typedescriptionreference_isAssignableFrom( pAssignable, pFromType ))
     316        3324 :         return sal_True;
     317           6 :     if (typelib_TypeClass_INTERFACE != pFromType->eTypeClass ||
     318             :         typelib_TypeClass_INTERFACE != pAssignable->eTypeClass)
     319             :     {
     320           6 :         return sal_False;
     321             :     }
     322             : 
     323             :     // query
     324           0 :     if (0 == pFrom)
     325           0 :         return sal_False;
     326           0 :     void * pInterface = *(void **)pFrom;
     327           0 :     if (0 == pInterface)
     328           0 :         return sal_False;
     329             : 
     330           0 :     if (0 == queryInterface)
     331           0 :         queryInterface = binuno_queryInterface;
     332           0 :     void * p = (*queryInterface)( pInterface, pAssignable );
     333           0 :     _release( p, release );
     334           0 :     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: */

Generated by: LCOV version 1.10