libsmbios_c library
|
00001 // Boost config.hpp configuration header file ------------------------------// 00002 00003 // (C) Copyright John Maddock 2001 - 2003. 00004 // (C) Copyright Darin Adler 2001. 00005 // (C) Copyright Peter Dimov 2001. 00006 // (C) Copyright Bill Kempf 2002. 00007 // (C) Copyright Jens Maurer 2002. 00008 // (C) Copyright David Abrahams 2002 - 2003. 00009 // (C) Copyright Gennaro Prota 2003. 00010 // (C) Copyright Eric Friedman 2003. 00011 // Use, modification and distribution are subject to the 00012 // Boost Software License, Version 1.0. (See accompanying file 00013 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 00014 00015 // See http://www.boost.org for most recent version. 00016 00017 // Boost config.hpp policy and rationale documentation has been moved to 00018 // http://www.boost.org/libs/config 00019 // 00020 // This file is intended to be stable, and relatively unchanging. 00021 // It should contain boilerplate code only - no compiler specific 00022 // code unless it is unavoidable - no changes unless unavoidable. 00023 00024 #ifndef LIBSMBIOS_CONFIG_SUFFIX_HPP 00025 #define LIBSMBIOS_CONFIG_SUFFIX_HPP 00026 00027 // 00028 // look for long long by looking for the appropriate macros in <limits.h>. 00029 // Note that we use limits.h rather than climits for maximal portability, 00030 // remember that since these just declare a bunch of macros, there should be 00031 // no namespace issues from this. 00032 // 00033 #include <limits.h> 00034 # if !defined(LIBSMBIOS_HAS_LONG_LONG) \ 00035 && !(defined(LIBSMBIOS_MSVC) && LIBSMBIOS_MSVC <=1300) && !defined(__BORLANDC__) \ 00036 && (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) 00037 # define LIBSMBIOS_HAS_LONG_LONG 00038 #endif 00039 #if !defined(LIBSMBIOS_HAS_LONG_LONG) && !defined(LIBSMBIOS_NO_INTEGRAL_INT64_T) 00040 # define LIBSMBIOS_NO_INTEGRAL_INT64_T 00041 #endif 00042 00043 // GCC 3.x will clean up all of those nasty macro definitions that 00044 // LIBSMBIOS_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine 00045 // it under GCC 3.x. 00046 #if defined(__GNUC__) && (__GNUC__ >= 3) && defined(LIBSMBIOS_NO_CTYPE_FUNCTIONS) 00047 # undef LIBSMBIOS_NO_CTYPE_FUNCTIONS 00048 #endif 00049 00050 00051 // 00052 // Assume any extensions are in namespace std:: unless stated otherwise: 00053 // 00054 # ifndef LIBSMBIOS_STD_EXTENSION_NAMESPACE 00055 # define LIBSMBIOS_STD_EXTENSION_NAMESPACE std 00056 # endif 00057 00058 // 00059 // If cv-qualified specializations are not allowed, then neither are cv-void ones: 00060 // 00061 # if defined(LIBSMBIOS_NO_CV_SPECIALIZATIONS) \ 00062 && !defined(LIBSMBIOS_NO_CV_VOID_SPECIALIZATIONS) 00063 # define LIBSMBIOS_NO_CV_VOID_SPECIALIZATIONS 00064 # endif 00065 00066 // 00067 // If there is no numeric_limits template, then it can't have any compile time 00068 // constants either! 00069 // 00070 # if defined(LIBSMBIOS_NO_LIMITS) \ 00071 && !defined(LIBSMBIOS_NO_LIMITS_COMPILE_TIME_CONSTANTS) 00072 # define LIBSMBIOS_NO_LIMITS_COMPILE_TIME_CONSTANTS 00073 # define LIBSMBIOS_NO_MS_INT64_NUMERIC_LIMITS 00074 # define LIBSMBIOS_NO_LONG_LONG_NUMERIC_LIMITS 00075 # endif 00076 00077 // 00078 // if there is no long long then there is no specialisation 00079 // for numeric_limits<long long> either: 00080 // 00081 #if !defined(LIBSMBIOS_HAS_LONG_LONG) && !defined(LIBSMBIOS_NO_LONG_LONG_NUMERIC_LIMITS) 00082 # define LIBSMBIOS_NO_LONG_LONG_NUMERIC_LIMITS 00083 #endif 00084 00085 // 00086 // if there is no __int64 then there is no specialisation 00087 // for numeric_limits<__int64> either: 00088 // 00089 #if !defined(LIBSMBIOS_HAS_MS_INT64) && !defined(LIBSMBIOS_NO_MS_INT64_NUMERIC_LIMITS) 00090 # define LIBSMBIOS_NO_MS_INT64_NUMERIC_LIMITS 00091 #endif 00092 00093 // 00094 // if member templates are supported then so is the 00095 // VC6 subset of member templates: 00096 // 00097 # if !defined(LIBSMBIOS_NO_MEMBER_TEMPLATES) \ 00098 && !defined(LIBSMBIOS_MSVC6_MEMBER_TEMPLATES) 00099 # define LIBSMBIOS_MSVC6_MEMBER_TEMPLATES 00100 # endif 00101 00102 // 00103 // Without partial specialization, can't test for partial specialisation bugs: 00104 // 00105 # if defined(LIBSMBIOS_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 00106 && !defined(LIBSMBIOS_BCB_PARTIAL_SPECIALIZATION_BUG) 00107 # define LIBSMBIOS_BCB_PARTIAL_SPECIALIZATION_BUG 00108 # endif 00109 00110 // 00111 // Without partial specialization, we can't have array-type partial specialisations: 00112 // 00113 # if defined(LIBSMBIOS_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 00114 && !defined(LIBSMBIOS_NO_ARRAY_TYPE_SPECIALIZATIONS) 00115 # define LIBSMBIOS_NO_ARRAY_TYPE_SPECIALIZATIONS 00116 # endif 00117 00118 // 00119 // Without partial specialization, std::iterator_traits can't work: 00120 // 00121 # if defined(LIBSMBIOS_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 00122 && !defined(LIBSMBIOS_NO_STD_ITERATOR_TRAITS) 00123 # define LIBSMBIOS_NO_STD_ITERATOR_TRAITS 00124 # endif 00125 00126 // 00127 // Without member template support, we can't have template constructors 00128 // in the standard library either: 00129 // 00130 # if defined(LIBSMBIOS_NO_MEMBER_TEMPLATES) \ 00131 && !defined(LIBSMBIOS_MSVC6_MEMBER_TEMPLATES) \ 00132 && !defined(LIBSMBIOS_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) 00133 # define LIBSMBIOS_NO_TEMPLATED_ITERATOR_CONSTRUCTORS 00134 # endif 00135 00136 // 00137 // Without member template support, we can't have a conforming 00138 // std::allocator template either: 00139 // 00140 # if defined(LIBSMBIOS_NO_MEMBER_TEMPLATES) \ 00141 && !defined(LIBSMBIOS_MSVC6_MEMBER_TEMPLATES) \ 00142 && !defined(LIBSMBIOS_NO_STD_ALLOCATOR) 00143 # define LIBSMBIOS_NO_STD_ALLOCATOR 00144 # endif 00145 00146 // 00147 // without ADL support then using declarations will break ADL as well: 00148 // 00149 #if defined(LIBSMBIOS_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(LIBSMBIOS_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL) 00150 # define LIBSMBIOS_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL 00151 #endif 00152 00153 // 00154 // If we have a standard allocator, then we have a partial one as well: 00155 // 00156 #if !defined(LIBSMBIOS_NO_STD_ALLOCATOR) 00157 # define LIBSMBIOS_HAS_PARTIAL_STD_ALLOCATOR 00158 #endif 00159 00160 // 00161 // We can't have a working std::use_facet if there is no std::locale: 00162 // 00163 # if defined(LIBSMBIOS_NO_STD_LOCALE) && !defined(LIBSMBIOS_NO_STD_USE_FACET) 00164 # define LIBSMBIOS_NO_STD_USE_FACET 00165 # endif 00166 00167 // 00168 // We can't have a std::messages facet if there is no std::locale: 00169 // 00170 # if defined(LIBSMBIOS_NO_STD_LOCALE) && !defined(LIBSMBIOS_NO_STD_MESSAGES) 00171 # define LIBSMBIOS_NO_STD_MESSAGES 00172 # endif 00173 00174 // 00175 // We can't have a working std::wstreambuf if there is no std::locale: 00176 // 00177 # if defined(LIBSMBIOS_NO_STD_LOCALE) && !defined(LIBSMBIOS_NO_STD_WSTREAMBUF) 00178 # define LIBSMBIOS_NO_STD_WSTREAMBUF 00179 # endif 00180 00181 // 00182 // We can't have a <cwctype> if there is no <cwchar>: 00183 // 00184 # if defined(LIBSMBIOS_NO_CWCHAR) && !defined(LIBSMBIOS_NO_CWCTYPE) 00185 # define LIBSMBIOS_NO_CWCTYPE 00186 # endif 00187 00188 // 00189 // We can't have a swprintf if there is no <cwchar>: 00190 // 00191 # if defined(LIBSMBIOS_NO_CWCHAR) && !defined(LIBSMBIOS_NO_SWPRINTF) 00192 # define LIBSMBIOS_NO_SWPRINTF 00193 # endif 00194 00195 // 00196 // If Win32 support is turned off, then we must turn off 00197 // threading support also, unless there is some other 00198 // thread API enabled: 00199 // 00200 #if defined(LIBSMBIOS_DISABLE_WIN32) && defined(_WIN32) \ 00201 && !defined(LIBSMBIOS_DISABLE_THREADS) && !defined(LIBSMBIOS_HAS_PTHREADS) 00202 # define LIBSMBIOS_DISABLE_THREADS 00203 #endif 00204 00205 // 00206 // Turn on threading support if the compiler thinks that it's in 00207 // multithreaded mode. We put this here because there are only a 00208 // limited number of macros that identify this (if there's any missing 00209 // from here then add to the appropriate compiler section): 00210 // 00211 #if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \ 00212 || defined(_PTHREADS)) && !defined(LIBSMBIOS_HAS_THREADS) 00213 # define LIBSMBIOS_HAS_THREADS 00214 #endif 00215 00216 // 00217 // Turn threading support off if LIBSMBIOS_DISABLE_THREADS is defined: 00218 // 00219 #if defined(LIBSMBIOS_DISABLE_THREADS) && defined(LIBSMBIOS_HAS_THREADS) 00220 # undef LIBSMBIOS_HAS_THREADS 00221 #endif 00222 00223 // 00224 // Turn threading support off if we don't recognise the threading API: 00225 // 00226 #if defined(LIBSMBIOS_HAS_THREADS) && !defined(LIBSMBIOS_HAS_PTHREADS)\ 00227 && !defined(LIBSMBIOS_HAS_WINTHREADS) && !defined(LIBSMBIOS_HAS_BETHREADS)\ 00228 && !defined(LIBSMBIOS_HAS_MPTASKS) 00229 # undef LIBSMBIOS_HAS_THREADS 00230 #endif 00231 00232 // 00233 // Turn threading detail macros off if we don't (want to) use threading 00234 // 00235 #ifndef LIBSMBIOS_HAS_THREADS 00236 # undef LIBSMBIOS_HAS_PTHREADS 00237 # undef LIBSMBIOS_HAS_PTHREAD_MUTEXATTR_SETTYPE 00238 # undef LIBSMBIOS_HAS_WINTHREADS 00239 # undef LIBSMBIOS_HAS_BETHREADS 00240 # undef LIBSMBIOS_HAS_MPTASKS 00241 #endif 00242 00243 // 00244 // If the compiler claims to be C99 conformant, then it had better 00245 // have a <stdint.h>: 00246 // 00247 # if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901) 00248 # define LIBSMBIOS_HAS_STDINT_H 00249 # endif 00250 00251 // 00252 // Define LIBSMBIOS_NO_SLIST and LIBSMBIOS_NO_HASH if required. 00253 // Note that this is for backwards compatibility only. 00254 // 00255 # ifndef LIBSMBIOS_HAS_SLIST 00256 # define LIBSMBIOS_NO_SLIST 00257 # endif 00258 00259 # ifndef LIBSMBIOS_HAS_HASH 00260 # define LIBSMBIOS_NO_HASH 00261 # endif 00262 00263 // LIBSMBIOS_HAS_ABI_HEADERS 00264 // This macro gets set if we have headers that fix the ABI, 00265 // and prevent ODR violations when linking to external libraries: 00266 #if defined(LIBSMBIOS_ABI_PREFIX) && defined(LIBSMBIOS_ABI_SUFFIX) && !defined(LIBSMBIOS_HAS_ABI_HEADERS) 00267 # define LIBSMBIOS_HAS_ABI_HEADERS 00268 #endif 00269 00270 #if defined(LIBSMBIOS_HAS_ABI_HEADERS) && defined(LIBSMBIOS_DISABLE_ABI_HEADERS) 00271 # undef LIBSMBIOS_HAS_ABI_HEADERS 00272 #endif 00273 00274 // LIBSMBIOS_NO_STDC_NAMESPACE workaround --------------------------------------// 00275 // Because std::size_t usage is so common, even in headers which do not 00276 // otherwise use the C library, the <cstddef> workaround is included here so 00277 // that ugly workaround code need not appear in many other boost headers. 00278 // NOTE WELL: This is a workaround for non-conforming compilers; <cstddef> 00279 // must still be #included in the usual places so that <cstddef> inclusion 00280 // works as expected with standard conforming compilers. The resulting 00281 // double inclusion of <cstddef> is harmless. 00282 00283 # ifdef LIBSMBIOS_NO_STDC_NAMESPACE 00284 # include <cstddef> 00285 namespace std { using ::ptrdiff_t; using ::size_t; } 00286 # endif 00287 00288 // LIBSMBIOS_NO_STD_MIN_MAX workaround -----------------------------------------// 00289 00290 # ifdef LIBSMBIOS_NO_STD_MIN_MAX 00291 00292 namespace std { 00293 template <class _Tp> 00294 inline const _Tp& min(const _Tp& __a, const _Tp& __b) { 00295 return __b < __a ? __b : __a; 00296 } 00297 template <class _Tp> 00298 inline const _Tp& max(const _Tp& __a, const _Tp& __b) { 00299 return __a < __b ? __b : __a; 00300 } 00301 } 00302 00303 # endif 00304 00305 // LIBSMBIOS_STATIC_CONSTANT workaround --------------------------------------- // 00306 // On compilers which don't allow in-class initialization of static integral 00307 // constant members, we must use enums as a workaround if we want the constants 00308 // to be available at compile-time. This macro gives us a convenient way to 00309 // declare such constants. 00310 00311 # ifdef LIBSMBIOS_NO_INCLASS_MEMBER_INITIALIZATION 00312 # define LIBSMBIOS_STATIC_CONSTANT(type, assignment) enum { assignment } 00313 # else 00314 # define LIBSMBIOS_STATIC_CONSTANT(type, assignment) static const type assignment 00315 # endif 00316 00317 // LIBSMBIOS_USE_FACET workaround ----------------------------------------------// 00318 // When the standard library does not have a conforming std::use_facet there 00319 // are various workarounds available, but they differ from library to library. 00320 // This macro provides a consistent way to access a locale's facets. 00321 // Usage: 00322 // replace 00323 // std::use_facet<Type>(loc); 00324 // with 00325 // LIBSMBIOS_USE_FACET(Type, loc); 00326 // Note do not add a std:: prefix to the front of LIBSMBIOS_USE_FACET! 00327 00328 #if defined(LIBSMBIOS_NO_STD_USE_FACET) 00329 # ifdef LIBSMBIOS_HAS_TWO_ARG_USE_FACET 00330 # define LIBSMBIOS_USE_FACET(Type, loc) std::use_facet(loc, static_cast<Type*>(0)) 00331 # elif defined(LIBSMBIOS_HAS_MACRO_USE_FACET) 00332 # define LIBSMBIOS_USE_FACET(Type, loc) std::_USE(loc, Type) 00333 # elif defined(LIBSMBIOS_HAS_STLP_USE_FACET) 00334 # define LIBSMBIOS_USE_FACET(Type, loc) (*std::_Use_facet<Type >(loc)) 00335 # endif 00336 #else 00337 # define LIBSMBIOS_USE_FACET(Type, loc) std::use_facet< Type >(loc) 00338 #endif 00339 00340 // LIBSMBIOS_NESTED_TEMPLATE workaround ------------------------------------------// 00341 // Member templates are supported by some compilers even though they can't use 00342 // the A::template member<U> syntax, as a workaround replace: 00343 // 00344 // typedef typename A::template rebind<U> binder; 00345 // 00346 // with: 00347 // 00348 // typedef typename A::LIBSMBIOS_NESTED_TEMPLATE rebind<U> binder; 00349 00350 #ifndef LIBSMBIOS_NO_MEMBER_TEMPLATE_KEYWORD 00351 # define LIBSMBIOS_NESTED_TEMPLATE template 00352 #else 00353 # define LIBSMBIOS_NESTED_TEMPLATE 00354 #endif 00355 00356 // LIBSMBIOS_UNREACHABLE_RETURN(x) workaround -------------------------------------// 00357 // Normally evaluates to nothing, unless LIBSMBIOS_NO_UNREACHABLE_RETURN_DETECTION 00358 // is defined, in which case it evaluates to return x; Use when you have a return 00359 // statement that can never be reached. 00360 00361 #ifdef LIBSMBIOS_NO_UNREACHABLE_RETURN_DETECTION 00362 # define LIBSMBIOS_UNREACHABLE_RETURN(x) return x; 00363 #else 00364 # define LIBSMBIOS_UNREACHABLE_RETURN(x) 00365 #endif 00366 00367 // LIBSMBIOS_DEDUCED_TYPENAME workaround ------------------------------------------// 00368 // 00369 // Some compilers don't support the use of `typename' for dependent 00370 // types in deduced contexts, e.g. 00371 // 00372 // template <class T> void f(T, typename T::type); 00373 // ^^^^^^^^ 00374 // Replace these declarations with: 00375 // 00376 // template <class T> void f(T, LIBSMBIOS_DEDUCED_TYPENAME T::type); 00377 00378 #ifndef LIBSMBIOS_NO_DEDUCED_TYPENAME 00379 # define LIBSMBIOS_DEDUCED_TYPENAME typename 00380 #else 00381 # define LIBSMBIOS_DEDUCED_TYPENAME 00382 #endif 00383 00384 // LIBSMBIOS_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------// 00385 // 00386 // Some compilers have problems with function templates whose 00387 // template parameters don't appear in the function parameter 00388 // list (basically they just link one instantiation of the 00389 // template in the final executable). These macros provide a 00390 // uniform way to cope with the problem with no effects on the 00391 // calling syntax. 00392 00393 // Example: 00394 // 00395 // #include <iostream> 00396 // #include <ostream> 00397 // #include <typeinfo> 00398 // 00399 // template <int n> 00400 // void f() { std::cout << n << ' '; } 00401 // 00402 // template <typename T> 00403 // void g() { std::cout << typeid(T).name() << ' '; } 00404 // 00405 // int main() { 00406 // f<1>(); 00407 // f<2>(); 00408 // 00409 // g<int>(); 00410 // g<double>(); 00411 // } 00412 // 00413 // With VC++ 6.0 the output is: 00414 // 00415 // 2 2 double double 00416 // 00417 // To fix it, write 00418 // 00419 // template <int n> 00420 // void f(LIBSMBIOS_EXPLICIT_TEMPLATE_NON_TYPE(int, n)) { ... } 00421 // 00422 // template <typename T> 00423 // void g(LIBSMBIOS_EXPLICIT_TEMPLATE_TYPE(T)) { ... } 00424 // 00425 00426 00427 // Don't think we need the following boost constructs for libsmbios 00428 //#if defined LIBSMBIOS_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS 00429 // 00430 //# include "smbios/type.hpp" 00431 //# include "smbios/non_type.hpp" 00432 // 00433 //# define LIBSMBIOS_EXPLICIT_TEMPLATE_TYPE(t) smbios::type<t>* = 0 00434 //# define LIBSMBIOS_EXPLICIT_TEMPLATE_TYPE_SPEC(t) smbios::type<t>* 00435 //# define LIBSMBIOS_EXPLICIT_TEMPLATE_NON_TYPE(t, v) smbios::non_type<t, v>* = 0 00436 //# define LIBSMBIOS_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) smbios::non_type<t, v>* 00437 // 00438 //# define LIBSMBIOS_APPEND_EXPLICIT_TEMPLATE_TYPE(t) , LIBSMBIOS_EXPLICIT_TEMPLATE_TYPE(t) 00439 //# define LIBSMBIOS_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) , LIBSMBIOS_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 00440 //# define LIBSMBIOS_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) , LIBSMBIOS_EXPLICIT_TEMPLATE_NON_TYPE(t, v) 00441 //# define LIBSMBIOS_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) , LIBSMBIOS_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) 00442 // 00443 //#else 00444 // 00446 // 00447 //# define LIBSMBIOS_EXPLICIT_TEMPLATE_TYPE(t) 00448 //# define LIBSMBIOS_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 00449 //# define LIBSMBIOS_EXPLICIT_TEMPLATE_NON_TYPE(t, v) 00450 //# define LIBSMBIOS_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) 00451 // 00452 //# define LIBSMBIOS_APPEND_EXPLICIT_TEMPLATE_TYPE(t) 00453 //# define LIBSMBIOS_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 00454 //# define LIBSMBIOS_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) 00455 //# define LIBSMBIOS_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) 00456 // 00457 // 00458 //#endif // defined LIBSMBIOS_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS 00459 00460 00461 // ---------------------------------------------------------------------------// 00462 00463 // 00464 // Helper macro LIBSMBIOS_STRINGIZE: 00465 // Converts the parameter X to a string after macro replacement 00466 // on X has been performed. 00467 // 00468 #define LIBSMBIOS_STRINGIZE(X) LIBSMBIOS_DO_STRINGIZE(X) 00469 #define LIBSMBIOS_DO_STRINGIZE(X) #X 00470 00471 // 00472 // Helper macro LIBSMBIOS_JOIN: 00473 // The following piece of macro magic joins the two 00474 // arguments together, even when one of the arguments is 00475 // itself a macro (see 16.3.1 in C++ standard). The key 00476 // is that macro expansion of macro arguments does not 00477 // occur in LIBSMBIOS_DO_JOIN2 but does in LIBSMBIOS_DO_JOIN. 00478 // 00479 #define LIBSMBIOS_JOIN( X, Y ) LIBSMBIOS_DO_JOIN( X, Y ) 00480 #define LIBSMBIOS_DO_JOIN( X, Y ) LIBSMBIOS_DO_JOIN2(X,Y) 00481 #define LIBSMBIOS_DO_JOIN2( X, Y ) X##Y 00482 00483 // 00484 // Set some default values for compiler/library/platform names. 00485 // These are for debugging config setup only: 00486 // 00487 # ifndef LIBSMBIOS_COMPILER 00488 # define LIBSMBIOS_COMPILER "Unknown ISO C++ Compiler" 00489 # endif 00490 # ifndef LIBSMBIOS_STDLIB 00491 # define LIBSMBIOS_STDLIB "Unknown ISO standard library" 00492 # endif 00493 # ifndef LIBSMBIOS_PLATFORM 00494 # if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \ 00495 || defined(_POSIX_SOURCE) 00496 # define LIBSMBIOS_PLATFORM "Generic Unix" 00497 # else 00498 # define LIBSMBIOS_PLATFORM "Unknown" 00499 # endif 00500 # endif 00501 00502 #endif 00503 00504 00505