diff options
Diffstat (limited to 'binary/solaris/test/patches/cc-12u2')
| -rw-r--r-- | binary/solaris/test/patches/cc-12u2/memory | 896 |
1 files changed, 896 insertions, 0 deletions
diff --git a/binary/solaris/test/patches/cc-12u2/memory b/binary/solaris/test/patches/cc-12u2/memory new file mode 100644 index 0000000..065bb8a --- /dev/null +++ b/binary/solaris/test/patches/cc-12u2/memory @@ -0,0 +1,896 @@ +// -*- C++ -*- +#ifndef __STD_MEMORY +#define __STD_MEMORY + +// Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. +/*************************************************************************** + * + * memory - declarations for the Standard Library memory implementation + * + *************************************************************************** + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + *************************************************************************** + * + * Copyright (c) 1994-1999 Rogue Wave Software, Inc. All Rights Reserved. + * + * This computer software is owned by Rogue Wave Software, Inc. and is + * protected by U.S. copyright laws and other laws and by international + * treaties. This computer software is furnished by Rogue Wave Software, + * Inc. pursuant to a written license agreement and may be used, copied, + * transmitted, and stored only in accordance with the terms of such + * license and with the inclusion of the above copyright notice. This + * computer software or any other copies thereof may not be provided or + * otherwise made available to any other person. + * + * U.S. Government Restricted Rights. This computer software is provided + * with Restricted Rights. Use, duplication, or disclosure by the + * Government is subject to restrictions as set forth in subparagraph (c) + * (1) (ii) of The Rights in Technical Data and Computer Software clause + * at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the + * Commercial Computer Software – Restricted Rights at 48 CFR 52.227-19, + * as applicable. Manufacturer is Rogue Wave Software, Inc., 5500 + * Flatiron Parkway, Boulder, Colorado 80301 USA. + * + **************************************************************************/ + +#include <stdcomp.h> + +#ifndef _RWSTD_NO_NEW_HEADER +#include <cstddef> +#include <cstdlib> +#include <climits> +#else +#include <stddef.h> +#include <stdlib.h> +#include <limits.h> + +#endif //_RWSTD_NO_NEW_HEADER + +#include <new> +#include <rw/iterator> +#include <utility> +#include <rw/rwstderr.h> +#include <rw/stdmutex.h> + + +// +// Turn off the warnings under the MSVC compiler that +// say 'bool reserved for future use' and turn off warnings +// that say 'debug information truncated to 256 characters' +// +#ifdef _RWSTD_MSVC_BOOL_WARNING +#pragma warning ( disable : 4237 ) +#endif + +#ifdef _RWSTD_NO_NEW_DECL +extern void _RWSTDExportFunc(*) operator new(size_t size, void* ptr); +#endif + +#ifdef _RWSTD_NO_NEW_HEADER +#include <exception> +#endif + +#pragma disable_warn + +#ifndef _RWSTD_NO_NAMESPACE +namespace __rwstd { +#endif + +// +// Template used for empty base optimization +// + template <class _Tt , class _Base> + class __rw_basis : public _Base + { + _Tt __data_; + public: + __rw_basis(const __rw_basis& b) : _Base(b), __data_(b.__data_) {;} + __rw_basis(const _Tt& t, const _Base& b) : _Base(b), __data_(t) {;} + __rw_basis(int t, const _Base& b) : _Base(b), __data_((_Tt)t) {;} // TEMP + __rw_basis operator=(const _Tt& t) { __data_ = t; return *this; } + __rw_basis operator=(int t) { __data_ = (_Tt)t; return *this; } // TEMP + __rw_basis operator=(const __rw_basis& r) + { __data_ = r.__data_; return *this; } + __rw_basis operator=(const _Base& b) + { *this = __rw_basis<_Tt,_Base>(__data_,b); return *this; } + operator _Tt() { return __data_; } + _Tt data() const { return __data_; } + }; + +// Default buffer size for containers. +#ifndef _RWSTD_CONTAINER_BUFFER_SIZE +#define _RWSTD_CONTAINER_BUFFER_SIZE 64 +#endif + +#ifndef _RWSTD_VECTOR_CONST_ENLARGE + // This function returns a suggested new capacity for a container needing + // more room; see stddefs.h for an explanation of these macro parameters. + // Return new buffer size in bytes. + // Third parameter not used. + template <class _Tt, class _Size> + inline _Size __rw_allocation_size(_Tt*,_Size cursize, _Size) + { + _Size cap = _RWSTD_STATIC_CAST(_Size, cursize * _RWSTD_NEW_CAPACITY_RATIO); + _Size sz = (cursize += _RWSTD_MINIMUM_NEW_CAPACITY) > cap ? cursize : cap; + return sz; + } +#else + // Increment the buffer size by a set amount + // indicated by __delta (if __delta is 0 then + // get delta size from _RWSTD_CONTAINER_BUFFER_SIZE + // if __n is zero then get initial buffer size from + // _RWSTD_CONTAINER_BUFFER_SIZE. Only vector calls + // this function with a non-zero value for cursize. + // Return new buffer size in bytes. + template <class _Tt, class _size> + inline _size __rw_allocation_size(_Tt*,_size __n, _size __delta) + { + if (__n) + return __n + (__delta ? + __delta : _RWSTD_CONTAINER_BUFFER_SIZE/sizeof(_Tt)); + else + return (_RWSTD_CONTAINER_BUFFER_SIZE>sizeof(_Tt)) ? + (_RWSTD_CONTAINER_BUFFER_SIZE/sizeof(_Tt)) : 1; + } +#endif // _RWSTD_CONTAINER_CONST_ENLARGE + + + +#if defined(_RWSTD_NO_DESTROY_NONBUILTIN) + template <class _Tt> struct __FS : public _T + { + __FS() { ; } + // + // Calls destructor, but does not free the space. + // + void operator delete (void*) {;} + }; +#endif // _RWSTD_NO_DESTROY_NONBUILTIN + + + template <class _Tt> + inline void __destroy (_Tt* pointer) + { +#if defined(_RWSTD_NO_DESTROY_NONBUILTIN) + delete (__FS<_Tt>*) (pointer); +#else +#if defined(_RWSTD_EXPLICIT_SCOPE_DESTROY) + pointer->_Tt::~_Tt(); +#else + pointer->~_Tt(); +#endif // _RWSTD_EXPLICIT_SCOPE_DESTROY +#endif // _RWSTD_NO_DESTROY_NONBUILTIN + } + + + template <class _T1, class _T2> + inline void __construct (_T1* p, const _T2& value) + { + ::new (p) _T1(value); + } + + template <class _ForwardIterator> + _RWSTD_TRICKY_INLINE void __destroy (_ForwardIterator first, _ForwardIterator last) + { + for ( ; first != last; ++first) + __destroy(&*first); + } + + +#if defined(_RWSTD_NO_DESTROY_BUILTIN) || defined(_RWSTD_NO_DESTROY_NONBUILTIN) +// +// Some specializations of STL destroy for builtin types.f +// + inline void __destroy (void*) {;} + inline void __destroy (char*) {;} + inline void __destroy (unsigned char*) {;} + inline void __destroy (short*) {;} + inline void __destroy (unsigned short*) {;} + inline void __destroy (int*) {;} + inline void __destroy (unsigned int*) {;} + inline void __destroy (long*) {;} + inline void __destroy (unsigned long*) {;} + inline void __destroy (float*) {;} + inline void __destroy (double*) {;} + inline void __destroy (void**) {;} + inline void __destroy (char**) {;} + inline void __destroy (unsigned char**) {;} + inline void __destroy (short**) {;} + inline void __destroy (unsigned short**) {;} + inline void __destroy (int**) {;} + inline void __destroy (unsigned int**) {;} + inline void __destroy (long**) {;} + inline void __destroy (unsigned long**) {;} + inline void __destroy (float**) {;} + inline void __destroy (double**) {;} + inline void __destroy (void***) {;} + inline void __destroy (char***) {;} + inline void __destroy (unsigned char***) {;} + inline void __destroy (short***) {;} + inline void __destroy (unsigned short***) {;} + inline void __destroy (int***) {;} + inline void __destroy (unsigned int***) {;} + inline void __destroy (long***) {;} + inline void __destroy (unsigned long***) {;} + inline void __destroy (float***) {;} + inline void __destroy (double***) {;} +#ifndef _RWSTD_NO_BOOL + inline void __destroy (bool*) {;} + inline void __destroy (bool**) {;} + inline void __destroy (bool***) {;} +#endif +#ifndef _RWSTD_NO_LONGDOUBLE + inline void __destroy (long double*) {;} + inline void __destroy (long double**) {;} + inline void __destroy (long double***) {;} +#endif +#ifndef _RWSTD_NO_OVERLOAD_WCHAR + inline void __destroy (wchar_t*) {;} + inline void __destroy (wchar_t**) {;} + inline void __destroy (wchar_t***) {;} +#endif +#endif /*_RWSTD_NO_DESTROY_BUILTIN || _RWSTD_NO_DESTROY_NONBUILTIN*/ + +#ifdef _RWSTD_LOCALIZED_ERRORS + extern const unsigned int _RWSTDExport rwse_OutOfRange; +#else + extern const char _RWSTDExportFunc(*) rwse_OutOfRange; +#endif // _RWSTD_LOCALIZED_ERRORS + +#ifndef _RWSTD_NO_NAMESPACE +} // __rwstd namespace + +namespace std { +#endif + +// +// The default allocator. +// + + +#ifdef _RWSTD_ALLOCATOR + + template <class _Tt> class allocator; + +// +// void specialization of allocator +// + _RWSTD_TEMPLATE + class allocator<void> { + public: + typedef void* pointer; + typedef const void* const_pointer; + typedef void value_type; + + template <class _U2> + struct rebind { typedef allocator<_U2> other; }; + + }; + + + template <class _Tt> + class allocator + { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tt* pointer; + typedef const _Tt* const_pointer; + typedef _Tt& reference; + typedef const _Tt& const_reference; + typedef _Tt value_type; + + template <class _U2> struct rebind + { typedef allocator<_U2> other; }; + + allocator() _RWSTD_THROW_SPEC_NULL + { ; } + + allocator(const allocator&) _RWSTD_THROW_SPEC_NULL + { ; } + + template <class _U2> + allocator(const allocator<_U2>&) _RWSTD_THROW_SPEC_NULL + { ; } + + template <class _U2> + allocator<_Tt>& operator=(const allocator<_U2>& a) _RWSTD_THROW_SPEC_NULL + { return *this; } + + pointer address(reference x) const + { + return _RWSTD_STATIC_CAST(pointer,&x); + } + const_pointer address(const_reference x) const + { + return _RWSTD_STATIC_CAST(const_pointer,&x); + } + pointer allocate(size_type n, allocator<void>::const_pointer = 0) + { + pointer tmp = + _RWSTD_STATIC_CAST(pointer,(::operator + new(_RWSTD_STATIC_CAST(size_t,(n * sizeof(value_type)))))); + _RWSTD_THROW_NO_MSG(tmp == 0, bad_alloc); + return tmp; + } + + void deallocate(pointer p, size_type) + { + ::operator delete(p); + } + size_type max_size() const _RWSTD_THROW_SPEC_NULL + { + return 1 > UINT_MAX/sizeof(_Tt) ? size_type(1) : size_type(UINT_MAX/sizeof(_Tt)); + } + inline void construct(pointer p, const _Tt& val); + + inline void destroy(_Tt* p); + + }; + + + + template <class _Tt> + void allocator<_Tt>::construct(pointer p, const _Tt& val) + { + __RWSTD::__construct(p,val); + } + + template <class _Tt> + void allocator<_Tt>::destroy(_Tt* p) + { + __RWSTD::__destroy(p); + } + +#else + +// +// Alternate allocator uses an interface class (allocator_interface) +// to get type safety. +// + template <class _Tt> + class allocator + { + public: + + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tt* pointer; + typedef const _Tt* const_pointer; + typedef _Tt& reference; + typedef const _Tt& const_reference; + typedef _Tt value_type; + + allocator() _RWSTD_THROW_SPEC_NULL { ; } + allocator(const allocator<_Tt>&) _RWSTD_THROW_SPEC_NULL + { ; } + allocator<_Tt>& operator=(const allocator<_Tt>&) _RWSTD_THROW_SPEC_NULL + { return *this; } + + void * allocate (size_type n, void * = 0) + { + void * tmp = _RWSTD_STATIC_CAST(void*,(::operator new(_RWSTD_STATIC_CAST(size_t,(n))))); + _RWSTD_THROW_NO_MSG(tmp == 0, bad_alloc); + return tmp; + } + + void deallocate (void* p, size_type) + { + ::operator delete(p); + } + size_type max_size (size_type size) const + { + return 1 > UINT_MAX/size ? size_type(1) : size_type(UINT_MAX/size); + } + }; + + _RWSTD_TEMPLATE + class allocator<void> + { + public: + + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef void* pointer; + typedef const void* const_pointer; + typedef void value_type; + + allocator() _RWSTD_THROW_SPEC_NULL { ; } + allocator(const allocator<void>&) _RWSTD_THROW_SPEC_NULL + { ; } + allocator<void>& operator=(const allocator<void>&) _RWSTD_THROW_SPEC_NULL + { return *this; } + + void * allocate (size_type n, void * = 0) + { + void * tmp = _RWSTD_STATIC_CAST(void*,(::operator new(_RWSTD_STATIC_CAST(size_t,(n))))); + _RWSTD_THROW_NO_MSG(tmp == 0, bad_alloc); + return tmp; + } + + void deallocate (void* p, size_type) + { + ::operator delete(p); + } + size_type max_size (size_type size) const + { + return 1 > UINT_MAX/size ? size_type(1) : size_type(UINT_MAX/size); + } + }; + +// +// allocator_interface provides all types and typed functions. Memory +// allocated as raw bytes using the class provided by the Allocator +// template parameter. allocator_interface casts appropriately. +// +// Multiple allocator_interface objects can attach to a single +// allocator, thus allowing one allocator to allocate all storage +// for a container, regardless of how many types are involved. +// +// The only real restriction is that pointer and reference are +// hard coded as _Tt* and _Tt&. Partial specialization would +// get around this. +// + template <class _Allocator,class _Tt> + class allocator_interface + { + public: + typedef _Allocator allocator_type; + typedef _Tt* pointer; + typedef const _Tt* const_pointer; + typedef _Tt& reference; + typedef const _Tt& const_reference; + typedef _Tt value_type; + typedef _TYPENAME _RWSTD_ALLOC_SIZE_TYPE size_type; + typedef _TYPENAME _RWSTD_ALLOC_DIFF_TYPE difference_type; + typedef void* void_pointer; + typedef const void* const_void_pointer; + + + + protected: + allocator_type alloc_; + + public: + allocator_interface() _RWSTD_THROW_SPEC_NULL { ; } + allocator_interface(const _Allocator& a) _RWSTD_THROW_SPEC_NULL + : alloc_(a) { ; } + + pointer address (_Tt& x) + { + return _RWSTD_STATIC_CAST(pointer,&x); + } + + size_type max_size () const + { + return alloc_.max_size(sizeof(_Tt)); + } + + pointer allocate(size_type n, pointer p = 0) + { + return _RWSTD_STATIC_CAST(pointer,alloc_.allocate(n*sizeof(_Tt),p)); + } + + void deallocate(pointer p, size_type n) + { + if ( p != 0 ) + alloc_.deallocate(p,n*sizeof(_Tt)); + } + + inline void construct(pointer p, const _Tt& val); + + inline void destroy(_Tt* p); + + }; + + + template <class _Allocator, class _Tt> + inline void + allocator_interface<_Allocator,_Tt>::construct(pointer p, const _Tt& val) + { + __RWSTD::__construct(p,val); + } + + template <class _Allocator, class _Tt> + inline void allocator_interface<_Allocator,_Tt>::destroy(_Tt* p) + { + __RWSTD::__destroy(p); + } + + _RWSTD_TEMPLATE + class allocator_interface<allocator<void>,void> + { + public: + typedef allocator<void> allocator_type; + typedef void* pointer; + typedef const void* const_pointer; + typedef void value_type; + typedef allocator<void>::size_type size_type; + typedef allocator<void>::difference_type difference_type; + + protected: + allocator_type alloc_; + + public: + allocator_interface() _RWSTD_THROW_SPEC_NULL { ; } + allocator_interface(const allocator<void>& a) _RWSTD_THROW_SPEC_NULL + : alloc_(a) { ; } + + size_type max_size () const + { + return alloc_.max_size(1); + } + + pointer allocate(size_type n, pointer = 0) + { + return _RWSTD_STATIC_CAST(pointer,alloc_.allocate(n)); + } + + void deallocate(pointer p, size_type n) + { + alloc_.deallocate(p,n); + } + }; + +#endif // _RWSTD_ALLOCATOR + +// +// Allocator globals +// + template <class _Tt, class _U2> + inline bool operator==(const allocator<_Tt>&, const allocator<_U2>&) _RWSTD_THROW_SPEC_NULL + { + return true; + } + +#ifndef _RWSTD_NO_NAMESPACE + template <class _Tt, class _U2> + inline bool operator!=(const allocator<_Tt>&, const allocator<_U2>&) _RWSTD_THROW_SPEC_NULL + { + return false; + } +#endif + +// +// Raw storage iterator. +// + + template <class _OutputIterator, class _Tt> + class raw_storage_iterator + : public iterator<output_iterator_tag,_Tt,ptrdiff_t,_Tt*,_Tt&> + { + protected: + _OutputIterator iter; + + public: + typedef _OutputIterator iterator_type; + typedef _Tt element_type; + + _EXPLICIT raw_storage_iterator (_OutputIterator x) : iter(x) {} + raw_storage_iterator<_OutputIterator, _Tt>& operator* () { return *this; } + raw_storage_iterator<_OutputIterator, _Tt>& operator= (const _Tt& element) + { + ::new(&(*iter)) _Tt(element); + return *this; + } + raw_storage_iterator<_OutputIterator, _Tt>& operator++ () + { + ++iter; return *this; + } + raw_storage_iterator<_OutputIterator, _Tt> operator++ (int) + { + raw_storage_iterator<_OutputIterator, _Tt> tmp = *this; + ++iter; + return tmp; + } + }; + + +// +// Temporary buffers +// + +#ifdef _RWSTD_FAST_TEMP_BUF + +#if defined(_RWSTD_SHARED_LIB) && !defined (_RWSTD_MULTI_THREAD) +#error Cannot use fast temporary buffer in this configuration +#endif +#if defined(_RWSTDDLL) && defined (__WIN16__) +#error Cannot use fast temporary buffer in this configuration +#endif + +#ifndef __stl_buffer_size +#define __stl_buffer_size 16384 /* 16k */ +#endif + +#ifndef _RWSTD_NO_NAMESPACE +} + +namespace __rwstd { +#endif + + extern char _RWSTDExport stl_temp_buffer[__stl_buffer_size]; + +#ifdef _RWSTD_MULTI_THREAD + extern _RWSTDMutex _RWSTDExport stl_temp_buffer_mutex; + extern bool _RWSTDExport stl_temp_buffer_being_used; +#endif + +#ifndef _RWSTD_NO_NAMESPACE +} // End of __rwstd namespace + +namespace std { +#endif + + template <class _Tt> +#ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE + inline pair<_Tt*, ptrdiff_t> get_temporary_buffer (ptrdiff_t len) +#else + inline pair<_Tt*, ptrdiff_t> get_temporary_buffer (ptrdiff_t len, _Tt*) +#endif + { + while (len > __stl_buffer_size / sizeof(_Tt)) + { + _Tt* tmp = _RWSTD_STATIC_CAST(_Tt*,( ::operator new(_RWSTD_STATIC_CAST(unsigned int,len) * sizeof(_Tt)))); + if (tmp) + { + pair<_Tt*, ptrdiff_t> result(tmp, len); + return result; + } + len = len / 2; + } + +#ifdef _RWSTD_MULTI_THREAD + _RWSTDGuard guard(__RWSTD::stl_temp_buffer_mutex); + + if (__RWSTD::stl_temp_buffer_being_used) + { + _Tt* tmp = _RWSTD_STATIC_CAST(_Tt*,( ::operator new(_RWSTD_STATIC_CAST(unsigned int,len) * sizeof(_Tt)))); + pair<_Tt*,ptrdiff_t> result(tmp, len); + return result; + } + else + { + __RWSTD::stl_temp_buffer_being_used = true; + pair<_Tt*, ptrdiff_t> result(_RWSTD_STATIC_CAST(_Tt*, + _RWSTD_STATIC_CAST(void*,__RWSTD::stl_temp_buffer)), + _RWSTD_STATIC_CAST(ptrdiff_t,(__stl_buffer_size / sizeof(_Tt)))); + return result; + } +#else + pair<_Tt*, ptrdiff_t> result(_RWSTD_STATIC_CAST(_Tt*, + _RWSTD_STATIC_CAST(void*,__RWSTD::stl_temp_buffer)), + _RWSTD_STATIC_CAST(ptrdiff_t,(__stl_buffer_size / sizeof(_Tt)))); + return result; +#endif /*_RWSTD_MULTI_THREAD*/ + } + + template <class _Tt> + inline void return_temporary_buffer (_Tt* p) + { +#ifdef _RWSTD_MULTI_THREAD + _RWSTDGuard guard(__RWSTD::stl_temp_buffer_mutex); + + if (_RWSTD_STATIC_CAST(char*, + _RWSTD_STATIC_CAST(void*,p)) != __RWSTD::stl_temp_buffer) + ::operator delete(p); + else + __RWSTD::stl_temp_buffer_being_used = false; +#else + if (_RWSTD_STATIC_CAST(char*, + _RWSTD_STATIC_CAST(void*,p)) != __RWSTD::stl_temp_buffer) + ::operator delete(p); +#endif /*_RWSTD_MULTI_THREAD*/ + } + +#else + + template <class _Tt> +#ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE + inline pair<_Tt*, ptrdiff_t> get_temporary_buffer (ptrdiff_t len) +#else + inline pair<_Tt*, ptrdiff_t> get_temporary_buffer (ptrdiff_t len, _Tt*) +#endif + { + _Tt* tmp = _RWSTD_STATIC_CAST(_Tt*,( ::operator new(len * sizeof(_Tt)))); + pair<_Tt*,ptrdiff_t> result(tmp, len); + return result; + } + + template <class _Tt> + inline void return_temporary_buffer (_Tt* p) + { + ::operator delete(p); + } + +#endif /*_RWSTD_FAST_TEMP_BUF*/ + + +// +// Specialized algorithms. +// + + template <class _InputIterator, class _ForwardIterator> + _RWSTD_TRICKY_INLINE _ForwardIterator uninitialized_copy (_InputIterator first, _InputIterator last, + _ForwardIterator result) + { + _ForwardIterator start = result; +#ifndef _RWSTD_NO_EXCEPTIONS + try { + while (first != last) + __RWSTD::__construct(result++, *first++); + } catch(...) { + __RWSTD::__destroy(start,result); + throw; + } +#else + while (first != last) + __RWSTD::__construct(result++, *first++); +#endif // _RWSTD_NO_EXCEPTIONS + + return result; + } + + template <class _ForwardIterator, class _Tt> + _RWSTD_TRICKY_INLINE void uninitialized_fill (_ForwardIterator first, _ForwardIterator last, + const _Tt& x) + { + _ForwardIterator start = first; +#ifndef _RWSTD_NO_EXCEPTIONS + try { + while (first != last) + __RWSTD::__construct(first++, x); + } catch(...) { + __RWSTD::__destroy(start,first); + throw; + } +#else + while (first != last) + __RWSTD::__construct(first++, x); +#endif // _RWSTD_NO_EXCEPTIONS + } + + template <class _ForwardIterator, class _Size, class _Tt> + _RWSTD_TRICKY_INLINE void uninitialized_fill_n (_ForwardIterator first, _Size n, const _Tt& x) + { + _ForwardIterator start = first; +#ifndef _RWSTD_NO_EXCEPTIONS + try { + while (n--) + __RWSTD::__construct(first++, x); + } catch(...) { + __RWSTD::__destroy(start,first); + throw; + } +#else + while (n--) + __RWSTD::__construct(first++, x); +#endif // _RWSTD_NO_EXCEPTIONS + } + + +// +// Template auto_ptr holds onto a pointer obtained via new and deletes that +// object when it itself is destroyed (such as when leaving block scope). +// +// It can be used to make calls to new() exception safe. +// + +//#ifndef _RWSTD_NO_MEM_CLASS_TEMPLATES + template <class _YY> class auto_ptr_ref + { + _YY* p; + public: + auto_ptr_ref(_YY* a) : p(a) {} + _YY* release() { _YY* tmp = p; p = 0; return tmp; } + }; +//#endif + + template<class _XX> class auto_ptr + { + public: + typedef _XX element_type; + + // + // construct/copy/destroy + // + _EXPLICIT auto_ptr (_XX* p = 0) _RWSTD_THROW_SPEC_NULL + : the_p(p) + { ; } + + auto_ptr (auto_ptr<_XX>& a) _RWSTD_THROW_SPEC_NULL + : the_p((_RWSTD_CONST_CAST(auto_ptr<_XX>&,a)).release()) + { ; } + + auto_ptr<_XX>& operator= (auto_ptr<_XX>& rhs) _RWSTD_THROW_SPEC_NULL + { + reset(rhs.release()); + return *this; + } +//#ifndef _RWSTD_NO_MEMBER_TEMPLATES + template <class _YY> + auto_ptr (auto_ptr<_YY>& a) _RWSTD_THROW_SPEC_NULL + : the_p((_RWSTD_CONST_CAST(auto_ptr<_YY>&,a)).release()) + { ; } + + template <class _YY> + auto_ptr<_XX>& operator= (auto_ptr<_YY>& rhs) _RWSTD_THROW_SPEC_NULL + { + reset(rhs.release()); + return *this; + } +//#endif + + ~auto_ptr () _RWSTD_THROW_SPEC_NULL { delete the_p; } + // + // members + // + _XX& operator* () const _RWSTD_THROW_SPEC_NULL { return *the_p; } + _XX* operator-> () const _RWSTD_THROW_SPEC_NULL { return the_p; } + _XX* get () const _RWSTD_THROW_SPEC_NULL { return the_p; } + + _XX* release () _RWSTD_THROW_SPEC_NULL + { + _XX* tmp = the_p; + the_p = 0; + return tmp; + } + + void reset (_XX* p = 0) _RWSTD_THROW_SPEC_NULL + { + if (the_p != p) + { + delete the_p; + the_p = p; + } + } + +//#ifndef _RWSTD_NO_MEM_CLASS_TEMPLATES + auto_ptr(auto_ptr_ref<_XX> r) _RWSTD_THROW_SPEC_NULL + : the_p (0) + { + reset(r.release()); + } + auto_ptr<_XX>& operator= (auto_ptr_ref<_XX> r) _RWSTD_THROW_SPEC_NULL + { + reset(r.release()); + return *this; + } +//#ifndef _RWSTD_NO_MEMBER_TEMPLATES + template <class _YY> operator auto_ptr_ref<_YY>() _RWSTD_THROW_SPEC_NULL + { + return auto_ptr_ref<_YY>(release()); + } + template <class _YY> operator auto_ptr<_YY>() _RWSTD_THROW_SPEC_NULL + { + auto_ptr<_YY> tmp; + tmp.reset(release()); + return tmp; + } +//#endif // _RWSTD_NO_MEMBER_TEMPLATES +//#endif // _RWSTD_NO_MEM_CLASS_TEMPLATES + + private: + _XX* the_p; + }; + + +#ifndef _RWSTD_NO_NAMESPACE +} +#endif + +#pragma enable_warn + +#endif /*__STD_MEMORY*/ |