+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
#ifndef _BACKWARD_HASH_FUN_H
#define _BACKWARD_HASH_FUN_H 1
-#include <cstddef>
+#include <bits/c++config.h>
_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
// 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
#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));
// -*- 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
#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)
// 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
# 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.
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),
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);
close()
{
if (!this->is_open())
- return NULL;
+ return 0;
bool __testfail = false;
{
__testfail = true;
if (__testfail)
- return NULL;
+ return 0;
else
return this;
}
#pragma GCC system_header
-#include <cstddef>
+#include <bits/c++config.h>
#include <bits/stl_function.h>
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();
* @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(); }
/**
*/
explicit
numpunct(__c_locale __cloc, size_t __refs = 0)
- : facet(__refs), _M_data(NULL)
+ : facet(__refs), _M_data(0)
{ _M_initialize_numpunct(__cloc); }
/**
// For use at construction time only.
void
- _M_initialize_numpunct(__c_locale __cloc = NULL);
+ _M_initialize_numpunct(__c_locale __cloc = 0);
};
template<typename _CharT>
// 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
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>;
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();
// For use at construction time only.
void
- _M_initialize_timepunct(__c_locale __cloc = NULL);
+ _M_initialize_timepunct(__c_locale __cloc = 0);
};
template<typename _CharT>
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)
* @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(); }
/**
*/
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); }
/**
// 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>
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>;
#define _MOVE_H 1
#include <bits/c++config.h>
-#include <cstddef>
#include <bits/concept_check.h>
_GLIBCXX_BEGIN_NAMESPACE(std)
#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>
#pragma GCC system_header
#include <bits/c++config.h>
-#include <cstddef>
_GLIBCXX_BEGIN_NAMESPACE(std)
#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
#pragma GCC system_header
#include <bits/c++config.h>
-#include <cstddef>
#include <stdio.h>
#ifndef _GLIBCXX_CSTDIO
#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 ();
#pragma GCC system_header
#include <bits/c++config.h>
-#include <cstddef>
#ifndef _GLIBCXX_CSTDLIB
#define _GLIBCXX_CSTDLIB 1
#pragma GCC system_header
#include <bits/c++config.h>
-#include <cstddef>
#include <string.h>
#ifndef _GLIBCXX_CSTRING
#pragma GCC system_header
-#include <cstddef>
+#include <bits/c++config.h>
#include <time.h>
#ifndef _GLIBCXX_CTIME
#pragma GCC system_header
#include <bits/c++config.h>
-#include <cstddef>
#if _GLIBCXX_HAVE_WCHAR_H
#include <wchar.h>
#include <bits/c++config.h>
#include <stddef.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
- using ::ptrdiff_t;
- using ::size_t;
-
-_GLIBCXX_END_NAMESPACE
-
#endif
#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.
#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 ();
#pragma GCC system_header
#include <bits/c++config.h>
-#include <cstddef>
#if !_GLIBCXX_HOSTED
// The C standard does not require a freestanding implementation to
#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.
#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.
#pragma GCC system_header
#include <bits/c++config.h>
-#include <cstddef>
#if _GLIBCXX_HAVE_WCHAR_H
#include <wchar.h>
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;
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;
}
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;
}
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;
_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(); }
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
// 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
#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
#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>
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()
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() { }
#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
// 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
// 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))
// 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
#pragma GCC system_header
#include <functional>
-#include <cstddef>
_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
{ }
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
_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:
#ifndef _NEW_ALLOCATOR_H
#define _NEW_ALLOCATOR_H 1
+#include <bits/c++config.h>
#include <new>
#include <bits/functexcept.h>
#include <bits/move.h>
#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>
* 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>
__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();
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;
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
__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
{
__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);)
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;
{
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;
}
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);
}
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);
_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();
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);
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
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),
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),
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;
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;
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);
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);
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))
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))
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)))
{
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)))
{
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;
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;
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)))
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(
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)));
}
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)));
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));
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)));
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;
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;
PB_DS_CLASS_C_DEC::
node_end() const
{
- return (const_node_iterator(NULL));
+ return (const_node_iterator(0));
}
PB_DS_CLASS_T_DEC
PB_DS_CLASS_C_DEC::
node_end()
{
- return (node_iterator(NULL));
+ return (node_iterator(0));
}
*/
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.
*/
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))
{ }
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))
{ }
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;
}
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;
}
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;
}
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;
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)
{ }
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;
}
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);
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;
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;
{
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
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);
}
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;
}
// Default constructor.
inline
- binary_heap_const_point_iterator_() : m_p_e(NULL) { }
+ binary_heap_const_point_iterator_() : m_p_e(0) { }
// Copy constructor.
inline
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>());
}
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>());
}
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
{
}
__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;
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
{
}
__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;
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);)
}
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);)
}
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);)
}
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));
{
_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)
{
_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;
base_type::actual_erase_node(p_nd);
- m_p_max = NULL;
+ m_p_max = 0;
_GLIBCXX_DEBUG_ONLY(assert_valid(true);)
}
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);
}
{
base_type::clear();
- m_p_max = NULL;
+ m_p_max = 0;
}
PB_DS_CLASS_T_DEC
base_type::actual_erase_node(it.m_p_nd);
- m_p_max = NULL;
+ m_p_max = 0;
_GLIBCXX_DEBUG_ONLY(assert_valid(true);)
}
size_type ersd = 0;
- while (p_out != NULL)
+ while (p_out != 0)
{
++ersd;
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;
p_cur = p_next;
}
- m_p_max = NULL;
+ m_p_max = 0;
_GLIBCXX_DEBUG_ONLY(assert_valid(true);)
_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;
}
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;
insert_node(p_nd);
- m_p_max = NULL;
+ m_p_max = 0;
_GLIBCXX_DEBUG_ONLY(assert_valid(true);)
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;
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;
{
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;
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;
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;
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);
{
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);
}
}
- 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;
_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);
{
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);
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);)
insert_node(p_nd);
- m_p_max = NULL;
+ m_p_max = 0;
_GLIBCXX_DEBUG_ONLY(assert_valid(true);)
}
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;
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;
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;
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);)
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;
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);)
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
{
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;
}
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
{
}
}
- 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;
}
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();
}
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);
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();
}
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;
{
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();
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);
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))
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);
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
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
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
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();)
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);
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);
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;
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;
}
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))
{
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();
_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);)
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);)
_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);)
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);)
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; }
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
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();
}
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);
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))
{
}
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);
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);
}
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;
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; }
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:
_GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);)
resize_base::notify_find_search_end();
- return NULL;
+ return 0;
}
inline pointer
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:
_GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);)
resize_base::notify_find_search_end();
- return NULL;
+ return 0;
}
inline bool
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];
return;
}
}
- r_p_value = NULL;
+ r_p_value = 0;
}
void
return;
}
}
- r_p_value = NULL;
+ r_p_value = 0;
}
void
return;
}
}
- r_p_value = NULL;
+ r_p_value = 0;
}
#ifdef _GLIBCXX_DEBUG
_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);
// -*- 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
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
// -*- 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
public:
// Size type.
- typedef size_t size_type;
+ typedef std::size_t size_type;
public:
// -*- 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
public:
// Size type.
- typedef size_t size_type;
+ typedef std::size_t size_type;
public:
// -*- 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
public:
// Size type.
- typedef size_t size_type;
+ typedef std::size_t size_type;
public:
// -*- 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
public:
// Size type.
- typedef size_t size_type;
+ typedef std::size_t size_type;
public:
// 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;
};
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);
}
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;
}
{
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;
}
}
// 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.
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;
}
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();)
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();)
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();)
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);
}
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
{
__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;
}
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();
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));
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;
{
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;
{
clear_imp(m_p_root);
_GLIBCXX_DEBUG_ASSERT(m_size == 0);
- m_p_root = NULL;
+ m_p_root = 0;
}
PB_DS_CLASS_T_DEC
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;
{
_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;
#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);
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;
}
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);
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;
{
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;
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;
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)
{
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));
{
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));
PB_DS_CLASS_C_DEC::
end()
{
- return (iterator(NULL));
+ return (iterator(0));
}
PB_DS_CLASS_T_DEC
PB_DS_CLASS_C_DEC::
end() const
{
- return (const_iterator(NULL));
+ return (const_iterator(0));
}
* 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
{
} // 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
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 << ' ';
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(););
#ifdef _GLIBCXX_DEBUG
debug_base(),
#endif
-m_p_l(NULL)
+m_p_l(0)
{
__try
{
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
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)))
}
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);
{
_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;
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))
{
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;
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);
}
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)))
}
_GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
- return NULL;
+ return 0;
}
PB_DS_CLASS_T_DEC
inline bool
PB_DS_CLASS_C_DEC::
empty() const
-{ return (m_p_l == NULL); }
+{ return (m_p_l == 0); }
_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);
PB_DS_CLASS_C_DEC::
begin()
{
- if (m_p_l == NULL)
+ if (m_p_l == 0)
{
_GLIBCXX_DEBUG_ASSERT(empty());
return end();
PB_DS_CLASS_C_DEC::
begin() const
{
- if (m_p_l == NULL)
+ if (m_p_l == 0)
{
_GLIBCXX_DEBUG_ASSERT(empty());
return end();
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));
}
{
_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
{
_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
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>
{
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;
// -*- 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
// 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:
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();) }
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();) }
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();) }
#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());
{
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();
}
_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();)
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();
{
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));
}
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
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
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);
}
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
};
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;
}
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
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.
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)));
}
};
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();
}
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;
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);)
}
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);)
}
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);)
}
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);
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;
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;
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))
{
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;
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;
}
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;
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));
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;
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);
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);
_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();)
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))
{
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();)
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)
{ }
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)
{ }
{
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;
}
#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:
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;
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;
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);
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);
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);
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;
_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();
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();
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);
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;
}
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);
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;
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;
}
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;
}
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);
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);
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;
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);
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);
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)));
// -*- 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
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);
{
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
{
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);
}
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];
{
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;
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);
{
iterator ret = it;
++ret;
- * it.m_p_p_cur = NULL;
+ * it.m_p_p_cur = 0;
return ret;
}
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;
}
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); }
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)
{ }
*/
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.
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
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;
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;
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
typename Internal_Node::iterator it = p_parent->begin();
if (*it == p_nd)
- return (NULL);
+ return (0);
typename Internal_Node::iterator prev_it;
do
{
while (true);
_GLIBCXX_DEBUG_ASSERT(false);
- return (NULL);
+ return (0);
}
inline static leaf_pointer
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
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);
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;
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;
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));
}
_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();)
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,
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,
{
_GLIBCXX_DEBUG_ONLY(assert_valid(););
_GLIBCXX_DEBUG_ONLY(other.assert_valid(););
- return (NULL);
+ return (0);
}
iterator it = lower_bound(r_key);
{
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);
}
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);
++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);
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;
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));
}
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);
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);
{
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;
}
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)
}
else
{
- p_y->m_p_left = NULL;
+ p_y->m_p_left = 0;
p_z->m_p_parent->m_p_right = p_x;
}
}
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;
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)
{
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;
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);
{
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;
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);
}
}
- if (p_x != NULL)
+ if (p_x != 0)
p_x->m_red = false;
}
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); }
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;
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;
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);
{
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,
}
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;
{
_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)
_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);
}
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)
_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);
}
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;
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;
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;
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);
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();
}
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;
}
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;
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;
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;
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);
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();)
{
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;
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)
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);
}
// -*- 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
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)
// -*- 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
public:
// Size type.
- typedef size_t size_type;
+ typedef std::size_t size_type;
// Default constructor.
sample_resize_policy();
// -*- 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
public:
// Size type.
- typedef size_t size_type;
+ typedef std::size_t size_type;
// Default constructor.
sample_resize_trigger();
// -*- 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
public:
// Size type.
- typedef size_t size_type;
+ typedef std::size_t size_type;
// Default constructor.
sample_size_policy();
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)
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();)
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);
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;
}
{
_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)))
{
_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)))
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)))
_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);
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);
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);
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);
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);
#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;
}
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;
}
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);
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();)
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();)
{
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;
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)); }
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
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));
}
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);
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)
_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;
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;
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;
{
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());
p_nd = m_a_aux[r];
}
- m_a_aux[r] = NULL;
+ m_a_aux[r] = 0;
++r;
}
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();
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;
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);
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();
{
base_type::clear();
- m_p_max = NULL;
+ m_p_max = 0;
}
PB_DS_CLASS_T_DEC
size_type ersd = 0;
- while (p_out != NULL)
+ while (p_out != 0)
{
++ersd;
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;
_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;
}
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;
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;
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;
}
{
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;
{
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);
}
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)
{
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;
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);
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);)
}
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;
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;
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;
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)
_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);
{
remove_node(p_nd);
- p_nd->m_p_l_child = NULL;
+ p_nd->m_p_l_child = 0;
make_root_and_link(p_nd);
return;
}
- if (p_nd->m_p_prev_or_parent == NULL)
+ if (p_nd->m_p_prev_or_parent == 0)
{
update_max(p_nd);
}
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)
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;
}
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;
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;
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;
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();)
// -*- 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
public:
// Metadata type.
- typedef size_t metadata_type;
+ typedef std::size_t metadata_type;
protected:
// -*- 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
public:
// Size type.
- typedef size_t size_type;
+ typedef std::size_t size_type;
// Key type.
typedef std::string key_type;
// -*- 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
public:
// Metadata type.
- typedef size_t metadata_type;
+ typedef std::size_t metadata_type;
protected:
inline
const_iterator_()
- : m_p_tbl(NULL)
+ : m_p_tbl(0)
{ }
// Increments.
inline
const_point_iterator_()
- : m_p_value(NULL)
+ : m_p_value(0)
{ }
// Copy constructor.
inline const_pointer
operator->() const
{
- _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL);
+ _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
return (m_p_value);
}
inline const_reference
operator*() const
{
- _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL);
+ _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
return (*m_p_value);
}
inline
iterator_()
- : const_iterator_(NULL, PB_DS_GEN_POS(), NULL)
+ : const_iterator_(0, PB_DS_GEN_POS(), 0)
{ }
// Conversion to a point-type iterator.
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));
}
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));
}
inline
point_iterator_()
- : m_p_value(NULL)
+ : m_p_value(0)
{ }
// Copy constructor.
inline pointer
operator->() const
{
- _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL);
+ _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
return (m_p_value);
}
inline reference
operator*() const
{
- _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL);
+ _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
return (*m_p_value);
}
// -*- 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
#ifndef PB_DS_EXCEPTION_HPP
#define PB_DS_EXCEPTION_HPP
+#include <bits/c++config.h>
#include <stdexcept>
#include <cstdlib>
// -*- 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
#ifndef PB_DS_HASH_POLICY_HPP
#define PB_DS_HASH_POLICY_HPP
+#include <bits/c++config.h>
#include <algorithm>
#include <vector>
#include <cmath>
#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:
#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:
#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>
{
#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>
{
// 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:
// 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:
// 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:
{
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
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
{
// -*- 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
#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>
#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>
{
// -*- 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
#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>
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;
// -*- 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
#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>
/**
// -*- 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
#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>
// -*- 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
#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>
// 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));
// 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));
// 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
#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>
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));
/** @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
/** @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
// -*- 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
#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>
// -*- 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
__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)
// 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)
{
__n /= 2;
- const _Tp* __lmax = NULL;
+ const _Tp* __lmax = 0;
for (_SeqNumber __i = 0; __i < __m; ++__i)
{
if (__a[__i] > 0)
_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);
}
(::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
__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;
// -*- 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
#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
}
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),
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});
{"__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);
__object_table.rehash(10000);
__stack_table.rehash(10000);
__stack_table_byte_size = 0;
- __id = NULL;
+ __id = 0;
}
template <typename __object_info, typename __stack_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;
{
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();
# include <bits/c++0x_warning.h>
#endif
+#include <bits/c++config.h>
#include <bits/atomic_base.h>
-#include <cstddef>
_GLIBCXX_BEGIN_NAMESPACE(std)
#pragma GCC system_header
-#include <cstddef> // For size_t
#include <string>
#include <bits/functexcept.h> // For invalid_argument, out_of_range,
// overflow_error
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);
}
};
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);
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);
// <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
#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>
#else
#include <tuple>
-#include <cstddef>
#include <chrono>
#include <exception>
#include <type_traits>
#include <memory>
#include <mutex>
#include <condition_variable>
-#include <cstddef>
#include <bits/functexcept.h>
#include <bits/functional_hash.h>
#include <bits/gthr.h>
# 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>
// 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
#pragma GCC system_header
#include <bits/c++config.h>
-#include <cstddef>
#include <cmath>
#include <algorithm>
#include <debug/debug.h>
// 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
# 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>
#pragma GCC visibility push(default)
-#include <cstddef>
+#include <bits/c++config.h>
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
#pragma GCC system_header
-#include <cstddef>
+#include <bits/c++config.h>
#include <exception>
#pragma GCC visibility push(default)
// 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
#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
// 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
__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);
}
}
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)
// 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
__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;
_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;
}
// 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.
__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);
__block->_M_next = reinterpret_cast<_Block_record*>(__c);
__block = __block->_M_next;
}
- __block->_M_next = NULL;
+ __block->_M_next = 0;
}
else
{
{
__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
{
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);
}
__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];
}
// 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)
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);
_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;
}
// 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)
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);
_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;
// 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
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);
// { 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
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
{
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;
// 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
{
void* pc = new char;
void* pa = new char[10];
- void* tmp = NULL;
+ void* tmp = 0;
operator delete(pc, tmp);
operator delete[](pa, tmp);
}
//
-// 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
do_something (void *arg)
{
static int bar __attribute__((unused)) = get_bar ();
- return NULL;
+ return 0;
}
int
{
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;
// 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
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);
}
// 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
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);
}
-// 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
// 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;
}
-// 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
// 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;
}
// 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
#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;
}
-// 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
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)
-// 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
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)
// { 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
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;
}
// 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
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(...)
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(...)
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(...)
// { 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
"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);
// 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
if (loc.name() != "*")
{
locale::global(loc);
- VERIFY( loc.name() == setlocale(LC_ALL, NULL) );
+ VERIFY( loc.name() == setlocale(LC_ALL, 0) );
}
}
// 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
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);
// 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 );
-// 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
bool test __attribute__((unused)) = true;
ostringstream stream;
- time_t tt = time(NULL);
+ time_t tt = time(0);
const char* fmt = "%c";
-// 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
bool test __attribute__((unused)) = true;
ostringstream stream;
- time_t tt = time(NULL);
+ time_t tt = time(0);
const char* fmt = "%c";
// 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
// libstdc++/23781
#include <list>
+#include <cstddef>
typedef std::list<int> list_type;
list_type::iterator it = NULL; // { dg-error "conversion" }
// 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
#include <list>
#include <cstdlib>
+#include <cstddef>
#include <pthread.h>
const int thread_cycles = 10;
// 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
// 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" }
// 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
#include <string>
#include <map>
#include <vector>
+#include <cstddef>
#include <pthread.h>
const int max_thread_count = 8;
// 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
// 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" }
// 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
// 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" }
// 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
// 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" }
// 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
*ostrb_it01;
VERIFY( !ostrb_it01.failed() );
- costreambuf_iter ostrb_it02(NULL);
+ costreambuf_iter ostrb_it02(0);
VERIFY( ostrb_it02.failed() );
ostrb_it02++;
++ostrb_it02;
-// 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
// 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() );
}
-// 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
VERIFY( !cvt->unshift_called );
filebuf* ret = fb.close();
VERIFY( cvt->unshift_called );
- VERIFY( ret == NULL );
+ VERIFY( !ret );
}
int main()
-// 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
// 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);
// read (standard)
FILE* f = fopen(name_01, "r");
- VERIFY( f != NULL );
+ VERIFY( f );
if (f)
{
std::ifstream ifstream1(name_01);
// { 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
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;
-// 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
VERIFY( !cvt->unshift_called );
wfilebuf* ret = fb.close();
VERIFY( cvt->unshift_called );
- VERIFY( ret == NULL );
+ VERIFY( !ret );
}
int main()
// 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
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();
-// 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
// 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);
-// 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
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();
// { 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
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() );
// { 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
wfilebuf* f = fb.close();
VERIFY( n1 != wfilebuf::traits_type::eof() );
- VERIFY( f != NULL );
+ VERIFY( f );
}
int main()
// { 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
VERIFY( n1 != wfilebuf::traits_type::eof() );
VERIFY( n2 != wfilebuf::traits_type::eof() );
- VERIFY( f != NULL );
+ VERIFY( f );
}
int main()
// { 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
wfilebuf* f = fb.close();
VERIFY( n1 != wfilebuf::traits_type::eof() );
- VERIFY( f != NULL );
+ VERIFY( f );
}
int main()
// { 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
VERIFY( n1 != wfilebuf::traits_type::eof() );
VERIFY( n2 != wfilebuf::traits_type::eof() );
- VERIFY( f != NULL );
+ VERIFY( f );
}
int main()
// 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
check_pointers()
{
bool test __attribute__((unused)) = true;
- test = (this->pbase() == NULL);
- test &= (this->pptr() == NULL);
+ test = (!this->pbase());
+ test &= (!this->pptr());
return test;
}
};
// 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
nullsetpbuf()
{
setp(foo, foo + 64);
- setp(NULL, NULL);
+ setp(0, 0);
}
};
// 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
nullsetpbuf()
{
setp(foo, foo + 64);
- setp(NULL, NULL);
+ setp(0, 0);
}
};
// 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
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() );
// 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
// 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);
}
{
- 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);
// 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
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);
// 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
// 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);
}
}
{
- 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);
// 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
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');;
// 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
try
{
- gnu_iostr obj(NULL);
+ gnu_iostr obj(0);
}
catch(std::exception& obj)
{
// 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
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;
// 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
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);
-// 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
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);
// 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
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;
// 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
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;
// 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
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;
// 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
sstr >> str;
// 2
- pod_char* chr = NULL;
+ pod_char* chr = 0;
sstr >> chr;
// 3
-// 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
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;
-// 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
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;
-// 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
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;
// 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
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);
-// 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
{
bool test __attribute__((unused)) = true;
istringstream stream;
- stream >> static_cast<streambuf*>(NULL);
+ stream >> static_cast<streambuf*>(0);
VERIFY(stream.rdstate() & ios_base::failbit);
}
try
{
- stream >> static_cast<streambuf*>(NULL);
+ stream >> static_cast<streambuf*>(0);
VERIFY(false);
}
catch (ios_base::failure&)
-// 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
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);
-// 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
{
bool test __attribute__((unused)) = true;
wistringstream stream;
- stream >> static_cast<wstreambuf*>(NULL);
+ stream >> static_cast<wstreambuf*>(0);
VERIFY( stream.rdstate() & ios_base::failbit );
}
try
{
- stream >> static_cast<wstreambuf*>(NULL);
+ stream >> static_cast<wstreambuf*>(0);
VERIFY( false );
}
catch (ios_base::failure&)
// 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
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;
-// 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
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;
// 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
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;
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) );
-// 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
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;
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) );
// 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
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;
-// 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
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;
// 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
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;
-// 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
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;
// 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
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;
-// 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
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;
// 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
#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;
}
// 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
try
{
- gnu_ostr obj(NULL);
+ gnu_ostr obj(0);
}
catch(std::exception& obj)
{
// 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
void test08()
{
bool test __attribute__((unused)) = true;
- char* pt = NULL;
+ char* pt = 0;
// 1
std::ostringstream oss;
// 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
void test08()
{
bool test __attribute__((unused)) = true;
- char* pt = NULL;
+ char* pt = 0;
// 2
std::wostringstream woss;
VERIFY( woss.good() );
// 3
- wchar_t* wt = NULL;
+ wchar_t* wt = 0;
woss.clear();
woss << wt;
VERIFY( woss.bad() );
// 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
// 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();
-// 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
bool test __attribute__((unused)) = true;
ostringstream stream;
- stream << static_cast<streambuf*>(NULL);
+ stream << static_cast<streambuf*>(0);
VERIFY( stream.rdstate() & ios_base::badbit );
}
try
{
- stream << static_cast<streambuf*>(NULL);
+ stream << static_cast<streambuf*>(0);
VERIFY( false );
}
catch (ios_base::failure&)
-// 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
// 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();
-// 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
bool test __attribute__((unused)) = true;
wostringstream stream;
- stream << static_cast<wstreambuf*>(NULL);
+ stream << static_cast<wstreambuf*>(0);
VERIFY( stream.rdstate() & ios_base::badbit );
}
try
{
- stream << static_cast<wstreambuf*>(NULL);
+ stream << static_cast<wstreambuf*>(0);
VERIFY( false );
}
catch (ios_base::failure&)
// 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
const string_type str01;
- stringbuf_type* strbuf01 = NULL;
+ stringbuf_type* strbuf01 = 0;
stringbuf_type strbuf02(str01);
ostream_type ostr01(strbuf01);
ostream_type ostr02(&strbuf02);
// 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
#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;
}
// 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
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;
}
// 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
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;
}
// 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
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;
}
// 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
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;
}
// 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
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;
}
// 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
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;
}
// 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
nullsetpbuf()
{
setp(foo, foo + 64);
- setp(NULL, NULL);
+ setp(0, 0);
}
};
// 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
nullsetpbuf()
{
setp(foo, foo + 64);
- setp(NULL, NULL);
+ setp(0, 0);
}
};
// 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
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;
}
// 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
nullsetpbuf()
{
setp(foo, foo + 64);
- setp(NULL, NULL);
+ setp(0, 0);
}
};
// 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
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;
}
// 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
nullsetpbuf()
{
setp(foo, foo + 64);
- setp(NULL, NULL);
+ setp(0, 0);
}
};
// 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
nullsetpbuf()
{
setp(foo, foo + 64);
- setp(NULL, NULL);
+ setp(0, 0);
}
};
// 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
nullsetpbuf()
{
setp(foo, foo + 64);
- setp(NULL, NULL);
+ setp(0, 0);
}
};
// 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
nullsetpbuf()
{
setp(foo, foo + 64);
- setp(NULL, NULL);
+ setp(0, 0);
}
};
// 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
nullsetpbuf()
{
setp(foo, foo + 64);
- setp(NULL, NULL);
+ setp(0, 0);
}
};
// 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
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) );
// 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
std::stringbuf b1;
std::cout.rdbuf( &b1 );
std::cout << "hello\n";
- std::cout.rdbuf(NULL);
+ std::cout.rdbuf(0);
}
int main()
// 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
if (child == 0)
{
FILE* file = fopen(name, "r+");
- VERIFY( file != NULL );
+ VERIFY( file != 0 );
fputs("Whatever\n", file);
fflush(file);
s1.signal();
// 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
std::wstringbuf b1;
std::wcout.rdbuf( &b1 );
std::wcout << L"hello\n";
- std::wcout.rdbuf(NULL);
+ std::wcout.rdbuf(0);
}
int main()
// { 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
// <http://www.gnu.org/licenses/>.
#include <atomic>
+#include <cstddef>
int main()
{
// { 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
int main()
{
// Single value constructor.
- void* v = NULL;
+ void* v = 0;
std::atomic_address a(v);
return 0;
}
// { 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
}
// { dg-error "used here" "" { target *-*-* } 32 }
-// { dg-error "deleted function" "" { target *-*-* } 83 }
+// { dg-error "deleted function" "" { target *-*-* } 82 }
// { 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
}
// { dg-error "used here" "" { target *-*-* } 31 }
-// { dg-error "deleted function" "" { target *-*-* } 82 }
+// { dg-error "deleted function" "" { target *-*-* } 81 }
// { 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
}
// { dg-error "used here" "" { target *-*-* } 32 }
-// { dg-error "deleted function" "" { target *-*-* } 135 }
+// { dg-error "deleted function" "" { target *-*-* } 134 }
// { 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
}
// { dg-error "used here" "" { target *-*-* } 31 }
-// { dg-error "deleted function" "" { target *-*-* } 134 }
+// { dg-error "deleted function" "" { target *-*-* } 133 }
// { 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
}
// { dg-error "used here" "" { target *-*-* } 32 }
-// { dg-error "deleted function" "" { target *-*-* } 298 }
+// { dg-error "deleted function" "" { target *-*-* } 297 }
// { 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
}
// { dg-error "used here" "" { target *-*-* } 31 }
-// { dg-error "deleted function" "" { target *-*-* } 297 }
+// { dg-error "deleted function" "" { target *-*-* } 296 }
}
// { dg-error "used here" "" { target *-*-* } 31 }
-// { dg-error "deleted function" "" { target *-*-* } 149 }
+// { dg-error "deleted function" "" { target *-*-* } 148 }
}
// { dg-error "here" "" { target *-*-* } 30 }
-// { dg-error "deleted function" "" { target *-*-* } 127 }
+// { dg-error "deleted function" "" { target *-*-* } 126 }
// { dg-excess-errors "In file included from" }
// { 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
}
// { dg-error "used here" "" { target *-*-* } 32 }
-// { dg-error "deleted function" "" { target *-*-* } 193 }
+// { dg-error "deleted function" "" { target *-*-* } 192 }
// { 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
}
// { dg-error "used here" "" { target *-*-* } 31 }
-// { dg-error "deleted function" "" { target *-*-* } 192 }
+// { dg-error "deleted function" "" { target *-*-* } 191 }
// { 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
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;
}
// 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
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") );
// 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
// 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" }
-// 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
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);
// 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
// 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" }
// 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
// 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" }
// -*- 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
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
done = false;
}
- if (m_p_c != NULL)
+ if (m_p_c)
PB_DS_COND_COMPARE(*m_p_c, m_native_c);
return done;
}
{
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());
{
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());
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());
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());
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());
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());
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());
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(),
{
{
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);
}
}
{
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);
}
}
{
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);
}
}
{
{
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);
}
}
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);
}
// -*- 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
};
// 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);
// -*- 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
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
done = false;
}
- if (m_p_c != NULL)
+ if (m_p_c)
PB_DS_COND_COMPARE(*m_p_c, m_native_c);
return done;
{
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;
{
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;
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());
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());
{
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);
}
}
// -*- 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
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)
//
-// 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
{
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;
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();
// -*- 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
{
// 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;
}
// 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
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();
// -*- 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
bool
write_position()
{
- bool one = this->pptr() != NULL;
+ bool one = this->pptr() != 0;
bool two = this->pptr() < this->epptr();
return one && two;
}
bool
read_position()
{
- bool one = this->gptr() != NULL;
+ bool one = this->gptr() != 0;
bool two = this->gptr() < this->egptr();
return one && two;
}
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;
}
};
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;
// -*- 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
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;
}
forward_iterator_wrapper()
{
- this->ptr = NULL;
- this->SharedInfo = NULL;
+ this->ptr = 0;
+ this->SharedInfo = 0;
}
T&
// -*- 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
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;
}
}
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; }
};
template<typename Container, int Iter>
void*
- do_thread(void* p = NULL)
+ do_thread(void* p = 0)
{
do_loop<Container, Iter>();
return p;
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);
projects / thirdparty / gcc.git / commitdiff
