libstdc++
parse_numbers.h
Go to the documentation of this file.
1 // Components for compile-time parsing of numbers -*- C++ -*-
2 
3 // Copyright (C) 2013-2019 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file bits/parse_numbers.h
26  * This is an internal header file, included by other library headers.
27  * Do not attempt to use it directly. @headername{chrono}
28  */
29 
30 #ifndef _GLIBCXX_PARSE_NUMBERS_H
31 #define _GLIBCXX_PARSE_NUMBERS_H 1
32 
33 #pragma GCC system_header
34 
35 // From n3642.pdf except I added binary literals and digit separator '\''.
36 
37 #if __cplusplus > 201103L
38 
39 #include <limits>
40 
41 namespace std _GLIBCXX_VISIBILITY(default)
42 {
43 _GLIBCXX_BEGIN_NAMESPACE_VERSION
44 
45 namespace __parse_int
46 {
47  template<unsigned _Base, char _Dig>
48  struct _Digit;
49 
50  template<unsigned _Base>
51  struct _Digit<_Base, '0'> : integral_constant<unsigned, 0>
52  {
53  using __valid = true_type;
54  };
55 
56  template<unsigned _Base>
57  struct _Digit<_Base, '1'> : integral_constant<unsigned, 1>
58  {
59  using __valid = true_type;
60  };
61 
62  template<unsigned _Base, unsigned _Val>
63  struct _Digit_impl : integral_constant<unsigned, _Val>
64  {
65  static_assert(_Base > _Val, "invalid digit");
66  using __valid = true_type;
67  };
68 
69  template<unsigned _Base>
70  struct _Digit<_Base, '2'> : _Digit_impl<_Base, 2>
71  { };
72 
73  template<unsigned _Base>
74  struct _Digit<_Base, '3'> : _Digit_impl<_Base, 3>
75  { };
76 
77  template<unsigned _Base>
78  struct _Digit<_Base, '4'> : _Digit_impl<_Base, 4>
79  { };
80 
81  template<unsigned _Base>
82  struct _Digit<_Base, '5'> : _Digit_impl<_Base, 5>
83  { };
84 
85  template<unsigned _Base>
86  struct _Digit<_Base, '6'> : _Digit_impl<_Base, 6>
87  { };
88 
89  template<unsigned _Base>
90  struct _Digit<_Base, '7'> : _Digit_impl<_Base, 7>
91  { };
92 
93  template<unsigned _Base>
94  struct _Digit<_Base, '8'> : _Digit_impl<_Base, 8>
95  { };
96 
97  template<unsigned _Base>
98  struct _Digit<_Base, '9'> : _Digit_impl<_Base, 9>
99  { };
100 
101  template<unsigned _Base>
102  struct _Digit<_Base, 'a'> : _Digit_impl<_Base, 0xa>
103  { };
104 
105  template<unsigned _Base>
106  struct _Digit<_Base, 'A'> : _Digit_impl<_Base, 0xa>
107  { };
108 
109  template<unsigned _Base>
110  struct _Digit<_Base, 'b'> : _Digit_impl<_Base, 0xb>
111  { };
112 
113  template<unsigned _Base>
114  struct _Digit<_Base, 'B'> : _Digit_impl<_Base, 0xb>
115  { };
116 
117  template<unsigned _Base>
118  struct _Digit<_Base, 'c'> : _Digit_impl<_Base, 0xc>
119  { };
120 
121  template<unsigned _Base>
122  struct _Digit<_Base, 'C'> : _Digit_impl<_Base, 0xc>
123  { };
124 
125  template<unsigned _Base>
126  struct _Digit<_Base, 'd'> : _Digit_impl<_Base, 0xd>
127  { };
128 
129  template<unsigned _Base>
130  struct _Digit<_Base, 'D'> : _Digit_impl<_Base, 0xd>
131  { };
132 
133  template<unsigned _Base>
134  struct _Digit<_Base, 'e'> : _Digit_impl<_Base, 0xe>
135  { };
136 
137  template<unsigned _Base>
138  struct _Digit<_Base, 'E'> : _Digit_impl<_Base, 0xe>
139  { };
140 
141  template<unsigned _Base>
142  struct _Digit<_Base, 'f'> : _Digit_impl<_Base, 0xf>
143  { };
144 
145  template<unsigned _Base>
146  struct _Digit<_Base, 'F'> : _Digit_impl<_Base, 0xf>
147  { };
148 
149  // Digit separator
150  template<unsigned _Base>
151  struct _Digit<_Base, '\''> : integral_constant<unsigned, 0>
152  {
153  using __valid = false_type;
154  };
155 
156 //------------------------------------------------------------------------------
157 
158  template<unsigned long long _Val>
159  using __ull_constant = integral_constant<unsigned long long, _Val>;
160 
161  template<unsigned _Base, char _Dig, char... _Digs>
162  struct _Power_help
163  {
164  using __next = typename _Power_help<_Base, _Digs...>::type;
165  using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
166  using type
167  = __ull_constant<__next::value * (__valid_digit{} ? _Base : 1ULL)>;
168  };
169 
170  template<unsigned _Base, char _Dig>
171  struct _Power_help<_Base, _Dig>
172  {
173  using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
174  using type = __ull_constant<__valid_digit::value>;
175  };
176 
177  template<unsigned _Base, char... _Digs>
178  struct _Power : _Power_help<_Base, _Digs...>::type
179  { };
180 
181  template<unsigned _Base>
182  struct _Power<_Base> : __ull_constant<0>
183  { };
184 
185 //------------------------------------------------------------------------------
186 
187  template<unsigned _Base, unsigned long long _Pow, char _Dig, char... _Digs>
188  struct _Number_help
189  {
190  using __digit = _Digit<_Base, _Dig>;
191  using __valid_digit = typename __digit::__valid;
192  using __next = _Number_help<_Base,
193  __valid_digit::value ? _Pow / _Base : _Pow,
194  _Digs...>;
195  using type = __ull_constant<_Pow * __digit::value + __next::type::value>;
196  static_assert((type::value / _Pow) == __digit::value,
197  "integer literal does not fit in unsigned long long");
198  };
199 
200  // Skip past digit separators:
201  template<unsigned _Base, unsigned long long _Pow, char _Dig, char..._Digs>
202  struct _Number_help<_Base, _Pow, '\'', _Dig, _Digs...>
203  : _Number_help<_Base, _Pow, _Dig, _Digs...>
204  { };
205 
206  // Terminating case for recursion:
207  template<unsigned _Base, char _Dig>
208  struct _Number_help<_Base, 1ULL, _Dig>
209  {
210  using type = __ull_constant<_Digit<_Base, _Dig>::value>;
211  };
212 
213  template<unsigned _Base, char... _Digs>
214  struct _Number
215  : _Number_help<_Base, _Power<_Base, _Digs...>::value, _Digs...>::type
216  { };
217 
218  template<unsigned _Base>
219  struct _Number<_Base>
220  : __ull_constant<0>
221  { };
222 
223 //------------------------------------------------------------------------------
224 
225  template<char... _Digs>
226  struct _Parse_int;
227 
228  template<char... _Digs>
229  struct _Parse_int<'0', 'b', _Digs...>
230  : _Number<2U, _Digs...>::type
231  { };
232 
233  template<char... _Digs>
234  struct _Parse_int<'0', 'B', _Digs...>
235  : _Number<2U, _Digs...>::type
236  { };
237 
238  template<char... _Digs>
239  struct _Parse_int<'0', 'x', _Digs...>
240  : _Number<16U, _Digs...>::type
241  { };
242 
243  template<char... _Digs>
244  struct _Parse_int<'0', 'X', _Digs...>
245  : _Number<16U, _Digs...>::type
246  { };
247 
248  template<char... _Digs>
249  struct _Parse_int<'0', _Digs...>
250  : _Number<8U, _Digs...>::type
251  { };
252 
253  template<char... _Digs>
254  struct _Parse_int
255  : _Number<10U, _Digs...>::type
256  { };
257 
258 } // namespace __parse_int
259 
260 
261 namespace __select_int
262 {
263  template<unsigned long long _Val, typename... _Ints>
264  struct _Select_int_base;
265 
266  template<unsigned long long _Val, typename _IntType, typename... _Ints>
267  struct _Select_int_base<_Val, _IntType, _Ints...>
268  : conditional_t<(_Val <= std::numeric_limits<_IntType>::max()),
269  integral_constant<_IntType, _Val>,
270  _Select_int_base<_Val, _Ints...>>
271  { };
272 
273  template<unsigned long long _Val>
274  struct _Select_int_base<_Val>
275  { };
276 
277  template<char... _Digs>
278  using _Select_int = typename _Select_int_base<
279  __parse_int::_Parse_int<_Digs...>::value,
280  unsigned char,
281  unsigned short,
282  unsigned int,
283  unsigned long,
284  unsigned long long
285  >::type;
286 
287 } // namespace __select_int
288 
289 _GLIBCXX_END_NAMESPACE_VERSION
290 } // namespace std
291 
292 #endif // __cplusplus > 201103L
293 
294 #endif // _GLIBCXX_PARSE_NUMBERS_H
integral_constant< bool, false > false_type
The type used as a compile-time boolean with false value.
Definition: type_traits:78
ISO C++ entities toplevel namespace is std.
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
Definition: type_traits:2388
integral_constant< bool, true > true_type
The type used as a compile-time boolean with true value.
Definition: type_traits:75