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