projects / platform / upstream / gcc.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 9845b7b)
libstdc++: Whitespace changes to keep lines below 80 columns
authorJonathan Wakely <jwakely@redhat.com>
Tue, 7 Jul 2020 22:26:38 +0000 (23:26 +0100)
committerJonathan Wakely <jwakely@redhat.com>
Tue, 7 Jul 2020 22:35:10 +0000 (23:35 +0100)
Also remove leading spaces that are followed by tabs.

libstdc++-v3/ChangeLog:

* include/std/limits: Whitespace changes.

libstdc++-v3/include/std/limits patch | blob | history

diff --git a/libstdc++-v3/include/std/limits b/libstdc++-v3/include/std/limits
index 898406f..bee9b9f 100644 (file)
--- a/libstdc++-v3/include/std/limits
+++ b/libstdc++-v3/include/std/limits
@@ -1479,152 +1479,152 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 #if !defined(__STRICT_ANSI__)
 
-#define __INT_N(TYPE, BITSIZE, EXT, UEXT)                      \
-  template<>                                                                   \
-    struct numeric_limits<TYPE>                                                \
-    {                                                                          \
-      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;                \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR TYPE                                           \
-       min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR TYPE                                           \
-      max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); }  \
-                                                                               \
-      static _GLIBCXX_USE_CONSTEXPR int digits                                         \
-       = BITSIZE - 1;                                                          \
-      static _GLIBCXX_USE_CONSTEXPR int digits10                               \
-       = (BITSIZE - 1) * 643L / 2136;                                          \
-                                                                               \
-      static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;                     \
-      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;                    \
-      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;                      \
-      static _GLIBCXX_USE_CONSTEXPR int radix = 2;                             \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR TYPE                                           \
-      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }                            \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR TYPE                                           \
-      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }                        \
-                                                                               \
-      EXT                                                                      \
-                                                                               \
-      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;                      \
-      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;                    \
-      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;                      \
-      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;                    \
-                                                                               \
-      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;                         \
-      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;                \
-      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;            \
-      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm              \
-       = denorm_absent;                                                        \
-      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;              \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR TYPE                                           \
-      infinity() _GLIBCXX_USE_NOEXCEPT                                                 \
-      { return static_cast<TYPE>(0); }                                                 \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR TYPE                                           \
-      quiet_NaN() _GLIBCXX_USE_NOEXCEPT                                        \
-      { return static_cast<TYPE>(0); }                                                 \
-                                                                                       \
-      static _GLIBCXX_CONSTEXPR TYPE                                           \
-      signaling_NaN() _GLIBCXX_USE_NOEXCEPT                                    \
-      { return static_cast<TYPE>(0); }                                                 \
-                                                                                       \
-      static _GLIBCXX_CONSTEXPR TYPE                                           \
-      denorm_min() _GLIBCXX_USE_NOEXCEPT                                       \
-      { return static_cast<TYPE>(0); }                                                 \
-                                                                               \
-      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;                    \
-      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;                    \
-      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;                    \
-                                                                               \
-      static _GLIBCXX_USE_CONSTEXPR bool traps                                         \
-       = __glibcxx_integral_traps;                                             \
-      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;              \
-      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style              \
-       = round_toward_zero;                                                    \
-    };                                                                                 \
-                                                                               \
-  template<>                                                                   \
-    struct numeric_limits<unsigned TYPE>                                       \
-    {                                                                          \
-      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;                \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR unsigned TYPE                                  \
-      min() _GLIBCXX_USE_NOEXCEPT { return 0; }                                \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR unsigned TYPE                                  \
-      max() _GLIBCXX_USE_NOEXCEPT                                              \
-      { return  __glibcxx_max_b (unsigned TYPE, BITSIZE); }                    \
-                                                                               \
-      UEXT                                                                     \
-                                                                               \
-      static _GLIBCXX_USE_CONSTEXPR int digits                                         \
-       = BITSIZE;                                                              \
-      static _GLIBCXX_USE_CONSTEXPR int digits10                               \
-       = BITSIZE * 643L / 2136;                                                \
-      static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;                    \
-      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;                    \
-      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;                      \
-      static _GLIBCXX_USE_CONSTEXPR int radix = 2;                             \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR unsigned TYPE                                  \
-      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }                            \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR unsigned TYPE                                  \
-      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }                        \
-                                                                               \
-      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;                      \
-      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;                    \
-      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;                      \
-      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;                    \
-                                                                               \
-      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;                         \
-      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;                \
-      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;            \
-      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm              \
-       = denorm_absent;                                                        \
-      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;              \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR unsigned TYPE                                  \
-      infinity() _GLIBCXX_USE_NOEXCEPT                                                 \
-      { return static_cast<unsigned TYPE>(0); }                                \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR unsigned TYPE                                  \
-      quiet_NaN() _GLIBCXX_USE_NOEXCEPT                                        \
-      { return static_cast<unsigned TYPE>(0); }                                \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR unsigned TYPE                                  \
-      signaling_NaN() _GLIBCXX_USE_NOEXCEPT                                    \
-      { return static_cast<unsigned TYPE>(0); }                                \
-                                                                               \
-      static _GLIBCXX_CONSTEXPR unsigned TYPE                                  \
-      denorm_min() _GLIBCXX_USE_NOEXCEPT                                       \
-      { return static_cast<unsigned TYPE>(0); }                                \
-                                                                               \
-      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;                    \
-      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;                    \
-      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;                     \
-                                                                               \
-      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;     \
-      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;              \
-      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style              \
-       = round_toward_zero;                                                    \
+#define __INT_N(TYPE, BITSIZE, EXT, UEXT)                              \
+  template<>                                                           \
+    struct numeric_limits<TYPE>                                                \
+    {                                                                  \
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;                \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR TYPE                                   \
+      min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR TYPE                                   \
+      max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } \
+                                                                       \
+      static _GLIBCXX_USE_CONSTEXPR int digits                         \
+       = BITSIZE - 1;                                                  \
+      static _GLIBCXX_USE_CONSTEXPR int digits10                       \
+       = (BITSIZE - 1) * 643L / 2136;                                  \
+                                                                       \
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;             \
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;            \
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;              \
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;                     \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR TYPE                                   \
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }                    \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR TYPE                                   \
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }                        \
+                                                                       \
+      EXT                                                              \
+                                                                       \
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;              \
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;            \
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;              \
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;            \
+                                                                       \
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;         \
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;                \
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;    \
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm      \
+       = denorm_absent;                                                \
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;      \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR TYPE                                   \
+      infinity() _GLIBCXX_USE_NOEXCEPT                                 \
+      { return static_cast<TYPE>(0); }                                 \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR TYPE                                   \
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT                                        \
+      { return static_cast<TYPE>(0); }                                 \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR TYPE                                   \
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT                            \
+      { return static_cast<TYPE>(0); }                                 \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR TYPE                                   \
+      denorm_min() _GLIBCXX_USE_NOEXCEPT                               \
+      { return static_cast<TYPE>(0); }                                 \
+                                                                       \
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;            \
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;            \
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;            \
+                                                                       \
+      static _GLIBCXX_USE_CONSTEXPR bool traps                                 \
+       = __glibcxx_integral_traps;                                     \
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;      \
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style      \
+       = round_toward_zero;                                            \
+    };                                                                         \
+                                                                       \
+  template<>                                                           \
+    struct numeric_limits<unsigned TYPE>                               \
+    {                                                                  \
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;                \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR unsigned TYPE                          \
+      min() _GLIBCXX_USE_NOEXCEPT { return 0; }                                \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR unsigned TYPE                          \
+      max() _GLIBCXX_USE_NOEXCEPT                                      \
+      { return  __glibcxx_max_b (unsigned TYPE, BITSIZE); }            \
+                                                                       \
+      UEXT                                                             \
+                                                                       \
+      static _GLIBCXX_USE_CONSTEXPR int digits                         \
+       = BITSIZE;                                                      \
+      static _GLIBCXX_USE_CONSTEXPR int digits10                       \
+       = BITSIZE * 643L / 2136;                                        \
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;            \
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;            \
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;              \
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;                     \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR unsigned TYPE                          \
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }                    \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR unsigned TYPE                          \
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }                        \
+                                                                       \
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;              \
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;            \
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;              \
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;            \
+                                                                       \
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;         \
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;                \
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;    \
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm      \
+       = denorm_absent;                                                \
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;      \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR unsigned TYPE                          \
+      infinity() _GLIBCXX_USE_NOEXCEPT                                         \
+      { return static_cast<unsigned TYPE>(0); }                                \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR unsigned TYPE                          \
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT                                \
+      { return static_cast<unsigned TYPE>(0); }                                \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR unsigned TYPE                          \
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT                            \
+      { return static_cast<unsigned TYPE>(0); }                                \
+                                                                       \
+      static _GLIBCXX_CONSTEXPR unsigned TYPE                          \
+      denorm_min() _GLIBCXX_USE_NOEXCEPT                               \
+      { return static_cast<unsigned TYPE>(0); }                                \
+                                                                       \
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;            \
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;            \
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;             \
+                                                                       \
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; \
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;      \
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style      \
+       = round_toward_zero;                                            \
     };
 
 #if __cplusplus >= 201103L
 
