1  /* Test of <limits.h> substitute.
       2     Copyright 2016-2023 Free Software Foundation, Inc.
       3  
       4     This program is free software: you can redistribute it and/or modify
       5     it under the terms of the GNU General Public License as published by
       6     the Free Software Foundation, either version 3 of the License, or
       7     (at your option) any later version.
       8  
       9     This program is distributed in the hope that it will be useful,
      10     but WITHOUT ANY WARRANTY; without even the implied warranty of
      11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12     GNU General Public License for more details.
      13  
      14     You should have received a copy of the GNU General Public License
      15     along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
      16  
      17  /* Written by Paul Eggert.  */
      18  
      19  #include <config.h>
      20  
      21  #include <limits.h>
      22  
      23  #if 4 < __GNUC__ + (3 <= __GNUC_MINOR__)
      24  # pragma GCC diagnostic ignored "-Woverlength-strings"
      25  #endif
      26  
      27  #define verify_width(width, min, max) \
      28    static_assert ((max) >> ((width) - 1 - ((min) < 0)) == 1)
      29  
      30  /* Macros borrowed from intprops.h.  */
      31  #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
      32  #define TYPE_WIDTH(t) (sizeof (t) * CHAR_BIT)
      33  #define TYPE_MINIMUM(t) ((t) ~ TYPE_MAXIMUM (t))
      34  #define TYPE_MAXIMUM(t)                                                 \
      35    ((t) (! TYPE_SIGNED (t)                                               \
      36          ? (t) -1                                                        \
      37          : ((((t) 1 << (TYPE_WIDTH (t) - 2)) - 1) * 2 + 1)))
      38  
      39  /* Type width macros.  */
      40  
      41  int type_bits[] =
      42    {
      43      CHAR_BIT,
      44      WORD_BIT,
      45      LONG_BIT
      46    };
      47  verify_width (CHAR_BIT, CHAR_MIN, CHAR_MAX);
      48  verify_width (WORD_BIT, INT_MIN, INT_MAX);
      49  verify_width (LONG_BIT, LONG_MIN, LONG_MAX);
      50  
      51  /* Numerical limit macros.  */
      52  
      53  char               limits1[]  = { CHAR_MIN, CHAR_MAX };
      54  static_assert (TYPE_MINIMUM (char) == CHAR_MIN);
      55  static_assert (TYPE_MAXIMUM (char) == CHAR_MAX);
      56  
      57  signed char        limits2[]  = { SCHAR_MIN, SCHAR_MAX };
      58  static_assert (TYPE_MINIMUM (signed char) == SCHAR_MIN);
      59  static_assert (TYPE_MAXIMUM (signed char) == SCHAR_MAX);
      60  
      61  unsigned char      limits3[]  = { UCHAR_MAX };
      62  static_assert (TYPE_MINIMUM (unsigned char) == 0);
      63  static_assert (TYPE_MAXIMUM (unsigned char) == UCHAR_MAX);
      64  
      65  short              limits4[]  = { SHRT_MIN, SHRT_MAX };
      66  static_assert (TYPE_MINIMUM (short int) == SHRT_MIN);
      67  static_assert (TYPE_MAXIMUM (short int) == SHRT_MAX);
      68  
      69  unsigned short     limits5[]  = { USHRT_MAX };
      70  static_assert (TYPE_MINIMUM (unsigned short int) == 0);
      71  static_assert (TYPE_MAXIMUM (unsigned short int) == USHRT_MAX);
      72  
      73  int                limits6[]  = { INT_MIN, INT_MAX };
      74  static_assert (TYPE_MINIMUM (int) == INT_MIN);
      75  static_assert (TYPE_MAXIMUM (int) == INT_MAX);
      76  
      77  unsigned int       limits7[]  = { UINT_MAX };
      78  static_assert (TYPE_MINIMUM (unsigned int) == 0);
      79  static_assert (TYPE_MAXIMUM (unsigned int) == UINT_MAX);
      80  
      81  long               limits8[]  = { LONG_MIN, LONG_MAX };
      82  static_assert (TYPE_MINIMUM (long int) == LONG_MIN);
      83  static_assert (TYPE_MAXIMUM (long int) == LONG_MAX);
      84  
      85  unsigned long      limits9[]  = { ULONG_MAX };
      86  static_assert (TYPE_MINIMUM (unsigned long int) == 0);
      87  static_assert (TYPE_MAXIMUM (unsigned long int) == ULONG_MAX);
      88  
      89  long long          limits10[] = { LLONG_MIN, LLONG_MAX };
      90  static_assert (TYPE_MINIMUM (long long int) == LLONG_MIN);
      91  static_assert (TYPE_MAXIMUM (long long int) == LLONG_MAX);
      92  
      93  unsigned long long limits11[] = { ULLONG_MAX };
      94  static_assert (TYPE_MINIMUM (unsigned long long int) == 0);
      95  static_assert (TYPE_MAXIMUM (unsigned long long int) == ULLONG_MAX);
      96  
      97  /* Specified by POSIX, not by ISO C.  */
      98  
      99  long long limits12[] = { SSIZE_MAX };
     100  
     101  /* Macros specified by C23 and by ISO/IEC TS 18661-1:2014.  */
     102  
     103  verify_width (CHAR_WIDTH, CHAR_MIN, CHAR_MAX);
     104  verify_width (SCHAR_WIDTH, SCHAR_MIN, SCHAR_MAX);
     105  verify_width (UCHAR_WIDTH, 0, UCHAR_MAX);
     106  verify_width (SHRT_WIDTH, SHRT_MIN, SHRT_MAX);
     107  verify_width (USHRT_WIDTH, 0, USHRT_MAX);
     108  verify_width (INT_WIDTH, INT_MIN, INT_MAX);
     109  verify_width (UINT_WIDTH, 0, UINT_MAX);
     110  verify_width (LONG_WIDTH, LONG_MIN, LONG_MAX);
     111  verify_width (ULONG_WIDTH, 0, ULONG_MAX);
     112  verify_width (LLONG_WIDTH, LLONG_MIN, LLONG_MAX);
     113  verify_width (ULLONG_WIDTH, 0, ULLONG_MAX);
     114  
     115  /* Macros specified by C23.  */
     116  
     117  int bool_attrs[] = { BOOL_MAX, BOOL_WIDTH };
     118  static_assert (BOOL_MAX == (((1U << (BOOL_WIDTH - 1)) - 1) * 2) + 1);
     119  
     120  static_assert (0 < MB_LEN_MAX);
     121  
     122  /* Get ssize_t, size_t.  */
     123  #include <sys/types.h>
     124  
     125  static_assert (TYPE_MAXIMUM (ssize_t) == SSIZE_MAX);
     126  /* Verify that ssize_t has the same width as size_t.  */
     127  static_assert (TYPE_MAXIMUM (size_t) / 2 == SSIZE_MAX);
     128  
     129  int
     130  main (void)
     131  {
     132    return 0;
     133  }