]> git.ipfire.org Git - thirdparty/gcc.git/commitdiff
c++config (std::size_t, [...]): Provide typedefs.
authorPaolo Carlini <paolo.carlini@oracle.com>
Thu, 3 Jun 2010 19:15:56 +0000 (19:15 +0000)
committerPaolo Carlini <paolo@gcc.gnu.org>
Thu, 3 Jun 2010 19:15:56 +0000 (19:15 +0000)
2010-06-03  Paolo Carlini  <paolo.carlini@oracle.com>

* include/bits/c++config (std::size_t, std::ptrdiff_t,
        std::nullptr_t): Provide typedefs.
* include/c_std/cstddef: Don't provide std::size_t and
std::ptrdiff_t here.
* include/c_global/cstddef: Likewise.
* src/condition_variable.cc: Don't include <cstddef>,
don't use NULL, use std::size_t and std::ptrdiff_t.
* src/mt_allocator.cc: Likewise.
* src/localename.cc: Likewise.
* src/chrono.cc: Likewise.
* src/thread.cc: Likewise.
* include/debug/formatter.h: Likewise.
* include/debug/functions.h: Likewise.
* include/std/valarray: Likewise.
* include/std/thread: Likewise.
* include/std/type_traits: Likewise.
* include/std/atomic: Likewise.
* include/std/iterator: Likewise.
* include/std/bitset: Likewise.
* include/std/fstream: Likewise.
* include/std/mutex: Likewise.
* include/c_std/cstdlib: Likewise.
* include/c_std/cstdio: Likewise.
* include/c_std/ctime: Likewise.
* include/c_std/cwchar: Likewise.
* include/c_std/cstring: Likewise.
* include/parallel/multiway_merge.h: Likewise.
* include/parallel/multiseq_selection.h: Likewise.
* include/parallel/base.h: Likewise.
* include/parallel/basic_iterator.h: Likewise.
* include/parallel/multiway_mergesort.h
* include/parallel/partition.h: Likewise.
* include/ext/string_conversions.h: Likewise.
* include/ext/pb_ds/assoc_container.hpp: Likewise.
* include/ext/pb_ds/detail/resize_policy/sample_size_policy.hpp:
Likewise.
* include/ext/pb_ds/detail/resize_policy/
hash_prime_size_policy_imp.hpp: Likewise.
* include/ext/pb_ds/detail/resize_policy/
sample_resize_policy.hpp: Likewise.
* include/ext/pb_ds/detail/resize_policy/
sample_resize_trigger.hpp: Likewise.
* include/ext/pb_ds/detail/binomial_heap_base_/
erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/binomial_heap_base_/
find_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/binomial_heap_base_/
insert_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/binomial_heap_base_/
constructors_destructor_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/binomial_heap_base_/
debug_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/binomial_heap_base_/
split_join_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
erase_store_hash_fn_imps.hpp: Likewise.
* include/ext/pb_ds/d: Likewise.etail/cc_hash_table_map_/
insert_no_store_hash_fn_imps.hpp
* include/ext/pb_ds/detail/cc_hash_table_map_/
cmp_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
find_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
insert_store_hash_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
debug_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
info_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
entry_list_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
trace_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
cc_ht_map_.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
resize_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
constructor_destructor_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/cc_hash_table_map_/
erase_no_store_hash_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/unordered_iterator/
iterator.hpp: Likewise.
* include/ext/pb_ds/detail/unordered_iterator/
const_iterator.hpp: Likewise.
* include/ext/pb_ds/detail/unordered_iterator/
point_iterator.hpp: Likewise.
* include/ext/pb_ds/detail/unordered_iterator/
const_point_iterator.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/child_iterator.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/
insert_join_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/
constructors_destructor_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/
const_child_iterator.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/rotate_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/node_iterators.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/internal_node.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/point_iterators.hpp: Likewise.
* include/ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/bin_search_tree_/
find_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/bin_search_tree_/
r_erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/bin_search_tree_/
constructors_destructor_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/bin_search_tree_/
debug_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/bin_search_tree_/
rotate_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/bin_search_tree_/
erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/bin_search_tree_/
insert_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/bin_search_tree_/
node_iterators.hpp: Likewise.
* include/ext/pb_ds/detail/bin_search_tree_/
point_iterators.hpp: Likewise.
* include/ext/pb_ds/detail/bin_search_tree_/
split_join_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/bin_search_tree_/
iterators_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/gp_hash_table_map_/
find_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/gp_hash_table_map_/
gp_ht_map_.hpp: Likewise.
* include/ext/pb_ds/detail/gp_hash_table_map_/
resize_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/gp_hash_table_map_/
standard_policies.hpp: Likewise.
* include/ext/pb_ds/detail/tree_policy/
sample_tree_node_update.hpp: Likewise.
* include/ext/pb_ds/detail/basic_tree_policy/
null_node_metadata.hpp: Likewise.
* include/ext/pb_ds/detail/binary_heap_/const_iterator.hpp: Likewise.
* include/ext/pb_ds/detail/binary_heap_/
const_point_iterator.hpp: Likewise.
* include/ext/pb_ds/detail/binary_heap_/
split_join_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/trie_policy/
sample_trie_node_update.hpp: Likewise.
* include/ext/pb_ds/detail/trie_policy/
sample_trie_e_access_traits.hpp: Likewise.
* include/ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/pairing_heap_/
split_join_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/list_update_policy/
counter_lu_metadata.hpp: Likewise.
* include/ext/pb_ds/detail/left_child_next_sibling_heap_/
trace_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/left_child_next_sibling_heap_/
erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/left_child_next_sibling_heap_/
null_metadata.hpp: Likewise.
* include/ext/pb_ds/detail/left_child_next_sibling_heap_/
const_iterator.hpp: Likewise.
* include/ext/pb_ds/detail/left_child_next_sibling_heap_/
insert_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/left_child_next_sibling_heap_/
constructors_destructor_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/left_child_next_sibling_heap_/
debug_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/left_child_next_sibling_heap_/
iterators_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/left_child_next_sibling_heap_/
const_point_iterator.hpp: Likewise.
* include/ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/thin_heap_/
constructors_destructor_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/thin_heap_/
split_join_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/ov_tree_map_/
constructors_destructor_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp: Likewise.
* include/ext/pb_ds/detail/ov_tree_map_/
iterators_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/hash_fn/sample_probe_fn.hpp: Likewise.
* include/ext/pb_ds/detail/hash_fn/
sample_ranged_probe_fn.hpp: Likewise.
* include/ext/pb_ds/detail/hash_fn/sample_range_hashing.hpp: Likewise.
* include/ext/pb_ds/detail/hash_fn/
sample_ranged_hash_fn.hpp: Likewise.
* include/ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/splay_tree_/
split_join_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/list_update_map_/
trace_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/list_update_map_/
erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/list_update_map_/
find_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp: Likewise.
* include/ext/pb_ds/detail/list_update_map_/
constructor_destructor_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/list_update_map_/
insert_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/list_update_map_/
info_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/list_update_map_/
iterators_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/rc_binomial_heap_/
erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/rc_binomial_heap_/
insert_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/rc_binomial_heap_/
debug_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/rb_tree_map_/
split_join_fn_imps.hpp: Likewise.
* include/ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp: Likewise.
* include/ext/pb_ds/list_update_policy.hpp: Likewise.
* include/ext/pb_ds/exception.hpp: Likewise.
* include/ext/pb_ds/tree_policy.hpp: Likewise.
* include/ext/pb_ds/tag_and_trait.hpp: Likewise.
* include/ext/pb_ds/hash_policy.hpp: Likewise.
* include/ext/pb_ds/trie_policy.hpp: Likewise.
* include/ext/pb_ds/priority_queue.hpp: Likewise.
* include/ext/throw_allocator.h: Likewis: Likewise.e.
* include/ext/bitmap_allocator.h
* include/ext/rc_string_base.h: Likewise.
* include/ext/new_allocator.h: Likewise.
* include/ext/codecvt_specializations.h: Likewise.
* include/ext/functional: Likewise.: Likewise.
* include/ext/array_allocator.h: Likewise.
* include/ext/mt_allocator.h: Likewise.
* include/ext/sso_string_base.h: Likewise.
* include/profile/impl/profiler_trace.h: Likewise.
* include/profile/impl/profiler_node.h: Likewise.
* include/bits/stl_algobase.h: Likewise.
* include/bits/functional_hash.h: Likewise.
* include/bits/locale_facets.tcc: Likewise.
* include/bits/locale_facets.h: Likewise.
* include/bits/stl_iterator_base_types.h: Likewise.
* include/bits/move.h: Likewise.
* include/bits/boost_concept_check.h: Likewise.
* include/bits/basic_string.tcc: Likewise.
* include/bits/locale_facets_nonio.tcc: Likewise.
* include/bits/fstream.tcc: Likewise.
* include/bits/locale_facets_nonio.h: Likewise.
* include/c_global/cstdlib: Likewise.
* include/c_global/cstdio: Likewise.
* include/c_global/ctime: Likewise.
* include/c_global/cwchar: Likewise.
* include/c_global/cstring
* include/tr1/type_traits: Likewise.
* include/backward/hash_fun.h: Likewise.
* libsupc++/new: Likewise.
* libsupc++/initializer_list: Likewise.
* testsuite/27_io/basic_ofstream/pthread2.cc: Likewise.
* testsuite/27_io/basic_iostream/cons/2020.cc: Likewise.
* testsuite/27_io/basic_streambuf/sgetn/wchar_t/1.cc: Likewise.
* testsuite/27_io/basic_streambuf/sgetn/char/1.cc: Likewise.
* testsuite/27_io/basic_streambuf/overflow/wchar_t/1.cc: Likewise.
* testsuite/27_io/basic_streambuf/overflow/char/1.cc: Likewise.
* testsuite/27_io/basic_streambuf/sgetc/wchar_t/1.cc: Likewise.
* testsuite/27_io/basic_streambuf/sgetc/char/1.cc: Likewise.
* testsuite/27_io/basic_streambuf/sputn/wchar_t/1057.cc: Likewise.
* testsuite/27_io/basic_streambuf/sputn/wchar_t/1.cc: Likewise.
* testsuite/27_io/basic_streambuf/sputn/char/1057.cc: Likewise.
* testsuite/27_io/basic_streambuf/sputn/char/1.cc: Likewise.
* testsuite/27_io/basic_streambuf/sputc/wchar_t/1057.cc: Likewise.
* testsuite/27_io/basic_streambuf/sputc/char/1057.cc: Likewise.
* testsuite/27_io/objects/wchar_t/5268.cc: Likewise.
* testsuite/27_io/objects/char/9661-1.cc: Likewise.
* testsuite/27_io/objects/char/5268.cc: Likewise.
* testsuite/27_io/objects/char/10.cc: Likewise.
* testsuite/27_io/basic_ios/copyfmt/char/1.cc: Likewise.
* testsuite/27_io/basic_ios/copyfmt/char/2.cc: Likewise.
* testsuite/27_io/basic_ios/exceptions/char/1.cc: Likewise.
* testsuite/27_io/basic_ios/locales/char/1.cc: Likewise.
* testsuite/27_io/basic_ios/clear/char/1.cc: Likewise.
* testsuite/27_io/basic_ostringstream/pthread3.cc: Likewise.
* testsuite/27_io/basic_stringbuf/sputc/wchar_t/1057.cc: Likewise.
* testsuite/27_io/basic_stringbuf/sputc/char/1057.cc: Likewise.
* testsuite/27_io/basic_stringbuf/sputn/wchar_t/1057.cc: Likewise.
* testsuite/27_io/basic_stringbuf/sputn/char/1057.cc: Likewise.
* testsuite/27_io/basic_istream/get/wchar_t/1.cc: Likewise.
* testsuite/27_io/basic_istream/get/char/1.cc: Likewise.
* testsuite/27_io/basic_istream/ignore/wchar_t/1.cc: Likewise.
* testsuite/27_io/basic_istream/ignore/char/1.cc: Likewise.
* testsuite/27_io/basic_istream/peek/wchar_t/1.cc: Likewise.
* testsuite/27_io/basic_istream/peek/char/1.cc: Likewise.
* testsuite/27_io/basic_istream/getline/wchar_t/1.cc: Likewise.
* testsuite/27_io/basic_istream/getline/char/1.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_other/wchar_t/
exceptions_null.cc
* testsuite/27_io/basic_istream/extractors_other/wchar_t/
1.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_other/char/
exceptions_null.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_other/char/1.cc: Likewise.
* testsuite/27_io/basic_istream/cons/3.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_arithmetic/
wchar_t/01.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_arithmetic/
char/01.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_character/
wchar_t/1.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_character/
wchar_t/2.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_character/
wchar_t/3.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_character/
char/1.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_character/
char/2.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_character/
char/3.cc: Likewise.
* testsuite/27_io/basic_istream/extractors_character/
char/9826.cc: Likewise.
* testsuite/27_io/basic_istream/read/wchar_t/1.cc: Likewise.
* testsuite/27_io/basic_istream/read/char/1.cc: Likewise.
* testsuite/27_io/basic_ostream/inserters_other/wchar_t/
exceptions_null.cc: Likewise.
* testsuite/27_io/basic_ostream/inserters_other/wchar_t/
1.cc: Likewise.
* testsuite/27_io/basic_ostream/inserters_other/char/
exceptions_null.cc: Likewise.
* testsuite/27_io/basic_ostream/inserters_other/char/1.cc: Likewise.
* testsuite/27_io/basic_ostream/cons/2020.cc: Likewise.
* testsuite/27_io/basic_ostream/sentry/pod/1.cc: Likewise.
* testsuite/27_io/basic_ostream/inserters_character/
wchar_t/8.cc: Likewise.
* testsuite/27_io/basic_ostream/inserters_character/
char/8.cc: Likewise.
* testsuite/27_io/basic_filebuf/setbuf/char/1.cc: Likewise.
* testsuite/27_io/basic_filebuf/sputc/char/1057.cc: Likewise.
* testsuite/27_io/basic_filebuf/open/char/1.cc: Likewise.
* testsuite/27_io/basic_filebuf/open/char/2.cc: Likewise.
* testsuite/27_io/basic_filebuf/open/char/9507.cc: Likewise.
* testsuite/27_io/basic_filebuf/imbue/wchar_t/14975-2.cc: Likewise.
* testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-1.cc: Likewise.
* testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-2.cc: Likewise.
* testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-3.cc: Likewise.
* testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-4.cc: Likewise.
* testsuite/27_io/basic_filebuf/close/wchar_t/12790-3.cc: Likewise.
* testsuite/27_io/basic_filebuf/close/char/9964.cc: Likewise.
* testsuite/27_io/basic_filebuf/close/char/1.cc: Likewise.
* testsuite/27_io/basic_filebuf/close/char/2.cc: Likewise.
* testsuite/27_io/basic_filebuf/close/char/12790-3.cc: Likewise.
* testsuite/27_io/basic_filebuf/sputn/char/1057.cc: Likewise.
* testsuite/24_iterators/ostreambuf_iterator/2.cc: Likewise.
* testsuite/18_support/bad_exception/23591_thread-1.c
* testsuite/18_support/new_delete_placement.cc: Likewise.
* testsuite/18_support/pthread_guard.cc: Likewise.
* testsuite/21_strings/basic_string/operations/wchar_t/1.cc: Likewise.
* testsuite/21_strings/basic_string/operations/char/1.cc: Likewise.
* testsuite/21_strings/basic_string/pthread4.cc: Likewise.
* testsuite/21_strings/basic_string/cons/wchar_t/5.cc: Likewise.
* testsuite/21_strings/basic_string/cons/char/5.cc: Likewise.
* testsuite/30_threads/timed_mutex/cons/assign_neg.cc: Likewise.
* testsuite/30_threads/timed_mutex/cons/copy_neg.cc: Likewise.
* testsuite/30_threads/recursive_mutex/cons/assign_neg.cc: Likewise.
* testsuite/30_threads/recursive_mutex/cons/copy_neg.cc: Likewise.
* testsuite/30_threads/mutex/cons/assign_neg.cc: Likewise.
* testsuite/30_threads/mutex/cons/copy_neg.cc: Likewise.
* testsuite/30_threads/thread/cons/assign_neg.cc: Likewise.
* testsuite/30_threads/thread/cons/copy_neg.cc: Likewise.
* testsuite/30_threads/recursive_timed_mutex/cons/
assign_neg.cc: Likewise.
* testsuite/30_threads/recursive_timed_mutex/cons/
copy_neg.cc: Likewise.
* testsuite/ext/mt_allocator/22309_thread.cc: Likewise.
* testsuite/ext/slist/23781.cc: Likewise.
* testsuite/ext/rope/pthread7-rope.cc: Likewise.
* testsuite/ext/stdio_filebuf/char/10063-2.cc: Likewise.
* testsuite/22_locale/ctype/is/wchar_t/1.cc: Likewise.
* testsuite/22_locale/ctype/is/char/1.cc: Likewise.
* testsuite/22_locale/time_put/put/char/12439_1.cc: Likewise.
* testsuite/22_locale/time_put/put/char/12439_3.cc: Likewise.
* testsuite/22_locale/locale/cons/2.cc: Likewise.
* testsuite/22_locale/locale/cons/12658_thread-1.cc: Likewise.
* testsuite/22_locale/locale/cons/29217.cc: Likewise.
* testsuite/22_locale/locale/global_locale_objects/14071.cc: Likewise.
* testsuite/22_locale/locale/global_locale_objects/2.cc: Likewise.
* testsuite/tr1/6_containers/unordered_multimap/
requirements/iterator_null_neg.cc: Likewise.
* testsuite/tr1/6_containers/unordered_multiset/
requirements/iterator_null_neg.cc: Likewise.
* testsuite/29_atomics/atomic_address/cons/single_value.cc: Likewise.
* testsuite/29_atomics/atomic_address/cons/aggregate.cc: Likewise.
* testsuite/23_containers/multimap/23781.cc: Likewise.
* testsuite/23_containers/set/23781.cc: Likewise.
* testsuite/23_containers/multiset/23781.cc: Likewise.
* testsuite/23_containers/list/pthread1.cc: Likewise.
* testsuite/23_containers/list/23781.cc: Likewise.
* testsuite/23_containers/map/pthread6.cc: Likewise.
* testsuite/23_containers/map/23781.cc: Likewise.
* testsuite/util/regression/rand/priority_queue/
rand_regression_test.hpp: Likewise.
* testsuite/util/regression/rand/priority_queue/
container_rand_regression_test.tcc: Likewise.
* testsuite/util/regression/rand/assoc/
rand_regression_test.hpp: Likewise.
* testsuite/util/regression/rand/assoc/
container_rand_regression_test.tcc: Likewise.
* testsuite/util/testsuite_hooks.cc: Likewise.
* testsuite/util/testsuite_io.h: Likewise.
* testsuite/util/testsuite_iterators.h: Likewise.
* testsuite/util/replacement_memory_operators.h: Likewise.
* testsuite/util/testsuite_allocator.h: Likewise.
* testsuite/util/testsuite_performance.h: Likewise.

From-SVN: r160231

317 files changed:
libstdc++-v3/ChangeLog
libstdc++-v3/include/backward/hash_fun.h
libstdc++-v3/include/bits/basic_string.tcc
libstdc++-v3/include/bits/boost_concept_check.h
libstdc++-v3/include/bits/c++config
libstdc++-v3/include/bits/fstream.tcc
libstdc++-v3/include/bits/functional_hash.h
libstdc++-v3/include/bits/locale_facets.h
libstdc++-v3/include/bits/locale_facets.tcc
libstdc++-v3/include/bits/locale_facets_nonio.h
libstdc++-v3/include/bits/locale_facets_nonio.tcc
libstdc++-v3/include/bits/move.h
libstdc++-v3/include/bits/stl_algobase.h
libstdc++-v3/include/bits/stl_iterator_base_types.h
libstdc++-v3/include/c_global/cstddef
libstdc++-v3/include/c_global/cstdio
libstdc++-v3/include/c_global/cstdlib
libstdc++-v3/include/c_global/cstring
libstdc++-v3/include/c_global/ctime
libstdc++-v3/include/c_global/cwchar
libstdc++-v3/include/c_std/cstddef
libstdc++-v3/include/c_std/cstdio
libstdc++-v3/include/c_std/cstdlib
libstdc++-v3/include/c_std/cstring
libstdc++-v3/include/c_std/ctime
libstdc++-v3/include/c_std/cwchar
libstdc++-v3/include/debug/formatter.h
libstdc++-v3/include/debug/functions.h
libstdc++-v3/include/ext/array_allocator.h
libstdc++-v3/include/ext/bitmap_allocator.h
libstdc++-v3/include/ext/codecvt_specializations.h
libstdc++-v3/include/ext/functional
libstdc++-v3/include/ext/mt_allocator.h
libstdc++-v3/include/ext/new_allocator.h
libstdc++-v3/include/ext/pb_ds/assoc_container.hpp
libstdc++-v3/include/ext/pb_ds/detail/basic_tree_policy/null_node_metadata.hpp
libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/find_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/iterators_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/node_iterators.hpp
libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/point_iterators.hpp
libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/rotate_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_iterator.hpp
libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_point_iterator.hpp
libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/split_join_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/debug_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/find_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/insert_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/split_join_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/entry_list_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/find_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp
libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/standard_policies.hpp
libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_probe_fn.hpp
libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_range_hashing.hpp
libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_hash_fn.hpp
libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_probe_fn.hpp
libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_iterator.hpp
libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_point_iterator.hpp
libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/null_metadata.hpp
libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/info_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/iterators_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp
libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/trace_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/list_update_policy/counter_lu_metadata.hpp
libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/iterators_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp
libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/split_join_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/child_iterator.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/const_child_iterator.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/internal_node.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/node_iterators.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/point_iterators.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/rotate_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/split_join_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp
libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_policy.hpp
libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_trigger.hpp
libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_size_policy.hpp
libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/split_join_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/constructors_destructor_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/split_join_fn_imps.hpp
libstdc++-v3/include/ext/pb_ds/detail/tree_policy/sample_tree_node_update.hpp
libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_e_access_traits.hpp
libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_node_update.hpp
libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_iterator.hpp
libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_point_iterator.hpp
libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/iterator.hpp
libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/point_iterator.hpp
libstdc++-v3/include/ext/pb_ds/exception.hpp
libstdc++-v3/include/ext/pb_ds/hash_policy.hpp
libstdc++-v3/include/ext/pb_ds/list_update_policy.hpp
libstdc++-v3/include/ext/pb_ds/priority_queue.hpp
libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp
libstdc++-v3/include/ext/pb_ds/tree_policy.hpp
libstdc++-v3/include/ext/pb_ds/trie_policy.hpp
libstdc++-v3/include/ext/rc_string_base.h
libstdc++-v3/include/ext/sso_string_base.h
libstdc++-v3/include/ext/string_conversions.h
libstdc++-v3/include/ext/throw_allocator.h
libstdc++-v3/include/parallel/base.h
libstdc++-v3/include/parallel/basic_iterator.h
libstdc++-v3/include/parallel/multiseq_selection.h
libstdc++-v3/include/parallel/multiway_merge.h
libstdc++-v3/include/parallel/multiway_mergesort.h
libstdc++-v3/include/parallel/partition.h
libstdc++-v3/include/profile/impl/profiler_node.h
libstdc++-v3/include/profile/impl/profiler_trace.h
libstdc++-v3/include/std/atomic
libstdc++-v3/include/std/bitset
libstdc++-v3/include/std/fstream
libstdc++-v3/include/std/iterator
libstdc++-v3/include/std/mutex
libstdc++-v3/include/std/thread
libstdc++-v3/include/std/type_traits
libstdc++-v3/include/std/valarray
libstdc++-v3/include/tr1/type_traits
libstdc++-v3/libsupc++/initializer_list
libstdc++-v3/libsupc++/new
libstdc++-v3/src/chrono.cc
libstdc++-v3/src/condition_variable.cc
libstdc++-v3/src/localename.cc
libstdc++-v3/src/mt_allocator.cc
libstdc++-v3/src/thread.cc
libstdc++-v3/testsuite/18_support/bad_exception/23591_thread-1.c
libstdc++-v3/testsuite/18_support/new_delete_placement.cc
libstdc++-v3/testsuite/18_support/pthread_guard.cc
libstdc++-v3/testsuite/21_strings/basic_string/cons/char/5.cc
libstdc++-v3/testsuite/21_strings/basic_string/cons/wchar_t/5.cc
libstdc++-v3/testsuite/21_strings/basic_string/operations/char/1.cc
libstdc++-v3/testsuite/21_strings/basic_string/operations/wchar_t/1.cc
libstdc++-v3/testsuite/21_strings/basic_string/pthread4.cc
libstdc++-v3/testsuite/22_locale/ctype/is/char/1.cc
libstdc++-v3/testsuite/22_locale/ctype/is/wchar_t/1.cc
libstdc++-v3/testsuite/22_locale/locale/cons/12658_thread-1.cc
libstdc++-v3/testsuite/22_locale/locale/cons/2.cc
libstdc++-v3/testsuite/22_locale/locale/cons/29217.cc
libstdc++-v3/testsuite/22_locale/locale/global_locale_objects/14071.cc
libstdc++-v3/testsuite/22_locale/locale/global_locale_objects/2.cc
libstdc++-v3/testsuite/22_locale/time_put/put/char/12439_1.cc
libstdc++-v3/testsuite/22_locale/time_put/put/char/12439_3.cc
libstdc++-v3/testsuite/23_containers/list/23781.cc
libstdc++-v3/testsuite/23_containers/list/pthread1.cc
libstdc++-v3/testsuite/23_containers/map/23781.cc
libstdc++-v3/testsuite/23_containers/map/pthread6.cc
libstdc++-v3/testsuite/23_containers/multimap/23781.cc
libstdc++-v3/testsuite/23_containers/multiset/23781.cc
libstdc++-v3/testsuite/23_containers/set/23781.cc
libstdc++-v3/testsuite/24_iterators/ostreambuf_iterator/2.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/1.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/12790-3.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/2.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/9964.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/close/wchar_t/12790-3.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/imbue/wchar_t/14975-2.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/open/char/1.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/open/char/2.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/open/char/9507.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-1.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-2.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-3.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-4.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/setbuf/char/1.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/sputc/char/1057.cc
libstdc++-v3/testsuite/27_io/basic_filebuf/sputn/char/1057.cc
libstdc++-v3/testsuite/27_io/basic_ios/clear/char/1.cc
libstdc++-v3/testsuite/27_io/basic_ios/copyfmt/char/1.cc
libstdc++-v3/testsuite/27_io/basic_ios/copyfmt/char/2.cc
libstdc++-v3/testsuite/27_io/basic_ios/exceptions/char/1.cc
libstdc++-v3/testsuite/27_io/basic_ios/locales/char/1.cc
libstdc++-v3/testsuite/27_io/basic_iostream/cons/2020.cc
libstdc++-v3/testsuite/27_io/basic_istream/cons/3.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_arithmetic/char/01.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_arithmetic/wchar_t/01.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_character/char/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_character/char/2.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_character/char/3.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_character/char/9826.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_character/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_character/wchar_t/2.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_character/wchar_t/3.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_other/char/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_other/char/exceptions_null.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_other/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/extractors_other/wchar_t/exceptions_null.cc
libstdc++-v3/testsuite/27_io/basic_istream/get/char/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/get/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/getline/char/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/getline/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/ignore/char/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/ignore/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/peek/char/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/peek/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/read/char/1.cc
libstdc++-v3/testsuite/27_io/basic_istream/read/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_ofstream/pthread2.cc
libstdc++-v3/testsuite/27_io/basic_ostream/cons/2020.cc
libstdc++-v3/testsuite/27_io/basic_ostream/inserters_character/char/8.cc
libstdc++-v3/testsuite/27_io/basic_ostream/inserters_character/wchar_t/8.cc
libstdc++-v3/testsuite/27_io/basic_ostream/inserters_other/char/1.cc
libstdc++-v3/testsuite/27_io/basic_ostream/inserters_other/char/exceptions_null.cc
libstdc++-v3/testsuite/27_io/basic_ostream/inserters_other/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_ostream/inserters_other/wchar_t/exceptions_null.cc
libstdc++-v3/testsuite/27_io/basic_ostream/sentry/pod/1.cc
libstdc++-v3/testsuite/27_io/basic_ostringstream/pthread3.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/overflow/char/1.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/overflow/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/sgetc/char/1.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/sgetc/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/sgetn/char/1.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/sgetn/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/sputc/char/1057.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/sputc/wchar_t/1057.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/sputn/char/1.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/sputn/char/1057.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/sputn/wchar_t/1.cc
libstdc++-v3/testsuite/27_io/basic_streambuf/sputn/wchar_t/1057.cc
libstdc++-v3/testsuite/27_io/basic_stringbuf/sputc/char/1057.cc
libstdc++-v3/testsuite/27_io/basic_stringbuf/sputc/wchar_t/1057.cc
libstdc++-v3/testsuite/27_io/basic_stringbuf/sputn/char/1057.cc
libstdc++-v3/testsuite/27_io/basic_stringbuf/sputn/wchar_t/1057.cc
libstdc++-v3/testsuite/27_io/objects/char/10.cc
libstdc++-v3/testsuite/27_io/objects/char/5268.cc
libstdc++-v3/testsuite/27_io/objects/char/9661-1.cc
libstdc++-v3/testsuite/27_io/objects/wchar_t/5268.cc
libstdc++-v3/testsuite/29_atomics/atomic_address/cons/aggregate.cc
libstdc++-v3/testsuite/29_atomics/atomic_address/cons/single_value.cc
libstdc++-v3/testsuite/30_threads/mutex/cons/assign_neg.cc
libstdc++-v3/testsuite/30_threads/mutex/cons/copy_neg.cc
libstdc++-v3/testsuite/30_threads/recursive_mutex/cons/assign_neg.cc
libstdc++-v3/testsuite/30_threads/recursive_mutex/cons/copy_neg.cc
libstdc++-v3/testsuite/30_threads/recursive_timed_mutex/cons/assign_neg.cc
libstdc++-v3/testsuite/30_threads/recursive_timed_mutex/cons/copy_neg.cc
libstdc++-v3/testsuite/30_threads/thread/cons/assign_neg.cc
libstdc++-v3/testsuite/30_threads/thread/cons/copy_neg.cc
libstdc++-v3/testsuite/30_threads/timed_mutex/cons/assign_neg.cc
libstdc++-v3/testsuite/30_threads/timed_mutex/cons/copy_neg.cc
libstdc++-v3/testsuite/ext/mt_allocator/22309_thread.cc
libstdc++-v3/testsuite/ext/rope/pthread7-rope.cc
libstdc++-v3/testsuite/ext/slist/23781.cc
libstdc++-v3/testsuite/ext/stdio_filebuf/char/10063-2.cc
libstdc++-v3/testsuite/tr1/6_containers/unordered_multimap/requirements/iterator_null_neg.cc
libstdc++-v3/testsuite/tr1/6_containers/unordered_multiset/requirements/iterator_null_neg.cc
libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.tcc
libstdc++-v3/testsuite/util/regression/rand/assoc/rand_regression_test.hpp
libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.tcc
libstdc++-v3/testsuite/util/regression/rand/priority_queue/rand_regression_test.hpp
libstdc++-v3/testsuite/util/replacement_memory_operators.h
libstdc++-v3/testsuite/util/testsuite_allocator.h
libstdc++-v3/testsuite/util/testsuite_hooks.cc
libstdc++-v3/testsuite/util/testsuite_io.h
libstdc++-v3/testsuite/util/testsuite_iterators.h
libstdc++-v3/testsuite/util/testsuite_performance.h

index a986e8d6325294c02ac8bd861b454aee0585f87e..ff8a796ceda0c20b721f04398e20b833704ff602 100644 (file)
@@ -1,3 +1,431 @@
+2010-06-03  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       * include/bits/c++config (std::size_t, std::ptrdiff_t,
+        std::nullptr_t): Provide typedefs.
+       * include/c_std/cstddef: Don't provide std::size_t and
+       std::ptrdiff_t here.
+       * include/c_global/cstddef: Likewise.
+       * src/condition_variable.cc: Don't include <cstddef>,
+       don't use NULL, use std::size_t and std::ptrdiff_t.
+       * src/mt_allocator.cc: Likewise.
+       * src/localename.cc: Likewise.
+       * src/chrono.cc: Likewise.
+       * src/thread.cc: Likewise.
+       * include/debug/formatter.h: Likewise.
+       * include/debug/functions.h: Likewise.
+       * include/std/valarray: Likewise.
+       * include/std/thread: Likewise.
+       * include/std/type_traits: Likewise.
+       * include/std/atomic: Likewise.
+       * include/std/iterator: Likewise.
+       * include/std/bitset: Likewise.
+       * include/std/fstream: Likewise.
+       * include/std/mutex: Likewise.
+       * include/c_std/cstdlib: Likewise.
+       * include/c_std/cstdio: Likewise.
+       * include/c_std/ctime: Likewise.
+       * include/c_std/cwchar: Likewise.
+       * include/c_std/cstring: Likewise.
+       * include/parallel/multiway_merge.h: Likewise.
+       * include/parallel/multiseq_selection.h: Likewise.
+       * include/parallel/base.h: Likewise.
+       * include/parallel/basic_iterator.h: Likewise.
+       * include/parallel/multiway_mergesort.h
+       * include/parallel/partition.h: Likewise.
+       * include/ext/string_conversions.h: Likewise.
+       * include/ext/pb_ds/assoc_container.hpp: Likewise.
+       * include/ext/pb_ds/detail/resize_policy/sample_size_policy.hpp:
+       Likewise.
+       * include/ext/pb_ds/detail/resize_policy/
+       hash_prime_size_policy_imp.hpp: Likewise.
+       * include/ext/pb_ds/detail/resize_policy/
+       sample_resize_policy.hpp: Likewise.
+       * include/ext/pb_ds/detail/resize_policy/
+       sample_resize_trigger.hpp: Likewise.
+       * include/ext/pb_ds/detail/binomial_heap_base_/
+       erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/binomial_heap_base_/
+       find_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/binomial_heap_base_/
+       insert_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/binomial_heap_base_/
+       constructors_destructor_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/binomial_heap_base_/
+       debug_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/binomial_heap_base_/
+       split_join_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       erase_store_hash_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/d: Likewise.etail/cc_hash_table_map_/
+       insert_no_store_hash_fn_imps.hpp
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       cmp_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       find_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       insert_store_hash_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       debug_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       info_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       entry_list_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       trace_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       cc_ht_map_.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       resize_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       constructor_destructor_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/cc_hash_table_map_/
+       erase_no_store_hash_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/unordered_iterator/
+       iterator.hpp: Likewise.
+       * include/ext/pb_ds/detail/unordered_iterator/
+       const_iterator.hpp: Likewise.
+       * include/ext/pb_ds/detail/unordered_iterator/
+       point_iterator.hpp: Likewise.
+       * include/ext/pb_ds/detail/unordered_iterator/
+       const_point_iterator.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/child_iterator.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/
+       insert_join_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/
+       constructors_destructor_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/
+       const_child_iterator.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/rotate_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/node_iterators.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/internal_node.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/point_iterators.hpp: Likewise.
+       * include/ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/bin_search_tree_/
+       find_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/bin_search_tree_/
+       r_erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/bin_search_tree_/
+       constructors_destructor_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/bin_search_tree_/
+       debug_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/bin_search_tree_/
+       rotate_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/bin_search_tree_/
+       erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/bin_search_tree_/
+       insert_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/bin_search_tree_/
+       node_iterators.hpp: Likewise.
+       * include/ext/pb_ds/detail/bin_search_tree_/
+       point_iterators.hpp: Likewise.
+       * include/ext/pb_ds/detail/bin_search_tree_/
+       split_join_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/bin_search_tree_/
+       iterators_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/gp_hash_table_map_/
+       find_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/gp_hash_table_map_/
+       gp_ht_map_.hpp: Likewise.
+       * include/ext/pb_ds/detail/gp_hash_table_map_/
+       resize_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/gp_hash_table_map_/
+       standard_policies.hpp: Likewise.
+       * include/ext/pb_ds/detail/tree_policy/
+       sample_tree_node_update.hpp: Likewise.
+       * include/ext/pb_ds/detail/basic_tree_policy/
+       null_node_metadata.hpp: Likewise.
+       * include/ext/pb_ds/detail/binary_heap_/const_iterator.hpp: Likewise.
+       * include/ext/pb_ds/detail/binary_heap_/
+       const_point_iterator.hpp: Likewise.
+       * include/ext/pb_ds/detail/binary_heap_/
+       split_join_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/trie_policy/
+       sample_trie_node_update.hpp: Likewise.
+       * include/ext/pb_ds/detail/trie_policy/
+       sample_trie_e_access_traits.hpp: Likewise.
+       * include/ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/pairing_heap_/
+       split_join_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/list_update_policy/
+       counter_lu_metadata.hpp: Likewise.
+       * include/ext/pb_ds/detail/left_child_next_sibling_heap_/
+       trace_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/left_child_next_sibling_heap_/
+       erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/left_child_next_sibling_heap_/
+       null_metadata.hpp: Likewise.
+       * include/ext/pb_ds/detail/left_child_next_sibling_heap_/
+       const_iterator.hpp: Likewise.
+       * include/ext/pb_ds/detail/left_child_next_sibling_heap_/
+       insert_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/left_child_next_sibling_heap_/
+       constructors_destructor_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/left_child_next_sibling_heap_/
+       debug_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/left_child_next_sibling_heap_/
+       iterators_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/left_child_next_sibling_heap_/
+       const_point_iterator.hpp: Likewise.
+       * include/ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/thin_heap_/
+       constructors_destructor_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/thin_heap_/
+       split_join_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/ov_tree_map_/
+       constructors_destructor_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp: Likewise.
+       * include/ext/pb_ds/detail/ov_tree_map_/
+       iterators_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/hash_fn/sample_probe_fn.hpp: Likewise.
+       * include/ext/pb_ds/detail/hash_fn/
+       sample_ranged_probe_fn.hpp: Likewise.
+       * include/ext/pb_ds/detail/hash_fn/sample_range_hashing.hpp: Likewise.
+       * include/ext/pb_ds/detail/hash_fn/
+       sample_ranged_hash_fn.hpp: Likewise.
+       * include/ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/splay_tree_/
+       split_join_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/list_update_map_/
+       trace_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/list_update_map_/
+       erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/list_update_map_/
+       find_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp: Likewise.
+       * include/ext/pb_ds/detail/list_update_map_/
+       constructor_destructor_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/list_update_map_/
+       insert_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/list_update_map_/
+       info_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/list_update_map_/
+       iterators_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/rc_binomial_heap_/
+       erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/rc_binomial_heap_/
+       insert_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/rc_binomial_heap_/
+       debug_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/rb_tree_map_/
+       split_join_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp: Likewise.
+       * include/ext/pb_ds/list_update_policy.hpp: Likewise.
+       * include/ext/pb_ds/exception.hpp: Likewise.
+       * include/ext/pb_ds/tree_policy.hpp: Likewise.
+       * include/ext/pb_ds/tag_and_trait.hpp: Likewise.
+       * include/ext/pb_ds/hash_policy.hpp: Likewise.
+       * include/ext/pb_ds/trie_policy.hpp: Likewise.
+       * include/ext/pb_ds/priority_queue.hpp: Likewise.
+       * include/ext/throw_allocator.h: Likewis: Likewise.e.
+       * include/ext/bitmap_allocator.h
+       * include/ext/rc_string_base.h: Likewise.
+       * include/ext/new_allocator.h: Likewise.
+       * include/ext/codecvt_specializations.h: Likewise.
+       * include/ext/functional: Likewise.: Likewise.
+       * include/ext/array_allocator.h: Likewise.
+       * include/ext/mt_allocator.h: Likewise.
+       * include/ext/sso_string_base.h: Likewise.
+       * include/profile/impl/profiler_trace.h: Likewise.
+       * include/profile/impl/profiler_node.h: Likewise.
+       * include/bits/stl_algobase.h: Likewise.
+       * include/bits/functional_hash.h: Likewise.
+       * include/bits/locale_facets.tcc: Likewise.
+       * include/bits/locale_facets.h: Likewise.
+       * include/bits/stl_iterator_base_types.h: Likewise.
+       * include/bits/move.h: Likewise.
+       * include/bits/boost_concept_check.h: Likewise.
+       * include/bits/basic_string.tcc: Likewise.
+       * include/bits/locale_facets_nonio.tcc: Likewise.
+       * include/bits/fstream.tcc: Likewise.
+       * include/bits/locale_facets_nonio.h: Likewise.
+       * include/c_global/cstdlib: Likewise.
+       * include/c_global/cstdio: Likewise.
+       * include/c_global/ctime: Likewise.
+       * include/c_global/cwchar: Likewise.
+       * include/c_global/cstring
+       * include/tr1/type_traits: Likewise.
+       * include/backward/hash_fun.h: Likewise.
+       * libsupc++/new: Likewise.
+       * libsupc++/initializer_list: Likewise.
+       * testsuite/27_io/basic_ofstream/pthread2.cc: Likewise.
+       * testsuite/27_io/basic_iostream/cons/2020.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/sgetn/wchar_t/1.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/sgetn/char/1.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/overflow/wchar_t/1.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/overflow/char/1.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/sgetc/wchar_t/1.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/sgetc/char/1.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/sputn/wchar_t/1057.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/sputn/wchar_t/1.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/sputn/char/1057.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/sputn/char/1.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/sputc/wchar_t/1057.cc: Likewise.
+       * testsuite/27_io/basic_streambuf/sputc/char/1057.cc: Likewise.
+       * testsuite/27_io/objects/wchar_t/5268.cc: Likewise.
+       * testsuite/27_io/objects/char/9661-1.cc: Likewise.
+       * testsuite/27_io/objects/char/5268.cc: Likewise.
+       * testsuite/27_io/objects/char/10.cc: Likewise.
+       * testsuite/27_io/basic_ios/copyfmt/char/1.cc: Likewise.
+       * testsuite/27_io/basic_ios/copyfmt/char/2.cc: Likewise.
+       * testsuite/27_io/basic_ios/exceptions/char/1.cc: Likewise.
+       * testsuite/27_io/basic_ios/locales/char/1.cc: Likewise.
+       * testsuite/27_io/basic_ios/clear/char/1.cc: Likewise.
+       * testsuite/27_io/basic_ostringstream/pthread3.cc: Likewise.
+       * testsuite/27_io/basic_stringbuf/sputc/wchar_t/1057.cc: Likewise.
+       * testsuite/27_io/basic_stringbuf/sputc/char/1057.cc: Likewise.
+       * testsuite/27_io/basic_stringbuf/sputn/wchar_t/1057.cc: Likewise.
+       * testsuite/27_io/basic_stringbuf/sputn/char/1057.cc: Likewise.
+       * testsuite/27_io/basic_istream/get/wchar_t/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/get/char/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/ignore/wchar_t/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/ignore/char/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/peek/wchar_t/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/peek/char/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/getline/wchar_t/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/getline/char/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_other/wchar_t/
+       exceptions_null.cc
+       * testsuite/27_io/basic_istream/extractors_other/wchar_t/
+       1.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_other/char/
+       exceptions_null.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_other/char/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/cons/3.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_arithmetic/
+       wchar_t/01.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_arithmetic/
+       char/01.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_character/
+       wchar_t/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_character/
+       wchar_t/2.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_character/
+       wchar_t/3.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_character/
+       char/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_character/
+       char/2.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_character/
+       char/3.cc: Likewise.
+       * testsuite/27_io/basic_istream/extractors_character/
+       char/9826.cc: Likewise.
+       * testsuite/27_io/basic_istream/read/wchar_t/1.cc: Likewise.
+       * testsuite/27_io/basic_istream/read/char/1.cc: Likewise.
+       * testsuite/27_io/basic_ostream/inserters_other/wchar_t/
+       exceptions_null.cc: Likewise.
+       * testsuite/27_io/basic_ostream/inserters_other/wchar_t/
+       1.cc: Likewise.
+       * testsuite/27_io/basic_ostream/inserters_other/char/
+       exceptions_null.cc: Likewise.
+       * testsuite/27_io/basic_ostream/inserters_other/char/1.cc: Likewise.
+       * testsuite/27_io/basic_ostream/cons/2020.cc: Likewise.
+       * testsuite/27_io/basic_ostream/sentry/pod/1.cc: Likewise.
+       * testsuite/27_io/basic_ostream/inserters_character/
+       wchar_t/8.cc: Likewise.
+       * testsuite/27_io/basic_ostream/inserters_character/
+       char/8.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/setbuf/char/1.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/sputc/char/1057.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/open/char/1.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/open/char/2.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/open/char/9507.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/imbue/wchar_t/14975-2.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-1.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-2.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-3.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/overflow/wchar_t/11305-4.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/close/wchar_t/12790-3.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/close/char/9964.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/close/char/1.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/close/char/2.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/close/char/12790-3.cc: Likewise.
+       * testsuite/27_io/basic_filebuf/sputn/char/1057.cc: Likewise.
+       * testsuite/24_iterators/ostreambuf_iterator/2.cc: Likewise.
+       * testsuite/18_support/bad_exception/23591_thread-1.c
+       * testsuite/18_support/new_delete_placement.cc: Likewise.
+       * testsuite/18_support/pthread_guard.cc: Likewise.
+       * testsuite/21_strings/basic_string/operations/wchar_t/1.cc: Likewise.
+       * testsuite/21_strings/basic_string/operations/char/1.cc: Likewise.
+       * testsuite/21_strings/basic_string/pthread4.cc: Likewise.
+       * testsuite/21_strings/basic_string/cons/wchar_t/5.cc: Likewise.
+       * testsuite/21_strings/basic_string/cons/char/5.cc: Likewise.
+       * testsuite/30_threads/timed_mutex/cons/assign_neg.cc: Likewise.
+       * testsuite/30_threads/timed_mutex/cons/copy_neg.cc: Likewise.
+       * testsuite/30_threads/recursive_mutex/cons/assign_neg.cc: Likewise.
+       * testsuite/30_threads/recursive_mutex/cons/copy_neg.cc: Likewise.
+       * testsuite/30_threads/mutex/cons/assign_neg.cc: Likewise.
+       * testsuite/30_threads/mutex/cons/copy_neg.cc: Likewise.
+       * testsuite/30_threads/thread/cons/assign_neg.cc: Likewise.
+       * testsuite/30_threads/thread/cons/copy_neg.cc: Likewise.
+       * testsuite/30_threads/recursive_timed_mutex/cons/
+       assign_neg.cc: Likewise.
+       * testsuite/30_threads/recursive_timed_mutex/cons/
+       copy_neg.cc: Likewise.
+       * testsuite/ext/mt_allocator/22309_thread.cc: Likewise.
+       * testsuite/ext/slist/23781.cc: Likewise.
+       * testsuite/ext/rope/pthread7-rope.cc: Likewise.
+       * testsuite/ext/stdio_filebuf/char/10063-2.cc: Likewise.
+       * testsuite/22_locale/ctype/is/wchar_t/1.cc: Likewise.
+       * testsuite/22_locale/ctype/is/char/1.cc: Likewise.
+       * testsuite/22_locale/time_put/put/char/12439_1.cc: Likewise.
+       * testsuite/22_locale/time_put/put/char/12439_3.cc: Likewise.
+       * testsuite/22_locale/locale/cons/2.cc: Likewise.
+       * testsuite/22_locale/locale/cons/12658_thread-1.cc: Likewise.
+       * testsuite/22_locale/locale/cons/29217.cc: Likewise.
+       * testsuite/22_locale/locale/global_locale_objects/14071.cc: Likewise.
+       * testsuite/22_locale/locale/global_locale_objects/2.cc: Likewise.
+       * testsuite/tr1/6_containers/unordered_multimap/
+       requirements/iterator_null_neg.cc: Likewise.
+       * testsuite/tr1/6_containers/unordered_multiset/
+       requirements/iterator_null_neg.cc: Likewise.
+       * testsuite/29_atomics/atomic_address/cons/single_value.cc: Likewise.
+       * testsuite/29_atomics/atomic_address/cons/aggregate.cc: Likewise.
+       * testsuite/23_containers/multimap/23781.cc: Likewise.
+       * testsuite/23_containers/set/23781.cc: Likewise.
+       * testsuite/23_containers/multiset/23781.cc: Likewise.
+       * testsuite/23_containers/list/pthread1.cc: Likewise.
+       * testsuite/23_containers/list/23781.cc: Likewise.
+       * testsuite/23_containers/map/pthread6.cc: Likewise.
+       * testsuite/23_containers/map/23781.cc: Likewise.
+       * testsuite/util/regression/rand/priority_queue/
+       rand_regression_test.hpp: Likewise.
+       * testsuite/util/regression/rand/priority_queue/
+       container_rand_regression_test.tcc: Likewise.
+       * testsuite/util/regression/rand/assoc/
+       rand_regression_test.hpp: Likewise.
+       * testsuite/util/regression/rand/assoc/
+       container_rand_regression_test.tcc: Likewise.
+       * testsuite/util/testsuite_hooks.cc: Likewise.
+       * testsuite/util/testsuite_io.h: Likewise.
+       * testsuite/util/testsuite_iterators.h: Likewise.
+       * testsuite/util/replacement_memory_operators.h: Likewise.
+       * testsuite/util/testsuite_allocator.h: Likewise.
+       * testsuite/util/testsuite_performance.h: Likewise.
+
 2010-06-02  Jonathan Wakely  <jwakely.gcc@gmail.com>
 
        * testsuite/tr1/2_general_utilities/shared_ptr/cons/pointer.cc: Fix
index b7b14a1e4188217e8236645ffcbe1942ca2ee22c..66e31d844cd2db6bdf09335b162dc353e41e482b 100644 (file)
@@ -57,7 +57,7 @@
 #ifndef _BACKWARD_HASH_FUN_H
 #define _BACKWARD_HASH_FUN_H 1
 
-#include <cstddef>
+#include <bits/c++config.h>
 
 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
 
index d450a4717de8ff75e24b283f1fd60aeff7379987..ab71ad67e17d6a53bc8461ae4417dc631b978ce5 100644 (file)
@@ -1,7 +1,7 @@
 // Components for manipulating sequences of characters -*- C++ -*-
 
 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-// 2006, 2007, 2008, 2009
+// 2006, 2007, 2008, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -130,7 +130,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 #endif
        // NB: Not required, but considered best practice.
        if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
-         __throw_logic_error(__N("basic_string::_S_construct NULL not valid"));
+         __throw_logic_error(__N("basic_string::_S_construct null not valid"));
 
        const size_type __dnew = static_cast<size_type>(std::distance(__beg,
                                                                      __end));
index 054fcf27e5e655dfb47baccc330ed50113461944..cffd7fb2d051f2e03f0f90578caddaab91db05b2 100644 (file)
@@ -1,6 +1,7 @@
 // -*- C++ -*-
 
-// Copyright (C) 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -41,7 +42,7 @@
 
 #pragma GCC system_header
 
-#include <cstddef>                // for ptrdiff_t, used next
+#include <bits/c++config.h>
 #include <bits/stl_iterator_base_types.h>    // for traits and tags
 
 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
index 3746696458ac324a961bc6b115642c23dcd1779f..9dc9ac24cd8d473e3c2082ed68f1f7e2e489087d 100644 (file)
@@ -1,7 +1,7 @@
 // Predefined symbols and macros -*- C++ -*-
 
 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-// 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+// 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -376,4 +376,19 @@ _GLIBCXX_END_NAMESPACE
 # endif
 #endif
 
+#ifdef __cplusplus
+
+_GLIBCXX_BEGIN_NAMESPACE(std)
+
+  typedef __SIZE_TYPE__         size_t;
+  typedef __PTRDIFF_TYPE__   ptrdiff_t;
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  typedef decltype(nullptr)  nullptr_t;
+#endif
+
+_GLIBCXX_END_NAMESPACE
+
+#endif // __cplusplus
+
 // End of prewritten config; the discovered settings follow.
index c5f7f8c52af8e712a49402ddbbe8eea7db3c14ee..c498f48caeee6544c9d07b9f7749245842edbc1b 100644 (file)
@@ -64,21 +64,21 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       if (_M_buf_allocated)
        {
          delete [] _M_buf;
-         _M_buf = NULL;
+         _M_buf = 0;
          _M_buf_allocated = false;
        }
       delete [] _M_ext_buf;
-      _M_ext_buf = NULL;
+      _M_ext_buf = 0;
       _M_ext_buf_size = 0;
-      _M_ext_next = NULL;
-      _M_ext_end = NULL;
+      _M_ext_next = 0;
+      _M_ext_end = 0;
     }
 
   template<typename _CharT, typename _Traits>
     basic_filebuf<_CharT, _Traits>::
     basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock),
     _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(),
-    _M_state_last(), _M_buf(NULL), _M_buf_size(BUFSIZ),
+    _M_state_last(), _M_buf(0), _M_buf_size(BUFSIZ),
     _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(), 
     _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false),
     _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0),
@@ -93,7 +93,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
     basic_filebuf<_CharT, _Traits>::
     open(const char* __s, ios_base::openmode __mode)
     {
-      __filebuf_type *__ret = NULL;
+      __filebuf_type *__ret = 0;
       if (!this->is_open())
        {
          _M_file.open(__s, __mode);
@@ -128,7 +128,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
     close()
     {
       if (!this->is_open())
-       return NULL;
+       return 0;
 
       bool __testfail = false;
       {
@@ -167,7 +167,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
        __testfail = true;
 
       if (__testfail)
-       return NULL;
+       return 0;
       else
        return this;
     }
index aaa05aad689c13147fbf282461602bbd7b94f47b..a207ffa6bd0cef56934abc3504e796f7af5a52f0 100644 (file)
@@ -32,7 +32,7 @@
 
 #pragma GCC system_header
 
-#include <cstddef>
+#include <bits/c++config.h>
 #include <bits/stl_function.h>
 
 namespace std
index 2e18f7da8edc949716a0801974ef584d035d4349..79bfd03026dac88dda6318f28905d2fec1ad6ff3 100644 (file)
@@ -1587,12 +1587,13 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
       bool                             _M_allocated;
 
-      __numpunct_cache(size_t __refs = 0) : facet(__refs),
-      _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false),
-      _M_truename(NULL), _M_truename_size(0), _M_falsename(NULL),
-      _M_falsename_size(0), _M_decimal_point(_CharT()),
-      _M_thousands_sep(_CharT()), _M_allocated(false)
-      { }
+      __numpunct_cache(size_t __refs = 0)
+      : facet(__refs), _M_grouping(0), _M_grouping_size(0),
+       _M_use_grouping(false),
+       _M_truename(0), _M_truename_size(0), _M_falsename(0),
+       _M_falsename_size(0), _M_decimal_point(_CharT()),
+       _M_thousands_sep(_CharT()), _M_allocated(false)
+        { }
 
       ~__numpunct_cache();
 
@@ -1657,7 +1658,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
        *  @param  refs  Refcount to pass to the base class.
        */
       explicit
-      numpunct(size_t __refs = 0) : facet(__refs), _M_data(NULL)
+      numpunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
       { _M_initialize_numpunct(); }
 
       /**
@@ -1685,7 +1687,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
        */
       explicit
       numpunct(__c_locale __cloc, size_t __refs = 0)
-      : facet(__refs), _M_data(NULL)
+      : facet(__refs), _M_data(0)
       { _M_initialize_numpunct(__cloc); }
 
       /**
@@ -1841,7 +1843,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
       // For use at construction time only.
       void
-      _M_initialize_numpunct(__c_locale __cloc = NULL);
+      _M_initialize_numpunct(__c_locale __cloc = 0);
     };
 
   template<typename _CharT>
index 1608e2c42daec3a2084f2256855f61ba550b29f1..52bafd36dfe5dc716510b3bd0c1f313db8ab8e0b 100644 (file)
@@ -1,7 +1,7 @@
 // Locale support -*- C++ -*-
 
 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-// 2006, 2007, 2008, 2009
+// 2006, 2007, 2008, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -56,7 +56,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
        const locale::facet** __caches = __loc._M_impl->_M_caches;
        if (!__caches[__i])
          {
-           __numpunct_cache<_CharT>* __tmp = NULL;
+           __numpunct_cache<_CharT>* __tmp = 0;
            __try
              {
                __tmp = new __numpunct_cache<_CharT>;
index a25e0acd2c0322b86e497e5f99d9e189e8b57596..fdc810d12be9cd4b2c34dbe71fd64e669226abd5 100644 (file)
@@ -118,20 +118,20 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       bool                             _M_allocated;
 
       __timepunct_cache(size_t __refs = 0) : facet(__refs),
-      _M_date_format(NULL), _M_date_era_format(NULL), _M_time_format(NULL),
-      _M_time_era_format(NULL), _M_date_time_format(NULL),
-      _M_date_time_era_format(NULL), _M_am(NULL), _M_pm(NULL),
-      _M_am_pm_format(NULL), _M_day1(NULL), _M_day2(NULL), _M_day3(NULL),
-      _M_day4(NULL), _M_day5(NULL), _M_day6(NULL), _M_day7(NULL),
-      _M_aday1(NULL), _M_aday2(NULL), _M_aday3(NULL), _M_aday4(NULL),
-      _M_aday5(NULL), _M_aday6(NULL), _M_aday7(NULL), _M_month01(NULL),
-      _M_month02(NULL), _M_month03(NULL), _M_month04(NULL), _M_month05(NULL),
-      _M_month06(NULL), _M_month07(NULL), _M_month08(NULL), _M_month09(NULL),
-      _M_month10(NULL), _M_month11(NULL), _M_month12(NULL), _M_amonth01(NULL),
-      _M_amonth02(NULL), _M_amonth03(NULL), _M_amonth04(NULL),
-      _M_amonth05(NULL), _M_amonth06(NULL), _M_amonth07(NULL),
-      _M_amonth08(NULL), _M_amonth09(NULL), _M_amonth10(NULL),
-      _M_amonth11(NULL), _M_amonth12(NULL), _M_allocated(false)
+      _M_date_format(0), _M_date_era_format(0), _M_time_format(0),
+      _M_time_era_format(0), _M_date_time_format(0),
+      _M_date_time_era_format(0), _M_am(0), _M_pm(0),
+      _M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0),
+      _M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0),
+      _M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0),
+      _M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0),
+      _M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0),
+      _M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0),
+      _M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0),
+      _M_amonth02(0), _M_amonth03(0), _M_amonth04(0),
+      _M_amonth05(0), _M_amonth06(0), _M_amonth07(0),
+      _M_amonth08(0), _M_amonth09(0), _M_amonth10(0),
+      _M_amonth11(0), _M_amonth12(0), _M_allocated(false)
       { }
 
       ~__timepunct_cache();
@@ -313,7 +313,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
       // For use at construction time only.
       void
-      _M_initialize_timepunct(__c_locale __cloc = NULL);
+      _M_initialize_timepunct(__c_locale __cloc = 0);
     };
 
   template<typename _CharT>
@@ -883,11 +883,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       bool                             _M_allocated;
 
       __moneypunct_cache(size_t __refs = 0) : facet(__refs),
-      _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false),
+      _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false),
       _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
-      _M_curr_symbol(NULL), _M_curr_symbol_size(0),
-      _M_positive_sign(NULL), _M_positive_sign_size(0),
-      _M_negative_sign(NULL), _M_negative_sign_size(0),
+      _M_curr_symbol(0), _M_curr_symbol_size(0),
+      _M_positive_sign(0), _M_positive_sign_size(0),
+      _M_negative_sign(0), _M_negative_sign_size(0),
       _M_frac_digits(0),
       _M_pos_format(money_base::pattern()),
       _M_neg_format(money_base::pattern()), _M_allocated(false)
@@ -955,7 +955,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
        *  @param refs  Passed to the base facet class.
       */
       explicit
-      moneypunct(size_t __refs = 0) : facet(__refs), _M_data(NULL)
+      moneypunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
       { _M_initialize_moneypunct(); }
 
       /**
@@ -983,7 +984,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       */
       explicit
       moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
-      : facet(__refs), _M_data(NULL)
+      : facet(__refs), _M_data(0)
       { _M_initialize_moneypunct(__cloc, __s); }
 
       /**
@@ -1271,8 +1272,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 
       // For use at construction time only.
        void
-       _M_initialize_moneypunct(__c_locale __cloc = NULL,
-                               const char* __name = NULL);
+       _M_initialize_moneypunct(__c_locale __cloc = 0,
+                               const char* __name = 0);
     };
 
   template<typename _CharT, bool _Intl>
index 48a913901e752190b749b07d3857970346e16566..b5c77b9d7c004c075ae968fa8ca3c68a36cf50bd 100644 (file)
@@ -44,7 +44,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
        const locale::facet** __caches = __loc._M_impl->_M_caches;
        if (!__caches[__i])
          {
-           __moneypunct_cache<_CharT, _Intl>* __tmp = NULL;
+           __moneypunct_cache<_CharT, _Intl>* __tmp = 0;
            __try
              {
                __tmp = new __moneypunct_cache<_CharT, _Intl>;
index a137f982bedb4eb7a046734cd5aa19654749867a..98755dc7e57c4ca4fa4fffccf8519bb2e88dfd3a 100644 (file)
@@ -31,7 +31,6 @@
 #define _MOVE_H 1
 
 #include <bits/c++config.h>
-#include <cstddef>
 #include <bits/concept_check.h>
 
 _GLIBCXX_BEGIN_NAMESPACE(std)
index 0489c413b95c34c09ecbb166c653fbba089dc900..fc3047b6bed71f7544738f1c75255121c8f40678 100644 (file)
@@ -58,7 +58,6 @@
 #define _STL_ALGOBASE_H 1
 
 #include <bits/c++config.h>
-#include <cstddef>
 #include <bits/functexcept.h>
 #include <bits/cpp_type_traits.h>
 #include <ext/type_traits.h>
index 07687bd2cd37ab46d00f96e9e8c35bed79dca84a..d934f434e6d0d82b62d57459ef7d4a5b43560990 100644 (file)
@@ -63,7 +63,6 @@
 #pragma GCC system_header
 
 #include <bits/c++config.h>
-#include <cstddef>
 
 _GLIBCXX_BEGIN_NAMESPACE(std)
 
index ce2d310244c994c49f994346ca5d0cd6f438f70d..d9a7383e68d4f1bc6c1b05a1915d982e8f2a5f93 100644 (file)
 
 #include <bits/c++config.h>
 #include <stddef.h>
-
-#ifndef _GLIBCXX_CSTDDEF
-#define _GLIBCXX_CSTDDEF 1
-
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
-  using ::ptrdiff_t;
-  using ::size_t;
-
-_GLIBCXX_END_NAMESPACE
-
-#endif
index f87af196936a65e65c7ae1164e4e5c2606063ef7..b547fbe40b89a6e45fc245ed743b4590495600f6 100644 (file)
@@ -41,7 +41,6 @@
 #pragma GCC system_header
 
 #include <bits/c++config.h>
-#include <cstddef>
 #include <stdio.h>
 
 #ifndef _GLIBCXX_CSTDIO
@@ -151,13 +150,13 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
 
 #if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
   extern "C" int
-  (snprintf)(char * restrict, size_t, const char * restrict, ...) throw ();
+  (snprintf)(char * restrict, std::size_t, const char * restrict, ...) throw ();
   extern "C" int
   (vfscanf)(FILE * restrict, const char * restrict, __gnuc_va_list);
   extern "C" int (vscanf)(const char * restrict, __gnuc_va_list);
   extern "C" int
-  (vsnprintf)(char * restrict, size_t, const char * restrict, __gnuc_va_list)
-  throw ();
+  (vsnprintf)(char * restrict, std::size_t, const char * restrict,
+             __gnuc_va_list) throw ();
   extern "C" int
   (vsscanf)(const char * restrict, const char * restrict, __gnuc_va_list)
   throw ();
index f4ff810cf71e9427c79ad98a33770c99562c7069..da95c0fe56c09b12ef3a9d8ee3e20661ca229deb 100644 (file)
@@ -41,7 +41,6 @@
 #pragma GCC system_header
 
 #include <bits/c++config.h>
-#include <cstddef>
 
 #ifndef _GLIBCXX_CSTDLIB
 #define _GLIBCXX_CSTDLIB 1
index 445202035d58998784d0c74c8b2bef50c51ad096..21721be67ed55867808bcf0837c0a2d80039bc38 100644 (file)
@@ -41,7 +41,6 @@
 #pragma GCC system_header
 
 #include <bits/c++config.h>
-#include <cstddef>
 #include <string.h>
 
 #ifndef _GLIBCXX_CSTRING
index 55f1f069766f96b5381a9d88c91af819e975cb01..f5bb49ccbc9451aa8982b87ff598a06aa1a595f2 100644 (file)
@@ -40,7 +40,7 @@
 
 #pragma GCC system_header
 
-#include <cstddef>
+#include <bits/c++config.h>
 #include <time.h>
 
 #ifndef _GLIBCXX_CTIME
index 537f39a023ba0e668e3b639c569ee41e1b99bce3..b16eb4685720c0787fab599e7446a228211febcc 100644 (file)
@@ -41,7 +41,6 @@
 #pragma GCC system_header
 
 #include <bits/c++config.h>
-#include <cstddef>
 
 #if _GLIBCXX_HAVE_WCHAR_H
 #include <wchar.h>
index 93fed5db6acc8c0d8c193b2139d53548737b6c53..006c432d7bcd4613479f54f36f48169c67adaa97 100644 (file)
 #include <bits/c++config.h>
 #include <stddef.h>
 
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
-  using ::ptrdiff_t;
-  using ::size_t;
-
-_GLIBCXX_END_NAMESPACE
-
 #endif
index a697437a6621db103076c021f4082731375a65a1..4a8acdddb6288cc7865854730de43fc98435113a 100644 (file)
@@ -43,8 +43,6 @@
 #pragma GCC system_header
 
 #include <bits/c++config.h>
-#include <cstddef>
-
 #include <stdio.h>
 
 // Get rid of those macros defined in <stdio.h> in lieu of real functions.
@@ -151,13 +149,13 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
 
 #if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
   extern "C" int
-  (snprintf)(char * restrict, size_t, const char * restrict, ...) throw ();
+  (snprintf)(char * restrict, std::size_t, const char * restrict, ...) throw ();
   extern "C" int
   (vfscanf)(FILE * restrict, const char * restrict, __gnuc_va_list);
   extern "C" int (vscanf)(const char * restrict, __gnuc_va_list);
   extern "C" int
-  (vsnprintf)(char * restrict, size_t, const char * restrict, __gnuc_va_list)
-  throw ();
+  (vsnprintf)(char * restrict, std::size_t, const char * restrict,
+             __gnuc_va_list) throw ();
   extern "C" int
   (vsscanf)(const char * restrict, const char * restrict, __gnuc_va_list)
   throw ();
index c1e3379c12132f952763b3c8aa8d3b88828401b1..734745a67751a4832df6809c8c323d955ab32099 100644 (file)
@@ -43,7 +43,6 @@
 #pragma GCC system_header
 
 #include <bits/c++config.h>
-#include <cstddef>
 
 #if !_GLIBCXX_HOSTED
 // The C standard does not require a freestanding implementation to
index 914365655eca8cdd7953601ceca5467091cd001c..06bf12fba9d2b5c6be17764cc6cfdeba626f087a 100644 (file)
@@ -44,7 +44,6 @@
 #pragma GCC system_header
 
 #include <bits/c++config.h>
-#include <cstddef>
 #include <string.h>
 
 // Get rid of those macros defined in <string.h> in lieu of real functions.
index dca90eb8d88065acdcbd5967cc442ebbbaa19975..459c8fc7b60a8cfc9bbea32d958d487ff6d5a7d7 100644 (file)
@@ -42,7 +42,7 @@
 
 #pragma GCC system_header
 
-#include <cstddef>
+#include <bits/c++config.h>
 #include <time.h>
 
 // Get rid of those macros defined in <time.h> in lieu of real functions.
index 3d503674ed19e3118874278351a06f14dbfa64cb..20c6ca3512aa409db4bfe36c144cc97108f29c75 100644 (file)
@@ -44,7 +44,6 @@
 #pragma GCC system_header
 
 #include <bits/c++config.h>
-#include <cstddef>
 
 #if _GLIBCXX_HAVE_WCHAR_H
 #include <wchar.h>
index b4b43896d04a0d4f9f8df26d85f40197a945bae9..a98ebd84a8d219ece5547b8ff13183d4d379182b 100644 (file)
@@ -338,7 +338,7 @@ namespace __gnu_debug
       const _Error_formatter&
       _M_iterator(const _Iterator& __it, const char* __name = 0)  const
       {
-       if (_M_num_parameters < size_t(__max_parameters))
+       if (_M_num_parameters < std::size_t(__max_parameters))
          _M_parameters[_M_num_parameters++] = _Parameter(__it, __name,
                                                          _Is_iterator());
        return *this;
@@ -347,7 +347,7 @@ namespace __gnu_debug
     const _Error_formatter&
     _M_integer(long __value, const char* __name = 0) const
     {
-      if (_M_num_parameters < size_t(__max_parameters))
+      if (_M_num_parameters < std::size_t(__max_parameters))
        _M_parameters[_M_num_parameters++] = _Parameter(__value, __name);
       return *this;
     }
@@ -355,7 +355,7 @@ namespace __gnu_debug
     const _Error_formatter&
     _M_string(const char* __value, const char* __name = 0) const
     {
-      if (_M_num_parameters < size_t(__max_parameters))
+      if (_M_num_parameters < std::size_t(__max_parameters))
        _M_parameters[_M_num_parameters++] = _Parameter(__value, __name);
       return *this;
     }
@@ -364,7 +364,7 @@ namespace __gnu_debug
       const _Error_formatter&
       _M_sequence(const _Sequence& __seq, const char* __name = 0) const
       {
-       if (_M_num_parameters < size_t(__max_parameters))
+       if (_M_num_parameters < std::size_t(__max_parameters))
          _M_parameters[_M_num_parameters++] = _Parameter(__seq, __name,
                                                          _Is_sequence());
        return *this;
@@ -381,7 +381,7 @@ namespace __gnu_debug
     _M_error() const;
 
   private:
-    _Error_formatter(const char* __file, size_t __line)
+    _Error_formatter(const char* __file, std::size_t __line)
     : _M_file(__file), _M_line(__line), _M_num_parameters(0), _M_text(0),
       _M_max_length(78), _M_column(1), _M_first_line(true), _M_wordwrap(false)
     { _M_get_max_length(); }
@@ -402,19 +402,19 @@ namespace __gnu_debug
     enum { __max_parameters = 9 };
 
     const char*         _M_file;
-    size_t              _M_line;
+    std::size_t         _M_line;
     mutable _Parameter  _M_parameters[__max_parameters];
-    mutable size_t      _M_num_parameters;
+    mutable std::size_t _M_num_parameters;
     mutable const char* _M_text;
-    mutable size_t      _M_max_length;
+    mutable std::size_t _M_max_length;
     enum { _M_indent = 4 } ;
-    mutable size_t      _M_column;
+    mutable std::size_t _M_column;
     mutable bool        _M_first_line;
     mutable bool        _M_wordwrap;
 
   public:
     static _Error_formatter
-    _M_at(const char* __file, size_t __line)
+    _M_at(const char* __file, std::size_t __line)
     { return _Error_formatter(__file, __line); }
   };
 } // namespace __gnu_debug
index a4b1d785844475fa7aeeaa73c4b3e15f828e9a87..237c0e66909744627628bb410401d73abce64971 100644 (file)
@@ -1,6 +1,6 @@
 // Debugging support implementation -*- C++ -*-
 
-// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -31,7 +31,6 @@
 #define _GLIBCXX_DEBUG_FUNCTIONS_H 1
 
 #include <bits/c++config.h>
-#include <cstddef>                       // for ptrdiff_t
 #include <bits/stl_iterator_base_types.h> // for iterator_traits, categories
 #include <bits/cpp_type_traits.h>         // for __is_integer
 
index 36f15fe936cb95fa80af761ea9884ec6fc9031cf..ca4d0d19b0178d55278a4dd49ebdc795c36f33be 100644 (file)
@@ -30,7 +30,7 @@
 #ifndef _ARRAY_ALLOCATOR_H
 #define _ARRAY_ALLOCATOR_H 1
 
-#include <cstddef>
+#include <bits/c++config.h>
 #include <new>
 #include <bits/functexcept.h>
 #include <tr1/array>
@@ -114,7 +114,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
         struct rebind
         { typedef array_allocator<_Tp1, _Array1> other; };
 
-      array_allocator(array_type* __array = NULL) throw() 
+      array_allocator(array_type* __array = 0) throw() 
       : _M_array(__array), _M_used(size_type()) { }
 
       array_allocator(const array_allocator& __o)  throw() 
@@ -122,7 +122,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
 
       template<typename _Tp1, typename _Array1>
         array_allocator(const array_allocator<_Tp1, _Array1>&) throw()
-       : _M_array(NULL), _M_used(size_type()) { }
+       : _M_array(0), _M_used(size_type()) { }
 
       ~array_allocator() throw() { }
 
index 05285f548cc5b09d621e8fbd20d5f85968f7317d..2aa08706c9d57713206090e33e57f076f7461609 100644 (file)
@@ -30,9 +30,8 @@
 #ifndef _BITMAP_ALLOCATOR_H
 #define _BITMAP_ALLOCATOR_H 1
 
-#include <cstddef> // For std::size_t, and ptrdiff_t.
-#include <bits/functexcept.h> // For __throw_bad_alloc().
 #include <utility> // For std::pair.
+#include <bits/functexcept.h> // For __throw_bad_alloc().
 #include <functional> // For greater_equal, and less_equal.
 #include <new> // For operator new.
 #include <debug/debug.h> // _GLIBCXX_DEBUG_ASSERT
index 89adb3f20d48159df8f89b93405003f3ee57307b..53295891bac42a2ca61290414c22ad7b675524b2 100644 (file)
@@ -1,7 +1,8 @@
 // Locale support (codecvt) -*- C++ -*-
 
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
-//  Free Software Foundation, Inc.
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+// 2008, 2009, 2010
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -381,7 +382,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
          // Argument list for iconv specifies a byte sequence. Thus,
          // all to/from arrays must be brutally casted to char*.
          char* __cto = reinterpret_cast<char*>(__to);
-         size_t __conv = __iconv_adaptor(iconv,__desc, NULL, NULL,
+         size_t __conv = __iconv_adaptor(iconv,__desc, 0, 0,
                                           &__cto, &__tlen); 
          
          if (__conv != size_t(-1))
index 546b9c68d6ce581a636ae2eeb94870f88aba160d..7cf6a45a0a307a8b2c437083a7166fb896558ad7 100644 (file)
@@ -1,6 +1,6 @@
 // Functional extensions -*- C++ -*-
 
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -60,7 +60,6 @@
 #pragma GCC system_header
 
 #include <functional>
-#include <cstddef>
 
 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
 
index 8fdb2f6393b5f09cfa756a34205196f6b1ee322c..1f6561db464accfce64091c11f351d2021bd7fd8 100644 (file)
@@ -154,11 +154,11 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
 
     explicit 
     __pool_base() 
-    : _M_options(_Tune()), _M_binmap(NULL), _M_init(false) { }
+    : _M_options(_Tune()), _M_binmap(0), _M_init(false) { }
 
     explicit 
     __pool_base(const _Tune& __options)
-    : _M_options(__options), _M_binmap(NULL), _M_init(false) { }
+    : _M_options(__options), _M_binmap(0), _M_init(false) { }
 
   private:
     explicit 
@@ -235,10 +235,10 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
       { }
 
       explicit __pool() 
-      : _M_bin(NULL), _M_bin_size(1) { }
+      : _M_bin(0), _M_bin_size(1) { }
 
       explicit __pool(const __pool_base::_Tune& __tune) 
-      : __pool_base(__tune), _M_bin(NULL), _M_bin_size(1) { }
+      : __pool_base(__tune), _M_bin(0), _M_bin_size(1) { }
 
     private:
       // An "array" of bin_records each of which represents a specific
@@ -358,12 +358,12 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
       _M_get_thread_id();
 
       explicit __pool() 
-      : _M_bin(NULL), _M_bin_size(1), _M_thread_freelist(NULL
+      : _M_bin(0), _M_bin_size(1), _M_thread_freelist(0
       { }
 
       explicit __pool(const __pool_base::_Tune& __tune) 
-      : __pool_base(__tune), _M_bin(NULL), _M_bin_size(1), 
-      _M_thread_freelist(NULL
+      : __pool_base(__tune), _M_bin(0), _M_bin_size(1), 
+       _M_thread_freelist(0
       { }
 
     private:
index beaddddf9eed6a3e78faf97271fef8f5f801fc40..5450565420712b63f6081f501912be3af6e7a78d 100644 (file)
@@ -30,6 +30,7 @@
 #ifndef _NEW_ALLOCATOR_H
 #define _NEW_ALLOCATOR_H 1
 
+#include <bits/c++config.h>
 #include <new>
 #include <bits/functexcept.h>
 #include <bits/move.h>
index dca953b49116ab2fb65e2d93d9d7eb0bc39688bc..9cec3b72c5427a95a247fc34a0fd99dbe871dfd6 100644 (file)
@@ -41,6 +41,7 @@
 #ifndef PB_DS_ASSOC_CNTNR_HPP
 #define PB_DS_ASSOC_CNTNR_HPP
 
+#include <bits/c++config.h>
 #include <ext/typelist.h>
 #include <ext/pb_ds/tag_and_trait.hpp>
 #include <ext/pb_ds/detail/standard_policies.hpp>
index 757b90956deec7f196bc7f83c231d1bdfe08d3d5..d9cc2dbfc4403edf85b03b6692252355f8753c24 100644 (file)
@@ -38,8 +38,8 @@
  * Contains an implementation class for tree-like classes.
  */
 
-#ifndef PB_DS_NULL_NODE_METADATA_HPP
-#define PB_DS_NULL_NODE_METADATA_HPP
+#ifndef PB_DS_0_NODE_METADATA_HPP
+#define PB_DS_0_NODE_METADATA_HPP
 
 #include <ext/pb_ds/detail/types_traits.hpp>
 
index 925d204dc6b4ac20a63eaea3f5141b8384bafca2..b9f80e960aa6e5d243aef915b72405164f47ca89 100644 (file)
@@ -92,7 +92,7 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
     __try
       {
         m_p_head->m_p_parent = recursive_copy_node(other.m_p_head->m_p_parent);
-        if (m_p_head->m_p_parent != NULL)
+        if (m_p_head->m_p_parent != 0)
          m_p_head->m_p_parent->m_p_parent = m_p_head;
         m_size = other.m_size;
         initialize_min_max();
@@ -142,7 +142,7 @@ void
 PB_DS_CLASS_C_DEC::
 initialize()
 {
-  m_p_head->m_p_parent = NULL;
+  m_p_head->m_p_parent = 0;
   m_p_head->m_p_left = m_p_head;
   m_p_head->m_p_right = m_p_head;
   m_size = 0;
@@ -153,8 +153,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 recursive_copy_node(const node_pointer p_nd)
 {
-  if (p_nd == NULL)
-    return (NULL);
+  if (p_nd == 0)
+    return (0);
 
   node_pointer p_ret = s_node_allocator.allocate(1);
   __try
@@ -167,7 +167,7 @@ recursive_copy_node(const node_pointer p_nd)
       __throw_exception_again;
     }
 
-  p_ret->m_p_left = p_ret->m_p_right = NULL;
+  p_ret->m_p_left = p_ret->m_p_right = 0;
 
   __try
     {
@@ -180,10 +180,10 @@ recursive_copy_node(const node_pointer p_nd)
       __throw_exception_again;
     }
 
-  if (p_ret->m_p_left != NULL)
+  if (p_ret->m_p_left != 0)
     p_ret->m_p_left->m_p_parent = p_ret;
 
-  if (p_ret->m_p_right != NULL)
+  if (p_ret->m_p_right != 0)
     p_ret->m_p_right->m_p_parent = p_ret;
 
   _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_ret);)
@@ -195,7 +195,7 @@ void
 PB_DS_CLASS_C_DEC::
 initialize_min_max()
 {
-  if (m_p_head->m_p_parent == NULL)
+  if (m_p_head->m_p_parent == 0)
     {
       m_p_head->m_p_left = m_p_head->m_p_right = m_p_head;
       return;
@@ -203,14 +203,14 @@ initialize_min_max()
 
   {
     node_pointer p_min = m_p_head->m_p_parent;
-    while (p_min->m_p_left != NULL)
+    while (p_min->m_p_left != 0)
       p_min = p_min->m_p_left;
     m_p_head->m_p_left = p_min;
   }
 
   {
     node_pointer p_max = m_p_head->m_p_parent;
-    while (p_max->m_p_right != NULL)
+    while (p_max->m_p_right != 0)
       p_max = p_max->m_p_right;
     m_p_head->m_p_right = p_max;
   }
index e3447bd4bec248433ef2a4ea7aae4db15af9ecc7..e1013e78f1b7c8596c0e4b98409fe9789e91360e 100644 (file)
@@ -49,7 +49,7 @@ assert_valid() const
   assert_consistent_with_debug_base();
   assert_size();
   assert_iterators();
-  if (m_p_head->m_p_parent == NULL)
+  if (m_p_head->m_p_parent == 0)
     {
       _GLIBCXX_DEBUG_ASSERT(m_size == 0);
     }
@@ -64,8 +64,8 @@ void
 PB_DS_CLASS_C_DEC::
 structure_only_assert_valid() const
 {
-  _GLIBCXX_DEBUG_ASSERT(m_p_head != NULL);
-  if (m_p_head->m_p_parent == NULL)
+  _GLIBCXX_DEBUG_ASSERT(m_p_head != 0);
+  if (m_p_head->m_p_parent == 0)
     {
       _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_left == m_p_head);
       _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_right == m_p_head);
@@ -77,7 +77,7 @@ structure_only_assert_valid() const
       _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_right != m_p_head);
     }
 
-  if (m_p_head->m_p_parent != NULL)
+  if (m_p_head->m_p_parent != 0)
     assert_node_consistent(m_p_head->m_p_parent);
   assert_min();
   assert_max();
@@ -96,8 +96,8 @@ typename PB_DS_CLASS_C_DEC::node_consistent_t
 PB_DS_CLASS_C_DEC::
 assert_node_consistent_(const node_pointer p_nd) const
 {
-  if (p_nd == NULL)
-    return (std::make_pair((const_pointer)NULL,(const_pointer)NULL));
+  if (p_nd == 0)
+    return (std::make_pair((const_pointer)0,(const_pointer)0));
 
   assert_node_consistent_with_left(p_nd);
   assert_node_consistent_with_right(p_nd);
@@ -105,18 +105,18 @@ assert_node_consistent_(const node_pointer p_nd) const
   const std::pair<const_pointer, const_pointer>
     l_range = assert_node_consistent_(p_nd->m_p_left);
 
-  if (l_range.second != NULL)
+  if (l_range.second != 0)
     _GLIBCXX_DEBUG_ASSERT(Cmp_Fn::operator()(PB_DS_V2F(*l_range.second),
                                             PB_DS_V2F(p_nd->m_value)));
 
   const std::pair<const_pointer, const_pointer>
     r_range = assert_node_consistent_(p_nd->m_p_right);
 
-  if (r_range.first != NULL)
+  if (r_range.first != 0)
     _GLIBCXX_DEBUG_ASSERT(Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value),
                                             PB_DS_V2F(*r_range.first)));
 
-  return (std::make_pair((l_range.first != NULL)? l_range.first :& p_nd->m_value,(r_range.second != NULL)? r_range.second :& p_nd->m_value));
+  return (std::make_pair((l_range.first != 0)? l_range.first :& p_nd->m_value,(r_range.second != 0)? r_range.second :& p_nd->m_value));
 }
 
 PB_DS_CLASS_T_DEC
@@ -124,7 +124,7 @@ void
 PB_DS_CLASS_C_DEC::
 assert_node_consistent_with_left(const node_pointer p_nd) const
 {
-  if (p_nd->m_p_left == NULL)
+  if (p_nd->m_p_left == 0)
     return;
   _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_left->m_p_parent == p_nd);
   _GLIBCXX_DEBUG_ASSERT(!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value),
@@ -136,7 +136,7 @@ void
 PB_DS_CLASS_C_DEC::
 assert_node_consistent_with_right(const node_pointer p_nd) const
 {
-  if (p_nd->m_p_right == NULL)
+  if (p_nd->m_p_right == 0)
     return;
   _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_right->m_p_parent == p_nd);
   _GLIBCXX_DEBUG_ASSERT(!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_p_right->m_value),
@@ -156,13 +156,13 @@ void
 PB_DS_CLASS_C_DEC::
 assert_min_imp(const node_pointer p_nd) const
 {
-  if (p_nd == NULL)
+  if (p_nd == 0)
     {
       _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_left == m_p_head);
       return;
     }
 
-  if (p_nd->m_p_left == NULL)
+  if (p_nd->m_p_left == 0)
     {
       _GLIBCXX_DEBUG_ASSERT(p_nd == m_p_head->m_p_left);
       return;
@@ -183,13 +183,13 @@ void
 PB_DS_CLASS_C_DEC::
 assert_max_imp(const node_pointer p_nd) const
 {
-  if (p_nd == NULL)
+  if (p_nd == 0)
     {
       _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_right == m_p_head);
       return;
     }
 
-  if (p_nd->m_p_right == NULL)
+  if (p_nd->m_p_right == 0)
     {
       _GLIBCXX_DEBUG_ASSERT(p_nd == m_p_head->m_p_right);
       return;
@@ -254,7 +254,7 @@ void
 PB_DS_CLASS_C_DEC::
 assert_consistent_with_debug_base(const node_pointer p_nd) const
 {
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return;
   debug_base::check_key_exists(PB_DS_V2F(p_nd->m_value));
   assert_consistent_with_debug_base(p_nd->m_p_left);
index a000c744cc3565e8ee0fd05ff464337c274d305d..a050a4be7b16af893cadef655047cf61179fdabb 100644 (file)
@@ -106,7 +106,7 @@ void
 PB_DS_CLASS_C_DEC::
 clear_imp(node_pointer p_nd)
 {
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return;
 
   clear_imp(p_nd->m_p_left);
index 413304b80a09a03a7ce3a4f6e384f5af4bf3bcd9..74af48a73277a2fbe22fd345f90dd350c995bdc9 100644 (file)
@@ -46,7 +46,7 @@ lower_bound(const_key_reference r_key) const
   node_pointer p_pot = m_p_head;
   node_pointer p_nd = m_p_head->m_p_parent;
 
-  while (p_nd != NULL)
+  while (p_nd != 0)
     if (Cmp_Fn::operator()(
                           PB_DS_V2F(p_nd->m_value),
                           r_key))
@@ -69,7 +69,7 @@ lower_bound(const_key_reference r_key)
   node_pointer p_pot = m_p_head;
   node_pointer p_nd = m_p_head->m_p_parent;
 
-  while (p_nd != NULL)
+  while (p_nd != 0)
     if (Cmp_Fn::operator()(
                           PB_DS_V2F(p_nd->m_value),
                           r_key))
@@ -92,7 +92,7 @@ upper_bound(const_key_reference r_key) const
   node_pointer p_pot = m_p_head;
   node_pointer p_nd = m_p_head->m_p_parent;
 
-  while (p_nd != NULL)
+  while (p_nd != 0)
     if (Cmp_Fn::operator()(r_key,
                           PB_DS_V2F(p_nd->m_value)))
       {
@@ -114,7 +114,7 @@ upper_bound(const_key_reference r_key)
   node_pointer p_pot = m_p_head;
   node_pointer p_nd = m_p_head->m_p_parent;
 
-  while (p_nd != NULL)
+  while (p_nd != 0)
     if (Cmp_Fn::operator()(r_key,
                           PB_DS_V2F(p_nd->m_value)))
       {
@@ -138,7 +138,7 @@ find(const_key_reference r_key)
     node_pointer p_pot = m_p_head;
   node_pointer p_nd = m_p_head->m_p_parent;
 
-  while (p_nd != NULL)
+  while (p_nd != 0)
     if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key))
       {
        p_pot = p_nd;
@@ -164,7 +164,7 @@ find(const_key_reference r_key) const
     node_pointer p_pot = m_p_head;
   node_pointer p_nd = m_p_head->m_p_parent;
 
-  while (p_nd != NULL)
+  while (p_nd != 0)
     if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key))
       {
        p_pot = p_nd;
index 3abf0a08d3c86932f457ee2583027a938bc8674c..6714c6f10bee8f2d303ea68dd9cddbda0c18aa99 100644 (file)
@@ -53,7 +53,7 @@ insert_leaf(const_reference r_value)
   node_pointer p_nd = m_p_head->m_p_parent;
   node_pointer p_pot = m_p_head;
 
-  while (p_nd != NULL)
+  while (p_nd != 0)
     if (!Cmp_Fn::operator()(
                            PB_DS_V2F(p_nd->m_value),
                            PB_DS_V2F(r_value)))
@@ -86,12 +86,12 @@ insert_leaf(const_reference r_value)
                                                          PB_DS_V2F(r_value)));
 
   p_nd = p_pot->m_p_left;
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return (std::make_pair(
                           insert_leaf_new(r_value, p_pot, true),
                           true));
 
-  while (p_nd->m_p_right != NULL)
+  while (p_nd->m_p_right != 0)
     p_nd = p_nd->m_p_right;
 
   return (std::make_pair(
@@ -109,7 +109,7 @@ insert_leaf_new(const_reference r_value, node_pointer p_nd, bool left_nd)
 
   if (left_nd)
     {
-      _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_left == NULL);
+      _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_left == 0);
       _GLIBCXX_DEBUG_ASSERT(Cmp_Fn::operator()(
                                          PB_DS_V2F(r_value),
                                          PB_DS_V2F(p_nd->m_value)));
@@ -121,7 +121,7 @@ insert_leaf_new(const_reference r_value, node_pointer p_nd, bool left_nd)
     }
   else
     {
-      _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_right == NULL);
+      _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_right == 0);
       _GLIBCXX_DEBUG_ASSERT(Cmp_Fn::operator()(
                                          PB_DS_V2F(p_nd->m_value),
                                          PB_DS_V2F(r_value)));
@@ -134,7 +134,7 @@ insert_leaf_new(const_reference r_value, node_pointer p_nd, bool left_nd)
 
   p_new_nd->m_p_parent = p_nd;
 
-  p_new_nd->m_p_left = p_new_nd->m_p_right = NULL;
+  p_new_nd->m_p_left = p_new_nd->m_p_right = 0;
 
   _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_nd));
 
@@ -159,7 +159,7 @@ insert_imp_empty(const_reference r_value)
 
   p_new_node->m_p_parent = m_p_head;
 
-  p_new_node->m_p_left = p_new_node->m_p_right = NULL;
+  p_new_node->m_p_left = p_new_node->m_p_right = 0;
 
   _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(
                                            PB_DS_V2F(r_value)));
@@ -184,7 +184,7 @@ get_new_node_for_leaf_insert(const_reference r_val, false_type)
 
   cond.set_no_action();
 
-  p_new_nd->m_p_left = p_new_nd->m_p_right = NULL;
+  p_new_nd->m_p_left = p_new_nd->m_p_right = 0;
 
   ++m_size;
 
@@ -202,7 +202,7 @@ get_new_node_for_leaf_insert(const_reference r_val, true_type)
                          static_cast<const void* >(&p_new_nd->m_value)))
     typename node::value_type(r_val);
 
-  p_new_nd->m_p_left = p_new_nd->m_p_right = NULL;
+  p_new_nd->m_p_left = p_new_nd->m_p_right = 0;
 
   ++m_size;
 
index ed7f1b172c8b4260849645d62734c5c2eb346eae..e20a4134a8bd8c4353edd475ba0450b9c4772d2a 100644 (file)
@@ -123,7 +123,7 @@ inline typename PB_DS_CLASS_C_DEC::const_node_iterator
 PB_DS_CLASS_C_DEC::
 node_end() const
 {
-  return (const_node_iterator(NULL));
+  return (const_node_iterator(0));
 }
 
 PB_DS_CLASS_T_DEC
@@ -131,6 +131,6 @@ inline typename PB_DS_CLASS_C_DEC::node_iterator
 PB_DS_CLASS_C_DEC::
 node_end()
 {
-  return (node_iterator(NULL));
+  return (node_iterator(0));
 }
 
index 365f02b6ef84aa25b04516f65686d4e45f350c04..284c0e9bcc9fed7c8a8e450f49b670d629d4ece5 100644 (file)
@@ -105,7 +105,7 @@ namespace __gnu_pbds
       */
 
       inline
-      bin_search_tree_const_node_it_(const node_pointer p_nd = NULL) : m_p_nd(const_cast<node_pointer>(p_nd))
+      bin_search_tree_const_node_it_(const node_pointer p_nd = 0) : m_p_nd(const_cast<node_pointer>(p_nd))
       { }
 
       // Access.
@@ -197,7 +197,7 @@ namespace __gnu_pbds
       */
 
       inline
-      bin_search_tree_node_it_(const node_pointer p_nd = NULL) : PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC(
+      bin_search_tree_node_it_(const node_pointer p_nd = 0) : PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC(
                                                                                                            const_cast<node_pointer>(p_nd))
       { }
 
index bb249e0705729bda6b0a4155b7af8fb630812af5..5bf3f229f5d1dd70ceb3944121fcb59e571c4202 100644 (file)
@@ -124,7 +124,7 @@ namespace __gnu_pbds
     public:
 
       inline
-      bin_search_tree_const_it_(const Node_Pointer p_nd = NULL
+      bin_search_tree_const_it_(const Node_Pointer p_nd = 0
       : m_p_nd(const_cast<Node_Pointer>(p_nd))
       { }
 
@@ -152,14 +152,14 @@ namespace __gnu_pbds
       inline const_pointer
       operator->() const
       {
-       _GLIBCXX_DEBUG_ASSERT(m_p_nd != NULL);
+       _GLIBCXX_DEBUG_ASSERT(m_p_nd != 0);
        return &m_p_nd->m_value;
       }
 
       inline const_reference
       operator*() const
       {
-       _GLIBCXX_DEBUG_ASSERT(m_p_nd != NULL);
+       _GLIBCXX_DEBUG_ASSERT(m_p_nd != 0);
        return m_p_nd->m_value;
       }
 
@@ -182,7 +182,7 @@ namespace __gnu_pbds
       inline PB_DS_TREE_CONST_IT_C_DEC& 
       operator++()
       {
-       _GLIBCXX_DEBUG_ASSERT(m_p_nd != NULL);
+       _GLIBCXX_DEBUG_ASSERT(m_p_nd != 0);
        inc(integral_constant<int,Is_Forward_Iterator>());
        return *this;
       }
@@ -225,10 +225,10 @@ namespace __gnu_pbds
            return;
          }
 
-       if (m_p_nd->m_p_right != NULL)
+       if (m_p_nd->m_p_right != 0)
          {
            m_p_nd = m_p_nd->m_p_right;
-           while (m_p_nd->m_p_left != NULL)
+           while (m_p_nd->m_p_left != 0)
              m_p_nd = m_p_nd->m_p_left;
            return;
          }
@@ -257,10 +257,10 @@ namespace __gnu_pbds
            return;
          }
 
-       if (m_p_nd->m_p_left != NULL)
+       if (m_p_nd->m_p_left != 0)
          {
            Node_Pointer p_y = m_p_nd->m_p_left;
-           while (p_y->m_p_right != NULL)
+           while (p_y->m_p_right != 0)
              p_y = p_y->m_p_right;
            m_p_nd = p_y;
            return;
@@ -297,7 +297,7 @@ namespace __gnu_pbds
     public:
 
       inline
-      bin_search_tree_it_(const Node_Pointer p_nd = NULL
+      bin_search_tree_it_(const Node_Pointer p_nd = 0
       : PB_DS_TREE_CONST_IT_C_DEC((Node_Pointer)p_nd)
       { }
 
@@ -325,14 +325,14 @@ namespace __gnu_pbds
       inline typename PB_DS_TREE_CONST_IT_C_DEC::pointer
       operator->() const
       {
-       _GLIBCXX_DEBUG_ASSERT(base_it_type::m_p_nd != NULL);
+       _GLIBCXX_DEBUG_ASSERT(base_it_type::m_p_nd != 0);
        return &base_it_type::m_p_nd->m_value;
       }
 
       inline typename PB_DS_TREE_CONST_IT_C_DEC::reference
       operator*() const
       {
-       _GLIBCXX_DEBUG_ASSERT(base_it_type::m_p_nd != NULL);
+       _GLIBCXX_DEBUG_ASSERT(base_it_type::m_p_nd != 0);
        return base_it_type::m_p_nd->m_value;
       }
 
index 667ef84704fa177403c21696b3b1beb401d5e20e..76c543f149ad14b40d4a302db5fe19c48492bc87 100644 (file)
@@ -106,7 +106,7 @@ void
 PB_DS_CLASS_C_DEC::
 clear_imp(node_pointer p_nd)
 {
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return;
 
   clear_imp(p_nd->m_p_left);
index 0598657fe04ed51247e6c599560ca2569603c55c..b21e98102df95aa1ff7888712f5590e599ca0cd9 100644 (file)
@@ -47,7 +47,7 @@ rotate_left(node_pointer p_x)
 
   p_x->m_p_right = p_y->m_p_left;
 
-  if (p_y->m_p_left != NULL)
+  if (p_y->m_p_left != 0)
     p_y->m_p_left->m_p_parent = p_x;
 
   p_y->m_p_parent = p_x->m_p_parent;
@@ -78,7 +78,7 @@ rotate_right(node_pointer p_x)
 
   p_x->m_p_left = p_y->m_p_right;
 
-  if (p_y->m_p_right != NULL)
+  if (p_y->m_p_right != 0)
     p_y->m_p_right->m_p_parent = p_x;
 
   p_y->m_p_parent = p_x->m_p_parent;
@@ -131,7 +131,7 @@ apply_update(node_pointer p_nd, Node_Update_*  /*p_update*/)
 {
   node_update::operator()(
                           node_iterator(p_nd),
-                          const_node_iterator(static_cast<node_pointer>(NULL)));
+                          const_node_iterator(static_cast<node_pointer>(0)));
 }
 
 PB_DS_CLASS_T_DEC
index 9d2bd6d742debae82f560149cbac6784587067ea..2c027f6ab985bb6a8ca10f604fa01f058f31246a 100644 (file)
@@ -139,7 +139,7 @@ typename PB_DS_CLASS_C_DEC::size_type
 PB_DS_CLASS_C_DEC::
 recursive_count(node_pointer p) const
 {
-  if (p == NULL)
+  if (p == 0)
     return 0;
   return 1 + recursive_count(p->m_p_left) + recursive_count(p->m_p_right);
 }
index 9cb13f99cca9804a22be5fbd751c60e2667d63f0..76cf80bd54432deb621c87302f2ff91f5fab80b4 100644 (file)
@@ -125,7 +125,7 @@ namespace __gnu_pbds
       inline PB_DS_CLASS_C_DEC& 
       operator++()
       {
-       _GLIBCXX_DEBUG_ASSERT(base_type::m_p_e != NULL);
+       _GLIBCXX_DEBUG_ASSERT(base_type::m_p_e != 0);
        inc();
        return *this;
       }
index d4013db16fe0ddb71e3755f439035a8c50b558f8..ab5efe2bb64537f947867ab8d513cbcdc34ed2d1 100644 (file)
@@ -92,7 +92,7 @@ namespace __gnu_pbds
 
       // Default constructor.
       inline
-      binary_heap_const_point_iterator_() : m_p_e(NULL) { }
+      binary_heap_const_point_iterator_() : m_p_e(0) { }
 
       // Copy constructor.
       inline
@@ -104,7 +104,7 @@ namespace __gnu_pbds
       inline const_pointer
       operator->() const
       {
-       _GLIBCXX_DEBUG_ASSERT(m_p_e != NULL);
+       _GLIBCXX_DEBUG_ASSERT(m_p_e != 0);
        return to_ptr(integral_constant<int, Simple>());
       }
 
@@ -112,7 +112,7 @@ namespace __gnu_pbds
       inline const_reference
       operator*() const
       {
-       _GLIBCXX_DEBUG_ASSERT(m_p_e != NULL);
+       _GLIBCXX_DEBUG_ASSERT(m_p_e != 0);
        return *to_ptr(integral_constant<int, Simple>());
       }
 
index 04b7d548f2ec4e8c22fb911a44354a53aff309f4..dfceb689132943b6fdda62421d987c3affe5c369 100644 (file)
@@ -68,8 +68,8 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other)
   const size_type other_actual_size =
     other.get_new_size_for_arbitrary(ersd);
 
-  entry_pointer a_entries = NULL;
-  entry_pointer a_other_entries = NULL;
+  entry_pointer a_entries = 0;
+  entry_pointer a_other_entries = 0;
 
   __try
     {
@@ -79,10 +79,10 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other)
     }
   __catch(...)
     {
-      if (a_entries != NULL)
+      if (a_entries != 0)
        s_entry_allocator.deallocate(a_entries, actual_size);
 
-      if (a_other_entries != NULL)
+      if (a_other_entries != 0)
        s_entry_allocator.deallocate(a_other_entries, other_actual_size);
 
       __throw_exception_again;
@@ -128,8 +128,8 @@ join(PB_DS_CLASS_C_DEC& other)
   const size_type len = m_size + other.m_size;
   const size_type actual_size = resize_policy::get_new_size_for_arbitrary(len);
 
-  entry_pointer a_entries = NULL;
-  entry_pointer a_other_entries = NULL;
+  entry_pointer a_entries = 0;
+  entry_pointer a_other_entries = 0;
 
   __try
     {
@@ -138,10 +138,10 @@ join(PB_DS_CLASS_C_DEC& other)
     }
   __catch(...)
     {
-      if (a_entries != NULL)
+      if (a_entries != 0)
        s_entry_allocator.deallocate(a_entries, actual_size);
 
-      if (a_other_entries != NULL)
+      if (a_other_entries != 0)
        s_entry_allocator.deallocate(a_other_entries, resize_policy::min_size);
 
       __throw_exception_again;
index 274c93378fd3130eed4aab9262794fb0021efff8..983df099dd7db417060f1bf5f12e6c23d005b601 100644 (file)
@@ -53,7 +53,7 @@ copy_from_range(It first_it, It last_it)
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 binomial_heap_base_() :
-  m_p_max(NULL)
+  m_p_max(0)
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid(false);)
     }
@@ -62,7 +62,7 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 binomial_heap_base_(const Cmp_Fn& r_cmp_fn) :
   PB_DS_BASE_C_DEC(r_cmp_fn),
-  m_p_max(NULL)
+  m_p_max(0)
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid(false);)
     }
@@ -71,7 +71,7 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 binomial_heap_base_(const PB_DS_CLASS_C_DEC& other) :
   PB_DS_BASE_C_DEC(other),
-  m_p_max(NULL)
+  m_p_max(0)
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid(false);)
     }
index 9a07f0e7d5174298eb7182e75fcfb4a1bcf50da7..1ccee551402b3fa47a2c7c76593d61087be87911 100644 (file)
@@ -55,9 +55,9 @@ void
 PB_DS_CLASS_C_DEC::
 assert_max() const
 {
-  if (m_p_max == NULL)
+  if (m_p_max == 0)
     return;
-  _GLIBCXX_DEBUG_ASSERT(base_type::parent(m_p_max) == NULL);
+  _GLIBCXX_DEBUG_ASSERT(base_type::parent(m_p_max) == 0);
   for (const_iterator it = base_type::begin(); it != base_type::end(); ++it)
     _GLIBCXX_DEBUG_ASSERT(!Cmp_Fn::operator()(m_p_max->m_value,
                                              it.m_p_nd->m_value));
@@ -71,14 +71,14 @@ assert_node_consistent(const_node_pointer p_nd, bool strictly_binomial,
 {
   _GLIBCXX_DEBUG_ASSERT(increasing || strictly_binomial);
   base_type::assert_node_consistent(p_nd, false);
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return;
   _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata == base_type::degree(p_nd));
   _GLIBCXX_DEBUG_ASSERT(base_type::size_under_node(p_nd) ==
                   static_cast<size_type>(1 << p_nd->m_metadata));
   assert_node_consistent(p_nd->m_p_next_sibling, strictly_binomial, increasing);
   assert_node_consistent(p_nd->m_p_l_child, true, false);
-  if (p_nd->m_p_next_sibling != NULL)
+  if (p_nd->m_p_next_sibling != 0)
     {
       if (increasing)
        {
index a4cf90c20f18357220f80b17acba6ba8700a949a..d6ead1e51c3ae63dfa1248e1737ddc1fbc3d98b2 100644 (file)
@@ -46,10 +46,10 @@ pop()
   _GLIBCXX_DEBUG_ONLY(assert_valid(true);)
     _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
 
-  if (m_p_max == NULL)
+  if (m_p_max == 0)
     find_max();
 
-  _GLIBCXX_DEBUG_ASSERT(m_p_max != NULL);
+  _GLIBCXX_DEBUG_ASSERT(m_p_max != 0);
 
   node_pointer p_nd = m_p_max;
 
@@ -57,7 +57,7 @@ pop()
 
   base_type::actual_erase_node(p_nd);
 
-  m_p_max = NULL;
+  m_p_max = 0;
 
   _GLIBCXX_DEBUG_ONLY(assert_valid(true);)
     }
@@ -67,33 +67,33 @@ void
 PB_DS_CLASS_C_DEC::
 remove_parentless_node(node_pointer p_nd)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
-  _GLIBCXX_DEBUG_ASSERT(base_type::parent(p_nd) == NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  _GLIBCXX_DEBUG_ASSERT(base_type::parent(p_nd) == 0);
 
   node_pointer p_cur_root = p_nd == base_type::m_p_root?
     p_nd->m_p_next_sibling :
     base_type::m_p_root;
 
-  if (p_cur_root != NULL)
-    p_cur_root->m_p_prev_or_parent = NULL;
+  if (p_cur_root != 0)
+    p_cur_root->m_p_prev_or_parent = 0;
 
-  if (p_nd->m_p_prev_or_parent != NULL)
+  if (p_nd->m_p_prev_or_parent != 0)
     p_nd->m_p_prev_or_parent->m_p_next_sibling = p_nd->m_p_next_sibling;
 
-  if (p_nd->m_p_next_sibling != NULL)
+  if (p_nd->m_p_next_sibling != 0)
     p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
 
   node_pointer p_child = p_nd->m_p_l_child;
 
-  if (p_child != NULL)
+  if (p_child != 0)
     {
-      p_child->m_p_prev_or_parent = NULL;
+      p_child->m_p_prev_or_parent = 0;
 
-      while (p_child->m_p_next_sibling != NULL)
+      while (p_child->m_p_next_sibling != 0)
        p_child = p_child->m_p_next_sibling;
     }
 
-  m_p_max = NULL;
+  m_p_max = 0;
 
   base_type::m_p_root = join(p_cur_root, p_child);
 }
@@ -105,7 +105,7 @@ clear()
 {
   base_type::clear();
 
-  m_p_max = NULL;
+  m_p_max = 0;
 }
 
 PB_DS_CLASS_T_DEC
@@ -122,7 +122,7 @@ erase(point_iterator it)
 
   base_type::actual_erase_node(it.m_p_nd);
 
-  m_p_max = NULL;
+  m_p_max = 0;
 
   _GLIBCXX_DEBUG_ONLY(assert_valid(true);)
     }
@@ -148,7 +148,7 @@ erase_if(Pred pred)
 
   size_type ersd = 0;
 
-  while (p_out != NULL)
+  while (p_out != 0)
     {
       ++ersd;
 
@@ -161,19 +161,19 @@ erase_if(Pred pred)
 
   node_pointer p_cur = base_type::m_p_root;
 
-  base_type::m_p_root = NULL;
+  base_type::m_p_root = 0;
 
-  while (p_cur != NULL)
+  while (p_cur != 0)
     {
       node_pointer p_next = p_cur->m_p_next_sibling;
 
-      p_cur->m_p_l_child = p_cur->m_p_prev_or_parent = NULL;
+      p_cur->m_p_l_child = p_cur->m_p_prev_or_parent = 0;
 
       p_cur->m_metadata = 0;
 
       p_cur->m_p_next_sibling = base_type::m_p_root;
 
-      if (base_type::m_p_root != NULL)
+      if (base_type::m_p_root != 0)
        base_type::m_p_root->m_p_prev_or_parent = p_cur;
 
       base_type::m_p_root = p_cur;
@@ -183,7 +183,7 @@ erase_if(Pred pred)
       p_cur = p_next;
     }
 
-  m_p_max = NULL;
+  m_p_max = 0;
 
   _GLIBCXX_DEBUG_ONLY(assert_valid(true);)
 
index ad7f65129ba36a73cca01e6895bda9f31012f2e9..3c8ff109def348515804e72c7dc9b88f2cb8d36f 100644 (file)
@@ -46,10 +46,10 @@ top() const
   _GLIBCXX_DEBUG_ONLY(assert_valid(false);)
     _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
 
-  if (m_p_max == NULL)
+  if (m_p_max == 0)
     const_cast<PB_DS_CLASS_C_DEC* >(this)->find_max();
 
-  _GLIBCXX_DEBUG_ASSERT(m_p_max != NULL);
+  _GLIBCXX_DEBUG_ASSERT(m_p_max != 0);
   return m_p_max->m_value;
 }
 
@@ -62,7 +62,7 @@ find_max()
 
   m_p_max = p_cur;
 
-  while (p_cur != NULL)
+  while (p_cur != 0)
     {
       if (Cmp_Fn::operator()(m_p_max->m_value, p_cur->m_value))
        m_p_max = p_cur;
index e67d0df148ff7be359958637547aa5275f68e3f0..735bddbb71a82b74328b4f346f093b2c9fdd86e4 100644 (file)
@@ -49,7 +49,7 @@ push(const_reference r_val)
 
   insert_node(p_nd);
 
-  m_p_max = NULL;
+  m_p_max = 0;
 
   _GLIBCXX_DEBUG_ONLY(assert_valid(true);)
 
@@ -61,10 +61,10 @@ inline void
 PB_DS_CLASS_C_DEC::
 insert_node(node_pointer p_nd)
 {
-  if (base_type::m_p_root == NULL)
+  if (base_type::m_p_root == 0)
     {
       p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent =
-       p_nd->m_p_l_child = NULL;
+       p_nd->m_p_l_child = 0;
 
       p_nd->m_metadata = 0;
 
@@ -75,7 +75,7 @@ insert_node(node_pointer p_nd)
 
   if (base_type::m_p_root->m_metadata > 0)
     {
-      p_nd->m_p_prev_or_parent = p_nd->m_p_l_child = NULL;
+      p_nd->m_p_prev_or_parent = p_nd->m_p_l_child = 0;
 
       p_nd->m_p_next_sibling = base_type::m_p_root;
 
@@ -92,7 +92,7 @@ insert_node(node_pointer p_nd)
     {
       p_nd->m_p_next_sibling = base_type::m_p_root->m_p_next_sibling;
 
-      p_nd->m_p_prev_or_parent = NULL;
+      p_nd->m_p_prev_or_parent = 0;
 
       p_nd->m_metadata = 1;
 
@@ -100,15 +100,15 @@ insert_node(node_pointer p_nd)
 
       base_type::m_p_root->m_p_prev_or_parent = p_nd;
 
-      base_type::m_p_root->m_p_next_sibling = NULL;
+      base_type::m_p_root->m_p_next_sibling = 0;
 
       base_type::m_p_root = p_nd;
     }
   else
     {
-      p_nd->m_p_next_sibling = NULL;
+      p_nd->m_p_next_sibling = 0;
 
-      p_nd->m_p_l_child = NULL;
+      p_nd->m_p_l_child = 0;
 
       p_nd->m_p_prev_or_parent = base_type::m_p_root;
 
@@ -128,7 +128,7 @@ inline typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 fix(node_pointer p_nd) const
 {
-  while (p_nd->m_p_next_sibling != NULL&& 
+  while (p_nd->m_p_next_sibling != 0&& 
         p_nd->m_metadata == p_nd->m_p_next_sibling->m_metadata)
     {
       node_pointer p_next = p_nd->m_p_next_sibling;
@@ -138,7 +138,7 @@ fix(node_pointer p_nd) const
          p_next->m_p_prev_or_parent =
            p_nd->m_p_prev_or_parent;
 
-         if (p_nd->m_p_prev_or_parent != NULL)
+         if (p_nd->m_p_prev_or_parent != 0)
            p_nd->m_p_prev_or_parent->m_p_next_sibling = p_next;
 
          base_type::make_child_of(p_nd, p_next);
@@ -151,8 +151,8 @@ fix(node_pointer p_nd) const
         {
          p_nd->m_p_next_sibling = p_next->m_p_next_sibling;
 
-         if (p_nd->m_p_next_sibling != NULL)
-           p_next->m_p_next_sibling = NULL;
+         if (p_nd->m_p_next_sibling != 0)
+           p_next->m_p_next_sibling = 0;
 
          base_type::make_child_of(p_next, p_nd);
 
@@ -160,7 +160,7 @@ fix(node_pointer p_nd) const
         }
     }
 
-  if (p_nd->m_p_next_sibling != NULL)
+  if (p_nd->m_p_next_sibling != 0)
     p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd;
 
   return p_nd;
@@ -174,7 +174,7 @@ modify(point_iterator it, const_reference r_new_val)
   _GLIBCXX_DEBUG_ONLY(assert_valid(true);)
     node_pointer p_nd = it.m_p_nd;
 
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
   _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd, false);)
 
     const bool bubble_up = Cmp_Fn::operator()(p_nd->m_value, r_new_val);
@@ -185,7 +185,7 @@ modify(point_iterator it, const_reference r_new_val)
     {
       node_pointer p_parent = base_type::parent(p_nd);
 
-      while (p_parent != NULL&& 
+      while (p_parent != 0&& 
             Cmp_Fn::operator()(p_parent->m_value, p_nd->m_value))
         {
          base_type::swap_with_parent(p_nd, p_parent);
@@ -193,10 +193,10 @@ modify(point_iterator it, const_reference r_new_val)
          p_parent = base_type::parent(p_nd);
         }
 
-      if (p_nd->m_p_prev_or_parent == NULL)
+      if (p_nd->m_p_prev_or_parent == 0)
        base_type::m_p_root = p_nd;
 
-      m_p_max = NULL;
+      m_p_max = 0;
 
       _GLIBCXX_DEBUG_ONLY(assert_valid(true);)
 
@@ -209,7 +209,7 @@ modify(point_iterator it, const_reference r_new_val)
 
   insert_node(p_nd);
 
-  m_p_max = NULL;
+  m_p_max = 0;
 
   _GLIBCXX_DEBUG_ONLY(assert_valid(true);)
     }
index a701937cb9998d6b9b052d19677ac5075f7e96fb..2a96236fb9ef00c66c23513fd97ff31ef04f2430 100644 (file)
@@ -61,7 +61,7 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other)
 
   node_pointer p_out = base_type::prune(pred);
 
-  while (p_out != NULL)
+  while (p_out != 0)
     {
       _GLIBCXX_DEBUG_ASSERT(base_type::m_size > 0);
       --base_type::m_size;
@@ -70,13 +70,13 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other)
 
       node_pointer p_next = p_out->m_p_next_sibling;
 
-      p_out->m_p_l_child = p_out->m_p_prev_or_parent = NULL;
+      p_out->m_p_l_child = p_out->m_p_prev_or_parent = 0;
 
       p_out->m_metadata = 0;
 
       p_out->m_p_next_sibling = other.m_p_root;
 
-      if (other.m_p_root != NULL)
+      if (other.m_p_root != 0)
        other.m_p_root->m_p_prev_or_parent = p_out;
 
       other.m_p_root = p_out;
@@ -90,19 +90,19 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other)
 
     node_pointer p_cur = base_type::m_p_root;
 
-  base_type::m_p_root = NULL;
+  base_type::m_p_root = 0;
 
-  while (p_cur != NULL)
+  while (p_cur != 0)
     {
       node_pointer p_next = p_cur->m_p_next_sibling;
 
-      p_cur->m_p_l_child = p_cur->m_p_prev_or_parent = NULL;
+      p_cur->m_p_l_child = p_cur->m_p_prev_or_parent = 0;
 
       p_cur->m_metadata = 0;
 
       p_cur->m_p_next_sibling = base_type::m_p_root;
 
-      if (base_type::m_p_root != NULL)
+      if (base_type::m_p_root != 0)
        base_type::m_p_root->m_p_prev_or_parent = p_cur;
 
       base_type::m_p_root = p_cur;
@@ -112,7 +112,7 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other)
       p_cur = p_next;
     }
 
-  m_p_max = NULL;
+  m_p_max = 0;
 
   _GLIBCXX_DEBUG_ONLY(assert_valid(true);)
     _GLIBCXX_DEBUG_ONLY(other.assert_valid(true);)
@@ -128,7 +128,7 @@ join(PB_DS_CLASS_C_DEC& other)
 
     node_pointer p_other = other.m_p_root;
 
-  if (p_other != NULL)
+  if (p_other != 0)
     do
       {
        node_pointer p_next = p_other->m_p_next_sibling;
@@ -137,15 +137,15 @@ join(PB_DS_CLASS_C_DEC& other)
 
        p_other = p_next;
       }
-    while (p_other != NULL);
+    while (p_other != 0);
 
   base_type::m_p_root = join(base_type::m_p_root, other.m_p_root);
   base_type::m_size += other.m_size;
-  m_p_max = NULL;
+  m_p_max = 0;
 
-  other.m_p_root = NULL;
+  other.m_p_root = 0;
   other.m_size = 0;
-  other.m_p_max = NULL;
+  other.m_p_max = 0;
 
   _GLIBCXX_DEBUG_ONLY(assert_valid(true);)
     _GLIBCXX_DEBUG_ONLY(other.assert_valid(true);)
@@ -156,15 +156,15 @@ inline typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 join(node_pointer p_lhs, node_pointer p_rhs) const
 {
-  node_pointer p_ret = NULL;
+  node_pointer p_ret = 0;
 
-  node_pointer p_cur = NULL;
+  node_pointer p_cur = 0;
 
-  while (p_lhs != NULL || p_rhs != NULL)
+  while (p_lhs != 0 || p_rhs != 0)
     {
-      if (p_rhs == NULL)
+      if (p_rhs == 0)
         {
-         if (p_cur == NULL)
+         if (p_cur == 0)
            p_ret = p_cur = p_lhs;
          else
             {
@@ -173,11 +173,11 @@ join(node_pointer p_lhs, node_pointer p_rhs) const
              p_lhs->m_p_prev_or_parent = p_cur;
             }
 
-         p_cur = p_lhs = NULL;
+         p_cur = p_lhs = 0;
         }
-      else if (p_lhs == NULL || p_rhs->m_metadata < p_lhs->m_metadata)
+      else if (p_lhs == 0 || p_rhs->m_metadata < p_lhs->m_metadata)
         {
-         if (p_cur == NULL)
+         if (p_cur == 0)
             {
              p_ret = p_cur = p_rhs;
 
@@ -196,7 +196,7 @@ join(node_pointer p_lhs, node_pointer p_rhs) const
         }
       else if (p_lhs->m_metadata < p_rhs->m_metadata)
         {
-         if (p_cur == NULL)
+         if (p_cur == 0)
            p_ret = p_cur = p_lhs;
          else
             {
@@ -221,11 +221,11 @@ join(node_pointer p_lhs, node_pointer p_rhs) const
         }
     }
 
-  if (p_cur != NULL)
-    p_cur->m_p_next_sibling = NULL;
+  if (p_cur != 0)
+    p_cur->m_p_next_sibling = 0;
 
-  if (p_ret != NULL)
-    p_ret->m_p_prev_or_parent = NULL;
+  if (p_ret != 0)
+    p_ret->m_p_prev_or_parent = 0;
 
   return p_ret;
 }
index f5efabe0840fadf9d0af5eb69d0417a781c24f7a..2bace9c5ebd0aa25c72b6a6aa142cbc721ab386d 100644 (file)
@@ -374,7 +374,7 @@ namespace __gnu_pbds
        entry_pointer p_e = m_entries[pos];
        resize_base::notify_insert_search_start();
 
-       while (p_e != NULL 
+       while (p_e != 0 
               && !hash_eq_fn_base::operator()(p_e->m_value.first, r_key))
          {
            resize_base::notify_insert_search_collision();
@@ -382,7 +382,7 @@ namespace __gnu_pbds
          }
 
        resize_base::notify_insert_search_end();
-       if (p_e != NULL)
+       if (p_e != 0)
          {
            _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
            return (p_e->m_value.second);
@@ -399,7 +399,7 @@ namespace __gnu_pbds
        comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key);
        entry_pointer p_e = m_entries[pos_hash_pair.first];
        resize_base::notify_insert_search_start();
-       while (p_e != NULL && 
+       while (p_e != 0 && 
               !hash_eq_fn_base::operator()(p_e->m_value.first, p_e->m_hash, r_key, pos_hash_pair.second))
          {
            resize_base::notify_insert_search_collision();
@@ -407,7 +407,7 @@ namespace __gnu_pbds
          }
 
        resize_base::notify_insert_search_end();
-       if (p_e != NULL)
+       if (p_e != 0)
          {
            _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
            return p_e->m_value.second;
@@ -468,7 +468,7 @@ namespace __gnu_pbds
       {
        entry_pointer p_e = m_entries[ranged_hash_fn_base::operator()(r_key)];
        resize_base::notify_find_search_start();
-       while (p_e != NULL && 
+       while (p_e != 0 && 
               !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key))
          {
            resize_base::notify_find_search_collision();
@@ -478,7 +478,7 @@ namespace __gnu_pbds
        resize_base::notify_find_search_end();
 
 #ifdef _GLIBCXX_DEBUG
-       if (p_e == NULL)
+       if (p_e == 0)
          debug_base::check_key_does_not_exist(r_key);
        else
          debug_base::check_key_exists(r_key);
@@ -492,7 +492,7 @@ namespace __gnu_pbds
        comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key);
        entry_pointer p_e = m_entries[pos_hash_pair.first];
        resize_base::notify_find_search_start();
-       while (p_e != NULL && 
+       while (p_e != 0 && 
               !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value),
                                            p_e->m_hash,
                                            r_key, pos_hash_pair.second))
@@ -504,7 +504,7 @@ namespace __gnu_pbds
        resize_base::notify_find_search_end();
 
 #ifdef _GLIBCXX_DEBUG
-       if (p_e == NULL)
+       if (p_e == 0)
          debug_base::check_key_does_not_exist(r_key);
        else
          debug_base::check_key_exists(r_key);
@@ -534,22 +534,22 @@ namespace __gnu_pbds
       inc_it_state(const_pointer& r_p_value, 
                   std::pair<entry_pointer, size_type>& r_pos) const
       {
-       _GLIBCXX_DEBUG_ASSERT(r_p_value != NULL);
+       _GLIBCXX_DEBUG_ASSERT(r_p_value != 0);
        r_pos.first = r_pos.first->m_p_next;
-       if (r_pos.first != NULL)
+       if (r_pos.first != 0)
          {
            r_p_value = &r_pos.first->m_value;
            return;
          }
 
        for (++r_pos.second; r_pos.second < m_num_e; ++r_pos.second)
-         if (m_entries[r_pos.second] != NULL)
+         if (m_entries[r_pos.second] != 0)
            {
              r_pos.first = m_entries[r_pos.second];
              r_p_value = &r_pos.first->m_value;
              return;
            }
-       r_p_value = NULL;
+       r_p_value = 0;
       }
 
       void
@@ -557,13 +557,13 @@ namespace __gnu_pbds
                         std::pair<entry_pointer, size_type>& r_pos) const
       {
        for (r_pos.second = 0; r_pos.second < m_num_e; ++r_pos.second)
-         if (m_entries[r_pos.second] != NULL)
+         if (m_entries[r_pos.second] != 0)
            {
              r_pos.first = m_entries[r_pos.second];
              r_p_value = &r_pos.first->m_value;
              return;
            }
-       r_p_value = NULL;
+       r_p_value = 0;
       }
 
 #ifdef _GLIBCXX_DEBUG
index 1a61893d1055f8aeec8f503f312ae727c973b7a7..c52684472323952c05ed408abc997c7a5ca34dd7 100644 (file)
@@ -64,7 +64,7 @@ cmp_with_other(const Other_Map_Type& other) const
        const_cast<PB_DS_CLASS_C_DEC& >(*this).
        find_key_pointer(r_key, traits_base::m_store_extra_indicator);
 
-      if (p_mapped_value == NULL)
+      if (p_mapped_value == 0)
        return false;
 
 #ifdef PB_DS_DATA_TRUE_INDICATOR
index 24294ad9135330149eb205de832ae18ce0d1132a..f67254169b71de1273b43107759c1f0d5137b4af 100644 (file)
@@ -87,7 +87,7 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn) :
   m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
   m_entries(s_entry_pointer_allocator.allocate(m_num_e))
 {
-  std::fill(m_entries, m_entries + m_num_e, (entry_pointer)NULL);
+  std::fill(m_entries, m_entries + m_num_e, (entry_pointer)0);
   Resize_Policy::notify_cleared();
   ranged_hash_fn_base::notify_resized(m_num_e);
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -184,7 +184,7 @@ void
 PB_DS_CLASS_C_DEC::
 initialize()
 {
-  std::fill(m_entries, m_entries + m_num_e, entry_pointer(NULL));
+  std::fill(m_entries, m_entries + m_num_e, entry_pointer(0));
   Resize_Policy::notify_resized(m_num_e);
   Resize_Policy::notify_cleared();
   ranged_hash_fn_base::notify_resized(m_num_e);
index 4219eef3885fca23dfc8f051923e0aee319ae7ae..81d68e3311e4d8806aac5cfed54e9bb6803177ff 100644 (file)
@@ -58,7 +58,7 @@ assert_entry_pointer_array_valid(const entry_pointer_array a_p_entries) const
   for (size_type pos = 0; pos < m_num_e; ++pos)
     {
       entry_pointer p_e = a_p_entries[pos];
-      while (p_e != NULL)
+      while (p_e != 0)
         {
          ++iterated_num_used_e;
          assert_entry_pointer_valid(p_e, traits_base::m_store_extra_indicator);
index fa09f7348433cdb483457ee238ed47a34f1c0a8c..912535f93901a3268ea64678add78f5f9bafe4a3 100644 (file)
@@ -43,7 +43,7 @@ void
 PB_DS_CLASS_C_DEC::
 deallocate_links_in_list(entry_pointer p_e)
 {
-  while (p_e != NULL)
+  while (p_e != 0)
     {
       entry_pointer p_dealloc_e = p_e;
       p_e = p_e->m_p_next;
index 9f9178bc91132aba16f4337825012f9bb1a7fbf1..e1260c0d9bdc2557a466edeab16387b9b32a56bd 100644 (file)
@@ -61,7 +61,7 @@ erase_if(Pred pred)
   size_type num_ersd = 0;
   for (size_type pos = 0; pos < m_num_e; ++pos)
     {
-      while (m_entries[pos] != NULL && pred(m_entries[pos]->m_value))
+      while (m_entries[pos] != 0 && pred(m_entries[pos]->m_value))
         {
          ++num_ersd;
          entry_pointer p_next_e = m_entries[pos]->m_p_next;
@@ -70,7 +70,7 @@ erase_if(Pred pred)
         }
 
       entry_pointer p_e = m_entries[pos];
-      while (p_e != NULL && p_e->m_p_next != NULL)
+      while (p_e != 0 && p_e->m_p_next != 0)
         {
          if (pred(p_e->m_p_next->m_value))
             {
@@ -92,7 +92,7 @@ PB_DS_CLASS_C_DEC::
 clear()
 {
   for (size_type pos = 0; pos < m_num_e; ++pos)
-    while (m_entries[pos] != NULL)
+    while (m_entries[pos] != 0)
       erase_entry_pointer(m_entries[pos]);
   do_resize_if_needed_no_throw();
   resize_base::notify_cleared();
index d24fc31f9dc9172a545c7e436f7f40529d201e77..1f8fa06bda36c9940458274dc22b3aace3ed093d 100644 (file)
@@ -56,7 +56,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos)
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   entry_pointer p_e = m_entries[pos];
   resize_base::notify_erase_search_start();
-  if (p_e == NULL)
+  if (p_e == 0)
     {
       resize_base::notify_erase_search_end();
       _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
@@ -77,7 +77,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos)
   while (true)
     {
       entry_pointer p_next_e = p_e->m_p_next;
-      if (p_next_e == NULL)
+      if (p_next_e == 0)
         {
          resize_base::notify_erase_search_end();
          _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
index d72df696221f56a1c2083a0ab00eec8c7b4dcffd..01192b4cefddccb5a248c8295a84a510902a045b 100644 (file)
@@ -47,7 +47,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair)
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   entry_pointer p_e = m_entries[r_pos_hash_pair.first];
   resize_base::notify_erase_search_start();
-  if (p_e == NULL)
+  if (p_e == 0)
     {
       resize_base::notify_erase_search_end();
       _GLIBCXX_DEBUG_ONLY(debug_base:: check_key_does_not_exist(r_key);)
@@ -69,7 +69,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair)
   while (true)
     {
       entry_pointer p_next_e = p_e->m_p_next;
-      if (p_next_e == NULL)
+      if (p_next_e == 0)
         {
          resize_base::notify_erase_search_end();
          _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
index 6ca9a03b4fa06be89e4859cd2c678c16f757549d..03db9f84f2836eddd75179eedb05c58857deb42f 100644 (file)
@@ -61,11 +61,11 @@ PB_DS_CLASS_T_DEC
 inline typename PB_DS_CLASS_C_DEC::point_iterator
 PB_DS_CLASS_C_DEC::
 find_end()
-{ return NULL; }
+{ return 0; }
 
 PB_DS_CLASS_T_DEC
 inline typename PB_DS_CLASS_C_DEC::const_point_iterator
 PB_DS_CLASS_C_DEC::
 find_end() const
-{ return NULL; }
+{ return 0; }
 
index dc1519df7b35fbeb7cc0fe981c3b551de317f37c..5722c775def3bb7f43bbcbec3224738b1acb043e 100644 (file)
@@ -81,7 +81,7 @@ cmp_with_other(const Other_Map_Type& other) const
        const_cast<PB_DS_CLASS_C_DEC& >(*this).
        find_key_pointer(r_key, traits_base::m_store_extra_indicator);
 
-      if (p_mapped_value == NULL)
+      if (p_mapped_value == 0)
        return false;
 
 #ifdef PB_DS_DATA_TRUE_INDICATOR
index 7215ccd86bc38650fb7b456b9d5b7c77256d4817..3d23eab5c35f5e39b2802ad5d1b33904ed207bfe 100644 (file)
@@ -50,7 +50,7 @@ insert_imp(const_reference r_val, false_type)
   entry_pointer p_e = m_entries[pos];
   resize_base::notify_insert_search_start();
 
-  while (p_e != NULL && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), 
+  while (p_e != 0 && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), 
                                                     r_key))
     {
       resize_base::notify_insert_search_collision();
@@ -58,7 +58,7 @@ insert_imp(const_reference r_val, false_type)
     }
 
   resize_base::notify_insert_search_end();
-  if (p_e != NULL)
+  if (p_e != 0)
     {
       _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
       return std::make_pair(&p_e->m_value, false);
index fbc284f80b96cdac0a13826e03a11144599e29a9..b35570690af5d865605f19fe48c82278106f6c2c 100644 (file)
@@ -50,7 +50,7 @@ insert_imp(const_reference r_val, true_type)
   entry_pointer p_e = m_entries[pos_hash_pair.first];
   resize_base::notify_insert_search_start();
 
-  while (p_e != NULL && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value),
+  while (p_e != 0 && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value),
                                                     p_e->m_hash,
                                                    key, pos_hash_pair.second))
     {
@@ -59,7 +59,7 @@ insert_imp(const_reference r_val, true_type)
     }
 
   resize_base::notify_insert_search_end();
-  if (p_e != NULL)
+  if (p_e != 0)
     {
       _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(key);)
       return std::make_pair(&p_e->m_value, false);
index 66333ec85c27e9b8b4b8617b0f4c3595ca64642e..11e2583bc47d600c6a6d4d7f1c75b03272250f66 100644 (file)
@@ -112,12 +112,12 @@ PB_DS_CLASS_C_DEC::
 resize_imp_no_exceptions(size_type new_size, entry_pointer_array a_p_entries_resized, size_type old_size)
 {
   std::fill(a_p_entries_resized, a_p_entries_resized + m_num_e,
-           entry_pointer(NULL));
+           entry_pointer(0));
 
   for (size_type pos = 0; pos < old_size; ++pos)
     {
       entry_pointer p_e = m_entries[pos];
-      while (p_e != NULL)
+      while (p_e != 0)
        p_e = resize_imp_no_exceptions_reassign_pointer(p_e, a_p_entries_resized,  traits_base::m_store_extra_indicator);
     }
 
index 6fa5676b9df536db83207ed1a3c42e1db5087016..77735aeafdd259810d5002eca71f0c1ea93121a4 100644 (file)
@@ -62,7 +62,7 @@ PB_DS_CLASS_C_DEC::
 trace_list(const_entry_pointer p_l) const
 {
   size_type iterated_num_used_e = 0;
-  while (p_l != NULL)
+  while (p_l != 0)
     {
       std::cerr << PB_DS_V2F(p_l->m_value) << " ";
       p_l = p_l->m_p_next;
index 69d53763ad50cfb8a490f8f9553d13b0976a27db..d39735c563275b55e502f9a8b1b478816e53c024 100644 (file)
@@ -60,11 +60,11 @@ PB_DS_CLASS_T_DEC
 inline typename PB_DS_CLASS_C_DEC::point_iterator
 PB_DS_CLASS_C_DEC::
 find_end()
-{ return NULL; }
+{ return 0; }
 
 PB_DS_CLASS_T_DEC
 inline typename PB_DS_CLASS_C_DEC::const_point_iterator
 PB_DS_CLASS_C_DEC::
 find_end() const
-{ return NULL; }
+{ return 0; }
 
index 4741afec0904ec663426709ce5432bcdd9e35770..5b2df85a8c295db078b9703cf62f28b2f24cf983 100644 (file)
@@ -490,7 +490,7 @@ namespace __gnu_pbds
                  resize_base::notify_find_search_end();
                  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);)
 
-                   return NULL;
+                   return 0;
                }
                break;
              case valid_entry_status:
@@ -513,7 +513,7 @@ namespace __gnu_pbds
 
        _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);)
        resize_base::notify_find_search_end();
-       return NULL;
+       return 0;
       }
 
       inline pointer
@@ -538,7 +538,7 @@ namespace __gnu_pbds
                  resize_base::notify_find_search_end();
                  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);)
 
-                 return NULL;
+                 return 0;
                }
                break;
              case valid_entry_status:
@@ -562,7 +562,7 @@ namespace __gnu_pbds
 
        _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);)
        resize_base::notify_find_search_end();
-       return NULL;
+       return 0;
       }
 
       inline bool
@@ -583,7 +583,7 @@ namespace __gnu_pbds
       void
       inc_it_state(const_pointer& r_p_value, size_type& r_pos) const
       {
-       _GLIBCXX_DEBUG_ASSERT(r_p_value != NULL);
+       _GLIBCXX_DEBUG_ASSERT(r_p_value != 0);
        for (++r_pos; r_pos < m_num_e; ++r_pos)
          {
            const_entry_pointer p_e =& m_entries[r_pos];
@@ -593,7 +593,7 @@ namespace __gnu_pbds
                return;
              }
          }
-       r_p_value = NULL;
+       r_p_value = 0;
       }
 
       void
@@ -608,7 +608,7 @@ namespace __gnu_pbds
                return;
              }
          }
-       r_p_value = NULL;
+       r_p_value = 0;
       }
 
       void
@@ -623,7 +623,7 @@ namespace __gnu_pbds
                return;
              }
          }
-       r_p_value = NULL;
+       r_p_value = 0;
       }
 
 #ifdef _GLIBCXX_DEBUG
index 0492a47928b58eb9f05cdee824e2ae7f988e30d0..115a8bf0dda6100823606bea10347ca7de7c020f 100644 (file)
@@ -87,7 +87,7 @@ resize_imp(size_type new_size)
 
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   const size_type old_size = m_num_e;
-  entry_array a_entries_resized = NULL;
+  entry_array a_entries_resized = 0;
 
   // Following line might throw an exception.
   a_entries_resized = s_entry_allocator.allocate(new_size);
index 479725fd51b76748a8000c46804800e0889db77a..dac063927f69446c4eb22958c11a5e955b4eef62 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -60,7 +60,7 @@ namespace __gnu_pbds
       typedef
       typename __conditional_type<
       is_same<
-      __gnu_pbds::direct_mask_range_hashing<size_t>,
+       __gnu_pbds::direct_mask_range_hashing<std::size_t>,
       Comb_Probe_Fn>::value,
       __gnu_pbds::linear_probe_fn<size_type>,
       __gnu_pbds::quadratic_probe_fn<size_type> >::__type
index dad6451d06fa8a8537de4b4f872e4b9f0fb6b549..7dcd82588c1bca857ab2394e13b4ff836c9aa789 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -48,7 +48,7 @@ class sample_probe_fn
 public:
 
   // Size type.
-  typedef size_t size_type;
+  typedef std::size_t size_type;
 
 public:
 
index 0912e7f27e8a6f8e02c2f4c6a4da170e415bffdb..988f111ea20d1442cea811888b9b5482d33d0ef0 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -48,7 +48,7 @@ class sample_range_hashing
 public:
 
   // Size type.
-  typedef size_t size_type;
+  typedef std::size_t size_type;
 
 public:
 
index 6120231e2e2326368b31baf0f0b34a0ba7139001..8fa04d140e5b1a28aae2ebcfb1fe3c421fc4da35 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -48,7 +48,7 @@ class sample_ranged_hash_fn
 public:
 
   // Size type.
-  typedef size_t size_type;
+  typedef std::size_t size_type;
 
 public:
 
index 915f108df83ecaefbb7d0fb4265b27e9fad90fcc..2bcfdf51a5422452f9c2121ec938cc5ea792f2f0 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -48,7 +48,7 @@ class sample_ranged_probe_fn
 public:
 
   // Size type.
-  typedef size_t size_type;
+  typedef std::size_t size_type;
 
 public:
 
@@ -70,7 +70,7 @@ protected:
 
   // Transforms the const key reference r_key into the i-th position within the table. This method is called for each collision within the probe sequence.
   inline size_type
-  operator()(const_key_reference r_key, size_t hash, size_type i) const;
+  operator()(const_key_reference r_key, std::size_t hash, size_type i) const;
 
 };
 
index 5955df161643b67fa5e9971a255b360854edfa66..4c085d4c69dfd62bad04f9d3b5b39b00fc5dd4ad 100644 (file)
@@ -118,7 +118,7 @@ namespace __gnu_pbds
       inline PB_DS_CLASS_C_DEC& 
       operator++()
       {
-       _GLIBCXX_DEBUG_ASSERT(base_type::m_p_nd != NULL);
+       _GLIBCXX_DEBUG_ASSERT(base_type::m_p_nd != 0);
        inc();
        return (*this);
       }
@@ -135,10 +135,10 @@ namespace __gnu_pbds
       void
       inc()
       {
-       if (base_type::m_p_nd->m_p_next_sibling != NULL)
+       if (base_type::m_p_nd->m_p_next_sibling != 0)
          {
            base_type::m_p_nd = base_type::m_p_nd->m_p_next_sibling;
-           while (base_type::m_p_nd->m_p_l_child != NULL)
+           while (base_type::m_p_nd->m_p_l_child != 0)
              base_type::m_p_nd = base_type::m_p_nd->m_p_l_child;
            return;
          }
@@ -147,7 +147,7 @@ namespace __gnu_pbds
          {
            node_pointer p_next = base_type::m_p_nd;
            base_type::m_p_nd = base_type::m_p_nd->m_p_prev_or_parent;
-           if (base_type::m_p_nd == NULL || base_type::m_p_nd->m_p_l_child == p_next)
+           if (base_type::m_p_nd == 0 || base_type::m_p_nd->m_p_l_child == p_next)
              return;
          }
       }
index 7d682526b4c44be3e9696be32e88b07348b2afa4..8eb1574446b814b8ee1f13d84514915612c469c6 100644 (file)
@@ -107,7 +107,7 @@ namespace __gnu_pbds
 
       // Default constructor.
       inline
-      left_child_next_sibling_heap_node_const_point_iterator_() : m_p_nd(NULL)
+      left_child_next_sibling_heap_node_const_point_iterator_() : m_p_nd(0)
       { }
 
       // Copy constructor.
@@ -119,7 +119,7 @@ namespace __gnu_pbds
       inline const_pointer
       operator->() const
       {
-       _GLIBCXX_DEBUG_ASSERT(m_p_nd != NULL);
+       _GLIBCXX_DEBUG_ASSERT(m_p_nd != 0);
        return &m_p_nd->m_value;
       }
 
@@ -127,7 +127,7 @@ namespace __gnu_pbds
       inline const_reference
       operator*() const
       {
-       _GLIBCXX_DEBUG_ASSERT(m_p_nd != NULL);
+       _GLIBCXX_DEBUG_ASSERT(m_p_nd != 0);
        return m_p_nd->m_value;
       }
 
index ea0572527c263c601460094966ffb8074a75d061..536ac66ea4b93ff7c1a4bd18278238c8980e7827 100644 (file)
@@ -49,7 +49,7 @@ PB_DS_CLASS_C_DEC::s_no_throw_copies_ind;
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 left_child_next_sibling_heap_() :
-  m_p_root(NULL),
+  m_p_root(0),
   m_size(0)
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
@@ -59,7 +59,7 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 left_child_next_sibling_heap_(const Cmp_Fn& r_cmp_fn) :
   Cmp_Fn(r_cmp_fn),
-  m_p_root(NULL),
+  m_p_root(0),
   m_size(0)
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
@@ -68,7 +68,7 @@ left_child_next_sibling_heap_(const Cmp_Fn& r_cmp_fn) :
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 left_child_next_sibling_heap_(const PB_DS_CLASS_C_DEC& other) 
-: Cmp_Fn(other), m_p_root(NULL), m_size(0)
+: Cmp_Fn(other), m_p_root(0), m_size(0)
 {
   m_size = other.m_size;
   _GLIBCXX_DEBUG_ONLY(other.assert_valid();)
@@ -111,8 +111,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 recursive_copy_node(const_node_pointer p_nd)
 {
-  if (p_nd == NULL)
-    return (NULL);
+  if (p_nd == 0)
+    return (0);
 
   node_pointer p_ret = s_node_allocator.allocate(1);
 
@@ -127,7 +127,7 @@ recursive_copy_node(const_node_pointer p_nd)
     }
 
   p_ret->m_p_l_child = p_ret->m_p_next_sibling =
-    p_ret->m_p_prev_or_parent = NULL;
+    p_ret->m_p_prev_or_parent = 0;
 
   __try
     {
@@ -140,12 +140,12 @@ recursive_copy_node(const_node_pointer p_nd)
       __throw_exception_again;
     }
 
-  if (p_ret->m_p_l_child != NULL)
+  if (p_ret->m_p_l_child != 0)
     p_ret->m_p_l_child->m_p_prev_or_parent = p_ret;
 
-  if (p_ret->m_p_next_sibling != NULL)
+  if (p_ret->m_p_next_sibling != 0)
     p_ret->m_p_next_sibling->m_p_prev_or_parent =
-      p_nd->m_p_next_sibling->m_p_prev_or_parent == p_nd ? p_ret : NULL;
+      p_nd->m_p_next_sibling->m_p_prev_or_parent == p_nd ? p_ret : 0;
 
   return p_ret;
 }
index 86871ac3817d75abf3933c1ce3673b59ac8cbcb1..16b8217bd61f9f4d547501431bb8ca047d796a02 100644 (file)
@@ -45,9 +45,9 @@ void
 PB_DS_CLASS_C_DEC::
 assert_valid() const
 {
-  _GLIBCXX_DEBUG_ASSERT(m_p_root == NULL || m_p_root->m_p_prev_or_parent == NULL);
+  _GLIBCXX_DEBUG_ASSERT(m_p_root == 0 || m_p_root->m_p_prev_or_parent == 0);
 
-  if (m_p_root != NULL)
+  if (m_p_root != 0)
     assert_node_consistent(m_p_root, Single_Link_Roots);
   assert_size();
   assert_iterators();
@@ -58,22 +58,22 @@ void
 PB_DS_CLASS_C_DEC::
 assert_node_consistent(const_node_pointer p_nd, bool single_link) const
 {
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return;
 
   assert_node_consistent(p_nd->m_p_l_child, false);
   assert_node_consistent(p_nd->m_p_next_sibling, single_link);
 
   if (single_link)
-    _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_prev_or_parent == NULL);
-  else if (p_nd->m_p_next_sibling != NULL)
+    _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_prev_or_parent == 0);
+  else if (p_nd->m_p_next_sibling != 0)
     _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling->m_p_prev_or_parent == p_nd);
 
-  if (p_nd->m_p_l_child == NULL)
+  if (p_nd->m_p_l_child == 0)
     return;
 
   const_node_pointer p_child = p_nd->m_p_l_child;
-  while (p_child != NULL)
+  while (p_child != 0)
     {
       const_node_pointer p_next_child = p_child->m_p_next_sibling;
       _GLIBCXX_DEBUG_ASSERT(!Cmp_Fn::operator()(p_nd->m_value, p_child->m_value));
@@ -115,7 +115,7 @@ PB_DS_CLASS_C_DEC::
 size_from_node(const_node_pointer p_nd)
 {
   size_type ret = 0;
-  while (p_nd != NULL)
+  while (p_nd != 0)
     {
       ret += 1 + size_from_node(p_nd->m_p_l_child);
       p_nd = p_nd->m_p_next_sibling;
@@ -130,7 +130,7 @@ degree(const_node_pointer p_nd)
 {
   size_type ret = 0;
   const_node_pointer p_child = p_nd->m_p_l_child;
-  while (p_child != NULL)
+  while (p_child != 0)
     {
       ++ret;
       p_child = p_child->m_p_next_sibling;
index 9fa09f49bbb542d47a2c06bba278aaff65e72c6a..605457fd4cbd8b33104c18515b69cc764d75afa5 100644 (file)
@@ -45,7 +45,7 @@ clear()
 {
   clear_imp(m_p_root);
   _GLIBCXX_DEBUG_ASSERT(m_size == 0);
-  m_p_root = NULL;
+  m_p_root = 0;
 }
 
 PB_DS_CLASS_T_DEC
@@ -64,7 +64,7 @@ void
 PB_DS_CLASS_C_DEC::
 clear_imp(node_pointer p_nd)
 {
-  while (p_nd != NULL)
+  while (p_nd != 0)
     {
       clear_imp(p_nd->m_p_l_child);
       node_pointer p_next = p_nd->m_p_next_sibling;
@@ -80,8 +80,8 @@ to_linked_list()
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   node_pointer p_cur = m_p_root;
-  while (p_cur != NULL)
-    if (p_cur->m_p_l_child != NULL)
+  while (p_cur != 0)
+    if (p_cur->m_p_l_child != 0)
       {
        node_pointer p_child_next = p_cur->m_p_l_child->m_p_next_sibling;
        p_cur->m_p_l_child->m_p_next_sibling = p_cur->m_p_next_sibling;
@@ -94,10 +94,10 @@ to_linked_list()
 #ifdef _GLIBCXX_DEBUG
   const_node_pointer p_counter = m_p_root;
   size_type count = 0;
-  while (p_counter != NULL)
+  while (p_counter != 0)
     {
       ++count;
-      _GLIBCXX_DEBUG_ASSERT(p_counter->m_p_l_child == NULL);
+      _GLIBCXX_DEBUG_ASSERT(p_counter->m_p_l_child == 0);
       p_counter = p_counter->m_p_next_sibling;
     }
   _GLIBCXX_DEBUG_ASSERT(count == m_size);
@@ -111,22 +111,22 @@ PB_DS_CLASS_C_DEC::
 prune(Pred pred)
 {
   node_pointer p_cur = m_p_root;
-  m_p_root = NULL;
-  node_pointer p_out = NULL;
-  while (p_cur != NULL)
+  m_p_root = 0;
+  node_pointer p_out = 0;
+  while (p_cur != 0)
     {
       node_pointer p_next = p_cur->m_p_next_sibling;
       if (pred(p_cur->m_value))
         {
          p_cur->m_p_next_sibling = p_out;
-         if (p_out != NULL)
+         if (p_out != 0)
            p_out->m_p_prev_or_parent = p_cur;
          p_out = p_cur;
         }
       else
         {
          p_cur->m_p_next_sibling = m_p_root;
-         if (m_p_root != NULL)
+         if (m_p_root != 0)
            m_p_root->m_p_prev_or_parent = p_cur;
          m_p_root = p_cur;
         }
@@ -141,7 +141,7 @@ PB_DS_CLASS_C_DEC::
 bubble_to_top(node_pointer p_nd)
 {
   node_pointer p_parent = parent(p_nd);
-  while (p_parent != NULL)
+  while (p_parent != 0)
     {
       swap_with_parent(p_nd, p_parent);
       p_parent = parent(p_nd);
index 926ccd39c22ed17590d6821f31e080e038a7691f..478abe018b0cc657a8807ecaabc4ad72084afb12 100644 (file)
@@ -87,12 +87,12 @@ inline void
 PB_DS_CLASS_C_DEC::
 make_child_of(node_pointer p_nd, node_pointer p_new_parent)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_new_parent != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_new_parent != 0);
 
   p_nd->m_p_next_sibling = p_new_parent->m_p_l_child;
 
-  if (p_new_parent->m_p_l_child != NULL)
+  if (p_new_parent->m_p_l_child != 0)
     p_new_parent->m_p_l_child->m_p_prev_or_parent = p_nd;
 
   p_nd->m_p_prev_or_parent = p_new_parent;
@@ -109,7 +109,7 @@ parent(node_pointer p_nd)
     {
       node_pointer p_pot = p_nd->m_p_prev_or_parent;
 
-      if (p_pot == NULL || p_pot->m_p_l_child == p_nd)
+      if (p_pot == 0 || p_pot->m_p_l_child == p_nd)
        return p_pot;
 
       p_nd = p_pot;
@@ -124,12 +124,12 @@ swap_with_parent(node_pointer p_nd, node_pointer p_parent)
   if (p_parent == m_p_root)
     m_p_root = p_nd;
 
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_parent != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_parent != 0);
   _GLIBCXX_DEBUG_ASSERT(parent(p_nd) == p_parent);
 
   const bool nd_direct_child = p_parent->m_p_l_child == p_nd;
-  const bool parent_root = p_parent->m_p_prev_or_parent == NULL;
+  const bool parent_root = p_parent->m_p_prev_or_parent == 0;
   const bool parent_direct_child =
     !parent_root&&  p_parent->m_p_prev_or_parent->m_p_l_child == p_parent;
 
@@ -138,16 +138,16 @@ swap_with_parent(node_pointer p_nd, node_pointer p_parent)
   std::swap(p_parent->m_p_l_child, p_nd->m_p_l_child);
   std::swap(p_parent->m_metadata, p_nd->m_metadata);
 
-  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_l_child != NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_prev_or_parent != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_l_child != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_prev_or_parent != 0);
 
-  if (p_nd->m_p_next_sibling != NULL)
+  if (p_nd->m_p_next_sibling != 0)
     p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd;
 
-  if (p_parent->m_p_next_sibling != NULL)
+  if (p_parent->m_p_next_sibling != 0)
     p_parent->m_p_next_sibling->m_p_prev_or_parent = p_parent;
 
-  if (p_parent->m_p_l_child != NULL)
+  if (p_parent->m_p_l_child != 0)
     p_parent->m_p_l_child->m_p_prev_or_parent = p_parent;
 
   if (parent_direct_child)
index dca70fdd509780fc6b42c372501199351b537907..b6587e229f2219338a629d9515bf46df2cc31e5c 100644 (file)
@@ -45,10 +45,10 @@ begin()
 {
   node_pointer p_nd = m_p_root;
 
-  if (p_nd == NULL)
-    return (iterator(NULL));
+  if (p_nd == 0)
+    return (iterator(0));
 
-  while (p_nd->m_p_l_child != NULL)
+  while (p_nd->m_p_l_child != 0)
     p_nd = p_nd->m_p_l_child;
 
   return (iterator(p_nd));
@@ -61,10 +61,10 @@ begin() const
 {
   node_pointer p_nd = m_p_root;
 
-  if (p_nd == NULL)
-    return (const_iterator(NULL));
+  if (p_nd == 0)
+    return (const_iterator(0));
 
-  while (p_nd->m_p_l_child != NULL)
+  while (p_nd->m_p_l_child != 0)
     p_nd = p_nd->m_p_l_child;
 
   return (const_iterator(p_nd));
@@ -75,7 +75,7 @@ inline typename PB_DS_CLASS_C_DEC::iterator
 PB_DS_CLASS_C_DEC::
 end()
 {
-  return (iterator(NULL));
+  return (iterator(0));
 }
 
 PB_DS_CLASS_T_DEC
@@ -83,6 +83,6 @@ inline typename PB_DS_CLASS_C_DEC::const_iterator
 PB_DS_CLASS_C_DEC::
 end() const
 {
-  return (const_iterator(NULL));
+  return (const_iterator(0));
 }
 
index 040466e8e840457723d06317c2dd3ad42057b1ea..7ba4bf6ee8b60b9b06d0ed5bd8a303b69b4f254a 100644 (file)
@@ -38,8 +38,8 @@
  * Contains an implementation struct for this type of heap's node.
  */
 
-#ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_NULL_METADATA_HPP
-#define PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_NULL_METADATA_HPP
+#ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_0_METADATA_HPP
+#define PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_0_METADATA_HPP
 
 namespace __gnu_pbds
 {
@@ -52,4 +52,4 @@ namespace __gnu_pbds
   } // namespace detail
 } // namespace __gnu_pbds
 
-#endif // #ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_NULL_METADATA_HPP
+#endif // #ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_0_METADATA_HPP
index 2b90cfa1dc0839fe47dec0ab736b2b7f30843723..8d33baa10acf77c8eef67d855bb8f6c7fc611e83 100644 (file)
@@ -57,7 +57,7 @@ void
 PB_DS_CLASS_C_DEC::
 trace_node(const_node_pointer p_nd, size_type level)
 {
-  while (p_nd != NULL)
+  while (p_nd != 0)
     {
       for (size_type i = 0; i < level; ++i)
        std::cerr << ' ';
index c998c3e67c1852b421d451b3ff174744ddaee838..662f40f34e88760a2a887a8bbe5763c90b102799 100644 (file)
@@ -67,13 +67,13 @@ copy_from_range(It first_it, It last_it)
 
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
-PB_DS_CLASS_NAME() : m_p_l(NULL)
+PB_DS_CLASS_NAME() : m_p_l(0)
 { _GLIBCXX_DEBUG_ONLY(assert_valid();) }
 
 PB_DS_CLASS_T_DEC
 template<typename It>
 PB_DS_CLASS_C_DEC::
-PB_DS_CLASS_NAME(It first_it, It last_it) : m_p_l(NULL)
+PB_DS_CLASS_NAME(It first_it, It last_it) : m_p_l(0)
 {
   copy_from_range(first_it, last_it);
   _GLIBCXX_DEBUG_ONLY(assert_valid(););
@@ -85,7 +85,7 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
 #ifdef _GLIBCXX_DEBUG
   debug_base(),
 #endif
-m_p_l(NULL)
+m_p_l(0)
 {
   __try
     {
@@ -125,13 +125,13 @@ PB_DS_CLASS_C_DEC::
 deallocate_all()
 {
   entry_pointer p_l = m_p_l;
-  while (p_l != NULL)
+  while (p_l != 0)
     {
       entry_pointer p_next_l = p_l->m_p_next;
       actual_erase_entry(p_l);
       p_l = p_next_l;
     }
-  m_p_l = NULL;
+  m_p_l = 0;
 }
 
 PB_DS_CLASS_T_DEC
index cdc59208fa3b75b202ad0d304fe8e9f7fabc3dd3..a7d0fbadf89f4a218489c363214149cf1e2c6535 100644 (file)
@@ -44,7 +44,7 @@ PB_DS_CLASS_C_DEC::
 erase(const_key_reference r_key)
 {
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
-  if (m_p_l == NULL)
+  if (m_p_l == 0)
     return false;
 
   if (s_eq_fn(r_key, PB_DS_V2F(m_p_l->m_value)))
@@ -56,7 +56,7 @@ erase(const_key_reference r_key)
     }
 
   entry_pointer p_l = m_p_l;
-  while (p_l->m_p_next != NULL)
+  while (p_l->m_p_next != 0)
     if (s_eq_fn(r_key, PB_DS_V2F(p_l->m_p_next->m_value)))
       {
        erase_next(p_l);
@@ -83,7 +83,7 @@ erase_if(Pred pred)
 {
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
   size_type num_ersd = 0;
-  while (m_p_l != NULL && pred(m_p_l->m_value))
+  while (m_p_l != 0 && pred(m_p_l->m_value))
     {
       entry_pointer p_next = m_p_l->m_p_next;
       ++num_ersd;
@@ -91,11 +91,11 @@ erase_if(Pred pred)
       m_p_l = p_next;
     }
 
-  if (m_p_l == NULL)
+  if (m_p_l == 0)
     return num_ersd;
 
   entry_pointer p_l = m_p_l;
-  while (p_l->m_p_next != NULL)
+  while (p_l->m_p_next != 0)
     {
       if (pred(p_l->m_p_next->m_value))
         {
@@ -115,9 +115,9 @@ void
 PB_DS_CLASS_C_DEC::
 erase_next(entry_pointer p_l)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_l != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_l != 0);
   _GLIBCXX_DEBUG_ASSERT(p_l != m_p_l);
-  _GLIBCXX_DEBUG_ASSERT(p_l->m_p_next != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_l->m_p_next != 0);
   entry_pointer p_next_l = p_l->m_p_next->m_p_next;
   actual_erase_entry(p_l->m_p_next);
   p_l->m_p_next = p_next_l;
index 50347ac5fca09b7991118f2079f379ecb342aee3..e7f5ed1d3f8a76bfc86d2a361b4a5f708f873145 100644 (file)
@@ -43,8 +43,8 @@ inline typename PB_DS_CLASS_C_DEC::entry_pointer
 PB_DS_CLASS_C_DEC::
 find_imp(const_key_reference r_key) const
 {
-  if (m_p_l == NULL)
-    return NULL;
+  if (m_p_l == 0)
+    return 0;
   if (s_eq_fn(r_key, PB_DS_V2F(m_p_l->m_value)))
     {
       apply_update(m_p_l, s_metadata_type_indicator);
@@ -53,7 +53,7 @@ find_imp(const_key_reference r_key) const
     }
 
   entry_pointer p_l = m_p_l;
-  while (p_l->m_p_next != NULL)
+  while (p_l->m_p_next != 0)
     {
       entry_pointer p_next = p_l->m_p_next;
       if (s_eq_fn(r_key, PB_DS_V2F(p_next->m_value)))
@@ -72,7 +72,7 @@ find_imp(const_key_reference r_key) const
     }
 
   _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
-  return NULL;
+  return 0;
 }
 
 PB_DS_CLASS_T_DEC
index 5ad39709d5d5d1fac369935e05a46b6ca72990b5..1aaaf1edd926fc4b1cff726cdc4c10a1f4962cf2 100644 (file)
@@ -54,4 +54,4 @@ PB_DS_CLASS_T_DEC
 inline bool
 PB_DS_CLASS_C_DEC::
 empty() const
-{ return (m_p_l == NULL); }
+{ return (m_p_l == 0); }
index 5efe2a13a6657f9530d1d02a5319059b65eb648b..197cfbc6d1870a65329c1cc97d452fba098a6ad0 100644 (file)
@@ -48,7 +48,7 @@ insert(const_reference r_val)
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   entry_pointer p_l = find_imp(PB_DS_V2F(r_val));
 
-  if (p_l != NULL)
+  if (p_l != 0)
     {
       _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(PB_DS_V2F(r_val));)
       return std::make_pair(point_iterator(&p_l->m_value), false);
index e3247c5b08066aca4403fd787e4d6e0732af243c..4d4e0b417c29b995b972119f634f8881d1d7fca2 100644 (file)
@@ -43,7 +43,7 @@ inline typename PB_DS_CLASS_C_DEC::iterator
 PB_DS_CLASS_C_DEC::
 begin()
 {
-  if (m_p_l == NULL)
+  if (m_p_l == 0)
     {
       _GLIBCXX_DEBUG_ASSERT(empty());
       return end();
@@ -56,7 +56,7 @@ inline typename PB_DS_CLASS_C_DEC::const_iterator
 PB_DS_CLASS_C_DEC::
 begin() const
 {
-  if (m_p_l == NULL)
+  if (m_p_l == 0)
     {
       _GLIBCXX_DEBUG_ASSERT(empty());
       return end();
@@ -68,13 +68,13 @@ PB_DS_CLASS_T_DEC
 inline typename PB_DS_CLASS_C_DEC::iterator
 PB_DS_CLASS_C_DEC::
 end()
-{ return iterator(NULL, NULL, this); }
+{ return iterator(0, 0, this); }
 
 PB_DS_CLASS_T_DEC
 inline typename PB_DS_CLASS_C_DEC::const_iterator
 PB_DS_CLASS_C_DEC::
 end() const
 {
-  return const_iterator(NULL, NULL, const_cast<PB_DS_CLASS_C_DEC* const>(this));
+  return const_iterator(0, 0, const_cast<PB_DS_CLASS_C_DEC* const>(this));
 }
 
index 0e9336b57ca8c061cdd26ca3564db136a2f8054c..cf43064e504aef9832182769fa10d4445881c280 100644 (file)
@@ -233,7 +233,7 @@ namespace __gnu_pbds
       {
        _GLIBCXX_DEBUG_ONLY(assert_valid();)
        entry_pointer p_e = find_imp(r_key);
-       return point_iterator(p_e == NULL ? NULL: &p_e->m_value);
+       return point_iterator(p_e == 0 ? 0: &p_e->m_value);
       }
 
       inline const_point_iterator
@@ -241,7 +241,7 @@ namespace __gnu_pbds
       {
        _GLIBCXX_DEBUG_ONLY(assert_valid();)
        entry_pointer p_e = find_imp(r_key);
-       return const_point_iterator(p_e == NULL ? NULL: &p_e->m_value);
+       return const_point_iterator(p_e == 0 ? 0: &p_e->m_value);
       }
 
       inline bool
@@ -315,7 +315,7 @@ namespace __gnu_pbds
       inc_it_state(const_pointer& r_p_value, entry_pointer& r_pos) const
       {
        r_pos = r_pos->m_p_next;
-       r_p_value = (r_pos == NULL) ? NULL : &r_pos->m_value;
+       r_p_value = (r_pos == 0) ? 0 : &r_pos->m_value;
       }
 
       template<typename Metadata>
index 908aacc19cd6346115e0bcbc7a2336c5a09c88c9..7c8defcdf06c349c4eec3eb60bef2167c2fdfd1b 100644 (file)
@@ -47,7 +47,7 @@ trace() const
 {
   std::cerr << m_p_l << std::endl << std::endl;
   const_entry_pointer p_l = m_p_l;
-  while (p_l != NULL)
+  while (p_l != 0)
     {
       std::cerr << PB_DS_V2F(p_l->m_value) << std::endl;
       p_l = p_l->m_p_next;
index 4ef7fe48a82045b6dfc61ef3b261dcf4212fdf9e..8e476cb91b9088f03c713307a0d0400b926f2337 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -47,7 +47,7 @@ namespace __gnu_pbds
 
     // A list-update metadata type that moves elements to the front of
     // the list based on the counter algorithm.
-    template<typename Size_Type = size_t>
+    template<typename Size_Type = std::size_t>
     class counter_lu_metadata
     {
     public:
index 545b98162930767e9fd766f52b49645ddaeb892c..3245566e39a6c0ba155f4a8283bb91e64dec974d 100644 (file)
@@ -49,9 +49,9 @@ PB_DS_CLASS_C_DEC::s_metadata_alloc;
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 PB_DS_OV_TREE_CLASS_NAME() :
-  m_a_values(NULL),
-  m_a_metadata(NULL),
-  m_end_it(NULL),
+  m_a_values(0),
+  m_a_metadata(0),
+  m_end_it(0),
   m_size(0)
 { _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) }
 
@@ -59,9 +59,9 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 PB_DS_OV_TREE_CLASS_NAME(const Cmp_Fn& r_cmp_fn) :
   cmp_fn_base(r_cmp_fn),
-  m_a_values(NULL),
-  m_a_metadata(NULL),
-  m_end_it(NULL),
+  m_a_values(0),
+  m_a_metadata(0),
+  m_end_it(0),
   m_size(0)
 { _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) }
 
@@ -70,9 +70,9 @@ PB_DS_CLASS_C_DEC::
 PB_DS_OV_TREE_CLASS_NAME(const Cmp_Fn& r_cmp_fn, const node_update& r_node_update) :
   cmp_fn_base(r_cmp_fn),
   node_update(r_node_update),
-  m_a_values(NULL),
-  m_a_metadata(NULL),
-  m_end_it(NULL),
+  m_a_values(0),
+  m_a_metadata(0),
+  m_end_it(0),
   m_size(0)
 { _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) }
 
@@ -87,9 +87,9 @@ PB_DS_OV_TREE_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
 #endif 
   cmp_fn_base(other),
   node_update(other),
-  m_a_values(NULL),
-  m_a_metadata(NULL),
-  m_end_it(NULL),
+  m_a_values(0),
+  m_a_metadata(0),
+  m_end_it(0),
   m_size(0)
 {
   copy_from_ordered_range(other.begin(), other.end());
index c32a8af48c796d4457a5718039c008ad4ab3db9e..9b7011b1ff6d694995001fdcc4a2d79a9384d324 100644 (file)
@@ -47,8 +47,8 @@ assert_valid() const
 {
   std::cout << "av1" << std::endl;
 
-  if (m_a_values == NULL || m_end_it == NULL || m_size == 0)
-    _GLIBCXX_DEBUG_ASSERT(m_a_values == NULL &&  m_end_it == NULL && m_size == 0);
+  if (m_a_values == 0 || m_end_it == 0 || m_size == 0)
+    _GLIBCXX_DEBUG_ASSERT(m_a_values == 0 &&  m_end_it == 0 && m_size == 0);
 
   std::cout << "av2" << std::endl;
   assert_iterators();
index 05e7d1a11075ce1ed323b132a41a3090069a5a8d..dd24114f490b59b35a5cb2530c9787a4cd0b0b54 100644 (file)
@@ -56,7 +56,7 @@ clear()
     }
 
   _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
-  m_a_values = NULL;
+  m_a_values = 0;
   m_size = 0;
   m_end_it = m_a_values;
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
index 91d277b0cae3c847cc4aa3326da24903bfaef285..08d6bfc2293bdfbd5b04265f8abc7917d2455348 100644 (file)
@@ -50,9 +50,9 @@ void
 PB_DS_CLASS_C_DEC::
 reallocate_metadata(Node_Update_* , size_type new_size)
 {
-  metadata_pointer a_new_metadata_vec =(new_size == 0) ? NULL : s_metadata_alloc.allocate(new_size);
+  metadata_pointer a_new_metadata_vec =(new_size == 0) ? 0 : s_metadata_alloc.allocate(new_size);
 
-  if (m_a_metadata != NULL)
+  if (m_a_metadata != 0)
     {
       for (size_type i = 0; i < m_size; ++i)
        m_a_metadata[i].~metadata_type();
index 7652c4c2ea2e8c53fc88c19f02c7c0fa36a6a218..0417ae1dd9ec53f9ce66aa96508620fff94e76fd 100644 (file)
@@ -69,8 +69,8 @@ PB_DS_node_begin_imp() const
 {
   return const_node_iterator(const_cast<pointer>(mid_pointer(begin(), end())),
                              const_cast<pointer>(begin()),
-                             const_cast<pointer>(end()),(m_a_metadata == NULL)?
-                             NULL :
+                             const_cast<pointer>(end()),(m_a_metadata == 0)?
+                             0 :
                              mid_pointer(m_a_metadata, m_a_metadata + m_size));
 }
 
@@ -80,7 +80,7 @@ PB_DS_CLASS_C_DEC::
 PB_DS_node_end_imp() const
 {
   return const_node_iterator(end(), end(), end(),
-                    (m_a_metadata == NULL) ? NULL : m_a_metadata + m_size);
+                    (m_a_metadata == 0) ? 0 : m_a_metadata + m_size);
 }
 
 PB_DS_CLASS_T_DEC
@@ -89,7 +89,7 @@ PB_DS_CLASS_C_DEC::
 PB_DS_node_begin_imp()
 {
   return node_iterator(mid_pointer(begin(), end()), begin(), end(),
-                      (m_a_metadata == NULL) ? NULL : mid_pointer(m_a_metadata, m_a_metadata + m_size));
+                      (m_a_metadata == 0) ? 0 : mid_pointer(m_a_metadata, m_a_metadata + m_size));
 }
 
 PB_DS_CLASS_T_DEC
@@ -98,6 +98,6 @@ PB_DS_CLASS_C_DEC::
 PB_DS_node_end_imp()
 {
   return node_iterator(end(), end(),
-                 end(),(m_a_metadata == NULL) ? NULL : m_a_metadata + m_size);
+                 end(),(m_a_metadata == 0) ? 0 : m_a_metadata + m_size);
 }
 
index 68fedc0eb05aa9cf283c23e196b29047cdd25c0c..1c45c51c1d85a9d60d41ea08c6ef2b9b8d0e6604 100644 (file)
@@ -118,7 +118,7 @@ namespace __gnu_pbds
 
     public:
       inline
-      ov_tree_node_const_it_(const_pointer p_nd = NULL,  const_pointer p_begin_nd = NULL,  const_pointer p_end_nd = NULL,  const_metadata_pointer p_metadata = NULL) : m_p_value(const_cast<pointer>(p_nd)), m_p_begin_value(const_cast<pointer>(p_begin_nd)), m_p_end_value(const_cast<pointer>(p_end_nd)), m_p_metadata(p_metadata)
+      ov_tree_node_const_it_(const_pointer p_nd = 0,  const_pointer p_begin_nd = 0,  const_pointer p_end_nd = 0,  const_metadata_pointer p_metadata = 0) : m_p_value(const_cast<pointer>(p_nd)), m_p_begin_value(const_cast<pointer>(p_begin_nd)), m_p_end_value(const_cast<pointer>(p_end_nd)), m_p_metadata(p_metadata)
       { }
 
       inline const_reference
@@ -134,7 +134,7 @@ namespace __gnu_pbds
          };
 
        PB_DS_STATIC_ASSERT(should_have_metadata, has_metadata);
-       _GLIBCXX_DEBUG_ASSERT(m_p_metadata != NULL);
+       _GLIBCXX_DEBUG_ASSERT(m_p_metadata != 0);
        return *m_p_metadata;
       }
 
@@ -164,8 +164,8 @@ namespace __gnu_pbds
 
        return (this_type(mid_pointer(m_p_value + 1, m_p_end_value),
                          m_p_value + 1,
-                         m_p_end_value,(m_p_metadata == NULL) ?
-                         NULL : mid_pointer(m_p_metadata + 1, p_end_metadata)));
+                         m_p_end_value,(m_p_metadata == 0) ?
+                         0 : mid_pointer(m_p_metadata + 1, p_end_metadata)));
       }
 
       inline bool
@@ -241,7 +241,7 @@ namespace __gnu_pbds
 
     public:
       inline
-      ov_tree_node_it_(const_pointer p_nd = NULL,  const_pointer p_begin_nd = NULL,  const_pointer p_end_nd = NULL,  const_metadata_pointer p_metadata = NULL) : base_type(p_nd,  p_begin_nd,  p_end_nd,  p_metadata)
+      ov_tree_node_it_(const_pointer p_nd = 0,  const_pointer p_begin_nd = 0,  const_pointer p_end_nd = 0,  const_metadata_pointer p_metadata = 0) : base_type(p_nd,  p_begin_nd,  p_end_nd,  p_metadata)
       { }
 
       // Access.
@@ -277,8 +277,8 @@ namespace __gnu_pbds
 
        return (this_type(base_type::mid_pointer(base_type::m_p_value + 1, base_type::m_p_end_value),
                          base_type::m_p_value + 1,
-                         base_type::m_p_end_value,(base_type::m_p_metadata == NULL)?
-                         NULL : base_type::mid_pointer(base_type::m_p_metadata + 1, p_end_metadata)));
+                         base_type::m_p_end_value,(base_type::m_p_metadata == 0)?
+                         0 : base_type::mid_pointer(base_type::m_p_metadata + 1, p_end_metadata)));
       }
 
     };
index 7c9fc13456abdc803aab573625210bc5c6133296..51afa4fab92a8dbc29ae67ad1dddcdb066ee1b02 100644 (file)
@@ -45,8 +45,8 @@ void
 PB_DS_CLASS_C_DEC::
 assert_valid() const
 {
-  _GLIBCXX_DEBUG_ASSERT(base_type::m_p_root == NULL 
-                       || base_type::m_p_root->m_p_next_sibling == NULL);
+  _GLIBCXX_DEBUG_ASSERT(base_type::m_p_root == 0 
+                       || base_type::m_p_root->m_p_next_sibling == 0);
   base_type::assert_valid();
 }
 
index 905be1098cfca63ab9932c59875b4a521cca3dd5..226e9531ada53606e83fd9b521a634a4a1f9968a 100644 (file)
@@ -48,8 +48,8 @@ pop()
 
   node_pointer p_new_root = join_node_children(base_type::m_p_root);
   _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_new_root, false);)
-  if (p_new_root != NULL)
-    p_new_root->m_p_prev_or_parent = NULL;
+  if (p_new_root != 0)
+    p_new_root->m_p_prev_or_parent = 0;
 
   base_type::actual_erase_node(base_type::m_p_root);
   base_type::m_p_root = p_new_root;
@@ -78,27 +78,27 @@ remove_node(node_pointer p_nd)
   node_pointer p_new_child = join_node_children(p_nd);
 
 #ifdef _GLIBCXX_DEBUG
-  if (p_new_child != NULL)
+  if (p_new_child != 0)
     base_type::assert_node_consistent(p_new_child, false);
 #endif 
 
   if (p_nd == base_type::m_p_root)
     {
-      if (p_new_child != NULL)
-       p_new_child->m_p_prev_or_parent = NULL;
+      if (p_new_child != 0)
+       p_new_child->m_p_prev_or_parent = 0;
       base_type::m_p_root = p_new_child;
       _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(base_type::m_p_root, false);)
       return;
     }
 
-  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_prev_or_parent != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_prev_or_parent != 0);
   if (p_nd->m_p_prev_or_parent->m_p_l_child == p_nd)
     {
-      if (p_new_child != NULL)
+      if (p_new_child != 0)
         {
          p_new_child->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
          p_new_child->m_p_next_sibling = p_nd->m_p_next_sibling;
-         if (p_new_child->m_p_next_sibling != NULL)
+         if (p_new_child->m_p_next_sibling != 0)
            p_new_child->m_p_next_sibling->m_p_prev_or_parent = p_new_child;
          p_nd->m_p_prev_or_parent->m_p_l_child = p_new_child;
          _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd->m_p_prev_or_parent, false);)
@@ -106,17 +106,17 @@ remove_node(node_pointer p_nd)
         }
 
       p_nd->m_p_prev_or_parent->m_p_l_child = p_nd->m_p_next_sibling;
-      if (p_nd->m_p_next_sibling != NULL)
+      if (p_nd->m_p_next_sibling != 0)
        p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
       _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd->m_p_prev_or_parent, false);)
       return;
     }
 
-  if (p_new_child != NULL)
+  if (p_new_child != 0)
     {
       p_new_child->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
       p_new_child->m_p_next_sibling = p_nd->m_p_next_sibling;
-      if (p_new_child->m_p_next_sibling != NULL)
+      if (p_new_child->m_p_next_sibling != 0)
        p_new_child->m_p_next_sibling->m_p_prev_or_parent = p_new_child;
       p_new_child->m_p_prev_or_parent->m_p_next_sibling = p_new_child;
       _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd->m_p_prev_or_parent, false);)
@@ -124,7 +124,7 @@ remove_node(node_pointer p_nd)
     }
 
   p_nd->m_p_prev_or_parent->m_p_next_sibling = p_nd->m_p_next_sibling;
-  if (p_nd->m_p_next_sibling != NULL)
+  if (p_nd->m_p_next_sibling != 0)
     p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
   _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd->m_p_prev_or_parent, false);)
 }
@@ -134,11 +134,11 @@ typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 join_node_children(node_pointer p_nd)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
   node_pointer p_ret = p_nd->m_p_l_child;
-  if (p_ret == NULL)
-    return NULL;
-  while (p_ret->m_p_next_sibling != NULL)
+  if (p_ret == 0)
+    return 0;
+  while (p_ret->m_p_next_sibling != 0)
     p_ret = forward_join(p_ret, p_ret->m_p_next_sibling);
   while (p_ret->m_p_prev_or_parent != p_nd)
     p_ret = back_join(p_ret->m_p_prev_or_parent, p_ret);
@@ -151,17 +151,17 @@ typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 forward_join(node_pointer p_nd, node_pointer p_next)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
   _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling == p_next);
   if (Cmp_Fn::operator()(p_nd->m_value, p_next->m_value))
     {
       p_next->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
       base_type::make_child_of(p_nd, p_next);
-      return p_next->m_p_next_sibling == NULL 
+      return p_next->m_p_next_sibling == 0 
        ? p_next : p_next->m_p_next_sibling;
     }
 
-  if (p_next->m_p_next_sibling != NULL)
+  if (p_next->m_p_next_sibling != 0)
     {
       p_next->m_p_next_sibling->m_p_prev_or_parent = p_nd;
       p_nd->m_p_next_sibling = p_next->m_p_next_sibling;
@@ -169,7 +169,7 @@ forward_join(node_pointer p_nd, node_pointer p_next)
       return p_nd->m_p_next_sibling;
     }
 
-  p_nd->m_p_next_sibling = NULL;
+  p_nd->m_p_next_sibling = 0;
   base_type::make_child_of(p_next, p_nd);
   _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd, false));
   return p_nd;
@@ -180,8 +180,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 back_join(node_pointer p_nd, node_pointer p_next)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_next->m_p_next_sibling == NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_next->m_p_next_sibling == 0);
 
   if (Cmp_Fn::operator()(p_nd->m_value, p_next->m_value))
     {
@@ -191,7 +191,7 @@ back_join(node_pointer p_nd, node_pointer p_next)
       return p_next;
     }
 
-  p_nd->m_p_next_sibling = NULL;
+  p_nd->m_p_next_sibling = 0;
   base_type::make_child_of(p_next, p_nd);
   _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd, false));
   return p_nd;
@@ -212,7 +212,7 @@ erase_if(Pred pred)
   base_type::to_linked_list();
   node_pointer p_out = base_type::prune(pred);
   size_type ersd = 0;
-  while (p_out != NULL)
+  while (p_out != 0)
     {
       ++ersd;
       node_pointer p_next = p_out->m_p_next_sibling;
@@ -221,11 +221,11 @@ erase_if(Pred pred)
     }
 
   node_pointer p_cur = base_type::m_p_root;
-  base_type::m_p_root = NULL;
-  while (p_cur != NULL)
+  base_type::m_p_root = 0;
+  while (p_cur != 0)
     {
       node_pointer p_next = p_cur->m_p_next_sibling;
-      p_cur->m_p_l_child = p_cur->m_p_next_sibling = p_cur->m_p_prev_or_parent = NULL;
+      p_cur->m_p_l_child = p_cur->m_p_next_sibling = p_cur->m_p_prev_or_parent = 0;
 
       push_imp(p_cur);
       p_cur = p_next;
index b00e9d13cdf7dcbad19f39c19d53a0a61c2d135f..af929e58131cf008a59c32a2b1fe4f1ec39e2adf 100644 (file)
@@ -59,17 +59,17 @@ inline void
 PB_DS_CLASS_C_DEC::
 push_imp(node_pointer p_nd)
 {
-  p_nd->m_p_l_child = NULL;
+  p_nd->m_p_l_child = 0;
 
-  if (base_type::m_p_root == NULL)
+  if (base_type::m_p_root == 0)
     {
-      p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent = NULL;
+      p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent = 0;
 
       base_type::m_p_root = p_nd;
     }
   else if (Cmp_Fn::operator()(base_type::m_p_root->m_value, p_nd->m_value))
     {
-      p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent = NULL;
+      p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent = 0;
 
       base_type::make_child_of(base_type::m_p_root, p_nd);
       _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd, false));
index 85d4ddf074a49b2594920fd42eaa6d1c3ca21535..12032734f4ed35e79ce9547b7b160cc972c47372 100644 (file)
@@ -61,7 +61,7 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other)
 
   node_pointer p_out = base_type::prune(pred);
 
-  while (p_out != NULL)
+  while (p_out != 0)
     {
       _GLIBCXX_DEBUG_ASSERT(base_type::m_size > 0);
       --base_type::m_size;
@@ -70,7 +70,7 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other)
 
       node_pointer p_next = p_out->m_p_next_sibling;
 
-      p_out->m_p_l_child = p_out->m_p_next_sibling = p_out->m_p_prev_or_parent = NULL;
+      p_out->m_p_l_child = p_out->m_p_next_sibling = p_out->m_p_prev_or_parent = 0;
 
       other.push_imp(p_out);
 
@@ -81,13 +81,13 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other)
 
     node_pointer p_cur = base_type::m_p_root;
 
-  base_type::m_p_root = NULL;
+  base_type::m_p_root = 0;
 
-  while (p_cur != NULL)
+  while (p_cur != 0)
     {
       node_pointer p_next = p_cur->m_p_next_sibling;
 
-      p_cur->m_p_l_child = p_cur->m_p_next_sibling = p_cur->m_p_prev_or_parent = NULL;
+      p_cur->m_p_l_child = p_cur->m_p_next_sibling = p_cur->m_p_prev_or_parent = 0;
 
       push_imp(p_cur);
 
@@ -106,7 +106,7 @@ join(PB_DS_CLASS_C_DEC& other)
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
     _GLIBCXX_DEBUG_ONLY(other.assert_valid();)
 
-    if (other.m_p_root == NULL)
+    if (other.m_p_root == 0)
       {
         _GLIBCXX_DEBUG_ONLY(assert_valid();)
          _GLIBCXX_DEBUG_ONLY(other.assert_valid();)
@@ -114,7 +114,7 @@ join(PB_DS_CLASS_C_DEC& other)
          return;
       }
 
-  if (base_type::m_p_root == NULL)
+  if (base_type::m_p_root == 0)
     base_type::m_p_root = other.m_p_root;
   else if (Cmp_Fn::operator()(base_type::m_p_root->m_value, other.m_p_root->m_value))
     {
@@ -131,7 +131,7 @@ join(PB_DS_CLASS_C_DEC& other)
 
   base_type::m_size += other.m_size;
 
-  other.m_p_root = NULL;
+  other.m_p_root = 0;
   other.m_size = 0;
 
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
index 15f349efbed9777c2e4af99d2c69d8770e4d11ce..8decad5a7f0d40a02d6c5f776f49c2e318a011b1 100644 (file)
@@ -48,8 +48,8 @@ public:
   typedef node_pointer_reference reference;
 
   inline
-  iterator(node_pointer_pointer p_p_cur = NULL,  
-          node_pointer_pointer p_p_end = NULL
+  iterator(node_pointer_pointer p_p_cur = 0,  
+          node_pointer_pointer p_p_end = 0
   : const_iterator(p_p_cur, p_p_end)
   { }
 
index bc349cf2dbd4dac89fa8bd216a9643c9d6615461..5cc9c2234c605c280eb6722697d69403855c24d0 100644 (file)
@@ -53,8 +53,8 @@ public:
 
 public:
   inline
-  const_iterator(node_pointer_pointer p_p_cur = NULL,  
-                node_pointer_pointer p_p_end = NULL
+  const_iterator(node_pointer_pointer p_p_cur = 0,  
+                node_pointer_pointer p_p_end = 0
   : m_p_p_cur(p_p_cur), m_p_p_end(p_p_end)
   { }
 
@@ -71,7 +71,7 @@ public:
   {
     do
       ++m_p_p_cur;
-    while (m_p_p_cur != m_p_p_end&& * m_p_p_cur == NULL);
+    while (m_p_p_cur != m_p_p_end&& * m_p_p_cur == 0);
     return *this;
   }
 
@@ -101,7 +101,7 @@ protected:
 #ifdef _GLIBCXX_DEBUG
   void
   assert_referencible() const
-  { _GLIBCXX_DEBUG_ASSERT(m_p_p_cur != m_p_p_end&& * m_p_p_cur != NULL); }
+  { _GLIBCXX_DEBUG_ASSERT(m_p_p_cur != m_p_p_end&& * m_p_p_cur != 0); }
 #endif 
 
 public:
index ca38f932a62136abeb9458a2c8c7bc508798db67..4d4b52a55ebfef36747d5291a81d4035c9188aea 100644 (file)
@@ -85,7 +85,7 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
   initialize();
   m_size = other.m_size;
   _GLIBCXX_DEBUG_ONLY(other.assert_valid();)
-    if (other.m_p_head->m_p_parent == NULL)
+    if (other.m_p_head->m_p_parent == 0)
       {
         _GLIBCXX_DEBUG_ONLY(assert_valid();)
         return;
@@ -143,7 +143,7 @@ PB_DS_CLASS_C_DEC::
 initialize()
 {
   new (m_p_head) head();
-  m_p_head->m_p_parent = NULL;
+  m_p_head->m_p_parent = 0;
   m_p_head->m_p_min = m_p_head;
   m_p_head->m_p_max = m_p_head;
   m_size = 0;
@@ -164,7 +164,7 @@ typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 recursive_copy_node(const_node_pointer p_other_nd)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_other_nd != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_other_nd != 0);
   if (p_other_nd->m_type == pat_trie_leaf_node_type)
     {
       const_leaf_pointer p_other_leaf = static_cast<const_leaf_pointer>(p_other_nd);
index de75657881bba1f78794cf784a74a399241b8dcc..664206499b21849c9d036e5d3df6b081e76d8b9d 100644 (file)
@@ -45,11 +45,11 @@ void
 PB_DS_CLASS_C_DEC::
 assert_valid() const
 {
-  if (m_p_head->m_p_parent != NULL)
+  if (m_p_head->m_p_parent != 0)
     m_p_head->m_p_parent->assert_valid(this);
   assert_iterators();
   assert_reverse_iterators();
-  if (m_p_head->m_p_parent == NULL)
+  if (m_p_head->m_p_parent == 0)
     {
       _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_min == m_p_head);
       _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_max == m_p_head);
@@ -99,7 +99,7 @@ typename PB_DS_CLASS_C_DEC::size_type
 PB_DS_CLASS_C_DEC::
 recursive_count_leafs(const_node_pointer p_nd)
 {
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return (0);
   if (p_nd->m_type == pat_trie_leaf_node_type)
     return (1);
index 90988184a8d7952132326d36e2dd0b483c20aa64..57e998981a8dc40b06a44939d6fdeb8fb2edb060 100644 (file)
@@ -44,7 +44,7 @@ PB_DS_CLASS_C_DEC::
 erase(const_key_reference r_key)
 {
   node_pointer p_nd = find_imp(r_key);
-  if (p_nd == NULL || p_nd->m_type == pat_trie_internal_node_type)
+  if (p_nd == 0 || p_nd->m_type == pat_trie_internal_node_type)
     {
       _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key));
       return false;
index 2552ead8bc5a65e7410e4081cdead23c147a5178..f53af2563395cbdd06a3767829bc12b5a7bb1821 100644 (file)
@@ -46,7 +46,7 @@ find(const_key_reference r_key)
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   node_pointer p_nd = find_imp(r_key);
 
-  if (p_nd == NULL || p_nd->m_type != pat_trie_leaf_node_type)
+  if (p_nd == 0 || p_nd->m_type != pat_trie_leaf_node_type)
     {
       _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
       return end();
@@ -71,7 +71,7 @@ find(const_key_reference r_key) const
 
   const_node_pointer p_nd = const_cast<PB_DS_CLASS_C_DEC* >(this)->find_imp(r_key);
 
-  if (p_nd == NULL || p_nd->m_type != pat_trie_leaf_node_type)
+  if (p_nd == 0 || p_nd->m_type != pat_trie_leaf_node_type)
     {
       _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
       return end();
@@ -93,7 +93,7 @@ PB_DS_CLASS_C_DEC::
 find_imp(const_key_reference r_key)
 {
   if (empty())
-    return (NULL);
+    return (0);
 
   typename synth_e_access_traits::const_iterator b_it =
     synth_e_access_traits::begin(r_key);
@@ -101,14 +101,14 @@ find_imp(const_key_reference r_key)
     synth_e_access_traits::end(r_key);
 
   node_pointer p_nd = m_p_head->m_p_parent;
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
 
   while (p_nd->m_type != pat_trie_leaf_node_type)
     {
       _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == pat_trie_internal_node_type);
       node_pointer p_next_nd = static_cast<internal_node_pointer>(p_nd)->get_child_node(b_it,  e_it,  this);
 
-      if (p_next_nd == NULL)
+      if (p_next_nd == 0)
        return p_nd;
       p_nd = p_next_nd;
     }
@@ -124,7 +124,7 @@ lower_bound_imp(const_key_reference r_key)
     return (m_p_head);
 
   node_pointer p_nd = m_p_head->m_p_parent;
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
 
   typename PB_DS_CLASS_C_DEC::const_e_iterator b_it =
     synth_e_access_traits::begin(r_key);
index e6049743f619fd2a919edf20a6f7bbcda51621b5..de3cb35276b8001ae0ef6a9f5336107e0d964311 100644 (file)
@@ -165,7 +165,7 @@ rec_join_prep(const_internal_node_pointer p_l, const_internal_node_pointer p_r,
           it != p_r->end(); ++ it)
         {
          const_node_pointer p_l_join_child = p_l->get_join_child(*it, this);
-         if (p_l_join_child != NULL)
+         if (p_l_join_child != 0)
            rec_join_prep(p_l_join_child, * it, r_bag);
         }
       return;
@@ -175,7 +175,7 @@ rec_join_prep(const_internal_node_pointer p_l, const_internal_node_pointer p_r,
       p_r->should_be_mine(p_l->pref_b_it(), p_l->pref_e_it(), 0, this))
     {
       const_node_pointer p_r_join_child = p_r->get_join_child(p_l, this);
-      if (p_r_join_child != NULL)
+      if (p_r_join_child != 0)
        rec_join_prep(p_r_join_child, p_l, r_bag);
       return;
     }
@@ -184,7 +184,7 @@ rec_join_prep(const_internal_node_pointer p_l, const_internal_node_pointer p_r,
       p_r->should_be_mine(p_l->pref_b_it(), p_l->pref_e_it(), 0, this))
     {
       const_node_pointer p_r_join_child = p_r->get_join_child(p_l, this);
-      if (p_r_join_child != NULL)
+      if (p_r_join_child != 0)
        rec_join_prep(p_r_join_child, p_l, r_bag);
       return;
     }
@@ -196,8 +196,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 rec_join(node_pointer p_l, node_pointer p_r, size_type checked_ind, split_join_branch_bag& r_bag)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_r != NULL);
-  if (p_l == NULL)
+  _GLIBCXX_DEBUG_ASSERT(p_r != 0);
+  if (p_l == 0)
     {
       apply_update(p_r, (node_update* )this);
       return (p_r);
@@ -245,8 +245,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 rec_join(leaf_pointer p_l, leaf_pointer p_r, split_join_branch_bag& r_bag)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_r != NULL);
-  if (p_l == NULL)
+  _GLIBCXX_DEBUG_ASSERT(p_r != 0);
+  if (p_l == 0)
     return (p_r);
   node_pointer p_ret = insert_branch(p_l, p_r, r_bag);
   _GLIBCXX_DEBUG_ASSERT(recursive_count_leafs(p_ret) == 2);
@@ -264,7 +264,7 @@ rec_join(leaf_pointer p_l, internal_node_pointer p_r, size_type checked_ind,
   const size_type rhs_leafs = recursive_count_leafs(p_r);
 #endif 
 
-  _GLIBCXX_DEBUG_ASSERT(p_r != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_r != 0);
   node_pointer p_ret = rec_join(p_r, p_l, checked_ind, r_bag);
   _GLIBCXX_DEBUG_ASSERT(recursive_count_leafs(p_ret) == lhs_leafs + rhs_leafs);
   return p_ret;
@@ -275,8 +275,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 rec_join(internal_node_pointer p_l, leaf_pointer p_r, size_type checked_ind, split_join_branch_bag& r_bag)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_l != NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_r != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_l != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_r != 0);
 
 #ifdef _GLIBCXX_DEBUG
   const size_type lhs_leafs = recursive_count_leafs(p_l);
@@ -313,8 +313,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 rec_join(internal_node_pointer p_l, internal_node_pointer p_r, split_join_branch_bag& r_bag)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_l != NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_r != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_l != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_r != 0);
 
 #ifdef _GLIBCXX_DEBUG
   const size_type lhs_leafs = recursive_count_leafs(p_l);
@@ -378,7 +378,7 @@ PB_DS_CLASS_C_DEC::
 insert(const_reference r_val)
 {
   node_pointer p_lf = find_imp(PB_DS_V2F(r_val));
-  if (p_lf != NULL && p_lf->m_type == pat_trie_leaf_node_type && 
+  if (p_lf != 0 && p_lf->m_type == pat_trie_leaf_node_type && 
       synth_e_access_traits::equal_keys(PB_DS_V2F(static_cast<leaf_pointer>(p_lf)->value()), PB_DS_V2F(r_val)))
     {
       _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(PB_DS_V2F(r_val)));
index bf2f42916dd8655a60c0979fed04880e3487839c..56cf13304976c075b49b2ada4e59b603a7b99a99 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -226,7 +226,7 @@ namespace __gnu_pbds
     get_pref_pos(const_e_iterator b_it, const_e_iterator e_it, 
                 const_e_access_traits_pointer p_traits) const
     {
-      if (static_cast<size_t>(std::distance(b_it, e_it)) <= m_e_ind)
+      if (static_cast<std::size_t>(std::distance(b_it, e_it)) <= m_e_ind)
        return 0;
       std::advance(b_it, m_e_ind);
       return 1 + p_traits->e_pos(*b_it);
@@ -240,7 +240,7 @@ namespace __gnu_pbds
     {
       std::advance(m_pref_e_it, m_e_ind);
       std::fill(m_a_p_children, m_a_p_children + arr_size,
-               static_cast<node_pointer>(NULL));
+               static_cast<node_pointer>(0));
     }
 
     PB_DS_CLASS_T_DEC
@@ -317,7 +317,7 @@ namespace __gnu_pbds
     {
       const size_type i = get_pref_pos(b_it, e_it, p_traits);
       _GLIBCXX_DEBUG_ASSERT(i < arr_size);
-      _GLIBCXX_DEBUG_ASSERT(m_a_p_children[i] != NULL);
+      _GLIBCXX_DEBUG_ASSERT(m_a_p_children[i] != 0);
       return iterator(m_a_p_children + i, m_a_p_children + i);
     }
 
@@ -345,11 +345,11 @@ namespace __gnu_pbds
       size_type i = get_pref_pos(b_it, e_it, p_traits);
       _GLIBCXX_DEBUG_ASSERT(i < arr_size);
 
-      if (m_a_p_children[i] != NULL)
+      if (m_a_p_children[i] != 0)
        return m_a_p_children[i];
 
       while (++i < arr_size)
-       if (m_a_p_children[i] != NULL)
+       if (m_a_p_children[i] != 0)
          {
            if (m_a_p_children[i]->m_type == pat_trie_leaf_node_type)
              return m_a_p_children[i];
@@ -370,7 +370,7 @@ namespace __gnu_pbds
     {
       const size_type i = get_pref_pos(b_it, e_it, p_traits);
       _GLIBCXX_DEBUG_ASSERT(i < arr_size);
-      if (m_a_p_children[i] == NULL)
+      if (m_a_p_children[i] == 0)
        {
          m_a_p_children[i] = p_nd;
          p_nd->m_p_parent = this;
@@ -423,7 +423,7 @@ namespace __gnu_pbds
       for (; i < arr_size; ++i)
        if (m_a_p_children[i] == p_nd)
          {
-           m_a_p_children[i] = NULL;
+           m_a_p_children[i] = 0;
            return;
          }
       _GLIBCXX_DEBUG_ASSERT(i != arr_size);
@@ -436,7 +436,7 @@ namespace __gnu_pbds
     {
       iterator ret = it;
       ++ret;
-      * it.m_p_p_cur = NULL;
+      * it.m_p_p_cur = 0;
       return ret;
     }
 
@@ -558,7 +558,7 @@ namespace __gnu_pbds
     get_begin_pos() const
     {
       size_type i;
-      for (i = 0; i < arr_size && m_a_p_children[i] == NULL; ++i)
+      for (i = 0; i < arr_size && m_a_p_children[i] == 0; ++i)
        ;
       return i;
     }
index 9902d96dbb15e24bb38b822cb1775be9791e4b99..893a762056d5bb5969e4e19d9baaf57e85332b99 100644 (file)
@@ -110,11 +110,11 @@ PB_DS_CLASS_T_DEC
 inline typename PB_DS_CLASS_C_DEC::const_node_iterator
 PB_DS_CLASS_C_DEC::
 node_end() const
-{ return const_node_iterator(NULL, this); }
+{ return const_node_iterator(0, this); }
 
 PB_DS_CLASS_T_DEC
 inline typename PB_DS_CLASS_C_DEC::node_iterator
 PB_DS_CLASS_C_DEC::
 node_end()
-{ return node_iterator(NULL, this); }
+{ return node_iterator(0, this); }
 
index 37250091d00afd9e9f8646a47db75b3883ea65b6..eb5e0002b9f6577de8a1172b7204ae98209e5f68 100644 (file)
@@ -180,8 +180,8 @@ namespace __gnu_pbds
        pat_trie_const_node_it_()
       */
       inline
-      pat_trie_const_node_it_(node_pointer p_nd = NULL,  
-                             const_e_access_traits_pointer p_traits = NULL
+      pat_trie_const_node_it_(node_pointer p_nd = 0,  
+                             const_e_access_traits_pointer p_traits = 0
       : m_p_nd(const_cast<node_pointer>(p_nd)), m_p_traits(p_traits)
       { }
 
@@ -299,7 +299,7 @@ namespace __gnu_pbds
       */
 
       inline
-      pat_trie_node_it_(node_pointer p_nd = NULL,  const_e_access_traits_pointer p_traits = NULL) : base_type(p_nd, p_traits)
+      pat_trie_node_it_(node_pointer p_nd = 0,  const_e_access_traits_pointer p_traits = 0) : base_type(p_nd, p_traits)
       { }
 
       // Access; returns the iterator*  associated with the current leaf.
index cada9071c51c1ec40d758a7c02d1a9be0b7acaae..0a142478eb81512142f40c974ae6c381a162dd17 100644 (file)
@@ -145,7 +145,7 @@ namespace __gnu_pbds
     public:
 
       inline
-      pat_trie_const_it_(node_pointer p_nd = NULL) : m_p_nd(p_nd)
+      pat_trie_const_it_(node_pointer p_nd = 0) : m_p_nd(p_nd)
       { }
 
       inline
@@ -245,7 +245,7 @@ namespace __gnu_pbds
 
        node_pointer p_y = m_p_nd->m_p_parent;
        while (p_y->m_type != pat_trie_head_node_type && 
-              get_larger_sibling(m_p_nd) == NULL)
+              get_larger_sibling(m_p_nd) == 0)
          {
            m_p_nd = p_y;
            p_y = p_y->m_p_parent;
@@ -274,7 +274,7 @@ namespace __gnu_pbds
 
        node_pointer p_y = m_p_nd->m_p_parent;
        while (p_y->m_type != pat_trie_head_node_type && 
-              get_smaller_sibling(m_p_nd) == NULL)
+              get_smaller_sibling(m_p_nd) == 0)
          {
            m_p_nd = p_y;
            p_y = p_y->m_p_parent;
@@ -300,7 +300,7 @@ namespace __gnu_pbds
 
        typename Internal_Node::iterator next_it = it;
        ++next_it;
-       return ((next_it == p_parent->end())? NULL :* next_it);
+       return ((next_it == p_parent->end())? 0 :* next_it);
       }
 
       inline static node_pointer
@@ -312,7 +312,7 @@ namespace __gnu_pbds
        typename Internal_Node::iterator it = p_parent->begin();
 
        if (*it == p_nd)
-         return (NULL);
+         return (0);
        typename Internal_Node::iterator prev_it;
        do
          {
@@ -324,7 +324,7 @@ namespace __gnu_pbds
        while (true);
 
        _GLIBCXX_DEBUG_ASSERT(false);
-       return (NULL);
+       return (0);
       }
 
       inline static leaf_pointer
@@ -397,7 +397,7 @@ namespace __gnu_pbds
       typedef typename Type_Traits::reference reference;
 
       inline
-      pat_trie_it_(node_pointer p_nd = NULL) : PB_DS_CONST_IT_C_DEC((node_pointer)p_nd)
+      pat_trie_it_(node_pointer p_nd = 0) : PB_DS_CONST_IT_C_DEC((node_pointer)p_nd)
       { }
 
       inline
index 52edf2506359f0bfac830e6b7f6f40851bc7f909..bfb456392b232966b22dfd498ff5cf591ee93ce1 100644 (file)
@@ -93,7 +93,7 @@ void
 PB_DS_CLASS_C_DEC::
 clear_imp(node_pointer p_nd)
 {
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return;
   clear_imp(p_nd->m_p_left);
   clear_imp(p_nd->m_p_right);
index c0809fa48bcbe1d0a17cf501eea0396e2e892415..40dc38c71b4d493b6211cff80a25cb5b1bca3bba 100644 (file)
@@ -46,7 +46,7 @@ rotate_left(node_pointer p_x)
   node_pointer p_y = p_x->m_p_right;
   p_x->m_p_right = p_y->m_p_left;
 
-  if (p_y->m_p_left != NULL)
+  if (p_y->m_p_left != 0)
     p_y->m_p_left->m_p_parent = p_x;
 
   p_y->m_p_parent = p_x->m_p_parent;
@@ -75,7 +75,7 @@ rotate_right(node_pointer p_x)
   node_pointer p_y = p_x->m_p_left;
   p_x->m_p_left = p_y->m_p_right;
 
-  if (p_y->m_p_right != NULL)
+  if (p_y->m_p_right != 0)
     p_y->m_p_right->m_p_parent = p_x;
 
   p_y->m_p_parent = p_x->m_p_parent;
@@ -122,10 +122,10 @@ inline void
 PB_DS_CLASS_C_DEC::
 apply_update(node_pointer p_nd, Node_Update_* p_update)
 {
-  p_update->operator()(& PB_DS_V2F(p_nd->m_value),(p_nd->m_p_left == NULL) ?
-                       NULL :
-                       & PB_DS_V2F(p_nd->m_p_left->m_value),(p_nd->m_p_right == NULL) ?
-                       NULL :
+  p_update->operator()(& PB_DS_V2F(p_nd->m_value),(p_nd->m_p_left == 0) ?
+                       0 :
+                       & PB_DS_V2F(p_nd->m_p_left->m_value),(p_nd->m_p_right == 0) ?
+                       0 :
                        & PB_DS_V2F(p_nd->m_p_right->m_value));
 }
 
index 9779a4bcd22bed7a943deb7852af7eebae787958..320d32c0667181f9e922d99638f709afbddfe547 100644 (file)
@@ -47,7 +47,7 @@ split(const_key_reference r_key, PB_DS_CLASS_C_DEC& other)
   _GLIBCXX_DEBUG_ONLY(other.assert_valid(););
   split_join_branch_bag bag;
   leaf_pointer p_split_lf = split_prep(r_key, other, bag);
-  if (p_split_lf == NULL)
+  if (p_split_lf == 0)
     {
       _GLIBCXX_DEBUG_ASSERT(bag.empty());
       _GLIBCXX_DEBUG_ONLY(assert_valid();)
@@ -88,7 +88,7 @@ split_prep(const_key_reference r_key, PB_DS_CLASS_C_DEC& other, split_join_branc
       other.clear();
       _GLIBCXX_DEBUG_ONLY(assert_valid(););
       _GLIBCXX_DEBUG_ONLY(other.assert_valid(););
-      return (NULL);
+      return (0);
     }
 
   if (synth_e_access_traits::cmp_keys(r_key,
@@ -98,7 +98,7 @@ split_prep(const_key_reference r_key, PB_DS_CLASS_C_DEC& other, split_join_branc
       value_swap(other);
       _GLIBCXX_DEBUG_ONLY(assert_valid(););
       _GLIBCXX_DEBUG_ONLY(other.assert_valid(););
-      return (NULL);
+      return (0);
     }
 
   if (!synth_e_access_traits::cmp_keys(r_key,
@@ -106,7 +106,7 @@ split_prep(const_key_reference r_key, PB_DS_CLASS_C_DEC& other, split_join_branc
     {
       _GLIBCXX_DEBUG_ONLY(assert_valid(););
       _GLIBCXX_DEBUG_ONLY(other.assert_valid(););
-      return (NULL);
+      return (0);
     }
 
   iterator it = lower_bound(r_key);
@@ -134,7 +134,7 @@ rec_split(node_pointer p_nd, const_e_iterator b_it, const_e_iterator e_it, PB_DS
 {
   if (p_nd->m_type == pat_trie_leaf_node_type)
     {
-      _GLIBCXX_DEBUG_ASSERT(other.m_p_head->m_p_parent == NULL);
+      _GLIBCXX_DEBUG_ASSERT(other.m_p_head->m_p_parent == 0);
       return (p_nd);
     }
 
@@ -202,27 +202,27 @@ PB_DS_CLASS_C_DEC::
 split_insert_branch(size_type e_ind, const_e_iterator b_it, typename internal_node::iterator child_b_it, size_type num_children, split_join_branch_bag& r_bag)
 {
 #ifdef _GLIBCXX_DEBUG
-  if (m_p_head->m_p_parent != NULL)
+  if (m_p_head->m_p_parent != 0)
     m_p_head->m_p_parent->assert_valid(this);
 #endif 
 
-  const size_type total_num_children =((m_p_head->m_p_parent == NULL)? 0 : 1) + num_children;
+  const size_type total_num_children =((m_p_head->m_p_parent == 0)? 0 : 1) + num_children;
 
   if (total_num_children == 0)
     {
-      _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_parent == NULL);
+      _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_parent == 0);
       return;
     }
 
   if (total_num_children == 1)
     {
-      if (m_p_head->m_p_parent != NULL)
+      if (m_p_head->m_p_parent != 0)
         {
          _GLIBCXX_DEBUG_ONLY(m_p_head->m_p_parent->assert_valid(this);)
           return;
         }
 
-      _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_parent == NULL);
+      _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_parent == 0);
       m_p_head->m_p_parent =* child_b_it;
       m_p_head->m_p_parent->m_p_parent = m_p_head;
       apply_update(m_p_head->m_p_parent, (node_update* )this);
@@ -242,7 +242,7 @@ split_insert_branch(size_type e_ind, const_e_iterator b_it, typename internal_no
       ++child_b_it;
     }
 
-  if (m_p_head->m_p_parent != NULL)
+  if (m_p_head->m_p_parent != 0)
     p_new_root->add_child(m_p_head->m_p_parent, 
                          pref_begin(m_p_head->m_p_parent),
                          pref_end(m_p_head->m_p_parent), this);
index e4b20943be6516d1551589a4b8443a95032ae470..e6af80413a4bc18b17db51fe2a433da645e51106 100644 (file)
@@ -46,7 +46,7 @@ PB_DS_CLASS_C_DEC::
 trace() const
 {
   std::cerr << std::endl;
-  if (m_p_head->m_p_parent == NULL)
+  if (m_p_head->m_p_parent == 0)
     return;
   trace_node(m_p_head->m_p_parent, 0);
   std::cerr << std::endl;
index 6d275e731d16f644fe1c652b34de174ee3d8312e..1eecdc109904e3b1da41916895c26d9f9aeaafca 100644 (file)
@@ -51,5 +51,5 @@ PB_DS_CLASS_C_DEC::
 apply_update(node_pointer p_nd, Node_Update_*  /*p_update*/)
 {
   Node_Update_::operator()(node_iterator(p_nd, this),
-                          const_node_iterator(NULL, this));
+                          const_node_iterator(0, this));
 }
index 18ecc4230ed25bd276106b3d4ad148d84357d2f6..7cdadfc5f83fb9e80a15c9f054edff06c76f26ff 100644 (file)
@@ -45,7 +45,7 @@ typename PB_DS_CLASS_C_DEC::size_type
 PB_DS_CLASS_C_DEC::
 assert_node_consistent(const node_pointer p_nd) const
 {
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return 1;
 
   const size_type l_height = assert_node_consistent(p_nd->m_p_left);
@@ -67,7 +67,7 @@ assert_valid() const
   base_type::assert_valid();
   const node_pointer p_head = base_type::m_p_head;
   _GLIBCXX_DEBUG_ASSERT(p_head->m_red);
-  if (p_head->m_p_parent != NULL)
+  if (p_head->m_p_parent != 0)
     {
       _GLIBCXX_DEBUG_ASSERT(!p_head->m_p_parent->m_red);
       assert_node_consistent(p_head->m_p_parent);
index 685b8a51b6baa869d3a29b2fa5d12fda1abd3a5e..2ae4cef072cff47ba2fc82f542f1ae23d4781237 100644 (file)
@@ -123,17 +123,17 @@ remove_node(node_pointer p_z)
 {
   update_min_max_for_erased_node(p_z);
   node_pointer p_y = p_z;
-  node_pointer p_x = NULL;
-  node_pointer p_new_x_parent = NULL;
+  node_pointer p_x = 0;
+  node_pointer p_new_x_parent = 0;
 
-  if (p_y->m_p_left == NULL)
+  if (p_y->m_p_left == 0)
     p_x = p_y->m_p_right;
-  else if (p_y->m_p_right == NULL)
+  else if (p_y->m_p_right == 0)
     p_x = p_y->m_p_left;
   else
     {
       p_y = p_y->m_p_right;
-      while (p_y->m_p_left != NULL)
+      while (p_y->m_p_left != 0)
        p_y = p_y->m_p_left;
       p_x = p_y->m_p_right;
     }
@@ -141,7 +141,7 @@ remove_node(node_pointer p_z)
   if (p_y == p_z)
     {
       p_new_x_parent = p_y->m_p_parent;
-      if (p_x != NULL)
+      if (p_x != 0)
        p_x->m_p_parent = p_y->m_p_parent;
 
       if (base_type::m_p_head->m_p_parent == p_z)
@@ -153,7 +153,7 @@ remove_node(node_pointer p_z)
         }
       else
         {
-         p_y->m_p_left = NULL;
+         p_y->m_p_left = 0;
          p_z->m_p_parent->m_p_right = p_x;
         }
     }
@@ -164,7 +164,7 @@ remove_node(node_pointer p_z)
       if (p_y != p_z->m_p_right)
         {
          p_new_x_parent = p_y->m_p_parent;
-         if (p_x != NULL)
+         if (p_x != 0)
            p_x->m_p_parent = p_y->m_p_parent;
          p_y->m_p_parent->m_p_left = p_x;
          p_y->m_p_right = p_z->m_p_right;
@@ -198,7 +198,7 @@ void
 PB_DS_CLASS_C_DEC::
 remove_fixup(node_pointer p_x, node_pointer p_new_x_parent)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_x == NULL || p_x->m_p_parent == p_new_x_parent);
+  _GLIBCXX_DEBUG_ASSERT(p_x == 0 || p_x->m_p_parent == p_new_x_parent);
 
   while (p_x != base_type::m_p_head->m_p_parent && is_effectively_black(p_x))
     if (p_x == p_new_x_parent->m_p_left)
@@ -223,7 +223,7 @@ remove_fixup(node_pointer p_x, node_pointer p_new_x_parent)
          {
            if (is_effectively_black(p_w->m_p_right))
              {
-               if (p_w->m_p_left != NULL)
+               if (p_w->m_p_left != 0)
                  p_w->m_p_left->m_red = false;
 
                p_w->m_red = true;
@@ -234,7 +234,7 @@ remove_fixup(node_pointer p_x, node_pointer p_new_x_parent)
            p_w->m_red = p_new_x_parent->m_red;
            p_new_x_parent->m_red = false;
 
-           if (p_w->m_p_right != NULL)
+           if (p_w->m_p_right != 0)
              p_w->m_p_right->m_red = false;
 
            base_type::rotate_left(p_new_x_parent);
@@ -264,7 +264,7 @@ remove_fixup(node_pointer p_x, node_pointer p_new_x_parent)
          {
            if (is_effectively_black(p_w->m_p_left))
              {
-               if (p_w->m_p_right != NULL)
+               if (p_w->m_p_right != 0)
                  p_w->m_p_right->m_red = false;
 
                p_w->m_red = true;
@@ -275,7 +275,7 @@ remove_fixup(node_pointer p_x, node_pointer p_new_x_parent)
            p_w->m_red = p_new_x_parent->m_red;
            p_new_x_parent->m_red = false;
 
-           if (p_w->m_p_left != NULL)
+           if (p_w->m_p_left != 0)
              p_w->m_p_left->m_red = false;
 
            base_type::rotate_right(p_new_x_parent);
@@ -284,6 +284,6 @@ remove_fixup(node_pointer p_x, node_pointer p_new_x_parent)
          }
       }
 
-  if (p_x != NULL)
+  if (p_x != 0)
     p_x->m_red = false;
 }
index 6b43b1a994cdd602a007292538e0accf63ec4909..97eba22f6f858bea1af5d53a198dad015f41f661 100644 (file)
@@ -42,5 +42,5 @@ PB_DS_CLASS_T_DEC
 inline bool
 PB_DS_CLASS_C_DEC::
 is_effectively_black(const node_pointer p_nd)
-{ return (p_nd == NULL || !p_nd->m_red); }
+{ return (p_nd == 0 || !p_nd->m_red); }
 
index 16a5d1edb294d4c79c92a271336d9722261d2487..a6a60160ccadccfd03e4cd53a0c56e7913f9d042 100644 (file)
@@ -67,7 +67,7 @@ insert_fixup(node_pointer p_nd)
       if (p_nd->m_p_parent == p_nd->m_p_parent->m_p_parent->m_p_left)
         {
          node_pointer p_y = p_nd->m_p_parent->m_p_parent->m_p_right;
-         if (p_y != NULL && p_y->m_red)
+         if (p_y != 0 && p_y->m_red)
             {
              p_nd->m_p_parent->m_red = false;
              p_y->m_red = false;
@@ -89,7 +89,7 @@ insert_fixup(node_pointer p_nd)
       else
         {
          node_pointer p_y = p_nd->m_p_parent->m_p_parent->m_p_left;
-         if (p_y != NULL && p_y->m_red)
+         if (p_y != 0 && p_y->m_red)
             {
              p_nd->m_p_parent->m_red = false;
              p_y->m_red = false;
index 9776a8d9a349048ff2a9b4f6bc7349aecbb4386a..96280564dd2730bc2578b1772c7c87f20d17b3bb 100644 (file)
@@ -67,8 +67,8 @@ void
 PB_DS_CLASS_C_DEC::
 join_imp(node_pointer p_x, node_pointer p_r)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_x != NULL);
-  if (p_r != NULL)
+  _GLIBCXX_DEBUG_ASSERT(p_x != 0);
+  if (p_r != 0)
     p_r->m_red = false;
 
   const size_type h = black_height(base_type::m_p_head->m_p_parent);
@@ -88,7 +88,7 @@ join_imp(node_pointer p_x, node_pointer p_r)
     {
       p_x_l = base_type::m_p_head->m_p_parent;
       base_type::m_p_head->m_p_parent = p_r;
-      if (p_r != NULL)
+      if (p_r != 0)
        p_r->m_p_parent = base_type::m_p_head;
 
       join_pos = find_join_pos_left(base_type::m_p_head->m_p_parent, 
@@ -112,11 +112,11 @@ join_imp(node_pointer p_x, node_pointer p_r)
     }
 
   p_x->m_p_left = p_x_l;
-  if (p_x_l != NULL)
+  if (p_x_l != 0)
     p_x_l->m_p_parent = p_x;
 
   p_x->m_p_right = p_x_r;
-  if (p_x_r != NULL)
+  if (p_x_r != 0)
     p_x_r->m_p_parent = p_x;
 
   p_x->m_red = true;
@@ -153,8 +153,8 @@ find_join_pos_right(node_pointer p_l, size_type h_l, size_type h_r)
 {
   _GLIBCXX_DEBUG_ASSERT(h_l >= h_r);
 
-  if (base_type::m_p_head->m_p_parent == NULL)
-    return (std::make_pair((node_pointer)NULL, base_type::m_p_head));
+  if (base_type::m_p_head->m_p_parent == 0)
+    return (std::make_pair((node_pointer)0, base_type::m_p_head));
 
   node_pointer p_l_parent = base_type::m_p_head;
   while (h_l > h_r)
@@ -177,7 +177,7 @@ find_join_pos_right(node_pointer p_l, size_type h_l, size_type h_r)
 
   _GLIBCXX_DEBUG_ASSERT(is_effectively_black(p_l));
   _GLIBCXX_DEBUG_ASSERT(black_height(p_l) == h_r);
-  _GLIBCXX_DEBUG_ASSERT(p_l == NULL || p_l->m_p_parent == p_l_parent);
+  _GLIBCXX_DEBUG_ASSERT(p_l == 0 || p_l->m_p_parent == p_l_parent);
   return std::make_pair(p_l, p_l_parent);
 }
 
@@ -189,8 +189,8 @@ PB_DS_CLASS_C_DEC::
 find_join_pos_left(node_pointer p_r, size_type h_l, size_type h_r)
 {
   _GLIBCXX_DEBUG_ASSERT(h_r > h_l);
-  if (base_type::m_p_head->m_p_parent == NULL)
-    return (std::make_pair((node_pointer)NULL,
+  if (base_type::m_p_head->m_p_parent == 0)
+    return (std::make_pair((node_pointer)0,
                           base_type::m_p_head));
   node_pointer p_r_parent = base_type::m_p_head;
   while (h_r > h_l)
@@ -213,7 +213,7 @@ find_join_pos_left(node_pointer p_r, size_type h_l, size_type h_r)
 
   _GLIBCXX_DEBUG_ASSERT(is_effectively_black(p_r));
   _GLIBCXX_DEBUG_ASSERT(black_height(p_r) == h_l);
-  _GLIBCXX_DEBUG_ASSERT(p_r == NULL || p_r->m_p_parent == p_r_parent);
+  _GLIBCXX_DEBUG_ASSERT(p_r == 0 || p_r->m_p_parent == p_r_parent);
   return std::make_pair(p_r, p_r_parent);
 }
 
@@ -223,7 +223,7 @@ PB_DS_CLASS_C_DEC::
 black_height(node_pointer p_nd)
 {
   size_type h = 1;
-  while (p_nd != NULL)
+  while (p_nd != 0)
     {
       if (p_nd->m_red == false)
        ++h;
@@ -275,7 +275,7 @@ void
 PB_DS_CLASS_C_DEC::
 split_at_node(node_pointer p_nd, PB_DS_CLASS_C_DEC& other)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
 
   node_pointer p_l = p_nd->m_p_left;
   node_pointer p_r = p_nd->m_p_right;
@@ -283,7 +283,7 @@ split_at_node(node_pointer p_nd, PB_DS_CLASS_C_DEC& other)
   if (p_parent == base_type::m_p_head)
     {
       base_type::m_p_head->m_p_parent = p_l;
-      if (p_l != NULL)
+      if (p_l != 0)
         {
          p_l->m_p_parent = base_type::m_p_head;
          p_l->m_red = false;
@@ -296,7 +296,7 @@ split_at_node(node_pointer p_nd, PB_DS_CLASS_C_DEC& other)
       else
        p_parent->m_p_right = p_l;
 
-      if (p_l != NULL)
+      if (p_l != 0)
        p_l->m_p_parent = p_parent;
 
       update_to_top(p_parent, (node_update* )this);
index 0194905c4c7ebc3d61693b29c9d55f63d81cda73..4b8878ee84c9af9ca70df01a1822557e1d442dae 100644 (file)
@@ -48,7 +48,7 @@ assert_valid() const
   base_type::assert_valid(false);
   if (!base_type::empty())
     {
-      _GLIBCXX_DEBUG_ASSERT(base_type::m_p_max != NULL);
+      _GLIBCXX_DEBUG_ASSERT(base_type::m_p_max != 0);
       base_type::assert_max();
     }
 
@@ -57,7 +57,7 @@ assert_valid() const
   if (m_rc.empty())
     {
       base_type::assert_valid(true);
-      _GLIBCXX_DEBUG_ASSERT(next_2_pointer(base_type::m_p_root) == NULL);
+      _GLIBCXX_DEBUG_ASSERT(next_2_pointer(base_type::m_p_root) == 0);
       return;
     }
 
@@ -65,13 +65,13 @@ assert_valid() const
   typename rc_t::const_iterator it = m_rc.end();
   --it;
 
-  while (p_nd != NULL)
+  while (p_nd != 0)
     {
       _GLIBCXX_DEBUG_ASSERT(*it == p_nd);
       const_node_pointer p_next = p_nd->m_p_next_sibling;
-      _GLIBCXX_DEBUG_ASSERT(p_next != NULL);
+      _GLIBCXX_DEBUG_ASSERT(p_next != 0);
       _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata == p_next->m_metadata);
-      _GLIBCXX_DEBUG_ASSERT(p_next->m_p_next_sibling == NULL ||
+      _GLIBCXX_DEBUG_ASSERT(p_next->m_p_next_sibling == 0 ||
                       p_next->m_metadata < p_next->m_p_next_sibling->m_metadata);
 
       --it;
@@ -85,13 +85,13 @@ typename PB_DS_CLASS_C_DEC::const_node_pointer
 PB_DS_CLASS_C_DEC::
 next_2_pointer(const_node_pointer p_nd)
 {
-  if (p_nd == NULL)
-    return NULL;
+  if (p_nd == 0)
+    return 0;
 
   node_pointer p_next = p_nd->m_p_next_sibling;
 
-  if (p_next == NULL)
-    return NULL;
+  if (p_next == 0)
+    return 0;
 
   if (p_nd->m_metadata == p_next->m_metadata)
     return p_nd;
@@ -104,13 +104,13 @@ typename PB_DS_CLASS_C_DEC::const_node_pointer
 PB_DS_CLASS_C_DEC::
 next_after_0_pointer(const_node_pointer p_nd)
 {
-  if (p_nd == NULL)
-    return NULL;
+  if (p_nd == 0)
+    return 0;
 
   node_pointer p_next = p_nd->m_p_next_sibling;
 
-  if (p_next == NULL)
-    return NULL;
+  if (p_next == 0)
+    return 0;
 
   if (p_nd->m_metadata < p_next->m_metadata)
     return p_next;
index 1113ffa6669d93c27404f1109c78d4c68f03e3bb..1f187a55749c341888b59118c3548f72ee624e85 100644 (file)
@@ -64,10 +64,10 @@ PB_DS_CLASS_C_DEC::
 make_binomial_heap()
 {
   node_pointer p_nd = base_type::m_p_root;
-  while (p_nd != NULL)
+  while (p_nd != 0)
     {
       node_pointer p_next = p_nd->m_p_next_sibling;
-      if (p_next == NULL)
+      if (p_next == 0)
        p_nd = p_next;
       else if (p_nd->m_metadata == p_next->m_metadata)
        p_nd = link_with_next_sibling(p_nd);
index aef4b928e1627391dc423fa425be4ce614181f78..2a3badccb5b3e70fa9f4123ff44459fe2b672c81 100644 (file)
@@ -51,20 +51,20 @@ push(const_reference r_val)
 
     node_pointer p_nd = base_type::get_new_node_for_insert(r_val);
 
-  p_nd->m_p_l_child = p_nd->m_p_prev_or_parent = NULL;
+  p_nd->m_p_l_child = p_nd->m_p_prev_or_parent = 0;
   p_nd->m_metadata = 0;
 
-  if (base_type::m_p_max == NULL || Cmp_Fn::operator()(base_type::m_p_max->m_value, r_val))
+  if (base_type::m_p_max == 0 || Cmp_Fn::operator()(base_type::m_p_max->m_value, r_val))
     base_type::m_p_max = p_nd;
 
   p_nd->m_p_next_sibling = base_type::m_p_root;
 
-  if (base_type::m_p_root != NULL)
+  if (base_type::m_p_root != 0)
     base_type::m_p_root->m_p_prev_or_parent = p_nd;
 
   base_type::m_p_root = p_nd;
 
-  if (p_nd->m_p_next_sibling != NULL&&  p_nd->m_p_next_sibling->m_metadata == 0)
+  if (p_nd->m_p_next_sibling != 0&&  p_nd->m_p_next_sibling->m_metadata == 0)
     m_rc.push(p_nd);
 
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
@@ -95,14 +95,14 @@ link_with_next_sibling(node_pointer p_nd)
 {
   node_pointer p_next = p_nd->m_p_next_sibling;
 
-  _GLIBCXX_DEBUG_ASSERT(p_next != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_next != 0);
   _GLIBCXX_DEBUG_ASSERT(p_next->m_p_prev_or_parent == p_nd);
 
   if (Cmp_Fn::operator()(p_nd->m_value, p_next->m_value))
     {
       p_next->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
 
-      if (p_next->m_p_prev_or_parent == NULL)
+      if (p_next->m_p_prev_or_parent == 0)
        base_type::m_p_root = p_next;
       else
        p_next->m_p_prev_or_parent->m_p_next_sibling = p_next;
@@ -119,7 +119,7 @@ link_with_next_sibling(node_pointer p_nd)
 
   p_nd->m_p_next_sibling = p_next->m_p_next_sibling;
 
-  if (p_nd->m_p_next_sibling != NULL)
+  if (p_nd->m_p_next_sibling != 0)
     p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd;
 
   if (base_type::m_p_max == p_next)
@@ -144,11 +144,11 @@ make_0_exposed()
 
   m_rc.pop();
 
-  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling != 0);
   _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata == p_nd->m_p_next_sibling->m_metadata);
 
   node_pointer p_res = link_with_next_sibling(p_nd);
 
-  if (p_res->m_p_next_sibling != NULL&&  p_res->m_metadata == p_res->m_p_next_sibling->m_metadata)
+  if (p_res->m_p_next_sibling != 0&&  p_res->m_metadata == p_res->m_p_next_sibling->m_metadata)
     m_rc.push(p_res);
 }
index a28f5ede5e64a63d3fe4ae5974f7ccd83d489ee3..c816cfdeac8f0a29f1cbf45cb5e5d5f030138d2b 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -150,7 +150,7 @@ inline PB_DS_CLASS_C_DEC::size_type
 PB_DS_CLASS_C_DEC::
 get_nearest_smaller_size(size_type n) const
 {
-  const size_t* p_lower = std::lower_bound(detail::g_a_sizes, 
+  const std::size_t* p_lower = std::lower_bound(detail::g_a_sizes, 
                       detail::g_a_sizes + detail::num_distinct_sizes, n);
 
   if (*p_lower >= n &&  p_lower != detail::g_a_sizes)
index ed70b951121dd0d502c17ea2c82312c3635e2dd7..33aecdf5fcc4bd68d1cc54d5e942ac14f1f841b9 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -47,7 +47,7 @@ class sample_resize_policy
 public:
 
   // Size type.
-  typedef size_t size_type;
+  typedef std::size_t size_type;
 
   // Default constructor.
   sample_resize_policy();
index a27dd9427027b6e7f849e6b98f8ac58b0e5e26dc..963c5530a462aaeb0db5453032cebfa0b327f8f8 100644 (file)
@@ -1,6 +1,7 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -47,7 +48,7 @@ class sample_resize_trigger
 public:
 
   // Size type.
-  typedef size_t size_type;
+  typedef std::size_t size_type;
 
   // Default constructor.
   sample_resize_trigger();
index 1f2d3a9c1259a8e88c1ca2412f527ad14b9994e3..9b3ba031c4b0ddac63ca1afde16e96873682b1b8 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -47,7 +47,7 @@ class sample_size_policy
 public:
 
   // Size type.
-  typedef size_t size_type;
+  typedef std::size_t size_type;
 
   // Default constructor.
   sample_size_policy();
index 084e25d26deccbe0e40c62620f3534fc86ff831d..f673877aed226e5839510ffaeb6393adeb64150c 100644 (file)
@@ -55,7 +55,7 @@ void
 PB_DS_CLASS_C_DEC::
 assert_special_imp(const node_pointer p_nd) const
 {
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return;
 
   if (p_nd == base_type::m_p_head)
index 508f586d78d552368d086dc5b4a4afab18bd3cc4..507b8ba407ce3a030d14af9073e8c2ddaa0f1393 100644 (file)
@@ -108,7 +108,7 @@ void
 PB_DS_CLASS_C_DEC::
 erase_node(node_pointer p_nd)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
   splay(p_nd);
 
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
@@ -119,27 +119,27 @@ erase_node(node_pointer p_nd)
 
   base_type::update_min_max_for_erased_node(p_nd);
   base_type::actual_erase_node(p_nd);
-  if (p_r == NULL)
+  if (p_r == 0)
     {
       base_type::m_p_head->m_p_parent = p_l;
-      if (p_l != NULL)
+      if (p_l != 0)
        p_l->m_p_parent = base_type::m_p_head;
       _GLIBCXX_DEBUG_ONLY(assert_valid();)
       return;
     }
 
   node_pointer p_target_r = leftmost(p_r);
-  _GLIBCXX_DEBUG_ASSERT(p_target_r != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_target_r != 0);
   p_r->m_p_parent = base_type::m_p_head;
   base_type::m_p_head->m_p_parent = p_r;
   splay(p_target_r);
 
-  _GLIBCXX_DEBUG_ONLY(p_target_r->m_p_left = NULL);
+  _GLIBCXX_DEBUG_ONLY(p_target_r->m_p_left = 0);
   _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_parent == this->m_p_head);
   _GLIBCXX_DEBUG_ASSERT(this->m_p_head->m_p_parent == p_target_r);
 
   p_target_r->m_p_left = p_l;
-  if (p_l != NULL)
+  if (p_l != 0)
     p_l->m_p_parent = p_target_r;
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   apply_update(p_target_r, (node_update* )this);
@@ -150,8 +150,8 @@ inline typename PB_DS_CLASS_C_DEC::node_pointer
 PB_DS_CLASS_C_DEC::
 leftmost(node_pointer p_nd)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
-  while (p_nd->m_p_left != NULL)
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  while (p_nd->m_p_left != 0)
     p_nd = p_nd->m_p_left;
   return p_nd;
 }
index 182425a8f305ddd28009e39435a5714502e6320f..e27142c17ecd5857debbb21b17d31b8ce7486edf 100644 (file)
@@ -67,7 +67,7 @@ find_imp(const_key_reference r_key)
 {
   _GLIBCXX_DEBUG_ONLY(base_type::structure_only_assert_valid();)
   node_pointer p_nd = base_type::m_p_head->m_p_parent;
-  while (p_nd != NULL)
+  while (p_nd != 0)
     if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key))
       {
        if (!Cmp_Fn::operator()(r_key, PB_DS_V2F(p_nd->m_value)))
@@ -86,7 +86,7 @@ find_imp(const_key_reference r_key) const
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   node_pointer p_nd = base_type::m_p_head->m_p_parent;
-  while (p_nd != NULL)
+  while (p_nd != 0)
     if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key))
       {
        if (!Cmp_Fn::operator()(r_key, PB_DS_V2F(p_nd->m_value)))
index e9ae987b09d4b0a43a44ea4851445af6f8e1c9f5..8381174d29fea111b8d9e829125bf54f60abe657 100644 (file)
@@ -64,7 +64,7 @@ insert_leaf_imp(const_reference r_value)
   node_pointer p_nd = base_type::m_p_head->m_p_parent;
   node_pointer p_pot = base_type::m_p_head;
 
-  while (p_nd != NULL)
+  while (p_nd != 0)
     if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), PB_DS_V2F(r_value)))
       {
        if (!Cmp_Fn::operator()(PB_DS_V2F(r_value), PB_DS_V2F(p_nd->m_value)))
@@ -83,10 +83,10 @@ insert_leaf_imp(const_reference r_value)
   _GLIBCXX_DEBUG_ONLY(base_type::check_key_does_not_exist(PB_DS_V2F(r_value)));
 
   p_nd = p_pot->m_p_left;
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return (std::make_pair(base_type::insert_leaf_new(r_value, p_pot, true), true));
 
-  while (p_nd->m_p_right != NULL)
+  while (p_nd->m_p_right != 0)
     p_nd = p_nd->m_p_right;
 
   return std::make_pair(insert_leaf_new(r_value, p_nd, false), true);
index e4f3556a5f0f80e9b24dae4327fddec0bc0df47e..b6993590acb89984887ab5694b243cf4b9d41389 100644 (file)
@@ -114,11 +114,11 @@ splay_zig_zag_left(node_pointer p_nd, node_pointer p_parent,
   p_grandparent->m_p_parent = p_nd;
 
   p_parent->m_p_left = p_b;
-  if (p_b != NULL)
+  if (p_b != 0)
     p_b->m_p_parent = p_parent;
 
   p_grandparent->m_p_right = p_c;
-  if (p_c != NULL)
+  if (p_c != 0)
     p_c->m_p_parent = p_grandparent;
 
   splay_zz_end(p_nd, p_parent, p_grandparent);
@@ -150,11 +150,11 @@ splay_zig_zag_right(node_pointer p_nd, node_pointer p_parent,
   p_grandparent->m_p_parent = p_nd;
 
   p_parent->m_p_right = p_b;
-  if (p_b != NULL)
+  if (p_b != 0)
     p_b->m_p_parent = p_parent;
 
   p_grandparent->m_p_left = p_c;
-  if (p_c != NULL)
+  if (p_c != 0)
     p_c->m_p_parent = p_grandparent;
 
   splay_zz_end(p_nd, p_parent, p_grandparent);
@@ -186,11 +186,11 @@ splay_zig_zig_left(node_pointer p_nd, node_pointer p_parent,
   p_grandparent->m_p_parent = p_parent;
 
   p_parent->m_p_left = p_b;
-  if (p_b != NULL)
+  if (p_b != 0)
     p_b->m_p_parent = p_parent;
 
   p_grandparent->m_p_left = p_c;
-  if (p_c != NULL)
+  if (p_c != 0)
     p_c->m_p_parent = p_grandparent;
 
   splay_zz_end(p_nd, p_parent, p_grandparent);
@@ -220,11 +220,11 @@ splay_zig_zig_right(node_pointer p_nd, node_pointer p_parent,
   p_grandparent->m_p_parent = p_parent;
 
   p_parent->m_p_right = p_b;
-  if (p_b != NULL)
+  if (p_b != 0)
     p_b->m_p_parent = p_parent;
 
   p_grandparent->m_p_right = p_c;
-  if (p_c != NULL)
+  if (p_c != 0)
     p_c->m_p_parent = p_grandparent;
 
   base_type::update_to_top(p_grandparent, (node_update* )this);
@@ -242,9 +242,9 @@ splay_zz_start(node_pointer p_nd,
 #endif
               node_pointer p_grandparent)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_parent != NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_grandparent != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_parent != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_grandparent != 0);
 
   const bool grandparent_head = p_grandparent->m_p_parent == base_type::m_p_head;
 
index 7f0b2cb205d54bf0e1aae857540497739419e547..401f22c0369c9f66e24e886bfa7f74568ba3702e 100644 (file)
@@ -53,15 +53,15 @@ join(PB_DS_CLASS_C_DEC& other)
     }
 
   node_pointer p_target_r = other.leftmost(other.m_p_head);
-  _GLIBCXX_DEBUG_ASSERT(p_target_r != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_target_r != 0);
   other.splay(p_target_r);
 
   _GLIBCXX_DEBUG_ASSERT(p_target_r == other.m_p_head->m_p_parent);
-  _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_left == NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_left == 0);
 
   p_target_r->m_p_left = base_type::m_p_head->m_p_parent;
 
-  _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_left != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_left != 0);
   p_target_r->m_p_left->m_p_parent = p_target_r;
 
   base_type::m_p_head->m_p_parent = p_target_r;
@@ -90,19 +90,19 @@ split(const_key_reference r_key, PB_DS_CLASS_C_DEC& other)
     }
 
   node_pointer p_upper_bound = upper_bound(r_key).m_p_nd;
-  _GLIBCXX_DEBUG_ASSERT(p_upper_bound != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_upper_bound != 0);
 
   splay(p_upper_bound);
   _GLIBCXX_DEBUG_ASSERT(p_upper_bound->m_p_parent == this->m_p_head);
 
   node_pointer p_new_root = p_upper_bound->m_p_left;
-  _GLIBCXX_DEBUG_ASSERT(p_new_root != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_new_root != 0);
 
   base_type::m_p_head->m_p_parent = p_new_root;
   p_new_root->m_p_parent = base_type::m_p_head;
   other.m_p_head->m_p_parent = p_upper_bound;
   p_upper_bound->m_p_parent = other.m_p_head;
-  p_upper_bound->m_p_left = NULL;
+  p_upper_bound->m_p_left = 0;
   apply_update(p_upper_bound, (node_update* )this);
   base_type::split_finish(other);
 
index 4d2c45ce04728379276a6ca9bcfee59bdefe3255..5a09f7c402084a18c327ae668caed390a64128c3 100644 (file)
@@ -52,7 +52,7 @@ copy_from_range(It first_it, It last_it)
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 thin_heap_() :
-  m_p_max(NULL)
+  m_p_max(0)
 {
   initialize();
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
@@ -62,7 +62,7 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 thin_heap_(const Cmp_Fn& r_cmp_fn) :
   PB_DS_BASE_C_DEC(r_cmp_fn),
-  m_p_max(NULL)
+  m_p_max(0)
 {
   initialize();
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
@@ -75,7 +75,7 @@ thin_heap_(const PB_DS_CLASS_C_DEC& other) :
 {
   initialize();
   m_p_max = base_type::m_p_root;
-  for (node_pointer p_nd = base_type::m_p_root; p_nd != NULL; p_nd = p_nd->m_p_next_sibling)
+  for (node_pointer p_nd = base_type::m_p_root; p_nd != 0; p_nd = p_nd->m_p_next_sibling)
     if (Cmp_Fn::operator()(m_p_max->m_value, p_nd->m_value))
       m_p_max = p_nd;
 
@@ -102,5 +102,5 @@ PB_DS_CLASS_T_DEC
 void
 PB_DS_CLASS_C_DEC::
 initialize()
-{ std::fill(m_a_aux, m_a_aux + max_rank, static_cast<node_pointer>(NULL)); }
+{ std::fill(m_a_aux, m_a_aux + max_rank, static_cast<node_pointer>(0)); }
 
index f7abe35279ce2fde83503648061bff378b4e2a2a..0aedadb9f843a9fbe4226d262e2db18ba3f00ca3 100644 (file)
@@ -57,7 +57,7 @@ PB_DS_CLASS_C_DEC::
 assert_aux_null() const
 {
   for (size_type i = 0; i < max_rank; ++i)
-    _GLIBCXX_DEBUG_ASSERT(m_a_aux[i] == NULL);
+    _GLIBCXX_DEBUG_ASSERT(m_a_aux[i] == 0);
 }
 
 PB_DS_CLASS_T_DEC
@@ -65,15 +65,15 @@ void
 PB_DS_CLASS_C_DEC::
 assert_max() const
 {
-  if (m_p_max == NULL)
+  if (m_p_max == 0)
     {
       _GLIBCXX_DEBUG_ASSERT(base_type::empty());
       return;
     }
 
   _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
-  _GLIBCXX_DEBUG_ASSERT(base_type::parent(m_p_max) == NULL);
-  _GLIBCXX_DEBUG_ASSERT(m_p_max->m_p_prev_or_parent == NULL);
+  _GLIBCXX_DEBUG_ASSERT(base_type::parent(m_p_max) == 0);
+  _GLIBCXX_DEBUG_ASSERT(m_p_max->m_p_prev_or_parent == 0);
   for (const_iterator it = base_type::begin(); it != base_type::end(); ++it)
     _GLIBCXX_DEBUG_ASSERT(!Cmp_Fn::operator()(m_p_max->m_value, it.m_p_nd->m_value));
 }
@@ -84,7 +84,7 @@ PB_DS_CLASS_C_DEC::
 assert_node_consistent(const_node_pointer p_nd, bool root) const
 {
   base_type::assert_node_consistent(p_nd, root);
-  if (p_nd == NULL)
+  if (p_nd == 0)
     return;
 
   assert_node_consistent(p_nd->m_p_next_sibling, root);
@@ -92,17 +92,17 @@ assert_node_consistent(const_node_pointer p_nd, bool root) const
   if (!root)
     {
       if (p_nd->m_metadata == 0)
-       _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling == NULL);
+       _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling == 0);
       else
        _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata == p_nd->m_p_next_sibling->m_metadata + 1);
     }
 
-  if (p_nd->m_p_l_child != NULL)
+  if (p_nd->m_p_l_child != 0)
     _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_l_child->m_metadata + 1 == base_type::degree(p_nd));
 
-  const bool unmarked_valid =(p_nd->m_p_l_child == NULL&&  p_nd->m_metadata == 0) ||(p_nd->m_p_l_child != NULL&&  p_nd->m_metadata == p_nd->m_p_l_child->m_metadata + 1);
+  const bool unmarked_valid =(p_nd->m_p_l_child == 0&&  p_nd->m_metadata == 0) ||(p_nd->m_p_l_child != 0&&  p_nd->m_metadata == p_nd->m_p_l_child->m_metadata + 1);
 
-  const bool marked_valid =(p_nd->m_p_l_child == NULL&&  p_nd->m_metadata == 1) ||(p_nd->m_p_l_child != NULL&&  p_nd->m_metadata == p_nd->m_p_l_child->m_metadata + 2);
+  const bool marked_valid =(p_nd->m_p_l_child == 0&&  p_nd->m_metadata == 1) ||(p_nd->m_p_l_child != 0&&  p_nd->m_metadata == p_nd->m_p_l_child->m_metadata + 2);
 
   _GLIBCXX_DEBUG_ASSERT(unmarked_valid || marked_valid);
   if (root)
index 69afcd39f15d82b80fe12528756091ee32a59e0c..6f1b20b441a8e0ada0ec3a4bc9a5e2057387faee 100644 (file)
@@ -46,7 +46,7 @@ pop()
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
     _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
 
-  _GLIBCXX_DEBUG_ASSERT(m_p_max != NULL);
+  _GLIBCXX_DEBUG_ASSERT(m_p_max != 0);
 
   node_pointer p_nd = m_p_max;
 
@@ -85,11 +85,11 @@ to_aux_except_max()
 
   p_add = m_p_max->m_p_l_child;
 
-  while (p_add != NULL)
+  while (p_add != 0)
     {
       node_pointer p_next_add = p_add->m_p_next_sibling;
 
-      p_add->m_metadata = p_add->m_p_l_child == NULL?
+      p_add->m_metadata = p_add->m_p_l_child == 0?
        0 :
        p_add->m_p_l_child->m_metadata + 1;
 
@@ -100,7 +100,7 @@ to_aux_except_max()
 
   p_add = m_p_max->m_p_next_sibling;
 
-  while (p_add != NULL)
+  while (p_add != 0)
     {
       node_pointer p_next_add = p_add->m_p_next_sibling;
 
@@ -117,7 +117,7 @@ add_to_aux(node_pointer p_nd)
 {
   size_type r = p_nd->m_metadata;
 
-  while (m_a_aux[r] != NULL)
+  while (m_a_aux[r] != 0)
     {
       _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata < rank_bound());
 
@@ -130,7 +130,7 @@ add_to_aux(node_pointer p_nd)
          p_nd = m_a_aux[r];
         }
 
-      m_a_aux[r] = NULL;
+      m_a_aux[r] = 0;
 
       ++r;
     }
@@ -159,7 +159,7 @@ inline void
 PB_DS_CLASS_C_DEC::
 make_from_aux()
 {
-  base_type::m_p_root = m_p_max = NULL;
+  base_type::m_p_root = m_p_max = 0;
 
   const size_type rnk_bnd = rank_bound();
 
@@ -167,11 +167,11 @@ make_from_aux()
 
   while (i < rnk_bnd)
     {
-      if (m_a_aux[i] != NULL)
+      if (m_a_aux[i] != 0)
         {
          make_root_and_link(m_a_aux[i]);
 
-         m_a_aux[i] = NULL;
+         m_a_aux[i] = 0;
         }
 
       ++i;
@@ -186,7 +186,7 @@ PB_DS_CLASS_C_DEC::
 remove_node(node_pointer p_nd)
 {
   node_pointer p_parent = p_nd;
-  while (base_type::parent(p_parent) != NULL)
+  while (base_type::parent(p_parent) != 0)
     p_parent = base_type::parent(p_parent);
 
   base_type::bubble_to_top(p_nd);
@@ -194,10 +194,10 @@ remove_node(node_pointer p_nd)
   m_p_max = p_nd;
 
   node_pointer p_fix = base_type::m_p_root;
-  while (p_fix != NULL&&  p_fix->m_p_next_sibling != p_parent)
+  while (p_fix != 0&&  p_fix->m_p_next_sibling != p_parent)
     p_fix = p_fix->m_p_next_sibling;
 
-  if (p_fix != NULL)
+  if (p_fix != 0)
     p_fix->m_p_next_sibling = p_nd;
 
   remove_max_node();
@@ -210,7 +210,7 @@ clear()
 {
   base_type::clear();
 
-  m_p_max = NULL;
+  m_p_max = 0;
 }
 
 PB_DS_CLASS_T_DEC
@@ -251,7 +251,7 @@ erase_if(Pred pred)
 
   size_type ersd = 0;
 
-  while (p_out != NULL)
+  while (p_out != 0)
     {
       ++ersd;
 
@@ -264,9 +264,9 @@ erase_if(Pred pred)
 
   node_pointer p_cur = base_type::m_p_root;
 
-  m_p_max = base_type::m_p_root = NULL;
+  m_p_max = base_type::m_p_root = 0;
 
-  while (p_cur != NULL)
+  while (p_cur != 0)
     {
       node_pointer p_next = p_cur->m_p_next_sibling;
 
index 52407e6d0ae94e650e927a6b522b5755cd379b8c..700486a60d779cb4d24bd468ad82eecd04f71895 100644 (file)
@@ -46,6 +46,6 @@ top() const
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
     _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
 
-  _GLIBCXX_DEBUG_ASSERT(m_p_max != NULL);
+  _GLIBCXX_DEBUG_ASSERT(m_p_max != 0);
   return m_p_max->m_value;
 }
index 7a6952fdad4402732816184aa455118880cac3ea..4e8a1c2d8cc9af534c6e5a32d1257e9d558d10f3 100644 (file)
@@ -49,11 +49,11 @@ push(const_reference r_val)
 
   p_nd->m_metadata = 0;
 
-  p_nd->m_p_prev_or_parent = p_nd->m_p_l_child = NULL;
+  p_nd->m_p_prev_or_parent = p_nd->m_p_l_child = 0;
 
-  if (base_type::m_p_root == NULL)
+  if (base_type::m_p_root == 0)
     {
-      p_nd->m_p_next_sibling = NULL;
+      p_nd->m_p_next_sibling = 0;
 
       m_p_max = base_type::m_p_root = p_nd;
 
@@ -64,7 +64,7 @@ push(const_reference r_val)
 
   p_nd->m_p_next_sibling = base_type::m_p_root;
 
-  base_type::m_p_root->m_p_prev_or_parent = NULL;
+  base_type::m_p_root->m_p_prev_or_parent = 0;
 
   base_type::m_p_root = p_nd;
 
@@ -81,7 +81,7 @@ PB_DS_CLASS_C_DEC::
 make_root(node_pointer p_nd)
 {
   p_nd->m_metadata =
-    p_nd->m_p_l_child == NULL?
+    p_nd->m_p_l_child == 0?
     0 :
     1 + p_nd->m_p_l_child->m_metadata;
 }
@@ -93,12 +93,12 @@ make_root_and_link(node_pointer p_nd)
 {
   make_root(p_nd);
 
-  p_nd->m_p_prev_or_parent = NULL;
+  p_nd->m_p_prev_or_parent = 0;
 
   p_nd->m_p_next_sibling = base_type::m_p_root;
 
-  if (base_type::m_p_root != NULL)
-    base_type::m_p_root->m_p_prev_or_parent = NULL;
+  if (base_type::m_p_root != 0)
+    base_type::m_p_root->m_p_prev_or_parent = 0;
 
   base_type::m_p_root = p_nd;
 
@@ -112,15 +112,15 @@ fix(node_pointer p_y)
 {
   while (true)
     {
-      if (p_y->m_p_prev_or_parent == NULL)
+      if (p_y->m_p_prev_or_parent == 0)
         {
          fix_root(p_y);
 
          return;
         }
-      else if (p_y->m_metadata == 1&&  p_y->m_p_next_sibling == NULL)
+      else if (p_y->m_metadata == 1&&  p_y->m_p_next_sibling == 0)
         {
-         if (p_y->m_p_l_child != NULL)
+         if (p_y->m_p_l_child != 0)
             {
              fix_sibling_rank_1_unmarked(p_y);
 
@@ -133,7 +133,7 @@ fix(node_pointer p_y)
         }
       else if (p_y->m_metadata > p_y->m_p_next_sibling->m_metadata + 1)
         {
-         _GLIBCXX_DEBUG_ASSERT(p_y->m_p_l_child != NULL);
+         _GLIBCXX_DEBUG_ASSERT(p_y->m_p_l_child != 0);
 
          if (p_y->m_metadata != p_y->m_p_l_child->m_metadata + 2)
             {
@@ -146,8 +146,8 @@ fix(node_pointer p_y)
 
          p_y = p_y->m_p_prev_or_parent;
         }
-      else if ((p_y->m_p_l_child == NULL&& 
-                p_y->m_metadata == 2) ||(p_y->m_p_l_child != NULL&& 
+      else if ((p_y->m_p_l_child == 0&& 
+                p_y->m_metadata == 2) ||(p_y->m_p_l_child != 0&& 
                                         p_y->m_metadata == p_y->m_p_l_child->m_metadata + 3))
         {
          node_pointer p_z = p_y->m_p_prev_or_parent;
@@ -166,7 +166,7 @@ inline void
 PB_DS_CLASS_C_DEC::
 fix_root(node_pointer p_y)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent == NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent == 0);
 
   make_root(p_y);
 
@@ -178,18 +178,18 @@ inline void
 PB_DS_CLASS_C_DEC::
 fix_sibling_rank_1_unmarked(node_pointer p_y)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0);
 
   _GLIBCXX_DEBUG_ONLY(node_pointer p_w = p_y->m_p_l_child;)
-    _GLIBCXX_DEBUG_ASSERT(p_w != NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling == NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_next_sibling == NULL);
+    _GLIBCXX_DEBUG_ASSERT(p_w != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling == 0);
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_next_sibling == 0);
 
   p_y->m_p_next_sibling = p_y->m_p_l_child;
 
   p_y->m_p_next_sibling->m_p_prev_or_parent = p_y;
 
-  p_y->m_p_l_child = NULL;
+  p_y->m_p_l_child = 0;
 
   _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_y, false);)
     }
@@ -199,8 +199,8 @@ inline void
 PB_DS_CLASS_C_DEC::
 fix_sibling_rank_1_marked(node_pointer p_y)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_l_child == NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_l_child == 0);
 
   p_y->m_metadata = 0;
 
@@ -212,17 +212,17 @@ inline void
 PB_DS_CLASS_C_DEC::
 fix_sibling_general_unmarked(node_pointer p_y)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0);
 
   node_pointer p_w = p_y->m_p_l_child;
-  _GLIBCXX_DEBUG_ASSERT(p_w != NULL);
-  _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_w != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling != 0);
 
   p_y->m_p_l_child = p_w->m_p_next_sibling;
   p_w->m_p_next_sibling->m_p_prev_or_parent = p_y;
 
   p_w->m_p_next_sibling = p_y->m_p_next_sibling;
-  _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling != 0);
   p_w->m_p_next_sibling->m_p_prev_or_parent = p_w;
 
   p_y->m_p_next_sibling = p_w;
@@ -236,7 +236,7 @@ inline void
 PB_DS_CLASS_C_DEC::
 fix_sibling_general_marked(node_pointer p_y)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0);
 
   --p_y->m_metadata;
 
@@ -248,9 +248,9 @@ inline void
 PB_DS_CLASS_C_DEC::
 fix_child(node_pointer p_y)
 {
-  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0);
 
-  if (p_y->m_p_next_sibling != NULL)
+  if (p_y->m_p_next_sibling != 0)
     p_y->m_p_next_sibling->m_p_prev_or_parent = p_y->m_p_prev_or_parent;
 
   if (p_y->m_p_prev_or_parent->m_p_l_child == p_y)
@@ -269,7 +269,7 @@ modify(point_iterator it, const_reference r_new_val)
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
     node_pointer p_nd = it.m_p_nd;
 
-  _GLIBCXX_DEBUG_ASSERT(p_nd != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
 
   const bool smaller = Cmp_Fn::operator()(r_new_val, p_nd->m_value);
 
@@ -279,7 +279,7 @@ modify(point_iterator it, const_reference r_new_val)
     {
       remove_node(p_nd);
 
-      p_nd->m_p_l_child = NULL;
+      p_nd->m_p_l_child = 0;
 
       make_root_and_link(p_nd);
 
@@ -288,7 +288,7 @@ modify(point_iterator it, const_reference r_new_val)
         return;
     }
 
-  if (p_nd->m_p_prev_or_parent == NULL)
+  if (p_nd->m_p_prev_or_parent == 0)
     {
       update_max(p_nd);
 
@@ -298,9 +298,9 @@ modify(point_iterator it, const_reference r_new_val)
     }
 
   node_pointer p_y = p_nd->m_p_prev_or_parent;
-  _GLIBCXX_DEBUG_ASSERT(p_y != NULL);
+  _GLIBCXX_DEBUG_ASSERT(p_y != 0);
 
-  if (p_nd->m_p_next_sibling != NULL)
+  if (p_nd->m_p_next_sibling != 0)
     p_nd->m_p_next_sibling->m_p_prev_or_parent = p_y;
 
   if (p_y->m_p_l_child == p_nd)
@@ -320,7 +320,7 @@ inline void
 PB_DS_CLASS_C_DEC::
 update_max(node_pointer p_nd)
 {
-  if (m_p_max == NULL || Cmp_Fn::operator()(m_p_max->m_value, p_nd->m_value))
+  if (m_p_max == 0 || Cmp_Fn::operator()(m_p_max->m_value, p_nd->m_value))
     m_p_max = p_nd;
 }
 
index 6acb7bd7571bbae667cc34acffb6b4afef306368..85ebe4cb400dbaf1069d6e8b642dd6165bdc81a7 100644 (file)
@@ -61,7 +61,7 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other)
 
   node_pointer p_out = base_type::prune(pred);
 
-  while (p_out != NULL)
+  while (p_out != 0)
     {
       _GLIBCXX_DEBUG_ASSERT(base_type::m_size > 0);
       --base_type::m_size;
@@ -79,11 +79,11 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other)
 
     node_pointer p_cur = base_type::m_p_root;
 
-  m_p_max = NULL;
+  m_p_max = 0;
 
-  base_type::m_p_root = NULL;
+  base_type::m_p_root = 0;
 
-  while (p_cur != NULL)
+  while (p_cur != 0)
     {
       node_pointer p_next = p_cur->m_p_next_sibling;
 
@@ -106,7 +106,7 @@ join(PB_DS_CLASS_C_DEC& other)
 
     node_pointer p_other = other.m_p_root;
 
-  while (p_other != NULL)
+  while (p_other != 0)
     {
       node_pointer p_next = p_other->m_p_next_sibling;
 
@@ -117,9 +117,9 @@ join(PB_DS_CLASS_C_DEC& other)
 
   base_type::m_size += other.m_size;
 
-  other.m_p_root = NULL;
+  other.m_p_root = 0;
   other.m_size = 0;
-  other.m_p_max = NULL;
+  other.m_p_max = 0;
 
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
     _GLIBCXX_DEBUG_ONLY(other.assert_valid();)
index 6ea68995e532fcf563f562e92ff5a335df8807e7..b8c19a587f8b04bf18011378e32206d8279784e1 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -56,7 +56,7 @@ class sample_tree_node_update
 public:
 
   // Metadata type.
-  typedef size_t metadata_type;
+  typedef std::size_t metadata_type;
 
 protected:
 
index 34fbe0cc3e2350897636d4b7ab0d228e1a8ea18a..2ecad89c9a73ae4e9417151e8df604e5e7d32216 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -48,7 +48,7 @@ class sample_trie_e_access_traits
 public:
 
   // Size type.
-  typedef size_t size_type;
+  typedef std::size_t size_type;
 
   // Key type.
   typedef std::string key_type;
index 55fd99787fbf921688fa37ffe61c33f796dfd9f5..8b2c6b591f74f07cae20e14a56f446815b6c0a2f 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -56,7 +56,7 @@ class sample_trie_node_update
 public:
 
   // Metadata type.
-  typedef size_t metadata_type;
+  typedef std::size_t metadata_type;
 
 protected:
 
index 38d4eb1cfbc59b7c121ac4218e4e72b3e4e6b601..71e262617940ecf90bd15bb26f8cae994debb50e 100644 (file)
@@ -74,7 +74,7 @@ public:
   inline
   const_iterator_()
 
-    : m_p_tbl(NULL)
+    : m_p_tbl(0)
   { }
 
   // Increments.
index bc0b2ad624a5ba8bd1fc188f80216d7053bda475..5574b28e1e19c0fa1051a96d2fee460d8a4e9114 100644 (file)
@@ -78,7 +78,7 @@ public:
   inline
   const_point_iterator_()
 
-    : m_p_value(NULL)
+    : m_p_value(0)
   { }
 
   // Copy constructor.
@@ -99,7 +99,7 @@ public:
   inline const_pointer
   operator->() const
   {
-    _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL);
+    _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
 
     return (m_p_value);
   }
@@ -108,7 +108,7 @@ public:
   inline const_reference
   operator*() const
   {
-    _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL);
+    _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
 
     return (*m_p_value);
   }
index 3e21aba8bada6d67258c03b893e9fca2f9e008f0..2836c17bea5114789232a87301784dc15a42402b 100644 (file)
@@ -74,7 +74,7 @@ public:
   inline
   iterator_()
 
-    : const_iterator_(NULL, PB_DS_GEN_POS(), NULL)
+    : const_iterator_(0, PB_DS_GEN_POS(), 0)
   { }
 
   // Conversion to a point-type iterator.
@@ -97,7 +97,7 @@ public:
   inline pointer
   operator->() const
   {
-    _GLIBCXX_DEBUG_ASSERT(base_type::m_p_value != NULL);
+    _GLIBCXX_DEBUG_ASSERT(base_type::m_p_value != 0);
 
     return (const_cast<pointer>(base_type::m_p_value));
   }
@@ -106,7 +106,7 @@ public:
   inline reference
   operator*() const
   {
-    _GLIBCXX_DEBUG_ASSERT(base_type::m_p_value != NULL);
+    _GLIBCXX_DEBUG_ASSERT(base_type::m_p_value != 0);
 
     return (const_cast<reference>(*base_type::m_p_value));
   }
index 37ce90069cfd2fd265e39c270a5f67d1aa4d8192..c009106e0dde6d5431879677ed13773b61cba1cc 100644 (file)
@@ -72,7 +72,7 @@ public:
   inline
   point_iterator_()
 
-    : m_p_value(NULL)
+    : m_p_value(0)
   { }
 
   // Copy constructor.
@@ -86,7 +86,7 @@ public:
   inline pointer
   operator->() const
   {
-    _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL);
+    _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
 
     return (m_p_value);
   }
@@ -95,7 +95,7 @@ public:
   inline reference
   operator*() const
   {
-    _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL);
+    _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
 
     return (*m_p_value);
   }
index 4f796b1ef336975f850f7fb89017dd0a88101fb8..b34e3ed26f220f69d7ac8adb1d3f42c8f654b948 100644 (file)
@@ -1,6 +1,7 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -41,6 +42,7 @@
 #ifndef PB_DS_EXCEPTION_HPP
 #define PB_DS_EXCEPTION_HPP
 
+#include <bits/c++config.h>
 #include <stdexcept>
 #include <cstdlib>
 
index 24c0c4562ccc046896ecaeff077bd13d61c36a77..f3bc86e97314cc176355b02b64eca1d22b988f64 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -41,6 +41,7 @@
 #ifndef PB_DS_HASH_POLICY_HPP
 #define PB_DS_HASH_POLICY_HPP
 
+#include <bits/c++config.h>
 #include <algorithm>
 #include <vector>
 #include <cmath>
@@ -66,7 +67,7 @@ namespace __gnu_pbds
 #define PB_DS_CLASS_C_DEC linear_probe_fn<Size_Type>
 
   // A probe sequence policy using fixed increments.
-  template<typename Size_Type = size_t>
+  template<typename Size_Type = std::size_t>
   class linear_probe_fn
   {
   public:
@@ -90,7 +91,7 @@ namespace __gnu_pbds
 #define PB_DS_CLASS_C_DEC quadratic_probe_fn<Size_Type>
 
   // A probe sequence policy using square increments.
-  template<typename Size_Type = size_t>
+  template<typename Size_Type = std::size_t>
   class quadratic_probe_fn
   {
   public:
@@ -114,7 +115,7 @@ namespace __gnu_pbds
 #define PB_DS_CLASS_C_DEC direct_mask_range_hashing<Size_Type>
 
   // A mask range-hashing class (uses a bit-mask).
-  template<typename Size_Type = size_t>
+  template<typename Size_Type = std::size_t>
   class direct_mask_range_hashing 
   : public detail::mask_based_range_hashing<Size_Type>
   {
@@ -146,7 +147,7 @@ namespace __gnu_pbds
 #define PB_DS_CLASS_C_DEC direct_mod_range_hashing<Size_Type>
 
   // A mod range-hashing class (uses the modulo function).
-  template<typename Size_Type = size_t>
+  template<typename Size_Type = std::size_t>
   class direct_mod_range_hashing 
   : public detail::mod_based_range_hashing<Size_Type>
   {
@@ -180,7 +181,7 @@ namespace __gnu_pbds
 
   // A resize trigger policy based on a load check. It keeps the
   // load factor between some load factors load_min and load_max.
-  template<bool External_Load_Access = false, typename Size_Type = size_t>
+  template<bool External_Load_Access = false, typename Size_Type = std::size_t>
   class hash_load_check_resize_trigger : private PB_DS_SIZE_BASE_C_DEC
   {
   public:
@@ -295,7 +296,7 @@ namespace __gnu_pbds
 
   // A resize trigger policy based on collision checks. It keeps the
   // simulated load factor lower than some given load factor.
-  template<bool External_Load_Access = false, typename Size_Type = size_t>
+  template<bool External_Load_Access = false, typename Size_Type = std::size_t>
   class cc_hash_max_collision_check_resize_trigger
   {
   public:
@@ -396,7 +397,7 @@ namespace __gnu_pbds
 
   // A size policy whose sequence of sizes form an exponential
   // sequence (typically powers of 2.
-  template<typename Size_Type = size_t>
+  template<typename Size_Type = std::size_t>
   class hash_exponential_size_policy
   {
   public:
@@ -438,7 +439,7 @@ namespace __gnu_pbds
   {
   public:
     // Size type.
-    typedef size_t size_type;
+    typedef std::size_t size_type;
 
     // Default constructor, or onstructor taking a start_size The
     // policy will use the sequence of sizes approximately
@@ -472,7 +473,7 @@ namespace __gnu_pbds
   template<typename Size_Policy = hash_exponential_size_policy<>,
           typename Trigger_Policy = hash_load_check_resize_trigger<>,
           bool External_Size_Access = false,
-          typename Size_Type = size_t>
+          typename Size_Type = std::size_t>
   class hash_standard_resize_policy 
   : public Size_Policy, public Trigger_Policy
   {
index ec05b69c7e6bbfc92477390331cf2516d1f4f21a..54a67c6e563b0cab095bb9083352431bcfb61590 100644 (file)
@@ -1,6 +1,7 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007, 2009, 2010
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -41,6 +42,7 @@
 #ifndef PB_DS_LU_POLICY_HPP
 #define PB_DS_LU_POLICY_HPP
 
+#include <bits/c++config.h>
 #include <cstdlib>
 #include <ext/pb_ds/detail/list_update_policy/counter_lu_metadata.hpp>
 
@@ -87,12 +89,13 @@ namespace __gnu_pbds
 #undef PB_DS_CLASS_T_DEC
 #undef PB_DS_CLASS_C_DEC
 
-#define PB_DS_CLASS_T_DEC template<size_t Max_Count, class Allocator>
+#define PB_DS_CLASS_T_DEC template<std::size_t Max_Count, class Allocator>
 #define PB_DS_CLASS_C_DEC counter_lu_policy<Max_Count, Allocator>
 
   // A list-update policy that moves elements to the front of the list
   // based on the counter algorithm.
-  template<size_t Max_Count = 5, typename Allocator = std::allocator<char> >
+  template<std::size_t Max_Count = 5,
+          typename Allocator = std::allocator<char> >
   class counter_lu_policy 
   : private detail::counter_lu_policy_base<typename Allocator::size_type>
   {
index 531f70c65cefa0e8545ffed70da0d2ca763323e8..b6088e7d73a2ceb3ebe2bae4fcc6e6832fcfb866 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -41,6 +41,7 @@
 #ifndef PB_DS_PRIORITY_QUEUE_HPP
 #define PB_DS_PRIORITY_QUEUE_HPP
 
+#include <bits/c++config.h>
 #include <ext/pb_ds/tag_and_trait.hpp>
 #include <ext/pb_ds/detail/priority_queue_base_dispatch.hpp>
 #include <ext/pb_ds/detail/standard_policies.hpp>
@@ -53,10 +54,13 @@ namespace __gnu_pbds
           typename Tag = pairing_heap_tag,
           typename Allocator = std::allocator<char> >
   class priority_queue 
-  : public detail::priority_queue_base_dispatch<Value_Type,Cmp_Fn,Tag,Allocator>::type
+  : public detail::priority_queue_base_dispatch<Value_Type,
+                                               Cmp_Fn,Tag,Allocator>::type
   {
   private:
-    typedef typename detail::priority_queue_base_dispatch<Value_Type,Cmp_Fn,Tag,Allocator>::type base_type;
+    typedef typename
+    detail::priority_queue_base_dispatch<Value_Type, Cmp_Fn,
+                                        Tag, Allocator>::type base_type;
 
   public:
     typedef Value_Type                                         value_type;
index ccd2533cc4f0f6e1fc7b67365e00b3858b92ea33..ef445336137d6f7bd16ab51198742b74c6815a5b 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -42,6 +42,7 @@
 #ifndef PB_DS_TAG_AND_TRAIT_HPP
 #define PB_DS_TAG_AND_TRAIT_HPP
 
+#include <bits/c++config.h>
 #include <ext/pb_ds/detail/type_utils.hpp>
 
 /**
index 990860ec0209618ba6aa4cb87c0537e570480fad..4af1adbde707cfa1c118ddb0dc2ae248fe6254ab 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -41,6 +41,7 @@
 #ifndef PB_DS_TREE_POLICY_HPP
 #define PB_DS_TREE_POLICY_HPP
 
+#include <bits/c++config.h>
 #include <iterator>
 #include <ext/pb_ds/detail/type_utils.hpp>
 #include <ext/pb_ds/detail/basic_tree_policy/basic_tree_policy_base.hpp>
index c10591bb7f300cb8b0700af2cede7959b2001567..fc452104f75aacb3b917fb96fb1b1e78ad86d521 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -41,6 +41,7 @@
 #ifndef PB_DS_TRIE_POLICY_HPP
 #define PB_DS_TRIE_POLICY_HPP
 
+#include <bits/c++config.h>
 #include <string>
 #include <ext/pb_ds/detail/type_utils.hpp>
 #include <ext/pb_ds/detail/trie_policy/trie_policy_base.hpp>
index a18b274fa88d26a20801476f9d7577088b854264..dd18738dc57af2e4ddbbb1f0339071e3833e6af7 100644 (file)
@@ -554,7 +554,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
        // NB: Not required, but considered best practice.
        if (__is_null_pointer(__beg) && __beg != __end)
          std::__throw_logic_error(__N("__rc_string_base::"
-                                      "_S_construct NULL not valid"));
+                                      "_S_construct null not valid"));
 
        const size_type __dnew = static_cast<size_type>(std::distance(__beg,
                                                                      __end));
index b0500cf17e0504b0421adbd666b2170a7ddcd2ea..43d44528999e83e81211bf9d2ee7d2a5ef0b7d11 100644 (file)
@@ -434,7 +434,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
        // NB: Not required, but considered best practice.
        if (__is_null_pointer(__beg) && __beg != __end)
          std::__throw_logic_error(__N("__sso_string_base::"
-                                      "_M_construct NULL not valid"));
+                                      "_M_construct null not valid"));
 
        size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
 
index 36c19e0a97abbbb67a61fb934de3b915822534a8..a4276f30ba2cfe86fb3e1b0c97445716dbcc3401 100644 (file)
@@ -1,6 +1,6 @@
 // String Conversions -*- C++ -*-
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -27,9 +27,9 @@
 
 #pragma GCC system_header
 
+#include <bits/c++config.h>
 #include <ext/numeric_traits.h>
 #include <bits/functexcept.h>
-#include <cstddef>
 #include <cstdlib>
 #include <cwchar>
 #include <cstdio>
index 70b197a705d1d7934e45fff665266f9b6fbc90a5..669d433e27295edac9a80ab42f06bd8f8962602a 100644 (file)
@@ -110,7 +110,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
     void
     insert(void* p, size_t size)
     {
-      if (p == NULL)
+      if (!p)
        {
          std::string error("annotate_base::insert null insert!\n");
          log_to_string(error, make_entry(p, size));
index 1a8c3cb60a8dc16e3348757613ab8f4af7ea45d0..7bff97f7706af6867edba2c73e449c7503c6d21c 100644 (file)
@@ -267,8 +267,8 @@ namespace __gnu_parallel
 
   /** @brief Similar to std::plus, but allows two different types. */
   template<typename _Tp1, typename _Tp2, typename _Result
-          = __typeof__(*static_cast<_Tp1*>(NULL)
-                       + *static_cast<_Tp2*>(NULL))>
+          = __typeof__(*static_cast<_Tp1*>(0)
+                       + *static_cast<_Tp2*>(0))>
     struct _Plus : public std::binary_function<_Tp1, _Tp2, _Result>
     {
       _Result
@@ -283,8 +283,8 @@ namespace __gnu_parallel
 
   /** @brief Similar to std::multiplies, but allows two different types. */
   template<typename _Tp1, typename _Tp2, typename _Result
-          = __typeof__(*static_cast<_Tp1*>(NULL)
-                       * *static_cast<_Tp2*>(NULL))>
+          = __typeof__(*static_cast<_Tp1*>(0)
+                       * *static_cast<_Tp2*>(0))>
     struct _Multiplies : public std::binary_function<_Tp1, _Tp2, _Result>
     {
       _Result
index c5c067a0b0da38a310ae8352cef2ec00164b0e70..a624edc1a3b5936fe59102ceb5f29cb801c7064a 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -34,7 +34,6 @@
 #define _GLIBCXX_PARALLEL_BASIC_ITERATOR_H 1
 
 #include <bits/c++config.h>
-#include <cstddef>
 #include <bits/stl_iterator_base_types.h>
 #include <bits/stl_iterator_base_funcs.h>
 #include <bits/stl_iterator.h>
index 1fab257ccdde2c089190849a3e84c840c526ed43..e77653aeefa8b97cdefe15ec88254e2da496f87b 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -230,7 +230,7 @@ namespace __gnu_parallel
           __n /= 2;
 
           _SeqNumber __lmax_seq = -1;  // to avoid warning
-          const _ValueType* __lmax = NULL; // impossible to avoid the warning?
+          const _ValueType* __lmax = 0; // impossible to avoid the warning?
           for (_SeqNumber __i = 0; __i < __m; __i++)
             {
               if (__a[__i] > 0)
@@ -332,8 +332,8 @@ namespace __gnu_parallel
       // Compare the keys on both edges of the border.
 
       // Maximum of left edge, minimum of right edge.
-      _ValueType* __maxleft = NULL;
-      _ValueType* __minright = NULL;
+      _ValueType* __maxleft = 0;
+      _ValueType* __minright = 0;
       for (_SeqNumber __i = 0; __i < __m; __i++)
         {
           if (__a[__i] > 0)
@@ -482,7 +482,7 @@ namespace __gnu_parallel
         {
           __n /= 2;
 
-          const _Tp* __lmax = NULL;
+          const _Tp* __lmax = 0;
           for (_SeqNumber __i = 0; __i < __m; ++__i)
             {
               if (__a[__i] > 0)
index 445184ae5ecd647b61262b64759d5ba39634a781..1baf76beb9ca0d411e64972554c1344c4ef2b931 100644 (file)
@@ -502,11 +502,11 @@ namespace __gnu_parallel
       _LT __lt(__k, __comp);
 
       // Default value for potentially non-default-constructible types.
-      _ValueType* __arbitrary_element = NULL;
+      _ValueType* __arbitrary_element = 0;
 
       for (_SeqNumber __t = 0; __t < __k; ++__t)
        {
-          if(__arbitrary_element == NULL
+          if(!__arbitrary_element
             && _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__t]) > 0)
             __arbitrary_element = &(*__seqs_begin[__t].first);
        }
index 85894719dc0ae56409a1e285320b6abd7d86f923..8e2c53ec661e9255bbf6e70bc610559cffa96a78 100644 (file)
@@ -434,7 +434,7 @@ namespace __gnu_parallel
                (::operator new(__size * sizeof(_ValueType)));
            }
          else
-           __sd._M_samples = NULL;
+           __sd._M_samples = 0;
 
          __sd._M_offsets = new _DifferenceType[__num_threads - 1];
          __sd._M_pieces
index 0d5a139968c9472592aab8b7bbe7af597a70a68c..27b3871f41b0ea868e0e5c7213a9b93b94575ffb 100644 (file)
@@ -73,7 +73,7 @@ namespace __gnu_parallel
                                         __leftnew, __rightnew;
 
       // just 0 or 1, but int to allow atomic operations
-      int* __reserved_left = NULL, * __reserved_right = NULL;
+      int* __reserved_left = 0, * __reserved_right = 0;
 
       _DifferenceType __chunk_size = __s.partition_chunk_size;
 
index 77654a8f813e5f998673efc2044b84fb876641be..97bb061300a7370824e3ca73bd066be2e4578e54 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 //
-// Copyright (C) 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -65,14 +65,14 @@ inline __stack_t __get_stack()
 #if defined _GLIBCXX_HAVE_EXECINFO_H
   size_t __max_depth = __stack_max_depth();
   if (__max_depth == 0)
-    return NULL;
+    return 0;
   __stack_npt __buffer(__max_depth);
   int __depth = backtrace(&__buffer[0], __max_depth);
   __stack_t __stack = new __stack_npt(__depth);
   memcpy(&(*__stack)[0], &__buffer[0], __depth * sizeof(__object_t));
   return __stack;
 #else
-  return NULL;
+  return 0;
 #endif
 }
 
index bfa8a6c3b21f0398352b4602ba0b72e63f9e8fac..19a2a8273ef6103e2fce200ee5db435ff397f903 100644 (file)
@@ -87,8 +87,8 @@ struct __warning_data
   const char* __warning_id;
   const char* __warning_message;
   __warning_data()
-  : __magnitude(0.0), __context(NULL), __warning_id(NULL),
-    __warning_message(NULL) { }
+  : __magnitude(0.0), __context(0), __warning_id(0),
+    __warning_message(0) { }
   __warning_data(float __m, __stack_t __c, const char* __id, 
                  const char* __msg)
   : __magnitude(__m), __context(__c), __warning_id(__id), 
@@ -141,13 +141,13 @@ struct __cost_factor
 
 typedef std::_GLIBCXX_STD_PR::vector<__cost_factor*> __cost_factor_vector;
 
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, NULL);
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, NULL);
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, NULL);
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, NULL);
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, NULL);
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, NULL); 
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, NULL);
+_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, 0);
+_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, 0);
+_GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, 0);
+_GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, 0);
+_GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, 0);
+_GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, 0); 
+_GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, 0);
 
 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_shift_cost_factor, 
                              {"__vector_shift_cost_factor", 1.0});
@@ -177,7 +177,7 @@ _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_find_cost_factor,
                              {"__umap_find_cost_factor", 10.0});
 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_iterate_cost_factor,
                              {"__umap_iterate_cost_factor", 1.7});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, NULL);
+_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, 0);
 
 _GLIBCXX_PROFILE_DEFINE_DATA(const char*, _S_trace_file_name,
                              _GLIBCXX_PROFILE_TRACE_PATH_ROOT);
@@ -249,7 +249,7 @@ __trace_base<__object_info, __stack_info>::__trace_base()
   __object_table.rehash(10000);
   __stack_table.rehash(10000);
   __stack_table_byte_size = 0;
-  __id = NULL;
+  __id = 0;
 }
 
 template <typename __object_info, typename __stack_info>
@@ -277,7 +277,7 @@ __object_info* __trace_base<__object_info, __stack_info>::__get_object_info(
       __object_table.find(__object);
   if (__object_it == __object_table.end()){
     this->__object_table_lock.unlock();
-    return NULL;
+    return 0;
   } else {
     this->__object_table_lock.unlock();
     return &__object_it->second;
@@ -336,7 +336,7 @@ inline size_t __env_to_size_t(const char* __env_var, size_t __default_value)
 {
   char* __env_value = getenv(__env_var);
   if (__env_value) {
-    long int __converted_value = strtol(__env_value, NULL, 10);
+    long int __converted_value = strtol(__env_value, 0, 10);
     if (errno || __converted_value < 0) {
       fprintf(stderr, "Bad value for environment variable '%s'.\n", __env_var);
       abort();
index 5ef52f3763f31f146c44355dc352023a3ba5b633..d4f685ced547fa09f3b4d42a91530f0906f5fba5 100644 (file)
@@ -38,8 +38,8 @@
 # include <bits/c++0x_warning.h>
 #endif
 
+#include <bits/c++config.h>
 #include <bits/atomic_base.h>
-#include <cstddef>
 
 _GLIBCXX_BEGIN_NAMESPACE(std)
 
index b23b51a78fed40dd5990f306b06c69fbcfbf7f03..32ca091706221332b223e508cd2663956af6836d 100644 (file)
@@ -45,7 +45,6 @@
 
 #pragma GCC system_header
 
-#include <cstddef>     // For size_t
 #include <string>
 #include <bits/functexcept.h>   // For invalid_argument, out_of_range,
                                 // overflow_error
index 9aa4f1ab10f6fbe2158ceef4ddcd63f346a9e8bf..00690bee9384c012d99466e755f36dd5dd91e413 100644 (file)
@@ -397,7 +397,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
        if (__testout && __off == 0 && _M_buf_size > 1 )
          this->setp(_M_buf, _M_buf + _M_buf_size - 1);
        else
-         this->setp(NULL, NULL);
+         this->setp(0, 0);
       }
     };
 
@@ -795,7 +795,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       explicit
       basic_fstream(const char* __s,
                    ios_base::openmode __mode = ios_base::in | ios_base::out)
-      : __iostream_type(NULL), _M_filebuf()
+      : __iostream_type(0), _M_filebuf()
       {
        this->init(&_M_filebuf);
        this->open(__s, __mode);
@@ -810,7 +810,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       explicit
       basic_fstream(const std::string& __s,
                    ios_base::openmode __mode = ios_base::in | ios_base::out)
-      : __iostream_type(NULL), _M_filebuf()
+      : __iostream_type(0), _M_filebuf()
       {
        this->init(&_M_filebuf);
        this->open(__s, __mode);
index a15bdf9744c963fa775af026a410fb079f314e52..5395106ae6aa9919b4ccfd25858ecbc140747048 100644 (file)
@@ -1,6 +1,6 @@
 // <iterator> -*- C++ -*-
 
-// Copyright (C) 2001, 2002, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -58,7 +58,6 @@
 #pragma GCC system_header
 
 #include <bits/c++config.h>
-#include <cstddef>
 #include <bits/stl_iterator_base_types.h>
 #include <bits/stl_iterator_base_funcs.h>
 #include <bits/stl_iterator.h>
index be435cd38e53af8a01b4b488dd3606adb5b1ed4a..b236f0db91d73324308ecac460d3f553edc566dc 100644 (file)
@@ -37,7 +37,6 @@
 #else
 
 #include <tuple>
-#include <cstddef>
 #include <chrono>
 #include <exception>
 #include <type_traits>
index 470f2c0f35cfb50e92cce38df4d72a46ee71063f..c348c76bc40ee518c5fff298776e00b755d77abc 100644 (file)
@@ -40,7 +40,6 @@
 #include <memory>
 #include <mutex>
 #include <condition_variable>
-#include <cstddef>
 #include <bits/functexcept.h>
 #include <bits/functional_hash.h>
 #include <bits/gthr.h>
index 9831851c4a54ab04b7a8b1e47f1e6507d3bd54bc..3253f419645b729566cbb2924ecf2a7fc58da4d1 100644 (file)
@@ -39,7 +39,7 @@
 #  error C++0x header cannot be included from TR1 header
 #endif
 
-#include <cstddef>
+#include <bits/c++config.h>
 
 #if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
 #  include <tr1_impl/type_traits>
index fa92751791dee6df12591bbed64a7f9a4111f91f..f15ac92b0bf76f351ad30dcc1a87755e5415105a 100644 (file)
@@ -1,7 +1,7 @@
 // The template and inlines for the -*- C++ -*- valarray class.
 
 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-// 2006, 2007, 2008, 2009
+// 2006, 2007, 2008, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -36,7 +36,6 @@
 #pragma GCC system_header
 
 #include <bits/c++config.h>
-#include <cstddef>
 #include <cmath>
 #include <algorithm>
 #include <debug/debug.h>
index fe28f84785a847eea3723da29a07a39210e6e130..33083ff9c7371ee77db331e74856163e6120167b 100644 (file)
@@ -1,6 +1,7 @@
 // TR1 type_traits -*- C++ -*-
 
-// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -35,7 +36,7 @@
 #  error TR1 header cannot be included from C++0x header
 #endif
 
-#include <cstddef>
+#include <bits/c++config.h>
 
 #if defined(_GLIBCXX_INCLUDE_AS_TR1)
 #  include <tr1_impl/type_traits>
index 3810706d47e325cdf9cee82e85eedb8560055e80..f4a8f864259b2db789358299899871b0e41b18c5 100644 (file)
@@ -36,7 +36,7 @@
 
 #pragma GCC visibility push(default)
 
-#include <cstddef>
+#include <bits/c++config.h>
 
 namespace std
 {
@@ -61,7 +61,7 @@ namespace std
       : _M_array(__a), _M_len(__l) { }
 
     public:
-      initializer_list() : _M_array(NULL), _M_len(0) { }
+      initializer_list() : _M_array(0), _M_len(0) { }
 
       // Number of elements.
       size_type
index 7b515311cab3974e4b31b997dac644304cf62732..80ee3ba0fd89332e3cc5f8f5254853e5e9b6ef81 100644 (file)
@@ -38,7 +38,7 @@
 
 #pragma GCC system_header
 
-#include <cstddef>
+#include <bits/c++config.h>
 #include <exception>
 
 #pragma GCC visibility push(default)
index 422b97399ac2391144dfebec4c811a444dde5e70..6d7a64d0080416ea9a3a1b9ff397b3824e7c91d8 100644 (file)
@@ -1,6 +1,6 @@
 // chrono -*- C++ -*-
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -51,7 +51,7 @@ namespace std
 #elif defined(_GLIBCXX_USE_GETTIMEOFDAY)
       timeval tv;
       // EINVAL, EFAULT
-      gettimeofday(&tv, NULL);
+      gettimeofday(&tv, 0);
       return time_point(duration(chrono::seconds(tv.tv_sec)
                                 + chrono::microseconds(tv.tv_usec)));
 #else
index fdcb6a04b38447d28afaa47547216e2684ab38fd..d3f29f657f40fb32a100d0dfff611bfa42a54503 100644 (file)
@@ -1,6 +1,6 @@
 // condition_variable -*- C++ -*-
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -34,7 +34,7 @@ namespace std
     __native_type __tmp = __GTHREAD_COND_INIT;
     _M_cond = __tmp;
 #else
-    int __e = __gthread_cond_init(&_M_cond, NULL);
+    int __e = __gthread_cond_init(&_M_cond, 0);
 
     if (__e)
       __throw_system_error(__e);
index 5ee8258ccb8cadede16e8cb9ca02fd07d7a68919..1dc1d6891c6c2a12a23fa84e14bfdd4d954ca188 100644 (file)
@@ -137,7 +137,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
          }
       }
     else
-      __throw_runtime_error(__N("locale::locale NULL not valid"));
+      __throw_runtime_error(__N("locale::locale null not valid"));
   }
 
   locale::locale(const locale& __base, const char* __s, category __cat)
index 9c3af0e60d5c9258858429c304acf952a4027c4f..b04fe5b05e447882e223f5f0bb26329a9e1a8cc9 100644 (file)
@@ -1,6 +1,6 @@
 // Allocator details.
 
-// Copyright (C) 2004, 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2004, 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -150,7 +150,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
        __block->_M_next = reinterpret_cast<_Block_record*>(__c);
        __block = __block->_M_next;
       }
-    __block->_M_next = NULL;
+    __block->_M_next = 0;
 
     __block = __bin._M_first[__thread_id];
     __bin._M_first[__thread_id] = __block->_M_next;
@@ -206,8 +206,8 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
        _Bin_record& __bin = _M_bin[__n];
        __v = ::operator new(sizeof(_Block_record*));
        __bin._M_first = static_cast<_Block_record**>(__v);
-       __bin._M_first[0] = NULL;
-       __bin._M_address = NULL;
+       __bin._M_first[0] = 0;
+       __bin._M_address = 0;
       }
     _M_init = true;
   }
@@ -362,7 +362,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
     //   blocks on global list (and if not add new ones) and
     //   get the first one.
     _Bin_record& __bin = _M_bin[__which];
-    _Block_record* __block = NULL;
+    _Block_record* __block = 0;
     if (__gthread_active_p())
       {
        // Resync the _M_used counters.
@@ -374,7 +374,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
        __atomic_add(&__reclaimed_base[__thread_id], -__reclaimed);
 
        __gthread_mutex_lock(__bin._M_mutex);
-       if (__bin._M_first[0] == NULL)
+       if (__bin._M_first[0] == 0)
          {
            void* __v = ::operator new(__options._M_chunk_size);
            _Block_address* __address = static_cast<_Block_address*>(__v);
@@ -395,7 +395,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
                __block->_M_next = reinterpret_cast<_Block_record*>(__c);
                __block = __block->_M_next;
              }
-           __block->_M_next = NULL;
+           __block->_M_next = 0;
          }
        else
          {
@@ -407,7 +407,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
              {
                __bin._M_free[__thread_id] = __bin._M_free[0];
                __bin._M_free[0] = 0;
-               __bin._M_first[0] = NULL;
+               __bin._M_first[0] = 0;
              }
            else
              {
@@ -417,7 +417,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
                while (--__block_count > 0)
                  __block = __block->_M_next;
                __bin._M_first[0] = __block->_M_next;
-               __block->_M_next = NULL;
+               __block->_M_next = 0;
              }
            __gthread_mutex_unlock(__bin._M_mutex);
          }
@@ -439,7 +439,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
            __block->_M_next = reinterpret_cast<_Block_record*>(__c);
            __block = __block->_M_next;
          }
-       __block->_M_next = NULL;
+       __block->_M_next = 0;
       }
       
     __block = __bin._M_first[__thread_id];
@@ -527,7 +527,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
                }
 
              // Set last record.
-             _M_thread_freelist[__i - 1]._M_next = NULL;
+             _M_thread_freelist[__i - 1]._M_next = 0;
              _M_thread_freelist[__i - 1]._M_id = __i;
 
              if (!freelist._M_thread_freelist_array)
@@ -572,7 +572,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
            std::memset(__v, 0, sizeof(_Block_record*) * __max_threads);    
            __bin._M_first = static_cast<_Block_record**>(__v);
 
-           __bin._M_address = NULL;
+           __bin._M_address = 0;
 
            __v = ::operator new(sizeof(size_t) * __max_threads);
            std::memset(__v, 0, sizeof(size_t) * __max_threads);
@@ -606,8 +606,8 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
            _Bin_record& __bin = _M_bin[__n];
            __v = ::operator new(sizeof(_Block_record*));
            __bin._M_first = static_cast<_Block_record**>(__v);
-           __bin._M_first[0] = NULL;
-           __bin._M_address = NULL;
+           __bin._M_first[0] = 0;
+           __bin._M_address = 0;
          }
       }
     _M_init = true;
@@ -722,7 +722,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
                }
 
              // Set last record.
-             _M_thread_freelist[__i - 1]._M_next = NULL;
+             _M_thread_freelist[__i - 1]._M_next = 0;
              _M_thread_freelist[__i - 1]._M_id = __i;
 
              if (!freelist._M_thread_freelist_array)
@@ -767,7 +767,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
            std::memset(__v, 0, sizeof(_Block_record*) * __max_threads);
            __bin._M_first = static_cast<_Block_record**>(__v);
 
-           __bin._M_address = NULL;
+           __bin._M_address = 0;
 
            __v = ::operator new(sizeof(size_t) * __max_threads);
            std::memset(__v, 0, sizeof(size_t) * __max_threads);
@@ -800,8 +800,8 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
            _Bin_record& __bin = _M_bin[__n];
            __v = ::operator new(sizeof(_Block_record*));
            __bin._M_first = static_cast<_Block_record**>(__v);
-           __bin._M_first[0] = NULL;
-           __bin._M_address = NULL;
+           __bin._M_first[0] = 0;
+           __bin._M_address = 0;
          }
       }
     _M_init = true;
index 879e864edd4bfbe459d2150eec77057f3722c8b5..2ea6a490735b0e631271e12e9eeee6fb5e10f595 100644 (file)
@@ -1,6 +1,6 @@
 // thread -*- C++ -*-
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -58,7 +58,7 @@ namespace std
     int __e = EINVAL;
 
     if (_M_id != id())
-      __e = __gthread_join(_M_id._M_thread, NULL);
+      __e = __gthread_join(_M_id._M_thread, 0);
 
     if (__e)
       __throw_system_error(__e);
index 9e621c3f786094245e51c1c772a440415c62add7..f6c623043cd4fad4145d79b65b5f860e92a7d4b8 100644 (file)
@@ -1,7 +1,7 @@
 // { dg-require-sharedlib "" }
 // { dg-options "-g -O2 -pthread -ldl -x c" { target *-*-linux* } }
 
-// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -32,20 +32,20 @@ static void* run(void* arg)
   void (*cb)();
 
   lib = dlopen("./testsuite_shared.so", RTLD_NOW);
-  if (lib == NULL)
+  if (!lib)
     {
       printf("dlopen failed: %s\n", strerror(errno));
-      return NULL;
+      return 0;
     }
   cb = (function_type) dlsym(lib, "try_throw_exception");
-  if (cb == NULL)
+  if (!cb)
     {
       printf("dlsym failed: %s\n", strerror(errno));
-      return NULL;
+      return 0;
     }
   cb();
   dlclose(lib);
-  return NULL;
+  return 0;
 }
 
 // libstdc++/23591
@@ -53,9 +53,9 @@ int main(void)
 {
   pthread_t pt;
 
-  if (pthread_create(&pt, NULL, &run, NULL) != 0)
+  if (pthread_create(&pt, 0, &run, 0) != 0)
     return 1;
-  if (pthread_join(pt, NULL) != 0)
+  if (pthread_join(pt, 0) != 0)
     return 1;
 
   return 0;
index ef845d3a39188a6b0ee30c56738cfd9087abebba..866a89b79cb45726d128d09a16f771bf631b0c25 100644 (file)
@@ -1,6 +1,6 @@
 // 2002-07-24 Benjamin Kosnik
 
-// Copyright (C) 2002, 2004, 2009 Free Software Foundation
+// Copyright (C) 2002, 2004, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -27,7 +27,7 @@ void test01()
 {
   void* pc = new char;
   void* pa = new char[10];
-  void* tmp = NULL;
+  void* tmp = 0;
   operator delete(pc, tmp);
   operator delete[](pa, tmp);
 }
index 965328ebcbabbfd91a648121ca8f12e423e6d369..5389316bab0c88f1fdb0e9e2beb9f86568fa57e2 100644 (file)
@@ -1,5 +1,5 @@
 //
-// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -40,7 +40,7 @@ void*
 do_something (void *arg)
 {
   static int bar __attribute__((unused)) = get_bar ();
-  return NULL;
+  return 0;
 }
 
 int
@@ -48,10 +48,10 @@ get_foo (void)
 {
   pthread_t new_thread;
 
-  if (pthread_create (&new_thread, NULL, do_something, NULL) != 0)
+  if (pthread_create (&new_thread, 0, do_something, 0) != 0)
     std::abort ();
 
-  if (pthread_join (new_thread, NULL) != 0)
+  if (pthread_join (new_thread, 0) != 0)
     std::abort ();
 
   return 1;
index 73839d26c22e091b27949b3a42c66d5707a5555d..5652478f42b07e768f42338d43c4316ab33ecd59 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-06-04 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -33,7 +33,7 @@ void test05()
   std::string empty2(empty.begin(), empty.end());
 
   // libstdc++/8716 (same underlying situation, same fix)
-  char const * s = NULL;
+  char const * s = 0;
   std::string zero_length_built_with_NULL(s,0);
 }
 
index 4fe58b6aced5b537a98894be012d0e3f4cf53f50..e72377de66a01953b44424f19e5a80516fcdfd29 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-06-04 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -33,7 +33,7 @@ void test05()
   std::wstring empty2(empty.begin(), empty.end());
 
   // libstdc++/8716 (same underlying situation, same fix)
-  wchar_t const * s = NULL;
+  wchar_t const * s = 0;
   std::wstring zero_length_built_with_NULL(s,0);
 }
 
index c39f6b416f7f05edfa55262144ec771fec290668..de0fe168e98219fdb47e42a15283c99ee61e7acb 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2004, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -29,7 +29,7 @@ int test01(void)
   // data() for size == 0 is non-NULL.
   VERIFY( empty.size() == 0 );
   const std::string::value_type* p = empty.data();
-  VERIFY( p != NULL );
+  VERIFY( p );
 
   return 0;
 }
index 1ddde9272277d455a1998b96f19c17036b012408..a57464aa5b55c9203b3c2baabb0b27fd6c92d9f3 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2004, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -29,7 +29,7 @@ int test01(void)
   // data() for size == 0 is non-NULL.
   VERIFY( empty.size() == 0 );
   const std::wstring::value_type* p = empty.data();
-  VERIFY( p != NULL );
+  VERIFY( p );
 
   return 0;
 }
index fb48898d69661523edc246d81227b14516959da8..b3dc9b20e7c71792c35af62e562208afe71e8640 100644 (file)
@@ -2,7 +2,7 @@
 // Adapted from http://gcc.gnu.org/ml/gcc-bugs/2002-01/msg00679.html
 // which was adapted from pthread1.cc by Mike Lu <MLu@dynamicsoft.com>
 //
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -95,12 +95,12 @@ main (void)
 #endif
 
   pthread_t prod;
-  pthread_create (&prod, NULL, produce, NULL);
+  pthread_create (&prod, 0, produce, 0);
   pthread_t cons;
-  pthread_create (&cons, NULL, consume, NULL);
+  pthread_create (&cons, 0, consume, 0);
 
-  pthread_join (prod, NULL);
-  pthread_join (cons, NULL);
+  pthread_join (prod, 0);
+  pthread_join (cons, 0);
 
   return 0;
 }
index 4a96797bf528dc0fb0da93c9b012466f5b4338f9..2df9553a35d645602114b1c1028f898743187693 100644 (file)
@@ -1,4 +1,5 @@
-// Copyright (C) 2000, 2001, 2002, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2000, 2001, 2002, 2003, 2009, 2010
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -84,8 +85,8 @@ void test01()
   std::ctype_base::mask m01[3];
   std::ctype_base::mask m02[13];
   const char_type* cc0 = strlit00;
-  const char_type* cc1 = NULL;
-  const char_type* cc2 = NULL;
+  const char_type* cc1 = 0;
+  const char_type* cc2 = 0;
 
   cc0 = strlit00;
   for (std::size_t i = 0; i < 3; ++i)
index cf2f845ca3b0349bf0ae5f285bb73ea3857d3aa5..0b989cbe729f905edea63323b4b61067a014a280 100644 (file)
@@ -1,4 +1,5 @@
-// Copyright (C) 2000, 2001, 2002, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2000, 2001, 2002, 2003, 2009, 2010
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -84,8 +85,8 @@ void test01()
   std::ctype_base::mask m01[3];
   std::ctype_base::mask m02[13];
   const char_type* cc0 = strlit00;
-  const char_type* cc1 = NULL;
-  const char_type* cc2 = NULL;
+  const char_type* cc1 = 0;
+  const char_type* cc2 = 0;
 
   cc0 = strlit00;
   for (std::size_t i = 0; i < 3; ++i)
index d7ad84137da8d96e1dd339230b7b2ae70d5ca64f..f36559ea27c9a96a2c231adb2ab3f40d6ac3c0ec 100644 (file)
@@ -3,7 +3,7 @@
 // { dg-options "-pthreads" { target *-*-solaris* } }
 // { dg-require-namedlocale "" }
 
-// Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation
+// Copyright (C) 2004, 2005, 2007, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -59,10 +59,10 @@ main()
   pthread_t tid[max_thread_count];
   
   for (int i = 0; i < max_thread_count; i++)
-    pthread_create (&tid[i], NULL, thread_main, 0);
+    pthread_create (&tid[i], 0, thread_main, 0);
   
   for (int i = 0; i < max_thread_count; i++)
-    pthread_join (tid[i], NULL);
+    pthread_join (tid[i], 0);
 
   return 0;
 }
index c5c70dcc9d7ad018a50b340441b2e00340b01fbd..c09b000130ec7c501285c2cd3689c356fe9daddd 100644 (file)
@@ -2,7 +2,8 @@
 
 // 2000-09-13 Benjamin Kosnik <bkoz@redhat.com>
 
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+// 2009, 2010
 // Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -96,7 +97,7 @@ void test01()
   VERIFY( loc07 != loc02 );  
   VERIFY( loc07.name() != "" );
   try
-    { locale loc08(static_cast<const char*>(NULL)); }
+    { locale loc08(static_cast<const char*>(0)); }
   catch(runtime_error& obj)
     { VERIFY( true ); }
   catch(...)
@@ -130,7 +131,7 @@ void test01()
     VERIFY( loc11 == loc01 );  
 
     try
-      { locale loc12(loc01, static_cast<const char*>(NULL), locale::ctype); }
+      { locale loc12(loc01, static_cast<const char*>(0), locale::ctype); }
     catch(runtime_error& obj)
       { VERIFY( true ); }
     catch(...)
@@ -178,7 +179,7 @@ void test01()
     VERIFY( loc11 == loc01 );
 
     try
-      { locale loc12(loc01, static_cast<const char*>(NULL), locale::ctype); }
+      { locale loc12(loc01, static_cast<const char*>(0), locale::ctype); }
     catch(runtime_error& obj)
       { VERIFY( true ); }
     catch(...)
index 428efc952b6287069c4f63bd8f1976b7d5a62fb1..6693f5d2d6de553a3ec18d56a5c9f41c83460a95 100644 (file)
@@ -1,6 +1,6 @@
 // { dg-require-namedlocale "" }
 
-// Copyright (C) 2006, 2009 Free Software Foundation
+// Copyright (C) 2006, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -36,7 +36,7 @@ void test01()
          "LC_PAPER=C;LC_NAME=C;LC_ADDRESS=C;LC_TELEPHONE=C;"
          "LC_MEASUREMENT=C;LC_IDENTIFICATION=C" );
 
-  VERIFY( locale().name() == setlocale(LC_ALL, NULL) );
+  VERIFY( locale().name() == setlocale(LC_ALL, 0) );
 
   locale loc1 = locale(locale::classic(), "en_US.UTF-8", locale::time);
 
index 4927e5647a1892bf5d944c8ef3dcea258ccfe795..30e133fd49a5dfecd786937701b7a23d58c61169 100644 (file)
@@ -2,7 +2,7 @@
 
 // 2004-02-09  Petur Runolfsson  <peturr02@ru.is>
 
-// Copyright (C) 2004, 2005, 2009 Free Software Foundation
+// Copyright (C) 2004, 2005, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -39,7 +39,7 @@ void test01()
   if (loc.name() != "*")
     {
       locale::global(loc);
-      VERIFY( loc.name() == setlocale(LC_ALL, NULL) );
+      VERIFY( loc.name() == setlocale(LC_ALL, 0) );
     }
 }
 
index 21d52fd4b2ec636fbb08a4f20a2b4e9e4ada6408..3265f71a29cd2f01125d2212c94effcb9512f7e5 100644 (file)
@@ -2,7 +2,7 @@
 
 // 2000-09-13 Benjamin Kosnik <bkoz@redhat.com>
 
-// Copyright (C) 2000, 2002, 2003, 2005, 2009 Free Software Foundation
+// Copyright (C) 2000, 2002, 2003, 2005, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -33,7 +33,7 @@ void test02()
   
   const string ph("en_PH");
   const string mx("es_MX");
-  const char* orig = setlocale(LC_ALL, NULL);
+  const char* orig = setlocale(LC_ALL, 0);
   const char* testph = setlocale(LC_ALL, ph.c_str());
   const char* testmx = setlocale(LC_ALL, mx.c_str());
   setlocale(LC_ALL, orig);
@@ -54,7 +54,7 @@ void test02()
       
       // Change global locale.
       locale global_orig = locale::global(loc_mx);
-      const char* lc_all_mx = setlocale(LC_ALL, NULL);
+      const char* lc_all_mx = setlocale(LC_ALL, 0);
       if (lc_all_mx)
        {
          VERIFY( mx == lc_all_mx );
index 7de5471495fb78e842423b3e4aead0f23b20a435..3c6ad92e48315b46abb800f7e96ec5fc53fef86c 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2003, 2009 Free Software Foundation
+// Copyright (C) 2003, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -47,7 +47,7 @@ void test01()
   bool test __attribute__((unused)) = true;
   
   ostringstream stream;
-  time_t tt = time(NULL);
+  time_t tt = time(0);
   
   const char* fmt = "%c";
   
index 54d4cde7cefc89a580497eefdc38ce6fb351abd0..3d19d36c20b9cf60be8ab574372d9de095b87343 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2003, 2009 Free Software Foundation
+// Copyright (C) 2003, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -46,7 +46,7 @@ void test03()
   bool test __attribute__((unused)) = true;
   
   ostringstream stream;
-  time_t tt = time(NULL);
+  time_t tt = time(0);
   
   const char* fmt = "%c";
   
index ca275bda5ad1f3f06adcd16e565794de7e57c6ea..7b291df798acfc9ce7c99bbdfdbe97c943dae3ef 100644 (file)
@@ -1,6 +1,6 @@
 // 2005-09-10  Paolo Carlini  <pcarlini@suse.de>
 //
-// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -22,6 +22,7 @@
 
 // libstdc++/23781
 #include <list>
+#include <cstddef>
 
 typedef std::list<int> list_type;
 list_type::iterator it = NULL; // { dg-error "conversion" }
index fcbb039dce3e460f90432430b7cdb4e8028fb8f9..7a1de4d660773751b3de2b5624d374e20c805cb4 100644 (file)
@@ -1,6 +1,6 @@
 // 2002-01-23  Loren J. Rittle <rittle@labs.mot.com> <ljrittle@acm.org>
 //
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -31,6 +31,7 @@
 
 #include <list>
 #include <cstdlib>
+#include <cstddef>
 #include <pthread.h>
 
 const int thread_cycles = 10;
index f7967693f797f75b1af543cd5fca42069b399c04..e282c75466710c323eed5b13a17e19ae7369f50e 100644 (file)
@@ -1,6 +1,6 @@
 // 2005-09-10  Paolo Carlini  <pcarlini@suse.de>
 //
-// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -22,6 +22,7 @@
 
 // libstdc++/23781
 #include <map>
+#include <cstddef>
 
 std::map<int, int>::iterator it = NULL; // { dg-error "conversion" }
 std::map<int, int>::const_iterator cit = NULL; // { dg-error "conversion" }
index 608527e8f08b60fa17e6ce61a996d55cdfe05539..8680ebbcc44dd8e64b1340524801a5935151ec79 100644 (file)
@@ -1,7 +1,7 @@
 // 2002-01-23  Loren J. Rittle <rittle@labs.mot.com> <ljrittle@acm.org>
 // Adpated from libstdc++/5444 submitted by markus.breuer@materna.de
 //
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -26,6 +26,7 @@
 #include <string>
 #include <map>
 #include <vector>
+#include <cstddef>
 #include <pthread.h>
 
 const int max_thread_count = 8;
index 912bb926b98db210eaeeee28d3cf0009d3a5a99f..50ec929064e4408a5ee4ae8711c50758dbf9f027 100644 (file)
@@ -1,6 +1,6 @@
 // 2005-09-10  Paolo Carlini  <pcarlini@suse.de>
 //
-// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -22,6 +22,7 @@
 
 // libstdc++/23781
 #include <map>
+#include <cstddef>
 
 std::multimap<int, int>::iterator it = NULL; // { dg-error "conversion" }
 std::multimap<int, int>::const_iterator cit = NULL; // { dg-error "conversion" }
index 80d13370345fb942e816325a15eb3093a943aebc..6b0bacf955b83a903d7a727bd49e00d2987c6b2b 100644 (file)
@@ -1,6 +1,6 @@
 // 2005-09-10  Paolo Carlini  <pcarlini@suse.de>
 //
-// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -22,6 +22,7 @@
 
 // libstdc++/23781
 #include <set>
+#include <cstddef>
 
 std::multiset<int>::iterator it = NULL; // { dg-error "conversion" }
 std::multiset<int>::const_iterator cit = NULL; // { dg-error "conversion" }
index 7a2a2bc7240664cd986437c2347a3799500ba4ab..b47b748ec8d97d16c73115d6249de535a68c64e7 100644 (file)
@@ -1,6 +1,6 @@
 // 2005-09-10  Paolo Carlini  <pcarlini@suse.de>
 //
-// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -22,6 +22,7 @@
 
 // libstdc++/23781
 #include <set>
+#include <cstddef>
 
 std::set<int>::iterator it = NULL; // { dg-error "conversion" }
 std::set<int>::const_iterator cit = NULL; // { dg-error "conversion" }
index 36d8adde348ddfec978c7aaae1e95e3b95735a27..0b86efacb923e20ede1cc42b5539b056684aa4be 100644 (file)
@@ -1,6 +1,6 @@
 // 2001-04-30  Benjamin Kosnik  <bkoz@redhat.com>
 
-// Copyright (C) 2001, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -49,7 +49,7 @@ bool test02(void)
   *ostrb_it01;
   VERIFY( !ostrb_it01.failed() );
 
-  costreambuf_iter ostrb_it02(NULL);
+  costreambuf_iter ostrb_it02(0);
   VERIFY( ostrb_it02.failed() );
   ostrb_it02++;
   ++ostrb_it02;
index 6dc56f9b154d486ed6e665a273ec66661ca539c4..0a12e7224507aaf9d68768d3dd85b896a5c16aeb 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -61,19 +61,19 @@ void test_01()
   // filebuf_type* close()
   std::filebuf* f;
   f = fb_01.close();
-  VERIFY( f != NULL );
+  VERIFY( f );
   VERIFY( !fb_01.is_open() );
 
   f = fb_02.close();
-  VERIFY( f != NULL );
+  VERIFY( f );
   VERIFY( !fb_02.is_open() );
 
   f = fb_03.close();
-  VERIFY( f != NULL );
+  VERIFY( f );
   VERIFY( !fb_03.is_open() );
 
   f = fb_03.close();
-  VERIFY( f == NULL );
+  VERIFY( !f );
   VERIFY( !fb_03.is_open() );
 }
 
index 2074ee78a0bc7ce199035bc2c994fe0d93b0d6e8..fe0624d109e6d0ec0a94fc64428cf38228bfee13 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -71,7 +71,7 @@ void test01()
   VERIFY( !cvt->unshift_called );
   filebuf* ret = fb.close();
   VERIFY( cvt->unshift_called );
-  VERIFY( ret == NULL );
+  VERIFY( !ret );
 }
 
 int main()
index 9d0cb0f749932e7a3cb5f7faadd8c99047184b65..c1a0f79c8e26e7e539463a7cb19f432fa8fac3bb 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -48,7 +48,7 @@ void test_02()
 
   // read (ext)
   FILE* f2 = fopen(name_01, "r");
-  VERIFY( f2 != NULL );
+  VERIFY( f2 );
   if (f2)
   {
     __gnu_cxx::stdio_filebuf<char> fb(f2, std::ios_base::in, 512);
@@ -58,7 +58,7 @@ void test_02()
 
   // read (standard)
   FILE* f = fopen(name_01, "r");
-  VERIFY( f != NULL );
+  VERIFY( f );
   if (f)
   {
     std::ifstream ifstream1(name_01);
index e520682b1123553474466c3d2b54f2731fc7a36d..f2c5abc3eb3accaf9773724a5ecb943202586301 100644 (file)
@@ -1,7 +1,7 @@
 // { dg-require-fork "" }
 // { dg-require-mkfifo "" }
 
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -69,14 +69,14 @@ bool test_07()
   
   filebuf fb;
   filebuf* ret = fb.open(name, ios_base::in | ios_base::out);
-  VERIFY( ret != NULL );
+  VERIFY( ret != 0 );
   VERIFY( fb.is_open() );
   s1.signal();
   s2.wait();
   fb.sputc('a');
 
   ret = fb.close();
-  VERIFY( ret != NULL );
+  VERIFY( ret != 0 );
   VERIFY( !fb.is_open() );
 
   return test;
index baa4ed31eb885ee9a1af46a0d312c97260aa2790..417fbc2ce39af6f85f3b97268cf3558a193a5dd4 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -69,7 +69,7 @@ void test01()
   VERIFY( !cvt->unshift_called );
   wfilebuf* ret = fb.close();
   VERIFY( cvt->unshift_called );
-  VERIFY( ret == NULL );
+  VERIFY( !ret );
 }
 
 int main()
index a3a78120e7859e870921d2bd4b797251bcaa5905..b233f65637e26a522d1a088905dc4f110cb2243a 100644 (file)
@@ -4,7 +4,8 @@
 
 // 2004-04-16  Petur Runolfsson  <peturr02@ru.is>
 
-// Copyright (C) 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -68,7 +69,7 @@ bool test01()
   wfilebuf fb;
   fb.pubimbue(loc_us);
   wfilebuf* ret = fb.open(name, ios_base::out);
-  VERIFY( ret != NULL );
+  VERIFY( ret != 0 );
   VERIFY( fb.is_open() );
 
   s1.wait();
index e10bd9153f2dd0d317e5a456367320efd67f1535..1a40da155cf2a321a1495470fccbd0b358d1828a 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -53,11 +53,11 @@ void test_01()
   // Should keep the old file attached, and disregard attempt to overthrow.
   std::filebuf* f = fb_02.open(name_02, std::ios_base::in | std::ios_base::out 
                               | std::ios_base::trunc);
-  VERIFY( f != NULL );
+  VERIFY( f );
   VERIFY( fb_02.is_open() );
   
   f = fb_02.open(name_03, std::ios_base::in | std::ios_base::out);
-  VERIFY( f == NULL );
+  VERIFY( !f );
   VERIFY( fb_02.is_open() );
 
   fb_03.open(name_03, std::ios_base::out | std::ios_base::trunc);
index 1bd81ee14d915201273685beb4c0a3a71025e254..755784fb9ae7a04d90d296c0a26d1369863fe944 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -41,7 +41,7 @@ void test_03()
   int first_fd = ::open(name_01, O_RDONLY);
   VERIFY( first_fd != -1 );
   FILE* first_file = ::fdopen(first_fd, "r");
-  VERIFY( first_file != NULL );
+  VERIFY( first_file );
   __gnu_cxx::stdio_filebuf<char> fb(first_file, std::ios_base::in);
 
   int second_fd = fb.fd();
index cfec76b310b355d8599a3cc6ea39407ff0e00558..5b404375e63efaae635f95b03393ac9118f58886 100644 (file)
@@ -1,6 +1,7 @@
 // { dg-require-mkfifo "" }
 
-// Copyright (C) 2001, 2002, 2003, 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2005, 2009, 2010
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -55,7 +56,7 @@ void test_06()
                              std::ios_base::in 
                              | std::ios_base::out
                              | std::ios_base::ate);
-  if (r == NULL)
+  if (!r)
     VERIFY( !fbuf.is_open() );
   else
     VERIFY( fbuf.is_open() );
index db02187decee0b4c2c0f52d992b839dd7aeab702..d762fb48c2c6a243b36b9a5d13e616604188963b 100644 (file)
@@ -1,6 +1,6 @@
 // { dg-require-namedlocale "" }
 
-// Copyright (C) 2003, 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2003, 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -37,7 +37,7 @@ void test01()
   wfilebuf* f = fb.close();
   
   VERIFY( n1 != wfilebuf::traits_type::eof() );
-  VERIFY( f != NULL );
+  VERIFY( f );
 }
 
 int main()
index 9ea64cc3e932c311afe5f71ce314b42c2884cd03..f11916e6f77bbda006f972ad31ede57f2e19dcf8 100644 (file)
@@ -1,6 +1,6 @@
 // { dg-require-namedlocale "" }
 
-// Copyright (C) 2003, 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2003, 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -39,7 +39,7 @@ void test02()
   
   VERIFY( n1 != wfilebuf::traits_type::eof() );
   VERIFY( n2 != wfilebuf::traits_type::eof() );
-  VERIFY( f != NULL );
+  VERIFY( f );
 }
 
 int main()
index 2f10e0dec42aa497e61a479e7b88983a83712dcc..2be9b52cbd2d904eb0bb066fd67fb837003f7472 100644 (file)
@@ -1,6 +1,6 @@
 // { dg-require-namedlocale "" }
 
-// Copyright (C) 2003, 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2003, 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -36,7 +36,7 @@ void test03()
   wfilebuf* f = fb.close();
        
   VERIFY( n1 != wfilebuf::traits_type::eof() );
-  VERIFY( f != NULL );
+  VERIFY( f );
 }
 
 int main()
index a03d9e8d1abe074f0dfa91d27d7760acbe5e66f2..7b48bfe7bb90ef5ca127a631fcc78d07bc15e84d 100644 (file)
@@ -1,6 +1,6 @@
 // { dg-require-namedlocale "" }
 
-// Copyright (C) 2003, 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2003, 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -38,7 +38,7 @@ void test04()
   
   VERIFY( n1 != wfilebuf::traits_type::eof() );
   VERIFY( n2 != wfilebuf::traits_type::eof() );
-  VERIFY( f != NULL );
+  VERIFY( f );
 }
 
 int main()
index 3b434ba7a52040b51742420426ec5da1b6378175..42688e825e0e3859f6f624b5be78d7f41e0bdc6b 100644 (file)
@@ -1,6 +1,6 @@
 // 2001-05-21 Benjamin Kosnik  <bkoz@redhat.com>
 
-// Copyright (C) 2001, 2002, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -40,8 +40,8 @@ public:
   check_pointers()
   { 
     bool test __attribute__((unused)) = true;
-    test = (this->pbase() == NULL);
-    test &= (this->pptr() == NULL);
+    test = (!this->pbase());
+    test &= (!this->pptr());
     return test;
   }
 };
index 4fd2d47130ecc8374de8815c5c6070547e031f76..a2368f93203a388039e3fa3dd80476b6889659f8 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -32,7 +32,7 @@ public:
   nullsetpbuf()
   {
     setp(foo, foo + 64);
-    setp(NULL, NULL);
+    setp(0, 0);
   }
 };
 
index 89ec0e53d1fd68934aa935eafa438c539274ae2e..c84a079d298f43a883bb42744d07ec25a33f7cee 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -32,7 +32,7 @@ public:
   nullsetpbuf()
   {
     setp(foo, foo + 64);
-    setp(NULL, NULL);
+    setp(0, 0);
   }
 };
 
index 5ac2cc08ccbb734edaca63477a199407f166cde5..b65d0890064c9848c0b062f2692b19522596b302 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-09-20 bkoz
 
-// Copyright (C) 1999, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 1999, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -35,7 +35,7 @@ void test01()
 
   iostate iostate02, iostate03;
   const iostate iostate01 = std::ios_base::badbit | std::ios_base::eofbit;
-  std::ios ios_01(NULL);
+  std::ios ios_01(0);
 
   // bool fail() const
   VERIFY( ios_01.fail() );
index 9150d1126bdb48942a58bf0ed16b152ca1ff32f0..0cf07f212b8dec31e0a14fbfe7294f7bff318c59 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-09-20 bkoz
 
-// Copyright (C) 1999, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 1999, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -35,8 +35,8 @@ void test02()
 
   // basic_ios& copyfmt(const basic_ios& rhs)
   {
-    std::ios ios_01(NULL);
-    std::ios ios_02(NULL);  
+    std::ios ios_01(0);
+    std::ios ios_02(0);  
     ios_01.exceptions(std::ios_base::eofbit);
     ios_02.exceptions(std::ios_base::eofbit);
     
@@ -49,8 +49,8 @@ void test02()
   }
 
   {
-    std::ios ios_01(NULL);
-    std::ios ios_02(NULL);  
+    std::ios ios_01(0);
+    std::ios ios_02(0);  
     ios_01.clear(std::ios_base::eofbit);
     ios_02.exceptions(std::ios_base::eofbit);
 
index 0a171a6fc54aa27bcc8cd55d7913b7858205c825..79390eaca1cc11e2c709d0a74e3d722bb888dffb 100644 (file)
@@ -2,7 +2,7 @@
 
 // 1999-09-20 bkoz
 
-// Copyright (C) 1999, 2003, 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 1999, 2003, 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -37,8 +37,8 @@ void test03()
   typedef std::ios_base::iostate iostate;
   locale loc_c = locale::classic();
   locale loc_de = locale("de_DE");
-  std::ios ios_01(NULL);
-  std::ios ios_02(NULL);
+  std::ios ios_01(0);
+  std::ios ios_02(0);
   ios_01.imbue(loc_c);
   ios_02.imbue(loc_de);
   ios_02.setstate(ios_base::badbit);
index 03f70c894585759bf4c8dd0bf369b557d16c7b06..f0494bd458df61d3963830d853f1a5510f058982 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-09-20 bkoz
 
-// Copyright (C) 1999, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 1999, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -35,13 +35,13 @@ void test01()
   // iostate exceptions() const
   iostate iostate02;
   {
-    std::ios ios_01(NULL);
+    std::ios ios_01(0);
     VERIFY( ios_01.exceptions() == std::ios_base::goodbit );
   }
 
   // void exceptions(iostate except)
   {
-    std::ios ios_01(NULL);
+    std::ios ios_01(0);
     try {
       ios_01.exceptions(std::ios_base::eofbit);
     }           
@@ -53,7 +53,7 @@ void test01()
   }
 
   {
-    std::ios ios_01(NULL);
+    std::ios ios_01(0);
     ios_01.clear(std::ios_base::eofbit);
     try {
       ios_01.exceptions(std::ios_base::eofbit);
index 3d5bf772434f020a529a8bb410cd1468fd6760bd..20de8a95708aa9a5fb6ebc33759591101eebc4ee 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-09-20 bkoz
 
-// Copyright (C) 1999, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 1999, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -29,7 +29,7 @@ void test01()
   bool test __attribute__((unused)) = true;
   const std::locale c_loc = std::locale::classic();
 
-  std::ios ios_01(NULL);
+  std::ios ios_01(0);
   std::ios::char_type ct01;
   std::ios::char_type ct02('x');;
 
index 4aec0e3cad383dc9bda4c49b7272dd39e68c4ab5..44fe41323c70f0f50f952eaf93e3eb889b6206da 100644 (file)
@@ -1,7 +1,7 @@
 // 1999-01-17 bkoz test functionality of basic_filebuf for char_type == char
 
 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-// 2006, 2007, 2008, 2009
+// 2006, 2007, 2008, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -34,7 +34,7 @@ void test07()
 
   try
     { 
-      gnu_iostr obj(NULL); 
+      gnu_iostr obj(0); 
     }
   catch(std::exception& obj)
     { 
index 4162f9e68aa97418d11ad3f8415a62b18d940001..3b2cb845e08ea51d767adbddbf882de745836739 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-01-17 bkoz test functionality of basic_filebuf for char_type == char
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2009
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+// 2005, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -33,7 +34,7 @@ void test07()
   typedef std::basic_istream<__gnu_test::pod_ushort> gnu_istr;
 
   try
-    { gnu_istr obj(NULL); }
+    { gnu_istr obj(0); }
   catch(std::exception& obj)
     { 
       test = false; 
index 619751506ab499c07d87cc0d5dcda7675b0f67a9..9f1593eac99e267d75f9c64e612ae02a10d07958 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-04-12 bkoz
 
-// Copyright (C) 1999, 2000, 2002, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 1999, 2000, 2002, 2003, 2009, 2010
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -35,7 +36,7 @@ std::stringbuf isbuf_02(str_02, std::ios_base::in);
 std::stringbuf isbuf_03(str_03, std::ios_base::in);
 std::stringbuf isbuf_04(str_04, std::ios_base::in);
 
-std::istream is_01(NULL);
+std::istream is_01(0);
 std::istream is_02(&isbuf_02);
 std::istream is_03(&isbuf_03);
 std::istream is_04(&isbuf_04);
index f0d1635da1b6a5838bcce323154856418dcd9317..36ddabad065216f5ab4e6a53b09fc63ef1c54f76 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2004, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -33,7 +33,7 @@ std::wstringbuf isbuf_02(str_02, std::ios_base::in);
 std::wstringbuf isbuf_03(str_03, std::ios_base::in);
 std::wstringbuf isbuf_04(str_04, std::ios_base::in);
 
-std::wistream is_01(NULL);
+std::wistream is_01(0);
 std::wistream is_02(&isbuf_02);
 std::wistream is_03(&isbuf_03);
 std::wistream is_04(&isbuf_04);
index c6fba2f2001b185b70c8eb8673686581f9b971bd..7e4387d315d0a583decf340e3e176c90cda7927d 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-07-26 bkoz
 
-// Copyright (C) 1999, 2003, 2005, 2009 Free Software Foundation
+// Copyright (C) 1999, 2003, 2005, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -32,7 +32,7 @@ void test01()
 
   std::stringbuf isbuf_01(std::ios_base::in);
   std::stringbuf isbuf_02(str_02, std::ios_base::in);
-  std::istream is_01(NULL);
+  std::istream is_01(0);
   std::istream is_02(&isbuf_02);
 
   std::ios_base::iostate state1, state2, statefail;
index edff030719464c389188570664597c4cc8021fe6..812d5413412c0a608435c5294d898fe04b882e0f 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-07-26 bkoz
 
-// Copyright (C) 1999, 2003, 2009 Free Software Foundation
+// Copyright (C) 1999, 2003, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -34,7 +34,7 @@ void test02()
 
   std::stringbuf isbuf_01(std::ios_base::in);
   std::stringbuf isbuf_02(str_02, std::ios_base::in);
-  std::istream is_01(NULL);
+  std::istream is_01(0);
   std::istream is_02(&isbuf_02);
   std::ios_base::iostate state1, state2, statefail;
   statefail = std::ios_base::failbit;
index cfaf5b11b6163082fe34b5bca94780789e54d6c2..551cb111a490b9fe903216cf90afa87fb4e50109 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-07-26 bkoz
 
-// Copyright (C) 1999, 2003, 2009 Free Software Foundation
+// Copyright (C) 1999, 2003, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -32,7 +32,7 @@ void test01()
 
   std::stringbuf isbuf_01(std::ios_base::in);
   std::stringbuf isbuf_02(str_02, std::ios_base::in);
-  std::istream is_01(NULL);
+  std::istream is_01(0);
   std::istream is_02(&isbuf_02);
 
   std::ios_base::iostate state1, state2, statefail;
index 224d0565f3a3487a355636ec33150157ebfe7f03..a2e480ebce64cdb142f031e272473c1045dc718b 100644 (file)
@@ -1,6 +1,6 @@
 // 2002-07-25 Benjamin Kosnik <bkoz@redhat.com>
 
-// Copyright (C) 2002, 2003, 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2002, 2003, 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -39,7 +39,7 @@ void test02()
   sstr >> str;
 
   // 2
-  pod_char*  chr = NULL;
+  pod_char*  chr = 0;
   sstr >> chr;
 
   // 3
index 2b428037f6b3b5553529093ae5bf666e5b399507..f7b749a5df057cf0074c60ec76aee9b57e0fb54b 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2005, 2009 Free Software Foundation
+// Copyright (C) 2004, 2005, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -30,7 +30,7 @@ void test01()
 
   std::wstringbuf isbuf_01(std::ios_base::in);
   std::wstringbuf isbuf_02(str_02, std::ios_base::in);
-  std::wistream is_01(NULL);
+  std::wistream is_01(0);
   std::wistream is_02(&isbuf_02);
 
   std::ios_base::iostate state1, state2, statefail;
index a6841198d832f5c7380754b6d2184f427d9bffbc..a697ef2b256db714a10866e669a2b21122f9a1c1 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2009 Free Software Foundation
+// Copyright (C) 2004, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -30,7 +30,7 @@ void test02()
 
   std::wstringbuf isbuf_01(std::ios_base::in);
   std::wstringbuf isbuf_02(str_02, std::ios_base::in);
-  std::wistream is_01(NULL);
+  std::wistream is_01(0);
   std::wistream is_02(&isbuf_02);
   std::ios_base::iostate state1, state2, statefail;
   statefail = std::ios_base::failbit;
index 3ba355d6452ae5bd7a8bb22d83342290ba3f7235..6ea22e395debfcc713339856d3f334ca4f472a48 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2009 Free Software Foundation
+// Copyright (C) 2004, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -30,7 +30,7 @@ void test01()
 
   std::wstringbuf isbuf_01(std::ios_base::in);
   std::wstringbuf isbuf_02(str_02, std::ios_base::in);
-  std::wistream is_01(NULL);
+  std::wistream is_01(0);
   std::wistream is_02(&isbuf_02);
 
   std::ios_base::iostate state1, state2, statefail;
index ecc50826f9e94420d0975aef9912a458faf5e46d..854dc7c856586d374a53ac3bfc6be66bc16c2fe5 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-07-28 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+// 2009, 2010
 // Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -41,7 +42,7 @@ void test01()
   std::stringbuf isbuf_04(str_02, std::ios_base::in);
   std::stringbuf isbuf_05(str_02, std::ios_base::in | std::ios_base::out);
 
-  std::istream is_00(NULL);
+  std::istream is_00(0);
   std::istream is_01(&isbuf_01);
   std::istream is_02(&isbuf_02);
   std::istream is_03(&isbuf_03);
index beab22c0a2124fb0f8756ba03673681b18971e75..96ba7193021bb029be6aef951ce80414352eb53d 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -28,7 +28,7 @@ void test2()
 {
   bool test __attribute__((unused)) = true;
   istringstream stream;
-  stream >> static_cast<streambuf*>(NULL);
+  stream >> static_cast<streambuf*>(0);
   VERIFY(stream.rdstate() & ios_base::failbit);
 }
 
@@ -40,7 +40,7 @@ void test4()
 
   try
     {
-      stream >> static_cast<streambuf*>(NULL);
+      stream >> static_cast<streambuf*>(0);
       VERIFY(false);
     }
   catch (ios_base::failure&)
index 809c0083502650c0ec43b06d248a506d37636bc9..eab6650b1acfaf75c222f0a94af7b7c653e0043b 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2005, 2006, 2009 Free Software Foundation
+// Copyright (C) 2004, 2005, 2006, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -38,7 +38,7 @@ void test01()
   std::wstringbuf isbuf_04(str_02, std::ios_base::in);
   std::wstringbuf isbuf_05(str_02, std::ios_base::in | std::ios_base::out);
 
-  std::wistream is_00(NULL);
+  std::wistream is_00(0);
   std::wistream is_01(&isbuf_01);
   std::wistream is_02(&isbuf_02);
   std::wistream is_03(&isbuf_03);
index eddef0ae43e538f1d6985dcf252fb31ab064f63d..bc04b7d9b22a9795a225555a0763ae47df019c0c 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2004, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -28,7 +28,7 @@ void test2()
 {
   bool test __attribute__((unused)) = true;
   wistringstream stream;
-  stream >> static_cast<wstreambuf*>(NULL);
+  stream >> static_cast<wstreambuf*>(0);
   VERIFY( stream.rdstate() & ios_base::failbit );
 }
 
@@ -40,7 +40,7 @@ void test4()
 
   try
     {
-      stream >> static_cast<wstreambuf*>(NULL);
+      stream >> static_cast<wstreambuf*>(0);
       VERIFY( false );
     }
   catch (ios_base::failure&)
index 19169d979347749ad48246e3460ced21a44f6b9b..f7957d8a51c5ff4e9ad82b41c1190bdfb1d8d871 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-08-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009 Free Software Foundation
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
+// Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -41,7 +42,7 @@ test03()
   std::stringbuf sbuf_04(str01, std::ios_base::in);
   std::stringbuf sbuf_05(str01, std::ios_base::in);
 
-  std::istream is_00(NULL);
+  std::istream is_00(0);
   std::istream is_04(&sbuf_04);
   std::istream is_05(&sbuf_05);
   std::ios_base::iostate statefail, stateeof;
index 7168aefcdbb64e7b866c4e93fbd6f944a48142a1..b3027c3af95465ae9fa3bcd312e5ae764cc26875 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2009 Free Software Foundation
+// Copyright (C) 2004, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -39,7 +39,7 @@ test03()
   std::wstringbuf sbuf_04(str01, std::ios_base::in);
   std::wstringbuf sbuf_05(str01, std::ios_base::in);
 
-  std::wistream is_00(NULL);
+  std::wistream is_00(0);
   std::wistream is_04(&sbuf_04);
   std::wistream is_05(&sbuf_05);
   std::ios_base::iostate statefail, stateeof;
index 67b1955fcd675daf8563722e78004f240352e1cf..48b245f9b96622ebe0dc81b8a9735a7328b050cf 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-08-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009 Free Software Foundation
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
+// Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -41,7 +42,7 @@ test02()
 
   std::stringbuf sbuf_04(str01, std::ios_base::in);
 
-  std::istream is_00(NULL);
+  std::istream is_00(0);
   std::istream is_04(&sbuf_04);
   std::ios_base::iostate state1, state2, statefail, stateeof;
   statefail = std::ios_base::failbit;
@@ -54,7 +55,7 @@ test02()
   is_00.getline(carray1, 20, '*');
   state2 = is_00.rdstate();
   // make sure failbit was set, since we couldn't extract
-  // from the NULL streambuf...
+  // from the null streambuf...
   VERIFY( state1 != state2 );
   VERIFY( static_cast<bool>(state2 & statefail) );
   
index 49305a33171aecbd36b5d90166422009f784199d..2445dd4f7494d654c95fe2a353761c2f6ade0ced 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2009 Free Software Foundation
+// Copyright (C) 2004, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -39,7 +39,7 @@ test02()
 
   std::wstringbuf sbuf_04(str01, std::ios_base::in);
 
-  std::wistream is_00(NULL);
+  std::wistream is_00(0);
   std::wistream is_04(&sbuf_04);
   std::ios_base::iostate state1, state2, statefail, stateeof;
   statefail = std::ios_base::failbit;
@@ -52,7 +52,7 @@ test02()
   is_00.getline(carray1, 20, L'*');
   state2 = is_00.rdstate();
   // make sure failbit was set, since we couldn't extract
-  // from the NULL streambuf...
+  // from the null streambuf...
   VERIFY( state1 != state2 );
   VERIFY( static_cast<bool>(state2 & statefail) );
   
index e70c1ab5fb2347f2d0876019e34506c1773537fe..de0546c321dea502820bd52be3746ea020ec7947 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-08-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009 Free Software Foundation
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
+// Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -36,7 +37,7 @@ test01()
   std::stringbuf isbuf_03(str_02, std::ios_base::in);
   std::stringbuf isbuf_04(str_02, std::ios_base::in);
 
-  std::istream is_00(NULL);
+  std::istream is_00(0);
   std::istream is_03(&isbuf_03);
   std::istream is_04(&isbuf_04);
   std::ios_base::iostate state1, state2, statefail, stateeof;
index 6254428d36835118db53ea5096c527af7da94db1..57c827dd65bd7b1e209ce940d19b26260a3c1bd7 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2009 Free Software Foundation
+// Copyright (C) 2004, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -34,7 +34,7 @@ test01()
   std::wstringbuf isbuf_03(str_02, std::ios_base::in);
   std::wstringbuf isbuf_04(str_02, std::ios_base::in);
 
-  std::wistream is_00(NULL);
+  std::wistream is_00(0);
   std::wistream is_03(&isbuf_03);
   std::wistream is_04(&isbuf_04);
   std::ios_base::iostate state1, state2, statefail, stateeof;
index 6d501646ad60b5609c33f3e8a102ec7e92761a1a..4b818b299ca495435b2410e046f5bf4c31d55936 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-08-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009 Free Software Foundation
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
+// Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -36,7 +37,7 @@ test01()
   std::stringbuf isbuf_03(str_02, std::ios_base::in);
   std::stringbuf isbuf_04(str_02, std::ios_base::in);
 
-  std::istream is_00(NULL);
+  std::istream is_00(0);
   std::istream is_03(&isbuf_03);
   std::istream is_04(&isbuf_04);
   std::ios_base::iostate state1, state2, statefail, stateeof;
index b4c0e32c46f242e4148d70eaaf719f1ea738c343..8aa4ecf4ef58424405345ee256513ece25cd0993 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2009 Free Software Foundation
+// Copyright (C) 2004, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -34,7 +34,7 @@ test01()
   std::wstringbuf isbuf_03(str_02, std::ios_base::in);
   std::wstringbuf isbuf_04(str_02, std::ios_base::in);
 
-  std::wistream is_00(NULL);
+  std::wistream is_00(0);
   std::wistream is_03(&isbuf_03);
   std::wistream is_04(&isbuf_04);
   std::ios_base::iostate state1, state2, statefail, stateeof;
index b9ebe7dfe9af48cb22b5f6002067c7e6ffa4a8bb..3879f7b422d682d724bfa5ec156c4bb77c42b129 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-08-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009, 2010
 // Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -34,7 +34,7 @@ test01()
   std::stringbuf isbuf_03(str_02, std::ios_base::in);
   std::stringbuf isbuf_04(str_02, std::ios_base::in);
 
-  std::istream is_00(NULL);
+  std::istream is_00(0);
   std::istream is_03(&isbuf_03);
   std::istream is_04(&isbuf_04);
   std::ios_base::iostate state1, state2, statefail, stateeof;
index 1485aa1abf080eceb590e44fe52123470d9980d5..508e0c8cb4dc7d6ae43ef8497c3db37a7b94bf6b 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2004, 2009 Free Software Foundation
+// Copyright (C) 2004, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,7 +31,7 @@ test01()
   std::wstringbuf isbuf_03(str_02, std::ios_base::in);
   std::wstringbuf isbuf_04(str_02, std::ios_base::in);
 
-  std::wistream is_00(NULL);
+  std::wistream is_00(0);
   std::wistream is_03(&isbuf_03);
   std::wistream is_04(&isbuf_04);
   std::ios_base::iostate state1, state2, statefail, stateeof;
index 04df562ffdaacabd28829b29b90168135ae9ebf0..cb683666cccfd2fed81bf3b84b7e5b5e294f1fac 100644 (file)
@@ -1,7 +1,7 @@
 // 2002-01-23  Loren J. Rittle <rittle@labs.mot.com> <ljrittle@acm.org>
 // Adpated from libstdc++/5347 submitted by markus.breuer@materna.de
 //
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -51,10 +51,10 @@ main()
 #endif
 
   for (int i = 0; i < max_thread_count; i++)
-    pthread_create (&tid[i], NULL, thread_main, 0);
+    pthread_create (&tid[i], 0, thread_main, 0);
 
   for (int i = 0; i < max_thread_count; i++)
-    pthread_join (tid[i], NULL);
+    pthread_join (tid[i], 0);
 
   return 0;
 }
index 125440b0b20f627e8b200b3d8c8de3b8ac86e461..07fb7b82eb2e7414609b9584cc7be6282eef5043 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-01-17 bkoz test functionality of basic_filebuf for char_type == char
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2009
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -34,7 +35,7 @@ void test07()
 
   try
     { 
-      gnu_ostr obj(NULL); 
+      gnu_ostr obj(0); 
     }
   catch(std::exception& obj)
     { 
index 85af3666a3b8fc2c6ab1966ea778afdf6e0dcfe2..f38e2e703dbdb0d6f2ec9f161d452edd605528b3 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-08-16 bkoz
 
-// Copyright (C) 1999, 2000, 2002, 2003, 2009 Free Software Foundation
+// Copyright (C) 1999, 2000, 2002, 2003, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -27,7 +27,7 @@
 void test08()
 {
   bool test __attribute__((unused)) = true;
-  char* pt = NULL;
+  char* pt = 0;
 
   // 1
   std::ostringstream oss;
index a414076b20a2bbdabd38362822fc4d9c3c25bdc0..76490b3c590a06d7a0bbe25fd73a86ce2f9b5a44 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-08-16 bkoz
 
-// Copyright (C) 1999, 2000, 2002, 2003, 2009 Free Software Foundation
+// Copyright (C) 1999, 2000, 2002, 2003, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -27,7 +27,7 @@
 void test08()
 {
   bool test __attribute__((unused)) = true;
-  char* pt = NULL;
+  char* pt = 0;
 
   // 2
   std::wostringstream woss;
@@ -40,7 +40,7 @@ void test08()
   VERIFY( woss.good() );
 
   // 3
-  wchar_t* wt = NULL;
+  wchar_t* wt = 0;
   woss.clear();
   woss << wt;
   VERIFY( woss.bad() );
index c53c160f736d591b85b5a4a12930f5285c59cd6a..0c94c68156f406526310dda97c7e233de418babc 100644 (file)
@@ -1,7 +1,8 @@
 // 1999-08-16 bkoz
 // 1999-11-01 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009 Free Software Foundation
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
+// Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -46,7 +47,7 @@ test02()
   // filebuf-> NULL 
   std::ifstream f_in1(name_01);
   std::ofstream f_out1(name_02);
-  std::stringbuf* strbuf01 = NULL;
+  std::stringbuf* strbuf01 = 0;
   iostate state01 = f_in1.rdstate();
   f_in1 >> strbuf01;
   iostate state02 = f_in1.rdstate();
index 3e5dddc16e405245d07e14b18b7009a22de3c4a6..6d28c5f04594aea3998f370bc8af09715c8ae58f 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2003, 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2003, 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -28,7 +28,7 @@ void test1()
   bool test __attribute__((unused)) = true;
 
   ostringstream stream;
-  stream << static_cast<streambuf*>(NULL);
+  stream << static_cast<streambuf*>(0);
   VERIFY( stream.rdstate() & ios_base::badbit );
 }
 
@@ -42,7 +42,7 @@ void test3()
        
   try
     {
-      stream << static_cast<streambuf*>(NULL);
+      stream << static_cast<streambuf*>(0);
       VERIFY( false );
     }
   catch (ios_base::failure&)
index bde6ba5985c72806b7a2ad839be9f23cae99262f..6e12a65bfbe91e4cffc2aee271adaf9abb47cf0e 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2005, 2009 Free Software Foundation
+// Copyright (C) 2005, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -41,7 +41,7 @@ test02()
   // filebuf-> NULL 
   std::wifstream f_in1(name_01);
   std::wofstream f_out1(name_02);
-  std::wstringbuf* strbuf01 = NULL;
+  std::wstringbuf* strbuf01 = 0;
   iostate state01 = f_in1.rdstate();
   f_in1 >> strbuf01;
   iostate state02 = f_in1.rdstate();
index 7e5cd6ddb65078c90d0eb9fdf794e24e02efade3..076aece647586fec332d3992da26de17e0f7eeb9 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -28,7 +28,7 @@ void test1()
   bool test __attribute__((unused)) = true;
 
   wostringstream stream;
-  stream << static_cast<wstreambuf*>(NULL);
+  stream << static_cast<wstreambuf*>(0);
   VERIFY( stream.rdstate() & ios_base::badbit );
 }
 
@@ -42,7 +42,7 @@ void test3()
        
   try
     {
-      stream << static_cast<wstreambuf*>(NULL);
+      stream << static_cast<wstreambuf*>(0);
       VERIFY( false );
     }
   catch (ios_base::failure&)
index 8a4088c95ba59174a098481f33b5098966deeffd..00becef2587ccfac4b462f65a41d9d9a8e649a57 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-10-14 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+// 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,7 +41,7 @@ void test01()
 
 
   const string_type str01;
-  stringbuf_type* strbuf01 = NULL;
+  stringbuf_type* strbuf01 = 0;
   stringbuf_type strbuf02(str01);
   ostream_type ostr01(strbuf01);
   ostream_type ostr02(&strbuf02);
index 81a8c96652d3af20cd1de72febe75593c6d7dea1..5b87d84c0228addabc5d6351a52a957ea5f62e1a 100644 (file)
@@ -1,7 +1,7 @@
 // 2002-01-23  Loren J. Rittle <rittle@labs.mot.com> <ljrittle@acm.org>
 // Adpated from libstdc++/5347 submitted by markus.breuer@materna.de
 //
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -48,10 +48,10 @@ main()
 #endif
 
   for (int i = 0; i < max_thread_count; i++)
-    pthread_create (&tid[i], NULL, thread_main, 0);
+    pthread_create (&tid[i], 0, thread_main, 0);
 
   for (int i = 0; i < max_thread_count; i++)
-    pthread_join (tid[i], NULL);
+    pthread_join (tid[i], 0);
 
   return 0;
 }
index 918726c87787ff8087e018029282b00d67d5caf4..65aff09ec2770793da04e2848fbe8f308224dc08 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+// 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,12 +41,12 @@ public:
   check_pointers()
   { 
     bool test __attribute__((unused)) = true;
-    VERIFY( this->eback() == NULL );
-    VERIFY( this->gptr() == NULL );
-    VERIFY( this->egptr() == NULL );
-    VERIFY( this->pbase() == NULL );
-    VERIFY( this->pptr() == NULL );
-    VERIFY( this->epptr() == NULL );
+    VERIFY( !this->eback() );
+    VERIFY( !this->gptr() );
+    VERIFY( !this->egptr() );
+    VERIFY( !this->pbase() );
+    VERIFY( !this->pptr() );
+    VERIFY( !this->epptr() );
     return test;
   }
 
index 384ea29afb09495849025fffc5c308ff06c56a83..30b67e4e6d16d1fcc5b65634d8320430a6869dc1 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,12 +40,12 @@ public:
   check_pointers()
   { 
     bool test __attribute__((unused)) = true;
-    VERIFY( this->eback() == NULL );
-    VERIFY( this->gptr() == NULL );
-    VERIFY( this->egptr() == NULL );
-    VERIFY( this->pbase() == NULL );
-    VERIFY( this->pptr() == NULL );
-    VERIFY( this->epptr() == NULL );
+    VERIFY( !this->eback() );
+    VERIFY( !this->gptr() );
+    VERIFY( !this->egptr() );
+    VERIFY( !this->pbase() );
+    VERIFY( !this->pptr() );
+    VERIFY( !this->epptr() );
     return test;
   }
 
index 37d729c92ad14f3454eee1e95210376a2a9f189b..cbf17820f388ea87ea14c56591b0590932f436bf 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+// 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,12 +41,12 @@ public:
   check_pointers()
   { 
     bool test __attribute__((unused)) = true;
-    VERIFY( this->eback() == NULL );
-    VERIFY( this->gptr() == NULL );
-    VERIFY( this->egptr() == NULL );
-    VERIFY( this->pbase() == NULL );
-    VERIFY( this->pptr() == NULL );
-    VERIFY( this->epptr() == NULL );
+    VERIFY( !this->eback() );
+    VERIFY( !this->gptr() );
+    VERIFY( !this->egptr() );
+    VERIFY( !this->pbase() );
+    VERIFY( !this->pptr() );
+    VERIFY( !this->epptr() );
     return test;
   }
 
index 16df0994dde6c079af89da5964cd745f1dfe7195..0c5c63f337d26d663425ad31a3d76ddc9362a1cb 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,12 +40,12 @@ public:
   check_pointers()
   { 
     bool test __attribute__((unused)) = true;
-    VERIFY( this->eback() == NULL );
-    VERIFY( this->gptr() == NULL );
-    VERIFY( this->egptr() == NULL );
-    VERIFY( this->pbase() == NULL );
-    VERIFY( this->pptr() == NULL );
-    VERIFY( this->epptr() == NULL );
+    VERIFY( !this->eback() );
+    VERIFY( !this->gptr() );
+    VERIFY( !this->egptr() );
+    VERIFY( !this->pbase() );
+    VERIFY( !this->pptr() );
+    VERIFY( !this->epptr() );
     return test;
   }
 
index be6145c6e6afe6925d3c0ca9b395eae16d3aebdf..d1530b18f3fbca464979cd80034cc4f9ebe222d9 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+// 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,12 +41,12 @@ public:
   check_pointers()
   { 
     bool test __attribute__((unused)) = true;
-    VERIFY( this->eback() == NULL );
-    VERIFY( this->gptr() == NULL );
-    VERIFY( this->egptr() == NULL );
-    VERIFY( this->pbase() == NULL );
-    VERIFY( this->pptr() == NULL );
-    VERIFY( this->epptr() == NULL );
+    VERIFY( !this->eback() );
+    VERIFY( !this->gptr() );
+    VERIFY( !this->egptr() );
+    VERIFY( !this->pbase() );
+    VERIFY( !this->pptr() );
+    VERIFY( !this->epptr() );
     return test;
   }
 
index 948865c5a645b5433044335e570ba6ba82f73519..66b4af5d3e663de47d03163d7d2e6080a994af86 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,12 +40,12 @@ public:
   check_pointers()
   { 
     bool test __attribute__((unused)) = true;
-    VERIFY( this->eback() == NULL );
-    VERIFY( this->gptr() == NULL );
-    VERIFY( this->egptr() == NULL );
-    VERIFY( this->pbase() == NULL );
-    VERIFY( this->pptr() == NULL );
-    VERIFY( this->epptr() == NULL );
+    VERIFY( !this->eback() );
+    VERIFY( !this->gptr() );
+    VERIFY( !this->egptr() );
+    VERIFY( !this->pbase() );
+    VERIFY( !this->pptr() );
+    VERIFY( !this->epptr() );
     return test;
   }
 
index 11cda23da15908887e598af0f147aeff77e4102c..440d82b5abe747e496e0315c36f6eb3c26e7fcd8 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -32,7 +32,7 @@ public:
   nullsetpbuf()
   {
     setp(foo, foo + 64);
-    setp(NULL, NULL);
+    setp(0, 0);
   }
 };
 
index d04be240824add35a24883188a21df6c489818d7..5e7166fdd3d71b96c3c6ec4423cbaf4edc4cfc3d 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -32,7 +32,7 @@ public:
   nullsetpbuf()
   {
     setp(foo, foo + 64);
-    setp(NULL, NULL);
+    setp(0, 0);
   }
 };
 
index 0fe945eec613db36088a571a63f94421d93a0eb3..2874b0eea4eb33202454df40cf0062e5b7b5899b 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+// 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,12 +41,12 @@ public:
   check_pointers()
   { 
     bool test __attribute__((unused)) = true;
-    VERIFY( this->eback() == NULL );
-    VERIFY( this->gptr() == NULL );
-    VERIFY( this->egptr() == NULL );
-    VERIFY( this->pbase() == NULL );
-    VERIFY( this->pptr() == NULL );
-    VERIFY( this->epptr() == NULL );
+    VERIFY( !this->eback() );
+    VERIFY( !this->gptr() );
+    VERIFY( !this->egptr() );
+    VERIFY( !this->pbase() );
+    VERIFY( !this->pptr() );
+    VERIFY( !this->epptr() );
     return test;
   }
 
index 227a1c7a54a2b53f9a8dc689af22f6c315331a99..dda78bde45717bcf0c420fe028ae3a1f091f984a 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -32,7 +32,7 @@ public:
   nullsetpbuf()
   {
     setp(foo, foo + 64);
-    setp(NULL, NULL);
+    setp(0, 0);
   }
 };
 
index b03ab1729270e76d5364c7a84aa432d9ff8c2b32..09b263b6c7b9a13ce8608d5298d55472358e376e 100644 (file)
@@ -1,6 +1,7 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+// 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -41,12 +42,12 @@ public:
   check_pointers()
   { 
     bool test __attribute__((unused)) = true;
-    VERIFY( this->eback() == NULL );
-    VERIFY( this->gptr() == NULL );
-    VERIFY( this->egptr() == NULL );
-    VERIFY( this->pbase() == NULL );
-    VERIFY( this->pptr() == NULL );
-    VERIFY( this->epptr() == NULL );
+    VERIFY( !this->eback() );
+    VERIFY( !this->gptr() );
+    VERIFY( !this->egptr() );
+    VERIFY( !this->pbase() );
+    VERIFY( !this->pptr() );
+    VERIFY( !this->epptr() );
     return test;
   }
 
index b40e24ce8a30fcb251b684ac10805dd19ac9677c..9b148bab93f34e92a035f775f00b6be2a092d0c4 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -32,7 +32,7 @@ public:
   nullsetpbuf()
   {
     setp(foo, foo + 64);
-    setp(NULL, NULL);
+    setp(0, 0);
   }
 };
 
index 06957dd19265de5aec0f494bcf3371288565c7d9..f88f28e39a1cf13e600af3c04be7f6490031b4b8 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -32,7 +32,7 @@ public:
   nullsetpbuf()
   {
     setp(foo, foo + 64);
-    setp(NULL, NULL);
+    setp(0, 0);
   }
 };
 
index 4b4216b883dfb0faa161d5acf5b4205f251c3878..ae07ebf30ed8dd74c16e0c272b47234279c0c4ae 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -32,7 +32,7 @@ public:
   nullsetpbuf()
   {
     setp(foo, foo + 64);
-    setp(NULL, NULL);
+    setp(0, 0);
   }
 };
 
index c05d289846d6974fed8b8bb0ad4943028b95c8ce..c51f47a8d3406bbf16492d9704366df0a0b9b6b8 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -32,7 +32,7 @@ public:
   nullsetpbuf()
   {
     setp(foo, foo + 64);
-    setp(NULL, NULL);
+    setp(0, 0);
   }
 };
 
index 33d1ad79afeaaea4b771b4745cb9e3d7eea4febd..99f7a550993cae3b10dd1ae0dbe3db83fcbefdb6 100644 (file)
@@ -1,6 +1,6 @@
 // 1999-10-11 bkoz
 
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -32,7 +32,7 @@ public:
   nullsetpbuf()
   {
     setp(foo, foo + 64);
-    setp(NULL, NULL);
+    setp(0, 0);
   }
 };
 
index a744e787ac6d930ab242a6200edb603aa1c9b29a..eebebc20e3023dd2f250a012f11cdc9271ef7c3d 100644 (file)
@@ -1,6 +1,6 @@
 // 2003-05-01  Petur Runolfsson  <peturr02@ru.is>
 
-// Copyright (C) 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -32,7 +32,7 @@ void test10()
   const char* name = "filebuf_virtuals-1.txt";
 
   FILE* ret = freopen(name, "r", stdin);
-  VERIFY( ret != NULL );
+  VERIFY( ret );
 
   streampos p1 = cin.tellg();
   VERIFY( p1 != streampos(-1) );
index 44f569c85e682f86ce6d5ca02b2c099f11decbb1..b7c0ac1df3da168b6be08050acfbccfa3a32a928 100644 (file)
@@ -1,6 +1,6 @@
 // 2001-06-05 Benjamin Kosnik  <bkoz@redhat.com>
 
-// Copyright (C) 2001, 2002, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -27,7 +27,7 @@ void test04()
   std::stringbuf b1;
   std::cout.rdbuf( &b1 );
   std::cout << "hello\n";
-  std::cout.rdbuf(NULL);
+  std::cout.rdbuf(0);
 }
 
 int main()
index 59b8f4d09c53ba730665c9dfdc75694c64dd7043..1ad194cd81fcb9f1c606876754ed1cf3a8d58edf 100644 (file)
@@ -3,7 +3,7 @@
 
 // 2003-04-30  Petur Runolfsson <peturr02@ru.is>
 
-// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -58,7 +58,7 @@ bool test01()
   if (child == 0)
     {
       FILE* file = fopen(name, "r+");
-      VERIFY( file != NULL );
+      VERIFY( file != 0 );
       fputs("Whatever\n", file);
       fflush(file);
       s1.signal();
index 918d4c5d7d6d7606d464809ca854a3373c3b1693..04571cc63edaf06ebd82083e2ed67d788906a805 100644 (file)
@@ -1,6 +1,6 @@
 // 2003-05-01 Petur Runolfsson  <peturr02@ru.is>
 
-// Copyright (C) 2001, 2002, 2003, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -27,7 +27,7 @@ void test04()
   std::wstringbuf b1;
   std::wcout.rdbuf( &b1 );
   std::wcout << L"hello\n";
-  std::wcout.rdbuf(NULL);
+  std::wcout.rdbuf(0);
 }
 
 int main()
index fa35b9cb20801cfd9270fc1c0987a7a2768fd6cb..ae2b76f248bfc7c4effcfeda34f452f4d55bf49d 100644 (file)
@@ -1,7 +1,7 @@
 // { dg-options "-std=gnu++0x" }
 // { dg-do compile }
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -19,6 +19,7 @@
 // <http://www.gnu.org/licenses/>.
 
 #include <atomic>
+#include <cstddef>
 
 int main()
 {
index 7a2e94977a7c9c46a53fea12e6ed4909c372fed3..b7e524a38f596874603f980b0f3ffbe4a8df3884 100644 (file)
@@ -1,6 +1,6 @@
 // { dg-options "-std=gnu++0x" }
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -22,7 +22,7 @@
 int main()
 {
   // Single value constructor.
-  void* v = NULL;
+  void* v = 0;
   std::atomic_address a(v);
   return 0;
 }
index 078cffceab8d00393813db8b0caa08e9a6519890..7e9d30b4f23b455c415717c4940b9ced9d909d3e 100644 (file)
@@ -3,7 +3,7 @@
 // { dg-require-cstdint "" }
 // { dg-require-gthreads "" }
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -33,4 +33,4 @@ void test01()
 }
 
 // { dg-error "used here" "" { target *-*-* } 32 }
-// { dg-error "deleted function" "" { target *-*-* } 83 }
+// { dg-error "deleted function" "" { target *-*-* } 82 }
index e13a0f6cfba0e1b31ecaab67753ad144acb285c1..c1ef0511b8dcedf79e27e7442aac60a45cfd8b3e 100644 (file)
@@ -3,7 +3,7 @@
 // { dg-require-cstdint "" }
 // { dg-require-gthreads "" }
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -32,4 +32,4 @@ void test01()
 }
 
 // { dg-error "used here" "" { target *-*-* } 31 }
-// { dg-error "deleted function" "" { target *-*-* } 82 }
+// { dg-error "deleted function" "" { target *-*-* } 81 }
index 6c6cefa177aad0ddf67b38413d730d7a2ceac936..42af43939d5503fd55cd607955baf34d5f5e39e8 100644 (file)
@@ -3,7 +3,7 @@
 // { dg-require-cstdint "" }
 // { dg-require-gthreads "" }
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -33,4 +33,4 @@ void test01()
 }
 
 // { dg-error "used here" "" { target *-*-* } 32 } 
-// { dg-error "deleted function" "" { target *-*-* } 135 }
+// { dg-error "deleted function" "" { target *-*-* } 134 }
index b62011b8b566dd5e672dcdcfad7eeb4c93d4f42e..53ff57deab8e9dee111656bc47f1203cc0a784e8 100644 (file)
@@ -3,7 +3,7 @@
 // { dg-require-cstdint "" }
 // { dg-require-gthreads "" }
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -32,4 +32,4 @@ void test01()
 }
 
 // { dg-error "used here" "" { target *-*-* } 31 } 
-// { dg-error "deleted function" "" { target *-*-* } 134 }
+// { dg-error "deleted function" "" { target *-*-* } 133 }
index 2e092bedd119e79486a6d7107df3ec10dd4e3f76..7fa642858824cebf789d46fc47f33c7da8799af6 100644 (file)
@@ -3,7 +3,7 @@
 // { dg-require-cstdint "" }
 // { dg-require-gthreads "" }
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -33,4 +33,4 @@ void test01()
 }
 
 // { dg-error "used here" "" { target *-*-* } 32 } 
-// { dg-error "deleted function" "" { target *-*-* } 298 }
+// { dg-error "deleted function" "" { target *-*-* } 297 }
index 9d10a7dac551e2eb7c676e92ab7cc5bc18d6af1a..df1ca0bc9240659c96a9d7e3b1a32885963ced3b 100644 (file)
@@ -3,7 +3,7 @@
 // { dg-require-cstdint "" }
 // { dg-require-gthreads "" }
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -32,4 +32,4 @@ void test01()
 }
 
 // { dg-error "used here" "" { target *-*-* } 31 } 
-// { dg-error "deleted function" "" { target *-*-* } 297 }
+// { dg-error "deleted function" "" { target *-*-* } 296 }
index f45b9f203aec45f3c9357a4a6464c52d4e47fc00..11705794ac94c1fa364c573db2da17aeafc1873d 100644 (file)
@@ -32,4 +32,4 @@ void test01()
 }
 
 // { dg-error "used here" "" { target *-*-* } 31 }
-// { dg-error "deleted function" "" { target *-*-* } 149 }
+// { dg-error "deleted function" "" { target *-*-* } 148 }
index ce5034bf5024f2e5a1af9f385df5d52e1e7ad73b..898ad16350f0533cd4ccc33dd376ac5f7c0636a7 100644 (file)
@@ -31,5 +31,5 @@ void test01()
 }
 
 // { dg-error "here" "" { target *-*-* } 30 }
-// { dg-error "deleted function" "" { target *-*-* } 127 }
+// { dg-error "deleted function" "" { target *-*-* } 126 }
 // { dg-excess-errors "In file included from" }
index 4648196966d33fcc75b077b04c2e549c5922a615..45b2385242dbdfd1f261177ad9a7bb2ecc86014f 100644 (file)
@@ -3,7 +3,7 @@
 // { dg-require-cstdint "" }
 // { dg-require-gthreads "" }
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -33,4 +33,4 @@ void test01()
 }
 
 // { dg-error "used here" "" { target *-*-* } 32 } 
-// { dg-error "deleted function" "" { target *-*-* } 193 }
+// { dg-error "deleted function" "" { target *-*-* } 192 }
index 716b0562a42e75c0443fbbe6e6a3bf9796a5f8c7..04dea643fff9bb4a69a5185af79df9408e0c5518 100644 (file)
@@ -3,7 +3,7 @@
 // { dg-require-cstdint "" }
 // { dg-require-gthreads "" }
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -32,4 +32,4 @@ void test01()
 }
 
 // { dg-error "used here" "" { target *-*-* } 31 } 
-// { dg-error "deleted function" "" { target *-*-* } 192 }
+// { dg-error "deleted function" "" { target *-*-* } 191 }
index bd52fd3454585afcd307763db0746d7d885b70f7..609f188aade087bed9aef3b21a5323842ae434cc 100644 (file)
@@ -1,7 +1,7 @@
 // { dg-require-sharedlib "" }
 // { dg-options "-g -O2 -pthread -ldl" { target *-*-linux* } }
 
-// Copyright (C) 2004, 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2004, 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -93,7 +93,7 @@ int
 main (void)
 {
   pthread_t th;
-  pthread_create(&th, NULL, tf, NULL);
-  pthread_join(th, NULL);
+  pthread_create(&th, 0, tf, 0);
+  pthread_join(th, 0);
   return 0;
 }
index b1520be4a57849775ebc6c0e7d8d0c1281c15a25..fd1ed09c6c38b9fd151e11c1fe713e6595a59447 100644 (file)
@@ -1,6 +1,6 @@
 // 2003-05-03  Loren J. Rittle <rittle@labs.mot.com> <ljrittle@acm.org>
 //
-// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -90,10 +90,10 @@ main()
       foo4 += foo3;
 
       for (int i = 0; i < max_thread_count; i++)
-       pthread_create (&tid[i], NULL, thread_main, 0);
+       pthread_create (&tid[i], 0, thread_main, 0);
 
       for (int i = 0; i < max_thread_count; i++)
-       pthread_join (tid[i], NULL);
+       pthread_join (tid[i], 0);
     }
 
   VERIFY( !std::strcmp (data, "barbazbongle") );
index 9b0e0a53e82df9dcc3f81ca0a728424d3b63e4a4..e1493c675586f753492c6fe0f65c842ee5fe2ad2 100644 (file)
@@ -1,6 +1,6 @@
 // 2005-09-10  Paolo Carlini  <pcarlini@suse.de>
 //
-// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -22,6 +22,7 @@
 
 // libstdc++/23781
 #include <ext/slist>
+#include <cstddef>
 
 __gnu_cxx::slist<int>::iterator it = NULL; // { dg-error "conversion" }
 __gnu_cxx::slist<int>::const_iterator cit = NULL; // { dg-error "conversion" }
index ce719e576f2c53c49e1091664c9867836e35955d..d0a1fcfc406ab1be74c58c3ab90aa063153d3a02 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2000, 2001, 2002, 2003, 2009 Free Software Foundation
+// Copyright (C) 2000, 2001, 2002, 2003, 2009, 2010 Free Software Foundation
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -37,7 +37,7 @@ void test2()
   fbuf.close();
 
   FILE* file = fopen("tmp_10063-2", "r");
-  setbuf(file, NULL);
+  setbuf(file, 0);
   int c = getc(file);
   VERIFY(c == '0');
   c = getc(file);
index a8a06fdbcdc74feeb7c7e176ba3e4a135c58c04d..1709816c306e5a197d600486e4ccd9f3fe3fd2a1 100644 (file)
@@ -1,6 +1,6 @@
 // 2005-09-10  Paolo Carlini  <pcarlini@suse.de>
 //
-// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -22,6 +22,7 @@
 
 // libstdc++/23781
 #include <tr1/unordered_map>
+#include <cstddef>
 
 std::tr1::unordered_multimap<int, int>::iterator it2 = NULL; // { dg-error "conversion" }
 std::tr1::unordered_multimap<int, int>::const_iterator cit2 = NULL; // { dg-error "conversion" }
index d77676eb1a1633f58815f511dcbe2ef268ba9aec..2201b2d29d1e47f85d388c8037cd1cb5b524f6fe 100644 (file)
@@ -1,6 +1,6 @@
 // 2005-09-10  Paolo Carlini  <pcarlini@suse.de>
 //
-// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -22,6 +22,7 @@
 
 // libstdc++/23781
 #include <tr1/unordered_set>
+#include <cstddef>
 
 std::tr1::unordered_multiset<int>::iterator it3 = NULL; // { dg-error "conversion" }
 std::tr1::unordered_multiset<int>::const_iterator cit3 = NULL; // { dg-error "conversion" }
index 43cdb9f2b62e7836d9a91f389facaee60a52d139..0f1586648538249d81b234e2df9e0dca8ec628be 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -45,7 +45,7 @@ container_rand_regression_test(unsigned long seed, size_t n, size_t m,
                               double mp, bool disp) 
 : m_seed((seed == 0) ? twister_rand_gen::get_time_determined_seed() : seed),
   m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_ep(ep), m_cp(cp), m_mp(mp),
-  m_disp(disp), m_p_c(NULL)
+  m_disp(disp), m_p_c(0)
 { }
 
 PB_DS_CLASS_T_DEC
@@ -71,7 +71,7 @@ default_constructor()
       done = false;
     }
 
-  if (m_p_c != NULL)
+  if (m_p_c)
     PB_DS_COND_COMPARE(*m_p_c, m_native_c);
   return done;
 }
@@ -98,7 +98,7 @@ copy_constructor()
 {
   PB_DS_TRACE("copy_constructor");
   bool done = true;
-  Cntnr* p_c = NULL;
+  Cntnr* p_c = 0;
   m_alloc.set_probability(m_tp);
   typename alloc_t::group_adjustor adjust(m_p_c->size());
 
@@ -124,7 +124,7 @@ assignment_operator()
 {
   PB_DS_TRACE("assignment operator");
   bool done = true;
-  Cntnr* p_c = NULL;
+  Cntnr* p_c = 0;
   m_alloc.set_probability(m_tp);
   typename alloc_t::group_adjustor adjust(m_p_c->size());
 
@@ -159,7 +159,7 @@ PB_DS_CLASS_C_DEC::
 it_constructor_imp(__gnu_pbds::cc_hash_tag)
 {
   bool done = true;
-  Cntnr* p_c = NULL;
+  Cntnr* p_c = 0;
   m_alloc.set_probability(m_tp);
   typename alloc_t::group_adjustor adjust(m_p_c->size());
 
@@ -226,7 +226,7 @@ PB_DS_CLASS_C_DEC::
 it_constructor_imp(__gnu_pbds::gp_hash_tag)
 {
   bool done = true;
-  Cntnr* p_c = NULL;
+  Cntnr* p_c = 0;
   m_alloc.set_probability(m_tp);
   typename alloc_t::group_adjustor adjust(m_p_c->size());
 
@@ -309,7 +309,7 @@ PB_DS_CLASS_C_DEC::
 it_constructor_imp(__gnu_pbds::tree_tag)
 {
   bool done = true;
-  Cntnr* p_c = NULL;
+  Cntnr* p_c = 0;
   m_alloc.set_probability(m_tp);
   typename alloc_t::group_adjustor adjust(m_p_c->size());
 
@@ -345,7 +345,7 @@ PB_DS_CLASS_C_DEC::
 it_constructor_imp(__gnu_pbds::list_update_tag)
 {
   bool done = true;
-  Cntnr* p_c = NULL;
+  Cntnr* p_c = 0;
   m_alloc.set_probability(m_tp);
   typename alloc_t::group_adjustor adjust(m_p_c->size());
 
@@ -370,7 +370,7 @@ PB_DS_CLASS_C_DEC::
 it_constructor_imp(__gnu_pbds::pat_trie_tag)
 {
   bool done = true;
-  Cntnr* p_c = NULL;
+  Cntnr* p_c = 0;
   m_alloc.set_probability(m_tp);
   typename alloc_t::group_adjustor adjust(m_p_c->size());
 
@@ -869,7 +869,7 @@ PB_DS_CLASS_C_DEC::
 operator()()
 {
   typedef xml_result_set_regression_formatter formatter_type;
-  formatter_type* p_fmt = NULL;
+  formatter_type* p_fmt = 0;
 
   if (m_disp)
     p_fmt = new formatter_type(string_form<Cntnr>::name(),
@@ -1591,30 +1591,30 @@ policy_access(__gnu_pbds::basic_hash_tag)
 {
   {
     typename Cntnr::hash_fn& r_t = m_p_c->get_hash_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
   {
     const typename Cntnr::hash_fn& r_t =((const Cntnr& )*m_p_c).get_hash_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
 
   {
     typename Cntnr::eq_fn& r_t = m_p_c->get_eq_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
   {
     const typename Cntnr::eq_fn& r_t =((const Cntnr& )*m_p_c).get_eq_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
 
   {
     typename Cntnr::resize_policy& r_t = m_p_c->get_resize_policy();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
   {
     const typename Cntnr::resize_policy& r_t =((const Cntnr& )*m_p_c).get_resize_policy();
 
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
 }
 
@@ -1627,12 +1627,12 @@ policy_access(__gnu_pbds::cc_hash_tag)
 
   {
     typename Cntnr::comb_hash_fn& r_t = m_p_c->get_comb_hash_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
   {
     const typename Cntnr::comb_hash_fn& r_t =((const Cntnr& )*m_p_c).get_comb_hash_fn();
 
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
 }
 
@@ -1645,21 +1645,21 @@ policy_access(__gnu_pbds::gp_hash_tag)
 
   {
     typename Cntnr::comb_probe_fn& r_t = m_p_c->get_comb_probe_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
   {
     const typename Cntnr::comb_probe_fn& r_t =((const Cntnr& )*m_p_c).get_comb_probe_fn();
 
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
 
   {
     typename Cntnr::probe_fn& r_t = m_p_c->get_probe_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
   {
     const typename Cntnr::probe_fn& r_t =((const Cntnr& )*m_p_c).get_probe_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
 }
 
@@ -1670,12 +1670,12 @@ policy_access(__gnu_pbds::tree_tag)
 {
   {
     typename Cntnr::cmp_fn& r_t = m_p_c->get_cmp_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
 
   {
     const typename Cntnr::cmp_fn& r_t =((const Cntnr& )*m_p_c).get_cmp_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
 }
 
@@ -1691,7 +1691,7 @@ PB_DS_CLASS_C_DEC::
 policy_access(__gnu_pbds::pat_trie_tag)
 {
   typename Cntnr::e_access_traits& r_t = m_p_c->get_e_access_traits();
-  assert(&r_t != NULL);
+  assert(&r_t);
 }
 
 
index d4b395b126a90a5266d759008054f36da3069012..5f2304952364b764ffb50a7c8a43fcbb9bff0da0 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -124,7 +124,7 @@ namespace detail
       };
 
     // XXX RAII, constructor takes bool for display
-    xml_test_rand_regression_formatter* p_fmt = NULL;
+    xml_test_rand_regression_formatter* p_fmt = 0;
     if (disp)
       p_fmt = new xml_test_rand_regression_formatter(sd, n, m, tp, ip, ep, cp, mp);
 
index f964911facb1f01a4e44d8f2a66d4a85fa352866..e929f3533fe7f3d2dc17f4594086b3ce9858f2e2 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -45,7 +45,7 @@ container_rand_regression_test(unsigned long seed, size_t n, size_t m,
                               double cp, double mp, bool disp) 
 : m_seed(seed == 0 ? twister_rand_gen::get_time_determined_seed(): seed),
   m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_dp(dp), m_ep(ep), m_cp(cp),
-  m_mp(mp), m_disp(disp), m_p_c(NULL)
+  m_mp(mp), m_disp(disp), m_p_c(0)
 { }
 
 PB_DS_CLASS_T_DEC
@@ -71,7 +71,7 @@ default_constructor()
       done = false;
     }
 
-  if (m_p_c != NULL)
+  if (m_p_c)
     PB_DS_COND_COMPARE(*m_p_c, m_native_c);
 
   return done;
@@ -99,7 +99,7 @@ copy_constructor()
 {
   PB_DS_TRACE("copy_constructor");
   bool done = true;
-  Cntnr* p_c = NULL;
+  Cntnr* p_c = 0;
   m_alloc.set_probability(m_tp);
 
   typedef typename allocator_type::group_adjustor adjustor;
@@ -127,7 +127,7 @@ assignment_operator()
 {
   PB_DS_TRACE("assignment operator");
   bool done = true;
-  Cntnr* p_c = NULL;
+  Cntnr* p_c = 0;
   m_alloc.set_probability(m_tp);
 
   typedef typename allocator_type::group_adjustor adjustor;
@@ -155,7 +155,7 @@ PB_DS_CLASS_C_DEC::
 it_constructor()
 {
   bool done = true;
-  Cntnr* p_c = NULL;
+  Cntnr* p_c = 0;
   m_alloc.set_probability(m_tp);
   typedef typename allocator_type::group_adjustor adjustor;
   adjustor adjust(m_p_c->size());
@@ -242,7 +242,7 @@ PB_DS_CLASS_C_DEC::
 operator()()
 {
   typedef xml_result_set_regression_formatter formatter_type;
-  formatter_type* p_fmt = NULL;
+  formatter_type* p_fmt = 0;
   if (m_disp)
     p_fmt = new formatter_type(string_form<Cntnr>::name(),
                               string_form<Cntnr>::desc());
@@ -668,12 +668,12 @@ policy_access()
 
   {
     typename Cntnr::cmp_fn& r_t = m_p_c->get_cmp_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
 
   {
     const typename Cntnr::cmp_fn& r_t =((const Cntnr& )*m_p_c).get_cmp_fn();
-    assert(&r_t != NULL);
+    assert(&r_t);
   }
 }
 
index 1cf86020d454fe1d04ef1bfd93f5722170e098aa..37f8d51af74aedbbe2f02e3fa0c3a87f61e4a161 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2008, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -123,7 +123,7 @@ namespace detail
        return -2;
       };
 
-    xml_test_rand_regression_formatter* p_fmt = NULL;
+    xml_test_rand_regression_formatter* p_fmt = 0;
     if (sd == 0)
       sd = twister_rand_gen::get_time_determined_seed();
     if (disp)
index c7b19edc457a2340a57ebcd3a7724f05f10335a4..895ccfe389705114b77d23e51244ef73f469cbdb 100644 (file)
@@ -1,5 +1,5 @@
 //
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -90,7 +90,7 @@ void* operator new(std::size_t size) throw(std::bad_alloc)
 {
   std::printf("operator new is called \n");
   void* p = std::malloc(size);
-  if (p == NULL)
+  if (!p)
     throw std::bad_alloc();
   __gnu_test::counter::increment();
   return p;
@@ -99,7 +99,7 @@ void* operator new(std::size_t size) throw(std::bad_alloc)
 void operator delete(void* p) throw()
 {
   std::printf("operator delete is called \n");
-  if (p != NULL)
+  if (p)
     {
       std::free(p);
       __gnu_test::counter::decrement();
index 96fe546b48257473af95aaf89e03c33de3b99d80..b7fce48b5bc12fe1b027a83af9d2f47ca3df0749 100644 (file)
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 // Testing allocator for the C++ library testsuite.
 //
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -186,8 +186,8 @@ namespace __gnu_test
     {
       // Let's not core here...
       Alloc  a;
-      a.deallocate(NULL, 1);
-      a.deallocate(NULL, 10);
+      a.deallocate(0, 1);
+      a.deallocate(0, 10);
       return true;
     }
 
index 6d77d57672febc7653d50f4429caeffd20b9e631..5b5b0d5a9a1a0ff1cee48c9a4fc77ff44038f630 100644 (file)
@@ -2,7 +2,7 @@
 
 // Utility subroutines for the C++ library testsuite. 
 //
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -170,7 +170,7 @@ namespace __gnu_test
     locale orig = locale::global(loc_name);
 
     const char* res = setlocale(LC_ALL, name);
-    if (res != NULL)
+    if (res)
       {
        string preLC_ALL = res;
        const func_callback::test_type* tests = l.tests();
index 50b1955ca11271d4c87419dd0708d0dd57d0a083..681448aa51faeb3f3fbfbb4c8ab3c538c4d5361a 100644 (file)
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 // Testing streambuf/filebuf/stringbuf for the C++ library testsuite.
 //
-// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -47,7 +47,7 @@ namespace __gnu_test
       bool
       write_position() 
       { 
-       bool one = this->pptr() != NULL
+       bool one = this->pptr() != 0
        bool two = this->pptr() < this->epptr();
        return one && two;
       }
@@ -55,7 +55,7 @@ namespace __gnu_test
       bool
       read_position()
       { 
-       bool one = this->gptr() != NULL
+       bool one = this->gptr() != 0
        bool two = this->gptr() < this->egptr();
        return one && two;
       }
@@ -63,21 +63,21 @@ namespace __gnu_test
       bool
       unbuffered() 
       { 
-       bool one = this->pbase() == NULL
-       bool two = this->pptr() == NULL
+       bool one = this->pbase() == 0
+       bool two = this->pptr() == 0
        return one && two;
       }
   
       bool
       check_pointers()
       {
-       bool one   = this->eback() == NULL;
-       bool two   = this->gptr() == NULL;
-       bool three = this->egptr() == NULL;
+       bool one   = this->eback() == 0;
+       bool two   = this->gptr() == 0;
+       bool three = this->egptr() == 0;
        
-       bool four  = this->pbase() == NULL;
-       bool five  = this->pptr() == NULL;
-       bool six   = this->epptr() == NULL;
+       bool four  = this->pbase() == 0;
+       bool five  = this->pptr() == 0;
+       bool six   = this->epptr() == 0;
        return one && two && three && four && five && six;
       }
     };
@@ -276,37 +276,37 @@ namespace __gnu_test
     protected:
       iter_type 
       do_put(iter_type, ios_base&, char_type, bool) const
-      { throw facet_error(); return iter_type(NULL); }
+      { throw facet_error(); return iter_type(0); }
       
       virtual iter_type 
       do_put(iter_type, ios_base&, char_type, long) const
-      { throw facet_error(); return iter_type(NULL); }
+      { throw facet_error(); return iter_type(0); }
 
       virtual iter_type 
       do_put(iter_type, ios_base&, char_type, unsigned long) const
-      { throw facet_error(); return iter_type(NULL); }
+      { throw facet_error(); return iter_type(0); }
 
 #ifdef _GLIBCXX_USE_LONG_LONG 
       virtual iter_type 
       do_put(iter_type, ios_base&, char_type, long long) const
-      { throw facet_error(); return iter_type(NULL); }
+      { throw facet_error(); return iter_type(0); }
 
       virtual iter_type 
       do_put(iter_type, ios_base&, char_type, unsigned long long) const
-      { throw facet_error(); return iter_type(NULL); }
+      { throw facet_error(); return iter_type(0); }
 #endif
       
       virtual iter_type 
       do_put(iter_type, ios_base&, char_type, double) const
-      { throw facet_error(); return iter_type(NULL); }
+      { throw facet_error(); return iter_type(0); }
 
       virtual iter_type 
       do_put(iter_type, ios_base&, char_type, long double) const
-      { throw facet_error(); return iter_type(NULL); }
+      { throw facet_error(); return iter_type(0); }
       
       virtual iter_type 
       do_put(iter_type, ios_base&, char_type, const void*) const
-      { throw facet_error(); return iter_type(NULL); }
+      { throw facet_error(); return iter_type(0); }
     };
 
   typedef  fail_num_put<char>     fail_num_put_char;
index 14a725fcbec5a8f98184f42570acb07e58064c2f..ee0c8e6eecdc5039d4506b62e7046b07aa0ba32b 100644 (file)
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 // Iterator Wrappers for the C++ library testsuite. 
 //
-// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
+// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -201,7 +201,7 @@ namespace __gnu_test
     bool
     operator==(const input_iterator_wrapper& in) const
     {
-      ITERATOR_VERIFY(SharedInfo != NULL && SharedInfo == in.SharedInfo);
+      ITERATOR_VERIFY(SharedInfo && SharedInfo == in.SharedInfo);
       ITERATOR_VERIFY(ptr>=SharedInfo->first && in.ptr>=SharedInfo->first);
       return ptr == in.ptr;
     }
@@ -274,8 +274,8 @@ namespace __gnu_test
 
     forward_iterator_wrapper()
     {
-      this->ptr = NULL;
-      this->SharedInfo = NULL;
+      this->ptr = 0;
+      this->SharedInfo = 0;
     }
 
     T&
index 54cf8856701a799bb59c33776862edddddd87075..61efd042db2ec20d86e2bcf133a8523fc5873e49 100644 (file)
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 // Testing performance utilities for the C++ library testsuite.
 //
-// Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009
+// Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -50,7 +50,7 @@ extern "C"
   struct mallinfo
   mallinfo(void)
   {
-    struct mallinfo m = { (((size_t) sbrk (0) + 1023) / 1024), 0 };
+    struct mallinfo m = { (((std::size_t) sbrk (0) + 1023) / 1024), 0 };
     return m;
   }
 }
@@ -114,15 +114,15 @@ namespace __gnu_test
        std::__throw_runtime_error("time_counter::stop");
     }
 
-    size_t
+    std::size_t
     real_time() const
     { return elapsed_end - elapsed_begin; }
 
-    size_t
+    std::size_t
     user_time() const
     { return tms_end.tms_utime - tms_begin.tms_utime; }
 
-    size_t
+    std::size_t
     system_time() const
     { return tms_end.tms_stime - tms_begin.tms_stime; }
   };
@@ -383,7 +383,7 @@ template<typename Container, int Iter>
 
 template<typename Container, int Iter>
   void*
-  do_thread(void* p = NULL)
+  do_thread(void* p = 0)
   {
     do_loop<Container, Iter>();
     return p;
@@ -412,10 +412,10 @@ template<typename Container, int Iter, bool Thread>
          pthread_create(&t3, 0, &do_thread<Container, Iter>, 0);
          pthread_create(&t4, 0, &do_thread<Container, Iter>, 0);
          
-         pthread_join(t1, NULL);
-         pthread_join(t2, NULL);
-         pthread_join(t3, NULL);
-         pthread_join(t4, NULL);
+         pthread_join(t1, 0);
+         pthread_join(t2, 0);
+         pthread_join(t3, 0);
+         pthread_join(t4, 0);
 #endif
        }
       stop_counters(time, resource);