From a47ab5294213cca2741f453b450b02666e08cac8 Mon Sep 17 00:00:00 2001 From: Patrick Scott Date: Fri, 16 Oct 2009 15:11:59 -0400 Subject: Use STLPort instead of our stripped version. This fixes the simulator build and allows us to get closer to sharing code with chromium. STLPort was copied with minor edits from the Android port of gears. --- WebKit/android/stlport/stl/_construct.h | 245 ++++++++++++++++++++++++++++++++ 1 file changed, 245 insertions(+) create mode 100644 WebKit/android/stlport/stl/_construct.h (limited to 'WebKit/android/stlport/stl/_construct.h') diff --git a/WebKit/android/stlport/stl/_construct.h b/WebKit/android/stlport/stl/_construct.h new file mode 100644 index 0000000..f828d92 --- /dev/null +++ b/WebKit/android/stlport/stl/_construct.h @@ -0,0 +1,245 @@ +/* + * + * 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. + * + */ + +/* NOTE: This is an internal header file, included by other STL headers. + * You should not attempt to use it directly. + */ + +#ifndef _STLP_INTERNAL_CONSTRUCT_H +#define _STLP_INTERNAL_CONSTRUCT_H + +#if !defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_INTERNAL_CSTRING) +# include +#endif + +#ifndef _STLP_INTERNAL_NEW +# include +#endif + +#ifndef _STLP_INTERNAL_ITERATOR_BASE_H +# include +#endif + +#ifndef _STLP_MOVE_CONSTRUCT_FWK_H +# include +#endif + +_STLP_BEGIN_NAMESPACE + +template +inline void __destroy_aux(_Tp* __pointer, const __false_type& /*_Trivial_destructor*/) +{ __pointer->~_Tp(); } + +template +inline void __destroy_aux(_Tp*, const __true_type& /*_Trivial_destructor*/) {} + +template +inline void _Destroy(_Tp* __pointer) { +#if defined (_STLP_MSVC) && (_STLP_MSVC <= 1010) + __pointer; +#endif + typedef typename __type_traits<_Tp>::has_trivial_destructor _Trivial_destructor; + __destroy_aux(__pointer, _Trivial_destructor()); +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset(__REINTERPRET_CAST(char*, __pointer), _STLP_SHRED_BYTE, sizeof(_Tp)); +#endif +} + +template +inline void _Destroy_Moved(_Tp* __pointer) { + typedef typename __move_traits<_Tp>::complete _Trivial_destructor; + __destroy_aux(__pointer, _Trivial_destructor()); +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)__pointer, _STLP_SHRED_BYTE, sizeof(_Tp)); +#endif +} + +#if defined (new) +# define _STLP_NEW_REDEFINE new +# undef new +#endif + +#if defined (_STLP_DEF_CONST_PLCT_NEW_BUG) +template +inline void _Construct_aux (_T1* __p, const __false_type&) { + _STLP_PLACEMENT_NEW (__p) _T1(); +} + +template +inline void _Construct_aux (_T1* __p, const __true_type&) { + _STLP_PLACEMENT_NEW (__p) _T1(0); +} +#endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */ + +template +inline void _Construct(_T1* __p) { +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1)); +#endif +#if defined (_STLP_DEF_CONST_PLCT_NEW_BUG) + _Construct_aux (__p, _HasDefaultZeroValue(__p)._Answer() ); +#else + _STLP_PLACEMENT_NEW (__p) _T1(); +#endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */ +} + +template +inline void _Copy_Construct(_Tp* __p, const _Tp& __val) { +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_Tp)); +#endif + _STLP_PLACEMENT_NEW (__p) _Tp(__val); +} + +template +inline void _Param_Construct(_T1* __p, const _T2& __val) { +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1)); +#endif + _STLP_PLACEMENT_NEW (__p) _T1(__val); +} + +template +inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __false_type& /*_IsPOD*/) { + _STLP_PLACEMENT_NEW (__p) _T1(_STLP_PRIV _AsMoveSource(__val)); +} + +template +inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __true_type& /*_IsPOD*/) { + _STLP_PLACEMENT_NEW (__p) _T1(__val); +} + +template +inline void _Move_Construct(_T1* __p, _T2& __val) { +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1)); +#endif + _Move_Construct_Aux(__p, __val, _Is_POD(__p)._Answer()); +} + +#if defined(_STLP_NEW_REDEFINE) +# if defined (DEBUG_NEW) +# define new DEBUG_NEW +# endif +# undef _STLP_NEW_REDEFINE +#endif + +template +_STLP_INLINE_LOOP void +__destroy_range_aux(_ForwardIterator __first, _ForwardIterator __last, _Tp*, const __false_type& /*_Trivial_destructor*/) { + for ( ; __first != __last; ++__first) { + __destroy_aux(&(*__first), __false_type()); +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)&(*__first), _STLP_SHRED_BYTE, sizeof(_Tp)); +#endif + } +} + +template +#if defined (_STLP_DEBUG_UNINITIALIZED) +_STLP_INLINE_LOOP void +__destroy_range_aux(_ForwardIterator __first, _ForwardIterator __last, _Tp*, const __true_type& /*_Trivial_destructor*/) { + for ( ; __first != __last; ++__first) + memset((char*)&(*__first), _STLP_SHRED_BYTE, sizeof(_Tp)); +} +#else +inline void +__destroy_range_aux(_ForwardIterator, _ForwardIterator, _Tp*, const __true_type& /*_Trivial_destructor*/) {} +#endif + +template +inline void +__destroy_range(_ForwardIterator __first, _ForwardIterator __last, _Tp *__ptr) { + typedef typename __type_traits<_Tp>::has_trivial_destructor _Trivial_destructor; + __destroy_range_aux(__first, __last, __ptr, _Trivial_destructor()); +} + +template +inline void _Destroy_Range(_ForwardIterator __first, _ForwardIterator __last) { + __destroy_range(__first, __last, _STLP_VALUE_TYPE(__first, _ForwardIterator)); +} + +inline void _Destroy_Range(char*, char*) {} +#if defined (_STLP_HAS_WCHAR_T) // dwa 8/15/97 +inline void _Destroy_Range(wchar_t*, wchar_t*) {} +inline void _Destroy_Range(const wchar_t*, const wchar_t*) {} +#endif + +template +inline void +__destroy_mv_srcs(_ForwardIterator __first, _ForwardIterator __last, _Tp *__ptr) { + typedef typename __move_traits<_Tp>::complete _CompleteMove; + __destroy_range_aux(__first, __last, __ptr, _CompleteMove()); +} + +template +inline void _Destroy_Moved_Range(_ForwardIterator __first, _ForwardIterator __last) { + __destroy_mv_srcs(__first, __last, _STLP_VALUE_TYPE(__first, _ForwardIterator)); +} + +#if defined (_STLP_DEF_CONST_DEF_PARAM_BUG) +// Those adaptors are here to fix common compiler bug regarding builtins: +// expressions like int k = int() should initialize k to 0 +template +inline _Tp __default_constructed_aux(_Tp*, const __false_type&) { + return _Tp(); +} +template +inline _Tp __default_constructed_aux(_Tp*, const __true_type&) { + return _Tp(0); +} + +template +inline _Tp __default_constructed(_Tp* __p) { + return __default_constructed_aux(__p, _HasDefaultZeroValue(__p)._Answer()); +} + +# define _STLP_DEFAULT_CONSTRUCTED(_TTp) __default_constructed((_TTp*)0) +#else +# define _STLP_DEFAULT_CONSTRUCTED(_TTp) _TTp() +#endif /* _STLP_DEF_CONST_DEF_PARAM_BUG */ + + +#if !defined (_STLP_NO_ANACHRONISMS) +// -------------------------------------------------- +// Old names from the HP STL. + +template +inline void construct(_T1* __p, const _T2& __val) {_Param_Construct(__p, __val); } +template +inline void construct(_T1* __p) { _STLP_STD::_Construct(__p); } +template +inline void destroy(_Tp* __pointer) { _STLP_STD::_Destroy(__pointer); } +template +inline void destroy(_ForwardIterator __first, _ForwardIterator __last) { _STLP_STD::_Destroy_Range(__first, __last); } +#endif /* _STLP_NO_ANACHRONISMS */ + +_STLP_END_NAMESPACE + +#endif /* _STLP_INTERNAL_CONSTRUCT_H */ + +// Local Variables: +// mode:C++ +// End: -- cgit v1.1