1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
|
/*
*
* 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 <stl/_cstring.h>
#endif
#ifndef _STLP_INTERNAL_NEW
# include <stl/_new.h>
#endif
#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
# include <stl/_iterator_base.h>
#endif
#ifndef _STLP_TYPE_TRAITS_H
# include <stl/type_traits.h>
#endif
#if !defined (_STLP_MOVE_CONSTRUCT_FWK_H) && !defined (_STLP_NO_MOVE_SEMANTIC)
# include <stl/_move_construct_fwk.h>
#endif
_STLP_BEGIN_NAMESPACE
template <class _Tp>
inline void __destroy_aux(_Tp* __pointer, const __false_type& /*_Trivial_destructor*/)
{ __pointer->~_Tp(); }
template <class _Tp>
inline void __destroy_aux(_Tp*, const __true_type& /*_Trivial_destructor*/) {}
template <class _Tp>
inline void _Destroy(_Tp* __pointer) {
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 <class _Tp>
inline void _Destroy_Moved(_Tp* __pointer) {
#if !defined (_STLP_NO_MOVE_SEMANTIC)
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
#else
_Destroy(__pointer);
#endif
}
#if defined (new)
# define _STLP_NEW_REDEFINE new
# undef new
#endif
template <class _T1>
inline void _Construct_aux (_T1* __p, const __false_type&) {
new(__p) _T1();
}
template <class _T1>
inline void _Construct_aux (_T1* __p, const __true_type&) {
#if defined (_STLP_DEF_CONST_PLCT_NEW_BUG)
*__p = _T1(0);
#else
// We use binary copying for POD types since it results
// in a considerably better code at least on MSVC.
*__p = _T1();
#endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */
}
template <class _T1>
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
_Construct_aux (__p, _Is_POD(__p)._Answer());
#endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */
}
template <class _Tp>
inline void _Copy_Construct_aux(_Tp* __p, const _Tp& __val, const __false_type&) {
new(__p) _Tp(__val);
}
template <class _Tp>
inline void _Copy_Construct_aux(_Tp* __p, const _Tp& __val, const __true_type&) {
// We use binary copying for POD types since it results
// in a considerably better code at least on MSVC.
*__p = __val;
}
template <class _Tp>
inline void _Copy_Construct(_Tp* __p, const _Tp& __val) {
#if defined (_STLP_DEBUG_UNINITIALIZED)
memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_Tp));
#endif
_Copy_Construct_aux(__p, __val, _Is_POD(__p)._Answer());
}
template <class _T1, class _T2>
inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __false_type&) {
new(__p) _T1(__val);
}
template <class _T1, class _T2>
inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __true_type&) {
// We use binary copying for POD types since it results
// in a considerably better code at least on MSVC.
*__p = _T1(__val);
}
template <class _T1, class _T2>
inline void _Param_Construct(_T1* __p, const _T2& __val) {
#if defined (_STLP_DEBUG_UNINITIALIZED)
memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1));
#endif
_Param_Construct_aux(__p, __val, _Is_POD(__p)._Answer());
}
template <class _T1, class _T2>
inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __false_type& /*_IsPOD*/) {
#if !defined (_STLP_NO_MOVE_SEMANTIC)
new(__p) _T1(_STLP_PRIV _AsMoveSource(__val));
#else
_Param_Construct(__p, __val);
#endif
}
template <class _T1, class _T2>
inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __true_type& /*_IsPOD*/) {
// We use binary copying for POD types since it results
// in a considerably better code at least on MSVC.
*__p = _T1(__val);
}
template <class _T1, class _T2>
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 <class _ForwardIterator, class _Tp>
_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 <class _ForwardIterator, class _Tp>
#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 <class _ForwardIterator, class _Tp>
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 <class _ForwardIterator>
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
#if !defined (_STLP_NO_MOVE_SEMANTIC)
template <class _ForwardIterator, class _Tp>
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());
}
#endif
template <class _ForwardIterator>
inline void _Destroy_Moved_Range(_ForwardIterator __first, _ForwardIterator __last)
#if !defined (_STLP_NO_MOVE_SEMANTIC)
{ __destroy_mv_srcs(__first, __last, _STLP_VALUE_TYPE(__first, _ForwardIterator)); }
#else
{ _Destroy_Range(__first, __last); }
#endif
#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 <class _Tp>
inline _Tp __default_constructed_aux(_Tp*, const __false_type&) {
return _Tp();
}
template <class _Tp>
inline _Tp __default_constructed_aux(_Tp*, const __true_type&) {
return _Tp(0);
}
template <class _Tp>
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 <class _T1, class _T2>
inline void construct(_T1* __p, const _T2& __val) {_Param_Construct(__p, __val); }
template <class _T1>
inline void construct(_T1* __p) { _STLP_STD::_Construct(__p); }
template <class _Tp>
inline void destroy(_Tp* __pointer) { _STLP_STD::_Destroy(__pointer); }
template <class _ForwardIterator>
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:
|
