1 /*
2 *
3 * Copyright (c) 1994
4 * Hewlett-Packard Company
5 *
6 * Copyright (c) 1996,1997
7 * Silicon Graphics Computer Systems, Inc.
8 *
9 * Copyright (c) 1997
10 * Moscow Center for SPARC Technology
11 *
12 * Copyright (c) 1999
13 * Boris Fomitchev
14 *
15 * This material is provided "as is", with absolutely no warranty expressed
16 * or implied. Any use is at your own risk.
17 *
18 * Permission to use or copy this software for any purpose is hereby granted
19 * without fee, provided the above notices are retained on all copies.
20 * Permission to modify the code and to distribute modified code is granted,
21 * provided the above notices are retained, and a notice that the code was
22 * modified is included with the above copyright notice.
23 *
24 */
25
26 /* NOTE: This is an internal header file, included by other STL headers.
27 * You should not attempt to use it directly.
28 */
29
30 #ifndef _STLP_INTERNAL_CONSTRUCT_H
31 #define _STLP_INTERNAL_CONSTRUCT_H
32
33 #if !defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_INTERNAL_CSTRING)
34 # include <stl/_cstring.h>
35 #endif
36
37 #ifndef _STLP_INTERNAL_NEW
38 # include <stl/_new.h>
39 #endif
40
41 #ifndef _STLP_INTERNAL_ITERATOR_BASE_H
42 # include <stl/_iterator_base.h>
43 #endif
44
45 #ifndef _STLP_TYPE_TRAITS_H
46 # include <stl/type_traits.h>
47 #endif
48
49 #if !defined (_STLP_MOVE_CONSTRUCT_FWK_H) && !defined (_STLP_NO_MOVE_SEMANTIC)
50 # include <stl/_move_construct_fwk.h>
51 #endif
52
53 _STLP_BEGIN_NAMESPACE
54
55 template <class _Tp>
__destroy_aux(_Tp * __pointer,const __false_type &)56 inline void __destroy_aux(_Tp* __pointer, const __false_type& /*_Trivial_destructor*/)
57 { __pointer->~_Tp(); }
58
59 template <class _Tp>
__destroy_aux(_Tp *,const __true_type &)60 inline void __destroy_aux(_Tp*, const __true_type& /*_Trivial_destructor*/) {}
61
62 template <class _Tp>
_Destroy(_Tp * __pointer)63 inline void _Destroy(_Tp* __pointer) {
64 typedef typename __type_traits<_Tp>::has_trivial_destructor _Trivial_destructor;
65 __destroy_aux(__pointer, _Trivial_destructor());
66 #if defined (_STLP_DEBUG_UNINITIALIZED)
67 memset(__REINTERPRET_CAST(char*, __pointer), _STLP_SHRED_BYTE, sizeof(_Tp));
68 #endif
69 }
70
71 template <class _Tp>
_Destroy_Moved(_Tp * __pointer)72 inline void _Destroy_Moved(_Tp* __pointer) {
73 #if !defined (_STLP_NO_MOVE_SEMANTIC)
74 typedef typename __move_traits<_Tp>::complete _Trivial_destructor;
75 __destroy_aux(__pointer, _Trivial_destructor());
76 # if defined (_STLP_DEBUG_UNINITIALIZED)
77 memset((char*)__pointer, _STLP_SHRED_BYTE, sizeof(_Tp));
78 # endif
79 #else
80 _Destroy(__pointer);
81 #endif
82 }
83
84 #if defined (new)
85 # define _STLP_NEW_REDEFINE new
86 # undef new
87 #endif
88
89 template <class _T1>
_Construct_aux(_T1 * __p,const __false_type &)90 inline void _Construct_aux (_T1* __p, const __false_type&) {
91 new(__p) _T1();
92 }
93
94 template <class _T1>
_Construct_aux(_T1 * __p,const __true_type &)95 inline void _Construct_aux (_T1* __p, const __true_type&) {
96 #if defined (_STLP_DEF_CONST_PLCT_NEW_BUG)
97 *__p = _T1(0);
98 #else
99 // We use binary copying for POD types since it results
100 // in a considerably better code at least on MSVC.
101 *__p = _T1();
102 #endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */
103 }
104
105 template <class _T1>
_Construct(_T1 * __p)106 inline void _Construct(_T1* __p) {
107 #if defined (_STLP_DEBUG_UNINITIALIZED)
108 memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1));
109 #endif
110 #if defined (_STLP_DEF_CONST_PLCT_NEW_BUG)
111 _Construct_aux (__p, _HasDefaultZeroValue(__p)._Answer());
112 #else
113 _Construct_aux (__p, _Is_POD(__p)._Answer());
114 #endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */
115 }
116
117 template <class _Tp>
_Copy_Construct_aux(_Tp * __p,const _Tp & __val,const __false_type &)118 __attribute__((always_inline)) inline void _Copy_Construct_aux(_Tp* __p, const _Tp& __val, const __false_type&) {
119 new(__p) _Tp(__val);
120 }
121
122 template <class _Tp>
_Copy_Construct_aux(_Tp * __p,const _Tp & __val,const __true_type &)123 __attribute__((always_inline)) inline void _Copy_Construct_aux(_Tp* __p, const _Tp& __val, const __true_type&) {
124 // We use binary copying for POD types since it results
125 // in a considerably better code at least on MSVC.
126 *__p = __val;
127 }
128
129 template <class _Tp>
_Copy_Construct(_Tp * __p,const _Tp & __val)130 __attribute__((always_inline)) inline void _Copy_Construct(_Tp* __p, const _Tp& __val) {
131 #if defined (_STLP_DEBUG_UNINITIALIZED)
132 memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_Tp));
133 #endif
134 _Copy_Construct_aux(__p, __val, _Is_POD(__p)._Answer());
135 }
136
137 template <class _T1, class _T2>
_Param_Construct_aux(_T1 * __p,const _T2 & __val,const __false_type &)138 __attribute__((always_inline)) inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __false_type&) {
139 new(__p) _T1(__val);
140 }
141
142 template <class _T1, class _T2>
_Param_Construct_aux(_T1 * __p,const _T2 & __val,const __true_type &)143 __attribute__((always_inline)) inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __true_type&) {
144 // We use binary copying for POD types since it results
145 // in a considerably better code at least on MSVC.
146 *__p = _T1(__val);
147 }
148
149 template <class _T1, class _T2>
_Param_Construct(_T1 * __p,const _T2 & __val)150 __attribute__((always_inline)) inline void _Param_Construct(_T1* __p, const _T2& __val) {
151 #if defined (_STLP_DEBUG_UNINITIALIZED)
152 memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1));
153 #endif
154 _Param_Construct_aux(__p, __val, _Is_POD(__p)._Answer());
155 }
156
157 template <class _T1, class _T2>
_Move_Construct_Aux(_T1 * __p,_T2 & __val,const __false_type &)158 __attribute__((always_inline)) inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __false_type& /*_IsPOD*/) {
159 #if !defined (_STLP_NO_MOVE_SEMANTIC)
160 new(__p) _T1(_STLP_PRIV _AsMoveSource(__val));
161 #else
162 _Param_Construct(__p, __val);
163 #endif
164 }
165
166 template <class _T1, class _T2>
_Move_Construct_Aux(_T1 * __p,_T2 & __val,const __true_type &)167 __attribute__((always_inline)) inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __true_type& /*_IsPOD*/) {
168 // We use binary copying for POD types since it results
169 // in a considerably better code at least on MSVC.
170 *__p = _T1(__val);
171 }
172
173 template <class _T1, class _T2>
_Move_Construct(_T1 * __p,_T2 & __val)174 __attribute__((always_inline)) inline void _Move_Construct(_T1* __p, _T2& __val) {
175 #if defined (_STLP_DEBUG_UNINITIALIZED)
176 memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1));
177 #endif
178 _Move_Construct_Aux(__p, __val, _Is_POD(__p)._Answer());
179 }
180
181 #if defined(_STLP_NEW_REDEFINE)
182 # if defined (DEBUG_NEW)
183 # define new DEBUG_NEW
184 # endif
185 # undef _STLP_NEW_REDEFINE
186 #endif
187
188 template <class _ForwardIterator, class _Tp>
189 _STLP_INLINE_LOOP void
__destroy_range_aux(_ForwardIterator __first,_ForwardIterator __last,_Tp *,const __false_type &)190 __destroy_range_aux(_ForwardIterator __first, _ForwardIterator __last, _Tp*, const __false_type& /*_Trivial_destructor*/) {
191 for ( ; __first != __last; ++__first) {
192 __destroy_aux(&(*__first), __false_type());
193 #if defined (_STLP_DEBUG_UNINITIALIZED)
194 memset((char*)&(*__first), _STLP_SHRED_BYTE, sizeof(_Tp));
195 #endif
196 }
197 }
198
199 template <class _ForwardIterator, class _Tp>
200 #if defined (_STLP_DEBUG_UNINITIALIZED)
201 _STLP_INLINE_LOOP void
__destroy_range_aux(_ForwardIterator __first,_ForwardIterator __last,_Tp *,const __true_type &)202 __destroy_range_aux(_ForwardIterator __first, _ForwardIterator __last, _Tp*, const __true_type& /*_Trivial_destructor*/) {
203 for ( ; __first != __last; ++__first)
204 memset((char*)&(*__first), _STLP_SHRED_BYTE, sizeof(_Tp));
205 }
206 #else
207 inline void
208 __destroy_range_aux(_ForwardIterator, _ForwardIterator, _Tp*, const __true_type& /*_Trivial_destructor*/) {}
209 #endif
210
211 template <class _ForwardIterator, class _Tp>
212 inline void
__destroy_range(_ForwardIterator __first,_ForwardIterator __last,_Tp * __ptr)213 __destroy_range(_ForwardIterator __first, _ForwardIterator __last, _Tp *__ptr) {
214 typedef typename __type_traits<_Tp>::has_trivial_destructor _Trivial_destructor;
215 __destroy_range_aux(__first, __last, __ptr, _Trivial_destructor());
216 }
217
218 template <class _ForwardIterator>
_Destroy_Range(_ForwardIterator __first,_ForwardIterator __last)219 inline void _Destroy_Range(_ForwardIterator __first, _ForwardIterator __last) {
220 __destroy_range(__first, __last, _STLP_VALUE_TYPE(__first, _ForwardIterator));
221 }
222
_Destroy_Range(char *,char *)223 inline void _Destroy_Range(char*, char*) {}
224 #if defined (_STLP_HAS_WCHAR_T) // dwa 8/15/97
_Destroy_Range(wchar_t *,wchar_t *)225 inline void _Destroy_Range(wchar_t*, wchar_t*) {}
_Destroy_Range(const wchar_t *,const wchar_t *)226 inline void _Destroy_Range(const wchar_t*, const wchar_t*) {}
227 #endif
228
229 #if !defined (_STLP_NO_MOVE_SEMANTIC)
230 template <class _ForwardIterator, class _Tp>
231 inline void
__destroy_mv_srcs(_ForwardIterator __first,_ForwardIterator __last,_Tp * __ptr)232 __destroy_mv_srcs(_ForwardIterator __first, _ForwardIterator __last, _Tp *__ptr) {
233 typedef typename __move_traits<_Tp>::complete _CompleteMove;
234 __destroy_range_aux(__first, __last, __ptr, _CompleteMove());
235 }
236 #endif
237
238 template <class _ForwardIterator>
_Destroy_Moved_Range(_ForwardIterator __first,_ForwardIterator __last)239 inline void _Destroy_Moved_Range(_ForwardIterator __first, _ForwardIterator __last)
240 #if !defined (_STLP_NO_MOVE_SEMANTIC)
241 { __destroy_mv_srcs(__first, __last, _STLP_VALUE_TYPE(__first, _ForwardIterator)); }
242 #else
243 { _Destroy_Range(__first, __last); }
244 #endif
245
246 #if defined (_STLP_DEF_CONST_DEF_PARAM_BUG)
247 // Those adaptors are here to fix common compiler bug regarding builtins:
248 // expressions like int k = int() should initialize k to 0
249 template <class _Tp>
__default_constructed_aux(_Tp *,const __false_type &)250 inline _Tp __default_constructed_aux(_Tp*, const __false_type&) {
251 return _Tp();
252 }
253 template <class _Tp>
__default_constructed_aux(_Tp *,const __true_type &)254 inline _Tp __default_constructed_aux(_Tp*, const __true_type&) {
255 return _Tp(0);
256 }
257
258 template <class _Tp>
__default_constructed(_Tp * __p)259 inline _Tp __default_constructed(_Tp* __p) {
260 return __default_constructed_aux(__p, _HasDefaultZeroValue(__p)._Answer());
261 }
262
263 # define _STLP_DEFAULT_CONSTRUCTED(_TTp) __default_constructed((_TTp*)0)
264 #else
265 # define _STLP_DEFAULT_CONSTRUCTED(_TTp) _TTp()
266 #endif /* _STLP_DEF_CONST_DEF_PARAM_BUG */
267
268
269 #if !defined (_STLP_NO_ANACHRONISMS)
270 // --------------------------------------------------
271 // Old names from the HP STL.
272
273 template <class _T1, class _T2>
construct(_T1 * __p,const _T2 & __val)274 inline void construct(_T1* __p, const _T2& __val) {_Param_Construct(__p, __val); }
275 template <class _T1>
construct(_T1 * __p)276 inline void construct(_T1* __p) { _STLP_STD::_Construct(__p); }
277 template <class _Tp>
destroy(_Tp * __pointer)278 inline void destroy(_Tp* __pointer) { _STLP_STD::_Destroy(__pointer); }
279 template <class _ForwardIterator>
destroy(_ForwardIterator __first,_ForwardIterator __last)280 inline void destroy(_ForwardIterator __first, _ForwardIterator __last) { _STLP_STD::_Destroy_Range(__first, __last); }
281 #endif /* _STLP_NO_ANACHRONISMS */
282
283 _STLP_END_NAMESPACE
284
285 #endif /* _STLP_INTERNAL_CONSTRUCT_H */
286
287 // Local Variables:
288 // mode:C++
289 // End:
290