← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gclcvs/quantal

« back to all changes in this revision

Viewing changes to gmp3/tests/t-constants.c

  • Committer: Bazaar Package Importer
  • Author(s): Camm Maguire
  • Date: 2004-06-24 15:13:46 UTC
  • Revision ID: james.westby@ubuntu.com-20040624151346-xh0xaaktyyp7aorc
Tags: 2.7.0-26
C_GC_OFFSET is 2 on m68k-linux

Show diffs side-by-side

added added

removed removed

Lines of Context:
gmp3/tests/t-constants.c
 
1
/* Check the values of some constants.
 
2
 
 
3
Copyright 2000, 2001 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 (MP_LIMB_T_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, modlimb_inverse_3_calc);
 
252
  }
 
253
 
 
254
  {
 
255
    mp_limb_t  MODLIMB_INVERSE_3_times_3 = MODLIMB_INVERSE_3 * CNST_LIMB(3);
 
256
    CHECK_LIMB (MODLIMB_INVERSE_3_times_3, CNST_LIMB(1));
 
257
  }
 
258
 
 
259
#ifdef PP_INVERTED
 
260
  {
 
261
    mp_limb_t  pp_inverted_calc;
 
262
    invert_limb (pp_inverted_calc, PP);
 
263
    CHECK_LIMB (PP_INVERTED, pp_inverted_calc);
 
264
  }
 
265
#endif
 
266
 
 
267
  if (argc >= 2 || error)
 
268
    {
 
269
      int  bits;
 
270
 
 
271
      printf ("\n");
 
272
      printf ("After gmp.h,\n");
 
273
      printf ("  ULONG_MAX  %s\n", ulong_max_def);
 
274
      printf ("  LONG_MAX   %s\n", long_max_def);
 
275
      printf ("  UINT_MAX   %s\n", uint_max_def);
 
276
      printf ("  INT_MAX    %s\n", int_max_def);
 
277
      printf ("  USHRT_MAX  %s\n", ushrt_max_def);
 
278
      printf ("  SHRT_MAX   %s\n", shrt_max_def);
 
279
      printf ("\n");
 
280
 
 
281
#ifdef _CRAY
 
282
      printf ("_CRAY is defined, so limits.h is being used\n");
 
283
#endif
 
284
 
 
285
      printf ("ULONG_MAX      %lX\n", ULONG_MAX);
 
286
      printf ("ULONG_HIGHBIT  %lX\n", ULONG_HIGHBIT);
 
287
      printf ("LONG_MAX       %lX\n", LONG_MAX);
 
288
      printf ("LONG_MIN       %lX\n", LONG_MIN);
 
289
 
 
290
      printf ("UINT_MAX       %X\n", UINT_MAX);
 
291
      printf ("UINT_HIGHBIT   %X\n", UINT_HIGHBIT);
 
292
      printf ("INT_MAX        %X\n", INT_MAX);
 
293
      printf ("INT_MIN        %X\n", INT_MIN);
 
294
 
 
295
      printf ("USHRT_MAX      %hX\n", USHRT_MAX);
 
296
      printf ("USHRT_HIGHBIT  %hX\n", USHRT_HIGHBIT);
 
297
      printf ("SHRT_MAX       %hX\n", SHRT_MAX);
 
298
      printf ("SHRT_MIN       %hX\n", SHRT_MIN);
 
299
 
 
300
      printf ("\n");
 
301
      printf ("Bits\n");
 
302
      CALC_BITS (bits, long);           printf ("  long           %d\n", bits);
 
303
      CALC_BITS (bits, int);            printf ("  int            %d\n", bits);
 
304
      CALC_BITS (bits, short);          printf ("  short          %d\n", bits);
 
305
      CALC_BITS (bits, unsigned long);  printf ("  unsigned long  %d\n", bits);
 
306
      CALC_BITS (bits, unsigned int);   printf ("  unsigned int   %d\n", bits);
 
307
      CALC_BITS (bits, unsigned short); printf ("  unsigned short %d\n", bits);
 
308
      CALC_BITS (bits, mp_size_t);      printf ("  mp_size_t      %d\n", bits);
 
309
    }
 
310
 
 
311
  if (error)
 
312
    abort ();
 
313
 
 
314
  exit (0);
 
315
}