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 5995 : void * binuno_queryInterface( void * pUnoI, typelib_TypeDescriptionReference * pDestType )
51 : {
52 : // init queryInterface() td
53 : static typelib_TypeDescription * g_pQITD = 0;
54 5995 : if (0 == g_pQITD)
55 : {
56 72 : MutexGuard aGuard( Mutex::getGlobalMutex() );
57 72 : if (0 == g_pQITD)
58 : {
59 : typelib_TypeDescriptionReference * type_XInterface =
60 72 : * typelib_static_type_getByTypeClass( typelib_TypeClass_INTERFACE );
61 72 : typelib_InterfaceTypeDescription * pTXInterfaceDescr = 0;
62 72 : TYPELIB_DANGER_GET( (typelib_TypeDescription **) &pTXInterfaceDescr, type_XInterface );
63 : OSL_ASSERT( pTXInterfaceDescr->ppAllMembers );
64 : typelib_typedescriptionreference_getDescription(
65 72 : &g_pQITD, pTXInterfaceDescr->ppAllMembers[ 0 ] );
66 72 : TYPELIB_DANGER_RELEASE( (typelib_TypeDescription *) pTXInterfaceDescr );
67 72 : }
68 : }
69 :
70 : uno_Any aRet, aExc;
71 5995 : uno_Any * pExc = &aExc;
72 : void * aArgs[ 1 ];
73 5995 : aArgs[ 0 ] = &pDestType;
74 : (*((uno_Interface *) pUnoI)->pDispatcher)(
75 5995 : (uno_Interface *) pUnoI, g_pQITD, &aRet, aArgs, &pExc );
76 :
77 5995 : uno_Interface * ret = 0;
78 5995 : if (0 == pExc)
79 : {
80 5995 : typelib_TypeDescriptionReference * ret_type = aRet.pType;
81 5995 : 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 5995 : typelib_typedescriptionreference_release( ret_type );
89 5995 : ret = (uno_Interface *) aRet.pReserved; // serving acquired interface
90 5995 : 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 5995 : return ret;
115 : }
116 :
117 : //==================================================================================================
118 66545 : void defaultConstructStruct(
119 : void * pMem,
120 : typelib_CompoundTypeDescription * pCompType )
121 : SAL_THROW(())
122 : {
123 66545 : _defaultConstructStruct( pMem, pCompType );
124 66545 : }
125 : //==================================================================================================
126 181441 : void copyConstructStruct(
127 : void * pDest, void * pSource,
128 : typelib_CompoundTypeDescription * pTypeDescr,
129 : uno_AcquireFunc acquire, uno_Mapping * mapping )
130 : SAL_THROW(())
131 : {
132 181441 : _copyConstructStruct( pDest, pSource, pTypeDescr, acquire, mapping );
133 181441 : }
134 : //==================================================================================================
135 250850 : void destructStruct(
136 : void * pValue,
137 : typelib_CompoundTypeDescription * pTypeDescr,
138 : uno_ReleaseFunc release )
139 : SAL_THROW(())
140 : {
141 250850 : _destructStruct( pValue, pTypeDescr, release );
142 250850 : }
143 : //==================================================================================================
144 64 : sal_Bool equalStruct(
145 : void * pDest, void *pSource,
146 : typelib_CompoundTypeDescription * pTypeDescr,
147 : uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
148 : SAL_THROW(())
149 : {
150 64 : return _equalStruct( pDest, pSource, pTypeDescr, queryInterface, release );
151 : }
152 : //==================================================================================================
153 25924 : 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 25924 : return _assignStruct( pDest, pSource, pTypeDescr, queryInterface, acquire, release );
160 : }
161 :
162 : //==============================================================================
163 780056 : uno_Sequence * copyConstructSequence(
164 : uno_Sequence * pSource,
165 : typelib_TypeDescriptionReference * pElementType,
166 : uno_AcquireFunc acquire, uno_Mapping * mapping )
167 : {
168 780056 : return icopyConstructSequence( pSource, pElementType, acquire, mapping );
169 : }
170 :
171 : //==============================================================================
172 807911 : void destructSequence(
173 : uno_Sequence * pSequence,
174 : typelib_TypeDescriptionReference * pType,
175 : typelib_TypeDescription * pTypeDescr,
176 : uno_ReleaseFunc release )
177 : {
178 807911 : idestructSequence( pSequence, pType, pTypeDescr, release );
179 807911 : }
180 :
181 : //==================================================================================================
182 2542 : 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 2542 : return _equalSequence( pDest, pSource, pElementType, queryInterface, release );
189 : }
190 :
191 : extern "C"
192 : {
193 : //##################################################################################################
194 11510562 : CPPU_DLLPUBLIC void SAL_CALL uno_type_constructData(
195 : void * pMem, typelib_TypeDescriptionReference * pType )
196 : SAL_THROW_EXTERN_C()
197 : {
198 11510562 : _defaultConstructData( pMem, pType, 0 );
199 11510562 : }
200 : //##################################################################################################
201 182 : CPPU_DLLPUBLIC void SAL_CALL uno_constructData(
202 : void * pMem, typelib_TypeDescription * pTypeDescr )
203 : SAL_THROW_EXTERN_C()
204 : {
205 182 : _defaultConstructData( pMem, pTypeDescr->pWeakRef, pTypeDescr );
206 182 : }
207 : //##################################################################################################
208 24771186 : 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 24771186 : _destructData( pValue, pType, 0, release );
214 24771187 : }
215 : //##################################################################################################
216 19992 : 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 19992 : _destructData( pValue, pTypeDescr->pWeakRef, pTypeDescr, release );
223 19992 : }
224 : //##################################################################################################
225 8961596 : 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 8961596 : _copyConstructData( pDest, pSource, pType, 0, acquire, 0 );
232 8961596 : }
233 : //##################################################################################################
234 260 : 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 260 : _copyConstructData( pDest, pSource, pTypeDescr->pWeakRef, pTypeDescr, acquire, 0 );
241 260 : }
242 : //##################################################################################################
243 166779 : 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 166779 : _copyConstructData( pDest, pSource, pType, 0, 0, mapping );
250 166779 : }
251 : //##################################################################################################
252 17353 : 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 17353 : _copyConstructData( pDest, pSource, pTypeDescr->pWeakRef, pTypeDescr, 0, mapping );
259 17353 : }
260 : //##################################################################################################
261 405787 : 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 405787 : 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 1516328 : 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 1516328 : queryInterface, acquire, release );
295 : }
296 : //##################################################################################################
297 47 : 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 47 : queryInterface, acquire, release );
307 : }
308 : //##################################################################################################
309 11445 : 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 11445 : if (::typelib_typedescriptionreference_isAssignableFrom( pAssignable, pFromType ))
316 11433 : return sal_True;
317 12 : if (typelib_TypeClass_INTERFACE != pFromType->eTypeClass ||
318 : typelib_TypeClass_INTERFACE != pAssignable->eTypeClass)
319 : {
320 12 : 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: */
|
