diff options
Diffstat (limited to 'WebKit/android/stlport/stl/config')
53 files changed, 6679 insertions, 0 deletions
diff --git a/WebKit/android/stlport/stl/config/_aix.h b/WebKit/android/stlport/stl/config/_aix.h new file mode 100644 index 0000000..bcbcb32 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_aix.h @@ -0,0 +1 @@ +#define _STLP_PLATFORM "AIX" diff --git a/WebKit/android/stlport/stl/config/_android.h b/WebKit/android/stlport/stl/config/_android.h new file mode 100644 index 0000000..1a954bf --- /dev/null +++ b/WebKit/android/stlport/stl/config/_android.h @@ -0,0 +1,79 @@ +#ifndef __stl_config__android_h +#define __stl_config__android_h + +#define _STLP_PLATFORM "Android" + +// The Android C library is mostly glibc-like +#define _STLP_USE_GLIBC 1 + +// ...and Unix-like. +#define _STLP_UNIX 1 + +// Have pthreads support. +#define _PTHREADS + +// Don't have native <cplusplus> headers +#define _STLP_HAS_NO_NEW_C_HEADERS 1 + +// Don't use wchar.h etc +#define _STLP_NO_WCHAR_T 1 + +// Don't have (working) native wide character support. +#define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1 + +// Don't use mbstate_t, define our own. +#define _STLP_NO_NATIVE_MBSTATE_T 1 + +// No (proper) wide stream support in Android +#define _STLP_NO_NATIVE_WIDE_STREAMS 1 + +// C library is in the global namespace. +#define _STLP_VENDOR_GLOBAL_CSTD 1 + +// Don't have underlying local support. +#undef _STLP_REAL_LOCALE_IMPLEMENTED + +// No pthread_spinlock_t in Android +#define _STLP_DONT_USE_PTHREAD_SPINLOCK 1 + +// Do not enable thread support +#define _NOTHREADS 1 + +// Little endian platform. +#define _STLP_LITTLE_ENDIAN 1 + +// No <exception> headers +#define _STLP_NO_EXCEPTION_HEADER 1 + +// No throwing exceptions +#define _STLP_NO_EXCEPTIONS 1 + +// Disable all iostreams +#define _STLP_NO_IOSTREAMS 1 + +// No need to define our own namespace +#define _STLP_NO_OWN_NAMESPACE 1 + +// Need this to define STLport's own bad_alloc class (which won't be +// thrown in any case) +#define _STLP_NEW_DONT_THROW_BAD_ALLOC 1 + +// Use __new_alloc instead of __node_alloc, so we don't need static functions. +#define _STLP_USE_SIMPLE_NODE_ALLOC 1 + +// Don't use extern versions of range errors, so we don't need to +// compile as a library. +#define _STLP_USE_NO_EXTERN_RANGE_ERRORS 1 + +// The system math library doesn't have long double variants, e.g +// sinl, cosl, etc +#define _STLP_NO_VENDOR_MATH_L 1 + +// Define how to include our native headers. +#define _STLP_NATIVE_HEADER(header) <libstdc++/include/header> +#define _STLP_NATIVE_C_HEADER(header) <../include/header> +#define _STLP_NATIVE_CPP_C_HEADER(header) <libstdc++/include/header> +#define _STLP_NATIVE_OLD_STREAMS_HEADER(header) <libstdc++/include/header> +#define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <libstdc++/include/header> + +#endif /* __stl_config__android_h */ diff --git a/WebKit/android/stlport/stl/config/_apcc.h b/WebKit/android/stlport/stl/config/_apcc.h new file mode 100644 index 0000000..5e8b115 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_apcc.h @@ -0,0 +1,31 @@ +// STLport config file for Apogee 4.x + +#define _STLP_COMPILER "Apogee" + +#define _STLP_NO_NEW_NEW_HEADER 1 +#define _STLP_HAS_NO_NEW_IOSTREAMS 1 +#define _STLP_HAS_NO_NEW_C_HEADERS 1 + +#if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4) +# define _STLP_RAND48 1 +#endif +// # define _STLP_RAND48 1 +#define _STLP_LONG_LONG long long +#define _STLP_NO_BAD_ALLOC 1 +#define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +#define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 +// # define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1 +#define _STLP_NO_EXCEPTION_HEADER 1 + +#undef _STLP_LINK_TIME_INSTANTIATION +#define _STLP_LINK_TIME_INSTANTIATION 1 + +#ifdef __STDLIB +# undef _STLP_NO_NEW_C_HEADERS +# undef _STLP_NO_NEW_NEW_HEADER +# undef _STLP_NO_BAD_ALLOC +# undef _STLP_LONG_LONG +#else +# undef _STLP_NO_EXCEPTION_SPEC +# define _STLP_NO_EXCEPTION_SPEC 1 +#endif diff --git a/WebKit/android/stlport/stl/config/_apple.h b/WebKit/android/stlport/stl/config/_apple.h new file mode 100644 index 0000000..4c030db --- /dev/null +++ b/WebKit/android/stlport/stl/config/_apple.h @@ -0,0 +1,122 @@ +/* STLport configuration file + * It is internal STLport header - DO NOT include it directly + */ + +/* common configuration settings for Apple MPW MrCpp / SCpp */ + +#if defined (__MRC__) +# define _STLP_COMPILER "MPW MrCpp" +#else +# define _STLP_COMPILER "MPW SCpp" +#endif + +#if defined(__MRC__) && __MRC__ < 0x500 +# error Apple's MPW MrCpp v.5.0.0 or better compiler required +#endif +#if defined(__SC__) && __SC__ < 0x890 +# error Apple's MPW SCpp v.8.9.0 or better compiler required +#endif + +/* TODO: Check that this config is necessary for all compiler versions. + * It is here for historical reasons for the moment. + */ +#define _STLP_NO_CONTAINERS_EXTENSION + +#ifdef qMacApp +# ifndef __CONDITIONALMACROS__ /* skip including ConditionalMacros_AC.h if ConditionalMacros.h is already included */ +# include <CoreSwitches_AC.h> +# include <ConditionalMacros_AC.h> +# include <Types_AC.h> +# define _STLP_FILE__ _FILE_AC +# define _STLP_DEBUG_MESSAGE +# define __stl_debug_message ProgramBreak_AC +# include <ConditionalMacros.h> +# endif +# include <Types.h> +#else +# include <ConditionalMacros.h> +# include <Types.h> +#endif + +#define _STLP_UINT32_T UInt32 +typedef int wint_t; + +#ifndef TYPE_BOOL +# error <ConditionalMacros.h> must be included. (TYPE_BOOL) +#endif +#if !TYPE_BOOL +# define _STLP_NO_BOOL +# define _STLP_DONT_USE_BOOL_TYPEDEF +#endif + +#ifndef TYPE_LONGLONG +# error <ConditionalMacros.h> must be included. (TYPE_LONGLONG) +#endif +#if TYPE_LONGLONG +# define _STLP_LONG_LONG long long +#endif + +#if !__option(exceptions) +# define _STLP_HAS_NO_EXCEPTIONS +#endif + +#define _STLP_DEBUG_MESSAGE_POST DebugStr("\pSTL diagnosis issued. See 'stderr' for detail."); +#define _STLP_ASSERT_MSG_TRAILER " " + +#ifdef _STLP_DEBUG +# define _STLP_THROW(x) (DebugStr("\pSTL is about to throw exception: "#x),throw x) +#endif + +#if defined(__MRC__) +# ifndef __spillargs +# define __spillargs 1 // MrCpp requires this symbol to be defined as 1 to properly handle va_start; ref.[ file stdarg.h; line 26 ] +# endif +#endif + +#if defined(__SC__) +#define _STLP_VENDOR_LONG_DOUBLE_MATH //*TY 12/03/2000 - SCpp's native math type is long double +#endif + +#ifndef _STLP_NATIVE_INCLUDE_PATH +# if __option(unix_includes) +# define _STLP_NATIVE_INCLUDE_PATH ../CIncludes // expects the alias to {CIncludes} under the same folder as {STL} +# else +# define _STLP_NATIVE_INCLUDE_PATH ::CIncludes // expects the alias to {CIncludes} under the same folder as {STL} +# endif +#endif +#if !defined(_STLP_MAKE_HEADER) +# if !__option(unix_includes) +# define _STLP_MAKE_HEADER(path, header) <path:header> // Mac uses ":" for directory delimiter +# endif +#endif + +# define _STLD _DBG // to keep the length of generated symbols within the compiler limitation + +#define _STLP_USE_STDIO_IO 1 //*TY 02/24/2000 - see also ; ref.[ file _fstream.h; line 36 ] +#define _STLP_NO_THREADS //*TY 12/17/2000 - multi-thread capability not explored, yet. +#undef _REENTRANT //*ty 11/24/2001 - to make sure no thread facility is activated +#define _NOTHREADS //*ty 12/07/2001 - + +// native library limitations +#define _STLP_VENDOR_GLOBAL_STD // mpw's c++ libs do not utilize namespace std yet +#define _STLP_NO_BAD_ALLOC // known limitation +#define _STLP_HAS_NO_NEW_C_HEADERS // known limitation +#define _STLP_NO_NEW_NEW_HEADER // known limitation +#define _STLP_NO_NATIVE_MBSTATE_T // known limitation +#define _STLP_NO_NATIVE_WIDE_FUNCTIONS // known limitation +#define _STLP_NO_NATIVE_WIDE_STREAMS // known limitation +#define _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT // known limitation +#define _STLP_BROKEN_EXCEPTION_CLASS // known limitation + +// compiler limitations +# define _STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS + +# define _STLP_MPWFIX_TRY try{ //*TY 06/01/2000 - exception handling bug workaround +# define _STLP_MPWFIX_CATCH }catch(...){throw;} //*TY 06/01/2000 - exception handling bug workaround +# define _STLP_MPWFIX_CATCH_ACTION(action) }catch(...){action;throw;} //*TY 06/01/2000 - exception handling bug workaround +# define _STLP_THROW_RETURN_BUG // known limitation +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION // known limitation +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX // known limitation +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER // known limitation +# define _STLP_NO_RELOPS_NAMESPACE // known limitation +// end of stl_apple.h diff --git a/WebKit/android/stlport/stl/config/_as400.h b/WebKit/android/stlport/stl/config/_as400.h new file mode 100644 index 0000000..a0261a4 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_as400.h @@ -0,0 +1,56 @@ +// STLport configuration file +// It is internal STLport header - DO NOT include it directly + +// AS/400 C++ config + +# ifdef _REENTRANT +# define _PTHREADS +# endif + +# define _STLP_NO_NEW_NEW_HEADER 1 + +# define _STLP_NO_BOOL +# define _STLP_LIMITED_DEFAULT_TEMPLATES + +# define _STLP_HAS_NO_NAMESPACES +# define _STLP_NEED_TYPENAME +# define _STLP_NEED_EXPLICIT +# define _STLP_HAS_NO_EXCEPTIONS +# define _STLP_NO_EXCEPTION_SPEC +# define _STLP_NO_ARROW_OPERATOR +# define _STLP_NO_NEW_STYLE_CASTS + +# define _STLP_NEED_MUTABLE +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX +# define _STLP_NO_BAD_ALLOC +# define _STLP_NO_MEMBER_TEMPLATES +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD +# define _STLP_NO_FRIEND_TEMPLATES +# define _STLP_NO_QUALIFIED_FRIENDS +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER + +# define _STLP_NO_METHOD_SPECIALIZATION +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS + +// # define _STLP_NO_EXCEPTION_HEADER + +# define _STLP_HAS_NO_NEW_C_HEADERS + +# define _STLP_STATIC_CONST_INIT_BUG +# define _STLP_THROW_RETURN_BUG +# define _STLP_LINK_TIME_INSTANTIATION +# define _STLP_NO_TEMPLATE_CONVERSIONS + +# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 +# define _STLP_TRIVIAL_DESTRUCTOR_BUG 1 + +# if defined(_LONG_LONG) +# define _STLP_LONG_LONG long long +# endif +# if defined(_PTHREADS) +# define _MULTI_THREADED +# endif +// fbp : to fix __partition() problem +# define _STLP_NONTEMPL_BASE_MATCH_BUG 1 diff --git a/WebKit/android/stlport/stl/config/_auto_link.h b/WebKit/android/stlport/stl/config/_auto_link.h new file mode 100644 index 0000000..52b5232 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_auto_link.h @@ -0,0 +1,57 @@ +/* We do not use auto link feature when: + * - user asked not to use it (_STLP_DONT_USE_AUTO_LINK) + * - STLport is used only as a STL library (_STLP_NO_IOSTREAMS || _STLP_USE_NO_IOSTREAMS) + * - we are building a C translation unit, STLport is a C++ Standard library implementation + */ +#if !defined (__BUILDING_STLPORT) && !defined (_STLP_DONT_USE_AUTO_LINK) && \ + !defined (_STLP_NO_IOSTREAMS) && !defined (_STLP_USE_NO_IOSTREAMS) && \ + defined (__cplusplus) + +# define _STLP_STRINGIZE(X) _STLP_STRINGIZE_AUX(X) +# define _STLP_STRINGIZE_AUX(X) #X + +# if defined (_STLP_DEBUG) +# define _STLP_LIB_OPTIM_MODE "stld" +# elif defined (_DEBUG) +# define _STLP_LIB_OPTIM_MODE "d" +# else +# define _STLP_LIB_OPTIM_MODE "" +# endif + +# if defined (_STLP_LIB_NAME_MOTIF) +# define _STLP_LIB_MOTIF "_"_STLP_LIB_NAME_MOTIF +# else +# define _STLP_LIB_MOTIF "" +# endif + +# if defined (_STLP_USE_DYNAMIC_LIB) +# if defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB) +# define _STLP_LIB_TYPE "_x" +# else +# define _STLP_LIB_TYPE "" +# endif +# else +# if defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB) +# define _STLP_LIB_TYPE "_statix" +# else +# define _STLP_LIB_TYPE "_static" +# endif +# endif + +# define _STLP_VERSION_STR _STLP_STRINGIZE(_STLPORT_MAJOR)"."_STLP_STRINGIZE(_STLPORT_MINOR) + +# define _STLP_STLPORT_LIB "stlport"_STLP_LIB_OPTIM_MODE""_STLP_LIB_TYPE""_STLP_LIB_MOTIF"."_STLP_VERSION_STR".lib" + +# if defined (_STLP_VERBOSE_AUTO_LINK) +# pragma message ("STLport: Auto linking to "_STLP_STLPORT_LIB) +# endif +# pragma comment (lib, _STLP_STLPORT_LIB) + +# undef _STLP_STLPORT_LIB +# undef _STLP_LIB_OPTIM_MODE +# undef _STLP_LIB_TYPE +# undef _STLP_STRINGIZE_AUX +# undef _STLP_STRINGIZE + +#endif /* _STLP_DONT_USE_AUTO_LINK */ + diff --git a/WebKit/android/stlport/stl/config/_bc.h b/WebKit/android/stlport/stl/config/_bc.h new file mode 100644 index 0000000..b56de07 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_bc.h @@ -0,0 +1,125 @@ +// STLport configuration file +// It is internal STLport header - DO NOT include it directly + +//#define _STLP_VERBOSE + +#define _STLP_COMPILER "Borland" + +#if (__BORLANDC__ < 0x551) +# error - Borland compilers below version 5.5.1 not supported. +#endif + +#if (__BORLANDC__ >= 0x580) && (__BORLANDC__ < 0x590) +# define _STLP_NO_NEW_C_HEADERS +# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../include/dinkumware/##header> +# define _STLP_NO_FORCE_INSTANTIATE +#endif + +#if (__BORLANDC__ >= 0x560) && (__BORLANDC__ < 0x570) +# define _USE_OLD_RW_STL +#endif + +#if (__BORLANDC__ >= 0x560) +# define NOWINBASEINTERLOCK // src/fstream.cpp error in winbase.h +#endif + +#if (__BORLANDC__ < 0x564) +# define _STLP_QUALIFIED_SPECIALIZATION_BUG +#endif + +#if (__BORLANDC__ < 0x560) +# define _STLP_NO_CONTAINERS_EXTENSION +#endif + +#define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER +#define _STLP_DONT_USE_PRIV_NAMESPACE +#define _STLP_NO_VENDOR_STDLIB_L +#define _STLP_NO_VENDOR_MATH_F +#define _STLP_DONT_USE_SHORT_STRING_OPTIM 1 +#define _STLP_NO_NATIVE_MBSTATE_T +#define _STLP_DLLEXPORT_NEEDS_PREDECLARATION +#undef _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT +#if (__BORLANDC__ < 0x580) && !defined (_RTLDLL) +# define _UNCAUGHT_EXCEPTION 1 +#endif + +// <limits> problem +#define _STLP_STATIC_CONST_INIT_BUG + +// <bitset> problems +#define _STLP_MEMBER_SPECIALIZATION_BUG 1 +#define _STLP_HAS_SPECIFIC_PROLOG_EPILOG 1 + +#define _STLP_LONG_LONG __int64 + +// auto enable thread safety and exceptions: +#ifndef _CPPUNWIND +# define _STLP_HAS_NO_EXCEPTIONS +#endif + +#if defined (__MT__) && !defined (_NOTHREADS) && !defined (_REENTRANT) +# if defined (_STLP_VERBOSE) +# pragma message ("multi threaded") +# endif +# define _REENTRANT 1 +#else +# if defined (_STLP_VERBOSE) +# pragma message ("single threaded") +# endif +#endif + +#define _STLP_EXPORT_DECLSPEC __declspec(dllexport) +#define _STLP_IMPORT_DECLSPEC __declspec(dllimport) + +#define _STLP_CLASS_EXPORT_DECLSPEC __declspec(dllexport) +#define _STLP_CLASS_IMPORT_DECLSPEC __declspec(dllimport) + +#if defined (_DLL) +# define _STLP_DLL +#endif +#if defined (_RTLDLL) +# define _STLP_RUNTIME_DLL +#endif +#include <stl/config/_detect_dll_or_lib.h> +#undef _STLP_RUNTIME_DLL +#undef _STLP_DLL + +#if defined (_STLP_USE_DYNAMIC_LIB) +# if defined (_STLP_VERBOSE) +# pragma message ("Using/Building STLport dll") +# endif +#elif defined (_STLP_USE_STATIC_LIB) +# if defined (_STLP_VERBOSE) +# pragma message ("Using/Building STLport lib") +# endif +#else +# error Unknown STLport usage config (dll/lib?) +#endif + +#if defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB) +# if defined (_STLP_VERBOSE) +# pragma message ("Using cross version of native runtime") +# endif +#endif + +#if !defined (_STLP_IMPORT_TEMPLATE_KEYWORD) +//# define _STLP_IMPORT_TEMPLATE_KEYWORD __declspec(dllimport) +#endif +//#define _STLP_EXPORT_TEMPLATE_KEYWORD __declspec(dllexport) + +#if defined (_STLP_USE_DYNAMIC_LIB) +# define _STLP_USE_DECLSPEC 1 +# if (__BORLANDC__ < 0x580) +# if defined (__BUILDING_STLPORT) +# define _STLP_CALL __cdecl __export +# else +# define _STLP_CALL __cdecl __import +# endif +#else +# define _STLP_CALL __cdecl +#endif +#else +# define _STLP_CALL __cdecl +#endif + +#include <stl/config/_auto_link.h> diff --git a/WebKit/android/stlport/stl/config/_como.h b/WebKit/android/stlport/stl/config/_como.h new file mode 100644 index 0000000..6076f88 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_como.h @@ -0,0 +1,207 @@ + +// STLport configuration file +// It is internal STLport header - DO NOT include it directly + +#define _STLP_COMPILER "Comeau" + +#include <stl/config/_native_headers.h> + +#define _STLP_UINT32_T unsigned int + +#define _STLP_HAS_NO_NEW_C_HEADERS +// #define _STLP_VENDOR_GLOBAL_EXCEPT_STD +#define _STLP_LONG_LONG long long + + +// +// ADDITIONS FOR COMEAU C++, made by Comeau Computing. +// We can be reached through comeau@comeaucomputing.com +// You shouldn't need to change anything below here for Comeau C++. +// If you do, please tell us at comeau@comeaucomputing.com +// +// Changes made here, AND THROUGH ALL FILES, based upon the __COMO__ macro +// (and SIMILAR NAMES INVOLVING COMO).... no doubt some of this will +// change as SGI integrates the changes into their code base since +// some changes are not really Comeau C++ specific, but required to +// make the SGI code compliant with Standard C++). +// +// Testing was done with Comeau C++ 4.2.44 and 4.2.45.2. Changes were made for +// both Comeau relaxed mode and Comeau strict mode, especially for end user code +// (that is, some of the .cxx files cannot compile in strict mode, because they +// contain extensions to Standard C++, however their object code forms can +// be used once compiled in relaxed mode, even if the end user code uses +// strict mode). +// +// These changes may also work for some earlier versions of Comeau C++, +// though we have not tested them. +// +// Actual mods made under RedHat 6.1 LINUX, should be ok with SuSE too and +// other LINUX's, and older Caldera LINUX, Solaris/SPARC, SunOS, SCO UNIX, +// and NetBSD. Other platforms may be added. Comeau will also perform +// custom ports for you. +// +// Check libcomo details at http://www.comeaucomputing.com/libcomo and +// http://www.comeaucomputing.com +// +// History of Comeau changes (this is rough, as work was often going on in parallel): +// BETA1 July 14, 2000, Initial port for RedHat 6.1 INTEL/ELF +// BETA2 Aug 4, 2000, Stronger RedHat support +// Support for Comeau strict mode for end user code +// BETA3 Aug 22, 2000, Support for other LINUX/INTEL/ELF's, including older ones +// BETA4 Sept 2, 2000, Initial support for SCO UNIX + other UNIX x86 SVR3's +// Stronger support for end user Comeau strict mode +// BETA5 Oct 5, 2000, Initial support for Solaris/SPARC +// More SCO support (though still incomplete) +// BETA6 Feb 5, 2001, Minor mods to accomodate Comeau C++ 4.2.45.1 +// BETA7 Mar 13, 2001, Verified with Comeau C++ 4.2.45.2 +// Minor NetBSD support +// BETA8 Apr 1. 2001, Initial support for SunOS/SPARC +// BETA9 Apr 7, 2001, Stronger SCO support + other UNIX x86 SVR3's +// Mods for an fpos_t problem for some LINUXes +// Mods since Destroy did not work in strict mode +// BETA10 Apr 12. 2001, Stronger NetBSD support +// +// PLANNED: +// BETAx TBA TBA, 2001, NetBSD, UNIXWARE, and Windows support expected +// + + +#ifdef __linux__ + +# define _STLP_NO_NATIVE_MBSTATE_T 1 +# define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1 +# define _STLP_NO_NATIVE_WIDE_STREAMS 1 +# define _STLP_NO_LONG_DOUBLE 1 + +// Comeau C++ under LINUX/INTEL/ELF +// Preprocess away "long long" routines for now, even in relaxed mode +# define __wcstoull_internal_defined 1 +# define __wcstoll_internal_defined 1 + +#endif /* __COMO__ under __linux__ */ + +#ifdef __USING_x86SVR3x_WITH_COMO /* SCO et al */ +/* UNIX 386+ SVR3 mods made with __USING_x86SVR3x_WITH_COMO + in other sources, not here */ +# define atan2l atan2 +# define cosl cos +# define sinl sin +# define sqrtl sqrt +# include <math.h> + inline long double expl(long double arg) { return exp(arg); } + inline long double logl(long double arg) { return log(arg); } +# define log10l log10 + +# define sinhl sinh +# define coshl cosh +# define fabsl fabs +namespace std { + inline int min(int a, int b) { return a>b ? b : a; } +} +#endif + +#ifdef sun +// Comeau C++ under Solaris/SPARC or SunOS + +#ifdef solarissparc +#define __USING_SOLARIS_SPARC_WITH_COMO /* show this in the source when grep'ing for COMO */ +// Note comowchar.h for Solaris/SPARC wchar stuff + +#include <math.h> +# define sinf sin +# define sinl sin +# define sinhf sinh +# define sinhl sinh +# define cosf cos +# define cosl cos +# define coshf cosh +# define coshl cosh +# define atan2l atan2 +# define atan2f atan2 + inline float logf(float arg) { return log(arg); } + inline long double logl(long double arg) { return log(arg); } +# define log10f log10 +# define log10l log10 +# define expf exp + inline long double expl(long double arg) { return exp(arg); } +# define sqrtf sqrt +# define sqrtl sqrt +# define fabsf fabs +# define fabsl fabs +#else +#define __USING_SUNOS_WITH_COMO + +#define __unix 1 +#define __EXTENSIONS__ /* This might create undue noise somewhere */ +#endif +#endif /* sun */ + +#if defined(__NetBSD__) +// From non-como #ifdef __GNUC__ above +#undef _STLP_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE +#define __unix 1 + +#include <sys/cdefs.h> +// Some joker #define'd __END_DECLS as }; +#undef __END_DECLS +#define __END_DECLS } + +// <sys/stat.h> prob +#include <sys/cdefs.h> +#undef __RENAME +#define __RENAME(x) + +#define wchar_t __COMO_WCHAR_T +#include <stddef.h> +#undef wchar_t + +#include <math.h> +# ifdef BORIS_DISABLED +# define atan2l atan2 +# define cosl cos +# define sinl sin +# define sqrtl sqrt + inline long double expl(long double arg) { return exp(arg); } + inline long double logl(long double arg) { return log(arg); } +# define log10l log10 +# define sinhl sinh +# define coshl cosh +# define fabsl fabs +# endif +#endif /* __NetBSD__ under __COMO__ */ + +// Shouldn't need to change anything below here for Comeau C++ +// If so, tell us at comeau@comeaucomputing.com + +#define _STLP_NO_DRAND48 + +#define _STLP_PARTIAL_SPECIALIZATION_SYNTAX +#define _STLP_NO_USING_CLAUSE_IN_CLASS + +#if __COMO_VERSION__ < 4300 +#if __COMO_VERSION__ >= 4245 +#define _STLP_NO_EXCEPTION_HEADER /**/ + // Is this needed? +# include <stdexcept.stdh> +#endif +#define _STLP_NO_BAD_ALLOC /**/ +#define _STLP_USE_AUTO_PTR_CONVERSIONS /**/ +#endif + +// this one is true only with MS +# if defined (_MSC_VER) +# define _STLP_WCHAR_T_IS_USHORT 1 +# if _MSC_VER <= 1200 +# define _STLP_VENDOR_GLOBAL_CSTD +# endif +# if _MSC_VER < 1100 +# define _STLP_NO_BAD_ALLOC 1 +# define _STLP_NO_EXCEPTION_HEADER 1 +# define _STLP_NO_NEW_NEW_HEADER 1 +# define _STLP_USE_NO_IOSTREAMS 1 +# endif +# endif + +// # define __EDG_SWITCHES + + diff --git a/WebKit/android/stlport/stl/config/_cray.h b/WebKit/android/stlport/stl/config/_cray.h new file mode 100644 index 0000000..32abd4f --- /dev/null +++ b/WebKit/android/stlport/stl/config/_cray.h @@ -0,0 +1,69 @@ +/* + * Copyright (c) 1997 + * Moscow Center for SPARC Technology + * + * Copyright (c) 1999 + * Boris Fomitchev + * + * This material is provided "as is", with absolutely no warranty expressed + * or implied. Any use is at your own risk. + * + * Permission to use or copy this software for any purpose is hereby granted + * without fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ + +#define _STLP_COMPILER "CC" + +// Mostly correct guess, change it for Alpha (and other environments +// that has 64-bit "long") +# define _STLP_UINT32_T unsigned long + +// Uncomment if long long is available +# define _STLP_LONG_LONG long long + +// Uncomment this if your compiler can't inline while(), for() +# define _STLP_LOOP_INLINE_PROBLEMS 1 + +// Uncomment this if your compiler does not support exceptions +// Cray C++ supports exceptions when '-h exceptions' option is user; +// therefore '-D_STLP_HAS_NO_EXCEPTIONS' must be used when '-h exceptions' +// is NOT used. +//# define _STLP_HAS_NO_EXCEPTIONS 1 + +// Delete? +// Define this if compiler lacks <exception> header +//# define _STLP_NO_EXCEPTION_HEADER 1 + +// Uncomment this if your C library has lrand48() function +# define _STLP_RAND48 1 + +// Uncomment if native new-style C library headers lile <cstddef>, etc are not available. +# define _STLP_HAS_NO_NEW_C_HEADERS 1 + +// uncomment if new-style headers <new> is available +# define _STLP_NO_NEW_NEW_HEADER 1 + +// uncomment this if <iostream> and other STD headers put their stuff in ::namespace, +// not std:: +# define _STLP_VENDOR_GLOBAL_STD + +// uncomment this if <cstdio> and the like put stuff in ::namespace, +// not std:: +# define _STLP_VENDOR_GLOBAL_CSTD + +# define _STLP_NATIVE_C_HEADER(__x) </usr/include/##__x> +// WARNING: Following is hardcoded to the system default C++ include files +# define _STLP_NATIVE_CPP_RUNTIME_HEADER(__x) </opt/ctl/CC/CC/include/##__x> + + +# define _STLP_NO_NATIVE_MBSTATE_T +# define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS +//# define _STLP_VENDOR_GLOBAL_EXCEPT_STD + +#if !defined (_CRAYIEEE) +# define _STLP_NO_IEC559_SUPPORT 1 +#endif diff --git a/WebKit/android/stlport/stl/config/_cygwin.h b/WebKit/android/stlport/stl/config/_cygwin.h new file mode 100644 index 0000000..7960d01 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_cygwin.h @@ -0,0 +1,6 @@ +#define _STLP_PLATFORM "Cygwin" + +/* Glibc is the platform API */ +#if !defined (_STLP_USE_GLIBC) +# define _STLP_USE_GLIBC +#endif diff --git a/WebKit/android/stlport/stl/config/_dec.h b/WebKit/android/stlport/stl/config/_dec.h new file mode 100644 index 0000000..9f732d9 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_dec.h @@ -0,0 +1,107 @@ +#define _STLP_COMPILER "Dec" + +# define _STLP_HAS_SPECIFIC_PROLOG_EPILOG + +# define _STLP_NATIVE_HEADER(header) <../cxx/##header> +# define _STLP_NATIVE_C_HEADER(x) <../include/##x> + +#if (__DECCXX_VER < 60300000) +# define _STLP_NATIVE_CPP_C_HEADER(header) <../cxx/##header> +#else +# define _STLP_NATIVE_CPP_C_HEADER(header) </usr/include/cxx_cname/##header> +#endif + +# define _STLP_NATIVE_OLD_STREAMS_HEADER(header) <../cxx/##header> +# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../cxx/##header> + +// Alpha is little-endian +# define _STLP_LITTLE_ENDIAN + +// collisions +# define _STLP_DONT_PUT_STLPORT_IN_STD + +#if (__DECCXX_VER < 60000000) + +// automatic template instantiation does not +// work with namespaces ;( +# define _STLP_HAS_NO_NAMESPACES 1 + +# define _STLP_NO_NEW_NEW_HEADER 1 + +# define _STLP_NO_WCHAR_T 1 +# define _STLP_NEED_EXPLICIT 1 + +# define _STLP_NO_BOOL 1 +# define _STLP_NEED_TYPENAME 1 +# define _STLP_NO_NEW_STYLE_CASTS 1 +# define _STLP_NEED_MUTABLE 1 +# define _STLP_NO_BAD_ALLOC 1 + + +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1 + +# define _STLP_NO_MEMBER_TEMPLATES 1 +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +# define _STLP_NO_FRIEND_TEMPLATES 1 +# define _STLP_NO_QUALIFIED_FRIENDS 1 +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1 +# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 +# define _STLP_BROKEN_USING_DIRECTIVE 1 +# define _STLP_NO_EXCEPTION_HEADER 1 +# define _STLP_DEF_CONST_PLCT_NEW_BUG 1 +# define _STLP_DEF_CONST_DEF_PARAM_BUG 1 + +#endif + + +#ifdef __NO_USE_STD_IOSTREAM +# define _STLP_HAS_NO_NEW_IOSTREAMS 1 +# else +// default is to use new iostreams, anyway +# ifndef __USE_STD_IOSTREAM +# define __USE_STD_IOSTREAM +# endif +#endif + +//# ifndef __STD_STRICT_ANSI_ERRORS +//# endif + +#ifndef __EXCEPTIONS +# define _STLP_HAS_NO_EXCEPTIONS 1 +#endif + +# ifdef __IMPLICIT_INCLUDE_ENABLED + +// but, works with ours ;). +# define _STLP_LINK_TIME_INSTANTIATION 1 +# else +# undef _STLP_LINK_TIME_INSTANTIATION +# endif + +# if defined (__IMPLICIT_USING_STD) && !defined (__NO_USE_STD_IOSTREAM) +// we should ban that ! +// # error "STLport won't work with new iostreams and std:: being implicitly included. Please use -std strict_ansi[_errors] or specify __NO_USE_STD_IOSTREAM" +# endif + +# if (defined (__STD_STRICT_ANSI) || defined (__STD_STRICT_ANSI_ERRORS)) +# define _STLP_STRICT_ANSI 1 +# else +// we want to enforce it +# define _STLP_LONG_LONG long long +# endif + +// unsigned 32-bit integer type +# define _STLP_UINT32_T unsigned int +#if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4) +# define _STLP_RAND48 1 +#endif +// # define _STLP_RAND48 1 + +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1 + +# if (__DECCXX_VER <= 60600000) +# define _STLP_HAS_NO_NEW_C_HEADERS 1 +# endif + diff --git a/WebKit/android/stlport/stl/config/_dec_vms.h b/WebKit/android/stlport/stl/config/_dec_vms.h new file mode 100644 index 0000000..5df8d26 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_dec_vms.h @@ -0,0 +1,90 @@ +// OpenVMS version + +#define _STLP_COMPILER "Dec Vms" + +# define _STLP_NATIVE_HEADER(header) <sys$library:##header> +# define _STLP_NATIVE_C_HEADER(x) <sys$library:##x> +# define _STLP_NATIVE_CPP_C_HEADER(header) <sys$library:##header> +# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <sys$library:##header> + +#if (__DECCXX_VER < 60000000) + +// automatic template instantiation does not +// work with namespaces ;( +# define _STLP_HAS_NO_NAMESPACES 1 + +# define _STLP_NO_WCHAR_T 1 +# define _STLP_NEED_EXPLICIT 1 + +# define _STLP_NO_BOOL 1 +# define _STLP_NEED_TYPENAME 1 +# define _STLP_NO_NEW_STYLE_CASTS 1 +# define _STLP_NEED_MUTABLE 1 +# define _STLP_NO_BAD_ALLOC 1 + +# define _STLP_NO_NEW_NEW_HEADER 1 +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1 + +# define _STLP_NO_MEMBER_TEMPLATES 1 +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +# define _STLP_NO_FRIEND_TEMPLATES 1 +# define _STLP_NO_QUALIFIED_FRIENDS 1 +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1 +# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 +# define _STLP_BROKEN_USING_DIRECTIVE 1 +# define _STLP_NO_EXCEPTION_HEADER 1 +# define _STLP_DEF_CONST_PLCT_NEW_BUG 1 +# define _STLP_DEF_CONST_DEF_PARAM_BUG 1 + +#endif + + +#ifdef __NO_USE_STD_IOSTREAM +# define _STLP_USE_NO_IOSTREAMS 1 +# else +// default is to use new iostreams, anyway +# ifndef __USE_STD_IOSTREAM +# define __USE_STD_IOSTREAM +# endif +#endif + +#ifndef __EXCEPTIONS +# define _STLP_HAS_NO_EXCEPTIONS 1 +#endif + +# ifdef __IMPLICIT_INCLUDE_ENABLED + +#ifdef _STLP_USE_NO_IOSTREAMS +// implicit include introduces conflicts +// between stlport and native lib. +# undef __IMPLICIT_INCLUDE_ENABLED +#endif + +// but, works with ours ;). +# define _STLP_LINK_TIME_INSTANTIATION 1 + +# endif + +# if defined (__IMPLICIT_USING_STD) && !defined (__NO_USE_STD_IOSTREAM) +// we should ban that ! +# error "STLport won't work with new iostreams and std:: being implicitly included. Please use -std strict_ansi[_errors] or specify __NO_USE_STD_IOSTREAM" +# endif + +# if !(defined (__STD_STRICT_ANSI) || defined (__STD_STRICT_ANSI_ERRORS)) +// we want to enforce it +# define _STLP_LONG_LONG long long +# endif + +// unsigned 32-bit integer type +# define _STLP_UINT32_T unsigned int +#if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4) +# define _STLP_RAND48 1 +#endif +// # define _STLP_RAND48 1 + +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1 + +#define _STLP_HAS_NO_NEW_C_HEADERS 1 + diff --git a/WebKit/android/stlport/stl/config/_detect_dll_or_lib.h b/WebKit/android/stlport/stl/config/_detect_dll_or_lib.h new file mode 100644 index 0000000..39049fa --- /dev/null +++ b/WebKit/android/stlport/stl/config/_detect_dll_or_lib.h @@ -0,0 +1,70 @@ +/* File used to define macros: + * _STLP_USE_DYNAMIC_LIB: To signal use STLport as a dll or build of the + * STLport dlls. + * _STLP_USE_STATIC_LIB: To signal use of STLport as a static lib or build of + * the STLport static libs. + * _STLP_USING_CROSS_NATIVE_RUNTIME_LIB: Signal that we are using a native runtime + * in a version different from the STLport one. + * If _STLP_USE_DYNAMIC_LIB or _STLP_USE_STATIC_LIB is alreday defined it means that + * user forces use of a specific version. In this case _STLP_USING_CROSS_NATIVE_RUNTIME_LIB + * will surely be defined otherwise there is no need to force macro defines. + * + * Before including this file the compiler must define: + * _STLP_DLL: If we are building a dll + * _STLP_RUNTIME_DLL: If we are using native runtime as a dll + */ +#if defined (__BUILDING_STLPORT) +# undef _STLP_USE_DYNAMIC_LIB +# undef _STLP_USE_STATIC_LIB +# if defined (_STLP_DLL) +/* We are building the STLport dll */ +# define _STLP_USE_DYNAMIC_LIB +# if !defined (_STLP_RUNTIME_DLL) +# define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB +# endif +# else +# define _STLP_USE_STATIC_LIB +# if defined (_STLP_RUNTIME_DLL) +# define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB +# endif +# endif +#else +# if !defined (_STLP_NO_IOSTREAMS) +/* STLport use only depend on _STLP_RUNTIME_DLL as we are replacing + * the native runtime. + */ +# if defined (_STLP_RUNTIME_DLL) +# if !defined (_STLP_USE_STATIC_LIB) +# if !defined (_STLP_USE_DYNAMIC_LIB) +# define _STLP_USE_DYNAMIC_LIB +# endif +# else +/* The user is forcing use of STLport as a dynamic library. We signal it so + * that the STLport namespace will be modify to report such a combination + * and force the user to link with the rebuilt STLport library. + */ +# define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB +# endif +# else +# if !defined(_STLP_USE_DYNAMIC_LIB) +# if !defined (_STLP_USE_STATIC_LIB) +# define _STLP_USE_STATIC_LIB +# endif +# else +/* Idem previous remark but the user forces use of the static native runtime. + */ +# define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB +# endif +# endif +# else +/* If we do not build and use STLport libs we consider that we are in a static lib + * mode as only dynamic lib needs additional export/import specifier. + */ +# define _STLP_USE_STATIC_LIB +# endif +#endif + +/* we don't have a static native runtime library on evc3/evc4 */ +#ifdef _STLP_WCE +# undef _STLP_USING_CROSS_NATIVE_RUNTIME_LIB +#endif diff --git a/WebKit/android/stlport/stl/config/_dm.h b/WebKit/android/stlport/stl/config/_dm.h new file mode 100644 index 0000000..aa027a9 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_dm.h @@ -0,0 +1,109 @@ +// STLport configuration file for Digital Mars C++ + +//#define _STLP_VERBOSE + +#define _STLP_COMPILER "DMC" + +#if defined (_STLP_VERBOSE) +# pragma message __DMC_VERSION_STRING__ +#endif + +#if (__DMC__ < 0x846) +# error "Digital Mars C++ versions prior to 8.46 are not supported!" +#endif + +#ifndef _CPPUNWIND +# define _STLP_NO_EXCEPTIONS +#endif +#define _STLP_VENDOR_GLOBAL_CSTD + +//DMC prefer enum to real static const variable because it do not consider +//static const as const enough to be used in switch declaration... +#define _STLP_STATIC_CONST_INIT_BUG + +#if !defined (_WIN32) +// it's not fully supported on non-Win32 platforms +# define _STLP_NO_NATIVE_WIDE_FUNCTIONS +#endif + +/* _STLP_NO_OWN_NAMESPACE is defined because Digital Mars' linker and libarian + appear to have problems with STLport namespaces. Summary of the issues: + + STATIC: Digital Mars' librarian (lib.exe) may fail with "len <= IDMAX" error + if _STLP_DEBUG is defined. This is because Digital Mars' librarian uses + Microsoft OMF format, which limits identifier length to about 512 bytes. + With STLport namespaces, some identifiers such as Category_Map in + src/locale_catalog.cpp may exceed the maximum OMF identifier length. + + DYNAMIC: Export issues with cin, cout, cerr, clog in src/iostream.cpp. + Exports in Digital Mars 'def' file must match mangled names in iostream.cpp. + With STLport namespaces, the mangled names in the intermediate files no + longer match these pre-defined exports. To use STLport dynamic libraries + and STLport namespaces with Digital Mars, the pre-defined exports in + src/iostream.cpp and the related Digital Mars 'def' files would need to be + revised. */ +#define _STLP_NO_OWN_NAMESPACE 1 + +// select threads strategy +#if defined (_MT) && !defined (_NOTHREADS) +# define _REENTRANT +#else +# define _NOTHREADS +#endif + +#ifndef _BOOL_DEFINED +# define _STLP_NO_BOOL +#else +# define _STLP_DONT_USE_BOOL_TYPEDEF +#endif + +#if _INTEGRAL_MAX_BITS >= 64 +# define _STLP_LONG_LONG long long +#endif + +#define _STLP_DONT_USE_PRIV_NAMESPACE +#define _STLP_NO_BAD_ALLOC +#define _STLP_THROW_RETURN_BUG + +#if !defined (_DLL) +# undef _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT +#endif + +#define _STLP_USE_ABBREVS +#define _STLP_NO_CONTAINERS_EXTENSION +#define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER + +#define _STLP_EXPORT_DECLSPEC __declspec(dllexport) +#define _STLP_IMPORT_DECLSPEC __declspec(dllimport) + +#define _STLP_CLASS_EXPORT_DECLSPEC __declspec(dllexport) +#define _STLP_CLASS_IMPORT_DECLSPEC __declspec(dllimport) + +#define _STLP_IMPORT_TEMPLATE_KEYWORD __declspec(dllimport) +#define _STLP_EXPORT_TEMPLATE_KEYWORD __declspec(dllexport) + +#if defined (_WINDLL) +# define _STLP_DLL +#endif +#if defined (_DLL) +# define _STLP_RUNTIME_DLL +#endif +#include <stl/config/_detect_dll_or_lib.h> +#undef _STLP_RUNTIME_DLL +#undef _STLP_DLL + +#if defined (_STLP_USE_DYNAMIC_LIB) +# define _STLP_USE_DECLSPEC 1 +# if defined (__BUILDING_STLPORT) +# define _STLP_CALL __export +# else +# define _STLP_CALL +# endif +#else +# define _STLP_CALL +#endif + +#include <stl/config/_auto_link.h> + +# undef __SC__ + diff --git a/WebKit/android/stlport/stl/config/_epilog.h b/WebKit/android/stlport/stl/config/_epilog.h new file mode 100644 index 0000000..ecbace5 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_epilog.h @@ -0,0 +1,32 @@ +#if defined (_STLP_MSVC) || defined (__ICL) || defined (__BORLANDC__) + +#if defined (__BORLANDC__) +# pragma option pop +# pragma option -w-pow // -w-8062 Previous options and warnings not restored +#else +# if !(defined (_STLP_MSVC) && (_STLP_MSVC < 1200)) +# pragma warning (pop) +# endif +# pragma pack (pop) +#endif + +#elif defined (__sgi) && !defined (__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) + +# pragma reset woff 1174 +# pragma reset woff 1375 +# pragma reset woff 1209 +/* from iterator_base.h */ +# pragma reset woff 1183 + +#elif defined (__DECCXX) + +# ifdef __PRAGMA_ENVIRONMENT +# pragma __environment __restore +# endif + +#elif defined (__IBMCPP__) + +# pragma info(restore) + +#endif + diff --git a/WebKit/android/stlport/stl/config/_evc.h b/WebKit/android/stlport/stl/config/_evc.h new file mode 100644 index 0000000..4881a9a --- /dev/null +++ b/WebKit/android/stlport/stl/config/_evc.h @@ -0,0 +1,354 @@ +/* + * File to have Microsoft eMbedded Visual C++ 3.0 and .NET working with STLport + * May 2004 + * Origin : Zdenek Nemec - zero@mapfactor.com + * Michael Fink - vividos@users.sourceforge.net + */ + +#ifndef _STLP_EVC_H +#define _STLP_EVC_H + +#define _STLP_COMPILER "eMbedded Visual C++" + +// This flag is being used by STLport to support +// old-fashioned Windows CE SDK (see stl_wince.h) +// do not use with eMebedded Visual C++ 3 or 4! +#ifdef _STLP_WINCE +# undef _STLP_WINCE +#endif + +/* Compiler dependent define. The following defines may be available: + * _STLP_WCE_EVC3 when compiling under eMbedded Visual C++ 3 + * _STLP_WCE_NET when compiling under eMbedded Visual C++ .NET + * _STLP_WCE always defined when compiling with one of the above + */ +#undef _STLP_WCE_EVC3 +#undef _STLP_WCE_NET + +#if (_WIN32_WCE > 300) +# define _STLP_WCE_NET UNDER_CE +#elif (_WIN32_WCE == 300) +# define _STLP_WCE_EVC3 UNDER_CE +#else +# error No support for Windows CE below 3.0! +#endif + +// This is defined for all platforms using Windows CE +#define _STLP_WCE + +/* All Windows CE versions up to at least version 5 are little-endian, even + * if the hardware (like e.g. MIPS) can be configured for big-endian, too. */ +#define _STLP_LITTLE_ENDIAN + +// Ensure _DEBUG is defined. +#if defined (DEBUG) && !defined (_DEBUG) +# define _DEBUG +#endif + +// in evc3/4, on ARM, check that _STLP_DEBUG is not defined +// the ARM compiler has a bug that prevents that debug mode from working +#if _WIN32_WCE < 500 && defined(ARM) && defined(_STLP_DEBUG) +# error _STLP_DEBUG mode is not supported in evc3 and evc4 on the ARM platform! +#endif + +// inherit all msvc6 options +#include <stl/config/_msvc.h> + +// CE up to at least version 5 has no C locale support +#define _STLP_NO_LOCALE_SUPPORT + +#if _WIN32_WCE >= 0x500 + // SDKs built with PB5 have terminate&co in namespace std... +# define _STLP_VENDOR_TERMINATE_STD _STLP_VENDOR_STD +# define _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD _STLP_VENDOR_STD + // ...and new_handler/set_new_handler in the global namespace. +# define _STLP_GLOBAL_NEW_HANDLER 1 +#endif + +// Always threaded in eMbedded Visual C++ 3.0 and .NET +#ifndef _MT +# define _MT +#endif + +// we don't have a static native runtime library +#undef _STLP_USING_CROSS_NATIVE_RUNTIME_LIB + +#if _WIN32_WCE < 400 +// no long double under CE3 and older +# define _STLP_NO_LONG_DOUBLE +#endif + +// no *f and *l math functions available +#define _STLP_NO_VENDOR_MATH_F +#define _STLP_NO_VENDOR_MATH_L + +/* + * Redirect cout, cerr and clog: + * If defined redirect cout, cerr and clog to + * files stdout.txt, stderr.txt and stdlog.txt + */ +//# define _STLP_REDIRECT_STDSTREAMS + +/* + * Static class members may generate LNK1179: + * Wrong COMDAT packing may cause LNK1179 error. + * For details see http://groups.google.com/groups?th=8a05c82c4ffee280 + * example P78. This define is not used/needed at this moment + * but may came handy in future... + */ +//# define _STLP_STATIC_MEMBERS_BUG + +// Use wide-string interface of windows native functions (CreateFile...). +// Note that this should be defined all the time while under CE. +#if defined (UNICODE) +# define _STLP_USE_WIDE_INTERFACE +#endif + +// Force exception std to std instead of __std_alias. +#if defined (__cplusplus) && !defined (_STLP_HAS_NO_NAMESPACES) +# ifdef _STLP_VENDOR_EXCEPT_STD +# undef _STLP_VENDOR_EXCEPT_STD +# endif +# define _STLP_VENDOR_EXCEPT_STD std +#endif + +// short string optimization bug under evc3, evc4 using ARM compiler +#if _MSC_VER<1400 && (defined (ARM) || defined (_ARM_)) +# define _STLP_DONT_USE_SHORT_STRING_OPTIM +#endif + +// when using MFC, disable another placement new declaration, since there is one in wcealt.h +#if !defined (__BUILDING_STLPORT) && defined (_MFC_VER) +# define __PLACEMENT_NEW_INLINE +#endif + +// threads +#undef _REENTRANT +#define _REENTRANT +#undef _NOTHREADS + +// Use old fashioned headers (ctime vs. time.h). +#undef _STLP_NO_NEW_C_HEADERS +#define _STLP_NO_NEW_C_HEADERS + +// exception handling support: only on evc4 and user added /GX to project settings +#if defined (_STLP_WCE_EVC3) || !defined (_CPPUNWIND) +# define _STLP_NO_EXCEPTION_HEADER +# define _STLP_NO_EXCEPTIONS +# undef _STLP_USE_EXCEPTIONS +# ifndef __THROW_BAD_ALLOC +# define __THROW_BAD_ALLOC { _STLP_WINCE_TRACE(L"out of memory"); ExitThread(1); } +# endif +#endif + +#define _STLP_WINCE_TRACE(msg) OutputDebugString(msg) + +/* + * eMbedded Visual C++ .NET specific settings + */ +#if defined (_STLP_WCE_NET) + +// evc4 has no locale and time support +# define _STLP_NO_LOCALE_SUPPORT +# define _STLP_NO_TIME_SUPPORT + +// ptrdiff_t is not defined in evc4 headers +# ifndef _PTRDIFF_T_DEFINED + typedef int ptrdiff_t; +# define _PTRDIFF_T_DEFINED +# endif + +/* + * Helper macros for including the native headers in cases where a file with + * the same name also exists in the STLport include folder. The idea behind + * this is that we first go up one directory and then down into a dir that + * is only present in the native install but not in STLport. + * + */ +# if !defined (_STLP_NATIVE_INCLUDE_PATH) +# if defined (_X86_) +# if defined (_STLP_WCE_TARGET_PROC_SUBTYPE_EMULATOR) +# define _STLP_NATIVE_INCLUDE_PATH ../Emulator +# else +# define _STLP_NATIVE_INCLUDE_PATH ../X86 +# endif +# elif defined (_ARM_) +# if _MSC_VER < 1400 + // eVC3/4 +# if defined (ARMV4) +# define _STLP_NATIVE_INCLUDE_PATH ../Armv4 +# elif defined (ARMV4I) +# define _STLP_NATIVE_INCLUDE_PATH ../Armv4i +# elif defined (ARMV4T) +# define _STLP_NATIVE_INCLUDE_PATH ../Armv4t +# else +# error Unknown ARM SDK. +# endif +# else + // VC8 crosscompiling for CE +# if defined (ARMV4) +# define _STLP_NATIVE_INCLUDE_PATH ../Armv4 +# elif defined(ARMV4I) || defined(ARMV4T) +# define _STLP_NATIVE_INCLUDE_PATH ../Armv4i +# else +# error Unknown ARM SDK. +# endif +# endif +# elif defined (_MIPS_) +# if defined (MIPS16) +# define _STLP_NATIVE_INCLUDE_PATH ../mips16 +# elif defined (MIPSII) +# define _STLP_NATIVE_INCLUDE_PATH ../mipsII +# elif defined (MIPSII_FP) +# define _STLP_NATIVE_INCLUDE_PATH ../mipsII_fp +# elif defined (MIPSIV) +# define _STLP_NATIVE_INCLUDE_PATH ../mipsIV +# elif defined (MIPSIV_FP) +# define _STLP_NATIVE_INCLUDE_PATH ../mipsIV_fp +# else +# error Unknown MIPS SDK. +# endif +# elif defined (SHx) +# if defined (SH3) +# define _STLP_NATIVE_INCLUDE_PATH ../sh3 +# elif defined (SH4) +# define _STLP_NATIVE_INCLUDE_PATH ../sh4 +# else +# error Unknown SHx SDK. +# endif +# else +# error Unknown SDK. +# endif +# endif /* !_STLP_NATIVE_INCLUDE_PATH */ + +/* Workaround when using MFCCE and using <new> together: MFCCE's wcealt.h doesn't + * check for __PLACEMENT_NEW_INLINE before defining operator new, so when <new> + * defines the operatore before, there will be an error C2084: + * "function 'void *__cdecl operator new(unsigned int,void *)' already has a body". + */ +# ifdef _STLP_USE_MFC +# define __PLACEMENT_NEW_INLINE +# endif + +#endif /* _STLP_WCE_NET */ + +/* Workaround in _windows.h needs native headers access macros + * to be defined */ +#include <stl/config/_native_headers.h> + +/* + * eMbedded Visual C++ 3.0 specific settings + */ +#if defined (_STLP_WCE_EVC3) + +# define _STLP_NO_NATIVE_MBSTATE_T + +// evc3 has no locale and time support +# define _STLP_NO_LOCALE_SUPPORT +# define _STLP_NO_TIME_SUPPORT + +// evc3 has new, but no explicit header +# define _STLP_NO_NEW_HEADER +# define _STLP_NO_NEW_NEW_HEADER + +// evc3 has no bad_alloc and no typeinfo +# undef _STLP_NO_BAD_ALLOC +# define _STLP_NO_BAD_ALLOC + +# undef _STLP_NO_TYPEINFO +# define _STLP_NO_TYPEINFO + +// missing things in eMbedded Visual C++ 3.0 headers +# ifndef _SIZE_T_DEFINED + typedef unsigned int size_t; +# define _SIZE_T_DEFINED +# endif + +# ifndef _WCHAR_T_DEFINED + typedef unsigned short wchar_t; +# define _WCHAR_T_DEFINED +# endif + +// ptrdiff_t is not defined in evc3 headers +# ifndef _PTRDIFF_T_DEFINED + typedef int ptrdiff_t; +# define _PTRDIFF_T_DEFINED +# endif + +// clock_t is not defined in evc3 headers +# ifndef _CLOCK_T_DEFINED + typedef long clock_t; +# define _CLOCK_T_DEFINED +# endif + +// Struct tm is not defined in evc3 headers +# ifndef _TM_DEFINED +struct tm { + int tm_sec; /* seconds after the minute - [0,59] */ + int tm_min; /* minutes after the hour - [0,59] */ + int tm_hour; /* hours since midnight - [0,23] */ + int tm_mday; /* day of the month - [1,31] */ + int tm_mon; /* months since January - [0,11] */ + int tm_year; /* years since 1900 */ + int tm_wday; /* days since Sunday - [0,6] */ + int tm_yday; /* days since January 1 - [0,365] */ + int tm_isdst; /* daylight savings time flag */ +}; +# define _TM_DEFINED +# endif + +// define placement new and delete operator +// note: when MFCCE headers are included first, don't define the new operator, +// since it was already defined in wcealt.h +# ifdef __cplusplus +# ifndef __PLACEMENT_NEW_INLINE +# ifndef _MFC_VER +inline void *__cdecl operator new(size_t, void *_P) { return (_P); } +# endif /* _MFC_VER */ +inline void __cdecl operator delete(void *, void *) { return; } +# define __PLACEMENT_NEW_INLINE +# endif +# endif /* __cplusplus */ + +// evc3 doesn't have native wide functions, e.g. fgetwc, wmemmove +# define _STLP_NO_NATIVE_WIDE_FUNCTIONS + +// evc3 doesn't have assert.h +# ifndef _ASSERT_DEFINED +# define assert(expr) _STLP_ASSERT(expr) +# define _ASSERT_DEFINED +# endif + +#endif /* _STLP_WCE_EVC3 */ + +// Minimize windows.h includes +#if !defined (WIN32_LEAN_AND_MEAN) +# define WIN32_LEAN_AND_MEAN +#endif +#if !defined (VC_EXTRALEAN) +# define VC_EXTRALEAN +#endif +#if !defined (STRICT) +# define STRICT +#endif + +// Don't let windows.h define its min and max macros. +#if !defined (NOMINMAX) +# define NOMINMAX +#endif + +/* + * original call: TerminateProcess(GetCurrentProcess(), 0); + * we substitute the GetCurrentProcess() with the result of the inline function + * defined in kfuncs.h, since we then can avoid including <windows.h> at all. + * all needed Win32 API functions are defined in <stl/_windows.h> + */ +#ifndef _ABORT_DEFINED +# define _STLP_ABORT() TerminateProcess(reinterpret_cast<HANDLE>(66), 0) +# define _ABORT_DEFINED +#endif + +// Notice: windows.h isn't included here anymore; all needed defines are in +// stl/_windows.h now + +#endif /* _STLP_EVC_H */ diff --git a/WebKit/android/stlport/stl/config/_freebsd.h b/WebKit/android/stlport/stl/config/_freebsd.h new file mode 100644 index 0000000..1bb6b58 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_freebsd.h @@ -0,0 +1 @@ +#define _STLP_PLATFORM "Free BSD" diff --git a/WebKit/android/stlport/stl/config/_fujitsu.h b/WebKit/android/stlport/stl/config/_fujitsu.h new file mode 100644 index 0000000..cf91e05 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_fujitsu.h @@ -0,0 +1,7 @@ +/* STLport configuration for Fujitsu compiler : looks like a perfect one ! */ +#define _STLP_COMPILER "Fujitsu" + +#define _STLP_NATIVE_INCLUDE_PATH ../std +#define _STLP_UINT32_T unsigned int +#define _STLP_LONG_LONG long long +#define _STLP_WCHAR_SUNPRO_EXCLUDE 1 diff --git a/WebKit/android/stlport/stl/config/_gcc.h b/WebKit/android/stlport/stl/config/_gcc.h new file mode 100644 index 0000000..8dae452 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_gcc.h @@ -0,0 +1,462 @@ +/* STLport configuration file + * It is internal STLport header - DO NOT include it directly + */ + +#define _STLP_COMPILER "gcc" + +/* Systems having GLIBC installed have different traits */ +#if defined (__linux__) +# ifndef _STLP_USE_GLIBC +# define _STLP_USE_GLIBC 1 +# endif +# if defined (__UCLIBC__) && !defined (_STLP_USE_UCLIBC) +# define _STLP_USE_UCLIBC 1 +# endif +#endif + +#if defined (__CYGWIN__) && \ + (__GNUC__ >= 3) && (__GNUC_MINOR__ >= 3) && !defined (_GLIBCPP_USE_C99) +# define _STLP_NO_VENDOR_MATH_L +# define _STLP_NO_VENDOR_STDLIB_L +#endif + +#if (__GNUC__ < 3) +# define _STLP_NO_VENDOR_STDLIB_L +#endif + +/* We guess if we are using the cygwin distrib that has a special include schema. + * There is no way to distinguish a cygwin distrib used in no-cygwin mode from a + * mingw install. We are forced to use a configuration option + */ +#if !defined (_STLP_NATIVE_INCLUDE_PATH) && \ + (defined (__CYGWIN__) || defined (__MINGW32__) && defined (_STLP_NO_CYGWIN)) +# if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 3)) +# define _STLP_NATIVE_INCLUDE_PATH ../../../__GNUC__.__GNUC_MINOR__.__GNUC_PATCHLEVEL__/include/c++ +# elif defined (_STLP_NO_CYGWIN) +# define _STLP_NATIVE_INCLUDE_PATH ../mingw +/*# else + * Before version gcc 3.4, the cygwin package include path was conform to the + * GNU convention which is set later in this file. + */ +# endif +#endif + +#if (__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 4)) +/* define for gcc versions before 3.4.0. */ +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD +#endif + +/* azov: gcc on lynx have a bug that causes internal + * compiler errors when compiling STLport with namespaces turned on. + * When the compiler gets better - comment out _STLP_HAS_NO_NAMESPACES + */ +#if defined (__Lynx__) && (__GNUC__ < 3) +# define _STLP_HAS_NO_NAMESPACES 1 +# define _STLP_NO_STATIC_TEMPLATE_DATA 1 +/* turn off useless warning about including system headers */ +# define __NO_INCLUDE_WARN__ 1 +#endif + +/* Tru64 Unix, AIX, HP : gcc there by default uses native ld and hence cannot auto-instantiate + static template data. If you are using GNU ld, please say so in user_config.h header */ +#if (__GNUC__ < 3) && !defined(_STLP_GCC_USES_GNU_LD) && \ + ((defined (__osf__) && defined (__alpha__)) || defined (_AIX) || defined (__hpux) || defined(__amigaos__) ) +# define _STLP_NO_STATIC_TEMPLATE_DATA +#endif + +#if !defined (_REENTRANT) && (defined (_THREAD_SAFE) || \ + (defined (__OpenBSD__) && defined (_POSIX_THREADS)) || \ + (defined (__MINGW32__) && defined (_MT))) +# define _REENTRANT +#endif + +#if defined (__DJGPP) +# define _STLP_RAND48 1 +# define _NOTHREADS 1 +# undef _PTHREADS +# define _STLP_LITTLE_ENDIAN +#endif + +#if defined (__MINGW32__) +/* Mingw32, egcs compiler using the Microsoft C runtime */ +# define _STLP_VENDOR_GLOBAL_CSTD +# undef _STLP_NO_DRAND48 +# define _STLP_NO_DRAND48 +# define _STLP_CALL + +# if defined (_STLP_NEW_PLATFORM_SDK) +/* For the moment the Windows SDK coming with Mingw still mimik the old platform SDK. */ +# undef _STLP_NEW_PLATFORM_SDK +# endif +#endif /* __MINGW32__ */ + +#if defined (__CYGWIN__) || defined (__MINGW32__) +# if !defined (_STLP_USE_STATIC_LIB) +# define _STLP_USE_DECLSPEC 1 +# if !defined (_STLP_USE_DYNAMIC_LIB) +# define _STLP_USE_DYNAMIC_LIB +# endif +# define _STLP_EXPORT_DECLSPEC __declspec(dllexport) +# define _STLP_CLASS_EXPORT_DECLSPEC __declspec(dllexport) +# define _STLP_CLASS_IMPORT_DECLSPEC __declspec(dllimport) +# endif +/* The following is defined independently of _STLP_USE_STATIC_LIB because it is also + * used to import symbols from PSDK under MinGW + */ +# define _STLP_IMPORT_DECLSPEC __declspec(dllimport) +#endif + +#if defined (__CYGWIN__) || defined (__MINGW32__) || !(defined (_STLP_USE_GLIBC) || defined (__sun) || defined(__APPLE__)) +# if !defined (__MINGW32__) && !defined (__CYGWIN__) +# define _STLP_NO_NATIVE_MBSTATE_T 1 +# endif +# if !defined (__MINGW32__) || (__GNUC__ < 3) || (__GNUC__ == 3) && (__GNUC_MINOR__ < 4) +# define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1 +# endif +# define _STLP_NO_NATIVE_WIDE_STREAMS 1 +#endif + +#define _STLP_NORETURN_FUNCTION __attribute__((noreturn)) + +/* Mac OS X is a little different with namespaces and cannot instantiate + * static data members in template classes */ +#if defined (__APPLE__) +# if ((__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 3))) +/* Mac OS X is missing a required typedef and standard macro */ +typedef unsigned int wint_t; +# endif + +# define __unix + +# if (__GNUC__ < 3) + + /* Mac OS X needs one and only one source file to initialize all static data + * members in template classes. Only one source file in an executable or + * library can declare instances for such data members, otherwise duplicate + * symbols will be generated. */ + +# define _STLP_NO_STATIC_TEMPLATE_DATA +# define _STLP_STATIC_CONST_INIT_BUG 1 +# define _STLP_STATIC_TEMPLATE_DATA 0 +# define _STLP_WEAK_ATTRIBUTE 1 + /* Workaround for the broken Mac OS X C++ preprocessor which cannot handle + * parameterized macros in #include statements */ +# define _STLP_NATIVE_HEADER(header) <../g++/##header##> +# define _STLP_NATIVE_C_HEADER(header) <../include/##header##> +# define _STLP_NATIVE_CPP_C_HEADER(header) <../g++/##header##> +# define _STLP_NATIVE_OLD_STREAMS_HEADER(header) <../g++/##header##> +# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../g++/##header##> +# endif /* __GNUC__ < 3 */ + +# define _STLP_NO_LONG_DOUBLE + +/* Mac OS X needs all "::" scope references to be "std::" */ +# define _STLP_USE_NEW_C_HEADERS + +# define _STLP_NO_VENDOR_STDLIB_L + +#endif /* __APPLE__ */ + + +#if defined(__BEOS__) && defined(__INTEL__) +# define _STLP_NATIVE_HEADER(header) <../stlport/beos/##header##> +# define _STLP_NATIVE_C_HEADER(header) <../stlport/beos/##header##> +# define _STLP_NATIVE_CPP_C_HEADER(header) <../stlport/beos/##header##> +# define _STLP_NATIVE_OLD_STREAMS_HEADER(header) <../stlport/beos/##header##> +# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../stlport/beos/##header##> +# define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1 +# define _STLP_NO_NATIVE_WIDE_STREAMS 1 +/* +# define _NOTHREADS 1 +*/ +# ifdef _PTHREADS +# undef _PTHREADS +# endif +# ifdef _STLP_PTHREADS +# undef _STLP_PTHREADS +# endif +# define _STLP_USE_STDIO_IO 1 +# define _STLP_USE_GLIBC 1 +#endif + +/* g++ 2.7.x and above */ +#define _STLP_LONG_LONG long long + +#ifdef _STLP_USE_UCLIBC +/* +# ifndef __DO_C99_MATH__ +*/ + /* No *f math fuctions variants (i.e. sqrtf, fabsf, etc.) */ +# define _STLP_NO_VENDOR_MATH_F + /* No *l math fuctions variants (i.e. sqrtl, fabsl, etc.) */ +# define _STLP_NO_VENDOR_MATH_L +# define _STLP_NO_LONG_DOUBLE +/* +# endif +*/ +#endif + +#if defined (__OpenBSD__) || defined (__FreeBSD__) +# define _STLP_NO_VENDOR_MATH_L +# define _STLP_NO_VENDOR_STDLIB_L /* no llabs */ +# ifndef __unix +# define __unix +# endif +#endif + +#if defined (__alpha__) +# define _STLP_NO_VENDOR_MATH_L +# define _STLP_NO_IEC559_SUPPORT +#endif + +#if defined (__hpux) +# define _STLP_NO_VENDOR_STDLIB_L /* no llabs */ + /* No *f math fuctions variants (i.e. sqrtf, fabsf, etc.) */ +# define _STLP_NO_VENDOR_MATH_F +#endif + +#if (__GNUC__ >= 3) +# ifndef _STLP_HAS_NO_NEW_C_HEADERS +/* +# ifndef _STLP_USE_UCLIBC +*/ +# define _STLP_HAS_NATIVE_FLOAT_ABS +/* +# endif +*/ +# else +# ifdef _STLP_USE_GLIBC +# define _STLP_VENDOR_LONG_DOUBLE_MATH 1 +# endif +# endif +#endif + +#if (__GNUC__ < 3) +# define _STLP_HAS_NO_NEW_C_HEADERS 1 +# define _STLP_VENDOR_GLOBAL_CSTD 1 +# define _STLP_DONT_USE_PTHREAD_SPINLOCK 1 +# ifndef __HONOR_STD +# define _STLP_VENDOR_GLOBAL_EXCEPT_STD 1 +# endif +/* egcs fails to initialize builtin types in expr. like this : new(p) char(); */ +# define _STLP_DEF_CONST_PLCT_NEW_BUG 1 +#endif + +/* +#define _STLP_VENDOR_GLOBAL_CSTD 1 +*/ + +#if (__GNUC__ == 2) && (__GNUC_MINOR__ < 95) +# define _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT +# define _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT +# define _STLP_DEF_CONST_DEF_PARAM_BUG 1 +#elif !defined (ANDROID) +// Don't drag in these externals on Android. +# undef _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT +# undef _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT +#endif + +#if (__GNUC_MINOR__ < 9) && (__GNUC__ < 3) /* gcc 2.8 */ +# define _STLP_NO_TEMPLATE_CONVERSIONS +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1 +# define _STLP_NO_FRIEND_TEMPLATES 1 +# define _STLP_HAS_NO_NAMESPACES 1 +# define _STLP_NO_METHOD_SPECIALIZATION 1 +# define _STLP_NO_MEMBER_TEMPLATES 1 +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 +# define _STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS +/* DJGPP doesn't seem to implement it in 2.8.x */ +# ifdef DJGPP +# define _STLP_NO_STATIC_TEMPLATE_DATA 1 +# endif +#endif + +#if __GNUC__ <= 2 && __GNUC_MINOR__ <= 7 && !defined (__CYGWIN32__) +/* Will it work with 2.6 ? I doubt it. */ +# if ( __GNUC_MINOR__ < 6 ) +__GIVE_UP_WITH_STL(GCC_272); +# endif + +# define _STLP_NO_RELOPS_NAMESPACE +# define _STLP_NON_TYPE_TMPL_PARAM_BUG +# define _STLP_LIMITED_DEFAULT_TEMPLATES 1 +# define _STLP_DEFAULT_TYPE_PARAM 1 +# define _STLP_NO_BAD_ALLOC +# define _STLP_NO_ARROW_OPERATOR 1 +# ifndef _STLP_NO_STATIC_TEMPLATE_DATA +# define _STLP_NO_STATIC_TEMPLATE_DATA +# endif +# define _STLP_STATIC_CONST_INIT_BUG 1 +# define _STLP_NO_METHOD_SPECIALIZATION 1 + +# if !defined (__CYGWIN32__) +# define _STLP_NESTED_TYPE_PARAM_BUG 1 +# define _STLP_BASE_MATCH_BUG 1 +/* unused operators are required (forward) */ +# define _STLP_CONST_CONSTRUCTOR_BUG +# define _STLP_NO_DEFAULT_NON_TYPE_PARAM +# endif +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1 +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1 +# define _STLP_NO_EXCEPTION_HEADER 1 +#else /* ! <= 2.7.* */ +#endif /* ! <= 2.7.* */ + +/* static template data members workaround strategy for gcc tries + * to use weak symbols. + * if you don't want to use that, #define _STLP_WEAK_ATTRIBUTE=0 ( you'll + * have to put "#define __PUT_STATIC_DATA_MEMBERS_HERE" line in one of your + * compilation unit ( or CFLAGS for it ) _before_ including any STL header ). + */ +#if defined (_STLP_NO_STATIC_TEMPLATE_DATA) && ! defined (_STLP_WEAK_ATTRIBUTE ) +/* systems using GNU ld or format that supports weak symbols + may use "weak" attribute + Linux & Solaris ( x86 & SPARC ) are being auto-recognized here */ +# if defined(_STLP_GNU_LD) || defined(__ELF__) || defined (__CYGWIN__) || \ + (( defined (__SVR4) || defined ( __svr4__ )) && \ + ( defined (sun) || defined ( __sun__ ))) +# define _STLP_WEAK_ATTRIBUTE 1 +# endif +#endif /* _STLP_WEAK_ATTRIBUTE */ + + +/* strict ANSI prohibits "long long" ( gcc) */ +#if defined ( __STRICT_ANSI__ ) +# undef _STLP_LONG_LONG +/* +# define _STLP_STRICT_ANSI 1 +*/ +#endif + +/* +#if !defined (__STRICT_ANSI__) || defined (__BUILDING_STLPORT) +# define _STLP_USE_TEMPLATE_EXPORT +# define _STLP_EXPORT_TEMPLATE_KEYWORD extern +# define _STLP_IMPORT_TEMPLATE_KEYWORD extern +#endif +*/ + +#ifndef __EXCEPTIONS +# undef _STLP_DONT_USE_EXCEPTIONS +# define _STLP_DONT_USE_EXCEPTIONS 1 +#endif + +#if (__GNUC__ >= 3) + +# if !defined (_STLP_NATIVE_INCLUDE_PATH) +# if ( (__GNUC__ == 3 ) && ((__GNUC_MINOR__ == 0) || ((__GNUC_MINOR__ < 3) && defined(__APPLE_CC__)))) +# define _STLP_NATIVE_INCLUDE_PATH ../g++-v3 +# else +# if ( ((__GNUC__ == 4 ) || (__GNUC_MINOR__ >= 3)) && defined(__APPLE_CC__)) +# define _STLP_NATIVE_INCLUDE_PATH ../c++ +/* +* Before version 3.4.0 the 0 patch level was not part of the include path: +*/ +# elif defined (__GNUC_PATCHLEVEL__) && ((__GNUC_PATCHLEVEL__ > 0) || \ + (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ > 3)) +# define _STLP_NATIVE_INCLUDE_PATH ../__GNUC__.__GNUC_MINOR__.__GNUC_PATCHLEVEL__ +# else +# define _STLP_NATIVE_INCLUDE_PATH ../__GNUC__.__GNUC_MINOR__ +# endif +# endif +# endif + +/* Instantiation scheme that used (default) in gcc 3 made void of sense explicit + instantiation within library: nothing except increased library size. - ptr + */ +# define _STLP_NO_FORCE_INSTANTIATE + +#elif (__GNUC_MINOR__ < 8) + +# if !defined (_STLP_NATIVE_INCLUDE_PATH) +# define _STLP_NATIVE_INCLUDE_PATH ../g++-include +# endif + +/* tuning of static template data members workaround */ +# if ( _STLP_STATIC_TEMPLATE_DATA < 1 ) +# if ( _STLP_WEAK_ATTRIBUTE > 0 ) +# define _STLP_WEAK __attribute__ (( weak )) +# else +# define _STLP_WEAK +# endif /* _STLP_WEAK_ATTRIBUTE */ + +# ifdef __PUT_STATIC_DATA_MEMBERS_HERE +# define __DECLARE_INSTANCE(type,item,init) type item _STLP_WEAK init +# else +# define __DECLARE_INSTANCE(type,item,init) +# endif /* __PUT_STATIC_DATA_MEMBERS_HERE */ +# endif /* _STLP_STATIC_TEMPLATE_DATA */ + +#else + +/* gcc-2.95.0 used to use "g++-3" directory which has been changed to "g++" in + * system-dependent "include" for 2.95.2 except for Cygwin and Mingw packages. + * I expect "g++-3" not being used in later releases. + * If your installation use "g++-3" include directory for any reason (pre-2.95.2 or Win binary kit), + * please change the macro below to point to your directory. + */ + +# if !defined (_STLP_NATIVE_INCLUDE_PATH) +# if defined(__DJGPP) +# define _STLP_NATIVE_INCLUDE_PATH ../lang/cxx +# elif (__GNUC__ >= 3) || (__GNUC_MINOR__ >= 97) +# define _STLP_NATIVE_INCLUDE_PATH ../include/g++-v3 +# elif ((__GNUC_MINOR__ >= 95 && __GNUC_MINOR__ < 97) && \ + !( defined (__FreeBSD__) || defined (__NetBSD__) || defined(__sgi) || defined (__OS2__) ) ) +# define _STLP_NATIVE_INCLUDE_PATH ../g++-3 +# elif (__GNUC_MINOR__ > 8) && (__GNUC_MINOR__ < 95) && (__GNUC__ < 3) && !defined( __Lynx__ ) +/* this really sucks, as GNUpro does not really identifies itself, so we have to guess + * depending on a platform + */ +# ifdef __hpux +# define _STLP_NATIVE_INCLUDE_PATH ../g++-3 +# else +# define _STLP_NATIVE_INCLUDE_PATH ../g++-2 +# endif +# else +# define _STLP_NATIVE_INCLUDE_PATH g++ +# endif +# endif + +/* <exception> et al */ +# ifdef __FreeBSD__ +# if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ > 95) +# define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH ../include +# endif +# else +/* azov */ +# ifndef __Lynx__ +# if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97) +/* +# define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH ../g++-v3 +*/ +# else +# define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH ../include +# endif +# endif +# endif + +#endif /* GNUC_MINOR < 8 */ + +#if !defined (_STLP_NATIVE_C_INCLUDE_PATH) +# define _STLP_NATIVE_C_INCLUDE_PATH ../include +#endif + +/* Tune settings for the case where static template data members are not + * instaniated by default + */ +#if defined ( _STLP_NO_STATIC_TEMPLATE_DATA ) +# define _STLP_STATIC_TEMPLATE_DATA 0 +# if !defined ( _STLP_WEAK_ATTRIBUTE ) +# define _STLP_WEAK_ATTRIBUTE 0 +# endif +# ifdef __PUT_STATIC_DATA_MEMBERS_HERE +# define __DECLARE_INSTANCE(type,item,init) type item init +# else +# define __DECLARE_INSTANCE(type,item,init) +# endif +#else +# define _STLP_STATIC_TEMPLATE_DATA 1 +#endif diff --git a/WebKit/android/stlport/stl/config/_hpacc.h b/WebKit/android/stlport/stl/config/_hpacc.h new file mode 100644 index 0000000..2cc5cc4 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_hpacc.h @@ -0,0 +1,196 @@ +// STLport configuration file +// It is internal STLport header - DO NOT include it directly + +#define _STLP_COMPILER "Acc" + +// system C-library dependent +#if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4) +# define _STLP_RAND48 1 +#endif +// # define _STLP_RAND48 1 +#define _STLP_NO_NATIVE_MBSTATE_T 1 +#define _STLP_HPACC_BROKEN_BUFEND 1 +#define _STLP_WCHAR_HPACC_EXCLUDE 1 + +// this was reported to help, just as with SUN CC 4.2 +#define _STLP_INLINE_STRING_LITERAL_BUG + +// specific prolog is needed to select correct threads impl +#define _STLP_HAS_SPECIFIC_PROLOG_EPILOG + +// HP aCC with +noeh +#ifdef __HPACC_NOEH +# define _STLP_HAS_NO_EXCEPTIONS 1 +#endif + +// HP compilers +// At that point, we only know we are on HP (and _not_ using gcc, +// according to "stlcomp.h" + +// __HP_aCC indicate HP ANSI C++, but not always (03.xx does not +// define it before 3.13, for example). +// +#if defined (__HP_aCC) + +# define _STLP_NO_FORCE_INSTANTIATE +# define _STLP_LONG_LONG long long +# define _STLP_NO_VENDOR_STDLIB_L + +# if (__HP_aCC <= 30000 && __HP_aCC >= 12100) + +//Special kludge to workaround bug in aCC A.01.23, CR JAGac40634 +# ifdef _STLP_DEBUG +static void _STLP_dummy_literal() { const char *p = "x";} +static void _STLP_dummy_literal_2() { const char *p = "123456789"; } +static void _STLP_dummy_literal_3() { const char *p = "123456700000000000000089";} +# endif + +# define _STLP_HP_ACC 0123 +# define _STLP_NATIVE_INCLUDE_PATH ../include +# define _STLP_VENDOR_GLOBAL_STD 1 +# define _STLP_VENDOR_GLOBAL_CSTD 1 +# define _STLP_DONT_THROW_RANGE_ERRORS 1 +# define _STLP_STATIC_CONST_INIT_BUG 1 +# if (__HP_aCC < 12700) +//new flag: on most HP compilers cwchar is missing +# define _STLP_NO_CWCHAR +# endif + +# define _STLP_FORCE_ALLOCATORS(t,a) \ + typedef typename _Alloc_traits<t,a>::_Orig _STLP_dummy_type1;\ + typedef typename _STLP_dummy_type1:: _STLP_TEMPLATE rebind<t>::other _STLP_dummy_type2; + +# endif /* 123 */ + +// latest version and up +# if (__HP_aCC >= 32500 ) +# define _STLP_HP_ACC 0325 + +# define _STLP_USE_NEW_C_HEADERS + +# define _STLP_FORCE_ALLOCATORS(t,a) \ + typedef typename _Alloc_traits<t,a>::_Orig _STLP_dummy_type1;\ + typedef typename _STLP_dummy_type1:: _STLP_TEMPLATE rebind<t>::other _STLP_dummy_type2; + +# if !defined ( _INCLUDE__STDC_A1_SOURCE ) // HP-UX 11i only +# define _STLP_HAS_NO_UNIX98_WCHAR_EXTENSIONS +# endif + +# if defined (_HP_NAMESPACE_STD) // option -AA +// from now, we have a full standard lib in namespace std +// +// -AA indicates that we are compiling against Rogue Wave 2.2.1 +// STL shipped with the HP aCC compiler. -AA tells the compiler +// to use the STL defined in the include_std directory. +// +# define _STLP_NATIVE_INCLUDE_PATH ../include_std + +// # define _STLP_HPACC_ONLY_NATIVE_STRING 1 // STLPort _string.c includes <locale> +# define _STLP_HP_ACC_COMPAT -1 +# else // option -Aa +# define _STLP_NATIVE_INCLUDE_PATH ../include +# define _STLP_VENDOR_GLOBAL_STD 1 +# define _STLP_VENDOR_GLOBAL_CSTD 1 +# define _STLP_DONT_THROW_RANGE_ERRORS 1 +# endif /* _NAMESPACE_STD */ +# endif + +# if (__HP_aCC >= 31400 && __HP_aCC < 32500) +# define _STLP_HP_ACC 0314 + +# define _STLP_FORCE_ALLOCATORS(t,a) \ +typedef typename _Alloc_traits<t,a>::_Orig _STLP_dummy_type1;\ +typedef typename _STLP_dummy_type1:: _STLP_TEMPLATE rebind<t>::other _STLP_dummy_type2; +# define _STLP_NO_CWCHAR +# if defined (_NAMESPACE_STD) // option -AA +// from now, we have a full standard lib in namespace std +# define _STLP_NATIVE_INCLUDE_PATH ../include_std +//# define _STLP_HPACC_ONLY_NATIVE_STRING 1 // STLPort _string.c includes <locale> +# define _STLP_HP_ACC_COMPAT -1 +# else // kind of compatibility mode +# define _STLP_NATIVE_INCLUDE_PATH ../include +# define _STLP_VENDOR_GLOBAL_STD 1 +# define _STLP_VENDOR_GLOBAL_CSTD 1 +# define _STLP_DONT_THROW_RANGE_ERRORS 1 +# define _STLP_NO_ROPE 1 +# endif /* _NAMESPACE_STD */ +# endif /* 314 */ + +# if ((__HP_aCC >= 30000 && __HP_aCC < 31400) || (__HP_aCC == 1)) // A.03.13: __HP_aCC == 1 + +# if (__HP_aCC != 1) +# define _STLP_HAS_NO_NEW_C_HEADERS 1 +# endif + +# define _STLP_NO_QUALIFIED_FRIENDS 1 +// aCC bug ? need explicit args on constructors of partial specialized +// classes +# define _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS 1 +// ?? fbp : maybe present in some versions ? +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +// <exception> and stuff is in global namespace +# define _STLP_VENDOR_GLOBAL_EXCEPT_STD +// fbp : moved here +# define _STLP_VENDOR_GLOBAL_CSTD 1 +// # define _INCLUDE_HPUX_SOURCE +# define _XPG4 +# define _INCLUDE_XOPEN_SOURCE +# define _INCLUDE_AES_SOURCE +# endif /* < 314 */ +# if __HP_aCC == 1 +# define _STLP_BROKEN_USING_IN_CLASS +# define _STLP_USING_BASE_MEMBER +# define _STLP_NO_CWCHAR +// # define _STLP_NO_WCHAR_T 1 +# endif +#endif /* HP_ACC */ + +// +#ifndef __HP_aCC +# define _STLP_NATIVE_INCLUDE_PATH ../CC +# define _STLP_NATIVE_C_INCLUDE_PATH ../include +// it is HP's old cfront-based compiler. +# define _STLP_NO_BOOL 1 +// # define _STLP_DONT_USE_BOOL_TYPEDEF 1 +# define _STLP_NO_NEW_NEW_HEADER 1 +# define _STLP_LIMITED_DEFAULT_TEMPLATES 1 +# define _STLP_NO_SIGNED_BUILTINS +# define _STLP_HAS_NO_NAMESPACES 1 +# define _STLP_NEED_TYPENAME 1 +# define _STLP_NEED_EXPLICIT 1 +# define _STLP_NO_EXCEPTION_SPEC 1 +# define _STLP_NONTEMPL_BASE_MATCH_BUG 1 +# define _STLP_NO_ARROW_OPERATOR 1 +# define _STLP_BASE_MATCH_BUG +# define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1 +# define _STLP_NO_NEW_STYLE_CASTS 1 +// # define _STLP_NO_WCHAR_T 1 +// # define _STLP_LONG_LONG long long +# define _STLP_NEED_MUTABLE 1 +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1 +# define _STLP_NO_BAD_ALLOC 1 +# define _STLP_NO_MEMBER_TEMPLATES 1 +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +# define _STLP_NO_FRIEND_TEMPLATES 1 +# define _STLP_NO_QUALIFIED_FRIENDS 1 +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1 +# define _STLP_MEMBER_POINTER_PARAM_BUG 1 +# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 +# define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1 +// # define _STLP_NO_METHOD_SPECIALIZATION 1 +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1 +# define _STLP_NO_EXCEPTION_HEADER 1 +# define _STLP_DEF_CONST_PLCT_NEW_BUG 1 +# define _STLP_DEF_CONST_DEF_PARAM_BUG 1 +# define _STLP_HAS_NO_NEW_C_HEADERS 1 +// # define _STLP_STATIC_CONST_INIT_BUG 1 +// # define _STLP_THROW_RETURN_BUG 1 +// # define _STLP_LINK_TIME_INSTANTIATION 1 +// # define _STLP_NO_TEMPLATE_CONVERSIONS 1 +# define _STLP_NO_TYPEINFO 1 +# define _STLP_WCHAR_T_IS_USHORT 1 + +#endif /* cfront */ diff --git a/WebKit/android/stlport/stl/config/_hpux.h b/WebKit/android/stlport/stl/config/_hpux.h new file mode 100644 index 0000000..1a67c08 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_hpux.h @@ -0,0 +1,11 @@ +#ifndef __stl_config__hpux_h +#define __stl_config__hpux_h + +#define _STLP_PLATFORM "HP Unix" + +#ifdef __GNUC__ +# define _STLP_NO_WCHAR_T +# define _STLP_NO_LONG_DOUBLE +#endif + +#endif /* __stl_config__hpux_h */ diff --git a/WebKit/android/stlport/stl/config/_ibm.h b/WebKit/android/stlport/stl/config/_ibm.h new file mode 100644 index 0000000..96c504c --- /dev/null +++ b/WebKit/android/stlport/stl/config/_ibm.h @@ -0,0 +1,146 @@ +/* STLport configuration file + * It is internal STLport header - DO NOT include it directly + */ + +#if defined (__IBMCPP__) || defined (__IBMC__) +# define _STLP_COMPILER "Visual Age C++" +#elif defined (__xlC__) +# define _STLP_COMPILER "xlc" +#else +# error "Unknown compiler" +#endif + +#if !defined(__IBMCPP__) || (__IBMCPP__ < 500) +# define _STLP_HAS_NO_NEW_C_HEADERS 1 +#endif + +/* string literal problem, same as with SUN and aCC */ +# define _STLP_INLINE_STRING_LITERAL_BUG 1 +# define _STLP_HAS_NATIVE_FLOAT_ABS + +# define _STLP_DEF_CONST_PLCT_NEW_BUG 1 +# define _STLP_DEF_CONST_DEF_PARAM_BUG 1 + + +# ifdef __IBMCPP__ +# define _STLP_HAS_SPECIFIC_PROLOG_EPILOG +# endif + +/* # if ( defined (__MULTI__) && defined (__WINDOWS__)) + * # define _STLP_WIN32THREADS 1 Only Visual Age 3.5 for Windows + * # endif + */ + +# if ( defined (__MULTI__) && defined (__OS2__)) +# define _STLP_OS2THREADS 1 +# endif + +/* __TEMPINC__ is set when /Ft+ option is used */ +# ifdef __TEMPINC__ +# define _STLP_LINK_TIME_INSTANTIATION 1 +# endif + +# if defined (__MVS__) +/* long long support is buggy - reported by Tinny Ng + * # if __EXTENDED__ && __COMPILER_VER__ >= 0x22060000 + * # define _STLP_LONG_LONG long long + * # endif + */ +/* boris : hstash reported it can be treated like UNIX */ +# define _STLP_UNIX 1 +# define _STLP_NO_TYPEINFO 1 +# undef _STLP_NATIVE_INCLUDE_PATH +# define _STLP_NATIVE_INCLUDE_PATH /usr/lpp/ioclib/include +/* same for C headers like <string.h> */ +# undef _STLP_NATIVE_C_INCLUDE_PATH +# define _STLP_NATIVE_C_INCLUDE_PATH /usr/include +# define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH /usr/include + +# elif (defined (__WINDOWS__) || defined (_AIX) || defined (__OS2__) ) && (__IBMCPP__ >= 350) + +# define _STLP_LONG_LONG long long + +#endif + +#if !( defined( __xlC__ ) && __xlC__ >= 0x500 ) + +/* AIX xlC 3.1 , 3.0.1 ==0x301 + * Visual Age C++ 3.x + * OS-390 C++ + * fbp : should be more version-specific! + */ + +# define _STLP_NO_BOOL 1 +# define _STLP_DONT_USE_BOOL_TYPEDEF 1 +# define _STLP_LIMITED_DEFAULT_TEMPLATES 1 +# define _STLP_HAS_NO_NAMESPACES 1 +# define _STLP_NEED_TYPENAME 1 +# define _STLP_NEED_EXPLICIT 1 +# define _STLP_NO_ARROW_OPERATOR 1 +# define _STLP_NO_NEW_STYLE_CASTS 1 +# define _STLP_NO_WCHAR_T 1 +# define _STLP_NEED_MUTABLE 1 +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1 +# define _STLP_NO_BAD_ALLOC 1 + +# define _STLP_NO_MEMBER_TEMPLATES 1 +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +# define _STLP_NO_FRIEND_TEMPLATES 1 +# define _STLP_NO_QUALIFIED_FRIENDS 1 +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1 + +# define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1 +# define _STLP_NO_METHOD_SPECIALIZATION 1 +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1 +# define _STLP_NO_EXCEPTION_HEADER 1 + +# define _STLP_NO_NEW_NEW_HEADER 1 + +# if defined (__OS2__) && (__IBMCPP__ <= 350) +# define _STLP_NO_TYPEINFO 1 +# endif +# define _STLP_NO_NEW_NEW_HEADER 1 + +# define _STLP_STATIC_CONST_INIT_BUG 1 +/* # define _STLP_THROW_RETURN_BUG 1 */ + + +# define _STLP_NO_TEMPLATE_CONVERSIONS 1 +# define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1 + +/* AIX xlC, Visual Age 3.0 for OS/2 and MS */ +# define _STLP_TRIVIAL_DESTRUCTOR_BUG + +# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 +# define _STLP_NONTEMPL_BASE_MATCH_BUG 1 + +#if __IBMCPP__ <= 350 +# define _STLP_NEED_UNREACHABLE_RETURN 1 +#endif + +#if __IBMCPP__ < 350 +# define _STLP_NO_LONG_DOUBLE 1 +#endif + +#if __IBMCPP__ >= 365 +/* does not have new C headers, but has div() */ +# define _STLP_LDIV +#endif + +#endif /* xlC 5 */ + +/* detect xlC5 by: */ +#if defined(__IBMCPP__) && (500 <= __IBMCPP__) && (__IBMCPP__ < 700) +# define _STLP_USE_EXCEPTIONS 1 +# define _STLP_STATIC_CONST_INIT_BUG 1 +/* #pragma report(disable,CPPC1500029) + * unsigned 32-bit integer type + */ +# define _STLP_UINT32_T unsigned int +# if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4) +# define _STLP_RAND48 1 +# endif +/* # define _STLP_RAND48 1 */ +#endif /* __IBMCPP__ == 500 */ diff --git a/WebKit/android/stlport/stl/config/_icc.h b/WebKit/android/stlport/stl/config/_icc.h new file mode 100644 index 0000000..1fc1bce --- /dev/null +++ b/WebKit/android/stlport/stl/config/_icc.h @@ -0,0 +1,44 @@ +// STLport configuration file +// It is internal STLport header - DO NOT include it directly +// A list of Intel compiler for Linux portion of STLport settings. + +#define _STLP_COMPILER "Intel ICC" + +#define _STLP_LONG_LONG long long + +// Edit relative path below (or put full path) to get native +// compiler headers included. Default is "../include". +// C headers may reside in different directory, so separate macro is provided. +#if (__INTEL_COMPILER < 800) +# define _STLP_NATIVE_INCLUDE_PATH ../include +# define _STLP_NATIVE_C_INCLUDE_PATH ../include +# define _STLP_NATIVE_CPP_C_INCLUDE_PATH ../include +#endif + +#if (__INTEL_COMPILER >= 800) +# define _STLP_NATIVE_INCLUDE_PATH ../include/c++ +# define _STLP_NATIVE_C_INCLUDE_PATH ../include +# define _STLP_NATIVE_CPP_C_INCLUDE_PATH ../include + +#endif /* __INTEL_COMPILER >= 800 */ + +#define _STLP_HAS_NO_NEW_C_HEADERS 1 +#define _STLP_VENDOR_GLOBAL_CSTD 1 + +/* Systems having GLIBC installed have different traits */ +#if !defined (_STLP_USE_GLIBC) && defined (__linux__) +# define _STLP_USE_GLIBC +# define _XOPEN_SOURCE 600 +#endif + +#undef _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT + + +#ifndef __GNUC__ +# define __GNUC__ 3 +#endif + +//#define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1 + +#define _STLP_NO_FORCE_INSTANTIATE +//#define _REENTRANT diff --git a/WebKit/android/stlport/stl/config/_intel.h b/WebKit/android/stlport/stl/config/_intel.h new file mode 100644 index 0000000..af8022f --- /dev/null +++ b/WebKit/android/stlport/stl/config/_intel.h @@ -0,0 +1,73 @@ +// STLport configuration file +// It is internal STLport header - DO NOT include it directly + +#define _STLP_COMPILER "Intel ICL" + +#define _STLP_IMPORT_TEMPLATE_KEYWORD extern + +/* You need to undef following macro if your icl install is binded to MSVC 6 + * native lib and you are building with /Qvc7 or /Qvc7.1 or /Qvc8 option. + */ +/* #define _STLP_MSVC_LIB 1200 */ +/* You need to undef following macro if your icl install is binded to MSVC .Net 2002 + * native lib and you are building without any /Qvc* option or with /Qvc6 or /Qvc7.1 + * or /Qvc8 option. + */ +/* #define _STLP_MSVC_LIB 1300 */ +/* You need to undef following macro if your icl install is binded to MSVC .Net 2002 + * native lib and you are building without any /Qvc* option or with /Qvc6 or /Qvc7 + * or /Qvc8 option. + */ +/* #define _STLP_MSVC_LIB 1310 */ +/* You need to undef following macro if your icl install is binded to MSVC .Net 2002 + * native lib and you are building without any /Qvc* option or with /Qvc6 or /Qvc7 + * or /Qvc7.1 option. + */ +/* #define _STLP_MSVC_LIB 1400 */ + +#include <stl/config/_msvc.h> + +#if defined (_STLP_DONT_RETURN_VOID) +# undef _STLP_DONT_RETURN_VOID +#endif + +#if (__ICL >= 900) +/* # undef _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT */ +# if !defined (_STLP_DONT_USE_EXCEPTIONS) +# define _STLP_NOTHROW throw() +# endif +#endif + +#if (__ICL <= 810) +/* If method specialization is activated, compiler do not export some + * symbols anymore. + */ +# define _STLP_NO_METHOD_SPECIALIZATION 1 +#endif + +#if (__ICL >= 800) +# define _STLP_STATIC_CONST_INIT_BUG 1 +#endif + +#if (__ICL >= 450) +# define _STLP_DLLEXPORT_NEEDS_PREDECLARATION 1 +#endif + +#if (__ICL < 450) +/* only static STLport lib works for ICL */ +# undef _STLP_USE_STATIC_LIB +# undef _STLP_USE_DYNAMIC_LIB +# define _STLP_USE_STATIC_LIB +/* disable hook which makes template symbols to be searched for in the library */ +# undef _STLP_NO_CUSTOM_IO +#endif + +#undef _STLP_LONG_LONG +#define _STLP_LONG_LONG long long + +#if defined (__cplusplus) && (__ICL >= 900) && (_STLP_MSVC_LIB < 1300) +namespace std +{ + void _STLP_CALL unexpected(); +} +#endif diff --git a/WebKit/android/stlport/stl/config/_kai.h b/WebKit/android/stlport/stl/config/_kai.h new file mode 100644 index 0000000..5b2bedb --- /dev/null +++ b/WebKit/android/stlport/stl/config/_kai.h @@ -0,0 +1,48 @@ +// STLport config file for KAI C++ compiler + +#if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4) +# define _STLP_RAND48 1 +#endif + +# ifndef __KAI_STRICT /* _NO_LONGLONG */ +# define _STLP_LONG_LONG long long +# endif + +# if !defined (__EXCEPTIONS) && ! defined (_EXCEPTIONS) +# define _STLP_HAS_NO_EXCEPTIONS +# endif + +# ifndef __BUILDING_STLPORT +# define _STLP_LINK_TIME_INSTANTIATION 1 +# endif + +// two levels of macros do not work good with kcc. +# define _STLP_NATIVE_HEADER(header) <../include/##header> +# define _STLP_NATIVE_C_HEADER(header) <../include/##header> +# define _STLP_NATIVE_CPP_C_HEADER(header) <../include/##header> +# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../include/##header> + +# ifdef _WIN32 +# define _STLP_MINIMUM_IMPORT_STD +# endif + +// KAI C++ uses EDG front-end, but apparently different switches +// # define __EDG_SWITCHES 1 + + +# define _STLP_VENDOR_GLOBAL_CSTD 1 +# define _STLP_VENDOR_MB_NAMESPACE std + +// boris : some of those may also apply to KCC 3.4 +# if __KCC_VERSION < 4000 +# define _STLP_VENDOR_GLOBAL_EXCEPT_STD 1 + +# endif + +# if defined (__sgi) +// this requires some discrimination on whether we are actually on +// a system officially supported by KAI. +# define _STLP_HAS_NO_NEW_C_HEADERS 1 +# include <standards.h> +# endif + diff --git a/WebKit/android/stlport/stl/config/_linux.h b/WebKit/android/stlport/stl/config/_linux.h new file mode 100644 index 0000000..342cd8b --- /dev/null +++ b/WebKit/android/stlport/stl/config/_linux.h @@ -0,0 +1,93 @@ +#ifndef __stl_config__linux_h +#define __stl_config__linux_h + +#define _STLP_PLATFORM "Linux" + +#include <features.h> + +/* This is defined wether library in use is glibc or not. + This may be treated as presence of GNU libc compatible + header files (these define is not really intended to check + for the presence of a particular library, but rather is used + to define an INTERFACE.) */ +#ifndef _STLP_USE_GLIBC +# define _STLP_USE_GLIBC 1 +#endif + +#define _STLP_UNIX 1 + +#if defined(_REENTRANT) && !defined(_PTHREADS) +# define _PTHREADS +#endif + +#ifdef __UCLIBC__ /* uClibc 0.9.27 */ +# define _STLP_USE_UCLIBC 1 +# if !defined(__UCLIBC_HAS_WCHAR__) +# ifndef _STLP_NO_WCHAR_T +# define _STLP_NO_WCHAR_T +# endif +# ifndef _STLP_NO_MBSTATE_T +# define _STLP_NO_MBSTATE_T +# endif +# ifndef _STLP_NO_NATIVE_WIDE_STREAMS +# define _STLP_NO_NATIVE_WIDE_STREAMS +# endif +# endif /* __UCLIBC_HAS_WCHAR__ */ + /* Hmm, bogus _GLIBCPP_USE_NAMESPACES seems undefined... */ +# define _STLP_VENDOR_GLOBAL_CSTD 1 +# if defined(_STLP_REAL_LOCALE_IMPLEMENTED) + /* locale in uClibc is very restricted */ + /* recheck if __UCLIBC_HAS_LOCALE__ defined...*/ +# undef _STLP_REAL_LOCALE_IMPLEMENTED +# endif +#endif + + +#if defined(_PTHREADS) +# define _STLP_THREADS +# define _STLP_PTHREADS +/* +# ifndef __USE_UNIX98 +# define __USE_UNIX98 +# endif +*/ +/* This feature exist at least since glibc 2.2.4 */ +/* # define __FIT_XSI_THR */ /* Unix 98 or X/Open System Interfaces Extention */ +# ifdef __USE_XOPEN2K +/* The IEEE Std. 1003.1j-2000 introduces functions to implement spinlocks. */ +# ifndef __UCLIBC__ /* There are no spinlocks in uClibc 0.9.27 */ +# define _STLP_USE_PTHREAD_SPINLOCK +# else +# ifndef _STLP_DONT_USE_PTHREAD_SPINLOCK + /* in uClibc (0.9.26) pthread_spinlock* declared in headers + * but absent in library */ +# define _STLP_DONT_USE_PTHREAD_SPINLOCK +# endif +# endif +/* # define __FIT_PSHARED_MUTEX */ +# endif +#endif + +/* Endiannes */ +#include <endian.h> +#if !defined(__BYTE_ORDER) || !defined(__LITTLE_ENDIAN) || !defined(__BIG_ENDIAN) +# error "One of __BYTE_ORDER, __LITTLE_ENDIAN and __BIG_ENDIAN undefined; Fix me!" +#endif + +#if ( __BYTE_ORDER == __LITTLE_ENDIAN ) +# define _STLP_LITTLE_ENDIAN 1 +#elif ( __BYTE_ORDER == __BIG_ENDIAN ) +# define _STLP_BIG_ENDIAN 1 +#else +# error "__BYTE_ORDER neither __BIG_ENDIAN nor __LITTLE_ENDIAN; Fix me!" +#endif + +#if defined(__GNUC__) && (__GNUC__ < 3) +# define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1 +/* +# define _STLP_NO_NATIVE_WIDE_STREAMS 1 +*/ +#endif + + +#endif /* __stl_config__linux_h */ diff --git a/WebKit/android/stlport/stl/config/_mac.h b/WebKit/android/stlport/stl/config/_mac.h new file mode 100644 index 0000000..d80cc71 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_mac.h @@ -0,0 +1 @@ +#define _STLP_PLATFORM "Mac" diff --git a/WebKit/android/stlport/stl/config/_macosx.h b/WebKit/android/stlport/stl/config/_macosx.h new file mode 100644 index 0000000..3d3452b --- /dev/null +++ b/WebKit/android/stlport/stl/config/_macosx.h @@ -0,0 +1,7 @@ +#define _STLP_PLATFORM "Mac OS X" + +#if defined (__BIG_ENDIAN__) +# define _STLP_BIG_ENDIAN 1 +#elif defined (__LITTLE_ENDIAN__) +# define _STLP_LITTLE_ENDIAN 1 +#endif diff --git a/WebKit/android/stlport/stl/config/_mlc.h b/WebKit/android/stlport/stl/config/_mlc.h new file mode 100644 index 0000000..8687d0b --- /dev/null +++ b/WebKit/android/stlport/stl/config/_mlc.h @@ -0,0 +1,7 @@ +// STLport configuration file +// It is internal STLport header - DO NOT include it directly + +#define _STLP_NO_MEMBER_TEMPLATES // Compiler does not support member templates +#define _STLP_NO_MEMBER_TEMPLATE_CLASSES // Compiler does not support member template classes + +#define _STLP_HAS_NEW_NEW_HEADER diff --git a/WebKit/android/stlport/stl/config/_msvc.h b/WebKit/android/stlport/stl/config/_msvc.h new file mode 100644 index 0000000..7c5036f --- /dev/null +++ b/WebKit/android/stlport/stl/config/_msvc.h @@ -0,0 +1,353 @@ +/* STLport configuration file + * It is internal STLport header - DO NOT include it directly + * Microsoft Visual C++ 6.0, 7.0, 7.1, 8.0, ICL + */ + +#if !defined (_STLP_COMPILER) +# define _STLP_COMPILER "Microsoft Visual Studio C++" +#endif + +#if !defined (__ICL) && !defined (_STLP_MSVC) +# define _STLP_MSVC _MSC_VER +#endif + +#if !defined (_STLP_MSVC_LIB) +# define _STLP_MSVC_LIB _MSC_VER +#endif + +#if defined (__BUILDING_STLPORT) && defined (_MANAGED) +/* Building a managed version of STLport is not supported because we haven't + * found a good reason to support it. However, building a managed translation + * unit using STLport _is_ supported. + */ +# error Sorry but building a managed version of STLport is not supported. +#endif + +#if defined (_STLP_USING_PLATFORM_SDK_COMPILER) +/* This is a specific section for compilers coming with platform SDKs. Native + * library coming with it is different from the one coming with commercial + * MSVC compilers so there is some specific settings. + */ +# define _STLP_NATIVE_INCLUDE_PATH ../crt +# define _STLP_VENDOR_GLOBAL_CSTD +# define _STLP_VENDOR_TERMINATE_STD +# define _STLP_GLOBAL_NEW_HANDLER +# if (_STLP_MSVC_LIB <= 1400) +/* We hope this bug will be fixed in future versions. */ +# define _STLP_NEW_DONT_THROW_BAD_ALLOC 1 +# endif +#endif + +#define _STLP_CALL __cdecl + +#ifndef _STLP_LONG_LONG +# define _STLP_LONG_LONG __int64 +#endif + +#define _STLP_PRAGMA_ONCE + +/* These switches depend on compiler flags. We are hoping here that compilers + * simulating MSVC behavior use identical macros to report compilation context. + * Otherwise those macros will have to be undef in specific compiler configuration + * files. + */ +#ifndef _CPPUNWIND +# define _STLP_DONT_USE_EXCEPTIONS 1 +#endif + +#ifndef _CPPRTTI +# define _STLP_NO_RTTI 1 +#endif + +#if defined (_MT) && !defined (_STLP_NO_THREADS) && !defined (_REENTRANT) +# define _REENTRANT 1 +#endif + +#if !defined (_NATIVE_WCHAR_T_DEFINED) +# define _STLP_WCHAR_T_IS_USHORT 1 +#endif + +#define _STLP_MINIMUM_IMPORT_STD +#define _STLP_NO_VENDOR_STDLIB_L 1 + +#if defined (_STLP_MSVC) + +#define _STLP_NORETURN_FUNCTION __declspec(noreturn) + +/* Full compiler version comes from boost library intrinsics.hpp header. */ +# if defined (_MSC_FULL_VER) && (_MSC_FULL_VER >= 140050215) +# define _STLP_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +# define _STLP_HAS_TRIVIAL_COPY(T) __has_trivial_copy(T) +# define _STLP_HAS_TRIVIAL_ASSIGN(T) __has_trivial_assign(T) +# define _STLP_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) +# define _STLP_IS_POD(T) __is_pod(T) +# define _STLP_HAS_TYPE_TRAITS_INTRINSICS +# endif + +# ifndef _STLP_MSVC50_COMPATIBILITY +# define _STLP_MSVC50_COMPATIBILITY 1 +# endif + +# define _STLP_DLLEXPORT_NEEDS_PREDECLARATION 1 +# define _STLP_HAS_SPECIFIC_PROLOG_EPILOG 1 + +/* # ifndef __BUILDING_STLPORT + * # define _STLP_USE_TEMPLATE_EXPORT 1 + * # endif + */ +# if (_STLP_MSVC <= 1401) +# define _STLP_STATIC_CONST_INIT_BUG 1 +# endif + +/** Note: the macro _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT is defined +unconditionally and undef'ed here when applicable. */ +# if defined(UNDER_CE) +/* eVCx: +uncaught_exception is declared in the SDKs delivered with eVC4 (eVC3 is +unknown) and they all reside in namespace 'std' there. However, they are not +part of any lib so linking fails. When using VC8 to crosscompile for CE 5 on +an ARMV4I, the uncaught_exception test fails, the function returns the wrong +value. */ +# else +/* VCx: +These are present at least since VC6, but the uncaught_exception() of VC6 is +broken, it returns the wrong value in the unittests. 7.1 and later seem to +work, 7.0 is still unknown (we assume it works until negative report). */ +# if (_STLP_MSVC >= 1300)// VC7 and later +# undef _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT +# if !defined (_STLP_DONT_USE_EXCEPTIONS) +# define _STLP_NOTHROW throw() +# endif +# endif +# endif + +# if (_STLP_MSVC <= 1300) +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1 +/* There is no partial spec, and MSVC breaks on simulating it for iterator_traits queries */ +# define _STLP_USE_OLD_HP_ITERATOR_QUERIES +# define _STLP_NO_TYPENAME_IN_TEMPLATE_HEADER +# define _STLP_NO_METHOD_SPECIALIZATION 1 +# define _STLP_DEF_CONST_PLCT_NEW_BUG 1 +# define _STLP_NO_TYPENAME_ON_RETURN_TYPE 1 +/* VC++ cannot handle default allocator argument in template constructors */ +# define _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS +# define _STLP_NO_QUALIFIED_FRIENDS 1 +# define _STLP_NO_FRIEND_TEMPLATES +/* Fails to properly resolve call to sin() from within sin() */ +# endif + +# if (_STLP_MSVC < 1300) +# define _STLP_NO_IEC559_SUPPORT 1 +# endif + +# if (_STLP_MSVC < 1300) /* including MSVC 6.0 */ +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +# define _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE 1 +# endif + +# if (_STLP_MSVC >= 1200) +# define _STLP_HAS_NATIVE_FLOAT_ABS 1 +# endif + +// TODO: some eVC4 compilers report _MSC_VER 1201 or 1202, which category do they belong to? +# if (_STLP_MSVC > 1200) && (_STLP_MSVC < 1310) +# define _STLP_NO_MOVE_SEMANTIC +# endif + +# if (_STLP_MSVC < 1300) +/* TODO: remove this if it is handled and documented elsewhere + * dums: VC6 do not handle correctly member templates of class that are explicitely + * instanciated to be exported. There is a workaround, seperate the non template methods + * from the template ones within 2 different classes and only export the non template one. + * It is implemented for basic_string and locale at the writing of this note. + * However this problem hos not been considered as important enough to remove template member + * methods for other classes. Moreover Boost (www.boost.org) required it to be granted. + * The workaround is activated thanks to the _STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND macro defined + * later in this config file. + */ +/* +# if defined (_DLL) +# define _STLP_NO_MEMBER_TEMPLATES 1 +# endif +*/ + +/* Boris : not defining this macro for SP5 causes other problems */ +/*# if !defined (_MSC_FULL_VER) || (_MSC_FULL_VER < 12008804 ) */ +# define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS 1 +/*# endif */ +# define _STLP_DONT_USE_BOOL_TYPEDEF 1 +# define _STLP_DONT_RETURN_VOID 1 +# endif + +/* + * MSVC6 is known to have many trouble with namespace management but + * MSVC .Net 2003 and 2005 also have a bug difficult to reproduce without + * STLport: + * namespace stlp_std { + * typedef int foo_int; + * } + * #include <map> + * const foo_int bar = 0; + * + * As you can see foo is available without namespace specification as if + * a using namespace stlp_std has been performed. Defining _STLP_USING_NAMESPACE_BUG + * restore the expected compilation error. + */ +# define _STLP_USING_NAMESPACE_BUG 1 + +# if (_STLP_MSVC < 1300) /* MSVC 6.0 and earlier */ +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1 +/* defined for DEBUG and NDEBUG too, to allow user mix own debug build with STLP release library */ +# define _STLP_USE_ABBREVS +# endif + +// TODO: what is the earliest version for this? If it is 1200, use _STLP_MSVC>=1200. +# if (_STLP_MSVC > 1100) && (_STLP_MSVC < 1300) +typedef char __stl_char; +# define _STLP_DEFAULTCHAR __stl_char +# endif + +# if (_STLP_MSVC < 1200) /* before VC++ 6.0 */ +/* # define _STLP_NO_MEMBER_TEMPLATES 1 */ +# define _STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS 1 +# define _STLP_DONT_USE_PARTIAL_SPEC_WRKD 1 +# define _STLP_QUALIFIED_SPECIALIZATION_BUG 1 +# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 +# define _STLP_THROW_RETURN_BUG 1 +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 +# define _STLP_DEF_CONST_DEF_PARAM_BUG 1 +# endif + +# if (_STLP_MSVC < 1100 ) +# ifndef _STLP_USE_NO_IOSTREAMS +# define _STLP_USE_NO_IOSTREAMS +# endif +/* # define _STLP_NESTED_TYPE_PARAM_BUG 1 */ +/* Debug mode does not work for 4.2 */ +# if defined (_STLP_DEBUG) +# pragma message ("STLport debug mode does not work for VC++ 4.2, turning _STLP_DEBUG off ...") +# undef _STLP_DEBUG +# endif +# define _STLP_NO_BOOL 1 +# define _STLP_NEED_TYPENAME 1 +# define _STLP_NEED_EXPLICIT 1 +# define _STLP_NEED_MUTABLE 1 +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX +# define _STLP_LIMITED_DEFAULT_TEMPLATES 1 +# define _STLP_NONTEMPL_BASE_MATCH_BUG 1 +# define _STLP_BROKEN_USING_DIRECTIVE 1 +# define _STLP_NO_ARROW_OPERATOR 1 +# define _STLP_NO_SIGNED_BUILTINS 1 +# define _STLP_NO_EXCEPTION_SPEC 1 +# define _STLP_HAS_NO_NAMESPACES 1 +# define _STLP_NO_AT_MEMBER_FUNCTION 1 +# define _STLP_NO_MEMBER_TEMPLATES 1 +# endif /* 1100 */ + +#endif /* _STLP_MSVC */ + +/** The desktop variants starting with VC8 have a set of more secure replacements +for the error-prone string handling functions of the C standard lib. */ +#if (_STLP_MSVC_LIB >= 1400) && !defined (_STLP_USING_PLATFORM_SDK_COMPILER) && !defined(UNDER_CE) +# define _STLP_USE_SAFE_STRING_FUNCTIONS 1 +#endif + +#if (_STLP_MSVC_LIB <= 1310) +# define _STLP_VENDOR_GLOBAL_CSTD +#endif + +#if (_STLP_MSVC_LIB >= 1300) && !defined(UNDER_CE) +/* Starting with MSVC 7.0 and compilers simulating it, + * we assume that the new SDK is granted: + */ +# define _STLP_NEW_PLATFORM_SDK 1 +#endif + +#if (_STLP_MSVC_LIB < 1300) /* including MSVC 6.0 */ +# define _STLP_GLOBAL_NEW_HANDLER 1 +# define _STLP_VENDOR_UNEXPECTED_STD +# define _STLP_NEW_DONT_THROW_BAD_ALLOC 1 +#endif + +#if (_STLP_MSVC_LIB < 1100) +/* up to 4.2, library is in global namespace */ +# define _STLP_VENDOR_GLOBAL_STD +#endif + +#if (_STLP_MSVC_LIB <= 1010) +/* "bool" is reserved in MSVC 4.1 while <yvals.h> absent, so : */ +# define _STLP_NO_BAD_ALLOC +# define _STLP_HAS_NO_NEW_C_HEADERS 1 +# define _STLP_NO_NEW_NEW_HEADER 1 +#elif (_STLP_MSVC_LIB < 1100) +/* VC++ 4.2 and higher */ +# define _STLP_YVALS_H 1 +# define _STLP_USE_NO_IOSTREAMS 1 +#endif + +#define _STLP_EXPORT_DECLSPEC __declspec(dllexport) +#define _STLP_IMPORT_DECLSPEC __declspec(dllimport) + +#if !defined (_STLP_MSVC) || (_STLP_MSVC >= 1100) +# define _STLP_CLASS_EXPORT_DECLSPEC __declspec(dllexport) +# define _STLP_CLASS_IMPORT_DECLSPEC __declspec(dllimport) +#endif + +#if defined (__DLL) || defined (_DLL) || defined (_RTLDLL) || defined (_AFXDLL) +# define _STLP_RUNTIME_DLL +#endif +#if defined (__BUILDING_STLPORT) && \ + (defined (_STLP_USE_DYNAMIC_LIB) || \ + defined (_STLP_RUNTIME_DLL) && !defined (_STLP_USE_STATIC_LIB)) +# define _STLP_DLL +#endif +#include <stl/config/_detect_dll_or_lib.h> +#undef _STLP_RUNTIME_DLL +#undef _STLP_DLL + +#if defined (_STLP_USE_DYNAMIC_LIB) +# undef _STLP_USE_DECLSPEC +# define _STLP_USE_DECLSPEC 1 +# if (_STLP_MSVC >= 1200) && (_STLP_MSVC < 1300) +# define _STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND 1 +# endif +#endif + +#if !defined (_STLP_IMPORT_TEMPLATE_KEYWORD) +# if !defined (_MSC_EXTENSIONS) || defined(_STLP_MSVC) && _STLP_MSVC >= 1300 +# define _STLP_IMPORT_TEMPLATE_KEYWORD +# else +# define _STLP_IMPORT_TEMPLATE_KEYWORD extern +# endif +#endif +#define _STLP_EXPORT_TEMPLATE_KEYWORD + +#if defined (_STLP_MSVC) && (_STLP_MSVC < 1200) +/* only static STLport lib now works for VC 5.0 */ +# undef _STLP_USE_STATIC_LIB +# undef _STLP_USE_DYNAMIC_LIB +# define _STLP_USE_STATIC_LIB +/* disable hook which makes template symbols to be searched for in the library */ +# undef _STLP_NO_CUSTOM_IO +#endif + +#include <stl/config/_auto_link.h> + +#if defined (_STLP_USING_PLATFORM_SDK_COMPILER) +/* The Windows 64 bits SDK required for the moment link to bufferoverflowU.lib for + * additional buffer overrun checks. Rather than require the STLport build system and + * users to explicitely link with it we use the MSVC auto link feature. + */ +# if !defined (_STLP_DONT_USE_AUTO_LINK) || defined (__BUILDING_STLPORT) +# pragma comment (lib, "bufferoverflowU.lib") +# if defined (_STLP_VERBOSE_AUTO_LINK) +# pragma message ("STLport: Auto linking to bufferoverflowU.lib") +# endif +# endif +#endif + +/* Local Variables: + * mode:C++ + * End: + */ diff --git a/WebKit/android/stlport/stl/config/_mwccnlm.h b/WebKit/android/stlport/stl/config/_mwccnlm.h new file mode 100644 index 0000000..6eaf9b5 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_mwccnlm.h @@ -0,0 +1,88 @@ +// STLport configuration file +// It is internal STLport header - DO NOT include it directly + +#define _STLP_COMPILER "Metrowerks CodeWarrior" + +// Bring in definition of __MSL__ and related items +#include <mslGlobals.h> +#include <ansi_parms.h> + +// *** CodeWarrior Compiler Common Features *** +#if __option(longlong) +# define _STLP_LONG_LONG long long +#endif + +#define _STLP_USE_UNIX_EMULATION_IO 1 + +#define _STLP_USE_AUTO_PTR_CONVERSIONS 1 + +#ifdef __INTEL__ +# define _STLP_LITTLE_ENDIAN +#else +# define _STLP_BIG_ENDIAN +#endif + +#if defined(_MSL_NO_LOCALE) +# define _STLP_NO_IMPORT_LOCALE +#endif + +#if !__option( wchar_type ) +# define _STLP_WCHAR_T_IS_USHORT +#endif + +#if __MWERKS__ < 0x3000 +// *** CodeWarrior Compiler Common Bugs *** +# define __MSL_FIX_ITERATORS__(myType) // Some MSL headers rely on this +# define _STLP_NO_FRIEND_TEMPLATES 1 // Bug mysteriously reintroduced in this version. +# define _STLP_THROW_RETURN_BUG 1 +#endif + +#if __MWERKS__ >= 0x2405 +# define _STLP_HAS_NATIVE_FLOAT_ABS +#endif + +#if __MWERKS__ < 0x2405 +# define _STLP_STATIC_CONST_INIT_BUG +#endif + +#if __MWERKS__ <= 0x2303 +# define _STLP_NO_TEMPLATE_CONVERSIONS 1 +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +#endif + +#if __MWERKS__ < 0x2301 +# define _STLP_MEMBER_SPECIALIZATION_BUG 1 +#endif + +#if __MWERKS__ < 0x2300 // CW Pro5 features +# define _STLP_INLINE_MEMBER_TEMPLATES 1 +# define _STLP_RELOPS_IN_STD_BUG 1 +# define _STLP_DEF_CONST_PLCT_NEW_BUG 1 +# define _STLP_DEF_CONST_DEF_PARAM_BUG 1 +# define _STLP_NO_TYPENAME_ON_RETURN_TYPE +#endif + +// fixes to native inclusion wrappers. +#if __MWERKS__ >= 0x2300 // CWPro5 changes paths - dwa 2/28/99 +# define _STLP_NATIVE_INCLUDE_PATH ../nwsdk/include/nlm +# define _STLP_NATIVE_C_INCLUDE_PATH ../nwsdk/include/nlm +# define _STLP_NATIVE_HEADER(header) <../nwsdk/include/nlm/##header> +# define _STLP_NATIVE_CPP_C_HEADER(header) <../Libraries/MSL C++/Include/##header> +# define _STLP_NATIVE_C_HEADER(header) <../nwsdk/include/nlm/##header> +# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../Libraries/MSL C++/Include/##header> + +# define _STLP_VENDOR_GLOBAL_CSTD 1 +# define _STLP_NO_VENDOR_STDLIB_L 1 +# define _STLP_NO_VENDOR_MATH_F 1 +# define _STLP_NO_VENDOR_MATH_L 1 + //# define _MSL_NO_THROW_SPECS + //# define _STD + //# define _CSTD +#endif + +// fbp +#if !defined( __MSL_CPP__ ) || __MSL_CPP__ <= 0x4105 +# define _STLP_NO_NATIVE_WIDE_STREAMS 1 +# endif + +#define _STLP_DLLEXPORT_NEEDS_PREDECLARATION 1 diff --git a/WebKit/android/stlport/stl/config/_mwerks.h b/WebKit/android/stlport/stl/config/_mwerks.h new file mode 100644 index 0000000..e6da32b --- /dev/null +++ b/WebKit/android/stlport/stl/config/_mwerks.h @@ -0,0 +1,161 @@ +// STLport configuration file +// It is internal STLport header - DO NOT include it directly + +#define _STLP_COMPILER "Metrowerk Codewarrior" + +// Bring in definition of __MSL__ and related items +#include <mslGlobals.h> +#include <ansi_parms.h> + +// +// Compiler features +// + + +// *** CodeWarrior Compiler Common Features *** +# if __option(longlong) +# define _STLP_LONG_LONG long long +# endif + +# define _STLP_USE_UNIX_EMULATION_IO 1 + +# define _STLP_USE_AUTO_PTR_CONVERSIONS 1 + +# ifdef __INTEL__ +# define _STLP_LITTLE_ENDIAN +# else +# define _STLP_BIG_ENDIAN +# endif + +#if defined(_MSL_NO_LOCALE) +#define _STLP_NO_IMPORT_LOCALE +#endif +#if !__option( wchar_type ) +# define _STLP_WCHAR_T_IS_USHORT +#endif + +# if __MWERKS__ < 0x3000 +// *** CodeWarrior Compiler Common Bugs *** +# define __MSL_FIX_ITERATORS__(myType) // Some MSL headers rely on this +# define _STLP_NO_FRIEND_TEMPLATES 1 // Bug mysteriously reintroduced in this version. +# define _STLP_THROW_RETURN_BUG 1 +# endif + +// *** Version-specific settings *** + +# if __MWERKS__ >= 0x2405 +# define _STLP_HAS_NATIVE_FLOAT_ABS +# endif + +# if __MWERKS__ < 0x2405 +# define _STLP_STATIC_CONST_INIT_BUG +# endif + +# if __MWERKS__ <= 0x2303 +# define _STLP_NO_TEMPLATE_CONVERSIONS 1 +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +# endif + +# if __MWERKS__ < 0x2301 +# define _STLP_MEMBER_SPECIALIZATION_BUG 1 +# endif + +# if __MWERKS__ < 0x2300 // CW Pro5 features +# define _STLP_INLINE_MEMBER_TEMPLATES 1 +# define _STLP_RELOPS_IN_STD_BUG 1 +# define _STLP_DEF_CONST_PLCT_NEW_BUG 1 +# define _STLP_DEF_CONST_DEF_PARAM_BUG 1 +# define _STLP_NO_TYPENAME_ON_RETURN_TYPE +# endif + +# if __MWERKS__ < 0x2200 // CW Pro4 features +# define _STLP_BROKEN_USING_DIRECTIVE 1 +# define _STLP_NO_MEMBER_TEMPLATES 1 +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +# define _STLP_NO_FRIEND_TEMPLATES 1 +# define _STLP_NO_QUALIFIED_FRIENDS 1 +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1 +# endif + +# if __MWERKS__ < 0x2100 // CW Pro3 features +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 +# define _STLP_HAS_NO_NAMESPACES 1 +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1 + +# define _STLP_NEED_TYPENAME 1 +# define _STLP_NO_ARROW_OPERATOR 1 +# define _STLP_TEMPLATE_PARAM_SUBTYPE_BUG 1 +# define _STLP_FORCED_INLINE_INSTANTIATION_BUG 1 +# define _STLP_MULTI_CONST_TEMPLATE_ARG_BUG 1 +# define _STLP_INLINE_NAME_RESOLUTION_BUG 1 +// *** Metrowerks Standard Library Bug *** +# define _STLP_MSVC50_COMPATIBILITY 1 +# endif + +# if __MWERKS__ < 0x2000 // v. 2.0 features +# define _STLP_NO_WCHAR_T 1 +# define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1 +# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 // dwa 8/21/97 - this bug fixed for CWPro2 +# endif + +# if __MWERKS__ < 0x1900 // dwa 8/19/97 - 1.9 Compiler feature defines +# define _STLP_LIMITED_DEFAULT_TEMPLATES 1 +# define _STLP_BASE_TYPEDEF_BUG 1 +# define _STLP_BASE_MATCH_BUG 1 +# define _STLP_NONTEMPL_BASE_MATCH_BUG 1 +# define _STLP_DEFAULT_TYPE_PARAM 1 // More limited template parameters + +# if __MWERKS__ < 0x1800 + __GIVE_UP_WITH_STL(CW_18) +# endif + +# endif + + +// fixes to native inclusion wrappers. +# if __MWERKS__ >= 0x2300 // CWPro5 changes paths - dwa 2/28/99 +# define _STLP_NATIVE_INCLUDE_PATH ../include +# define _STLP_NATIVE_C_INCLUDE_PATH ../include +# define _STLP_NATIVE_HEADER(header) <../include/##header> +# define _STLP_NATIVE_CPP_C_HEADER(header) <../include/##header> +# define _STLP_NATIVE_C_HEADER(header) <../include/##header> +# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../include/##header> +# else + +# define _STLP_NATIVE_INCLUDE_PATH Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C++:Include +# define _STLP_NATIVE_C_INCLUDE_PATH Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:MSL Common:Public Includes +# define _STLP_NATIVE_HEADER(header) <Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C++:Include:##header> +# define _STLP_NATIVE_CPP_C_HEADER(header) <Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C++:Include:##header> +# define _STLP_NATIVE_C_HEADER(header) <Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:MSL Common:Public Includes:##header> +# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:MSL Common:Public Includes:##header> + +# endif + +//Following block come from boost intrinsics.hpp file: +#if defined (__MSL_CPP__) && (__MSL_CPP__ >= 0x8000) + // Metrowerks compiler is acquiring intrinsic type traits support + // post version 8. We hook into the published interface to pick up + // user defined specializations as well as compiler intrinsics as + // and when they become available: +# include <msl_utility> +# define _STLP_HAS_TRIVIAL_CONSTRUCTOR(T) Metrowerks::has_trivial_default_ctor<T>::value +# define _STLP_HAS_TRIVIAL_COPY(T) Metrowerks::has_trivial_copy_ctor<T>::value +# define _STLP_HAS_TRIVIAL_ASSIGN(T) Metrowerks::has_trivial_assignment<T>::value +# define _STLP_HAS_TRIVIAL_DESTRUCTOR(T) Metrowerks::has_trivial_dtor<T>::value +# define _STLP_IS_POD(T) Metrowerks::is_POD<T>::value +# define _STLP_HAS_TYPE_TRAITS_INTRINSICS +#endif + +// fbp +# if !defined( __MSL_CPP__ ) || __MSL_CPP__ <= 0x4105 +# define _STLP_NO_NATIVE_WIDE_STREAMS 1 +# endif + +# if defined(__MACH__) +# define _STLP_MAC +# define O_BINARY 0 +# elif defined(macintosh) +# define _NOTHREADS +# endif +# define _STLP_DLLEXPORT_NEEDS_PREDECLARATION 1 diff --git a/WebKit/android/stlport/stl/config/_native_headers.h b/WebKit/android/stlport/stl/config/_native_headers.h new file mode 100644 index 0000000..f1f4bc9 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_native_headers.h @@ -0,0 +1,50 @@ + /* + * + * Copyright (c) 2006 + * Francois Dumont + * + * This material is provided "as is", with absolutely no warranty expressed + * or implied. Any use is at your own risk. + * + * Permission to use or copy this software for any purpose is hereby granted + * without fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ + +#if !defined (_STLP_MAKE_HEADER) +# define _STLP_MAKE_HEADER(path, header) <path/header> +#endif + +#if !defined (_STLP_NATIVE_HEADER) +# if !defined (_STLP_NATIVE_INCLUDE_PATH) +# define _STLP_NATIVE_INCLUDE_PATH ../include +# endif +# define _STLP_NATIVE_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_INCLUDE_PATH,header) +#endif + +/* For some compilers, C headers like <stdio.h> are located in separate directory */ +#if !defined (_STLP_NATIVE_C_HEADER) +# if !defined (_STLP_NATIVE_C_INCLUDE_PATH) +# define _STLP_NATIVE_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH +# endif +# define _STLP_NATIVE_C_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_C_INCLUDE_PATH,header) +#endif + +/* For some compilers, C-library headers like <cstdio> are located in separate directory */ +#if !defined (_STLP_NATIVE_CPP_C_HEADER) +# if !defined (_STLP_NATIVE_CPP_C_INCLUDE_PATH) +# define _STLP_NATIVE_CPP_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH +# endif +# define _STLP_NATIVE_CPP_C_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_CPP_C_INCLUDE_PATH,header) +#endif + +/* Some compilers locate basic C++ runtime support headers (<new>, <typeinfo>, <exception>) in separate directory */ +#if !defined ( _STLP_NATIVE_CPP_RUNTIME_HEADER ) +# if !defined (_STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH) +# define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH +# endif +# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH,header) +#endif diff --git a/WebKit/android/stlport/stl/config/_netware.h b/WebKit/android/stlport/stl/config/_netware.h new file mode 100644 index 0000000..14debd2 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_netware.h @@ -0,0 +1 @@ +#define _STLP_PLATFORM "Novell Netware" diff --git a/WebKit/android/stlport/stl/config/_openbsd.h b/WebKit/android/stlport/stl/config/_openbsd.h new file mode 100644 index 0000000..cb69825 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_openbsd.h @@ -0,0 +1 @@ +#define _STLP_PLATFORM "Open BSD" diff --git a/WebKit/android/stlport/stl/config/_prolog.h b/WebKit/android/stlport/stl/config/_prolog.h new file mode 100644 index 0000000..5ad943f --- /dev/null +++ b/WebKit/android/stlport/stl/config/_prolog.h @@ -0,0 +1,52 @@ + +#if defined (_STLP_MSVC) || defined (__ICL) + +# if !defined (_STLP_MSVC) || (_STLP_MSVC >= 1200) +# pragma warning(push) +# endif +# include <stl/config/_warnings_off.h> +/* We are forcing the alignment to guaranty that libraries are use + * with the same alignment as the one use to build them. + */ +# if !defined (_WIN64) +# pragma pack(push, 8) +# else +# pragma pack(push, 16) +# endif + +#elif defined (__BORLANDC__) + +# pragma option push +# pragma option -Vx- -Ve- -a8 -b -pc +# include <stl/config/_warnings_off.h> + +#elif defined (__sgi) && !defined (__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) + +# pragma set woff 1209 +# pragma set woff 1174 +# pragma set woff 1375 +/* from iterator_base.h */ +# pragma set woff 1183 + +#elif defined (__DECCXX) + +# ifdef __PRAGMA_ENVIRONMENT +# pragma __environment __save +# pragma __environment __header_defaults +# endif + +#elif defined (__IBMCPP__) +/* supress EDC3130: A constant is being used as a conditional expression */ +# pragma info(nocnd) + +#elif defined (__HP_aCC) +/* _REENTRANT selects Posix 1c threads unless draft4 selected. + * * This usage is obsolescent, "-D_POSIX_C_SOURCE=199506" is preferred */ +# if 0 /* defined (_REENTRANT) && ! defined (_POSIX_C_SOURCE) */ +# define _POSIX_C_SOURCE 199506 +# endif +#elif defined (__WATCOMCPLUSPLUS__) +# pragma warning 604 10 /* must lookahead to determine... */ +# pragma warning 594 10 /* resolved as declaration/type */ +# pragma warning 595 10 /* resolved as an expression */ +#endif diff --git a/WebKit/android/stlport/stl/config/_sgi.h b/WebKit/android/stlport/stl/config/_sgi.h new file mode 100644 index 0000000..2f7518f --- /dev/null +++ b/WebKit/android/stlport/stl/config/_sgi.h @@ -0,0 +1,92 @@ +// STLport configuration file +// It is internal STLport header - DO NOT include it directly + +#define _STLP_COMPILER "CC" + +#define _STLP_HAS_SPECIFIC_PROLOG_EPILOG + +// define native include path before trying to include anything + +#define _STLP_NATIVE_HEADER(__x) </usr/include/CC/##__x> +#define _STLP_NATIVE_C_HEADER(__x) </usr/include/##__x> +#define _STLP_NATIVE_OLD_STREAMS_HEADER(__x) </usr/include/CC/##__x> +#define _STLP_NATIVE_CPP_C_HEADER(__x) </usr/include/CC/##__x> +#define _STLP_NATIVE_CPP_RUNTIME_HEADER(__x) </usr/include/CC/##__x> + +#define _STLP_NO_NATIVE_MBSTATE_T + +#define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS +#define _STLP_NO_NATIVE_WIDE_FUNCTIONS +#define _STLP_NO_MEMBER_TEMPLATE_CLASSES + +// #define _STLP_NO_BAD_ALLOC + +#define _STL_HAS_NAMESPACES + +#if ! defined (__EXCEPTIONS) && ! defined (_STLP_NO_EXCEPTIONS) +# define _STLP_NO_EXCEPTIONS +#endif + +// #define _STLP_NOTHROW throw() + +#define __EDG_SWITCHES + +#define _STLP_USE_SGI_STRING 1 + +#define _STLP_HAS_NO_NEW_C_HEADERS 1 +// # define _STLP_VENDOR_GLOBAL_EXCEPT_STD + +#define _STLP_NO_POST_COMPATIBLE_SECTION + +#include <standards.h> + +#if !(_COMPILER_VERSION >= 730) +# define _STLP_NO_NEW_NEW_HEADER 1 +#endif + +#if (_COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS)) +# define _STLP_EXTERN_RANGE_ERRORS +#endif + +#if !defined(_BOOL) +# define _STLP_NO_BOOL +#endif +#if defined(_MIPS_SIM) && _MIPS_SIM == _ABIO32 +# define _STLP_STATIC_CONST_INIT_BUG +#endif + +#if (_COMPILER_VERSION < 720) || (defined(_MIPS_SIM) && _MIPS_SIM == _ABIO32) +# define _STLP_DEF_CONST_PLCT_NEW_BUG +# define _STLP_DEF_CONST_DEF_PARAM_BUG +#endif +#if !((_COMPILER_VERSION >= 730) && defined(_MIPS_SIM) && _MIPS_SIM != _ABIO32) +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD +#endif +#if !defined(_STANDARD_C_PLUS_PLUS) +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS +#endif +#if !((_COMPILER_VERSION >= 721) && defined(_NAMESPACES)) +# define _STLP_HAS_NO_NAMESPACES +#endif +#if (_COMPILER_VERSION < 721) || !defined(_STL_HAS_NAMESPACES) || defined(_STLP_NO_NAMESPACES) +# define _STLP_NO_EXCEPTION_HEADER +#endif +#if _COMPILER_VERSION < 730 || !defined(_STANDARD_C_PLUS_PLUS) || !defined(_NAMESPACES) +# define _STLP_NO_BAD_ALLOC +#endif +#if defined(_LONGLONG) && defined(_SGIAPI) && _SGIAPI +# define _STLP_LONG_LONG long long +#endif +#if !(_COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS)) +# define _STLP_USE_NO_IOSTREAMS +#endif +#if !(_COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS)) +# define _STLP_NO_AT_MEMBER_FUNCTION +#endif +// # if !(_COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS)) +#if !(_COMPILER_VERSION >= 721 && defined(_STANDARD_C_PLUS_PLUS)) +# define _STLP_NO_TEMPLATE_CONVERSIONS +#endif +#if !((_COMPILER_VERSION >= 730) && defined(_MIPS_SIM) && _MIPS_SIM != _ABIO32) +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER +#endif diff --git a/WebKit/android/stlport/stl/config/_solaris.h b/WebKit/android/stlport/stl/config/_solaris.h new file mode 100644 index 0000000..7e00d9c --- /dev/null +++ b/WebKit/android/stlport/stl/config/_solaris.h @@ -0,0 +1,85 @@ +#ifndef __stl_config__solaris_h +#define __stl_config__solaris_h + +#define _STLP_PLATFORM "Sun Solaris" + +/* include system features file */ +#include <sys/feature_tests.h> + +/* system-dependent defines */ + +/* + * Should be fixed: + * 1. __SunOS_5_x not defined, and no way to derive this from headers only; + * define it with -D on compiler command line is a bad idea too. + * + * 2. Solaris may has, but may hasn't MATH_F and MATH_L functions (even with two + * underscores)---this depends upon system update level and seems legally present + * only in Solaris 10 (i.e. I saw Solaris 9 with and without __acosf in libm.so.1) + * + * - ptr + */ + +#if defined (__SunOS_5_8) && ! defined (_STLP_HAS_NO_NEW_C_HEADERS) && ( __cplusplus >= 199711L) +# define _STLP_HAS_NATIVE_FLOAT_ABS +#endif + +#if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4) +# define _STLP_RAND48 1 +#endif + +#if (defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 == 4)) || defined (__SunOS_5_6) +# define _STLP_WCHAR_SUNPRO_EXCLUDE 1 +# define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1 +#endif + +/* boris : this should always be defined for Solaris 5 & 6. Any ideas how to do it? */ +#if !(defined ( __KCC ) && __KCC_VERSION > 3400 ) && \ + ((defined(__SunOS_5_5_1) || defined(__SunOS_5_6) )) +# ifndef _STLP_NO_NATIVE_MBSTATE_T +# define _STLP_NO_NATIVE_MBSTATE_T 1 +# endif +#endif /* KCC */ + +/* For SPARC we use lightweight synchronization */ +#if defined (__sparc) /* && (defined (_REENTRANT) || defined (_PTHREADS)) */ +# if ( (defined (__GNUC__) && defined (__sparc_v9__)) || \ + defined (__sparcv9) ) \ + && !defined(_NOTHREADS) && !defined (_STLP_NO_SPARC_SOLARIS_THREADS) +# define _STLP_SPARC_SOLARIS_THREADS +# define _STLP_THREADS_DEFINED +# endif +#endif + +/* gcc does not support ELF64 yet ; however; it supports ultrasparc + v8plus. + * limits.h contains invalid values for this combination + */ +#ifdef __GNUC__ +# if (defined (__sparc_v9__) || defined (__sparcv9)) && !defined ( __WORD64 ) && !defined(__arch64__) +# define __LONG_MAX__ 2147483647L +# endif +#endif + +/* + * Hmm, I don't found in Solaris 9 system headers definition like __SunOS_5_9 + * (defined in SunPro?); I also can't find functions like fmodf (again, + * I found modff in libc, but no acosf etc.). Strange, I saw __cosf functions + * (built-in?) at least with gcc some time ago, but don't see ones with + * gcc 3.3.2 on SunOS sparc-solaris1 5.9 Generic_112233-03 sun4u sparc SUNW,Ultra-60 + * from Sorceforge's CF. + * 2005-12-15, - ptr + * + * P.S. That's why I add two defines: + */ + +/* #ifdef __GNUC__ */ +#define _STLP_NO_VENDOR_MATH_F +#define _STLP_NO_VENDOR_MATH_L +/* #endif */ + +#ifdef __GNUC__ +# define _STLP_WCHAR_BORLAND_EXCLUDE +# define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1 +#endif + +#endif /* __stl_config__solaris_h */ diff --git a/WebKit/android/stlport/stl/config/_sunprocc.h b/WebKit/android/stlport/stl/config/_sunprocc.h new file mode 100644 index 0000000..b54e121 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_sunprocc.h @@ -0,0 +1,161 @@ +// STLport configuration file +// It is internal STLport header - DO NOT include it directly + +#define _STLP_COMPILER "Sunpro CC" + +#define _STLP_LONG_LONG long long + +// GAB: 11/09/05 +// Starting with 5.0 the STLport code expects to be +// instantiated during compile time. This is due to undefing +// a number of defines that are also used in the c versions +// of the file. When they are undefed the c version fails to +// compile. +// # define _STLP_LINK_TIME_INSTANTIATION 1 + +#if ! defined(_BOOL) +# define _STLP_NO_BOOL 1 +#endif + +// compatibility mode stuff +#if (__SUNPRO_CC >= 0x510) && (!defined (__SUNPRO_CC_COMPAT) || (__SUNPRO_CC_COMPAT == 5 )) +# define _STLP_NATIVE_INCLUDE_PATH ../CC/Cstd +# define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH ../CC +#elif (__SUNPRO_CC >= 0x500) && (!defined (__SUNPRO_CC_COMPAT) || (__SUNPRO_CC_COMPAT == 5 )) +# define _STLP_NATIVE_INCLUDE_PATH ../CC +#elif (defined (__SUNPRO_CC_COMPAT) && __SUNPRO_CC_COMPAT == 4) +# define _STLP_NATIVE_INCLUDE_PATH ../CC4 +#else +# define _STLP_NATIVE_INCLUDE_PATH ../CC +#endif + +#define _STLP_STATIC_CONST_INIT_BUG 1 + +#if (__SUNPRO_CC < 0x530) +// those are tested and proved not to work... +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 +# define _STLP_USE_OLD_HP_ITERATOR_QUERIES +#endif + +#ifdef _STLP_USE_NO_IOSTREAMS +# define _STLP_HAS_NO_NEW_C_HEADERS 1 +#endif + +// those do not depend on compatibility +#if (__SUNPRO_CC < 0x510) +# define _STLP_NO_TYPENAME_ON_RETURN_TYPE 1 +# define _STLP_NONTEMPL_BASE_MATCH_BUG 1 +#endif + +#if (__SUNPRO_CC < 0x510) || (defined (__SUNPRO_CC_COMPAT) && (__SUNPRO_CC_COMPAT < 5)) + +# define _STLP_NO_QUALIFIED_FRIENDS 1 + +// no partial , just for explicit one +# define _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS +# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 + +# define _STLP_NO_MEMBER_TEMPLATES 1 +# define _STLP_NO_FRIEND_TEMPLATES 1 + +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1 +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +#endif + +// Features that depend on compatibility switch +#if ( __SUNPRO_CC < 0x500 ) || (defined (__SUNPRO_CC_COMPAT) && (__SUNPRO_CC_COMPAT < 5)) + +# ifndef _STLP_USE_NO_IOSTREAMS +# define _STLP_USE_NO_IOSTREAMS 1 +# endif +# define _STLP_NO_NEW_NEW_HEADER 1 +// # define _STLP_NO_RELOPS_NAMESPACE +# define _STLP_HAS_NO_NAMESPACES 1 +# define _STLP_NEED_MUTABLE 1 +# define _STLP_NO_BAD_ALLOC 1 +# define _STLP_NO_EXCEPTION_HEADER 1 +# define _STLP_NATIVE_C_INCLUDE_PATH ../include +#elif (__SUNPRO_CC < 0x510) +// # define _STLP_NATIVE_C_HEADER(header) <../CC/##header##.SUNWCCh> +# define _STLP_NATIVE_CPP_C_HEADER(header) <../CC/##header##.SUNWCCh> +# define _STLP_NATIVE_C_INCLUDE_PATH /usr/include +#elif defined( __SunOS_5_5_1 ) || defined( __SunOS_5_6 ) || defined( __SunOS_5_7 ) +# define _STLP_NATIVE_C_INCLUDE_PATH ../CC/std +# define _STLP_NATIVE_CPP_C_INCLUDE_PATH ../CC/std +#else +# define _STLP_NATIVE_C_INCLUDE_PATH /usr/include +# define _STLP_NATIVE_CPP_C_INCLUDE_PATH ../CC/std +#endif + +#if ( __SUNPRO_CC < 0x500 ) + +# undef _STLP_NATIVE_C_HEADER +# undef _STLP_NATIVE_CPP_C_HEADER + +# define wint_t __wint_t +// famous CC 4.2 bug +# define _STLP_INLINE_STRING_LITERAL_BUG 1 +// /usr/include +# define _STLP_NATIVE_C_INCLUDE_PATH ../include + +// 4.2 cannot handle iterator_traits<_Tp>::iterator_category as a return type ;( +# define _STLP_USE_OLD_HP_ITERATOR_QUERIES + +// 4.2 does not like it +# undef _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS + +# define _STLP_LIMITED_DEFAULT_TEMPLATES 1 + +# define _STLP_NEED_TYPENAME 1 +# define _STLP_NEED_EXPLICIT 1 +# define _STLP_NO_BAD_ALLOC 1 +# define _STLP_NO_ARROW_OPERATOR 1 + +# define _STLP_DEF_CONST_PLCT_NEW_BUG 1 +# define _STLP_DEF_CONST_DEF_PARAM_BUG 1 +# define _STLP_GLOBAL_NESTED_RETURN_TYPE_PARAM_BUG 1 +# undef _STLP_HAS_NO_NEW_C_HEADERS +# define _STLP_HAS_NO_NEW_C_HEADERS 1 +// # define _STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS + +# if ( __SUNPRO_CC < 0x420 ) +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1 +# define _STLP_NO_NEW_STYLE_CASTS 1 +# define _STLP_NO_METHOD_SPECIALIZATION 1 +# if ( __SUNPRO_CC > 0x401 ) +# if (__SUNPRO_CC==0x410) +# define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1 +# endif +# else + // SUNPro C++ 4.0.1 +# define _STLP_BASE_MATCH_BUG 1 +# define _STLP_BASE_TYPEDEF_BUG 1 +# if (( __SUNPRO_CC < 0x401 ) && !defined(__SUNPRO_C)) + __GIVE_UP_WITH_STL(SUNPRO_401) +# endif +# endif /* 4.0.1 */ +# endif /* 4.2 */ +#endif /* < 5.0 */ + +#ifndef _MBSTATET_H +# define _MBSTATET_H +# undef _MBSTATE_T +# define _MBSTATE_T +typedef struct __mbstate_t { +# if defined(_LP64) + long __filler[4]; +# else + int __filler[6]; +# endif +} __mbstate_t; +# ifndef _STLP_HAS_NO_NAMESPACES +namespace std { + typedef __mbstate_t mbstate_t; +} +using std::mbstate_t; +# else +typedef __mbstate_t mbstate_t; +# endif +#endif /* __MBSTATET_H */ diff --git a/WebKit/android/stlport/stl/config/_symantec.h b/WebKit/android/stlport/stl/config/_symantec.h new file mode 100644 index 0000000..7926bf5 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_symantec.h @@ -0,0 +1,48 @@ +/* STLport configuration file + * It is internal STLport header - DO NOT include it directly + */ + +#define _STLP_COMPILER "Symantec" + +/* if not using maximum ANSI compatibility ( -A -Ab -Aw), + * uncomment the following two lines: + */ +/*# define _STLP_NO_BOOL 1 */ +/*# define _STLP_NO_WCHAR_T 1 */ + +/* TODO: Check that this config is necessary for all compiler versions. + * It is here for historical reasons for the moment. + */ +#define _STLP_NO_CONTAINERS_EXTENSION + +# define _STLP_HAS_NO_NAMESPACES 1 + +# define _STLP_NEED_TYPENAME 1 +# define _STLP_NEED_EXPLICIT 1 +# define _STLP_NO_NEW_STYLE_CASTS 1 +# define _STLP_NEED_MUTABLE 1 +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1 +/* # define _STLP_NO_BAD_ALLOC 1 */ + +# define _STLP_NO_MEMBER_TEMPLATES 1 +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +# define _STLP_NO_FRIEND_TEMPLATES 1 +# define _STLP_NO_QUALIFIED_FRIENDS 1 +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1 + +/* # define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1 */ +# define _STLP_NO_METHOD_SPECIALIZATION 1 +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1 +/* # define _STLP_NO_EXCEPTION_HEADER 1 */ + +# define _STLP_HAS_NO_NEW_C_HEADERS 1 + +# define _STLP_STATIC_CONST_INIT_BUG 1 +# define _STLP_THROW_RETURN_BUG 1 +/* # define _STLP_LINK_TIME_INSTANTIATION 1 */ +# define _STLP_NO_TEMPLATE_CONVERSIONS 1 + +# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 + diff --git a/WebKit/android/stlport/stl/config/_system.h b/WebKit/android/stlport/stl/config/_system.h new file mode 100644 index 0000000..ce22044 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_system.h @@ -0,0 +1,190 @@ +/* + * Copyright (c) 1997 + * Moscow Center for SPARC Technology + * + * Copyright (c) 1999 + * Boris Fomitchev + * + * This material is provided "as is", with absolutely no warranty expressed + * or implied. Any use is at your own risk. + * + * Permission to use or copy this software for any purpose is hereby granted + * without fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ + +/* + * Purpose of this file : + * + * To hold COMPILER-SPECIFIC portion of STLport settings. + * In general, user should not edit this file unless + * using the compiler not recognized below. + * + * If your compiler is not being recognized yet, + * please look for definitions of macros in stl_mycomp.h, + * copy stl_mycomp.h to stl_YOUR_COMPILER_NAME, + * adjust flags for your compiler, and add <include config/stl_YOUR_COMPILER_NAME> + * to the secton controlled by unique macro defined internaly by your compiler. + * + * To change user-definable settings, please edit <user_config.h> + * + */ + +#ifndef __stl_config__system_h +#define __stl_config__system_h + +#if defined(__SYMBIAN32__) +# if defined(__GCCE__) || defined(__ARMCC__) +# include <stl/config/stl_gcce.h> +# elif defined(__WINSCW__) +# include <stl/config/stl_winscw.h> +# endif +# include <stl/config/stl_symbian.h> +#elif defined (__sun) +# include <stl/config/_solaris.h> +# if defined (__GNUC__) +# include <stl/config/_gcc.h> +# elif defined (__SUNPRO_CC) +# include <stl/config/_sunprocc.h> +/* +# ifdef __KCC +# include <stl/config/_kai.h> +# endif +*/ +# elif defined (__APOGEE__) /* Apogee 4.x */ +# include <stl/config/_apcc.h> +# elif defined (__FCC_VERSION) /* Fujitsu Compiler, v4.0 assumed */ +# include <stl/config/_fujitsu.h> +# endif +#elif defined (__hpux) +# include <stl/config/_hpux.h> +# if defined (__GNUC__) +# include <stl/config/_gcc.h> +# elif defined (__HP_aCC) +# include <stl/config/_hpacc.h> +# endif +#elif defined (ANDROID) + /* Android mobile phone platform. Somewhat but not entirely GNU/Linux-like */ +# include <stl/config/_android.h> +# include <stl/config/_gcc.h> +#elif defined (linux) || defined (__linux__) +# include <stl/config/_linux.h> +/* Intel's icc define __GNUC__! */ +# if defined (__INTEL_COMPILER) +# include <stl/config/_icc.h> +# elif defined (__GNUC__) +# include <stl/config/_gcc.h> +# endif +/* +# ifdef __KCC +# include <stl/config/_kai.h> +# endif +*/ +#elif defined (__FreeBSD__) +# include <stl/config/_freebsd.h> +# if defined (__GNUC__) +# include <stl/config/_gcc.h> +# endif +#elif defined (__OpenBSD__) +# include <stl/config/_openbsd.h> +# if defined (__GNUC__) +# include <stl/config/_gcc.h> +# endif +#elif defined (N_PLAT_NLM) /* Novell NetWare */ +# include <stl/config/_netware.h> +# ifdef __MWERKS__ /* Metrowerks CodeWarrior */ +# include <stl/config/_mwccnlm.h> +# endif +#elif defined (__sgi) /* IRIX? */ +# define _STLP_PLATFORM "SGI Irix" +# if defined (__GNUC__) +# include <stl/config/_gcc.h> +# else +# include <stl/config/_sgi.h> +# endif +#elif defined (__OS400__) /* AS/400 C++ */ +# define _STLP_PLATFORM "OS 400" +# if defined (__GNUC__) +# include <stl/config/_gcc.h> +# else +# include <stl/config/_as400.h> +# endif +#elif defined (_AIX) +# include <stl/config/_aix.h> +# if defined (__xlC__) || defined (__IBMC__) || defined ( __IBMCPP__ ) + /* AIX xlC, Visual Age C++ , OS-390 C++ */ +# include <stl/config/_ibm.h> +# endif +#elif defined (_CRAY) /* Cray C++ 3.4 or 3.5 */ +# define _STLP_PLATFORM "Cray" +# include <config/_cray.h> +#elif defined (__DECCXX) || defined (__DECC) +# define _STLP_PLATFORM "DECC" +# ifdef __vms +# include <stl/config/_dec_vms.h> +# else +# include <stl/config/_dec.h> +# endif +#elif defined (macintosh) || defined (_MAC) +# include <stl/config/_mac.h> +# if defined (__MWERKS__) +# include <stl/config/_mwerks.h> +# elif defined (__MRC__) || (defined (__SC__) && (__SC__ >= 0x882)) + /* Apple MPW SCpp 8.8.2, Apple MPW MrCpp 4.1.0 */ +# include <stl/config/_apple.h> +# endif +#elif defined (__APPLE__) +# include <stl/config/_macosx.h> +# ifdef __GNUC__ +# include <stl/config/_gcc.h> +# endif +#elif defined (__CYGWIN__) +# include <stl/config/_cygwin.h> +# if defined (__GNUC__) +# include <stl/config/_gcc.h> +# endif +#elif defined (__MINGW32__) +# define _STLP_PLATFORM "MinGW" +# if defined (__GNUC__) +# include <stl/config/_gcc.h> +# endif +# include <stl/config/_windows.h> +#elif defined (_WIN32) || defined (__WIN32) || defined (WIN32) || defined (__WIN32__) || \ + defined (__WIN16) || defined (WIN16) || defined (_WIN16) +# if defined ( __BORLANDC__ ) /* Borland C++ ( 4.x - 5.x ) */ +# include <stl/config/_bc.h> +# elif defined (__WATCOM_CPLUSPLUS__) || defined (__WATCOMC__) /* Watcom C++ */ +# include <stl/config/_watcom.h> +# elif defined (__COMO__) || defined (__COMO_VERSION_) +# include <stl/config/_como.h> +# elif defined (__DMC__) /* Digital Mars C++ */ +# include <stl/config/_dm.h> +# elif defined (__SC__) && (__SC__ < 0x800) /* Symantec 7.5 */ +# include <stl/config/_symantec.h> +# elif defined (__ICL) /* Intel reference compiler for Win */ +# include <stl/config/_intel.h> +# elif defined (__MWERKS__) +# include <stl/config/_mwerks.h> +# elif defined (_MSC_VER) && (_MSC_VER >= 1200) && defined (UNDER_CE) + /* Microsoft eMbedded Visual C++ 3.0, 4.0 (.NET) */ +# include <stl/config/_evc.h> +# elif defined (_MSC_VER) + /* Microsoft Visual C++ 6.0, 7.0, 7.1, 8.0 */ +# include <stl/config/_msvc.h> +# endif + +# include <stl/config/_windows.h> +#else +# error Unknown platform !! +#endif + +#if !defined (_STLP_COMPILER) +/* Unable to identify the compiler, issue error diagnostic. + * Edit <config/stl_mycomp.h> to set STLport up for your compiler. */ +# include <stl/config/stl_mycomp.h> +#endif + +#endif /* __stl_config__system_h */ diff --git a/WebKit/android/stlport/stl/config/_warnings_off.h b/WebKit/android/stlport/stl/config/_warnings_off.h new file mode 100644 index 0000000..5618e6e --- /dev/null +++ b/WebKit/android/stlport/stl/config/_warnings_off.h @@ -0,0 +1,60 @@ +/* This header turns off warnings that STLport headers generate for compiled + * user code. + */ + +#if defined (_STLP_MSVC) +# if (_STLP_MSVC > 1000) +# if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) +/* + * 31/07/2004: dums - now that we do not export the basic_string class anymore but only a base class + * we have to disable this warning as the string are used as data members type of many iostream classes. + */ +# pragma warning ( disable : 4251 ) // ignore template classes being exported in .dll's +# endif + +# if (_STLP_MSVC < 1200) // VC5 and earlier +# pragma warning( disable : 4389 ) // '==' : signed/unsigned mismatch +// multiple copy constructors/assignment operators specified, +// with member templates are bogus... +# pragma warning( disable : 4521 ) +# pragma warning( disable : 4522 ) +# endif + +# if (_STLP_MSVC < 1300) // VC6, eVC3, eVC4 +# pragma warning( disable : 4097 ) // typedef-name used as based class of (...) +# pragma warning( disable : 4231 ) // non standard extension : 'extern' before template instanciation +# pragma warning( disable : 4244 ) // implicit conversion: possible loss of data +# pragma warning( disable : 4284 ) // for -> operator +//This warning is necessary because of the native platform headers: +# pragma warning( disable : 4290 ) // c++ exception specification ignored +# pragma warning( disable : 4514 ) // unreferenced inline function has been removed +# pragma warning( disable : 4660 ) // template-class specialization '...' is already instantiated +# pragma warning( disable : 4701 ) // local variable '...' may be used without having been initialized +# pragma warning( disable : 4710 ) // function (...) not inlined +# pragma warning( disable : 4786 ) // identifier truncated to 255 characters +# endif + +# if (_STLP_MSVC < 1400) +# pragma warning( disable : 4511 ) // copy constructor cannot be generated +# endif + +//Pool of common warnings for all MSVC supported versions: +//Many are only useful if warning level is set to 4. +# pragma warning( disable : 4100 ) // unreferenced formal parameter +# pragma warning( disable : 4127 ) // conditional expression is constant +# pragma warning( disable : 4146 ) // unary minus operator applied to unsigned type, result still unsigned +# pragma warning( disable : 4245 ) // conversion from 'enum ' to 'unsigned int', signed/unsigned mismatch +# pragma warning( disable : 4355 ) // this used in base member initializer list (used in rope implementation) +# pragma warning( disable : 4510 ) // default constructor cannot be generated +# pragma warning( disable : 4512 ) // assignment operator could not be generated +# pragma warning( disable : 4571 ) // catch(...) blocks compiled with /EHs do not catch or re-throw Structured Exceptions +# pragma warning( disable : 4610 ) // struct '...' can never be instantiated - user defined construtor required +# endif +#elif defined (__BORLANDC__) +# pragma option -w-ccc // -w-8008 Condition is always true OR Condition is always false +# pragma option -w-inl // -w-8027 Functions containing reserved words are not expanded inline +# pragma option -w-ngu // -w-8041 Negating unsigned value +# pragma option -w-pow // -w-8062 Previous options and warnings not restored +# pragma option -w-rch // -w-8066 Unreachable code +# pragma option -w-par // -w-8057 Parameter 'parameter' is never used +#endif diff --git a/WebKit/android/stlport/stl/config/_watcom.h b/WebKit/android/stlport/stl/config/_watcom.h new file mode 100644 index 0000000..f960424 --- /dev/null +++ b/WebKit/android/stlport/stl/config/_watcom.h @@ -0,0 +1,154 @@ +// STLport configuration file +// It is internal STLport header - DO NOT include it directly + +#define _STLP_COMPILER "Watcom" + +# ifndef _STLP_USE_NO_IOSTREAMS +# define _STLP_USE_NO_IOSTREAMS +# endif + +# define _STLP_NO_RELOPS_NAMESPACE +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX + +# define _STLP_HAS_SPECIFIC_PROLOG_EPILOG +# define _STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS +# define _STLP_USE_OLD_HP_ITERATOR_QUERIES + +// On QNX, headers are supposed to be found in /usr/include, +// so default "../include" should work. +# ifndef __QNX__ +# define _STLP_NATIVE_INCLUDE_PATH ../h +# endif + +// Inline replacements for locking calls under Watcom +// Define _STLP_NO_WATCOM_INLINE_INTERLOCK to keep using +// standard WIN32 calls +// Define _STL_MULTIPROCESSOR to enable lock +#if !defined(_STLP_NO_WATCOM_INLINE_INTERLOCK) + +long __stl_InterlockedIncrement( long *var ); +long __stl_InterlockedDecrement( long *var ); + +#ifdef _STL_MULTIPROCESSOR +// Multiple Processors, add lock prefix +#pragma aux __stl_InterlockedIncrement parm [ ecx ] = \ + ".586" \ + "mov eax, 1" \ + "lock xadd [ecx], eax" \ + "inc eax" \ + value [eax]; + + +#pragma aux __stl_InterlockedDecrement parm [ ecx ] = \ + ".586" \ + "mov eax, 0FFFFFFFFh" \ + "lock xadd [ecx], eax" \ + "dec eax" \ + value [eax]; +#else +// Single Processor, lock prefix not needed +#pragma aux __stl_InterlockedIncrement parm [ ecx ] = \ + ".586" \ + "mov eax, 1" \ + "xadd [ecx], eax" \ + "inc eax" \ + value [eax]; + +#pragma aux __stl_InterlockedDecrement parm [ ecx ] = \ + ".586" \ + "mov eax, 0FFFFFFFFh" \ + "xadd [ecx], eax" \ + "dec eax" \ + value [eax]; +#endif // _STL_MULTIPROCESSOR + +long __stl_InterlockedExchange( long *Destination, long Value ); + +// xchg has auto-lock +#pragma aux __stl_InterlockedExchange parm [ecx] [eax] = \ + ".586" \ + "xchg eax, [ecx]" \ + value [eax]; +#else + +#define __stl_InterlockedIncrement InterlockedIncrement +#define __stl_InterlockedDecrement InterlockedDecrement +#define __stl_InterlockedExchange InterlockedExchange +#endif /* INLINE INTERLOCK */ + +#define _STLP_ATOMIC_INCREMENT(__x) __stl_InterlockedIncrement((long*)__x) +#define _STLP_ATOMIC_DECREMENT(__x) __stl_InterlockedDecrement((long*)__x) +#define _STLP_ATOMIC_EXCHANGE(__x, __y) __stl_InterlockedExchange((long*)__x, (long)__y) + +// boris : is this true or just the header is not in /usr/include ? +# ifdef __QNX__ +# define _STLP_NO_TYPEINFO 1 +# endif + +# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1 +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +# define _STLP_NO_MEMBER_TEMPLATES 1 +# define _STLP_NO_FRIEND_TEMPLATES 1 +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 + + +# define _STLP_LIMITED_DEFAULT_TEMPLATES 1 +# define _STLP_HAS_NO_NAMESPACES 1 +# define _STLP_NEED_TYPENAME 1 + +# if __WATCOMC__ < 1100 +# define _STLP_NO_WCHAR_T 1 +# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1 +# endif + +# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1 + +# define _STLP_STATIC_CONST_INIT_BUG 1 +// # define _STLP_THROW_RETURN_BUG 1 +# define _STLP_NO_TEMPLATE_CONVERSIONS 1 + +# define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1 + +# define _STLP_HAS_NO_NEW_IOSTREAMS 1 +# define _STLP_HAS_NO_NEW_C_HEADERS 1 +# define _STLP_NO_NEW_NEW_HEADER 1 +# define _STLP_VENDOR_GLOBAL_STD + +# define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1 +# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 +# define _STLP_NONTEMPL_BASE_MATCH_BUG +# define _STLP_NO_EXCEPTION_HEADER 1 +# define _STLP_NO_BAD_ALLOC 1 + +# define _STLP_NESTED_TYPE_PARAM_BUG 1 + +# define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS 1 + +# if (__WATCOM_CPLUSPLUS__ < 1100 ) +# define _STLP_NO_BOOL 1 +# define _STLP_NEED_EXPLICIT 1 +# define _STLP_NEED_MUTABLE 1 +# define _STLP_NO_ARROW_OPERATOR 1 +# endif +// This one is present in 11, but apparently has bugs (with auto_ptr). +# define _STLP_NO_NEW_STYLE_CASTS 1 + +// Get rid of Watcom's min and max macros +#undef min +#undef max + +// for switches (-xs, -xss, -xst) +// +#if !(defined (__SW_XS) || defined (__SW_XSS) || defined(__SW_XST)) +# define _STLP_HAS_NO_EXCEPTIONS 1 +# endif + +# if defined ( _MT ) && !defined (_NOTHREADS) && !defined (_REENTRANT) +# define _REENTRANT 1 +# endif + + + + + diff --git a/WebKit/android/stlport/stl/config/_windows.h b/WebKit/android/stlport/stl/config/_windows.h new file mode 100644 index 0000000..69068bc --- /dev/null +++ b/WebKit/android/stlport/stl/config/_windows.h @@ -0,0 +1,223 @@ +/* + * Copyright (c) 1997-1999 + * Silicon Graphics Computer Systems, Inc. + * + * Copyright (c) 1999 + * Boris Fomitchev + * + * Copyright (c) 2003 + * Francois Dumont + * + * This material is provided "as is", with absolutely no warranty expressed + * or implied. Any use is at your own risk. + * + * Permission to use or copy this software for any purpose is hereby granted + * without fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ +#ifndef _STLP_INTERNAL_WINDOWS_H +#define _STLP_INTERNAL_WINDOWS_H + +#if !defined (_STLP_PLATFORM) +# define _STLP_PLATFORM "Windows" +#endif + +/* _STLP_WIN32_VERSION is used to detect targetted Windows platforms as + * old ones are not supporting some Win32 functions that STLport use. + * Limited OSs are going up to and including Windows 98 so they can be + * detected using WINVER or _WIN32_WINDOWS macros, we do not have to use + * _WINNT_WINDOWS macro for the moment. + */ +#if !defined (_STLP_WIN32_VERSION) +# if defined (WINVER) +# define _STLP_WIN32_VERSION WINVER +# elif defined (_WIN32_WINDOWS) +# define _STLP_WIN32_VERSION _WIN32_WINDOWS +# endif +#endif + +#if !defined (_STLP_BIG_ENDIAN) && !defined (_STLP_LITTLE_ENDIAN) +# if defined (_MIPSEB) +# define _STLP_BIG_ENDIAN 1 +# endif +# if defined (__i386) || defined (_M_IX86) || defined (_M_ARM) || \ + defined (__amd64__) || defined (_M_AMD64) || defined (__x86_64__) || \ + defined (__alpha__) +# define _STLP_LITTLE_ENDIAN 1 +# endif +# if defined (__ia64__) + /* itanium allows both settings (for instance via gcc -mbig-endian) - hence a seperate check is required */ +# if defined (__BIG_ENDIAN__) +# define _STLP_BIG_ENDIAN 1 +# else +# define _STLP_LITTLE_ENDIAN 1 +# endif +# endif +#endif /* _STLP_BIG_ENDIAN */ + +#if !defined (_STLP_WINDOWS_H_INCLUDED) +# define _STLP_WINDOWS_H_INCLUDED +# if !(defined ( _STLP_MSVC ) || defined (__BORLANDC__) || defined (__ICL) || defined (__WATCOMC__) || \ + defined (__MINGW32__) || defined (__DMC__)) +# if defined (_STLP_USE_MFC) +# include <afx.h> +# else +# include <windows.h> +# endif +# else +/* This section serves as a replacement for windows.h header for Visual C++ */ +# if defined (__cplusplus) +extern "C" { +# endif +# if (defined (_M_AMD64) || defined (_M_IA64) || (!defined (_STLP_WCE) && defined (_M_MRX000)) || defined (_M_ALPHA) || \ + (defined (_M_PPC) && (_STLP_MSVC_LIB >= 1000))) && !defined (RC_INVOKED) +# define InterlockedIncrement _InterlockedIncrement +# define InterlockedDecrement _InterlockedDecrement +# define InterlockedExchange _InterlockedExchange +/* Here we use a different macro name than the InterlockedExchangePointer SDK function + * to avoid macro definition conflict as the SDK might already define InterlockedExchangePointer + * as a macro. + */ +# define STLPInterlockedExchangePointer _InterlockedExchangePointer +# define _STLP_STDCALL +# else +# if defined (_MAC) +# define _STLP_STDCALL _cdecl +# else +# define _STLP_STDCALL __stdcall +# endif +# endif + +# if defined (_STLP_NEW_PLATFORM_SDK) +_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedIncrement(long volatile *); +_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedDecrement(long volatile *); +_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedExchange(long volatile *, long); +# if defined (STLPInterlockedExchangePointer) +_STLP_IMPORT_DECLSPEC void* _STLP_STDCALL STLPInterlockedExchangePointer(void* volatile *, void*); +# endif +_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedExchangeAdd(long volatile *, long); +# elif defined (_STLP_WCE) + +/* start of eMbedded Visual C++ specific section */ +# include <windef.h> /* needed for basic windows types */ + + /** in SDKs generated with PB5, windef.h somehow includes headers which then + define setjmp. */ +# if (_WIN32_WCE >= 0x500) +# define _STLP_NATIVE_SETJMP_H_INCLUDED +# endif + +# ifndef _WINBASE_ /* winbase.h already included? */ +long WINAPI InterlockedIncrement(long*); +long WINAPI InterlockedDecrement(long*); +long WINAPI InterlockedExchange(long*, long); +# endif + +# ifndef __WINDOWS__ /* windows.h already included? */ + +# if defined (x86) +# include <winbase.h> /* needed for inline versions of Interlocked* functions */ +# endif + +# ifndef _MFC_VER + +# define MessageBox MessageBoxW +int WINAPI MessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType); + +# define wvsprintf wvsprintfW +int WINAPI wvsprintfW(LPWSTR, LPCWSTR, va_list ArgList); + +void WINAPI ExitThread(DWORD dwExitCode); + +# if !defined (COREDLL) +# define _STLP_WCE_WINBASEAPI DECLSPEC_IMPORT +# else +# define _STLP_WCE_WINBASEAPI +# endif + +_STLP_WCE_WINBASEAPI int WINAPI +MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, + int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar); + +_STLP_WCE_WINBASEAPI UINT WINAPI GetACP(); + +_STLP_WCE_WINBASEAPI BOOL WINAPI TerminateProcess(HANDLE hProcess, DWORD uExitCode); + +# define OutputDebugString OutputDebugStringW +void WINAPI OutputDebugStringW(LPCWSTR); + +_STLP_WCE_WINBASEAPI void WINAPI Sleep(DWORD); + +# undef _STLP_WCE_WINBASEAPI + +# endif /* !_MFC_VER */ + +# endif /* !__WINDOWS__ */ + +/* end of eMbedded Visual C++ specific section */ + +# else +/* boris : for the latest SDK, you may actually need the other version of the declaration (above) + * even for earlier VC++ versions. There is no way to tell SDK versions apart, sorry ... + */ +_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedIncrement(long*); +_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedDecrement(long*); +_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedExchange(long*, long); +# endif + +# if !defined (STLPInterlockedExchangePointer) +/* This API function do not exist in the old platform SDK and is equivalent to + * InterlockedExchange on 32 bits platform: + */ +# if defined (__cplusplus) +/* We do not define this function if we are not in a C++ translation unit just + * because of the inline portability issue it would introduce. We will have to + * fix it the day we need this function for a C translation unit. + */ +inline +void* _STLP_CALL STLPInterlockedExchangePointer(void* volatile* __a, void* __b) { +# if defined (_STLP_MSVC) +/* Here MSVC produces warning if 64 bits portability issue is activated. + * MSVC do not see that _STLP_ATOMIC_EXCHANGE_PTR is a macro which content + * is based on the platform, Win32 or Win64 + */ +# pragma warning (push) +# pragma warning (disable : 4311) // pointer truncation from void* to long +# pragma warning (disable : 4312) // conversion from long to void* of greater size +# endif +# if !defined (_STLP_NO_NEW_STYLE_CASTS) + return reinterpret_cast<void*>(InterlockedExchange(reinterpret_cast<long*>(const_cast<void**>(__a)), + reinterpret_cast<long>(__b))); +# else + return (void*)InterlockedExchange((long*)__a, (long)__b); +# endif +# if defined (_STLP_MSVC) +# pragma warning (pop) +# endif +} +# endif +# endif + +# if !defined (_STLP_WCE) +_STLP_IMPORT_DECLSPEC void _STLP_STDCALL Sleep(unsigned long); +_STLP_IMPORT_DECLSPEC void _STLP_STDCALL OutputDebugStringA(const char* lpOutputString); +# endif + +# if defined (InterlockedIncrement) +# pragma intrinsic(_InterlockedIncrement) +# pragma intrinsic(_InterlockedDecrement) +# pragma intrinsic(_InterlockedExchange) +# pragma intrinsic(_InterlockedExchangePointer) +# endif +# if defined (__cplusplus) +} /* extern "C" */ +# endif + +# endif /* STL_MSVC __BORLANDC__ __ICL __WATCOMC__ __MINGW32__ __DMC__*/ + +#endif /* _STLP_WINDOWS_H_INCLUDED */ + +#endif /* _STLP_INTERNAL_WINDOWS_H */ diff --git a/WebKit/android/stlport/stl/config/compat.h b/WebKit/android/stlport/stl/config/compat.h new file mode 100644 index 0000000..f03d874 --- /dev/null +++ b/WebKit/android/stlport/stl/config/compat.h @@ -0,0 +1,84 @@ + +/* + * Compatibility section + * This section sets new-style macros based on old-style ones, for compatibility + */ + +#if defined (__STL_DEBUG) && !defined (_STLP_DEBUG) +# define _STLP_DEBUG __STL_DEBUG +#endif +#if defined (__STL_NO_ANACHRONISMS) && !defined (_STLP_NO_ANACHRONISMS) +# define _STLP_NO_ANACHRONISMS __STL_NO_ANACHRONISMS +#endif +#if defined (__STL_NO_EXTENSIONS) && !defined (_STLP_NO_EXTENSIONS) +# define _STLP_NO_EXTENSIONS __STL_NO_EXTENSIONS +#endif +#if defined (__STL_NO_EXCEPTIONS) && !defined (_STLP_NO_EXCEPTIONS) +# define _STLP_NO_EXCEPTIONS __STL_NO_EXCEPTIONS +#endif +#if defined (__STL_NO_NAMESPACES) && !defined (_STLP_NO_NAMESPACES) +# define _STLP_NO_NAMESPACES __STL_NO_NAMESPACES +#endif +#if defined (__STL_MINIMUM_DEFAULT_TEMPLATE_PARAMS) && !defined (_STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS) +# define _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS __STL_MINIMUM_DEFAULT_TEMPLATE_PARAMS +#endif +#if defined (__STL_NO_OWN_NAMESPACE) && !defined (_STLP_NO_OWN_NAMESPACE) +# define _STLP_NO_OWN_NAMESPACE __STL_NO_OWN_NAMESPACE +#endif + +#if defined (__STL_NO_RELOPS_NAMESPACE) && !defined (_STLP_NO_RELOPS_NAMESPACE) +# define _STLP_NO_RELOPS_NAMESPACE __STL_NO_RELOPS_NAMESPACE +#endif + +#if defined (__STL_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_UNINITIALIZED) +# define _STLP_DEBUG_UNINITIALIZED __STL_DEBUG_UNINITIALIZED +#endif +#if defined (__STL_SHRED_BYTE) && !defined (_STLP_SHRED_BYTE) +# define _STLP_SHRED_BYTE __STL_SHRED_BYTE +#endif +#if defined (__STL_USE_MFC) && !defined (_STLP_USE_MFC) +# define _STLP_USE_MFC __STL_USE_MFC +#endif + +#if defined (__STL_USE_NEWALLOC) && !defined (_STLP_USE_NEWALLOC) +# define _STLP_USE_NEWALLOC __STL_USE_NEWALLOC +#endif +#if defined (__STL_USE_MALLOC) && !defined (_STLP_USE_MALLOC) +# define _STLP_USE_MALLOC __STL_USE_MALLOC +#endif + +#if defined (__STL_DEBUG_ALLOC) && !defined (_STLP_DEBUG_ALLOC) +# define _STLP_DEBUG_ALLOC __STL_DEBUG_ALLOC +#endif + +#if defined (__STL_DEBUG_MESSAGE) && !defined (_STLP_DEBUG_MESSAGE) +# define _STLP_DEBUG_MESSAGE __STL_DEBUG_MESSAGE +#endif + +#if defined (__STL_DEBUG_TERMINATE) && !defined (_STLP_DEBUG_TERMINATE) +# define _STLP_DEBUG_TERMINATE __STL_DEBUG_TERMINATE +#endif + +#if defined (__STL_USE_ABBREVS) && !defined (_STLP_USE_ABBREVS) +# define _STLP_USE_ABBREVS __STL_USE_ABBREVS +#endif + +#if defined (__STL_NO_MSVC50_COMPATIBILITY) && !defined (_STLP_NO_MSVC50_COMPATIBILITY) +# define _STLP_NO_MSVC50_COMPATIBILITY __STL_NO_MSVC50_COMPATIBILITY +#endif + +#if defined (__STL_USE_RAW_SGI_ALLOCATORS) && !defined (_STLP_USE_RAW_SGI_ALLOCATORS) +# define _STLP_USE_RAW_SGI_ALLOCATORS __STL_USE_RAW_SGI_ALLOCATORS +#endif + +/* STLport do not support anymore the iostream wrapper mode so this macro should + * always been define for other libraries that was using it: + */ +#if !defined (_STLP_OWN_IOSTREAMS) +# define _STLP_OWN_IOSTREAMS +#endif + +#if defined (_STLP_NO_OWN_IOSTREAMS) +# error STLport do not support anymore the wrapper mode. If you want to use STLport \ +use its iostreams implementation or no iostreams at all. +#endif diff --git a/WebKit/android/stlport/stl/config/features.h b/WebKit/android/stlport/stl/config/features.h new file mode 100644 index 0000000..7b285d5 --- /dev/null +++ b/WebKit/android/stlport/stl/config/features.h @@ -0,0 +1,1196 @@ + /* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Copyright (c) 1997 + * Moscow Center for SPARC Technology + * + * Copyright (c) 1999 + * Boris Fomitchev + * + * This material is provided "as is", with absolutely no warranty expressed + * or implied. Any use is at your own risk. + * + * Permission to use or copy this software for any purpose is hereby granted + * without fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ + +#ifndef _STLP_FEATURES_H +#define _STLP_FEATURES_H + +/* + * Purpose of this file: + * + * Defines all STLport settings. + * This file is actually a wrapper : it includes compiler-specific + * settings from <config/stlcomp.h> + * and user-defined settings from <config/user_config.h>. + * See <config/stl_mycomp.h> and <config/user_config.h> for the description + * of those macros + * + */ + +/* Definition of the STLport version informations */ +#include <stl/_stlport_version.h> + +/* Other macros defined by this file: + + * bool, true, and false, if _STLP_NO_BOOL is defined. + * typename, as a null macro if it's not already a keyword. + * explicit, as a null macro if it's not already a keyword. + * namespace-related macros (_STLP_STD, _STLP_BEGIN_NAMESPACE, etc.) + * exception-related macros (_STLP_TRY, _STLP_UNWIND, etc.) + * _STLP_ASSERT, either as a test or as a null macro, depending on + whether or not _STLP_ASSERTIONS is defined. +*/ + +/* Definition of the 2 STLport debug levels */ +#define _STLP_STLPORT_DBG_LEVEL 1 +#define _STLP_STANDARD_DBG_LEVEL 2 + +/* Placeholder for user to override settings. + * It could be also used to mask settings from + * different directories. + */ +#include <stl/config/user_config.h> + +#if defined (_STLP_DEBUG) && !defined (_STLP_DEBUG_LEVEL) +# define _STLP_DEBUG_LEVEL _STLP_STLPORT_DBG_LEVEL +#endif + +#if defined (__BUILDING_STLPORT) +/* For the STLport implementation we can use everything: + */ +# if defined (_STLP_NO_ANACHRONISMS) +# undef _STLP_NO_ANACHRONISMS +# endif +# if defined (_STLP_NO_EXTENSIONS) +# undef _STLP_NO_EXTENSIONS +# endif +/* Moreover there are things that has no sens: + */ +# if defined (_STLP_NO_IOSTREAMS) +# error If you do not use iostreams you do not need to build the STLport library. +# endif +#endif + +/* ========================================================= */ +/* This file is used for compatibility; it accepts old-style config + switches */ +#include <stl/config/compat.h> + +/* Common configuration file for this particular installation. */ +#include <stl/config/host.h> + +/* Operational Environment specific */ +#include <stl/config/_system.h> + +/* ========================================================= */ + +/* some fixes to configuration. This also includes modifications + * of STLport switches depending on compiler flags, + * or settings applicable to a group of compilers, such as + * to all who use EDG front-end. + */ +#include <stl/config/stl_confix.h> + +#ifdef _STLP_USE_BOOST_SUPPORT +/* We are going to use the boost library support. To limit the problem + * of self referencing headers we have to specify clearly to the boost + * library that the Standard lib is STLport: + */ +# ifndef BOOST_STDLIB_CONFIG +# define BOOST_STDLIB_CONFIG <boost/config/stdlib/stlport.hpp> +# endif +#endif + + +/* + * Performs integrity check on user-specified parameters + * and site-specific settings. + */ +/* +# include <stl/_check_config.h> +*/ + +/* SGI terms */ + +#if !defined (_STLP_NO_MEMBER_TEMPLATES) && !defined (_STLP_MEMBER_TEMPLATES) +# define _STLP_MEMBER_TEMPLATES 1 +#endif + +#if !defined (_STLP_NO_FRIEND_TEMPLATES) && !defined (_STLP_FRIEND_TEMPLATES) +# define _STLP_FRIEND_TEMPLATES 1 +#endif + +#if !defined (_STLP_NO_MEMBER_TEMPLATE_CLASSES) && !defined (_STLP_MEMBER_TEMPLATE_CLASSES) +# define _STLP_MEMBER_TEMPLATE_CLASSES 1 +#endif + +#if defined (_STLP_NO_MEMBER_TEMPLATE_CLASSES) && !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) +# define _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE 1 +#endif + +#if !defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) +# define _STLP_CLASS_PARTIAL_SPECIALIZATION 1 +#endif + +#if !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) && !defined (_STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER) +# define _STLP_FUNCTION_TMPL_PARTIAL_ORDER 1 +#endif + +#if !defined (_STLP_DONT_USE_SHORT_STRING_OPTIM) && !defined (_STLP_USE_SHORT_STRING_OPTIM) +# define _STLP_USE_SHORT_STRING_OPTIM 1 +#endif + +#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_NO_EXTENSIONS) && \ + !defined (_STLP_NO_CONTAINERS_EXTENSION) && !defined (_STLP_USE_CONTAINERS_EXTENSION) +# define _STLP_USE_CONTAINERS_EXTENSION +#endif + +#if defined (_STLP_USE_CONTAINERS_EXTENSION) +# define _STLP_TEMPLATE_FOR_CONT_EXT template <class _KT> +#else +# define _STLP_TEMPLATE_FOR_CONT_EXT +#endif + +#if defined (_STLP_USE_PTR_SPECIALIZATIONS) && \ + (defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION) && defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)) +# error "Sorry but according the STLport settings your compiler can not support the pointer specialization feature." +#endif + +#if defined (_STLP_NO_IOSTREAMS) && \ + !defined (_STLP_USE_NEWALLOC) && !defined (_STLP_USE_MALLOC) +# define _STLP_USE_NEWALLOC +#endif + +#if !defined (_STLP_BIG_ENDIAN) && !defined (_STLP_LITTLE_ENDIAN) +# if defined (_MIPSEB) || defined (__sparc) || defined (_AIX) || \ + defined (__hpux) || defined (macintosh) || defined (_MAC) +# define _STLP_BIG_ENDIAN 1 +# elif defined (__i386) || defined (_M_IX86) || defined (_M_ARM) || \ + defined (__amd64__) || defined (_M_AMD64) || defined (__x86_64__) || \ + defined (__alpha__) +# define _STLP_LITTLE_ENDIAN 1 +# elif defined (__ia64__) + /* itanium allows both settings (for instance via gcc -mbig-endian) - hence a seperate check is required */ +# if defined (__BIG_ENDIAN__) +# define _STLP_BIG_ENDIAN 1 +# else +# define _STLP_LITTLE_ENDIAN 1 +# endif +# else +# error "can't determine endianess" +# endif +#endif /* _STLP_BIG_ENDIAN */ + +/* ========================================================== + * final workaround tuning based on given flags + * ========================================================== */ + +#ifndef _STLP_UINT32_T +# define _STLP_UINT32_T unsigned long +#endif +#ifndef _STLP_ABORT +# define _STLP_ABORT() abort() +#endif + +#if !defined (_STLP_HAS_NO_NAMESPACES) +# if defined _STLP_NO_NAMESPACES +# undef _STLP_USE_NAMESPACES +# else +/* assume it as the default, turn it off later if NO_NAMESPACES selected */ +# undef _STLP_USE_NAMESPACES +# define _STLP_USE_NAMESPACES 1 +# endif +#endif + +#if defined (_STLP_NO_IOSTREAMS) +# define _STLP_USE_NO_IOSTREAMS +#endif + +/* Operating system recognition (basic) */ +#if defined (__unix) || defined (__linux__) || defined (__QNX__) || defined (_AIX) || defined (__NetBSD__) || defined(__OpenBSD__) || defined (__Lynx__) +# define _STLP_UNIX 1 +#elif defined(macintosh) || defined (_MAC) +# define _STLP_MAC 1 +#elif defined (_WIN32) || defined (__WIN32) || defined (WIN32) || defined (__WIN32__) +# ifndef __SYMBIAN32__ +# define _STLP_WIN32 1 +# endif +#elif defined (__WIN16) || defined (WIN16) || defined (_WIN16) +# define _STLP_WIN16 +#endif /* __unix */ + +#if defined (_STLP_WIN16) +# define _STLP_LDOUBLE_80 +#elif defined(_STLP_WIN32) +# if defined (_STLP_MSVC) || defined (__ICL) || defined (__BORLANDC__) || defined (__CYGWIN__) +# define _STLP_LDOUBLE_64 +# else +# define _STLP_LDOUBLE_96 +# endif +#elif defined (_STLP_UNIX) +# if defined (__CYGWIN__) +# define _STLP_LDOUBLE_96 +# endif +#endif + +#if !defined (_STLP_LDOUBLE_64) && !defined (_STLP_LDOUBLE_80) && !defined (_STLP_LDOUBLE_96) && !defined (_STLP_LDOUBLE_128) +# define _STLP_LDOUBLE_128 +#endif + +#if !defined (_STLP_NO_LONG_DOUBLE) +# define _STLP_LONGEST_FLOAT_TYPE long double +#else +# define _STLP_LONGEST_FLOAT_TYPE double +#endif + +/* Native headers access macros */ +#include <stl/config/_native_headers.h> + +/* shared library tune-up */ + +#if defined (__BUILDING_STLPORT) +/* if we are rebuilding right now, place everything here */ +# undef _STLP_DESIGNATED_DLL +# define _STLP_DESIGNATED_DLL 1 +#endif + +/* Use own namespace always if possible and not explicitly instructed otherwise */ +#if defined (_STLP_USE_NAMESPACES) && !defined (_STLP_BROKEN_USING_DIRECTIVE) && \ + !defined (_STLP_NO_OWN_NAMESPACE) +# undef _STLP_USE_OWN_NAMESPACE +# define _STLP_USE_OWN_NAMESPACE 1 +#else +# undef _STLP_WHOLE_NATIVE_STD +#endif + +#if !defined (_NOTHREADS) && !defined (_STLP_THREADS_DEFINED) + +# if defined (_PTHREADS) +# define _STLP_PTHREADS +# define _STLP_THREADS +# endif +# if defined (_UITHREADS) +# define _STLP_UITHREADS +# define _STLP_THREADS +# endif + +# if defined (__sgi) && !defined (__KCC) && !defined (__GNUC__) +# define _STLP_SGI_THREADS +# elif defined (__DECC) || defined (__DECCXX) +# define _STLP_DEC_THREADS +# elif defined (_STLP_WIN32) && !defined (_STLP_PTHREADS) +# define _STLP_WIN32THREADS 1 +# elif ((defined (__sun) && !defined (__linux__)) || defined (_UITHREADS) ) && \ + !defined(_STLP_PTHREADS) +# define _STLP_UITHREADS +# elif defined (__OS2__) +# define _STLP_OS2THREADS +# elif defined (__BEOS__) +# define _STLP_BETHREADS +# elif defined (__MWERKS__) && defined (N_PLAT_NLM) /* (__dest_os == __netware_os) */ +# define _STLP_NWTHREADS +# else +# define _STLP_PTHREADS +# endif /* __sgi */ +# define _STLP_THREADS_DEFINED +#endif + +#if (defined (_REENTRANT) || defined (_THREAD_SAFE) || \ + (defined (_POSIX_THREADS) && defined (__OpenBSD__))) && \ + !defined (_STLP_THREADS) +# define _STLP_THREADS +#endif /* _REENTRANT */ + +#if defined (__linux__) && defined (_STLP_PTHREADS) +/* # include <features.h> */ + +# if defined (__USE_XOPEN2K) && !defined (_STLP_DONT_USE_PTHREAD_SPINLOCK) +# define _STLP_USE_PTHREAD_SPINLOCK +# define _STLP_STATIC_MUTEX _STLP_mutex +# endif /* __USE_XOPEN2K */ +#endif /* __linux__ && _STLP_PTHREADS */ + +#if defined (__OpenBSD__) && defined (_POSIX_THREADS) && !defined (_STLP_DONT_USE_PTHREAD_SPINLOCK) +# define _STLP_USE_PTHREAD_SPINLOCK +# define _STLP_STATIC_MUTEX _STLP_mutex +#endif + +#ifndef _STLP_STATIC_MUTEX +# define _STLP_STATIC_MUTEX _STLP_mutex_base +#endif + +#if (defined (_MFC_VER) || defined (_AFXDLL)) && !defined (_STLP_USE_MFC) +# define _STLP_USE_MFC 1 +#endif + +#if defined (_STLP_THREADS) +# define _STLP_VOLATILE volatile +/* windows.h _MUST be included before bool definition ;( */ +# if defined (_STLP_WIN32THREADS) && defined (_STLP_NO_BOOL) +# undef NOMINMAX +# define NOMINMAX +# ifdef _STLP_USE_MFC +# include <afx.h> +# else +# include <windows.h> +# endif +# define _STLP_WINDOWS_H_INCLUDED +# endif +#else +# define _STLP_VOLATILE +#endif + +#if !defined (_STLP_USE_NEW_C_HEADERS) && !defined (_STLP_HAS_NO_NEW_C_HEADERS) +# define _STLP_USE_NEW_C_HEADERS +#endif +/* disable new-style headers if requested */ +#if defined (_STLP_NO_NEW_C_HEADERS) +# undef _STLP_USE_NEW_C_HEADERS +#endif + +#if !defined (_STLP_STATIC_TEMPLATE_DATA) +# define _STLP_STATIC_TEMPLATE_DATA 1 +#endif + +#if defined (_STLP_BASE_TYPEDEF_BUG) +# undef _STLP_BASE_TYPEDEF_OUTSIDE_BUG +# define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1 +#endif + +#if defined (_STLP_NESTED_TYPE_PARAM_BUG) || (defined (_STLP_MSVC) && (_STLP_MSVC < 1100)) +# define _STLP_GLOBAL_NESTED_RETURN_TYPE_PARAM_BUG +#endif + +/* SUNpro 4.2 inline string literal bug */ +#ifdef _STLP_INLINE_STRING_LITERAL_BUG +# define _STLP_FIX_LITERAL_BUG(__x) __x = __x; +#else +# define _STLP_FIX_LITERAL_BUG(__x) +#endif + +#if defined (_STLP_NON_TYPE_TMPL_PARAM_BUG) +# undef _STLP_NO_DEFAULT_NON_TYPE_PARAM +# define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1 +#endif + +#define _STLP_NEW new +#define _STLP_PLACEMENT_NEW new + +#ifdef _STLP_DEBUG +# define _STLP_ASSERTIONS 1 +#endif + +#if !defined (_STLP_STATIC_ASSERT) +/* Some compiler support 0 size array so we use negative size array to generate + * a compilation time error. + */ +# define _STLP_STATIC_ASSERT(expr) typedef char __static_assert[expr ? 1 : -1]; +#endif + +/* apple mpw exception handling bug */ +#ifndef _STLP_MPWFIX_TRY +# define _STLP_MPWFIX_TRY +#endif +#ifndef _STLP_MPWFIX_CATCH +# define _STLP_MPWFIX_CATCH +#endif +#ifndef _STLP_MPWFIX_CATCH_ACTION +# define _STLP_MPWFIX_CATCH_ACTION(action) +#endif + +/* if _STLP_DEBUG or _STLP_ASSERTIONS are set, stl/debug/_debug.h defines those */ + +#if !defined (_STLP_ASSERTIONS) && !defined (_STLP_DEBUG) && !defined (_STLP_DEBUG_ALLOC) +# define _STLP_ASSERT(expr) +#endif + +#if !defined (_STLP_DEBUG) +# define _STLP_VERBOSE_ASSERT(expr,diagnostic) +# define _STLP_DEBUG_CHECK(expr) +# define _STLP_DEBUG_DO(expr) +#endif + +#if !defined (_STLP_WEAK) +# define _STLP_WEAK +#endif + +/* default parameters as template types derived from arguments ( not always supported ) */ +#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES) +# define _STLP_DFL_TMPL_PARAM( classname, defval ) class classname +#else +# if !defined (_STLP_DEFAULT_TYPE_PARAM) +# define _STLP_DEFAULT_TYPE_PARAM 1 +# endif +# define _STLP_DFL_TMPL_PARAM( classname, defval ) class classname = defval +#endif + +/* default parameters as complete types */ +#if defined (_STLP_DEFAULT_TYPE_PARAM) +# define _STLP_DFL_TYPE_PARAM( classname, defval ) class classname = defval +# define _STLP_DFL_NON_TYPE_PARAM(type,name,val) type name = val +#else +# define _STLP_DFL_TYPE_PARAM( classname, defval ) class classname +# define _STLP_DFL_NON_TYPE_PARAM(type,name,val) type name +#endif + +/* SGI compatibility */ + +#ifdef _STLP_NO_WCHAR_T +# ifndef _STLP_NO_NATIVE_WIDE_STREAMS +# define _STLP_NO_NATIVE_WIDE_STREAMS 1 +# endif +#else +# define _STLP_HAS_WCHAR_T 1 +#endif + +#if !defined (_STLP_NO_AT_MEMBER_FUNCTION) +# define _STLP_CAN_THROW_RANGE_ERRORS 1 +#endif + +#if !defined (_STLP_USE_RAW_SGI_ALLOCATORS) +# define _STLP_DEFAULT_ALLOCATOR(_Tp) allocator< _Tp > +# define _STLP_DEFAULT_ALLOCATOR_SELECT( _Tp ) _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) +# define _STLP_DEFAULT_PAIR_ALLOCATOR(_Key, _Tp) allocator< pair < _Key, _Tp > > +# if defined (_STLP_LIMITED_DEFAULT_TEMPLATES) +# define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) class _Alloc +# define _STLP_USE_WRAPPER_FOR_ALLOC_PARAM 1 +# else +# define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) \ + class _Alloc = allocator< pair < _Key, _Tp > > +# endif +#else +# define _STLP_DEFAULT_ALLOCATOR( _Tp ) __sgi_alloc +# define _STLP_DEFAULT_ALLOCATOR_SELECT( _Tp ) _STLP_DFL_TYPE_PARAM(_Alloc,__sgi_alloc) +# define _STLP_DEFAULT_PAIR_ALLOCATOR( _Key, _Tp ) __sgi_alloc +# define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) _STLP_DFL_TYPE_PARAM(_Alloc,__sgi_alloc) +# if defined (_STLP_LIMITED_DEFAULT_TEMPLATES) && !defined (_STLP_DEFAULT_TYPE_PARAM) +# define _STLP_USE_WRAPPER_FOR_ALLOC_PARAM 1 +# endif +#endif + +/* debug mode tool */ +#if defined (_STLP_DEBUG) +# define _STLP_NON_DBG_NAME(X) _NonDbg_##X +#endif + +/* pointer specialization tool */ +#if defined (_STLP_USE_PTR_SPECIALIZATIONS) +# define _STLP_PTR_IMPL_NAME(X) _Impl_##X +#endif + +#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) +# define _STLP_NO_MEM_T_NAME(X) _NoMemT_##X +# if defined (_STLP_DEBUG) +# define _STLP_NON_DBG_NO_MEM_T_NAME(X) _NonDbg_NoMemT_##X +# endif +#endif + +/* this always mean the C library is in global namespace */ +#if defined (_STLP_HAS_NO_NEW_C_HEADERS) && !defined (_STLP_VENDOR_GLOBAL_CSTD) +# define _STLP_VENDOR_GLOBAL_CSTD 1 +#endif + +/* Depending of whether compiler supports namespaces, + * tune the parameters for vendor-supplied libraries. + * This section is guarded by _STLP_HAS_NO_NAMESPACES, not by _STLP_USE_NAMESPACES, + * since it depends only on the native features, not on user's preference whether + * to use namespace for STLport or not. + */ +#if !defined (_STLP_HAS_NO_NAMESPACES) +/* Import some vendor's headers into corresponding STLport ones if they might be needed + * (if we wrap native iostreams and use namepace other than std::) */ +# if defined (_STLP_WHOLE_NATIVE_STD) +# define _STLP_IMPORT_VENDOR_STD 1 +# undef _STLP_MINIMUM_IMPORT_STD +# endif + +/* if using stlport:: namespace or if C library stuff is not in vendor's std::, + * try importing 'em. + * MSVC has ambiguity problem when we try to import C-style std:: stuff back into global namespace */ +# if defined (_STLP_USE_NAMESPACES) && (defined(_STLP_USE_OWN_NAMESPACE) || defined (_STLP_VENDOR_GLOBAL_CSTD)) +# define _STLP_IMPORT_VENDOR_CSTD 1 +# endif + +# if defined (_STLP_NO_USING_FOR_GLOBAL_FUNCTIONS) && !defined (_STLP_DO_IMPORT_CSTD_FUNCTIONS) +# define _STLP_NO_CSTD_FUNCTION_IMPORTS +# endif + +# define _STLP_USING_NAMESPACE(x) using namespace x ; + +namespace std { } +namespace __std_alias = std; + +/* assume std:: namespace for C++ std library if not being told otherwise */ +# if defined (_STLP_VENDOR_GLOBAL_STD) +# define _STLP_VENDOR_STD +# else +# define _STLP_VENDOR_STD __std_alias +# endif + +/* tune things that come from C library */ +# if defined (_STLP_VENDOR_GLOBAL_CSTD) || !defined(_STLP_USE_NEW_C_HEADERS) +/* in old-style headers, C functions go to global scope. */ +# define _STLP_VENDOR_CSTD +# define _STLP_USING_VENDOR_CSTD +# else +# define _STLP_VENDOR_CSTD _STLP_VENDOR_STD +# define _STLP_USING_VENDOR_CSTD _STLP_USING_NAMESPACE(_STLP_VENDOR_CSTD) +# endif /* _STLP_VENDOR_CSTD */ +/* exception, typeinfo, new - always come from the vendor */ +# if !defined (_STLP_VENDOR_EXCEPT_STD) +# if defined (_STLP_VENDOR_GLOBAL_EXCEPT_STD) +# define _STLP_VENDOR_EXCEPT_STD +# else +# define _STLP_VENDOR_EXCEPT_STD _STLP_VENDOR_STD +# endif +# endif +# define _STLP_OLD_IO_NAMESPACE +# if !defined (_STLP_VENDOR_MB_NAMESPACE) +# define _STLP_VENDOR_MB_NAMESPACE _STLP_VENDOR_CSTD +# endif +#else +/* compiler has no namespace support */ +# define _STLP_VENDOR_STD +# define _STLP_VENDOR_CSTD +# define _STLP_USING_NAMESPACE(x) +# define _STLP_USING_VENDOR_CSTD +# define _STLP_VENDOR_EXCEPT_STD +#endif + +#if defined (_STLP_USE_NAMESPACES) + +# if defined (_STLP_USE_OWN_NAMESPACE) +# if !defined (_STLP_STD_NAME) +# if !defined (_STLP_DEBUG) +# if !defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB) +# ifndef _STLP_THREADS +# define _STLP_STD_NAME stlpmtx_std +# else +# define _STLP_STD_NAME stlp_std +# endif +# else +# ifndef _STLP_THREADS +# define _STLP_STD_NAME stlpxmtx_std +# else +# define _STLP_STD_NAME stlpx_std +# endif +# endif +# else +/* + * The STLport debug mode is binary incompatible with the other modes, + * lets make it clear on the STLport namespace to generate link errors rather + * than runtime. + */ +# if !defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB) +# ifndef _STLP_THREADS +# define _STLP_STD_NAME stlpdmtx_std +# else +# define _STLP_STD_NAME stlpd_std +# endif +# else +# ifndef _STLP_THREADS +# define _STLP_STD_NAME stlpdxmtx_std +# else +# define _STLP_STD_NAME stlpdx_std +# endif +# endif +# endif +# endif +namespace _STLP_STD_NAME { } +# else +# if defined (_STLP_DEBUG) +namespace stdD = std; +# endif +# define _STLP_STD_NAME std +# endif /* _STLP_USE_OWN_NAMESPACE */ + +# if !defined (_STLP_USING_NAMESPACE_BUG) +# define _STLP_PRIV_NAME stlp_priv +namespace _STLP_PRIV_NAME { + using namespace _STLP_STD_NAME; +} +# else +# define _STLP_PRIV_NAME priv +# endif + +# define _STLP_BEGIN_NAMESPACE namespace _STLP_STD_NAME { +# define _STLP_END_NAMESPACE } + +# if !defined (_STLP_DONT_USE_PRIV_NAMESPACE) +# if !defined (_STLP_USING_NAMESPACE_BUG) +/* We prefer to make private namespace a totaly seperated namespace... + */ +# define _STLP_PRIV ::_STLP_PRIV_NAME:: +# define _STLP_MOVE_TO_PRIV_NAMESPACE } namespace _STLP_PRIV_NAME { +# define _STLP_MOVE_TO_STD_NAMESPACE } namespace _STLP_STD_NAME { +# else +/* but sometimes we can't: + */ +# define _STLP_PRIV _STLP_PRIV_NAME:: +# define _STLP_MOVE_TO_PRIV_NAMESPACE namespace _STLP_PRIV_NAME { +# define _STLP_MOVE_TO_STD_NAMESPACE } +# endif +# else +# define _STLP_PRIV +# define _STLP_MOVE_TO_PRIV_NAMESPACE +# define _STLP_MOVE_TO_STD_NAMESPACE +# endif + +/* decide whether or not we use separate namespace for rel ops */ +# if defined (_STLP_NO_RELOPS_NAMESPACE) +# define _STLP_BEGIN_RELOPS_NAMESPACE _STLP_BEGIN_NAMESPACE namespace rel_ops {} +# define _STLP_END_RELOPS_NAMESPACE } +# else +/* Use std::rel_ops namespace */ +# define _STLP_BEGIN_RELOPS_NAMESPACE _STLP_BEGIN_NAMESPACE namespace rel_ops { +# define _STLP_END_RELOPS_NAMESPACE } } +# define _STLP_USE_SEPARATE_RELOPS_NAMESPACE +# endif /* Use std::rel_ops namespace */ + +# define _STLP_STD ::_STLP_STD_NAME + +/* Official STLport namespace when std is not redefined. + * Here we don't use a macro as stlport is used as file name by boost + * and folder name under beos: + */ +namespace stlport = _STLP_STD_NAME; + +/* Backward compatibility: + */ +namespace _STL = _STLP_STD_NAME; +#undef __STLPORT_NAMESPACE +#define __STLPORT_NAMESPACE _STLP_STD_NAME + +#else /* _STLP_USE_NAMESPACES */ +/* STLport is being put into global namespace */ +# define _STLP_STD +# define _STLP_PRIV +# define _STLP_BEGIN_NAMESPACE +# define _STLP_END_NAMESPACE +# define _STLP_MOVE_TO_PRIV_NAMESPACE +# define _STLP_MOVE_TO_STD_NAMESPACE + +/* boris : it was found out that _STLP_USE_SEPARATE_RELOPS_NAMESPACE + causes less problems than having relational operator templates in global namespace + Please define _STLP_NO_RELOPS_NAMESPACE in config/user_config.h if your code rely on them. */ +# if !defined (_STLP_NO_RELOPS_NAMESPACE) +# define _STLP_USE_SEPARATE_RELOPS_NAMESPACE +# endif +# define _STLP_BEGIN_RELOPS_NAMESPACE +# define _STLP_END_RELOPS_NAMESPACE +# undef _STLP_USE_OWN_NAMESPACE +#endif /* _STLP_USE_NAMESPACES */ + +#define STLPORT_CSTD _STLP_VENDOR_CSTD +#define STLPORT _STLP_STD_NAME + +#if defined(_STLP_BOGUS_TEMPLATE_TYPE_MATCHING_BUG) +# define _STLP_SIMPLE_TYPE(T) _stl_trivial_proxy<T> +#else +# define _STLP_SIMPLE_TYPE(T) T +#endif + +#ifndef _STLP_RAND48 +# define _STLP_NO_DRAND48 +#endif + +/* advanced keywords usage */ +#define __C_CAST(__x, __y) ((__x)(__y)) +#ifndef _STLP_NO_NEW_STYLE_CASTS +# define __CONST_CAST(__x,__y) const_cast<__x>(__y) +# define __STATIC_CAST(__x,__y) static_cast<__x>(__y) +# define __REINTERPRET_CAST(__x,__y) reinterpret_cast<__x>(__y) +# define __DYNAMIC_CAST(__x,__y) dynamic_cast<__x>(__y) +#else +# define __STATIC_CAST(__x,__y) __C_CAST(__x, __y) +# define __CONST_CAST(__x,__y) __C_CAST(__x, __y) +# define __REINTERPRET_CAST(__x,__y) __C_CAST(__x, __y) +# define __DYNAMIC_CAST(__x,__y) __C_CAST(__x, __y) +#endif + +#if defined (_STLP_NEED_TYPENAME) && ! defined (typename) +# define typename +#endif + +#if defined (_STLP_NEED_TYPENAME) || defined (_STLP_NO_TYPENAME_ON_RETURN_TYPE ) +# define _STLP_TYPENAME_ON_RETURN_TYPE +#else +# define _STLP_TYPENAME_ON_RETURN_TYPE typename +#endif + +#ifdef _STLP_NO_TYPENAME_IN_TEMPLATE_HEADER +# define _STLP_HEADER_TYPENAME +#else +# define _STLP_HEADER_TYPENAME typename +#endif + +#ifndef _STLP_NO_MEMBER_TEMPLATE_KEYWORD +# define _STLP_TEMPLATE template +#else +# define _STLP_TEMPLATE +#endif + +#if defined (_STLP_USE_CONTAINERS_EXTENSION) +# define _STLP_KEY_TYPE_FOR_CONT_EXT(type) +# define _STLP_TEMPLATE_FOR_CONT_EXT template <class _KT> +#else +# define _STLP_KEY_TYPE_FOR_CONT_EXT(type) typedef type _KT; +# define _STLP_TEMPLATE_FOR_CONT_EXT +#endif + +#if defined (_STLP_NEED_EXPLICIT) && !defined (explicit) +# define explicit +#endif + +#if !defined (_STLP_NEED_MUTABLE) +# define _STLP_ASSIGN_MUTABLE(type,x,y) x = y +#else +# define _STLP_ASSIGN_MUTABLE(type,x,y) __CONST_CAST(type,x)=y +# define mutable +#endif + +#if defined (_STLP_NO_SIGNED_BUILTINS) +/* old HP-UX doesn't understand "signed" keyword */ +# define signed +#endif + +#if defined (_STLP_LOOP_INLINE_PROBLEMS) +# define _STLP_INLINE_LOOP +#else +# define _STLP_INLINE_LOOP inline +#endif + +#define _STLP_PRIVATE public + +#ifndef _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX +# define _STLP_TEMPLATE_NULL template<> +#else +# define _STLP_TEMPLATE_NULL +#endif + +#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER +# define _STLP_OPERATOR_TEMPLATE +#else +# define _STLP_OPERATOR_TEMPLATE _STLP_TEMPLATE_NULL +#endif + +#ifndef _STLP_CLASS_PARTIAL_SPECIALIZATION +/* unless we have other compiler problem, try simulating partial spec here */ +# if !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) +# define _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS +# endif +/* For your own iterators, please use inheritance from iterator<> instead of these obsolete queries. */ +# if (defined (_STLP_NESTED_TYPE_PARAM_BUG) || !defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)) +# if ! defined ( _STLP_USE_OLD_HP_ITERATOR_QUERIES ) +# define _STLP_USE_OLD_HP_ITERATOR_QUERIES +# endif +# elif defined ( _STLP_NO_ANACHRONISMS ) +# undef _STLP_USE_OLD_HP_ITERATOR_QUERIES +# endif +#endif + +#ifndef _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS +# define _STLP_NULL_TMPL_ARGS <> +# else +# define _STLP_NULL_TMPL_ARGS +#endif + +#if !defined (_STLP_ALLOCATOR_TYPE_DFL) +# if defined (_STLP_DONT_SUP_DFLT_PARAM) +# define _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS +# endif +# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) +# define _STLP_ALLOCATOR_TYPE_DFL +# else +# define _STLP_ALLOCATOR_TYPE_DFL = allocator_type() +# endif +#endif + +/* When the compiler do not correctly initialized the basic types value in default parameters we prefer + * to avoid them to be able to correct this bug. + */ +#if defined (_STLP_DEF_CONST_DEF_PARAM_BUG) +# define _STLP_DONT_SUP_DFLT_PARAM 1 +#endif + +#if defined (__SGI_STL_NO_ARROW_OPERATOR) && ! defined (_STLP_NO_ARROW_OPERATOR) +# define _STLP_NO_ARROW_OPERATOR +#endif + +#if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) +# if !(defined (_STLP_NO_ARROW_OPERATOR)) && \ + !defined (_STLP_NO_MSVC50_COMPATIBILITY) && !defined (_STLP_MSVC50_COMPATIBILITY) +/* this one is needed for proper reverse_iterator<> operator ->() handling */ +# define _STLP_MSVC50_COMPATIBILITY 1 +# endif +#endif + +#if defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION ) +# if (defined(__IBMCPP__) && (500 <= __IBMCPP__) && (__IBMCPP__ < 600) ) +# define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \ + typedef typename _STLP_STD :: reverse_iterator<const_iterator> const_reverse_iterator; \ + typedef typename _STLP_STD :: reverse_iterator<iterator> reverse_iterator +# elif (defined (__sgi) && ! defined (__GNUC__)) || defined (__SUNPRO_CC) || defined (__xlC__) +# define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \ + typedef _STLP_STD:: _STLP_TEMPLATE reverse_iterator<const_iterator> const_reverse_iterator; \ + typedef _STLP_STD:: _STLP_TEMPLATE reverse_iterator<iterator> reverse_iterator +# else +# define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \ + typedef _STLP_STD::reverse_iterator<const_iterator> const_reverse_iterator; \ + typedef _STLP_STD::reverse_iterator<iterator> reverse_iterator +# endif +#else /* _STLP_CLASS_PARTIAL_SPECIALIZATION */ +# if defined (_STLP_MSVC50_COMPATIBILITY) +# define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \ + typedef _STLP_STD::__reverse_iterator<const_iterator, value_type, const_reference, \ + const_pointer, difference_type> const_reverse_iterator; \ + typedef _STLP_STD::__reverse_iterator<iterator, value_type, reference, pointer, difference_type> \ + reverse_iterator +# else +# define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \ + typedef _STLP_STD::__reverse_iterator<const_iterator, value_type, const_reference, \ + difference_type> const_reverse_iterator; \ + typedef _STLP_STD::__reverse_iterator<iterator, value_type, \ + reference, difference_type> \ + reverse_iterator +# endif +#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */ + +#define _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS \ + _STLP_DECLARE_REVERSE_ITERATORS(reverse_bidirectional_iterator) +#define _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS \ + _STLP_DECLARE_REVERSE_ITERATORS(reverse_iterator) + +#define __IMPORT_CONTAINER_TYPEDEFS(_Super) \ + typedef typename _Super::value_type value_type; \ + typedef typename _Super::size_type size_type; \ + typedef typename _Super::difference_type difference_type; \ + typedef typename _Super::reference reference; \ + typedef typename _Super::const_reference const_reference; \ + typedef typename _Super::pointer pointer; \ + typedef typename _Super::const_pointer const_pointer; \ + typedef typename _Super::allocator_type allocator_type; + + +#define __IMPORT_ITERATORS(_Super) \ + typedef typename _Super::iterator iterator; \ + typedef typename _Super::const_iterator const_iterator; + +#define __IMPORT_REVERSE_ITERATORS(_Super) \ + typedef typename _Super::const_reverse_iterator const_reverse_iterator; \ + typedef typename _Super::reverse_iterator reverse_iterator; + +#define __IMPORT_SUPER_COPY_ASSIGNMENT(__derived_name, _Self, _SUPER) \ + __derived_name(const _Super& __x) : _SUPER(__x) {} \ + _Self& operator=(const _Super& __x) { \ + *(_Super*)this = __x; \ + return *this; \ + } \ + __derived_name(const _Self& __x) : _SUPER(__x) {} \ + _Self& operator=(const _Self& __x) { \ + *(_Super*)this = __x; \ + return *this; \ + } + +#define __IMPORT_WITH_ITERATORS(_Super) \ + __IMPORT_CONTAINER_TYPEDEFS(_Super) __IMPORT_ITERATORS(_Super) + +#define __IMPORT_WITH_REVERSE_ITERATORS(_Super) \ + __IMPORT_WITH_ITERATORS(_Super) __IMPORT_REVERSE_ITERATORS(_Super) + +#if defined (_STLP_TRIVIAL_CONSTRUCTOR_BUG) +# define __TRIVIAL_CONSTRUCTOR(__type) __type() {} +#else +# define __TRIVIAL_CONSTRUCTOR(__type) +#endif + +#if defined (_STLP_TRIVIAL_DESTRUCTOR_BUG) +# define __TRIVIAL_DESTRUCTOR(__type) ~__type() {} +#else +# define __TRIVIAL_DESTRUCTOR(__type) +#endif + +#define __TRIVIAL_STUFF(__type) \ + __TRIVIAL_CONSTRUCTOR(__type) __TRIVIAL_DESTRUCTOR(__type) + +#if defined (_STLP_HAS_NO_EXCEPTIONS) +# define _STLP_NO_EXCEPTIONS +#endif + +#if !defined (_STLP_DONT_USE_EXCEPTIONS) && !defined (_STLP_NO_EXCEPTIONS) && !defined (_STLP_USE_EXCEPTIONS) +# define _STLP_USE_EXCEPTIONS +#endif + +#if defined (_STLP_USE_EXCEPTIONS) +# define _STLP_TRY try +# define _STLP_CATCH_ALL catch(...) +# ifndef _STLP_THROW +# define _STLP_THROW(x) throw x +# endif +# define _STLP_RETHROW throw + +# define _STLP_UNWIND(action) catch(...) { action; throw; } + +# ifdef _STLP_THROW_RETURN_BUG +# define _STLP_RET_AFTER_THROW(data) return data; +# else +# define _STLP_RET_AFTER_THROW(data) +# endif + +/* We do not use exception throw specifications unless we are forced to */ +# if !defined (_STLP_THROWS) +# define _STLP_THROWS(x) +# endif +# if !defined (_STLP_NOTHROW) +# define _STLP_NOTHROW +# endif +#else +# define _STLP_TRY +# define _STLP_CATCH_ALL if (false) +# ifndef _STLP_THROW +# define _STLP_THROW(x) +# endif +# define _STLP_RETHROW {} +# define _STLP_UNWIND(action) +# define _STLP_THROWS(x) +# define _STLP_NOTHROW +# define _STLP_RET_AFTER_THROW(data) +#endif + +/* + * Here we check _STLP_NO_EXCEPTIONS which means that the compiler has no + * exception support but not the _STLP_USE_EXCEPTIONS which simply means + * that the user do not want to use them. + */ +#if !defined (_STLP_NO_EXCEPTIONS) && !defined (_STLP_NO_EXCEPTION_SPEC) +# define _STLP_THROWS_INHERENTLY(x) throw x +# define _STLP_NOTHROW_INHERENTLY throw() +#else +# define _STLP_THROWS_INHERENTLY(x) +# define _STLP_NOTHROW_INHERENTLY +#endif + +/* STLport function not returning are functions that throw so we translate + * the noreturn functions in throwing functions taking also into account + * exception support activation. + */ +#if defined (_STLP_NORETURN_FUNCTION) && !defined (_STLP_NO_EXCEPTIONS) && \ + !defined (_STLP_FUNCTION_THROWS) +# define _STLP_FUNCTION_THROWS _STLP_NORETURN_FUNCTION +#else +# define _STLP_FUNCTION_THROWS +#endif + +#if defined(_STLP_NO_BOOL) +# if (defined (__IBMCPP__) && (__IBMCPP__ < 400)) && ! defined (_AIX) +# include <isynonym.hpp> +# if defined (__OS400__) +typedef int bool; +# elif !( defined (__xlC__) || defined (_AIX)) +typedef Boolean bool; +# endif +# else +# if defined(_STLP_YVALS_H) +# include <yvals.h> +# else +# if defined (_STLP_DONT_USE_BOOL_TYPEDEF) +# define bool int +# else +typedef int bool; +# endif +# define true 1 +# define false 0 +# endif +# endif /* __IBMCPP__ */ +#else +# define _STLP_BOOL_KEYWORD 1 +#endif /* _STLP_NO_BOOL */ + +#ifndef _STLP_MPW_EXTRA_CONST +# define _STLP_MPW_EXTRA_CONST +#endif + +#ifndef _STLP_DEFAULTCHAR +# define _STLP_DEFAULTCHAR char +#endif + +#if defined (_STLP_DEBUG_ALLOC) && !defined (_STLP_ASSERTIONS) +# define _STLP_ASSERTIONS 1 +#endif + +/* uninitialized value filler */ +#ifndef _STLP_SHRED_BYTE +/* This value is designed to cause problems if an error occurs */ +# define _STLP_SHRED_BYTE 0xA3 +#endif /* _STLP_SHRED_BYTE */ + +/* shared library tune-up */ +#ifndef _STLP_IMPORT_DECLSPEC +# define _STLP_IMPORT_DECLSPEC +#endif + +/* a keyword used to instantiate export template */ +#ifndef _STLP_EXPORT_TEMPLATE_KEYWORD +# define _STLP_EXPORT_TEMPLATE_KEYWORD +#endif +#ifndef _STLP_IMPORT_TEMPLATE_KEYWORD +# define _STLP_IMPORT_TEMPLATE_KEYWORD +#endif + +#ifdef _STLP_USE_NO_IOSTREAMS +/* + * If we do not use iostreams we do not use the export/import + * techniques to avoid build of the STLport library. + */ +# undef _STLP_USE_DECLSPEC +/* We also undef USE_DYNAMIC_LIB macro as this macro add some code + * to use the dynamic (shared) STLport library for some platform/compiler + * configuration leading to problem when do not link to the STLport lib. + */ +# undef _STLP_USE_DYNAMIC_LIB +#endif + +#if defined (_STLP_DLLEXPORT_NEEDS_PREDECLARATION) && defined (_STLP_USE_DECLSPEC) +# if ! defined (_STLP_USE_TEMPLATE_EXPORT) +/* this setting turns on "extern template" extension use */ +# define _STLP_USE_TEMPLATE_EXPORT +# endif +# if defined (_STLP_DESIGNATED_DLL) && ! defined (_STLP_NO_FORCE_INSTANTIATE) +# define _STLP_NO_FORCE_INSTANTIATE +# endif +#endif + +#if defined (_STLP_DESIGNATED_DLL) /* This is a lib which will contain STLport exports */ +# define _STLP_EXPORT _STLP_EXPORT_TEMPLATE_KEYWORD +#else +# define _STLP_EXPORT _STLP_IMPORT_TEMPLATE_KEYWORD +#endif + +#ifndef _STLP_EXPORT_TEMPLATE +# define _STLP_EXPORT_TEMPLATE _STLP_EXPORT template +#endif + +#if defined (_STLP_USE_DECLSPEC) /* using export/import technique */ + +# ifndef _STLP_EXPORT_DECLSPEC +# define _STLP_EXPORT_DECLSPEC +# endif +# ifndef _STLP_IMPORT_DECLSPEC +# define _STLP_IMPORT_DECLSPEC +# endif +# ifndef _STLP_CLASS_EXPORT_DECLSPEC +# define _STLP_CLASS_EXPORT_DECLSPEC +# endif +# ifndef _STLP_CLASS_IMPORT_DECLSPEC +# define _STLP_CLASS_IMPORT_DECLSPEC +# endif +# if defined (_STLP_DESIGNATED_DLL) /* This is a lib which will contain STLport exports */ +# define _STLP_DECLSPEC _STLP_EXPORT_DECLSPEC +# define _STLP_CLASS_DECLSPEC _STLP_CLASS_EXPORT_DECLSPEC +# else +# define _STLP_DECLSPEC _STLP_IMPORT_DECLSPEC /* Other modules, importing STLport exports */ +# define _STLP_CLASS_DECLSPEC _STLP_CLASS_IMPORT_DECLSPEC +# endif + +#else /* Not using DLL export/import specifications */ + +# define _STLP_DECLSPEC +# define _STLP_CLASS_DECLSPEC + +#endif + +#define _STLP_EXPORT_TEMPLATE_CLASS _STLP_EXPORT template class _STLP_CLASS_DECLSPEC + +#if defined (_STLP_MSVC) || defined (__ICL) +# define _STLP_STATIC_MEMBER_DECLSPEC +#else +# define _STLP_STATIC_MEMBER_DECLSPEC _STLP_DECLSPEC +#endif + +#if !defined (_STLP_CALL) +# define _STLP_CALL +#endif + +#ifndef _STLP_USE_NO_IOSTREAMS + +# if defined (__DECCXX) && ! defined (__USE_STD_IOSTREAM) +# define __USE_STD_IOSTREAM +# endif + +/* We only need to expose details of streams implementation + if we use non-standard i/o or are building STLport*/ +# if defined (__BUILDING_STLPORT) || defined (_STLP_NO_FORCE_INSTANTIATE) || !defined(_STLP_NO_CUSTOM_IO) +# define _STLP_EXPOSE_STREAM_IMPLEMENTATION 1 +# endif + +/* We only need to expose details of global implementation if we are building STLport + or have not instantiated everything in the lib */ +# if defined (__BUILDING_STLPORT) || defined (_STLP_NO_FORCE_INSTANTIATE) +# undef _STLP_EXPOSE_GLOBALS_IMPLEMENTATION +# define _STLP_EXPOSE_GLOBALS_IMPLEMENTATION 1 +# endif + +#else /* _STLP_USE_NO_IOSTREAMS */ +/* when we are not using SGI iostreams, we must expose globals, but not streams implementation */ +# define _STLP_EXPOSE_GLOBALS_IMPLEMENTATION +#endif /* _STLP_USE_NO_IOSTREAMS */ + +#ifdef _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS +# define _STLP_PSPEC2(t1,t2) < t1,t2 > +# define _STLP_PSPEC3(t1,t2,t3) < t1,t2,t3 > +#else +# define _STLP_PSPEC2(t1,t2) /* nothing */ +# define _STLP_PSPEC3(t1,t2,t3) /* nothing */ +#endif + +/* Activation of the partial template workaround: + */ +#if !defined(_STLP_DONT_USE_PARTIAL_SPEC_WRKD) &&\ + (!defined(_STLP_CLASS_PARTIAL_SPECIALIZATION) || !defined(_STLP_FUNCTION_TMPL_PARTIAL_ORDER)) +# define _STLP_USE_PARTIAL_SPEC_WORKAROUND +#endif + +#ifndef _STLP_USE_NO_IOSTREAMS +# define _STLP_NEW_IO_NAMESPACE _STLP_STD +# define _STLP_NO_WIDE_STREAMS _STLP_NO_WCHAR_T +#endif + +#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE +# define _STLP_RELOPS_OPERATORS(_TMPL, _TP) \ +_TMPL inline bool _STLP_CALL operator!=(const _TP& __x, const _TP& __y) {return !(__x == __y);}\ +_TMPL inline bool _STLP_CALL operator>(const _TP& __x, const _TP& __y) {return __y < __x;}\ +_TMPL inline bool _STLP_CALL operator<=(const _TP& __x, const _TP& __y) { return !(__y < __x);}\ +_TMPL inline bool _STLP_CALL operator>=(const _TP& __x, const _TP& __y) { return !(__x < __y);} +#else +# define _STLP_RELOPS_OPERATORS(_TMPL, _TP) +#endif + +#if defined ( _STLP_USE_ABBREVS ) +# include <stl/_abbrevs.h> +#endif + +/* A really useful macro */ +#define _STLP_ARRAY_SIZE(A) sizeof(A) / sizeof(A[0]) +#define _STLP_ARRAY_AND_SIZE(A) A, sizeof(A) / sizeof(A[0]) + +/* some cleanup */ +#undef _STLP_DONT_USE_BOOL_TYPEDEF +#undef _STLP_YVALS_H +#undef _STLP_LOOP_INLINE_PROBLEMS +#undef _STLP_NEED_EXPLICIT +#undef _STLP_NEED_TYPENAME +#undef _STLP_NO_NEW_STYLE_CASTS +#undef __AUTO_CONFIGURED + +#endif /* _STLP_FEATURES_H */ diff --git a/WebKit/android/stlport/stl/config/host.h b/WebKit/android/stlport/stl/config/host.h new file mode 100644 index 0000000..95b71a3 --- /dev/null +++ b/WebKit/android/stlport/stl/config/host.h @@ -0,0 +1,279 @@ +/* + * This file defines site configuration. + */ + +/* + * _STLP_NO_THREADS: if defined, STLport don't use any + * multithreading support. Synonym is _NOTHREADS + */ +/* +#define _NOTHREADS +#define _STLP_NO_THREADS +*/ + +/* _PTHREADS: if defined, use POSIX threads for multithreading support. */ +/* +#define _PTHREADS +*/ + +/* compatibility section + */ + +#if (defined (_STLP_NOTHREADS) || defined (_STLP_NO_THREADS) || defined (NOTHREADS)) +# if !defined (_NOTHREADS) +# define _NOTHREADS +# endif +# if !defined (_STLP_NO_THREADS) +# define _STLP_NO_THREADS +# endif +#endif + +#if !defined(_STLP_USE_DYNAMIC_LIB) && !defined(_STLP_USE_STATIC_LIB) +/* + * Turn _STLP_USE_DYNAMIC_LIB to enforce use of .dll version of STLport library. + * NOTE: please do that only if you know what you are doing! + * Changing default will require you to change makefiles in "build" accordingly + * and to rebuild STLPort library! + * On UNIX, this has no effect, see build/lib/README for make tags. + * See STLport configuration file (build/lib/configure.bat) for help in building + * the require library versions. + */ +/* +#define _STLP_USE_DYNAMIC_LIB +*/ + +/* + * Turn _STLP_USE_STATIC_LIB to enforce use of static version of STLport library. + * NOTE: please do that only if you know what you are doing! + * Changing default will require you to change makefile in "build" accordingly + * and to rebuild STLPort library! + * On UNIX, this has no effect, see build/lib/README for make tags. + * See STLport configuration file (build/lib/configure.bat) for help in building + * the require library versions. + */ +/* +#define _STLP_USE_STATIC_LIB +*/ +#endif + +/* + * Signal STLport that we are using the cygwin distrib with the -mno-cygwin option. + * This is similar to a mingw environment except that relative path to native headers + * is different, this is why we need this macro. + */ +/* +#define _STLP_NO_CYGWIN + */ + +/* + * Edit relative path below (or put full path) to get native + * compiler vendor's headers included. Default is "../include" + * for _STLP_NATIVE_INCLUDE_PATH, default for other macros is + * _STLP_NATIVE_INCLUDE_PATH. + * Hint: never install STLport in the directory that ends with "include" + */ +/* +#undef _STLP_NATIVE_INCLUDE_PATH +#define _STLP_NATIVE_INCLUDE_PATH ../include +*/ +/* same for C library headers like <cstring> */ +/* +#undef _STLP_NATIVE_CPP_C_INCLUDE_PATH +#define _STLP_NATIVE_CPP_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH +*/ +/* same for C headers like <string.h> */ +/* +#undef _STLP_NATIVE_C_INCLUDE_PATH +#define _STLP_NATIVE_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH +*/ +/* Some compilers locate basic C++ runtime support headers (<new>, <typeinfo>, <exception>) in separate directory */ +/* +#undef _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH +#define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH +*/ + +/* + * If namespases available, STLport use own namespace (and masquerade + * it as std). Disable own namespace may cause undefined behaviour. + */ +/* +#define _STLP_NO_OWN_NAMESPACE 1 +*/ + +/* + * Uncomment _STLP_LEAKS_PEDANTIC to force deallocation of ALL allocated + * memory chunks. Normally not required. But if you worry about quazi-leaks + * (may be reported by some leaks detection tools), use + * _STLP_LEAKS_PEDANTIC. It should be used with _STLP_USE_NEWALLOC or + * _STLP_USE_MALLOC (see below), the default node_alloc allocator also clean + * its internal memory pool but only if STLport is used as a dynamic library + * under Win32 (using MSVC like compilers). + */ +/* +#define _STLP_LEAKS_PEDANTIC 1 +*/ + +/* + * Uncomment _STLP_USE_NEWALLOC to force allocator<T> to use plain "new" + * instead of STLport optimized node allocator engine. + */ +/* +#define _STLP_USE_NEWALLOC 1 +*/ + +/* + * Uncomment _STLP_USE_MALLOC to force allocator<T> to use plain "malloc" + * instead of STLport optimized node allocator engine. + */ +/* +#define _STLP_USE_MALLOC 1 +*/ + +/* + * Uncomment _STLP_USE_PERTHREAD_ALLOC to force allocator<T> to use + * a specific implementation targetting the massively multi-threaded + * environment. The implementation is based on the POSIX pthread + * interface. + */ +/* +#define _STLP_USE_PERTHREAD_ALLOC 1 +*/ + +/* + * Set _STLP_DEBUG_ALLOC to use allocators that perform memory debugging, + * such as padding/checking for memory consistency + */ +/* +#define _STLP_DEBUG_ALLOC 1 +*/ + +/* + * For compiler not supporting partial template specialization or ordering of + * template functions STLport implement a workaround based on inheritance + * detection. This inheritance can introduce trouble in client code when + * a user class derived a STL container (which is not advised as STL containers + * do not have virtual destructors). To disable this workaround turn this macro on: + */ +/* +#define _STLP_DONT_USE_PARTIAL_SPEC_WRKD 1 +*/ + +/* + * Uncomment this to force all debug diagnostic to be directed through a + * user-defined global function: + * void __stl_debug_message(const char * format_str, ...) + * instead of predefined STLport routine. + * This allows you to take control of debug message output. + * Default routine calls fprintf(stderr,...) + * Note : If you set this macro, you must supply __stl_debug_message + * function definition somewhere. + */ +/* +#define _STLP_DEBUG_MESSAGE 1 +*/ + +/* + * Uncomment this to force all failed assertions to be executed through + * user-defined global function: + * void __stl_debug_terminate(void). This allows + * you to take control of assertion behaviour for debugging purposes. + * Default routine calls _STLP_ABORT(). + * Note : If you set this macro, you must supply __stl_debug_terminate + * function definition somewhere. + */ +/* +#define _STLP_DEBUG_TERMINATE 1 +*/ + +/* + * Uncomment that to disable exception handling code + */ +/* +#define _STLP_DONT_USE_EXCEPTIONS 1 +*/ + +/* + * _STLP_NO_NAMESPACES: if defined, don't put the library in namespace + * stlport:: or std::, even if the compiler supports namespaces + */ +/* +#define _STLP_NO_NAMESPACES 1 +*/ + +/*========================================================== + * Compatibility section + *==========================================================*/ + +/* + * Use abbreviated class names for linker benefit (don't affect interface). + * This option is obsolete, but should work in this release. + * + */ +/* +#define _STLP_USE_ABBREVS +*/ + +/* + * This definition precludes STLport reverse_iterator to be compatible with + * other parts of MSVC library. (With partial specialization, it just + * has no effect). + * Use it _ONLY_ if you use SGI-style reverse_iterator<> template explicitly + */ +/* +#define _STLP_NO_MSVC50_COMPATIBILITY 1 +*/ + +/* + * _STLP_USE_RAW_SGI_ALLOCATORS is a hook so that users can disable use of + * allocator<T> as default parameter for containers, and use SGI + * raw allocators as default ones, without having to edit library headers. + * Use of this macro is strongly discouraged. + */ +/* +#define _STLP_USE_RAW_SGI_ALLOCATORS 1 +*/ + +/* + * Use obsolete overloaded template functions iterator_category(), value_type(), distance_type() + * for querying iterator properties. Please note those names are non-standard and are not guaranteed + * to be used by every implementation. However, this setting is on by default when partial specialization + * is not implemented in the compiler and cannot be simulated (only if _STLP_NO_ANACHRONISMS is not set). + * Use of those interfaces for user-defined iterators is strongly discouraged: + * please use public inheritance from iterator<> template to achieve desired effect. + * Second form is to disable old-style queries in any case. + */ +/* +#define _STLP_USE_OLD_HP_ITERATOR_QUERIES +#define _STLP_NO_OLD_HP_ITERATOR_QUERIES +*/ + + +/* + * On systems with support of large files (_LARGEFILE_SOURCE, + * _LARGEFILE64_SOURCE defined) we will use 64-bit file offset, even if + * __USE_FILE_OFFSET64 or _FILE_OFFSET_BITS not defined or _FILE_OFFSET_BITS + * less than 64. In the last case sizeof(std::streamoff) may not be equal to + * sizeof(off_t), if you want to force equal size of off_t and streamoff, + * uncomment macro below. But pay attention, this has influence on libstlport + * and in future usage it may cause conflict with defined _FILE_OFFSET_BITS macro. + */ + +/* +#define _STLP_USE_DEFAULT_FILE_OFFSET +*/ + +/*==========================================================================*/ + +/* This section contains swithes which should be off by default, + * but so few compilers would have it undefined, so that we set them here, + * with the option to be turned off later in compiler-specific file + */ + +#define _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT +#define _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT + +/* + Local Variables: + mode:C++ + End: +*/ diff --git a/WebKit/android/stlport/stl/config/stl_confix.h b/WebKit/android/stlport/stl/config/stl_confix.h new file mode 100644 index 0000000..a1be1f2 --- /dev/null +++ b/WebKit/android/stlport/stl/config/stl_confix.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) 1999 + * Boris Fomitchev + * + * This material is provided "as is", with absolutely no warranty expressed + * or implied. Any use is at your own risk. + * + * Permission to use or copy this software for any purpose is hereby granted + * without fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ + +/* + * STLport configuration file + * It is internal STLport header - DO NOT include it directly + * Purpose of this file : to define STLport settings that depend on + * compiler flags or can be otherwise missed + * + */ + +#ifndef _STLP_CONFIX_H +# define _STLP_CONFIX_H + +/* If, by any chance, C compiler gets there, try to help it to pass smoothly */ +# if ! defined (__cplusplus) && ! defined (_STLP_HAS_NO_NAMESPACES) +# define _STLP_HAS_NO_NAMESPACES +# endif + +# if defined(__MINGW32__) +# define _STLP_NO_DRAND48 +# endif + +/* Modena C++ library */ +#if defined (__MWERKS__) && __MWERKS__ <= 0x2303 || (defined (__KCC) && __KCC_VERSION < 3400) +# include <mcompile.h> +# define _STLP_USE_MSIPL 1 +# if defined (__KCC) || (defined(__MSL_CPP__) && \ + ( (__MSL_CPP__ >= 0x5000 && defined( _MSL_NO_MESSAGE_FACET )) || \ + (__MSL_CPP__ < 0x5000 && defined( MSIPL_NL_TYPES ))) \ + ) +# define _STLP_NO_NATIVE_MESSAGE_FACET 1 +# endif +#endif + +/* common switches for EDG front-end */ +# if defined (__EDG_SWITCHES) +# if !(defined(_TYPENAME) || defined (_TYPENAME_IS_KEYWORD)) +# undef _STLP_NEED_TYPENAME +# define _STLP_NEED_TYPENAME 1 +# endif +# if !defined(_WCHAR_T_IS_KEYWORD) +# undef _STLP_NO_WCHAR_T +# define _STLP_NO_WCHAR_T 1 +# endif +# ifndef _PARTIAL_SPECIALIZATION_OF_CLASS_TEMPLATES +# undef _STLP_NO_CLASS_PARTIAL_SPECIALIZATION +# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 +# endif +# ifndef _MEMBER_TEMPLATES +# undef _STLP_NO_MEMBER_TEMPLATES +# define _STLP_NO_MEMBER_TEMPLATES 1 +# undef _STLP_NO_MEMBER_TEMPLATE_CLASSES +# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 +# endif +# if !defined(_MEMBER_TEMPLATE_KEYWORD) +# undef _STLP_NO_MEMBER_TEMPLATE_KEYWORD +# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 +# endif +# if !defined (__EXCEPTIONS) && ! defined (_EXCEPTIONS) +# undef _STLP_HAS_NO_EXCEPTIONS +# define _STLP_HAS_NO_EXCEPTIONS +# endif +# undef __EDG_SWITCHES +# endif /* EDG */ +#endif diff --git a/WebKit/android/stlport/stl/config/stl_gcce.h b/WebKit/android/stlport/stl/config/stl_gcce.h new file mode 100644 index 0000000..e5f7040 --- /dev/null +++ b/WebKit/android/stlport/stl/config/stl_gcce.h @@ -0,0 +1,20 @@ +#ifndef _STLP_WINSCW_H +#define _STLP_WINSCW_H + +#define _STLP_COMPILER "GCCE" + +//========================================================== + +# define _STLP_LONG_LONG long long + +#ifdef _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT +# undef _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT +#endif + +#ifdef _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT +# undef _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT +#endif + +//========================================================== + +#endif diff --git a/WebKit/android/stlport/stl/config/stl_mycomp.h b/WebKit/android/stlport/stl/config/stl_mycomp.h new file mode 100644 index 0000000..710d5fa --- /dev/null +++ b/WebKit/android/stlport/stl/config/stl_mycomp.h @@ -0,0 +1,290 @@ +/* + * Copyright (c) 1997 + * Moscow Center for SPARC Technology + * + * Copyright (c) 1999 + * Boris Fomitchev + * + * This material is provided "as is", with absolutely no warranty expressed + * or implied. Any use is at your own risk. + * + * Permission to use or copy this software for any purpose is hereby granted + * without fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ + +/* + * Purpose of this file : + * + * A list of COMPILER-SPECIFIC portion of STLport settings. + * This file is provided to help in manual configuration + * of STLport. This file is being included by stlcomp.h + * when STLport is unable to identify your compiler. + * Please remove the error diagnostic below before adjusting + * macros. + * + */ +#ifndef _STLP_MYCOMP_H +#define _STLP_MYCOMP_H + +#error "Your compiler version is not recognized by STLport. Please edit <stlport/stl/config/stl_mycomp.h>" + +//========================================================== + +// the values choosen here as defaults try to give +// maximum functionality on the most conservative settings + +// Mostly correct guess, change it for Alpha (and other environments +// that has 64-bit "long") +// # define _STLP_UINT32_T unsigned long + +// Disables wchar_t functionality +// # define _STLP_NO_WCHAR_T 1 + +// Define if wchar_t is not a unique type, and is actually a typedef to unsigned short. +// # define _STLP_WCHAR_T_IS_USHORT 1 + +// Uncomment if long long is available +// # define _STLP_LONG_LONG long long + +// Uncomment if long double is not available +// # define _STLP_NO_LONG_DOUBLE 1 + +// Uncomment this if your compiler does not support "typename" keyword +// # define _STLP_NEED_TYPENAME 1 + +// Uncomment this if your compiler does not support "mutable" keyword +// # define _STLP_NEED_MUTABLE 1 + +// Uncomment this if your compiler does not support "explicit" keyword +// # define _STLP_NEED_EXPLICIT 1 + +// Uncomment if new-style-casts like const_cast<> are not available +// # define _STLP_NO_NEW_STYLE_CASTS 1 + +// Uncomment this if your compiler does not have "bool" type +// # define _STLP_NO_BOOL 1 + +// Uncomment this if your compiler does not have "bool" type, but has "bool" keyword reserved +// # define _STLP_DONT_USE_BOOL_TYPEDEF 1 + +// Uncomment this if your compiler does not have "bool" type, but defines "bool" in <yvals.h> +// # define _STLP_YVALS_H 1 + +// Uncomment this if your compiler has limited or no default template arguments for classes +// # define _STLP_LIMITED_DEFAULT_TEMPLATES 1 + +// Uncomment this if your compiler support only complete (not dependent on other parameters) +// types as default parameters for class templates +// # define _STLP_DEFAULT_TYPE_PARAM 1 + +// Uncomment this if your compiler do not support default parameters in template class methods +// # define _STLP_DONT_SUP_DFLT_PARAM 1 + +// Uncomment this if your compiler has problem with not-type +// default template parameters +// # define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1 + +// Define if compiler has +// trouble with functions getting non-type-parameterized classes as parameters +// # define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 + +// Uncomment this if your compiler lacks static data members. +// Uncomment next line if your compiler supports __attribute__((weak)) +// # define _STLP_NO_STATIC_TEMPLATE_DATA 1 +// # define _STLP_WEAK_ATTRIBUTE 1 + +// Uncomment this if your compiler does not support namespaces +// # define _STLP_HAS_NO_NAMESPACES 1 + +// Uncomment if "using" keyword does not work with template types +// # define _STLP_BROKEN_USING_DIRECTIVE 1 + +// Uncomment this if your compiler does not support exceptions +// # define _STLP_HAS_NO_EXCEPTIONS 1 + +// Uncomment this when you are able to detect that the user do not +// want to use the exceptions feature. +// # define _STLP_DONT_USE_EXCEPTIONS 1 + +// Uncomment this if your compiler does not support exception specifications +// # define _STLP_NO_EXCEPTION_SPEC + +// Define this if your compiler requires return statement after throw() +// # define _STLP_THROW_RETURN_BUG 1 + +// Define this if your compiler do not support return of void +// # define _STLP_DONT_RETURN_VOID 1 + +// Header <new> that comes with the compiler +// does not define bad_alloc exception +// # define _STLP_NO_BAD_ALLOC 1 + +// Define this if your compiler do not throw bad_alloc from the new operator +// # define _STLP_NEW_DONT_THROW_BAD_ALLOC 1 + +// Uncomment if member template methods are not available +// # define _STLP_NO_MEMBER_TEMPLATES 1 + +// Uncomment if member template classes are not available +// # define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1 + +// Uncomment if your compiler do not support the std::allocator rebind technique +// This is a special case of bad member template classes support, it is automatically +// defined if _STLP_NO_MEMBER_TEMPLATE_CLASSES is defined. +// # define _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE 1 + +// Uncomment if no "template" keyword should be used with member template classes +// # define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1 + +// Uncomment if friend member templates are not available +// # define _STLP_NO_FRIEND_TEMPLATES 1 + +// Compiler does not accept friend declaration qualified with namespace name. +// # define _STLP_NO_QUALIFIED_FRIENDS 1 + +// Uncomment if partial specialization is not available +// # define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1 + +// Define if class being partially specialized require full name (template parameters) +// of itself for method declarations +// # define _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS + +// Compiler has problem with qualified specializations (cont int, volatile int...) +// # define _STLP_QUALIFIED_SPECIALIZATION_BUG + +// Compiler has problems specializing members of partially +// specialized class +// # define _STLP_MEMBER_SPECIALIZATION_BUG + +// Uncomment if partial order of template functions is not available +// # define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1 + +// Uncomment if specialization of methods is not allowed +// # define _STLP_NO_METHOD_SPECIALIZATION 1 + +// Uncomment if full specialization does not use partial spec. syntax : template <> struct .... +// # define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1 + +// Uncomment if compiler does not support explicit template arguments for functions +// # define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS + +// Uncomment this if your compiler can't inline while(), for() +// # define _STLP_LOOP_INLINE_PROBLEMS 1 + +// Define if the compiler fails to match a template function argument of base +// # define _STLP_BASE_MATCH_BUG 1 + +// Define if the compiler fails to match a template function argument of base +// (non-template) +//# define _STLP_NONTEMPL_BASE_MATCH_BUG 1 + +// Define if the compiler rejects outline method definition +// explicitly taking nested types/typedefs +// # define _STLP_NESTED_TYPE_PARAM_BUG 1 + +// Compiler requires typename keyword on outline method definition +// explicitly taking nested types/typedefs +// #define _STLP_TYPENAME_ON_RETURN_TYPE + +// Define if the baseclass typedefs not visible from outside +// # define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1 + +// if your compiler have serious problems with typedefs, try this one +// # define _STLP_BASE_TYPEDEF_BUG 1 + +// Uncomment if getting errors compiling mem_fun* adaptors +// # define _STLP_MEMBER_POINTER_PARAM_BUG 1 + +// * _STLP_STATIC_CONST_INIT_BUG: defined if the compiler can't handle a +// constant-initializer in the declaration of a static const data member +// of integer type. (See section 9.4.2, paragraph 4, of the C++ standard.) +// # define _STLP_STATIC_CONST_INIT_BUG + +// Define if default constructor for builtin integer type fails to initialize it to 0 +// In expression like new(&char) char(): +//# define _STLP_DEF_CONST_PLCT_NEW_BUG 1 +// In default function parameter like _M_method(_Tp __x = _Tp()) +//# define _STLP_DEF_CONST_DEF_PARAM_BUG 1 + +// Defined if constructor +// required to explicitly call member's default constructors for const objects +// # define _STLP_CONST_CONSTRUCTOR_BUG 1 + +// Defined if the compiler has trouble calling POD-types constructors/destructors +// # define _STLP_TRIVIAL_CONSTRUCTOR_BUG 1 +// # define _STLP_TRIVIAL_DESTRUCTOR_BUG 1 + +// Define if having problems specializing maps/sets with +// key type being const +// # define _STLP_MULTI_CONST_TEMPLATE_ARG_BUG + +// Uncomment this to disable -> operators on all iterators +// # define _STLP_NO_ARROW_OPERATOR 1 + +// Uncomment this to disble at() member functions for containers +// # define _STLP_NO_AT_MEMBER_FUNCTION 1 + +// Define this if compiler lacks <exception> header +// # define _STLP_NO_EXCEPTION_HEADER 1 + +// Uncomment this if your C library has lrand48() function +// # define _STLP_RAND48 1 + +// Uncomment if native new-style C library headers lile <cstddef>, etc are not available. +// # define _STLP_HAS_NO_NEW_C_HEADERS 1 + +// uncomment if new-style headers <new> is available +// # define _STLP_HAS_NEW_NEW_HEADER 1 + +// uncomment this if <iostream> and other STD headers put their stuff in ::namespace, +// not std:: +// # define _STLP_VENDOR_GLOBAL_STD + +// uncomment this if <cstdio> and the like put stuff in ::namespace, +// not std:: +// # define _STLP_VENDOR_GLOBAL_CSTD + +// uncomment this if your compiler consider as ambiguous a function imported within +// the stlport namespace and called without scope (:: or std::) +// # define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS 1 + +// uncomment this if your compiler define all the C math functions C++ additional +// overloads in ::namespace and not only in std::. +// # define _STLP_HAS_GLOBAL_C_MATH_FUNCTIONS 1 + +// uncomment this if your compiler has problem with the import of a namespace in +// an other one with the using namespace directive +// # define _STLP_USING_NAMESPACE_BUG 1 + +// Edit relative path below (or put full path) to get native +// compiler headers included. Default is "../include". +// C headers may reside in different directory, so separate macro is provided. +// Hint : never install STLport in the directory that ends with "include" +// # define _STLP_NATIVE_INCLUDE_PATH ../include +// # define _STLP_NATIVE_C_INCLUDE_PATH ../include +// # define _STLP_NATIVE_CPP_C_INCLUDE_PATH ../include + +// This macro constructs header path from directory and name. +// You may change it if your compiler does not understand "/". +// # define _STLP_MAKE_HEADER(path, header) <path/header> + +// This macro constructs native include header path from include path and name. +// You may have do define it if experimenting problems with preprocessor +// # define _STLP_NATIVE_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_INCLUDE_PATH,header) + +// Same for C headers +// #define _STLP_NATIVE_C_HEADER(header) + +// uncomment this if your compiler/platform do not fully support the IEC 559 floating point +// numbers specification (also known as IEEE 754 in the US). This specification define the +// infinity and NaN (Not a Number) representation. Unit tests should tell you if your compiler +// support it. +// # define _STLP_NO_IEC559_SUPPORT 1 + + +//========================================================== +#endif diff --git a/WebKit/android/stlport/stl/config/stl_symbian.h b/WebKit/android/stlport/stl/config/stl_symbian.h new file mode 100644 index 0000000..46ee3c4 --- /dev/null +++ b/WebKit/android/stlport/stl/config/stl_symbian.h @@ -0,0 +1,76 @@ +#ifndef __stlp_config_symbian_h +#define __stlp_config_symbian_h + +//========================================================== + +#if defined(_WIN32) +# undef _WIN32 +#endif + +//========================================================== + +#ifdef __cplusplus +# include <e32cmn.h> +#endif + +//========================================================== + +#if defined(__MARM__) +# if !defined(_M_ARM) +# define _M_ARM 1 +# endif +#else +# if !defined(_M_IX86) +# define _M_IX86 1 +# endif +#endif + +//========================================================== + +#define __PIPS__ + +//========================================================== + +#define _STLP_HAS_NO_NEW_C_HEADERS 1 +#define _STLP_NO_NEW_NEW_HEADER 1 +#define _STLP_NO_NEW_HEADER 1 +#define _STLP_NEW_DONT_THROW_BAD_ALLOC 1 +#define _STLP_NO_EXCEPTION_HEADER 1 +#define _STLP_NO_TYPEINFO 1 +#define _STLP_NO_VENDOR_STDLIB_L 1 +#define _STLP_USE_NOT_INIT_SEGMENT 1 +#define _STLP_NO_LONG_DOUBLE 1 +#define _STLP_NO_OWN_NAMESPACE 1 +#define _STLP_USE_MALLOC 1 +#define _STLP_USE_NO_EXTERN_RANGE_ERRORS 1 +#define _STLP_USE_SIMPLE_NODE_ALLOC 1 +#define _STLP_DONT_THROW_RANGE_ERRORS 1 +#define _STLP_EXPOSE_GLOBALS_IMPLEMENTATION 1 +#define _STLP_USE_NEWALLOC 1 +#define _STLP_INLINE_EXCEPTION_CLASS 1 +#define _STLP_USE_PARTIAL_SPEC_WORKAROUND 1 +#define _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS 1 +//========================================================== + +#ifdef _STLP_REAL_LOCALE_IMPLEMENTED +# undef _STLP_REAL_LOCALE_IMPLEMENTED +#endif + +//========================================================== + +#define _STLP_NATIVE_C_INCLUDE_PATH stdapis +//========================================================== + +#define _Locale_SPACE _CTYPE_S +#define _Locale_PRINT _CTYPE_R +#define _Locale_CNTRL _CTYPE_C +#define _Locale_UPPER _CTYPE_U +#define _Locale_LOWER _CTYPE_L +#define _Locale_ALPHA _CTYPE_A +#define _Locale_DIGIT _CTYPE_D +#define _Locale_PUNCT _CTYPE_P +#define _Locale_XDIGIT _CTYPE_X + +//========================================================== + +#endif diff --git a/WebKit/android/stlport/stl/config/stl_winscw.h b/WebKit/android/stlport/stl/config/stl_winscw.h new file mode 100644 index 0000000..ca161e9 --- /dev/null +++ b/WebKit/android/stlport/stl/config/stl_winscw.h @@ -0,0 +1,15 @@ +#ifndef _STLP_WINSCW_H +#define _STLP_WINSCW_H + +#define _STLP_COMPILER "WINSCW" + +#undef __MWERKS__ + +//========================================================== + +# define _STLP_WCHAR_T_IS_USHORT 1 +# define _STLP_LONG_LONG long long + +//========================================================== + +#endif diff --git a/WebKit/android/stlport/stl/config/user_config.h b/WebKit/android/stlport/stl/config/user_config.h new file mode 100644 index 0000000..07ac7f9 --- /dev/null +++ b/WebKit/android/stlport/stl/config/user_config.h @@ -0,0 +1,311 @@ +/* + * Copyright (c) 1999 + * Boris Fomitchev + * + * This material is provided "as is", with absolutely no warranty expressed + * or implied. Any use is at your own risk. + * + * Permission to use or copy this software for any purpose is hereby granted + * without fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +/* + * Purpose of this file : + * + * To hold user-definable portion of STLport settings which may be overridden + * on per-project basis. + * Please note that if you use STLport iostreams (compiled library) then you have + * to use consistent settings when you compile STLport library and your project. + * Those settings are defined in host.h and have to be the same for a given + * STLport installation. + */ + + +/*========================================================== + * User-settable macros that control compilation: + * Features selection + *==========================================================*/ + +/* + * Use this switch for embedded systems where no iostreams are available + * at all. STLport own iostreams will also get disabled automatically then. + * You can either use STLport iostreams, or no iostreams. + * If you want iostreams, you have to compile library in ../build/lib + * and supply resulting library at link time. + */ +/* +#define _STLP_NO_IOSTREAMS 1 +*/ + +/* + * Set _STLP_DEBUG to turn the "Debug Mode" on. + * That gets you checked iterators/ranges in the manner + * of "Safe STL". Very useful for debugging. Thread-safe. + * Please do not forget to link proper STLport library flavor + * (e.g libstlportstlg.so or libstlportstlg.a) when you set this flag + * in STLport iostreams mode, namespace customization guaranty that you + * link to the right library. + */ +/* +#define _STLP_DEBUG 1 +*/ +/* + * You can also choose the debug level: + * STLport debug level: Default value + * Check only what the STLport implementation consider as invalid. + * It also change the iterator invalidation schema. + * Standard debug level: Check for all operations the standard consider as "undefined behavior" + * even if STlport implement it correctly. It also invalidates iterators + * more often. + */ +/* +#define _STLP_DEBUG_LEVEL _STLP_STLPORT_DBG_LEVEL +#define _STLP_DEBUG_LEVEL _STLP_STANDARD_DBG_LEVEL +*/ +/* When an inconsistency is detected by the 'safe STL' the program will abort. + * If you prefer an exception define the following macro. The thrown exception + * will be the Standard runtime_error exception. + */ +/* +#define _STLP_DEBUG_MODE_THROWS + */ + +/* + * _STLP_NO_CUSTOM_IO : define this if you do not instantiate basic_xxx iostream + * classes with custom types (which is most likely the case). Custom means types + * other than char, wchar_t, char_traits<> and allocator<> like + * basic_ostream<my_char_type, my_traits<my_char_type> > or + * basic_string<char, char_traits<char>, my_allocator > + * When this option is on, most non-inline template functions definitions for iostreams + * are not seen by the client which saves a lot of compile time for most compilers, + * also object and executable size for some. + * Default is off, just not to break compilation for those who do use those types. + * That also guarantees that you still use optimized standard i/o when you compile + * your program without optimization. Option does not affect STLport library build; you + * may use the same binary library with and without this option, on per-project basis. + */ +/* +#define _STLP_NO_CUSTOM_IO +*/ + +/* + * _STLP_NO_RELOPS_NAMESPACE: if defined, don't put the relational + * operator templates (>, <=. >=, !=) in namespace std::rel_ops, even + * if the compiler supports namespaces. + * Note : if the compiler do not support namespaces, those operators are not be provided by default, + * to simulate hiding them into rel_ops. This was proved to resolve many compiler bugs with ambiguity. + */ +/* +#define _STLP_NO_RELOPS_NAMESPACE 1 +*/ + +/* + * If _STLP_USE_OWN_NAMESPACE is in effect, STLport by default will try + * to rename std:: for the user to stlport::. If you do not want this feature, + * please define the following switch and then use stlport:: + */ +/* +#define _STLP_DONT_REDEFINE_STD 1 +*/ + +/* + * _STLP_WHOLE_NATIVE_STD : only meaningful in _STLP_USE_OWN_NAMESPACE mode. + * Normally, STLport only imports necessary components from native std:: namespace - + * those not yet provided by STLport (<iostream>, <complex>, etc.) + * and their dependencies (<string>, <stdexcept>). + * You might want everything from std:: being available in std:: namespace when you + * include corresponding STLport header (like STLport <map> provides std::map as well, etc.), + * if you are going to use both stlport:: and std:: components in your code. + * Otherwise this option is not recommended as it increases the size of your object files + * and slows down compilation. + */ +/* +#define _STLP_WHOLE_NATIVE_STD +*/ + +/* + * Use this option to catch uninitialized members in your classes. + * When it is set, construct() and destroy() fill the class storage + * with _STLP_SHRED_BYTE (see below). + * Note : _STLP_DEBUG and _STLP_DEBUG_ALLOC don't set this option automatically. + */ +/* +#define _STLP_DEBUG_UNINITIALIZED 1 +#define _STLP_DEBUG_ALLOC 1 +*/ + +/* + * Uncomment and provide a definition for the byte with which raw memory + * will be filled if _STLP_DEBUG_ALLOC or _STLP_DEBUG_UNINITIALIZED is defined. + * Choose a value which is likely to cause a noticeable problem if dereferenced + * or otherwise abused. A good value may already be defined for your platform. + */ +/* +#define _STLP_SHRED_BYTE 0xA3 +*/ + +/* + * This option is for gcc users only and only affects systems where native linker + * does not let gcc to implement automatic instantiation of static template data members/ + * It is being put in this file as there is no way to check if we are using GNU ld automatically, + * so it becomes user's responsibility. + */ +/* +#define _STLP_GCC_USES_GNU_LD +*/ + +/*========================================================== + * Compatibility section + *==========================================================*/ + +/* + * Define this macro to disable anachronistic constructs (like the ones used in HP STL and + * not included in final standard, etc. + */ +/* +#define _STLP_NO_ANACHRONISMS 1 +*/ + +/* + * Define this macro to disable STLport extensions (for example, to make sure your code will + * compile with some other implementation ) + */ +/* +#define _STLP_NO_EXTENSIONS 1 +*/ + +/* + * You should define this macro if compiling with MFC - STLport <stl/config/_windows.h> + * then include <afx.h> instead of <windows.h> to get synchronisation primitives + */ +/* +#define _STLP_USE_MFC 1 +*/ + +/* + * boris : this setting is here as we cannot detect precense of new Platform SDK automatically + * If you are using new PSDK with VC++ 6.0 or lower, + * please define this to get correct prototypes for InterlockedXXX functions + */ +/* +#define _STLP_NEW_PLATFORM_SDK 1 +*/ + +/* + * For the same reason as the one above we are not able to detect easily use + * of the compiler coming with the Platform SDK instead of the one coming with + * a Microsoft Visual Studio release. This change native C/C++ library location + * and implementation, please define this to get correct STLport configuration. + */ +/* +#define _STLP_USING_PLATFORM_SDK_COMPILER 1 +*/ + +/* + * Some compilers support the automatic linking feature. + * Uncomment the following if you prefer to specify the STLport library + * to link with yourself. + * For the moment, this feature is only supported and implemented within STLport + * by the Microsoft compilers. + */ +/* +#define _STLP_DONT_USE_AUTO_LINK 1 +*/ + +/* + * If you customize the STLport generated library names don't forget to give + * the motif you used during configuration here if you still want the auto link + * to work. (Do not remove double quotes in the macro value) + */ +/* +#define _STLP_LIB_NAME_MOTIF "???" + */ + +/* + * When using automatic linking (see above), output a message that tells the + * user which lib is getting linked via 'pragma message(..)'. + * This setting has no effect if automatic linking is not active. + */ +/* +#define _STLP_VERBOSE_AUTO_LINK 1 +*/ + +/* + * Use minimum set of default arguments on template classes that have more + * than one - for example map<>, set<>. + * This has effect only if _STLP_LIMITED_DEFAULT_TEMPLATES is on. + * If _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS is set, you'll be able to compile + * set<T> with those compilers, but you'll have to use __set__<T, less<T>> + * + * Affects : map<>, multimap<>, set<>, multiset<>, hash_*<>, + * queue<>, priority_queue<>, stack<>, istream_iterator<> + */ +/* +#define _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS 1 +*/ + +/* + * The agregation of strings using the + operator is an expensive operation + * as it requires construction of temporary objects that need memory allocation + * and deallocation. The problem can be even more important if you are adding + * several strings together in a single expression. To avoid this problem STLport + * implement expression template. With this technique addition of 2 strings is not + * a string anymore but a temporary object having a reference to each of the + * original strings involved in the expression. This object carry information + * directly to the destination string to set its size correctly and only make + * a single call to the allocator. This technique also works for the addition of + * N elements where elements are basic_string, C string or a single character. + * The drawback can be longer compilation time and bigger executable size. + * STLport rebuild: Yes + */ +/* +#define _STLP_USE_TEMPLATE_EXPRESSION 1 +*/ + +/* + * By default the STLport basic_string implementation use a little static buffer + * (of 16 chars when writing this doc) to avoid systematically memory allocation + * in case of little basic_string. The drawback of such a method is bigger + * basic_string size and some performance penalty for method like swap. If you + * prefer systematical dynamic allocation turn on this macro. + * STLport rebuild: Yes + */ +/* +#define _STLP_DONT_USE_SHORT_STRING_OPTIM 1 +*/ + +/* + * To reduce the famous code bloat trouble due to the use of templates STLport grant + * a specialization of some containers for pointer types. So all instanciations + * of those containers with a pointer type will use the same implementation based on + * a container of void*. This feature has show very good result on object files size + * but after link phase and optimization you will only experiment benefit if you use + * many container with pointer types. + */ +/* +#define _STLP_USE_PTR_SPECIALIZATIONS 1 +*/ + +/* + * To achieve many different optimizations within the template implementations STLport + * uses some type traits technique. With this macro you can ask STLport to use the famous + * boost type traits rather than the internal one. The advantages are more compiler + * integration and a better support. If you only define this macro once the STLport has been + * built you just have to add the boost install path within your include path. If you want + * to use this feature at STLport built time you will have to define the + * STLP_BUILD_BOOST_PATH enrironment variable with the value of the boost library path. + */ +/* +#define _STLP_USE_BOOST_SUPPORT 1 +*/ + +/*==========================================================*/ + +/* + Local Variables: + mode: C++ + End: +*/ |