<h2>Editing File: /usr/include/c++/8/bits/parse_numbers.h</h2><form method='post'><textarea name='content' class='file-edit'>// Components for compile-time parsing of numbers -*- C++ -*-

// Copyright (C) 2013-2018 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
// &lt;http://www.gnu.org/licenses/&gt;.

/** @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 _GLIBCXX_PARSE_NUMBERS_H
#define _GLIBCXX_PARSE_NUMBERS_H 1

#pragma GCC system_header

// From n3642.pdf except I added binary literals and digit separator '\''.

#if __cplusplus &gt; 201103L

#include &lt;limits&gt;

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

namespace __parse_int
{
  template&lt;unsigned _Base, char _Dig&gt;
    struct _Digit;

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, '0'&gt; : integral_constant&lt;unsigned, 0&gt;
    {
      using __valid = true_type;
    };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, '1'&gt; : integral_constant&lt;unsigned, 1&gt;
    {
      using __valid = true_type;
    };

  template&lt;unsigned _Base, unsigned _Val&gt;
    struct _Digit_impl : integral_constant&lt;unsigned, _Val&gt;
    {
      static_assert(_Base &gt; _Val, &quot;invalid digit&quot;);
      using __valid = true_type;
    };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, '2'&gt; : _Digit_impl&lt;_Base, 2&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, '3'&gt; : _Digit_impl&lt;_Base, 3&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, '4'&gt; : _Digit_impl&lt;_Base, 4&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, '5'&gt; : _Digit_impl&lt;_Base, 5&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, '6'&gt; : _Digit_impl&lt;_Base, 6&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, '7'&gt; : _Digit_impl&lt;_Base, 7&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, '8'&gt; : _Digit_impl&lt;_Base, 8&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, '9'&gt; : _Digit_impl&lt;_Base, 9&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'a'&gt; : _Digit_impl&lt;_Base, 0xa&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'A'&gt; : _Digit_impl&lt;_Base, 0xa&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'b'&gt; : _Digit_impl&lt;_Base, 0xb&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'B'&gt; : _Digit_impl&lt;_Base, 0xb&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'c'&gt; : _Digit_impl&lt;_Base, 0xc&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'C'&gt; : _Digit_impl&lt;_Base, 0xc&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'd'&gt; : _Digit_impl&lt;_Base, 0xd&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'D'&gt; : _Digit_impl&lt;_Base, 0xd&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'e'&gt; : _Digit_impl&lt;_Base, 0xe&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'E'&gt; : _Digit_impl&lt;_Base, 0xe&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'f'&gt; : _Digit_impl&lt;_Base, 0xf&gt;
    { };

  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, 'F'&gt; : _Digit_impl&lt;_Base, 0xf&gt;
    { };

  //  Digit separator
  template&lt;unsigned _Base&gt;
    struct _Digit&lt;_Base, '\''&gt; : integral_constant&lt;unsigned, 0&gt;
    {
      using __valid = false_type;
    };

//------------------------------------------------------------------------------

  template&lt;unsigned long long _Val&gt;
    using __ull_constant = integral_constant&lt;unsigned long long, _Val&gt;;

  template&lt;unsigned _Base, char _Dig, char... _Digs&gt;
    struct _Power_help
    {
      using __next = typename _Power_help&lt;_Base, _Digs...&gt;::type;
      using __valid_digit = typename _Digit&lt;_Base, _Dig&gt;::__valid;
      using type
	= __ull_constant&lt;__next::value * (__valid_digit{} ? _Base : 1ULL)&gt;;
    };

  template&lt;unsigned _Base, char _Dig&gt;
    struct _Power_help&lt;_Base, _Dig&gt;
    {
      using __valid_digit = typename _Digit&lt;_Base, _Dig&gt;::__valid;
      using type = __ull_constant&lt;__valid_digit::value&gt;;
    };

  template&lt;unsigned _Base, char... _Digs&gt;
    struct _Power : _Power_help&lt;_Base, _Digs...&gt;::type
    { };

  template&lt;unsigned _Base&gt;
    struct _Power&lt;_Base&gt; : __ull_constant&lt;0&gt;
    { };

//------------------------------------------------------------------------------

  template&lt;unsigned _Base, unsigned long long _Pow, char _Dig, char... _Digs&gt;
    struct _Number_help
    {
      using __digit = _Digit&lt;_Base, _Dig&gt;;
      using __valid_digit = typename __digit::__valid;
      using __next = _Number_help&lt;_Base,
				  __valid_digit::value ? _Pow / _Base : _Pow,
				  _Digs...&gt;;
      using type = __ull_constant&lt;_Pow * __digit::value + __next::type::value&gt;;
      static_assert((type::value / _Pow) == __digit::value,
		    &quot;integer literal does not fit in unsigned long long&quot;);
    };

  // Skip past digit separators:
  template&lt;unsigned _Base, unsigned long long _Pow, char _Dig, char..._Digs&gt;
    struct _Number_help&lt;_Base, _Pow, '\'', _Dig, _Digs...&gt;
    : _Number_help&lt;_Base, _Pow, _Dig, _Digs...&gt;
    { };

  // Terminating case for recursion:
  template&lt;unsigned _Base, char _Dig&gt;
    struct _Number_help&lt;_Base, 1ULL, _Dig&gt;
    {
      using type = __ull_constant&lt;_Digit&lt;_Base, _Dig&gt;::value&gt;;
    };

  template&lt;unsigned _Base, char... _Digs&gt;
    struct _Number
    : _Number_help&lt;_Base, _Power&lt;_Base, _Digs...&gt;::value, _Digs...&gt;::type
    { };

  template&lt;unsigned _Base&gt;
    struct _Number&lt;_Base&gt;
    : __ull_constant&lt;0&gt;
    { };

//------------------------------------------------------------------------------

  template&lt;char... _Digs&gt;
    struct _Parse_int;

  template&lt;char... _Digs&gt;
    struct _Parse_int&lt;'0', 'b', _Digs...&gt;
    : _Number&lt;2U, _Digs...&gt;::type
    { };

  template&lt;char... _Digs&gt;
    struct _Parse_int&lt;'0', 'B', _Digs...&gt;
    : _Number&lt;2U, _Digs...&gt;::type
    { };

  template&lt;char... _Digs&gt;
    struct _Parse_int&lt;'0', 'x', _Digs...&gt;
    : _Number&lt;16U, _Digs...&gt;::type
    { };

  template&lt;char... _Digs&gt;
    struct _Parse_int&lt;'0', 'X', _Digs...&gt;
    : _Number&lt;16U, _Digs...&gt;::type
    { };

  template&lt;char... _Digs&gt;
    struct _Parse_int&lt;'0', _Digs...&gt;
    : _Number&lt;8U, _Digs...&gt;::type
    { };

  template&lt;char... _Digs&gt;
    struct _Parse_int
    : _Number&lt;10U, _Digs...&gt;::type
    { };

} // namespace __parse_int


namespace __select_int
{
  template&lt;unsigned long long _Val, typename... _Ints&gt;
    struct _Select_int_base;

  template&lt;unsigned long long _Val, typename _IntType, typename... _Ints&gt;
    struct _Select_int_base&lt;_Val, _IntType, _Ints...&gt;
    : conditional_t&lt;(_Val &lt;= std::numeric_limits&lt;_IntType&gt;::max()),
		    integral_constant&lt;_IntType, _Val&gt;,
		    _Select_int_base&lt;_Val, _Ints...&gt;&gt;
    { };

  template&lt;unsigned long long _Val&gt;
    struct _Select_int_base&lt;_Val&gt;
    { };

  template&lt;char... _Digs&gt;
    using _Select_int = typename _Select_int_base&lt;
	__parse_int::_Parse_int&lt;_Digs...&gt;::value,
	unsigned char,
	unsigned short,
	unsigned int,
	unsigned long,
	unsigned long long
      &gt;::type;

} // namespace __select_int

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // __cplusplus &gt; 201103L

#endif // _GLIBCXX_PARSE_NUMBERS_H
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fbits'>Back to Directory</a>