tree 96b72811d60eb32fc711ca58101056b6d33b904b
parent 6d6e786e0f55d99f1a163b2880a29573f5fbd1e9
author Travis Vitek <vitek@apache.org> 1214414683 +0000
committer Travis Vitek <vitek@apache.org> 1214414683 +0000


2008-06-24  Travis Vitek  <vitek@roguewave.com>

	Merge r659253, r662845, r662846, r662858, r662906, r663373,
	      r663377, r663410, r664133, r664234 and r664236 from
		  branches/4.2.x.

	2008-06-03  Eric Lemings <eric.lemings@roguewave.com>

	STDCXX-550
	* tests/iostream/27.istream.manip.cpp (test_ws): Cast RHS
	`err_after' from `size_t' type to `int' type of LHS
	`Streambuf::throw_after_' and `Streambuf::fail_after_' members.
	(No easy way to change the type of either side.)
	* tests/iostream/27.istream.unformatted.get.cpp (check_failure):
	Change `actual' type from `int' to `std::streamsize' result type
	of expression in RHS of assignment.
	(test_get_void, test_get_char, test_get_char_array)
	(test_get_streambuf): Cast `gcount' argument to `int' used by
	6th parameter in `check_failure()' function.
	(test_get_char_array<charT, Traits>): Use `int' type instead of
	`std::streamsize' since `test_get_char_array()' function doesn't
	use the latter for parameter types.
	* tests/iostream/27.stringbuf.virtuals.cpp (PubBuf::capacity):
	Cast result of pointer arithmetic expression to `int' return
	type of function.
	(test_virtual): Explicitly cast RHS of assignment `warg_len' to
	`int' type of LHS `arg0'.  Also cast `arg0' to `std::streamsize'
	type for 2nd parameter in `std::streambuf<T>::sputn()' function.
	Cast return type of said function to `int' type of LHS `ret'
	variable.
	(test_xsputn)[TEST]: Cast result of `sizeof' expression to
	`int' type used by 7th parameter of `test_virtual' function.
	* tests/iostream/27.filebuf.codecvt.cpp (cformat::do_length):
	Cast result of pointer arithmetic expression to `int' return
	type of function.
	(run_test): Change `buflen' type from `int' to `std::size_t'
	to hold result of `strlen()' function.

	* tests/localization/22.locale.codecvt.mt.cpp (thread_func):
	Change `inx' type from `int' to `std::size_t' for `nlocales'.
	* tests/localization/22.locale.time.get.cpp (test_english): Cast
	return value of `strftime()' function to `int' type used by
	corresponding parameter in `do_test()' function.
	* tests/localization/22.locale.money.put.mt.cpp (MyMoneyData):
	Change type of `money_index_' member from `unsigned' to `size_t'.

	* tests/regress/21.string.io.stdcxx-206.cpp (test): Replaced
	`sizeof(buf)' expression with `bufsize' enumerator.
	* tests/regress/27.stringbuf.overflow.stdcxx-149.cpp (main):
	Cast result of pointer arithmetic to `int' type for
	`write_positions' in LHS of copy assignment.

	* tests/utilities/20.operators.cpp (RandomNumberGenerator):
	Change parameter type of RNG from hard-coded `int' to template
	parameter `T'.
	(test_random_access_iterators): Instantiate RNG using difference
	type of iterator rather than value type as specified by
	`random_shuffle' requirements.

	* examples/include/teller.h, examples/tutorial/teller.cpp:
	Change return type of `lcg_rand()' function from 'unsigned long'
	to plain `int'.  (It's already explicitly cast in the return
	statement to an `int' anyways.)

	2008-06-03  Martin Sebor  <sebor@roguewave.com>

	* tests/regress/21.c.strings.stdcxx-843.cpp [!_RWSTD_MBSTATE_T_SIZE]
	(<rw/_defs.h>): Explicitly #included in case none of the previously
	#included headers does so (i.e., we're using the compiler's C++ C
	headers).

	2008-06-03  Eric Lemings <eric.lemings@roguewave.com>

	STDCXX-488
	* etc/config/GNUmakefile.tst (LDFLAGS): Use appropriate form of
	RPATH options in LDFLAGS variable on Darwin platforms.
	* etc/config/gcc.config: Retrieve major OS version on Darwin
	platforms and use @rpath in -install_name flag if building
	on Darwin 9.x (Mac OS 10.5).  Use only library basename for all
	other versions of Darwin.  Also define RPATH variable on Darwin.
	2008-06-03  Eric Lemings <eric.lemings@roguewave.com>

	STDCXX-810
	* tests/include/alg_test.h, tests/include/environ.h,
	tests/include/testdefs.h tests/include/any.h,
	tests/include/driver.h, tests/include/file.h,
	tests/include/valcmp.h, tests/include/cmdopt.h: Renamed using
	`rw_' prefix.

	* tests/include/21.strings.h, tests/include/23.list.h,
	tests/include/23.containers.h: Replaced `21.' and `23.' prefixes
	with `rw_' prefix.  Also changed `list' to `lists' since the
	other two headers are also plural.

	* Updated #include directives where necessary in all test driver
	and test suite header and source files (too many to list).

	2008-06-04  Travis Vitek  <vitek@roguewave.com>

	STDCXX-901
	* include/valarray (gslice_array<>::operator=): Don't skip
	loop body if the slice is reset but has one element.
	(gslice_array<>::operator*=): Ditto.
	(gslice_array<>::operator/=): Ditto.
	(gslice_array<>::operator+=): Ditto.
	(gslice_array<>::operator-=): Ditto.
	(gslice_array<>::operator%=): Ditto.
	(gslice_array<>::operator^=): Ditto.
	(gslice_array<>::operator&=): Ditto.
	(gslice_array<>::operator|=): Ditto.
	(gslice_array<>::operator<<=): Ditto.
	(gslice_array<>::operator>>=): Ditto.
	(valarray<>::ctor): Ditto.
	(valarray<>::operator=): Ditto.
	* tests/numerics/26.gslice.array.cassign.cpp: New test
	for slice computed assignment operators.

	2008-06-04  Travis Vitek  <vitek@roguewave.com>

	STDCXX-955
	* include/valarray: Correctly calculate	indices when the
	length array contains a zero.
	* src/valarray.cpp: Ditto.
	* tests/numerics/26.class.gslice.cpp (make_array): Update to
	handle empty strings or other poorly formatted input.
	(get_array_size, next_index): Correctly calculate indices
	when the slice length array contains a zero.
	(test_gslice): Remove unnecessary line feed from assertion.
	(run_test): Update degenerate testcase to match comment.
	* tests/regress/26.valarray.sub.stdcxx-995.cpp: Add new
	regression test.

	2008-06-04  Travis Vitek  <vitek@roguewave.com>

	STDCXX-872
	* tests/support/18.support.rtti.cpp [__IBMCPP__]: Avoid
	testing typeid() if rtti support is disabled.

	2008-06-06  Travis Vitek  <vitek@roguewave.com>

	STDCXX-955
	* tests/regress/26.valarray.sub.stdcxx-955.cpp: Fix copyright date.
	Test both conditions mentioned in original bug to ensure that code
	is completely fixed.

	2008-06-06  Travis Vitek  <vitek@roguewave.com>

	* tests/numerics/26.gslice.array.cassign.cpp: Update include
	directives to be consistent with r662858

	2008-05-22  Eric Lemings <eric.lemings@roguewave.com>

	STDCXX-550
	* src/num_put.cpp (__rw_itoa): Silence 64-bit conversion warning
	with explicit cast to `unsigned' type.

	* tests/src/locale.cpp (rw_locales, _rw_all_locales),
	util/runall.cpp (main), util/aliases.cpp (get_installed_locales):
	Silence 64-bit conversion warnings by explicitly casting `size_t'
	result from `sizeof' operator to `int' type expected by second
	size parameter in fgets() function.
	* tests/src/thread.cpp (rw_thread_pool): First parameter in
	rw_alarm() is `unsigned'.  Explicit cast `size_t' timeout value
	to silence warning.
	* tests/src/value.cpp (_rw_fmtxarrayv): Explicitly cast `long'
	return value from strtol() function to `int' to silence warning.
	* tests/src/char.cpp (_rw_fmtstringv): Likewise.
	* tests/src/rand.cpp (rw_seed32): Explicitly cast `clock_t'
	return value from clock() function to `unsigned' value.
	* tests/src/cmdopt.cpp (_rw_getbounds, _rw_getarg): Explicitly
	cast `long' value to `int' type of minval_, maxval_, and pcntr_
	members.
	* tests/src/23.containers.cpp (_rw_sigcat, _rw_argno): Explicitly
	cast `which' value from `size_t' type to `int' type used by
	`argmap' variable.
	* tests/src/opt_lines.cpp (_rw_enable_lines): Explicitly cast
	`first' value from `long' type to `int' type used by first
	parameter of _rw_enable_lines() function.
	* tests/src/process.cpp (rw_waitpid): Explicitly cast PID from
	`rw_pid_t' type to system `pid_t' type used by first parameter
	of waitpid() function.  Also cast `time_t' expression to `int'
	type of local variable `delta'.
	(rw_process_kill): Cast `size_t' expression to `unsigned' type
	of `sigcount' variable.  Cast `rw_pid_t' value to system's
	`pid_t' type used by first parameter of kill() function.
	* tests/src/opt_trace.cpp (_rw_setopt_trace_mask): Changed type
	of loop index from `int' to `long'.

	* tests/algorithms/25.generate.cpp (test_generate_n): Explicitly
	convert `size_t' value to `int' type to silence 64-bit conversion
	warnings.
	* tests/algorithms/25.fill.cpp (test_fill_n): First parameter in
	`Size' constructor should be an `int'.
	* tests/algorithms/25.random.shuffle.cpp (test_random_shuffle):
	Change line parameter from `size_t' type to `int' type.

	* tests/containers/23.deque.modifiers.cpp: Explicitly cast
	expressions involving `UserClass::n_total_copy_ctor_' and
	`UserClass::n_total_op_assign_' members to `int' type of lhs of
	assignment.
	(test_erase): Cast `size_t' argument used as 7th parameter in
	exception_loop() function to `int' type.
	* tests/containers/23.bitset.cons.cpp (test_string_ctor): Cast
	result of pointer arithmetic expression to `int' type of rhs of
	assignment operator.
	* tests/containers/23.vector.cons.cpp (test_ctors): Assign to
	`val' using temporary `T' value constructed from `i' rather than
	directly from `i'.

	* tests/localization/22.locale.synopsis.cpp (test_locale): Change
	loop index type from `unsigned' to `size_t' resulting from
	pointer arithmetic in initializer.
	* tests/localization/22.locale.codecvt.length.cpp
	(test_wcodecvt_byname_libc_based) [TEST]: Next to last parameter
	type in test_length() function is an `int', not `size_t'.
	* tests/localization/22.locale.num.get.cpp (test_errno)
	[TEST_ERRNO]: Fourth from last parameter type in do_test()
	function is an `int'.  Cast `size_t' result of sizeof operator.
	(test_long): Cast `size_t' result from sizeof operator to
	`int' type of local `NC' variable.  Define INTSIZE() macro to
	cast `size_t' result from sizeof operator to `int' type in test
	cases.  (This parameter defaults to negative value or its type
	would be changed to `size_t' type.)
	(test_pvoid) [PVOIDSTR], (test_ldbl): Use INSTIZE() macro.

	* tests/numerics/26.c.math.cpp (check_bits): Changed `unsigned'
	parameter type to `size_t' parameter type.
	(test_behavior):  Remove SIZE() macro and replaced with sizeof
	operator.

	* tests/regress/24.operations.stdcxx-234.cpp (main): Cast
	iterator `difference_type' to return type of main() function.

	* tests/strings/21.string.io.cpp (test_io): Cast rhs of
	assignments to `int' type of `throw_when_' array elements.

	* util/monetary.cpp (Def::write_monetary): Cast expressions in
	rhs of assignments to `unsigned' type of `_RW::__rw_punct_t'
	members.
	* util/time.cpp (Def::write_time): Ditto for `time_out_` members.
	* util/locale.cpp (print_toupper, print_tolower): Cast return
	value of _RW::__rw_ctype_t::wtoupper_s() function to `int'
	return type of function.
	(print_charmap): Change loop index type from `size_t' to
	`unsigned'.
	* util/numeric.cpp (Def::write_numeric): Same change as above
	to monetary and time for `num_punct_out_' members.
	* util/messages.cpp (Def::write_messages): Same change as above
	to monetary, time, and numeric for 'messages_out_' members.
	* util/ctype.cpp (Def::write_ctype): Same change as facets above.
	* util/exec.cpp (get_signo): Cast return type from strtol()
	function to `int' return type of function.
	* util/cmdopt.cpp: Explicitly cast return value of sysconf()
	function to `float' type used by `TICKS_PER_SEC' global.
	(eval_options): Cast return value of strtol() function to
	`unsigned' type.  Second parameter of get_long_val() function
	expects `unsigned' type (go figure).  Cast return value of
	sizeof operator.  exit() function expects `int' status code.
	Parameter type of rw_sleep() function is `int'.
	* util/codecvt.cpp (gen_wchar_tables, gen_xlit_data): Cast
	string::size_type values to `unsigned' type of offset variables.  
	(write_codecvt): Add UINT() macro for casting values to
	`unsigned' type expected by lhs of several assignments. 
	* util/charmap.cp (Charmap::increment_wchar): Cast
	string::size_type values to `int' type of local `last_elm' which
	can be negative.
	(increment_encoding): Cast return value of convert_escape()
	function to `unsigned' type of `last_byte' variable.
	* util/collate.cpp (Def::process_weights): Change loop index
	type from `size_t' to `int'.
	(Def::write_collate): Cast wstring::size_type and size of
	intrinsic types to `unsigned' type.  Also moved definition of
	local variable `i' closer to point of use.
	(Def::get_weight): Changed type of local `c' from `size_t' to
	`unsigned'.  Cast return value of convert_escape() function to
	`unsigned' type of `weight' array elements.

	* examples/manual/strstream.cpp (main): Change local `gcount'
	variable from `int' type to `std::streamsize' type.


git-svn-id: https://svn.apache.org/repos/asf/stdcxx/trunk@671608 13f79535-47bb-0310-9956-ffa450edef68
