[BACK]Return to t-constants.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib / gmp / tests

Annotation of OpenXM_contrib/gmp/tests/t-constants.c, Revision 1.1

1.1     ! ohara       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:
        !           218:   CHECK_HIGHBIT (GMP_LIMB_HIGHBIT, mp_limb_t,      LL("0x%lX","0x%lX"));
        !           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: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>