From 1c9f675fd91d50b9c4eb944481ab6a59386a89c7 Mon Sep 17 00:00:00 2001 From: Ed Smith-Rowland <3dw4rd@verizon.net> Date: Sat, 1 Jun 2013 18:37:47 +0000 Subject: [PATCH] Implement N3642 - User-defined Literals for Standard Library Types 2013-05-30 Ed Smith-Rowland <3dw4rd@verizon.net> Implement N3642 - User-defined Literals for Standard Library Types * include/bits/parse_numbers.h: New. * include/std/chrono: Add duration literal operators. * include/bits/basic_string.h: Add string literal operators. * include/Makefile.in: Add parse_numbers.h. * include/Makefile.am: Ditto. * testsuite/20_util/duration/literals/values.cc: New. * testsuite/20_util/duration/literals/types.cc: New. * testsuite/20_util/duration/requirements/typedefs_neg1.cc: Adjust. * testsuite/20_util/duration/requirements/typedefs_neg2.cc: Adjust. * testsuite/20_util/duration/requirements/typedefs_neg3.cc: Adjust. * testsuite/21_strings/basic_string/literals/values.cc: New. * testsuite/21_strings/basic_string/literals/types.cc: New. From-SVN: r199584 --- libstdc++-v3/ChangeLog | 16 + libstdc++-v3/include/Makefile.am | 1 + libstdc++-v3/include/Makefile.in | 1 + libstdc++-v3/include/bits/basic_string.h | 37 ++ libstdc++-v3/include/bits/parse_numbers.h | 417 ++++++++++++++++++ libstdc++-v3/include/std/chrono | 133 ++++++ .../20_util/duration/literals/types.cc | 74 ++++ .../20_util/duration/literals/values.cc | 69 +++ .../duration/requirements/typedefs_neg1.cc | 2 +- .../duration/requirements/typedefs_neg2.cc | 2 +- .../duration/requirements/typedefs_neg3.cc | 2 +- .../21_strings/basic_string/literals/types.cc | 47 ++ .../basic_string/literals/values.cc | 50 +++ 13 files changed, 848 insertions(+), 3 deletions(-) create mode 100644 libstdc++-v3/include/bits/parse_numbers.h create mode 100644 libstdc++-v3/testsuite/20_util/duration/literals/types.cc create mode 100644 libstdc++-v3/testsuite/20_util/duration/literals/values.cc create mode 100644 libstdc++-v3/testsuite/21_strings/basic_string/literals/types.cc create mode 100644 libstdc++-v3/testsuite/21_strings/basic_string/literals/values.cc diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 85e96a382ce..2ec47f74224 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,19 @@ +2013-05-30 Ed Smith-Rowland <3dw4rd@verizon.net> + + Implement N3642 - User-defined Literals for Standard Library Types + * include/bits/parse_numbers.h: New. + * include/std/chrono: Add duration literal operators. + * include/bits/basic_string.h: Add string literal operators. + * include/Makefile.in: Add parse_numbers.h. + * include/Makefile.am: Ditto. + * testsuite/20_util/duration/literals/values.cc: New. + * testsuite/20_util/duration/literals/types.cc: New. + * testsuite/20_util/duration/requirements/typedefs_neg1.cc: Adjust. + * testsuite/20_util/duration/requirements/typedefs_neg2.cc: Adjust. + * testsuite/20_util/duration/requirements/typedefs_neg3.cc: Adjust. + * testsuite/21_strings/basic_string/literals/values.cc: New. + * testsuite/21_strings/basic_string/literals/types.cc: New. + 2013-05-28 Jonathan Wakely * src/c++11/compatibility-chrono.cc (steady_clock::now()): If diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index e8ef7066bcd..f09300b8bee 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -117,6 +117,7 @@ bits_headers = \ ${bits_srcdir}/move.h \ ${bits_srcdir}/ostream.tcc \ ${bits_srcdir}/ostream_insert.h \ + ${bits_srcdir}/parse_numbers.h \ ${bits_srcdir}/postypes.h \ ${bits_srcdir}/ptr_traits.h \ ${bits_srcdir}/random.h \ diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index 2ba9433bd7d..a090cad9fce 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -379,6 +379,7 @@ bits_headers = \ ${bits_srcdir}/move.h \ ${bits_srcdir}/ostream.tcc \ ${bits_srcdir}/ostream_insert.h \ + ${bits_srcdir}/parse_numbers.h \ ${bits_srcdir}/postypes.h \ ${bits_srcdir}/ptr_traits.h \ ${bits_srcdir}/random.h \ diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h index 23bd9b9c096..a249df23742 100644 --- a/libstdc++-v3/include/bits/basic_string.h +++ b/libstdc++-v3/include/bits/basic_string.h @@ -3106,6 +3106,43 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _GLIBCXX_END_NAMESPACE_VERSION } // namespace +#if __cplusplus > 201103L + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +inline namespace literals { +inline namespace string_literals { + + inline basic_string + operator"" s(const char* __str, size_t __len) + { return basic_string{__str, __len}; } + +#ifdef _GLIBCXX_USE_WCHAR_T + inline basic_string + operator"" s(const wchar_t* __str, size_t __len) + { return basic_string{__str, __len}; } +#endif + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + inline basic_string + operator"" s(const char16_t* __str, size_t __len) + { return basic_string{__str, __len}; } + + inline basic_string + operator"" s(const char32_t* __str, size_t __len) + { return basic_string{__str, __len}; } +#endif + +} // inline namespace string_literals +} // inline namespace literals + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // __cplusplus > 201103L + #endif // C++11 #endif /* _BASIC_STRING_H */ diff --git a/libstdc++-v3/include/bits/parse_numbers.h b/libstdc++-v3/include/bits/parse_numbers.h new file mode 100644 index 00000000000..eaa3d27a18a --- /dev/null +++ b/libstdc++-v3/include/bits/parse_numbers.h @@ -0,0 +1,417 @@ +// Components for compile-time parsing of numbers -*- C++ -*- + +// Copyright (C) 2013 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 of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/parse_numbers.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{chrono} + */ + +#ifndef _PARSE_NUMBERS_H +#define _PARSE_NUMBERS_H 1 + +#pragma GCC system_header + +// From n3642.pdf except I added binary literals and digit separator '`'. + +#if __cplusplus > 201103L + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +namespace __parse_int { + + template + struct _Digit; + + template + struct _Digit<_Base, '0'> + { + static constexpr bool valid{true}; + static constexpr unsigned value{0}; + }; + + template + struct _Digit<_Base, '1'> + { + static constexpr bool valid{true}; + static constexpr unsigned value{1}; + }; + + template + struct _Digit<_Base, '2'> + { + static_assert(_Base > 2, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{2}; + }; + + template + struct _Digit<_Base, '3'> + { + static_assert(_Base > 3, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{3}; + }; + + template + struct _Digit<_Base, '4'> + { + static_assert(_Base > 4, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{4}; + }; + + template + struct _Digit<_Base, '5'> + { + static_assert(_Base > 5, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{5}; + }; + + template + struct _Digit<_Base, '6'> + { + static_assert(_Base > 6, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{6}; + }; + + template + struct _Digit<_Base, '7'> + { + static_assert(_Base > 7, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{7}; + }; + + template + struct _Digit<_Base, '8'> + { + static_assert(_Base > 8, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{8}; + }; + + template + struct _Digit<_Base, '9'> + { + static_assert(_Base > 9, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{9}; + }; + + template + struct _Digit<_Base, 'a'> + { + static_assert(_Base > 0xa, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xa}; + }; + + template + struct _Digit<_Base, 'A'> + { + static_assert(_Base > 0xa, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xa}; + }; + + template + struct _Digit<_Base, 'b'> + { + static_assert(_Base > 0xb, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xb}; + }; + + template + struct _Digit<_Base, 'B'> + { + static_assert(_Base > 0xb, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xb}; + }; + + template + struct _Digit<_Base, 'c'> + { + static_assert(_Base > 0xc, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xc}; + }; + + template + struct _Digit<_Base, 'C'> + { + static_assert(_Base > 0xc, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xc}; + }; + + template + struct _Digit<_Base, 'd'> + { + static_assert(_Base > 0xd, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xd}; + }; + + template + struct _Digit<_Base, 'D'> + { + static_assert(_Base > 0xd, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xd}; + }; + + template + struct _Digit<_Base, 'e'> + { + static_assert(_Base > 0xe, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xe}; + }; + + template + struct _Digit<_Base, 'E'> + { + static_assert(_Base > 0xe, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xe}; + }; + + template + struct _Digit<_Base, 'f'> + { + static_assert(_Base > 0xf, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xf}; + }; + + template + struct _Digit<_Base, 'F'> + { + static_assert(_Base > 0xf, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xf}; + }; + + // Digit separator + template + struct _Digit<_Base, '`'> + { + static constexpr bool valid{false}; + static constexpr unsigned value{0}; + }; + + +//------------------------------------------------------------------------------ + + template + struct _Digits_help + { + static constexpr unsigned + value{_Digit<_Base, _Dig>::valid ? + 1U + _Digits_help<_Base, _Digs...>::value : + _Digits_help<_Base, _Digs...>::value}; + }; + + template + struct _Digits_help<_Base, _Dig> + { + static constexpr unsigned value{_Digit<_Base, _Dig>::valid ? 1U : 0U}; + }; + + template + struct _Digits + { + static constexpr unsigned value{_Digits_help<_Base, _Digs...>::value}; + }; + + template + struct _Digits<_Base> + { + static constexpr unsigned value{0U}; + }; + +//------------------------------------------------------------------------------ + + template + struct _Power_help + { + static constexpr unsigned + value{_Digit<_Base, _Dig>::valid ? + _Base * _Power_help<_Base, _Digs...>::value : + _Power_help<_Base, _Digs...>::value}; + }; + + template + struct _Power_help<_Base, _Dig> + { + static constexpr unsigned value{_Digit<_Base, _Dig>::valid ? 1U : 0U}; + }; + + template + struct _Power + { + static constexpr unsigned value{_Power_help<_Base, _Digs...>::value}; + }; + + template + struct _Power<_Base> + { + static constexpr unsigned value{0U}; + }; + +//------------------------------------------------------------------------------ + + template + struct _Number_help + { + static constexpr unsigned + value{_Digit<_Base, _Dig>::valid ? + _Pow * _Digit<_Base, _Dig>::value + + _Number_help<_Base, _Pow / _Base, _Digs...>::value : + _Number_help<_Base, _Pow, _Digs...>::value}; + }; + + template + struct _Number_help<_Base, _Pow, _Dig> + { + //static_assert(_Pow == 1U, "power should be one"); + static constexpr unsigned + value{_Digit<_Base, _Dig>::valid ? _Digit<_Base, _Dig>::value : 0U}; + }; + + template + struct _Number + { + static constexpr unsigned + value{_Number_help<_Base, _Power<_Base, _Digs...>::value, + _Digs...>::value}; + }; + + template + struct _Number<_Base> + { + static constexpr unsigned value{0U}; + }; + +//------------------------------------------------------------------------------ +// This _Parse_int is the same 'level' as the old _Base_dispatch. + + template + struct _Parse_int; + + template + struct _Parse_int<'0', 'b', _Digs...> + { + static constexpr unsigned long long + value{_Number<2U, _Digs...>::value}; + }; + + template + struct _Parse_int<'0', 'B', _Digs...> + { + static constexpr unsigned long long + value{_Number<2U, _Digs...>::value}; + }; + + template + struct _Parse_int<'0', 'x', _Digs...> + { + static constexpr unsigned long long + value{_Number<16U, _Digs...>::value}; + }; + + template + struct _Parse_int<'0', 'X', _Digs...> + { + static constexpr unsigned long long + value{_Number<16U, _Digs...>::value}; + }; + + template + struct _Parse_int<'0', _Digs...> + { + static constexpr unsigned long long + value{_Number<8U, _Digs...>::value}; + }; + + template + struct _Parse_int + { + static constexpr unsigned long long + value{_Number<10U, _Digs...>::value}; + }; + +} // namespace __parse_int + + +namespace __select_int { + + template + struct _Select_int_base; + + template + struct _Select_int_base<_Val, _IntType, _Ints...> + : integral_constant + < + typename conditional + < + _Val <= static_cast + (std::numeric_limits<_IntType>::max()), + _IntType, + typename _Select_int_base<_Val, _Ints...>::value_type + >::type, + _Val + > + { }; + + template + struct _Select_int_base<_Val> : integral_constant + { }; + + template + struct _Select_int + : _Select_int_base< + __parse_int::_Parse_int<_Digs...>::value, + unsigned char, + unsigned short, + unsigned int, + unsigned long, + unsigned long long + > + { }; + +} // namespace __select_int + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // __cplusplus > 201103L + +#endif // _PARSE_NUMBERS_H diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono index 6d9df7d7dda..f4c4ef017e6 100644 --- a/libstdc++-v3/include/std/chrono +++ b/libstdc++-v3/include/std/chrono @@ -39,6 +39,7 @@ #include #include #include +#include // for literals support. #ifdef _GLIBCXX_USE_C99_STDINT_TR1 @@ -786,4 +787,136 @@ _GLIBCXX_END_NAMESPACE_VERSION #endif // C++11 +#if __cplusplus > 201103L + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +inline namespace literals { +inline namespace chrono_literals { + + namespace __detail { + + using namespace __parse_int; + + template + struct _Select_type + : conditional< + _Val <= static_cast + (numeric_limits::max()), + _Dur, void> + { + static constexpr typename _Select_type::type + value{static_cast(_Val)}; + }; + + template + constexpr typename _Select_type<_Val, _Dur>::type + _Select_type<_Val, _Dur>::value; + + } // __detail + + inline constexpr chrono::duration> + operator"" h(long double __hours) + { return chrono::duration>{__hours}; } + + template + inline constexpr typename + __detail::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::hours>::type + operator"" h() + { + return __detail::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::hours>::value; + } + + inline constexpr chrono::duration> + operator"" min(long double __mins) + { return chrono::duration>{__mins}; } + + template + inline constexpr typename + __detail::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::minutes>::type + operator"" min() + { + return __detail::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::minutes>::value; + } + + inline constexpr chrono::duration + operator"" s(long double __secs) + { return chrono::duration{__secs}; } + + template + inline constexpr typename + __detail::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::seconds>::type + operator"" s() + { + return __detail::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::seconds>::value; + } + + inline constexpr chrono::duration + operator"" ms(long double __msecs) + { return chrono::duration{__msecs}; } + + template + inline constexpr typename + __detail::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::milliseconds>::type + operator"" ms() + { + return __detail::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::milliseconds>::value; + } + + inline constexpr chrono::duration + operator"" us(long double __usecs) + { return chrono::duration{__usecs}; } + + template + inline constexpr typename + __detail::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::microseconds>::type + operator"" us() + { + return __detail::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::microseconds>::value; + } + + inline constexpr chrono::duration + operator"" ns(long double __nsecs) + { return chrono::duration{__nsecs}; } + + template + inline constexpr typename + __detail::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::nanoseconds>::type + operator"" ns() + { + return __detail::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::nanoseconds>::value; + } + +} // inline namespace chrono_literals +} // inline namespace literals + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif //_GLIBCXX_USE_C99_STDINT_TR1 + +#endif // __cplusplus > 201103L + #endif //_GLIBCXX_CHRONO diff --git a/libstdc++-v3/testsuite/20_util/duration/literals/types.cc b/libstdc++-v3/testsuite/20_util/duration/literals/types.cc new file mode 100644 index 00000000000..67ef2faf292 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/duration/literals/types.cc @@ -0,0 +1,74 @@ +// { dg-options "-std=gnu++1y" } +// { dg-do compile } + +// Copyright (C) 2013 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 of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// NOTE: This makes use of the fact that we know how moveable +// is implemented on string (via swap). If the implementation changed +// this test may begin to fail. + +#include +#include + +void +test03() +{ + using namespace std::literals::chrono_literals; + + static_assert(std::is_same::value, + "1h is std::chrono::hours"); + + static_assert(std::is_same>>::value, + "1.0h is std::chrono::duration>"); + + static_assert(std::is_same::value, + "1min is std::chrono::minutes"); + + static_assert(std::is_same>>::value, + "1.0min is std::chrono::duration>"); + + static_assert(std::is_same::value, + "1s is std::chrono::seconds"); + + static_assert(std::is_same>>::value, + "1.0s is std::chrono::duration>"); + + static_assert(std::is_same::value, + "1ms is std::chrono::milliseconds"); + + static_assert(std::is_same>>::value, + "1.0ms is std::chrono::duration>"); + + static_assert(std::is_same::value, + "1us is std::chrono::microseconds"); + + static_assert(std::is_same>>::value, + "1.0us is std::chrono::duration>"); + + static_assert(std::is_same::value, + "1ns is std::chrono::nanoseconds"); + + static_assert(std::is_same>>::value, + "1.0ns is std::chrono::duration>"); +} diff --git a/libstdc++-v3/testsuite/20_util/duration/literals/values.cc b/libstdc++-v3/testsuite/20_util/duration/literals/values.cc new file mode 100644 index 00000000000..37bbbd02cb7 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/duration/literals/values.cc @@ -0,0 +1,69 @@ +// { dg-do run } +// { dg-options "-std=gnu++1y" } + +// Copyright (C) 2013 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 of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// NOTE: This makes use of the fact that we know how moveable +// is implemented on string (via swap). If the implementation changed +// this test may begin to fail. + +#include +#include + +void +test03() +{ + using namespace std::literals::chrono_literals; + + auto jiffy = 23ns; + VERIFY( jiffy == std::chrono::nanoseconds(23) ); + auto fjiffy = 23.0ns; + VERIFY( (fjiffy == std::chrono::duration(23.0L)) ); + auto blip = 14us; + VERIFY( blip == std::chrono::microseconds(14) ); + auto fblip = 14.0us; + VERIFY( (fblip == std::chrono::duration(14.0L)) ); + auto bit = 77ms; + VERIFY( bit == std::chrono::milliseconds(77) ); + auto fbit = 77.0ms; + VERIFY( (fbit == std::chrono::duration(77.0L)) ); + auto warmup = 33s; + VERIFY( warmup == std::chrono::seconds(33) ); + auto fwarmup = 33.0s; + VERIFY( (fwarmup == std::chrono::duration>(33.0L)) ); + auto classtime = 50min; + VERIFY( classtime == std::chrono::minutes(50) ); + auto fclasstime = 50.0min; + VERIFY( (fclasstime == std::chrono::duration>(50.0L)) ); + auto longtime = 1h + 30min; + VERIFY( longtime == std::chrono::minutes(90) ); + auto flongtime = 1.0h + 30.0min; + VERIFY( (flongtime == std::chrono::duration>(1.0L) + + std::chrono::duration>(30.0L)) ); + VERIFY( (flongtime == std::chrono::duration>(90.0L)) ); + auto workday = 8h; + VERIFY( workday == std::chrono::hours(8) ); + auto fworkday = 8.0h; + VERIFY( (fworkday == std::chrono::duration>(8.0L)) ); +} + +int +main() +{ + test03(); +} diff --git a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg1.cc b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg1.cc index 1b686e476cf..db4237991bf 100644 --- a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg1.cc +++ b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg1.cc @@ -31,5 +31,5 @@ void test01() test_type d; } -// { dg-error "rep cannot be a duration" "" { target *-*-* } 245 } +// { dg-error "rep cannot be a duration" "" { target *-*-* } 246 } // { dg-error "required from here" "" { target *-*-* } 31 } diff --git a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc index 2cc5cd68e0a..8da5dbff431 100644 --- a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc +++ b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc @@ -32,5 +32,5 @@ void test01() test_type d; // { dg-error "required from here" } } -// { dg-error "must be a specialization of ratio" "" { target *-*-* } 246 } +// { dg-error "must be a specialization of ratio" "" { target *-*-* } 247 } // { dg-prune-output "not a member" } diff --git a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg3.cc b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg3.cc index a9313ccb2cc..4837f5d64fc 100644 --- a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg3.cc +++ b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg3.cc @@ -33,5 +33,5 @@ void test01() test_type d; } -// { dg-error "period must be positive" "" { target *-*-* } 248 } +// { dg-error "period must be positive" "" { target *-*-* } 249 } // { dg-error "required from here" "" { target *-*-* } 33 } diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/literals/types.cc b/libstdc++-v3/testsuite/21_strings/basic_string/literals/types.cc new file mode 100644 index 00000000000..677f5bf8560 --- /dev/null +++ b/libstdc++-v3/testsuite/21_strings/basic_string/literals/types.cc @@ -0,0 +1,47 @@ +// { dg-options "-std=gnu++1y" } +// { dg-do compile } + +// Copyright (C) 2013 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 of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// NOTE: This makes use of the fact that we know how moveable +// is implemented on string (via swap). If the implementation changed +// this test may begin to fail. + +#include +#include + +void +test01() +{ + using namespace std::literals::string_literals; + + static_assert(std::is_same::value, + "\"Hello\"s is std::string"); + + static_assert(std::is_same::value, + "u8\"Hello\"s is std::string"); + + static_assert(std::is_same::value, + "L\"Hello\"s is std::wstring"); + + static_assert(std::is_same::value, + "u\"Hello\"s is std::u16string"); + + static_assert(std::is_same::value, + "U\"Hello\"s is std::u32string"); +} diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/literals/values.cc b/libstdc++-v3/testsuite/21_strings/basic_string/literals/values.cc new file mode 100644 index 00000000000..09285590e2a --- /dev/null +++ b/libstdc++-v3/testsuite/21_strings/basic_string/literals/values.cc @@ -0,0 +1,50 @@ +// { dg-do run } +// { dg-options "-std=gnu++1y" } + +// Copyright (C) 2013 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 of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// NOTE: This makes use of the fact that we know how moveable +// is implemented on string (via swap). If the implementation changed +// this test may begin to fail. + +#include +#include + +void +test01() +{ + using namespace std::literals::string_literals; + + std::string planet = "Mercury"s; + std::wstring wplanet = L"Venus"s; + std::string u8planet = u8"Mars"s; + std::u16string u16planet = u"Juiter"s; + std::u32string u32planet = U"Saturn"s; + + VERIFY( planet == std::string("Mercury") ); + VERIFY( wplanet == std::wstring(L"Venus") ); + VERIFY( u8planet == std::string(u8"Mars") ); + VERIFY( u16planet == std::u16string(u"Juiter") ); + VERIFY( u32planet == std::u32string(U"Saturn") ); +} + +int +main() +{ + test01(); +} -- 2.30.2