[18190] | 1 | /* Check the values of some constants. |
---|
| 2 | |
---|
| 3 | Copyright 2000, 2001, 2002 Free Software Foundation, Inc. |
---|
| 4 | |
---|
| 5 | This file is part of the GNU MP Library. |
---|
| 6 | |
---|
| 7 | The GNU MP Library is free software; you can redistribute it and/or modify |
---|
| 8 | it under the terms of the GNU Lesser General Public License as published by |
---|
| 9 | the Free Software Foundation; either version 2.1 of the License, or (at your |
---|
| 10 | option) any later version. |
---|
| 11 | |
---|
| 12 | The GNU MP Library is distributed in the hope that it will be useful, but |
---|
| 13 | WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
---|
| 14 | or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public |
---|
| 15 | License for more details. |
---|
| 16 | |
---|
| 17 | You should have received a copy of the GNU Lesser General Public License |
---|
| 18 | along with the GNU MP Library; see the file COPYING.LIB. If not, write to |
---|
| 19 | the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, |
---|
| 20 | MA 02111-1307, USA. */ |
---|
| 21 | |
---|
| 22 | #include <stdio.h> |
---|
| 23 | #include <stdlib.h> |
---|
| 24 | #include "gmp.h" |
---|
| 25 | |
---|
| 26 | #ifdef ULONG_MAX |
---|
| 27 | char *ulong_max_def = "defined"; |
---|
| 28 | #else |
---|
| 29 | char *ulong_max_def = "not defined"; |
---|
| 30 | #endif |
---|
| 31 | #ifdef LONG_MAX |
---|
| 32 | char *long_max_def = "defined"; |
---|
| 33 | #else |
---|
| 34 | char *long_max_def = "not defined"; |
---|
| 35 | #endif |
---|
| 36 | |
---|
| 37 | #ifdef UINT_MAX |
---|
| 38 | char *uint_max_def = "defined"; |
---|
| 39 | #else |
---|
| 40 | char *uint_max_def = "not defined"; |
---|
| 41 | #endif |
---|
| 42 | #ifdef INT_MAX |
---|
| 43 | char *int_max_def = "defined"; |
---|
| 44 | #else |
---|
| 45 | char *int_max_def = "not defined"; |
---|
| 46 | #endif |
---|
| 47 | |
---|
| 48 | #ifdef USHRT_MAX |
---|
| 49 | char *ushrt_max_def = "defined"; |
---|
| 50 | #else |
---|
| 51 | char *ushrt_max_def = "not defined"; |
---|
| 52 | #endif |
---|
| 53 | #ifdef SHRT_MAX |
---|
| 54 | char *shrt_max_def = "defined"; |
---|
| 55 | #else |
---|
| 56 | char *shrt_max_def = "not defined"; |
---|
| 57 | #endif |
---|
| 58 | |
---|
| 59 | #include "gmp-impl.h" |
---|
| 60 | #include "longlong.h" |
---|
| 61 | |
---|
| 62 | |
---|
| 63 | #ifdef _LONG_LONG_LIMB |
---|
| 64 | #define LL(l,ll) ll |
---|
| 65 | #else |
---|
| 66 | #define LL(l,ll) l |
---|
| 67 | #endif |
---|
| 68 | |
---|
| 69 | #if __GMP_MP_SIZE_T_INT |
---|
| 70 | #define SS(i,l) i |
---|
| 71 | #else |
---|
| 72 | #define SS(i,l) l |
---|
| 73 | #endif |
---|
| 74 | |
---|
| 75 | |
---|
| 76 | #define CHECK_LIMB_S(x, xname, y, yname) \ |
---|
| 77 | do { \ |
---|
| 78 | if ((x) != (y)) \ |
---|
| 79 | { \ |
---|
| 80 | printf (LL("%s == %lx, but %s == %lx\n", \ |
---|
| 81 | "%s == %llx, but %s == %llx\n"), \ |
---|
| 82 | xname, x, yname, y); \ |
---|
| 83 | error = 1; \ |
---|
| 84 | } \ |
---|
| 85 | } while (0) |
---|
| 86 | |
---|
| 87 | #define CHECK_INT_S(x, xname, y, yname) \ |
---|
| 88 | do { \ |
---|
| 89 | if ((x) != (y)) \ |
---|
| 90 | { \ |
---|
| 91 | printf ("%s == %d, but %s == %d\n", xname, x, yname, y); \ |
---|
| 92 | error = 1; \ |
---|
| 93 | } \ |
---|
| 94 | } while (0) |
---|
| 95 | |
---|
| 96 | |
---|
| 97 | |
---|
| 98 | #define CHECK_CONDITION_S(x, xname) \ |
---|
| 99 | do { \ |
---|
| 100 | if (!(x)) \ |
---|
| 101 | { \ |
---|
| 102 | printf ("%s is false\n", xname); \ |
---|
| 103 | error = 1; \ |
---|
| 104 | } \ |
---|
| 105 | } while (0) |
---|
| 106 | |
---|
| 107 | |
---|
| 108 | /* How many bits seem to work in the given type. */ |
---|
| 109 | #define CALC_BITS(result, type) \ |
---|
| 110 | do { \ |
---|
| 111 | type n = 1; \ |
---|
| 112 | result = 0; \ |
---|
| 113 | while (n != 0) \ |
---|
| 114 | { \ |
---|
| 115 | n <<= 1; \ |
---|
| 116 | result++; \ |
---|
| 117 | } \ |
---|
| 118 | } while (0) |
---|
| 119 | |
---|
| 120 | #define CHECK_BITS_S(constant, constant_name, type) \ |
---|
| 121 | do { \ |
---|
| 122 | int calculated; \ |
---|
| 123 | CALC_BITS (calculated, type); \ |
---|
| 124 | if (calculated != constant) \ |
---|
| 125 | { \ |
---|
| 126 | printf ("%s == %d, but calculated %d\n", \ |
---|
| 127 | constant_name, constant, calculated); \ |
---|
| 128 | error = 1; \ |
---|
| 129 | } \ |
---|
| 130 | } while (0) |
---|
| 131 | |
---|
| 132 | |
---|
| 133 | #define CHECK_HIGHBIT_S(value, value_name, type, format) \ |
---|
| 134 | do { \ |
---|
| 135 | type n = value; \ |
---|
| 136 | if (n == 0) \ |
---|
| 137 | { \ |
---|
| 138 | printf ("%s == 0\n", value_name); \ |
---|
| 139 | error = 1; \ |
---|
| 140 | } \ |
---|
| 141 | n <<= 1; \ |
---|
| 142 | if (n != 0) \ |
---|
| 143 | { \ |
---|
| 144 | printf ("%s << 1 = ", value_name); \ |
---|
| 145 | printf (format, n); \ |
---|
| 146 | printf (" != 0\n"); \ |
---|
| 147 | error = 1; \ |
---|
| 148 | } \ |
---|
| 149 | } while (0) |
---|
| 150 | |
---|
| 151 | |
---|
| 152 | #define CHECK_MAX_S(max_val, max_name, min_val, min_name, type, format) \ |
---|
| 153 | do { \ |
---|
| 154 | type maxval = max_val; \ |
---|
| 155 | type minval = min_val; \ |
---|
| 156 | type n = maxval; \ |
---|
| 157 | n++; \ |
---|
| 158 | if (n != minval) \ |
---|
| 159 | { \ |
---|
| 160 | printf ("%s + 1 = ", max_name); \ |
---|
| 161 | printf (format, n); \ |
---|
| 162 | printf (" != %s = ", min_name); \ |
---|
| 163 | printf (format, minval); \ |
---|
| 164 | printf ("\n"); \ |
---|
| 165 | error = 1; \ |
---|
| 166 | } \ |
---|
| 167 | if (maxval <= minval) \ |
---|
| 168 | { \ |
---|
| 169 | printf ("%s = ", max_name); \ |
---|
| 170 | printf (format, maxval); \ |
---|
| 171 | printf (" <= %s = ", min_name); \ |
---|
| 172 | printf (format, minval); \ |
---|
| 173 | printf ("\n"); \ |
---|
| 174 | error = 1; \ |
---|
| 175 | } \ |
---|
| 176 | } while (0) |
---|
| 177 | |
---|
| 178 | |
---|
| 179 | #if HAVE_STRINGIZE |
---|
| 180 | #define CHECK_LIMB(x,y) CHECK_LIMB_S (x, #x, y, #y) |
---|
| 181 | #define CHECK_INT(x,y) CHECK_INT_S (x, #x, y, #y) |
---|
| 182 | #define CHECK_CONDITION(x) CHECK_CONDITION_S (x, #x) |
---|
| 183 | #define CHECK_BITS(c,t) CHECK_BITS_S (c, #c, t) |
---|
| 184 | #define CHECK_MAX(m,n,t,f) CHECK_MAX_S (m, #m, n, #n, t, f) |
---|
| 185 | #define CHECK_HIGHBIT(n,t,f) CHECK_HIGHBIT_S (n, #n, t, f) |
---|
| 186 | #else |
---|
| 187 | #define CHECK_LIMB(x,y) CHECK_LIMB_S (x, "x", y, "y") |
---|
| 188 | #define CHECK_INT(x,y) CHECK_INT_S (x, "x", y, "y") |
---|
| 189 | #define CHECK_CONDITION(x) CHECK_CONDITION_S (x, "x") |
---|
| 190 | #define CHECK_BITS(c,t) CHECK_BITS_S (c, "c", t) |
---|
| 191 | #define CHECK_MAX(m,n,t,f) CHECK_MAX_S (m, "m", n, "n", t, f) |
---|
| 192 | #define CHECK_HIGHBIT(n,t,f) CHECK_HIGHBIT_S (n, "n", t, f) |
---|
| 193 | #endif |
---|
| 194 | |
---|
| 195 | |
---|
| 196 | /* The tests below marked "Bad!" fail on Cray T90 systems, where int, short |
---|
| 197 | and mp_size_t are 48 bits or some such but don't wraparound in a plain |
---|
| 198 | twos complement fashion. In particular, |
---|
| 199 | |
---|
| 200 | INT_HIGHBIT << 1 = 0xFFFFC00000000000 != 0 |
---|
| 201 | INT_MAX + 1 = 35184372088832 != INT_MIN = -35184372088832 |
---|
| 202 | |
---|
| 203 | This is a bit bizarre, but doesn't matter because GMP doesn't rely on any |
---|
| 204 | particular overflow behaviour for int or short, only for mp_limb_t. */ |
---|
| 205 | |
---|
| 206 | int |
---|
| 207 | main (int argc, char *argv[]) |
---|
| 208 | { |
---|
| 209 | int error = 0; |
---|
| 210 | |
---|
| 211 | CHECK_INT (BYTES_PER_MP_LIMB, sizeof(mp_limb_t)); |
---|
| 212 | CHECK_INT (mp_bits_per_limb, BITS_PER_MP_LIMB); |
---|
| 213 | CHECK_INT (__GMP_BITS_PER_MP_LIMB, BITS_PER_MP_LIMB); |
---|
| 214 | |
---|
| 215 | CHECK_BITS (BITS_PER_MP_LIMB, mp_limb_t); |
---|
| 216 | CHECK_BITS (BITS_PER_ULONG, unsigned long); |
---|
| 217 | |
---|
[22253] | 218 | CHECK_HIGHBIT (GMP_LIMB_HIGHBIT, mp_limb_t, LL("0x%lX","0x%llX")); |
---|
[18190] | 219 | CHECK_HIGHBIT (ULONG_HIGHBIT, unsigned long, "0x%lX"); |
---|
| 220 | CHECK_HIGHBIT (UINT_HIGHBIT, unsigned int, "0x%X"); |
---|
| 221 | CHECK_HIGHBIT (USHRT_HIGHBIT, unsigned short, "0x%hX"); |
---|
| 222 | CHECK_HIGHBIT (LONG_HIGHBIT, long, "0x%lX"); |
---|
| 223 | #if 0 /* Bad! */ |
---|
| 224 | CHECK_HIGHBIT (INT_HIGHBIT, int, "0x%X"); |
---|
| 225 | CHECK_HIGHBIT (SHRT_HIGHBIT, short, "0x%hX"); |
---|
| 226 | #endif |
---|
| 227 | |
---|
| 228 | #if 0 /* Bad! */ |
---|
| 229 | CHECK_MAX (LONG_MAX, LONG_MIN, long, "%ld"); |
---|
| 230 | CHECK_MAX (INT_MAX, INT_MIN, int, "%d"); |
---|
| 231 | CHECK_MAX (SHRT_MAX, SHRT_MIN, short, "%hd"); |
---|
| 232 | #endif |
---|
| 233 | CHECK_MAX (ULONG_MAX, 0, unsigned long, "%lu"); |
---|
| 234 | CHECK_MAX (UINT_MAX, 0, unsigned int, "%u"); |
---|
| 235 | CHECK_MAX (USHRT_MAX, 0, unsigned short, "%hu"); |
---|
| 236 | #if 0 /* Bad! */ |
---|
| 237 | CHECK_MAX (MP_SIZE_T_MAX, MP_SIZE_T_MIN, mp_size_t, SS("%d","%ld")); |
---|
| 238 | #endif |
---|
| 239 | |
---|
| 240 | /* UHWtype should have at least enough bits for half a UWtype */ |
---|
| 241 | { |
---|
| 242 | int bits_per_UWtype, bits_per_UHWtype; |
---|
| 243 | CALC_BITS (bits_per_UWtype, UWtype); |
---|
| 244 | CALC_BITS (bits_per_UHWtype, UHWtype); |
---|
| 245 | CHECK_CONDITION (2*bits_per_UHWtype >= bits_per_UWtype); |
---|
| 246 | } |
---|
| 247 | |
---|
| 248 | { |
---|
| 249 | mp_limb_t modlimb_inverse_3_calc; |
---|
| 250 | modlimb_invert (modlimb_inverse_3_calc, CNST_LIMB(3)); |
---|
| 251 | CHECK_LIMB (MODLIMB_INVERSE_3 & GMP_NUMB_MASK, |
---|
| 252 | modlimb_inverse_3_calc & GMP_NUMB_MASK); |
---|
| 253 | } |
---|
| 254 | |
---|
| 255 | { |
---|
| 256 | mp_limb_t MODLIMB_INVERSE_3_times_3 |
---|
| 257 | = (MODLIMB_INVERSE_3 * CNST_LIMB(3)) & GMP_NUMB_MASK; |
---|
| 258 | CHECK_LIMB (MODLIMB_INVERSE_3_times_3, CNST_LIMB(1)); |
---|
| 259 | } |
---|
| 260 | |
---|
| 261 | #ifdef PP_INVERTED |
---|
| 262 | { |
---|
| 263 | mp_limb_t pp_inverted_calc; |
---|
| 264 | invert_limb (pp_inverted_calc, PP); |
---|
| 265 | CHECK_LIMB (PP_INVERTED, pp_inverted_calc); |
---|
| 266 | } |
---|
| 267 | #endif |
---|
| 268 | |
---|
| 269 | if (argc >= 2 || error) |
---|
| 270 | { |
---|
| 271 | int bits; |
---|
| 272 | |
---|
| 273 | printf ("\n"); |
---|
| 274 | printf ("After gmp.h,\n"); |
---|
| 275 | printf (" ULONG_MAX %s\n", ulong_max_def); |
---|
| 276 | printf (" LONG_MAX %s\n", long_max_def); |
---|
| 277 | printf (" UINT_MAX %s\n", uint_max_def); |
---|
| 278 | printf (" INT_MAX %s\n", int_max_def); |
---|
| 279 | printf (" USHRT_MAX %s\n", ushrt_max_def); |
---|
| 280 | printf (" SHRT_MAX %s\n", shrt_max_def); |
---|
| 281 | printf ("\n"); |
---|
| 282 | |
---|
| 283 | #ifdef _CRAY |
---|
| 284 | printf ("_CRAY is defined, so limits.h is being used\n"); |
---|
| 285 | #endif |
---|
| 286 | |
---|
| 287 | printf ("ULONG_MAX %lX\n", ULONG_MAX); |
---|
| 288 | printf ("ULONG_HIGHBIT %lX\n", ULONG_HIGHBIT); |
---|
| 289 | printf ("LONG_MAX %lX\n", LONG_MAX); |
---|
| 290 | printf ("LONG_MIN %lX\n", LONG_MIN); |
---|
| 291 | |
---|
| 292 | printf ("UINT_MAX %X\n", UINT_MAX); |
---|
| 293 | printf ("UINT_HIGHBIT %X\n", UINT_HIGHBIT); |
---|
| 294 | printf ("INT_MAX %X\n", INT_MAX); |
---|
| 295 | printf ("INT_MIN %X\n", INT_MIN); |
---|
| 296 | |
---|
| 297 | printf ("USHRT_MAX %hX\n", USHRT_MAX); |
---|
| 298 | printf ("USHRT_HIGHBIT %hX\n", USHRT_HIGHBIT); |
---|
| 299 | printf ("SHRT_MAX %hX\n", SHRT_MAX); |
---|
| 300 | printf ("SHRT_MIN %hX\n", SHRT_MIN); |
---|
| 301 | |
---|
| 302 | printf ("\n"); |
---|
| 303 | printf ("Bits\n"); |
---|
| 304 | CALC_BITS (bits, long); printf (" long %d\n", bits); |
---|
| 305 | CALC_BITS (bits, int); printf (" int %d\n", bits); |
---|
| 306 | CALC_BITS (bits, short); printf (" short %d\n", bits); |
---|
| 307 | CALC_BITS (bits, unsigned long); printf (" unsigned long %d\n", bits); |
---|
| 308 | CALC_BITS (bits, unsigned int); printf (" unsigned int %d\n", bits); |
---|
| 309 | CALC_BITS (bits, unsigned short); printf (" unsigned short %d\n", bits); |
---|
| 310 | CALC_BITS (bits, mp_size_t); printf (" mp_size_t %d\n", bits); |
---|
| 311 | } |
---|
| 312 | |
---|
| 313 | if (error) |
---|
| 314 | abort (); |
---|
| 315 | |
---|
| 316 | exit (0); |
---|
| 317 | } |
---|