tbb_stddef.h

00001 /*
00002     Copyright 2005-2012 Intel Corporation.  All Rights Reserved.
00003 
00004     The source code contained or described herein and all documents related
00005     to the source code ("Material") are owned by Intel Corporation or its
00006     suppliers or licensors.  Title to the Material remains with Intel
00007     Corporation or its suppliers and licensors.  The Material is protected
00008     by worldwide copyright laws and treaty provisions.  No part of the
00009     Material may be used, copied, reproduced, modified, published, uploaded,
00010     posted, transmitted, distributed, or disclosed in any way without
00011     Intel's prior express written permission.
00012 
00013     No license under any patent, copyright, trade secret or other
00014     intellectual property right is granted to or conferred upon you by
00015     disclosure or delivery of the Materials, either expressly, by
00016     implication, inducement, estoppel or otherwise.  Any license under such
00017     intellectual property rights must be express and approved by Intel in
00018     writing.
00019 */
00020 
00021 #ifndef __TBB_tbb_stddef_H
00022 #define __TBB_tbb_stddef_H
00023 
00024 // Marketing-driven product version
00025 #define TBB_VERSION_MAJOR 4
00026 #define TBB_VERSION_MINOR 0
00027 
00028 // Engineering-focused interface version
00029 #define TBB_INTERFACE_VERSION 6004
00030 #define TBB_INTERFACE_VERSION_MAJOR TBB_INTERFACE_VERSION/1000
00031 
00032 // The oldest major interface version still supported
00033 // To be used in SONAME, manifests, etc.
00034 #define TBB_COMPATIBLE_INTERFACE_VERSION 2
00035 
00036 #define __TBB_STRING_AUX(x) #x
00037 #define __TBB_STRING(x) __TBB_STRING_AUX(x)
00038 
00039 // We do not need defines below for resource processing on windows
00040 #if !defined RC_INVOKED
00041 
00042 // Define groups for Doxygen documentation
00052 // Simple text that is displayed on the main page of Doxygen documentation.
00094 // Define preprocessor symbols used to determine architecture
00095 #if _WIN32||_WIN64
00096 #   if defined(_M_X64)||defined(__x86_64__)  // the latter for MinGW support
00097 #       define __TBB_x86_64 1
00098 #   elif defined(_M_IA64)
00099 #       define __TBB_ipf 1
00100 #   elif defined(_M_IX86)||defined(__i386__) // the latter for MinGW support
00101 #       define __TBB_x86_32 1
00102 #   endif
00103 #else /* Assume generic Unix */
00104 #   if !__linux__ && !__APPLE__
00105 #       define __TBB_generic_os 1
00106 #   endif
00107 #   if __x86_64__
00108 #       define __TBB_x86_64 1
00109 #   elif __ia64__
00110 #       define __TBB_ipf 1
00111 #   elif __i386__||__i386  // __i386 is for Sun OS
00112 #       define __TBB_x86_32 1
00113 #   else
00114 #       define __TBB_generic_arch 1
00115 #   endif
00116 #endif
00117 
00118 // tbb_config.h should be included the first since it contains macro definitions used in other headers
00119 #include "tbb_config.h"
00120 
00121 #if _MSC_VER >=1400
00122     #define __TBB_EXPORTED_FUNC   __cdecl
00123     #define __TBB_EXPORTED_METHOD __thiscall
00124 #else
00125     #define __TBB_EXPORTED_FUNC
00126     #define __TBB_EXPORTED_METHOD
00127 #endif
00128 
00129 #if __INTEL_COMPILER || _MSC_VER
00130 #define __TBB_NOINLINE(decl) __declspec(noinline) decl
00131 #elif __GNUC__
00132 #define __TBB_NOINLINE(decl) decl __attribute__ ((noinline))
00133 #else
00134 #define __TBB_NOINLINE(decl) decl
00135 #endif
00136 
00137 #include <cstddef>      /* Need size_t and ptrdiff_t */
00138 
00139 #if _MSC_VER
00140     #define __TBB_tbb_windef_H
00141     #include "internal/_tbb_windef.h"
00142     #undef __TBB_tbb_windef_H
00143 #endif
00144 #if !defined(_MSC_VER) || _MSC_VER>=1600
00145     #include <stdint.h>
00146 #endif
00147 
00149 namespace tbb {
00150 
00151 #if _MSC_VER && _MSC_VER<1600
00152     namespace internal {
00153         typedef __int8 int8_t;
00154         typedef __int16 int16_t;
00155         typedef __int32 int32_t;
00156         typedef __int64 int64_t;
00157         typedef unsigned __int8 uint8_t;
00158         typedef unsigned __int16 uint16_t;
00159         typedef unsigned __int32 uint32_t;
00160         typedef unsigned __int64 uint64_t;
00161     } // namespace internal
00162 #else /* Posix */
00163     namespace internal {
00164         using ::int8_t;
00165         using ::int16_t;
00166         using ::int32_t;
00167         using ::int64_t;
00168         using ::uint8_t;
00169         using ::uint16_t;
00170         using ::uint32_t;
00171         using ::uint64_t;
00172     } // namespace internal
00173 #endif /* Posix */
00174 
00175     using std::size_t;
00176     using std::ptrdiff_t;
00177 
00179     typedef void(*assertion_handler_type)( const char* filename, int line, const char* expression, const char * comment );
00180 
00181 #if TBB_USE_ASSERT
00182 
00184 
00187     #define __TBB_ASSERT(predicate,message) ((predicate)?((void)0):tbb::assertion_failure(__FILE__,__LINE__,#predicate,message))
00188     #define __TBB_ASSERT_EX __TBB_ASSERT
00189 
00191     assertion_handler_type __TBB_EXPORTED_FUNC set_assertion_handler( assertion_handler_type new_handler );
00192 
00194 
00197     void __TBB_EXPORTED_FUNC assertion_failure( const char* filename, int line, const char* expression, const char* comment );
00198 
00199 #else /* !TBB_USE_ASSERT */
00200 
00202     #define __TBB_ASSERT(predicate,comment) ((void)0)
00204     #define __TBB_ASSERT_EX(predicate,comment) ((void)(1 && (predicate)))
00205 
00206 #endif /* !TBB_USE_ASSERT */
00207 
00209 
00213 extern "C" int __TBB_EXPORTED_FUNC TBB_runtime_interface_version();
00214 
00216 
00220 class split {
00221 };
00222 
00227 namespace internal {
00228 
00230 
00233 const size_t NFS_MaxLineSize = 128;
00234 
00254 #define __TBB_atomic // intentionally empty, see above
00255 
00256 template<class T, int S>
00257 struct padded_base : T {
00258     char pad[NFS_MaxLineSize - sizeof(T) % NFS_MaxLineSize];
00259 };
00260 template<class T> struct padded_base<T, 0> : T {};
00261 
00263 template<class T>
00264 struct padded : padded_base<T, sizeof(T)> {};
00265 
00267 
00269 #define __TBB_offsetof(class_name, member_name) \
00270     ((ptrdiff_t)&(reinterpret_cast<class_name*>(0x1000)->member_name) - 0x1000)
00271 
00273 #define __TBB_get_object_ref(class_name, member_name, member_addr) \
00274     (*reinterpret_cast<class_name*>((char*)member_addr - __TBB_offsetof(class_name, member_name)))
00275 
00277 void __TBB_EXPORTED_FUNC handle_perror( int error_code, const char* aux_info );
00278 
00279 #if TBB_USE_EXCEPTIONS
00280     #define __TBB_TRY try
00281     #define __TBB_CATCH(e) catch(e)
00282     #define __TBB_THROW(e) throw e
00283     #define __TBB_RETHROW() throw
00284 #else /* !TBB_USE_EXCEPTIONS */
00285     inline bool __TBB_false() { return false; }
00286     #define __TBB_TRY
00287     #define __TBB_CATCH(e) if ( tbb::internal::__TBB_false() )
00288     #define __TBB_THROW(e) ((void)0)
00289     #define __TBB_RETHROW() ((void)0)
00290 #endif /* !TBB_USE_EXCEPTIONS */
00291 
00293 void __TBB_EXPORTED_FUNC runtime_warning( const char* format, ... );
00294 
00295 #if TBB_USE_ASSERT
00296 static void* const poisoned_ptr = reinterpret_cast<void*>(-1);
00297 
00299 template<typename T>
00300 inline void poison_pointer( T*& p ) { p = reinterpret_cast<T*>(poisoned_ptr); }
00301 
00303 template<typename T>
00304 inline bool is_poisoned( T* p ) { return p == reinterpret_cast<T*>(poisoned_ptr); }
00305 #else
00306 template<typename T>
00307 inline void poison_pointer( T* ) {/*do nothing*/}
00308 #endif /* !TBB_USE_ASSERT */
00309 
00311 
00313 template<typename T, typename U> 
00314 inline T punned_cast( U* ptr ) {
00315     uintptr_t x = reinterpret_cast<uintptr_t>(ptr);
00316     return reinterpret_cast<T>(x);
00317 }
00318 
00320 class no_assign {
00321     // Deny assignment
00322     void operator=( const no_assign& );
00323 public:
00324 #if __GNUC__
00326     no_assign() {}
00327 #endif /* __GNUC__ */
00328 };
00329 
00331 class no_copy: no_assign {
00333     no_copy( const no_copy& );
00334 public:
00336     no_copy() {}
00337 };
00338 
00340 template<typename T>
00341 struct allocator_type {
00342     typedef T value_type;
00343 };
00344 
00345 #if _MSC_VER
00347 template<typename T>
00348 struct allocator_type<const T> {
00349     typedef T value_type;
00350 };
00351 #endif
00352 
00354 inline size_t size_t_select( unsigned u, unsigned long long ull ) {
00355     /* Explicit cast of the arguments to size_t is done to avoid compiler warnings
00356        (e.g. by Clang and MSVC) about possible truncation. The value of the right size,
00357        which is selected by ?:, is anyway not truncated or promoted.
00358        MSVC still warns if this trick is applied directly to constants, hence this function. */
00359     return (sizeof(size_t)==sizeof(u)) ? size_t(u) : size_t(ull);
00360 }
00361 
00362 // Struct to be used as a version tag for inline functions.
00365 struct version_tag_v3 {};
00366 
00367 typedef version_tag_v3 version_tag;
00368 
00369 } // internal
00371 
00372 } // tbb
00373 
00374 #endif /* RC_INVOKED */
00375 #endif /* __TBB_tbb_stddef_H */

Copyright © 2005-2012 Intel Corporation. All Rights Reserved.

Intel, Pentium, Intel Xeon, Itanium, Intel XScale and VTune are registered trademarks or trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

* Other names and brands may be claimed as the property of others.