+2003-12-09 Bernardo Innocenti <bernie@develer.com>
+
+ * include/backward/algo.h, include/backward/algobase.h,
+ include/backward/alloc.h, include/backward/complex.h,
+ include/backward/defalloc.h, include/backward/function.h,
+ include/backward/iterator.h, include/backward/new.h,
+ include/backward/ostream.h, include/backward/queue.h,
+ include/backward/rope.h, include/backward/stream.h,
+ include/backward/streambuf.h, include/backward/strstream,
+ include/backward/tempbuf.h, include/backward/tree.h,
+ include/backward/vector.h: Remove trailing whitespace.
+
2003-12-08 Paolo Carlini <pcarlini@suse.de>
* config/locale/generic/c_locale.cc (__convert_to_v(long&),
#include <ext/numeric>
// Names from <stl_algo.h>
-using std::for_each;
-using std::find;
-using std::find_if;
-using std::adjacent_find;
-using std::count;
-using std::count_if;
-using std::search;
-using std::search_n;
-using std::swap_ranges;
-using std::transform;
-using std::replace;
-using std::replace_if;
-using std::replace_copy;
-using std::replace_copy_if;
-using std::generate;
-using std::generate_n;
-using std::remove;
-using std::remove_if;
-using std::remove_copy;
-using std::remove_copy_if;
-using std::unique;
-using std::unique_copy;
-using std::reverse;
-using std::reverse_copy;
-using std::rotate;
-using std::rotate_copy;
-using std::random_shuffle;
-using std::partition;
-using std::stable_partition;
-using std::sort;
-using std::stable_sort;
-using std::partial_sort;
-using std::partial_sort_copy;
-using std::nth_element;
-using std::lower_bound;
-using std::upper_bound;
-using std::equal_range;
-using std::binary_search;
-using std::merge;
-using std::inplace_merge;
-using std::includes;
-using std::set_union;
-using std::set_intersection;
-using std::set_difference;
-using std::set_symmetric_difference;
-using std::min_element;
-using std::max_element;
-using std::next_permutation;
-using std::prev_permutation;
-using std::find_first_of;
-using std::find_end;
+using std::for_each;
+using std::find;
+using std::find_if;
+using std::adjacent_find;
+using std::count;
+using std::count_if;
+using std::search;
+using std::search_n;
+using std::swap_ranges;
+using std::transform;
+using std::replace;
+using std::replace_if;
+using std::replace_copy;
+using std::replace_copy_if;
+using std::generate;
+using std::generate_n;
+using std::remove;
+using std::remove_if;
+using std::remove_copy;
+using std::remove_copy_if;
+using std::unique;
+using std::unique_copy;
+using std::reverse;
+using std::reverse_copy;
+using std::rotate;
+using std::rotate_copy;
+using std::random_shuffle;
+using std::partition;
+using std::stable_partition;
+using std::sort;
+using std::stable_sort;
+using std::partial_sort;
+using std::partial_sort_copy;
+using std::nth_element;
+using std::lower_bound;
+using std::upper_bound;
+using std::equal_range;
+using std::binary_search;
+using std::merge;
+using std::inplace_merge;
+using std::includes;
+using std::set_union;
+using std::set_intersection;
+using std::set_difference;
+using std::set_symmetric_difference;
+using std::min_element;
+using std::max_element;
+using std::next_permutation;
+using std::prev_permutation;
+using std::find_first_of;
+using std::find_end;
// Names from stl_heap.h
using std::push_heap;
using std::sort_heap;
// Names from stl_numeric.h
-using std::accumulate;
-using std::inner_product;
-using std::partial_sum;
-using std::adjacent_difference;
+using std::accumulate;
+using std::inner_product;
+using std::partial_sum;
+using std::adjacent_difference;
// Names from ext/algorithm
-using __gnu_cxx::random_sample;
+using __gnu_cxx::random_sample;
using __gnu_cxx::random_sample_n;
-using __gnu_cxx::is_sorted;
+using __gnu_cxx::is_sorted;
using __gnu_cxx::is_heap;
using __gnu_cxx::count; // Extension returning void
using __gnu_cxx::count_if; // Extension returning void
// Names from ext/numeric
-using __gnu_cxx::power;
-using __gnu_cxx::iota;
+using __gnu_cxx::power;
+using __gnu_cxx::iota;
#endif /* _BACKWARD_ALGO_H */
#include <ext/memory>
// Names from stl_algobase.h
-using std::iter_swap;
-using std::swap;
-using std::min;
-using std::max;
-using std::copy;
-using std::copy_backward;
-using std::fill;
-using std::fill_n;
-using std::mismatch;
-using std::equal;
-using std::lexicographical_compare;
+using std::iter_swap;
+using std::swap;
+using std::min;
+using std::max;
+using std::copy;
+using std::copy_backward;
+using std::fill;
+using std::fill_n;
+using std::mismatch;
+using std::equal;
+using std::lexicographical_compare;
// Names from stl_uninitialized.h
using std::uninitialized_copy;
using std::uninitialized_fill_n;
// Names from ext/algorithm
-using __gnu_cxx::copy_n;
-using __gnu_cxx::lexicographical_compare_3way;
+using __gnu_cxx::copy_n;
+using __gnu_cxx::lexicographical_compare_3way;
// Names from ext/memory
using __gnu_cxx::uninitialized_copy_n;
#include <ext/debug_allocator.h>
#include <ext/malloc_allocator.h>
-using __gnu_cxx::__malloc_alloc;
-using __gnu_cxx::__debug_alloc;
-using __gnu_cxx::__pool_alloc;
-using std::__alloc;
-using std::__simple_alloc;
+using __gnu_cxx::__malloc_alloc;
+using __gnu_cxx::__debug_alloc;
+using __gnu_cxx::__pool_alloc;
+using std::__alloc;
+using std::__simple_alloc;
using std::allocator;
-#endif
+#endif
#include <complex>
using std::complex;
-typedef complex<float> float_complex;
-typedef complex<double> double_complex;
-typedef complex<long double> long_double_complex;
+typedef complex<float> float_complex;
+typedef complex<double> double_complex;
+typedef complex<long double> long_double_complex;
#endif
// This file WILL BE REMOVED in a future release.
//
// DO NOT USE THIS FILE unless you have an old container implementation
-// that requires an allocator with the HP-style interface.
+// that requires an allocator with the HP-style interface.
//
// Standard-conforming allocators have a very different interface. The
// standard default allocator is declared in the header <memory>.
#include "new.h"
#include <stddef.h>
#include <stdlib.h>
-#include <limits.h>
-#include "iostream.h"
+#include <limits.h>
+#include "iostream.h"
#include "algobase.h"
set_new_handler(0);
_Tp* __tmp = (_Tp*)(::operator new((size_t)(__size * sizeof(_Tp))));
if (__tmp == 0) {
- cerr << "out of memory" << endl;
+ cerr << "out of memory" << endl;
exit(1);
}
return __tmp;
typedef const _Tp& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
- pointer allocate(size_type __n) {
+ pointer allocate(size_type __n) {
return ::allocate((difference_type)__n, (pointer)0);
}
void deallocate(pointer __p) { ::deallocate(__p); }
pointer address(reference __x) { return (pointer)&__x; }
- const_pointer const_address(const_reference __x) {
- return (const_pointer)&__x;
+ const_pointer const_address(const_reference __x) {
+ return (const_pointer)&__x;
}
- size_type init_page_size() {
- return max(size_type(1), size_type(4096/sizeof(_Tp)));
+ size_type init_page_size() {
+ return max(size_type(1), size_type(4096/sizeof(_Tp)));
}
- size_type max_size() const {
- return max(size_type(1), size_type(UINT_MAX/sizeof(_Tp)));
+ size_type max_size() const {
+ return max(size_type(1), size_type(UINT_MAX/sizeof(_Tp)));
}
};
#include <ext/functional>
// Names from stl_function.h
-using std::unary_function;
-using std::binary_function;
-using std::plus;
-using std::minus;
-using std::multiplies;
-using std::divides;
-using std::modulus;
-using std::negate;
-using std::equal_to;
-using std::not_equal_to;
-using std::greater;
-using std::less;
-using std::greater_equal;
-using std::less_equal;
-using std::logical_and;
-using std::logical_or;
-using std::logical_not;
-using std::unary_negate;
-using std::binary_negate;
-using std::not1;
-using std::not2;
-using std::binder1st;
-using std::binder2nd;
-using std::bind1st;
-using std::bind2nd;
-using std::pointer_to_unary_function;
-using std::pointer_to_binary_function;
-using std::ptr_fun;
-using std::mem_fun_t;
-using std::const_mem_fun_t;
-using std::mem_fun_ref_t;
-using std::const_mem_fun_ref_t;
-using std::mem_fun1_t;
-using std::const_mem_fun1_t;
-using std::mem_fun1_ref_t;
-using std::const_mem_fun1_ref_t;
-using std::mem_fun;
-using std::mem_fun_ref;
+using std::unary_function;
+using std::binary_function;
+using std::plus;
+using std::minus;
+using std::multiplies;
+using std::divides;
+using std::modulus;
+using std::negate;
+using std::equal_to;
+using std::not_equal_to;
+using std::greater;
+using std::less;
+using std::greater_equal;
+using std::less_equal;
+using std::logical_and;
+using std::logical_or;
+using std::logical_not;
+using std::unary_negate;
+using std::binary_negate;
+using std::not1;
+using std::not2;
+using std::binder1st;
+using std::binder2nd;
+using std::bind1st;
+using std::bind2nd;
+using std::pointer_to_unary_function;
+using std::pointer_to_binary_function;
+using std::ptr_fun;
+using std::mem_fun_t;
+using std::const_mem_fun_t;
+using std::mem_fun_ref_t;
+using std::const_mem_fun_ref_t;
+using std::mem_fun1_t;
+using std::const_mem_fun1_t;
+using std::mem_fun1_ref_t;
+using std::const_mem_fun1_ref_t;
+using std::mem_fun;
+using std::mem_fun_ref;
// Names from ext/functional
-using __gnu_cxx::identity_element;
-using __gnu_cxx::unary_compose;
-using __gnu_cxx::binary_compose;
-using __gnu_cxx::compose1;
-using __gnu_cxx::compose2;
-using __gnu_cxx::identity;
-using __gnu_cxx::select1st;
-using __gnu_cxx::select2nd;
-using __gnu_cxx::project1st;
-using __gnu_cxx::project2nd;
-using __gnu_cxx::constant_void_fun;
-using __gnu_cxx::constant_unary_fun;
-using __gnu_cxx::constant_binary_fun;
-using __gnu_cxx::constant0;
-using __gnu_cxx::constant1;
-using __gnu_cxx::constant2;
-using __gnu_cxx::subtractive_rng;
-using __gnu_cxx::mem_fun1;
-using __gnu_cxx::mem_fun1_ref;
+using __gnu_cxx::identity_element;
+using __gnu_cxx::unary_compose;
+using __gnu_cxx::binary_compose;
+using __gnu_cxx::compose1;
+using __gnu_cxx::compose2;
+using __gnu_cxx::identity;
+using __gnu_cxx::select1st;
+using __gnu_cxx::select2nd;
+using __gnu_cxx::project1st;
+using __gnu_cxx::project2nd;
+using __gnu_cxx::constant_void_fun;
+using __gnu_cxx::constant_unary_fun;
+using __gnu_cxx::constant_binary_fun;
+using __gnu_cxx::constant0;
+using __gnu_cxx::constant1;
+using __gnu_cxx::constant2;
+using __gnu_cxx::subtractive_rng;
+using __gnu_cxx::mem_fun1;
+using __gnu_cxx::mem_fun1_ref;
#endif /* _BACKWARD_FUNCTION_H */
using std::distance;
using __gnu_cxx::distance; // 3-parameter extension
-using std::advance;
+using std::advance;
using std::insert_iterator;
using std::front_insert_iterator;
inline void
destroy(_Tp* __pointer)
{ std::_Destroy(__pointer); }
-
+
template <class _ForwardIterator>
inline void
destroy(_ForwardIterator __first, _ForwardIterator __last)
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
-//
+//
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
-//
+//
// You should have received a copy of the GNU General Public License
// along with GCC; see the file COPYING. If not, write to
// the Free Software Foundation, 59 Temple Place - Suite 330,
using std::new_handler;
using std::set_new_handler;
-#endif
+#endif
#include "backward_warning.h"
#include "iostream.h"
-#endif
+#endif
// Local Variables:
// mode:C++
using std::queue;
using std::priority_queue;
-#endif
+#endif
// Local Variables:
// mode:C++
#define _BACKWARD_ROPE_H 1
#include "backward_warning.h"
-#include "hashtable.h"
+#include "hashtable.h"
#include <ext/rope>
-using __gnu_cxx::char_producer;
-using __gnu_cxx::sequence_buffer;
-using __gnu_cxx::rope;
-using __gnu_cxx::crope;
-using __gnu_cxx::wrope;
+using __gnu_cxx::char_producer;
+using __gnu_cxx::sequence_buffer;
+using __gnu_cxx::rope;
+using __gnu_cxx::crope;
+using __gnu_cxx::wrope;
#endif /* _BACKWARD_ROPE_H */
#include "backward_warning.h"
#include "iostream.h"
-#endif
+#endif
// Local Variables:
// mode:C++
using std::streambuf;
-#endif
+#endif
// Local Variables:
// mode:C++
// Note that this class is not a template.
class strstreambuf : public basic_streambuf<char, char_traits<char> >
{
- public:
+ public:
// Types.
typedef char_traits<char> _Traits;
typedef basic_streambuf<char, _Traits> _Base;
- public:
+ public:
// Constructor, destructor
explicit strstreambuf(streamsize __initial_capacity = 0);
strstreambuf(void* (*__alloc)(size_t), void (*__free)(void*));
virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode
= ios_base::in | ios_base::out);
- private:
+ private:
// Dynamic allocation, possibly using _M_alloc_fun and _M_free_fun.
char* _M_alloc(size_t);
void _M_free(char*);
// Helper function used in constructors.
void _M_setup(char* __get, char* __put, streamsize __n);
- private:
+ private:
// Data members.
void* (*_M_alloc_fun)(size_t);
void (*_M_free_fun)(void*);
strstreambuf _M_buf;
};
} // namespace std
-#endif
+#endif
#include "pair.h"
#include "iterator.h"
#include <limits.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <bits/type_traits.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <bits/type_traits.h>
#include <bits/stl_construct.h>
#include <bits/stl_uninitialized.h>
#include <ext/memory>
using __gnu_cxx::rb_tree;
-#endif
+#endif
// Local Variables:
// mode:C++
// End:
#include "backward_warning.h"
#include "algobase.h"
-#include "alloc.h"
+#include "alloc.h"
#include <vector>
using std::vector;
projects / gcc.git / commitdiff