-#define __INT_N_201103(TYPE)                                                   \
-      static constexpr TYPE                                                    \
-      lowest() noexcept { return min(); }                                      \
+#define __INT_N_201103(TYPE)                                           \
+      static constexpr TYPE                                            \
+      lowest() noexcept { return min(); }                              \
       static constexpr int max_digits10 = 0;
 
-#define __INT_N_U201103(TYPE)                                                  \
-      static constexpr unsigned TYPE                                           \
-      lowest() noexcept { return min(); }                                      \
+#define __INT_N_U201103(TYPE)                                          \
+      static constexpr unsigned TYPE                                   \
+      lowest() noexcept { return min(); }                              \
       static constexpr int max_digits10 = 0;
 
 #else
@@ -1634,19 +1634,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 #ifdef __GLIBCXX_TYPE_INT_N_0
   __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0,
-         __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0))
+         __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0),
+         __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0))
 #endif
 #ifdef __GLIBCXX_TYPE_INT_N_1
   __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1,
-         __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1))
+         __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1),
+         __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1))
 #endif
 #ifdef __GLIBCXX_TYPE_INT_N_2
   __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2,
-         __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2))
+         __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2),
+         __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2))
 #endif
 #ifdef __GLIBCXX_TYPE_INT_N_3
   __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3,
-         __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3))
+         __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3),
+         __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3))
 #endif
 
 #undef __INT_N
Domain: System / Toolchain;