]> gcc.gnu.org Git - gcc.git/blob - gcc/enquire.c
git://gcc.gnu.org / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
(i_define, u_define, f_define): Add #undef before #define.
[gcc.git] / gcc / enquire.c
1 /* Everything you wanted to know about your machine and C compiler,
2 but didn't know who to ask. */
3
4 #ifndef VERSION
5 #define VERSION "4.3"
6 #endif
7
8 /* Author: Steven Pemberton, CWI, Amsterdam; steven@cwi.nl
9 Bugfixes and upgrades gratefully received.
10
11 Copyright (c) 1988, 1989, 1990 Steven Pemberton, CWI, Amsterdam.
12 All rights reserved.
13
14 Changes by Richard Stallman:
15 Undef CHAR_BIT, etc., if defined in stdio.h, Richard Stallman, Aug 90.
16 In EPROP, avoid a <= old if bad is set, Richard Stallman, May 91.
17 Use gstddef.h, not stddef.h, Richard Stallman, Nov 91.
18 Don't declare malloc, instead cast the value, Richard Stallman, Nov 91.
19 Include sys/types.h before signal.h, Apr 92.
20 Support NO_LONG_DOUBLE_IO in f_define and f_rep; new fn fake_f_rep, Apr 92.
21 Enclose -f output in #ifndef _FLOAT_H___, Richard Stallman, May 92.
22 Add #undef before every #define, Jim Wilson, Dec 92.
23
24 COMPILING
25 With luck and a following wind, just the following will work:
26 cc enquire.c -o enquire
27 You may get some messages about unreachable code, which you can ignore.
28
29 If your compiler doesn't support: add flag:
30 signed char (eg pcc) -DNO_SC
31 unsigned char -DNO_UC
32 unsigned short and long -DNO_UI
33 void -DNO_VOID
34 signal(), or setjmp/longjmp() -DNO_SIG
35 %Lf in printf -DNO_LONG_DOUBLE_IO
36
37 Try to compile first with no flags, and see if you get any errors -
38 you might be surprised. (Most non-ANSI compilers need -DNO_SC, though.)
39 Some compilers need a -f flag for floating point.
40
41 Don't use any optimisation flags: the program may not work if you do.
42 Though "while (a+1.0-a-1.0 == 0.0)" may look like "while(1)" to an
43 optimiser, to a floating-point unit there's a world of difference.
44
45 Some compilers offer various flags for different floating point
46 modes; it's worth trying all possible combinations of these.
47
48 Add -DID=\"name\" if you want the machine/flags identified in the output.
49
50 FAULTY COMPILERS
51 Because of bugs and/or inadequacies, some compilers need the following
52 defines:
53
54 If your C preprocessor doesn't have the predefined __FILE__ macro, and
55 you don't want to call this file enquire.c but, say, tell.c, add the
56 flag -DFILENAME=\"tell.c\" .
57
58 Some compilers won't accept the line "#include FILENAME".
59 Add flag -DNO_FILE. In that case, this file *must* be called enquire.c.
60
61 Some compilers can't cope with "#ifdef __FILE__". Use -DFILENAME=
62 or -DNO_FILE as above.
63
64 Some naughty compilers define __STDC__, but don't really support it.
65 Some define it as 0, in which case we treat it as undefined.
66 But if your compiler defines it, and isn't really ANSI C,
67 add flag -DNO_STDC. (To those compiler writers: for shame).
68
69 Some naughty compilers define __STDC__, but don't have the stddef.h
70 include file. Add flag -DNO_STDDEF.
71
72 Summary of naughty-compiler flags:
73 If your compiler doesn't support: add flag:
74 __FILE__ (and you changed the filename) -DFILENAME=\"name.c\"
75 #ifdef __FILE__ -DNO_FILE or -DFILENAME=...
76 #include FILENAME -DNO_FILE
77 __STDC__ (properly) -DNO_STDC
78 stddef.h -DNO_STDDEF
79
80 Some systems crash when you try to malloc all store. To save users of
81 such defective systems too much grief, they may compile with -DNO_MEM,
82 which ignores that bit of the code.
83
84 While it is not our policy to support defective compilers, pity has been
85 taken on people with compilers that can't produce object files bigger than
86 32k (especially since it was an easy addition). Compile the program
87 into separate parts like this:
88 cc -DSEP -DPASS0 -o p0.o <other flags> enquire.c
89 cc -DSEP -DPASS1 -o p1.o <other flags> enquire.c
90 cc -DSEP -DPASS2 -o p2.o <other flags> enquire.c
91 cc -DSEP -DPASS3 -o p3.o <other flags> enquire.c
92 cc -o enquire p0.o p1.o p2.o p3.o
93
94 SYSTEM DEPENDENCIES
95 You may possibly need to add some calls to signal() for other sorts of
96 exception on your machine than SIGFPE, and SIGOVER. See lines beginning
97 #ifdef SIGxxx in main() (and communicate the differences to me!).
98
99 OUTPUT
100 Run without argument to get the information as English text. If run
101 with argument -l (e.g. enquire -l), output is a series of #define's for
102 the ANSI standard limits.h include file, excluding MB_MAX_CHAR. If run
103 with argument -f, output is a series of #define's for the ANSI standard
104 float.h include file (according to ANSI C Draft of Dec 7, 1988).
105 Flag -v gives verbose output: output includes the English text above
106 as C comments. The program exit(0)'s if everything went ok, otherwise
107 it exits with a positive number, telling how many problems there were.
108
109 VERIFYING THE COMPILER
110 If, having produced the float.h and limits.h header files, you want to
111 verify that the compiler reads them back correctly (there are a lot of
112 boundary cases, of course, like minimum and maximum numbers), you can
113 recompile enquire.c with -DVERIFY set (plus the other flags that you used
114 when compiling the version that produced the header files). This then
115 recompiles the program so that it #includes "limits.h" and "float.h",
116 and checks that the constants it finds there are the same as the
117 constants it produces. Run the resulting program with enquire -fl.
118 Very few compilers have passed without error.
119 NB: You *must* recompile with the same compiler and flags, otherwise
120 you may get odd results.
121
122 You can also use this option if your compiler already has both files,
123 and you want to confirm that this program produces the right results.
124
125 TROUBLESHOOTING.
126 This program is now quite trustworthy, and suspicious and wrong output
127 may well be caused by bugs in the compiler, not in the program (however
128 of course, this is not guaranteed, and no responsibility can be
129 accepted, etc.)
130
131 The program only works if overflows are ignored by the C system or
132 are catchable with signal().
133
134 If the program fails to run to completion (often with the error message
135 "Unexpected signal at point x"), this often turns out to be a bug in the
136 C compiler's run-time system. Check what was about to be printed, and
137 try to narrow the problem down.
138
139 Another possible problem is that you have compiled the program to produce
140 loss-of-precision arithmetic traps. The program cannot cope with these,
141 and you should re-compile without them. (They should never be the default).
142
143 Make sure you compiled with optimisation turned off.
144
145 Output preceded by *** WARNING: identifies behaviour of the C system
146 deemed incorrect by the program. Likely problems are that printf or
147 scanf don't cope properly with certain boundary numbers: this program
148 goes to a lot of trouble to calculate its values, and these values
149 are mostly boundary numbers. Experience has shown that often printf
150 cannot cope with these values, and so in an attempt to increase
151 confidence in the output, for each float and double that is printed,
152 the printed value is checked by using sscanf to read it back.
153 Care is taken that numbers are printed with enough digits to uniquely
154 identify them, and therefore that they can be read back identically.
155 If the number read back is different, then there is probably a bug in
156 printf or sscanf, and the program prints the warning message.
157 If the two numbers in the warning look identical, then printf is more
158 than likely rounding the last digit(s) incorrectly. To put you at ease
159 that the two really are different, the bit patterns of the two numbers
160 are also printed. The difference is very likely in the last bit.
161 Many scanf's read the minimum double back as 0.0, and similarly cause
162 overflow when reading the maximum double. This program quite ruthlessly
163 declares all these behaviours faulty. The point is that if you get
164 one of these warnings, the output may be wrong, so you should check
165 the result carefully if you intend to use the results. Of course, printf
166 and sscanf may both be wrong, and cancel each other out, so you should
167 check the output carefully anyway.
168
169 The warning that "a cast didn't work" refers to cases like this:
170
171 float f;
172 #define C 1.234567890123456789
173 f= C;
174 if (f != (float) C) printf ("Wrong!");
175
176 A faulty compiler will widen f to double and ignore the cast to float,
177 and because there is more accuracy in a double than a float, fail to
178 recognise that they are the same. In the actual case in point, f and C
179 are passed as parameters to a function that discovers they are not equal,
180 so it's just possible that the error was in the parameter passing,
181 not in the cast (see function Validate()).
182 For ANSI C, which has float constants, the error message is "constant has
183 wrong precision".
184
185 REPORTING PROBLEMS
186 If the program doesn't work for you for any reason that can't be
187 narrowed down to a problem in the C compiler, or it has to be changed in
188 order to get it to compile, or it produces suspicious output (like a very
189 low maximum float, for instance), please mail the problem and an example
190 of the incorrect output to steven@cwi.nl or ..!hp4nl!cwi.nl!steven, so that
191 improvements can be worked into future versions; cwi.nl is the European
192 backbone, and is connected to uunet and other fine hosts.
193
194 The program tries to catch and diagnose bugs in the compiler/run-time
195 system. I would be especially pleased to have reports of failures so
196 that I can improve this service.
197
198 I apologise unreservedly for the contorted use of the preprocessor...
199
200 THE SMALL PRINT
201 You may copy and distribute verbatim copies of this source file.
202
203 You may modify this source file, and copy and distribute such
204 modified versions, provided that you leave the copyright notice
205 at the top of the file and also cause the modified file to carry
206 prominent notices stating that you changed the files and the date
207 of any change; and cause the whole of any work that you distribute
208 or publish, that in whole or in part contains or is a derivative of
209 this program or any part thereof, to be licensed at no charge to
210 all third parties on terms identical to those here.
211
212 If you do have a fix to any problem, please send it to me, so that
213 other people can have the benefits.
214
215 While every effort has been taken to make this program as reliable as
216 possible, no responsibility can be taken for the correctness of the
217 output, nor suitability for any particular use.
218
219 This program is an offshoot of a project funded by public funds.
220 If you use this program for research or commercial use (i.e. more
221 than just for the fun of knowing about your compiler) mailing a short
222 note of acknowledgement may help keep enquire.c supported.
223
224 ACKNOWLEDGEMENTS
225 Many people have given time and ideas to making this program what it is.
226 To all of them thanks, and apologies for not mentioning them by name.
227
228 HISTORY
229 Originally started as a program to generate configuration constants
230 for a large piece of software we were writing, which later took on
231 a life of its own...
232 1.0 Length 6658!; end 1984?
233 Unix only. Only printed a dozen maximum int/double values.
234 2.0 Length 10535; Spring 1985
235 Prints values as #defines (about 20 of them)
236 More extensive floating point, using Cody and Waite
237 Handles signals better
238 Programs around optimisations
239 Handles Cybers
240 3.0 Length 12648; Aug 1987; prints about 42 values
241 Added PASS stuff, so treats float as well as double
242 4.0 Length 33891; Feb 1989; prints around 85 values
243 First GNU version (for gcc, where they call it hard-params.c)
244 Generates float.h and limits.h files
245 Handles long double
246 Generates warnings for dubious output
247 4.1 Length 47738; April 1989
248 Added VERIFY and TEST
249 4.2 Length 63442; Feb 1990
250 Added SEP
251 Fixed eps/epsneg
252 Added check for pseudo-unsigned chars
253 Added description for each #define output
254 Added check for absence of defines during verify
255 Added prototypes
256 Added NO_STDC and NO_FILE
257 Fixed alignments output
258 4.3 Length 75000; Oct 1990; around 114 lines of output
259 Function xmalloc defined, Richard Stallman, June 89.
260 Alignments computed from member offsets rather than structure sizes,
261 Richard Stallman, Oct 89.
262 Print whether char* and int* pointers have the same format;
263 also char * and function *.
264 Update to Draft C version Dec 7, 1988
265 - types of constants produced in limits.h
266 (whether to put a U after unsigned shorts and chars and
267 whether to output -1024 as (-1023-1))
268 - values of SCHAR_MIN/MAX
269 - values of *_EPSILON (not the smallest but the effective smallest)
270 Added FILENAME, since standard C doesn't allow #define __FILE__
271 Renamed from config.c to enquire.c
272 Added size_t and ptrdiff_t enquiries
273 Added promotion enquiries
274 Added type checks of #defines
275 Added NO_STDDEF
276 Changed endian to allow for cases where not all bits are used
277 Sanity check for max integrals
278 Fixed definition of setjmp for -DNO_SIG
279 Moved #define ... 0.0L inside #ifdef STDC, in case some cpp's tokenize
280 Added NO_MEM
281 */
282
283 /* Set FILENAME to the name of this file */
284 #ifndef FILENAME
285 #ifdef NO_FILE
286 #define FILENAME "enquire.c"
287 #else
288 #ifdef __FILE__ /* It's a compiler bug if this fails. Compile with -DNO_FILE */
289 #define FILENAME __FILE__
290 #else
291 #define FILENAME "enquire.c"
292 #endif /* __FILE__ */
293 #endif /* NO_FILE */
294 #endif /* FILENAME */
295
296 /* If PASS isn't defined, then this is the first pass over this file. */
297 #ifndef PASS
298 #ifndef SEP
299 #define PASS 1
300 #define PASS0 1
301 #define PASS1 1
302 #endif /* SEP */
303
304 /* A description of the ANSI constants */
305 #define D_CHAR_BIT "Number of bits in a storage unit"
306 #define D_CHAR_MAX "Maximum char"
307 #define D_CHAR_MIN "Minimum char"
308 #define D_SCHAR_MAX "Maximum signed char"
309 #define D_SCHAR_MIN "Minimum signed char"
310 #define D_UCHAR_MAX "Maximum unsigned char (minimum is always 0)"
311
312 #define D_INT_MAX "Maximum %s"
313 #define D_INT_MIN "Minimum %s"
314 #define D_UINT_MAX "Maximum unsigned %s (minimum is always 0)"
315
316 #define D_FLT_ROUNDS "Addition rounds to 0: zero, 1: nearest, 2: +inf, 3: -inf, -1: unknown"
317 #define D_FLT_RADIX "Radix of exponent representation"
318 #define D_MANT_DIG "Number of base-FLT_RADIX digits in the significand of a %s"
319 #define D_DIG "Number of decimal digits of precision in a %s"
320 #define D_MIN_EXP "Minimum int x such that FLT_RADIX**(x-1) is a normalised %s"
321 #define D_MIN_10_EXP "Minimum int x such that 10**x is a normalised %s"
322 #define D_MAX_EXP "Maximum int x such that FLT_RADIX**(x-1) is a representable %s"
323 #define D_MAX_10_EXP "Maximum int x such that 10**x is a representable %s"
324 #define D_MAX "Maximum %s"
325 #define D_EPSILON "Difference between 1.0 and the minimum %s greater than 1.0"
326 #define D_MIN "Minimum normalised %s"
327
328 /* Procedure just marks the functions that don't return a result */
329 #ifdef NO_VOID
330 #define Procedure int
331 #else
332 #define Procedure void
333 #endif
334
335 /* Some bad compilers define __STDC__, when they don't support it.
336 Compile with -DNO_STDC to get round this.
337 */
338 #ifndef NO_STDC
339 #ifdef __STDC__
340 #if __STDC__ /* If __STDC__ is 0, assume it isn't supported */
341 #define STDC
342 #endif
343 #endif
344 #endif
345
346 /* Stuff different for ANSI C, and old C:
347 ARGS and NOARGS are used for function prototypes.
348 Volatile is used to reduce the chance of optimisation,
349 and to prevent variables being put in registers (when setjmp/longjmp
350 wouldn't work as we want)
351 Long_double is the longest floating point type available.
352 stdc is used in tests like "if (stdc)", which is less ugly than #ifdef.
353 U is output after unsigned constants.
354 */
355 #ifdef STDC
356
357 #define ARGS(x) x
358 #define NOARGS (void)
359 #define Volatile volatile
360 #define Long_double long double
361 #define stdc 1
362 #define U "U"
363
364 #else /* Old style C */
365
366 #define ARGS(x) ()
367 #define NOARGS ()
368 #define Volatile static
369 #define Long_double double
370 #define stdc 0
371 #define U ""
372
373 #endif /* STDC */
374
375 /* include files */
376 #include <stdio.h>
377
378 #ifdef STDC
379 #ifndef NO_STDDEF
380 #include "gstddef.h" /* for size_t: if this fails, define NO_STDDEF */
381 #endif
382 #endif
383
384 #ifdef NO_SIG
385 #define jmp_buf int
386 #else
387 #include <sys/types.h>
388 #include <signal.h>
389 #include <setjmp.h>
390 #endif
391
392 /* Kludge around the possibility that <stdio.h> includes <limits.h> */
393 #ifdef CHAR_BIT
394 #undef CHAR_BIT
395 #undef CHAR_MAX
396 #undef CHAR_MIN
397 #undef SCHAR_MAX
398 #undef SCHAR_MIN
399 #undef UCHAR_MAX
400 #undef UCHAR_MIN
401 #endif
402
403 #ifdef VERIFY
404 #include "limits.h"
405 #include "float.h"
406 #endif
407
408 #define Vprintf if (V) printf
409 #define Unexpected(place) if (setjmp(lab)!=0) croak(place)
410 #define fabs(x) (((x)<0.0)?(-x):(x))
411
412 #endif /* PASS */
413
414 #ifdef PASS0
415
416 /* Prototypes for what's to come: */
417
418 int false NOARGS;
419
420 #ifdef NO_STDDEF
421 char *malloc (); /* Old style prototype */
422 #else
423 char *malloc ARGS((size_t size));
424 #endif
425
426 Procedure exit ARGS((int status));
427
428 char *f_rep ARGS((int precision, Long_double val));
429 char *fake_f_rep ARGS((char *type, Long_double val));
430
431 int maximum_int NOARGS;
432 int cprop NOARGS;
433 int basic NOARGS;
434 Procedure sprop NOARGS;
435 Procedure iprop NOARGS;
436 Procedure lprop NOARGS;
437 Procedure usprop NOARGS;
438 Procedure uiprop NOARGS;
439 Procedure ulprop NOARGS;
440 int fprop ARGS((int bits_per_byte));
441 int dprop ARGS((int bits_per_byte));
442 int ldprop ARGS((int bits_per_byte));
443 Procedure efprop ARGS((int fprec, int dprec, int lprec));
444 Procedure edprop ARGS((int fprec, int dprec, int lprec));
445 Procedure eldprop ARGS((int fprec, int dprec, int lprec));
446
447 int setmode ARGS((char *s));
448 Procedure farewell ARGS((int bugs));
449 Procedure describe ARGS((char *description, char *extra));
450 Procedure missing ARGS((char *s));
451 Procedure fmissing ARGS((char *s));
452 Procedure check_defines NOARGS;
453 Procedure bitpattern ARGS((char *p, unsigned int size));
454 int ceil_log ARGS((int base, Long_double x));
455 Procedure croak ARGS((int place));
456 Procedure eek_a_bug ARGS((char *problem));
457 Procedure endian ARGS((int bits_per_byte));
458 int exponent ARGS((Long_double x, double *fract, int *exp));
459 int floor_log ARGS((int base, Long_double x));
460 Procedure f_define ARGS((char *desc, char *extra, char *sort, char *name,
461 int prec, Long_double val, char *mark));
462 Procedure i_define ARGS((char *desc, char *extra, char *sort, char *name,
463 long val, long lim, long req, char *mark));
464 Procedure u_define ARGS((char *desc, char *extra, char *sort, char *name,
465 unsigned long val, unsigned long req, char *mark));
466
467 #ifdef NO_SIG /* There's no signal(), or setjmp/longjmp() */
468
469 /* Dummy routines instead */
470
471 int setjmp ARGS((int lab));
472
473 int lab=1;
474 int setjmp(lab) int lab; { return(0); }
475 Procedure signal(i, p) int i, (*p)(); {}
476
477 #else
478 jmp_buf lab;
479 Procedure overflow(sig) int sig; { /* what to do on over/underflow */
480 signal(sig, overflow);
481 longjmp(lab, 1);
482 }
483
484 #endif /*NO_SIG*/
485
486 int V= 0, /* verbose */
487 L= 0, /* produce limits.h */
488 F= 0, /* produce float.h */
489 bugs=0; /* The number of (possible) bugs in the output */
490
491 char co[4], oc[4]; /* Comment starter and ender symbols */
492
493 int bits_per_byte; /* the number of bits per unit returned by sizeof() */
494 int flt_rounds; /* The calculated value of FLT_ROUNDS */
495 int flt_radix; /* The calculated value of FLT_RADIX */
496
497 #ifdef TEST
498 /* Set the fp modes on a SUN with 68881 chip, to check that different
499 rounding modes etc. get properly detected.
500 Compile with -f68881 for cc, -m68881 for gcc, and with additional flag
501 -DTEST. Run with additional parameter +hex-number, to set the 68881 mode
502 register to hex-number
503 */
504
505 /* Bits 0x30 = rounding mode */
506 #define ROUND_BITS 0x30
507 #define TO_NEAREST 0x00
508 #define TO_ZERO 0x10
509 #define TO_MINUS_INF 0x20
510 #define TO_PLUS_INF 0x30 /* The SUN FP user's guide seems to be wrong here */
511
512 /* Bits 0xc0 = extended rounding */
513 #define EXT_BITS 0xc0
514 #define ROUND_EXTENDED 0x00
515 #define ROUND_SINGLE 0x40
516 #define ROUND_DOUBLE 0x80
517
518 /* Enabled traps */
519 #define EXE_INEX1 0x100
520 #define EXE_INEX2 0x200
521 #define EXE_DZ 0x400
522 #define EXE_UNFL 0x800
523 #define EXE_OVFL 0x1000
524 #define EXE_OPERR 0x2000
525 #define EXE_SNAN 0x4000
526 #define EXE_BSUN 0x8000
527
528 /* Only used for testing, on a Sun with 68881 chip */
529 /* Print the FP mode */
530 printmode(new) unsigned new; {
531 fpmode_(&new);
532 printf("New fp mode:\n");
533 printf(" Round toward ");
534 switch (new & ROUND_BITS) {
535 case TO_NEAREST: printf("nearest"); break;
536 case TO_ZERO: printf("zero"); break;
537 case TO_MINUS_INF: printf("minus infinity"); break;
538 case TO_PLUS_INF: printf("plus infinity"); break;
539 default: printf("???"); break;
540 }
541
542 printf("\n Extended rounding precision: ");
543
544 switch (new & EXT_BITS) {
545 case ROUND_EXTENDED: printf("extended"); break;
546 case ROUND_SINGLE: printf("single"); break;
547 case ROUND_DOUBLE: printf("double"); break;
548 default: printf("???"); break;
549 }
550
551 printf("\n Enabled exceptions:");
552 if (new & (unsigned) EXE_INEX1) printf(" inex1");
553 if (new & (unsigned) EXE_INEX2) printf(" inex2");
554 if (new & (unsigned) EXE_DZ) printf(" dz");
555 if (new & (unsigned) EXE_UNFL) printf(" unfl");
556 if (new & (unsigned) EXE_OVFL) printf(" ovfl");
557 if (new & (unsigned) EXE_OPERR) printf(" operr");
558 if (new & (unsigned) EXE_SNAN) printf(" snan");
559 if (new & (unsigned) EXE_BSUN) printf(" bsun");
560 printf("\n");
561 }
562
563 /* Only used for testing, on a Sun with 68881 chip */
564 /* Set the FP mode */
565 int setmode(s) char *s; {
566 unsigned mode=0, dig;
567 char c;
568
569 while (*s) {
570 c= *s++;
571 if (c>='0' && c<='9') dig= c-'0';
572 else if (c>='a' && c<='f') dig= c-'a'+10;
573 else if (c>='A' && c<='F') dig= c-'A'+10;
574 else return 1;
575 mode= mode<<4 | dig;
576 }
577 printmode(mode);
578 return 0;
579 }
580 #else
581 /* ARGSUSED */
582 int setmode(s) char *s; {
583 fprintf(stderr, "Can't set mode: not compiled with TEST\n");
584 return(1);
585 }
586 #endif
587
588 Procedure farewell(bugs) int bugs; {
589 if (bugs == 0) exit(0);
590 printf("\n%sFor hints on dealing with the ", co);
591 if (bugs == 1) printf("problem");
592 else printf("%d problems", bugs);
593 printf(" above\n see the section 'TROUBLESHOOTING' in the file ");
594 printf("%s%s\n", FILENAME, oc);
595 exit(bugs);
596 }
597
598 /* The program has received a signal where it wasn't expecting one */
599 Procedure croak(place) int place; {
600 printf("*** Unexpected signal at point %d\n", place);
601 farewell(bugs+1); /* An exit isn't essential here, but avoids loops */
602 }
603
604 /* This is here in case alloca.c is used, which calls this. */
605 char *xmalloc(size) unsigned size; {
606 char *value = (char *)malloc(size);
607 if (value == 0) {
608 fprintf(stderr, "Virtual memory exceeded\n");
609 exit(bugs+1);
610 }
611 return value;
612 }
613
614 int maxint;
615
616 int maximum_int() {
617 /* Find the maximum integer */
618 Volatile int newi, int_max, two=2;
619
620 /* Calculate maxint ***********************************/
621 /* Calculate 2**n-1 until overflow - then use the previous value */
622
623 newi=1; int_max=0;
624
625 if (setjmp(lab)==0) { /* Yields int_max */
626 while(newi>int_max) {
627 int_max=newi;
628 newi=newi*two+1;
629 }
630 }
631 Unexpected(0);
632 return int_max;
633 }
634
635 int main(argc, argv) int argc; char *argv[]; {
636 int dprec, fprec, lprec;
637 unsigned int size;
638 long total;
639 int i; char *s; int bad;
640
641 #ifdef SIGFPE
642 signal(SIGFPE, overflow);
643 #endif
644 #ifdef SIGOVER
645 signal(SIGOVER, overflow);
646 #endif
647 /* Add more calls as necessary */
648
649 Unexpected(1);
650
651 bad=0;
652 for (i=1; i < argc; i++) {
653 s= argv[i];
654 if (*s == '-') {
655 s++;
656 while (*s) {
657 switch (*(s++)) {
658 case 'v': V=1; break;
659 case 'l': L=1; break;
660 case 'f': F=1; break;
661 default: bad=1; break;
662 }
663 }
664 } else if (*s == '+') {
665 s++;
666 bad= setmode(s);
667 } else bad= 1;
668 }
669 if (bad) {
670 fprintf(stderr,
671 "Usage: %s [-vlf]\n v=Verbose l=Limits.h f=Float.h\n",
672 argv[0]);
673 exit(1);
674 }
675 if (L || F) {
676 co[0]= '/'; oc[0]= ' ';
677 co[1]= '*'; oc[1]= '*';
678 co[2]= ' '; oc[2]= '/';
679 co[3]= '\0'; oc[3]= '\0';
680 } else {
681 co[0]= '\0'; oc[0]= '\0';
682 V=1;
683 }
684
685 if (L) printf("%slimits.h%s\n", co, oc);
686 if (F) printf("%sfloat.h%s\n", co, oc);
687 if (F) {
688 printf ("#ifndef _FLOAT_H___\n");
689 printf ("#define _FLOAT_H___\n");
690 }
691 #ifdef ID
692 printf("%sProduced on %s by enquire version %s, CWI, Amsterdam%s\n",
693 co, ID, VERSION, oc);
694 #else
695 printf("%sProduced by enquire version %s, CWI, Amsterdam%s\n",
696 co, VERSION, oc);
697 #endif
698
699 #ifdef VERIFY
700 printf("%sVerification phase%s\n", co, oc);
701 #endif
702
703 #ifdef NO_SIG
704 Vprintf("%sCompiled without signal(): %s%s\n",
705 co,
706 "there's nothing that can be done if overflow occurs",
707 oc);
708 #endif
709 #ifdef NO_SC
710 Vprintf("%sCompiled without signed char%s\n", co, oc);
711 #endif
712 #ifdef NO_UC
713 Vprintf("%Compiled without unsigned char%s\n", co, oc);
714 #endif
715 #ifdef NO_UI
716 Vprintf("%Compiled without unsigned short or long%s\n", co, oc);
717 #endif
718 #ifdef __STDC__
719 Vprintf("%sCompiler claims to be ANSI C level %d%s\n",
720 co, __STDC__, oc);
721 #else
722 Vprintf("%sCompiler does not claim to be ANSI C%s\n", co, oc);
723 #endif
724 printf("\n");
725 check_defines();
726
727 maxint= maximum_int();
728 bits_per_byte= basic();
729 Vprintf("\n");
730 if (F||V) {
731 fprec= fprop(bits_per_byte);
732 dprec= dprop(bits_per_byte);
733 lprec= ldprop(bits_per_byte);
734 efprop(fprec, dprec, lprec);
735 edprop(fprec, dprec, lprec);
736 eldprop(fprec, dprec, lprec);
737 }
738 #ifndef NO_MEM
739 if (V) {
740 /* An extra goody: the approximate amount of data-space */
741 /* Allocate store until no more available */
742 /* Different implementations have a different argument type
743 to malloc. Here we assume that it's the same type as
744 that which sizeof() returns */
745 size=1<<((bits_per_byte*sizeof(int))-2);
746 total=0;
747 while (size!=0) {
748 while ( malloc((false()?sizeof(int):size)) !=
749 (char *)NULL
750 ) {
751 total+=(size/2);
752 }
753 size/=2;
754 }
755
756 Vprintf("%sMemory mallocatable ~= %ld Kbytes%s\n",
757 co, (total+511)/512, oc);
758 }
759 #endif
760 if (F) {
761 printf ("#endif %s _FLOAT_H___%s\n", co, oc);
762 }
763 farewell(bugs);
764 return bugs; /* To keep compilers and lint happy */
765 }
766
767 Procedure eek_a_bug(problem) char *problem; {
768 /* The program has discovered a problem */
769 printf("\n%s*** WARNING: %s%s\n", co, problem, oc);
770 bugs++;
771 }
772
773 Procedure describe(description, extra) char *description, *extra; {
774 /* Produce the description for a #define */
775 printf(" %s", co);
776 printf(description, extra);
777 printf("%s\n", oc);
778 }
779
780 Procedure i_define(desc, extra, sort, name, val, lim, req, mark)
781 char *desc, *extra, *sort, *name; long val, lim, req; char *mark; {
782 /* Produce a #define for a signed int type */
783 describe(desc, extra);
784 printf("#undef %s%s\n", sort, name);
785 if (val >= 0) {
786 printf("#define %s%s %ld%s\n", sort, name, val, mark);
787 } else if (val + lim < 0) {
788 /* We may not produce a constant like -1024 if the max
789 allowable value is 1023. It has then to be output as
790 -1023-1. lim is the max allowable value. */
791 printf("#define %s%s (%ld%s%ld%s)\n",
792 sort, name, -lim, mark, val+lim, mark);
793 } else {
794 printf("#define %s%s (%ld%s)\n", sort, name, val, mark);
795 }
796 /* If VERIFY is not set, val and req are just the same value;
797 if it is set, val is the value as calculated, and req is
798 the #defined constant
799 */
800 if (val != req) {
801 printf("%s*** Verify failed for above #define!\n", co);
802 printf(" Compiler has %ld for value%s\n\n", req, oc);
803 bugs++;
804 }
805 Vprintf("\n");
806 }
807
808 Procedure u_define(desc, extra, sort, name, val, req, mark)
809 char *desc, *extra, *sort, *name; unsigned long val, req; char *mark; {
810 /* Produce a #define for an unsigned value */
811 describe(desc, extra);
812 printf("#undef %s%s\n", sort, name);
813 printf("#define %s%s %lu%s%s\n", sort, name, val, U, mark);
814 if (val != req) {
815 printf("%s*** Verify failed for above #define!\n", co);
816 printf(" Compiler has %lu for value%s\n\n", req, oc);
817 bugs++;
818 }
819 Vprintf("\n");
820 }
821
822 Procedure f_define(desc, extra, sort, name, precision, val, mark)
823 char *desc, *extra, *sort, *name; int precision;
824 Long_double val; char *mark; {
825 /* Produce a #define for a float/double/long double */
826 describe(desc, extra);
827 printf ("#undef %s%s\n", sort, name);
828 if (stdc) {
829 #ifdef NO_LONG_DOUBLE_IO
830 static int union_defined = 0;
831 if (!strcmp(sort, "LDBL")) {
832 if (!union_defined) {
833 printf("#ifndef __LDBL_UNION__\n");
834 printf("#define __LDBL_UNION__\n");
835 printf("union __convert_long_double {\n");
836 printf(" int __convert_long_double_i[4];\n");
837 printf(" long double __convert_long_double_d;\n");
838 printf("};\n");
839 printf("#endif\n");
840 union_defined = 1;
841 }
842 printf("#define %s%s %s\n",
843 sort, name, fake_f_rep("long double", val));
844 } else {
845 printf("#define %s%s %s%s\n",
846 sort, name, f_rep(precision, val), mark);
847 }
848 #else
849 printf("#define %s%s %s%s\n",
850 sort, name, f_rep(precision, val), mark);
851 #endif
852 } else if (*mark == 'F') {
853 /* non-ANSI C has no float constants, so cast the constant */
854 printf("#define %s%s ((float)%s)\n",
855 sort, name, f_rep(precision, val));
856 } else {
857 printf("#define %s%s %s\n", sort, name, f_rep(precision, val));
858 }
859 Vprintf("\n");
860 }
861
862 int floor_log(base, x) int base; Long_double x; {
863 /* return floor(log base(x)) */
864 int r=0;
865 while (x>=base) { r++; x/=base; }
866 return r;
867 }
868
869 int ceil_log(base, x) int base; Long_double x; {
870 int r=0;
871 while (x>1.0) { r++; x/=base; }
872 return r;
873 }
874
875 int exponent(x, fract, exp) Long_double x; double *fract; int *exp; {
876 /* Split x into a fraction and a power of ten;
877 returns 0 if x is unusable, 1 otherwise.
878 Only used for error messages about faulty output.
879 */
880 int r=0, neg=0;
881 Long_double old;
882 *fract=0.0; *exp=0;
883 if (x<0.0) {
884 x= -x;
885 neg= 1;
886 }
887 if (x==0.0) return 1;
888 if (x>=10.0) {
889 while (x>=10.0) {
890 old=x; r++; x/=10.0;
891 if (old==x) return 0;
892 }
893 } else {
894 while (x<1.0) {
895 old=x; r--; x*=10.0;
896 if (old==x) return 0;
897 }
898 }
899 if (neg) *fract= (double) -x;
900 else *fract=(double) x;
901 *exp=r;
902 return 1;
903 }
904
905 /* Print a value of type TYPE with value VAL,
906 assuming that sprintf can't handle this type properly (without truncation).
907 We create an expression that uses type casting to create the value from
908 a bit pattern. */
909
910 char *fake_f_rep(type, val) char *type; Long_double val; {
911 static char buf[1024];
912 union { int i[4]; Long_double ld;} u;
913 u.ld = val;
914 sprintf(buf, "(__extension__ ((union __convert_long_double) {0x%x, 0x%x, 0x%x, 0x%x}).__convert_long_double_d)",
915 u.i[0], u.i[1], u.i[2], u.i[3]);
916 return buf;
917 }
918
919 char *f_rep(precision, val) int precision; Long_double val; {
920 /* Return the floating representation of val */
921 static char buf[1024];
922 char *f1;
923 #ifdef NO_LONG_DOUBLE_IO
924 if (1)
925 #else
926 if (sizeof(double) == sizeof(Long_double))
927 #endif
928 {
929 double d = val;
930 /* Assume they're the same, and use non-stdc format */
931 /* This is for stdc compilers using non-stdc libraries */
932 sprintf(buf, "%.*e", precision, d);
933 } else {
934 /* It had better support Le then */
935 sprintf(buf, "%.*Le", precision, val);
936 }
937 return buf;
938 }
939
940 Procedure bitpattern(p, size) char *p; unsigned int size; {
941 /* Printf the bit-pattern of p */
942 char c;
943 int i, j;
944
945 for (i=1; i<=size; i++) {
946 c= *p;
947 p++;
948 for (j=bits_per_byte-1; j>=0; j--)
949 printf("%c", (c>>j)&1 ? '1' : '0');
950 if (i!=size) printf(" ");
951 }
952 }
953
954 #define Order(x, px, mode)\
955 printf("%s%s ", co, mode); for (i=0; i<sizeof(x); i++) px[i]= ab[i]; \
956 for (i=1; i<=sizeof(x); i++) { c=((x>>(bits_per_byte*(sizeof(x)-i)))&mask);\
957 putchar(c==0 ? '?' : (char)c); }\
958 printf("%s\n", oc);
959
960 Procedure endian(bits_per_byte) int bits_per_byte; {
961 /* Printf the byte-order used on this machine */
962 /*unsigned*/ short s=0;
963 /*unsigned*/ int j=0;
964 /*unsigned*/ long l=0;
965
966 char *ps= (char *) &s,
967 *pj= (char *) &j,
968 *pl= (char *) &l,
969 *ab= "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
970 unsigned int mask, i, c;
971
972 mask=0;
973 for (i=1; i<=(unsigned)bits_per_byte; i++) mask= (mask<<1)|1;
974
975 if (V) {
976 printf("%sCHARACTER ORDER%s\n", co, oc);
977 Order(s, ps, "short:");
978 Order(j, pj, "int: ");
979 Order(l, pl, "long: ");
980 }
981 }
982
983 Procedure missing(s) char *s; {
984 printf("%s*** #define %s missing from limits.h%s\n", co, s, oc);
985 bugs++;
986 }
987
988 Procedure fmissing(s) char *s; {
989 printf("%s*** #define %s missing from float.h%s\n", co, s, oc);
990 bugs++;
991 }
992
993 /* To try and fool optimisers */
994 int false() { return 0; }
995
996 #define Promoted(x) (false()?(x):(-1))
997 #define is_signed(x) (Promoted(x) < 0)
998 #define sign_of(x) ((x)?"signed":"unsigned")
999 #define Signed 1
1000 #define Unsigned 0
1001 #define sgn(x) ((is_signed(x))?Signed:Unsigned)
1002
1003 #define showtype(t, x) Vprintf("%s%s %s %s%s\n", co, t, sign_of(is_signed(x)), type_of(sizeof(x)), oc)
1004
1005 char *type_of(x) int x; {
1006 if (x == sizeof(char)) {
1007 if (sizeof(char) == sizeof(int)) return "char/short/int";
1008 if (sizeof(char) == sizeof(short)) return "char/short";
1009 return "char";
1010 }
1011 if (x == sizeof(short)) {
1012 if (sizeof(short) == sizeof(int)) return "short/int";
1013 return "short";
1014 }
1015 if (x == sizeof(int)) {
1016 if (sizeof(int) == sizeof(long)) return "int/long";
1017 return "int";
1018 }
1019 if (x == sizeof(long)) return "long";
1020 return "unknown-type";
1021 }
1022
1023 char *ftype_of(x) int x; {
1024 if (x == sizeof(float)) {
1025 return "float";
1026 }
1027 if (x == sizeof(double)) {
1028 if (sizeof(double) == sizeof(Long_double))
1029 return "(long)double";
1030 return "double";
1031 }
1032 if (x == sizeof(Long_double)) {
1033 return "long double";
1034 }
1035 return "unknown-type";
1036 }
1037
1038 Procedure typerr(name, esign, esize, sign, size)
1039 char *name; int esign, esize, sign, size;
1040 {
1041 Vprintf("*** %s has wrong type: expected %s %s, found %s %s\n",
1042 name, sign_of(esign), type_of(esize),
1043 sign_of(sign), type_of(size));
1044 }
1045
1046 Procedure ftyperr(name, esize, size) char *name; int esize, size; {
1047 Vprintf("*** %s has wrong type: expected %s, found %s\n",
1048 name, ftype_of(esize), ftype_of(size));
1049 }
1050
1051 promotions() {
1052 int si; long sl;
1053 unsigned int ui; unsigned long ul;
1054 short ss; unsigned short us;
1055
1056 Vprintf("\n%sPROMOTIONS%s\n", co, oc);
1057
1058 if (
1059 /* Possible warnings here; no problem */
1060 (sizeof(Promoted(si)) != sizeof(int)) ||
1061 (sizeof(Promoted(sl)) != sizeof(long)) ||
1062 (sizeof(Promoted(ss)) != sizeof(int)) ||
1063 (sizeof(Promoted(ui)) != sizeof(int)) ||
1064 (sizeof(Promoted(ul)) != sizeof(long)) ||
1065 (sizeof(Promoted(us)) != sizeof(int)) ||
1066 is_signed(ui) || is_signed(ul) ||
1067 !is_signed(si) || !is_signed(sl)
1068 )
1069 {
1070 eek_a_bug("promotions don't work properly in conditional expressions\n");
1071 }
1072
1073 showtype("unsigned short promotes to", Promoted((unsigned short)0));
1074 showtype("long+unsigned gives", sl+ui);
1075 }
1076
1077 #define checktype(x, n, s, t) if((sgn(x)!=s)||(sizeof(x)!=sizeof(t))) typerr(n, s, sizeof(t), sign_of(x), sizeof(x));
1078
1079 #define fchecktype(x, n, t) if (sizeof(x) != sizeof(t)) ftyperr(n, sizeof(x), sizeof(t));
1080
1081 Procedure check_defines() {
1082 /* ensure that all #defines are present and have the correct type */
1083 #ifdef VERIFY
1084 int usign;
1085
1086 #ifdef NO_UI
1087 usign= Signed;
1088 #else
1089 /* Implementations promote unsigned short differently */
1090 usign= is_signed((unsigned short)0);
1091 #endif
1092
1093 if (L) {
1094 #ifdef CHAR_BIT
1095 checktype(CHAR_BIT, "CHAR_BIT", Signed, int);
1096 #else
1097 missing("CHAR_BIT");
1098 #endif
1099 #ifdef CHAR_MAX
1100 checktype(CHAR_MAX, "CHAR_MAX", Signed, int);
1101 #else
1102 missing("CHAR_MAX");
1103 #endif
1104 #ifdef CHAR_MIN
1105 checktype(CHAR_MIN, "CHAR_MIN", Signed, int);
1106 #else
1107 missing("CHAR_MIN");
1108 #endif
1109 #ifdef SCHAR_MAX
1110 checktype(SCHAR_MAX, "SCHAR_MAX", Signed, int);
1111 #else
1112 missing("SCHAR_MAX");
1113 #endif
1114 #ifdef SCHAR_MIN
1115 checktype(SCHAR_MIN, "SCHAR_MIN", Signed, int);
1116 #else
1117 missing("SCHAR_MIN");
1118 #endif
1119 #ifdef UCHAR_MAX
1120 checktype(UCHAR_MAX, "UCHAR_MAX", Signed, int);
1121 #else
1122 missing("UCHAR_MAX");
1123 #endif
1124 #ifdef SHRT_MAX
1125 checktype(SHRT_MAX, "SHRT_MAX", Signed, int);
1126 #else
1127 missing("SHRT_MAX");
1128 #endif
1129 #ifdef SHRT_MIN
1130 checktype(SHRT_MIN, "SHRT_MIN", Signed, int);
1131 #else
1132 missing("SHRT_MIN");
1133 #endif
1134 #ifdef INT_MAX
1135 checktype(INT_MAX, "INT_MAX", Signed, int);
1136 #else
1137 missing("INT_MAX");
1138 #endif
1139 #ifdef INT_MIN
1140 checktype(INT_MIN, "INT_MIN", Signed, int);
1141 #else
1142 missing("INT_MIN");
1143 #endif
1144 #ifdef LONG_MAX
1145 checktype(LONG_MAX, "LONG_MAX", Signed, long);
1146 #else
1147 missing("LONG_MAX");
1148 #endif
1149 #ifdef LONG_MIN
1150 checktype(LONG_MIN, "LONG_MIN", Signed, long);
1151 #else
1152 missing("LONG_MIN");
1153 #endif
1154 #ifdef USHRT_MAX
1155 checktype(USHRT_MAX, "USHRT_MAX", usign, int);
1156 #else
1157 missing("USHRT_MAX");
1158 #endif
1159 #ifdef UINT_MAX
1160 checktype(UINT_MAX, "UINT_MAX", Unsigned, int);
1161 #else
1162 missing("UINT_MAX");
1163 #endif
1164 #ifdef ULONG_MAX
1165 checktype(ULONG_MAX, "ULONG_MAX", Unsigned, long);
1166 #else
1167 missing("ULONG_MAX");
1168 #endif
1169 } /* if (L) */
1170
1171 if (F) {
1172 #ifdef FLT_RADIX
1173 checktype(FLT_RADIX, "FLT_RADIX", Signed, int);
1174 #else
1175 fmissing("FLT_RADIX");
1176 #endif
1177 #ifdef FLT_MANT_DIG
1178 checktype(FLT_MANT_DIG, "FLT_MANT_DIG", Signed, int);
1179 #else
1180 fmissing("FLT_MANT_DIG");
1181 #endif
1182 #ifdef FLT_DIG
1183 checktype(FLT_DIG, "FLT_DIG", Signed, int);
1184 #else
1185 fmissing("FLT_DIG");
1186 #endif
1187 #ifdef FLT_ROUNDS
1188 checktype(FLT_ROUNDS, "FLT_ROUNDS", Signed, int);
1189 #else
1190 fmissing("FLT_ROUNDS");
1191 #endif
1192 #ifdef FLT_EPSILON
1193 fchecktype(FLT_EPSILON, "FLT_EPSILON", float);
1194 #else
1195 fmissing("FLT_EPSILON");
1196 #endif
1197 #ifdef FLT_MIN_EXP
1198 checktype(FLT_MIN_EXP, "FLT_MIN_EXP", Signed, int);
1199 #else
1200 fmissing("FLT_MIN_EXP");
1201 #endif
1202 #ifdef FLT_MIN
1203 fchecktype(FLT_MIN, "FLT_MIN", float);
1204 #else
1205 fmissing("FLT_MIN");
1206 #endif
1207 #ifdef FLT_MIN_10_EXP
1208 checktype(FLT_MIN_10_EXP, "FLT_MIN_10_EXP", Signed, int);
1209 #else
1210 fmissing("FLT_MIN_10_EXP");
1211 #endif
1212 #ifdef FLT_MAX_EXP
1213 checktype(FLT_MAX_EXP, "FLT_MAX_EXP", Signed, int);
1214 #else
1215 fmissing("FLT_MAX_EXP");
1216 #endif
1217 #ifdef FLT_MAX
1218 fchecktype(FLT_MAX, "FLT_MAX", float);
1219 #else
1220 fmissing("FLT_MAX");
1221 #endif
1222 #ifdef FLT_MAX_10_EXP
1223 checktype(FLT_MAX_10_EXP, "FLT_MAX_10_EXP", Signed, int);
1224 #else
1225 fmissing("FLT_MAX_10_EXP");
1226 #endif
1227 #ifdef DBL_MANT_DIG
1228 checktype(DBL_MANT_DIG, "DBL_MANT_DIG", Signed, int);
1229 #else
1230 fmissing("DBL_MANT_DIG");
1231 #endif
1232 #ifdef DBL_DIG
1233 checktype(DBL_DIG, "DBL_DIG", Signed, int);
1234 #else
1235 fmissing("DBL_DIG");
1236 #endif
1237 #ifdef DBL_EPSILON
1238 fchecktype(DBL_EPSILON, "DBL_EPSILON", double);
1239 #else
1240 fmissing("DBL_EPSILON");
1241 #endif
1242 #ifdef DBL_MIN_EXP
1243 checktype(DBL_MIN_EXP, "DBL_MIN_EXP", Signed, int);
1244 #else
1245 fmissing("DBL_MIN_EXP");
1246 #endif
1247 #ifdef DBL_MIN
1248 fchecktype(DBL_MIN, "DBL_MIN", double);
1249 #else
1250 fmissing("DBL_MIN");
1251 #endif
1252 #ifdef DBL_MIN_10_EXP
1253 checktype(DBL_MIN_10_EXP, "DBL_MIN_10_EXP", Signed, int);
1254 #else
1255 fmissing("DBL_MIN_10_EXP");
1256 #endif
1257 #ifdef DBL_MAX_EXP
1258 checktype(DBL_MAX_EXP, "DBL_MAX_EXP", Signed, int);
1259 #else
1260 fmissing("DBL_MAX_EXP");
1261 #endif
1262 #ifdef DBL_MAX
1263 fchecktype(DBL_MAX, "DBL_MAX", double);
1264 #else
1265 fmissing("DBL_MAX");
1266 #endif
1267 #ifdef DBL_MAX_10_EXP
1268 checktype(DBL_MAX_10_EXP, "DBL_MAX_10_EXP", Signed, int);
1269 #else
1270 fmissing("DBL_MAX_10_EXP");
1271 #endif
1272 #ifdef STDC
1273 #ifdef LDBL_MANT_DIG
1274 checktype(LDBL_MANT_DIG, "LDBL_MANT_DIG", Signed, int);
1275 #else
1276 fmissing("LDBL_MANT_DIG");
1277 #endif
1278 #ifdef LDBL_DIG
1279 checktype(LDBL_DIG, "LDBL_DIG", Signed, int);
1280 #else
1281 fmissing("LDBL_DIG");
1282 #endif
1283 #ifdef LDBL_EPSILON
1284 fchecktype(LDBL_EPSILON, "LDBL_EPSILON", long double);
1285 #else
1286 fmissing("LDBL_EPSILON");
1287 #endif
1288 #ifdef LDBL_MIN_EXP
1289 checktype(LDBL_MIN_EXP, "LDBL_MIN_EXP", Signed, int);
1290 #else
1291 fmissing("LDBL_MIN_EXP");
1292 #endif
1293 #ifdef LDBL_MIN
1294 fchecktype(LDBL_MIN, "LDBL_MIN", long double);
1295 #else
1296 fmissing("LDBL_MIN");
1297 #endif
1298 #ifdef LDBL_MIN_10_EXP
1299 checktype(LDBL_MIN_10_EXP, "LDBL_MIN_10_EXP", Signed, int);
1300 #else
1301 fmissing("LDBL_MIN_10_EXP");
1302 #endif
1303 #ifdef LDBL_MAX_EXP
1304 checktype(LDBL_MAX_EXP, "LDBL_MAX_EXP", Signed, int);
1305 #else
1306 fmissing("LDBL_MAX_EXP");
1307 #endif
1308 #ifdef LDBL_MAX
1309 fchecktype(LDBL_MAX, "LDBL_MAX", long double);
1310 #else
1311 fmissing("LDBL_MAX");
1312 #endif
1313 #ifdef LDBL_MAX_10_EXP
1314 checktype(LDBL_MAX_10_EXP, "LDBL_MAX_10_EXP", Signed, int);
1315 #else
1316 fmissing("LDBL_MAX_10_EXP");
1317 #endif
1318 #endif /* STDC */
1319 } /* if (F) */
1320 #endif /* VERIFY */
1321 }
1322
1323 #ifdef VERIFY
1324 #ifndef SCHAR_MAX
1325 #define SCHAR_MAX char_max
1326 #endif
1327 #ifndef SCHAR_MIN
1328 #define SCHAR_MIN char_min
1329 #endif
1330 #ifndef UCHAR_MAX
1331 #define UCHAR_MAX char_max
1332 #endif
1333 #endif /* VERIFY */
1334
1335 #ifndef CHAR_BIT
1336 #define CHAR_BIT char_bit
1337 #endif
1338 #ifndef CHAR_MAX
1339 #define CHAR_MAX char_max
1340 #endif
1341 #ifndef CHAR_MIN
1342 #define CHAR_MIN char_min
1343 #endif
1344 #ifndef SCHAR_MAX
1345 #define SCHAR_MAX char_max
1346 #endif
1347 #ifndef SCHAR_MIN
1348 #define SCHAR_MIN char_min
1349 #endif
1350 #ifndef UCHAR_MAX
1351 #define UCHAR_MAX char_max
1352 #endif
1353
1354 int cprop() {
1355 /* Properties of type char */
1356 Volatile char c, char_max, char_min;
1357 Volatile int bits_per_byte, c_signed;
1358 long char_bit;
1359
1360 Unexpected(2);
1361
1362 /* Calculate number of bits per character *************************/
1363 c=1; bits_per_byte=0;
1364 do { c=c<<1; bits_per_byte++; } while(c!=0);
1365 c= (char)(-1);
1366 if (((int)c)<0) c_signed=1;
1367 else c_signed=0;
1368 Vprintf("%schar = %d bits, %ssigned%s\n",
1369 co, (int)sizeof(c)*bits_per_byte, (c_signed?"":"un"), oc);
1370 char_bit=(long)(sizeof(c)*bits_per_byte);
1371 if (L) i_define(D_CHAR_BIT, "", "CHAR", "_BIT",
1372 char_bit, 0L, (long) CHAR_BIT, "");
1373
1374 c=0; char_max=0;
1375 c++;
1376 if (setjmp(lab)==0) { /* Yields char_max */
1377 while (c>char_max) {
1378 char_max=c;
1379 c++;
1380 }
1381 } else {
1382 Vprintf("%sCharacter overflow generates a trap!%s\n", co, oc);
1383 }
1384 c=0; char_min=0;
1385 c--;
1386 if (setjmp(lab)==0) { /* Yields char_min */
1387 while (c<char_min) {
1388 char_min=c;
1389 c--;
1390 }
1391 }
1392 if (c_signed && char_min == 0) {
1393 Vprintf("%sBEWARE! Chars are pseudo-unsigned:%s\n", co, oc);
1394 Vprintf("%s %s%s%s\n",
1395 "They contain only nonnegative values, ",
1396 "but sign extend when used as integers.", co, oc);
1397 }
1398 Unexpected(3);
1399
1400 if (L) {
1401 /* Because of the integer promotions, you must use a U after
1402 the MAX_CHARS in the following cases */
1403 if ((sizeof(char) == sizeof(int)) && !c_signed) {
1404 u_define(D_CHAR_MAX, "", "CHAR", "_MAX",
1405 (long) char_max,
1406 (long) CHAR_MAX, "");
1407 } else {
1408 i_define(D_CHAR_MAX, "", "CHAR", "_MAX",
1409 (long) char_max, 0L,
1410 (long) CHAR_MAX, "");
1411 }
1412 i_define(D_CHAR_MIN, "", "CHAR", "_MIN",
1413 (long) char_min, (long) maxint,
1414 (long) CHAR_MIN, "");
1415 if (c_signed) {
1416 i_define(D_SCHAR_MAX, "", "SCHAR", "_MAX",
1417 (long) char_max, 0L,
1418 (long) SCHAR_MAX, "");
1419 i_define(D_SCHAR_MIN, "", "SCHAR", "_MIN",
1420 (long) char_min, (long) maxint,
1421 (long) SCHAR_MIN, "");
1422 } else {
1423 if (sizeof(char) == sizeof(int)) {
1424 u_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",
1425 (long) char_max,
1426 (long) UCHAR_MAX, "");
1427 } else {
1428 i_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",
1429 (long) char_max, 0L,
1430 (long) UCHAR_MAX, "");
1431 }
1432 }
1433
1434 if (c_signed) {
1435 #ifndef NO_UC
1436 Volatile unsigned char c, char_max;
1437 c=0; char_max=0;
1438 c++;
1439 if (setjmp(lab)==0) { /* Yields char_max */
1440 while (c>char_max) {
1441 char_max=c;
1442 c++;
1443 }
1444 }
1445 Unexpected(4);
1446 if (sizeof(char) == sizeof(int)) {
1447 u_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",
1448 (long) char_max,
1449 (long) UCHAR_MAX, "");
1450 } else {
1451 i_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",
1452 (long) char_max, 0L,
1453 (long) UCHAR_MAX, "");
1454 }
1455 #endif
1456 } else {
1457 #ifndef NO_SC
1458 /* Define NO_SC if this gives a syntax error */ Volatile signed char c, char_max, char_min;
1459 c=0; char_max=0;
1460 c++;
1461 if (setjmp(lab)==0) { /* Yields char_max */
1462 while (c>char_max) {
1463 char_max=c;
1464 c++;
1465 }
1466 }
1467 c=0; char_min=0;
1468 c--;
1469 if (setjmp(lab)==0) { /* Yields char_min */
1470 while (c<char_min) {
1471 char_min=c;
1472 c--;
1473 }
1474 }
1475 Unexpected(5);
1476 i_define(D_SCHAR_MIN, "", "SCHAR", "_MIN",
1477 (long) char_min, (long) maxint,
1478 (long) SCHAR_MIN, "");
1479 i_define(D_SCHAR_MAX, "", "SCHAR", "_MAX",
1480 (long) char_max, 0L,
1481 (long) SCHAR_MAX, "");
1482 #endif /* NO_SC */
1483 }
1484 }
1485 return bits_per_byte;
1486 }
1487
1488 int basic() {
1489 /* The properties of the basic types.
1490 Returns number of bits per sizeof unit */
1491 Volatile int bits_per_byte;
1492 typedef int function ();
1493 int variable;
1494 int *p, *q;
1495
1496 Vprintf("%sSIZES%s\n", co, oc);
1497 bits_per_byte= cprop();
1498
1499 /* Shorts, ints and longs *****************************************/
1500 Vprintf("%sshort=%d int=%d long=%d float=%d double=%d bits %s\n",
1501 co,
1502 (int) sizeof(short)*bits_per_byte,
1503 (int) sizeof(int)*bits_per_byte,
1504 (int) sizeof(long)*bits_per_byte,
1505 (int) sizeof(float)*bits_per_byte,
1506 (int) sizeof(double)*bits_per_byte, oc);
1507 if (stdc) {
1508 Vprintf("%slong double=%d bits%s\n",
1509 co, (int) sizeof(Long_double)*bits_per_byte, oc);
1510 }
1511 Vprintf("%schar*=%d bits%s%s\n",
1512 co, (int)sizeof(char *)*bits_per_byte,
1513 sizeof(char *)>sizeof(int)?" BEWARE! larger than int!":"",
1514 oc);
1515 Vprintf("%sint* =%d bits%s%s\n",
1516 co, (int)sizeof(int *)*bits_per_byte,
1517 sizeof(int *)>sizeof(int)?" BEWARE! larger than int!":"",
1518 oc);
1519 Vprintf("%sfunc*=%d bits%s%s\n",
1520 co, (int)sizeof(function *)*bits_per_byte,
1521 sizeof(function *)>sizeof(int)?" BEWARE! larger than int!":"",
1522 oc);
1523 if (V) printf ("%s%s %s %s%s\n", co, "Type size_t is",
1524 ((((false()?( sizeof(int)):(-1)) < 0) )?
1525 "signed":"unsigned") ,
1526 type_of(sizeof(
1527 sizeof(int)+0
1528 )
1529 ),
1530 oc);
1531 showtype("Type size_t is", sizeof(0));
1532
1533 /* Alignment constants ********************************************/
1534
1535 #define alignment(TYPE) \
1536 ((long)((char *)&((struct{char c; TYPE d;}*)0)->d - (char *)0))
1537
1538 Vprintf("\n%sALIGNMENTS%s\n", co, oc);
1539
1540 Vprintf("%schar=%ld short=%ld int=%ld long=%ld%s\n",
1541 co,
1542 alignment(char), alignment(short),
1543 alignment(int), alignment(long),
1544 oc);
1545
1546 Vprintf("%sfloat=%ld double=%ld%s\n",
1547 co,
1548 alignment(float), alignment(double),
1549 oc);
1550
1551 if (stdc) {
1552 Vprintf("%slong double=%ld%s\n",
1553 co,
1554 alignment(Long_double),
1555 oc);
1556 }
1557 Vprintf("%schar*=%ld int*=%ld func*=%ld%s\n",
1558 co,
1559 alignment(char *), alignment(int *), alignment(function *),
1560 oc);
1561
1562 Vprintf("\n");
1563
1564 /* Ten little endians *********************************************/
1565
1566 endian(bits_per_byte);
1567
1568 /* Pointers *******************************************************/
1569
1570 Vprintf("\n%sPROPERTIES OF POINTERS%s\n", co, oc);
1571
1572 if ((long) (char *) &variable == (long) (int *) &variable)
1573 Vprintf("%sChar and int pointer formats seem identical%s\n",
1574 co, oc);
1575 else
1576 Vprintf("%sChar and int pointer formats are different%s\n",
1577 co, oc);
1578 if ((long) (char *) &variable == (long) (function *) &variable)
1579 Vprintf("%sChar and function pointer formats seem identical%s\n",
1580 co, oc);
1581 else
1582 Vprintf("%sChar and function pointer formats are different%s\n",
1583 co, oc);
1584
1585 if (V) {
1586 if ("abcd"=="abcd")
1587 printf("%sStrings are shared%s\n", co, oc);
1588 else printf("%sStrings are not shared%s\n", co, oc);
1589 }
1590
1591 p=0; q=0;
1592 showtype("Type ptrdiff_t is", p-q);
1593
1594 Vprintf("\n%sPROPERTIES OF INTEGRAL TYPES%s\n", co, oc);
1595
1596 sprop();
1597 iprop();
1598 lprop();
1599 usprop();
1600 uiprop();
1601 ulprop();
1602
1603 promotions();
1604
1605 Unexpected(6);
1606
1607 return bits_per_byte;
1608 }
1609
1610 #else /* not PASS0 */
1611
1612 #ifdef SEP
1613 extern jmp_buf lab;
1614 extern int V, L, F, bugs, bits_per_byte;
1615 extern char co[], oc[];
1616 extern char *f_rep();
1617 #endif /* SEP */
1618 #endif /* ifdef PASS0 */
1619
1620 /* As I said, I apologise for the contortions below. The functions are
1621 expanded by the preprocessor twice or three times (for float and double,
1622 and maybe for long double, and for short, int and long). That way,
1623 I never make a change to one that I forget to make to the other.
1624 You can look on it as C's fault for not supporting multi-line macro's.
1625 This whole file is read 3 times by the preprocessor, with PASSn set for
1626 n=1, 2 or 3, to decide which parts to reprocess.
1627 */
1628
1629 /* #undef on an already undefined thing is (wrongly) flagged as an error
1630 by some compilers, therefore the #ifdef that follows:
1631 */
1632 #ifdef Number
1633 #undef Number
1634 #undef THING
1635 #undef Thing
1636 #undef thing
1637 #undef FPROP
1638 #undef Fname
1639 #undef Store
1640 #undef Sum
1641 #undef Diff
1642 #undef Mul
1643 #undef Div
1644 #undef ZERO
1645 #undef HALF
1646 #undef ONE
1647 #undef TWO
1648 #undef THREE
1649 #undef FOUR
1650 #undef Self
1651 #undef F_check
1652 #undef Validate
1653 #undef EPROP
1654 #undef MARK
1655
1656 /* These are the float.h constants */
1657 #undef F_RADIX
1658 #undef F_MANT_DIG
1659 #undef F_DIG
1660 #undef F_ROUNDS
1661 #undef F_EPSILON
1662 #undef F_MIN_EXP
1663 #undef F_MIN
1664 #undef F_MIN_10_EXP
1665 #undef F_MAX_EXP
1666 #undef F_MAX
1667 #undef F_MAX_10_EXP
1668 #endif
1669
1670 #ifdef Integer
1671 #undef Integer
1672 #undef INT
1673 #undef IPROP
1674 #undef Iname
1675 #undef UPROP
1676 #undef Uname
1677 #undef OK_UI
1678 #undef IMARK
1679
1680 #undef I_MAX
1681 #undef I_MIN
1682 #undef U_MAX
1683 #endif
1684
1685 #ifdef PASS1
1686
1687 /* Define the things we're going to use this pass */
1688
1689 #define Number float
1690 #define THING "FLOAT"
1691 #define Thing "Float"
1692 #define thing "float"
1693 #define Fname "FLT"
1694 #define FPROP fprop
1695 #define Store fStore
1696 #define Sum fSum
1697 #define Diff fDiff
1698 #define Mul fMul
1699 #define Div fDiv
1700 #define ZERO 0.0
1701 #define HALF 0.5
1702 #define ONE 1.0
1703 #define TWO 2.0
1704 #define THREE 3.0
1705 #define FOUR 4.0
1706 #define Self fSelf
1707 #define F_check fCheck
1708 #define MARK "F"
1709 #ifdef VERIFY
1710 #define Validate(prec, val, req, same) fValidate(prec, val, req, same)
1711 #endif
1712
1713 #define EPROP efprop
1714
1715 #define Integer short
1716 #define INT "short"
1717 #define IPROP sprop
1718 #define Iname "SHRT"
1719 #ifndef NO_UI
1720 #define OK_UI 1
1721 #endif
1722 #define IMARK ""
1723
1724 #define UPROP usprop
1725 #define Uname "USHRT"
1726
1727 #ifdef VERIFY
1728 #ifdef SHRT_MAX
1729 #define I_MAX SHRT_MAX
1730 #endif
1731 #ifdef SHRT_MIN
1732 #define I_MIN SHRT_MIN
1733 #endif
1734 #ifdef USHRT_MAX
1735 #define U_MAX USHRT_MAX
1736 #endif
1737
1738 #ifdef FLT_RADIX
1739 #define F_RADIX FLT_RADIX
1740 #endif
1741 #ifdef FLT_MANT_DIG
1742 #define F_MANT_DIG FLT_MANT_DIG
1743 #endif
1744 #ifdef FLT_DIG
1745 #define F_DIG FLT_DIG
1746 #endif
1747 #ifdef FLT_ROUNDS
1748 #define F_ROUNDS FLT_ROUNDS
1749 #endif
1750 #ifdef FLT_EPSILON
1751 #define F_EPSILON FLT_EPSILON
1752 #endif
1753 #ifdef FLT_MIN_EXP
1754 #define F_MIN_EXP FLT_MIN_EXP
1755 #endif
1756 #ifdef FLT_MIN
1757 #define F_MIN FLT_MIN
1758 #endif
1759 #ifdef FLT_MIN_10_EXP
1760 #define F_MIN_10_EXP FLT_MIN_10_EXP
1761 #endif
1762 #ifdef FLT_MAX_EXP
1763 #define F_MAX_EXP FLT_MAX_EXP
1764 #endif
1765 #ifdef FLT_MAX
1766 #define F_MAX FLT_MAX
1767 #endif
1768 #ifdef FLT_MAX_10_EXP
1769 #define F_MAX_10_EXP FLT_MAX_10_EXP
1770 #endif
1771 #endif /* VERIFY */
1772
1773 #endif /* PASS1 */
1774
1775 #ifdef PASS2
1776
1777 #define Number double
1778 #define THING "DOUBLE"
1779 #define Thing "Double"
1780 #define thing "double"
1781 #define Fname "DBL"
1782 #define FPROP dprop
1783 #define Store dStore
1784 #define Sum dSum
1785 #define Diff dDiff
1786 #define Mul dMul
1787 #define Div dDiv
1788 #define ZERO 0.0
1789 #define HALF 0.5
1790 #define ONE 1.0
1791 #define TWO 2.0
1792 #define THREE 3.0
1793 #define FOUR 4.0
1794 #define Self dSelf
1795 #define F_check dCheck
1796 #define MARK ""
1797 #ifdef VERIFY
1798 #define Validate(prec, val, req, same) dValidate(prec, val, req, same)
1799 #endif
1800
1801 #define EPROP edprop
1802
1803 #define Integer int
1804 #define INT "int"
1805 #define IPROP iprop
1806 #define Iname "INT"
1807 #define OK_UI 1 /* Unsigned int is always possible */
1808 #define IMARK ""
1809
1810 #define UPROP uiprop
1811 #define Uname "UINT"
1812
1813 #ifdef VERIFY
1814 #ifdef INT_MAX
1815 #define I_MAX INT_MAX
1816 #endif
1817 #ifdef INT_MIN
1818 #define I_MIN INT_MIN
1819 #endif
1820 #ifdef UINT_MAX
1821 #define U_MAX UINT_MAX
1822 #endif
1823
1824 #ifdef DBL_MANT_DIG
1825 #define F_MANT_DIG DBL_MANT_DIG
1826 #endif
1827 #ifdef DBL_DIG
1828 #define F_DIG DBL_DIG
1829 #endif
1830 #ifdef DBL_EPSILON
1831 #define F_EPSILON DBL_EPSILON
1832 #endif
1833 #ifdef DBL_MIN_EXP
1834 #define F_MIN_EXP DBL_MIN_EXP
1835 #endif
1836 #ifdef DBL_MIN
1837 #define F_MIN DBL_MIN
1838 #endif
1839 #ifdef DBL_MIN_10_EXP
1840 #define F_MIN_10_EXP DBL_MIN_10_EXP
1841 #endif
1842 #ifdef DBL_MAX_EXP
1843 #define F_MAX_EXP DBL_MAX_EXP
1844 #endif
1845 #ifdef DBL_MAX
1846 #define F_MAX DBL_MAX
1847 #endif
1848 #ifdef DBL_MAX_10_EXP
1849 #define F_MAX_10_EXP DBL_MAX_10_EXP
1850 #endif
1851 #endif /* VERIFY */
1852
1853 #endif /* PASS2 */
1854
1855 #ifdef PASS3
1856
1857 #ifdef STDC
1858 #define Number long double
1859
1860 #define ZERO 0.0L
1861 #define HALF 0.5L
1862 #define ONE 1.0L
1863 #define TWO 2.0L
1864 #define THREE 3.0L
1865 #define FOUR 4.0L
1866 #endif
1867
1868 #define THING "LONG DOUBLE"
1869 #define Thing "Long double"
1870 #define thing "long double"
1871 #define Fname "LDBL"
1872 #define FPROP ldprop
1873 #define Store ldStore
1874 #define Sum ldSum
1875 #define Diff ldDiff
1876 #define Mul ldMul
1877 #define Div ldDiv
1878 #define Self ldSelf
1879 #define F_check ldCheck
1880 #define MARK "L"
1881 #ifdef VERIFY
1882 #define Validate(prec, val, req, same) ldValidate(prec, val, req, same)
1883 #endif
1884
1885 #define EPROP eldprop
1886
1887 #define Integer long
1888 #define INT "long"
1889 #define IPROP lprop
1890 #define Iname "LONG"
1891 #ifndef NO_UI
1892 #define OK_UI 1
1893 #endif
1894 #define IMARK "L"
1895
1896 #define UPROP ulprop
1897 #define Uname "ULONG"
1898
1899 #ifdef VERIFY
1900 #ifdef LONG_MAX
1901 #define I_MAX LONG_MAX
1902 #endif
1903 #ifdef LONG_MIN
1904 #define I_MIN LONG_MIN
1905 #endif
1906 #ifdef ULONG_MAX
1907 #define U_MAX ULONG_MAX
1908 #endif
1909
1910 #ifdef LDBL_MANT_DIG
1911 #define F_MANT_DIG LDBL_MANT_DIG
1912 #endif
1913 #ifdef LDBL_DIG
1914 #define F_DIG LDBL_DIG
1915 #endif
1916 #ifdef LDBL_EPSILON
1917 #define F_EPSILON LDBL_EPSILON
1918 #endif
1919 #ifdef LDBL_MIN_EXP
1920 #define F_MIN_EXP LDBL_MIN_EXP
1921 #endif
1922 #ifdef LDBL_MIN
1923 #define F_MIN LDBL_MIN
1924 #endif
1925 #ifdef LDBL_MIN_10_EXP
1926 #define F_MIN_10_EXP LDBL_MIN_10_EXP
1927 #endif
1928 #ifdef LDBL_MAX_EXP
1929 #define F_MAX_EXP LDBL_MAX_EXP
1930 #endif
1931 #ifdef LDBL_MAX
1932 #define F_MAX LDBL_MAX
1933 #endif
1934 #ifdef LDBL_MAX_10_EXP
1935 #define F_MAX_10_EXP LDBL_MAX_10_EXP
1936 #endif
1937 #endif /* VERIFY */
1938
1939 #endif /* PASS3 */
1940
1941 #ifndef I_MAX
1942 #define I_MAX int_max
1943 #endif
1944 #ifndef I_MIN
1945 #define I_MIN int_min
1946 #endif
1947 #ifndef U_MAX
1948 #define U_MAX u_max
1949 #endif
1950
1951 #ifndef F_RADIX
1952 #define F_RADIX f_radix
1953 #endif
1954 #ifndef F_MANT_DIG
1955 #define F_MANT_DIG f_mant_dig
1956 #endif
1957 #ifndef F_DIG
1958 #define F_DIG f_dig
1959 #endif
1960 #ifndef F_ROUNDS
1961 #define F_ROUNDS f_rounds
1962 #endif
1963 #ifndef F_EPSILON
1964 #define F_EPSILON f_epsilon
1965 #endif
1966 #ifndef F_MIN_EXP
1967 #define F_MIN_EXP f_min_exp
1968 #endif
1969 #ifndef F_MIN
1970 #define F_MIN f_min
1971 #endif
1972 #ifndef F_MIN_10_EXP
1973 #define F_MIN_10_EXP f_min_10_exp
1974 #endif
1975 #ifndef F_MAX_EXP
1976 #define F_MAX_EXP f_max_exp
1977 #endif
1978 #ifndef F_MAX
1979 #define F_MAX f_max
1980 #endif
1981 #ifndef F_MAX_10_EXP
1982 #define F_MAX_10_EXP f_max_10_exp
1983 #endif
1984
1985 #ifndef VERIFY
1986 #define Validate(prec, val, req, same) {;}
1987 #endif
1988
1989 #ifdef Integer
1990
1991 Procedure IPROP() {
1992 /* the properties of short, int, and long */
1993 Volatile Integer newi, int_max, maxeri, int_min, minneri;
1994 Volatile int ibits, ipower, two=2;
1995
1996 /* Calculate max short/int/long ***********************************/
1997 /* Calculate 2**n-1 until overflow - then use the previous value */
1998
1999 newi=1; int_max=0;
2000
2001 if (setjmp(lab)==0) { /* Yields int_max */
2002 for(ipower=0; newi>int_max; ipower++) {
2003 int_max=newi;
2004 newi=newi*two+1;
2005 }
2006 Vprintf("%sOverflow of a%s %s does not generate a trap%s\n",
2007 co, INT[0]=='i'?"n":"", INT, oc);
2008 } else {
2009 Vprintf("%sOverflow of a%s %s generates a trap%s\n",
2010 co, INT[0]=='i'?"n":"", INT, oc);
2011 }
2012 Unexpected(7);
2013
2014 /* Minimum value: assume either two's or one's complement *********/
2015 int_min= -int_max;
2016 if (setjmp(lab)==0) { /* Yields int_min */
2017 if (int_min-1 < int_min) int_min--;
2018 }
2019 Unexpected(8);
2020
2021 /* Now for those daft Cybers */
2022
2023 maxeri=0; newi=int_max;
2024
2025 if (setjmp(lab)==0) { /* Yields maxeri */
2026 for(ibits=ipower; newi>maxeri; ibits++) {
2027 maxeri=newi;
2028 newi=newi+newi+1;
2029 }
2030 }
2031 Unexpected(9);
2032
2033 minneri= -maxeri;
2034 if (setjmp(lab)==0) { /* Yields minneri */
2035 if (minneri-1 < minneri) minneri--;
2036 }
2037 Unexpected(10);
2038
2039 Vprintf("%sMaximum %s = %ld (= 2**%d-1)%s\n",
2040 co, INT, (long)int_max, ipower, oc);
2041 Vprintf("%sMinimum %s = %ld%s\n", co, INT, (long)int_min, oc);
2042
2043 if (L) i_define(D_INT_MAX, INT, Iname, "_MAX",
2044 (long) int_max, 0L,
2045 (long) I_MAX, IMARK);
2046 if (L) i_define(D_INT_MIN, INT, Iname, "_MIN",
2047 (long) int_min, (long) (PASS==1?maxint:int_max),
2048 (long) I_MIN, IMARK);
2049
2050 if(int_max < 0) { /* It has happened */
2051 eek_a_bug("signed integral comparison faulty?");
2052 }
2053
2054 if (maxeri>int_max) {
2055 Vprintf("%sThere is a larger %s, %ld (= 2**%d-1), %s %s%s\n",
2056 co, INT, (long)maxeri, ibits,
2057 "but only for addition, not multiplication",
2058 "(I smell a Cyber!)",
2059 oc);
2060 }
2061
2062 if (minneri<int_min) {
2063 Vprintf("%sThere is a smaller %s, %ld, %s %s%s\n",
2064 co, INT, (long)minneri,
2065 "but only for addition, not multiplication",
2066 "(I smell a Cyber!)",
2067 oc);
2068 }
2069 }
2070
2071 Procedure UPROP () {
2072 /* The properties of unsigned short/int/long */
2073 #ifdef OK_UI
2074 Volatile unsigned Integer u_max, newi, two;
2075 newi=1; u_max=0; two=2;
2076
2077 if (setjmp(lab)==0) { /* Yields u_max */
2078 while(newi>u_max) {
2079 u_max=newi;
2080 newi=newi*two+1;
2081 }
2082 }
2083 Unexpected(11);
2084 Vprintf("%sMaximum unsigned %s = %lu%s\n",
2085 co, INT, (unsigned long) u_max, oc);
2086
2087 /* Oh woe: new standard C defines value preserving promotions */
2088 if (L) {
2089 if (PASS == 1 && sizeof(short) < sizeof(int)) {
2090 /* Special only for short */
2091 i_define(D_UINT_MAX, INT, Uname, "_MAX",
2092 (unsigned long) u_max, 0L,
2093 (unsigned long) U_MAX, IMARK);
2094 } else {
2095 u_define(D_UINT_MAX, INT, Uname, "_MAX",
2096 (unsigned long) u_max,
2097 (unsigned long) U_MAX, IMARK);
2098 }
2099 }
2100 #endif
2101 }
2102
2103 #endif /* Integer */
2104
2105 #ifdef Number
2106
2107 /* The following routines are intended to defeat any attempt at optimisation
2108 or use of extended precision, and to defeat faulty narrowing casts.
2109 The weird prototypes are because of widening incompatibilities.
2110 */
2111 #ifdef STDC
2112 #define ARGS1(atype, a) (atype a)
2113 #define ARGS2(atype, a, btype, b) (atype a, btype b)
2114 #else
2115 #define ARGS1(atype, a) (a) atype a;
2116 #define ARGS2(atype, a, btype, b) (a, b) atype a; btype b;
2117 #endif
2118
2119 Procedure Store ARGS2(Number, a, Number *, b) { *b=a; }
2120 Number Sum ARGS2(Number, a, Number, b) {Number r; Store(a+b, &r); return (r); }
2121 Number Diff ARGS2(Number, a, Number, b){Number r; Store(a-b, &r); return (r); }
2122 Number Mul ARGS2(Number, a, Number, b) {Number r; Store(a*b, &r); return (r); }
2123 Number Div ARGS2(Number, a, Number, b) {Number r; Store(a/b, &r); return (r); }
2124 Number Self ARGS1(Number, a) {Number r; Store(a, &r); return (r); }
2125
2126 Procedure F_check ARGS((int precision, Long_double val1));
2127
2128 Procedure F_check(precision, val1) int precision; Long_double val1; {
2129 /* You don't think I'm going to go to all the trouble of writing
2130 a program that works out what all sorts of values are, only to
2131 have printf go and print the wrong values out, do you?
2132 No, you're right, so this function tries to see if printf
2133 has written the right value, by reading it back again.
2134 This introduces a new problem of course: suppose printf writes
2135 the correct value, and scanf reads it back wrong... oh well.
2136 But I'm adamant about this: the precision given is enough
2137 to uniquely identify the printed number, therefore I insist
2138 that sscanf read the number back identically. Harsh yes, but
2139 sometimes you've got to be cruel to be kind.
2140 */
2141 Long_double new1;
2142 Number val, new, diff;
2143 double rem;
2144 int e;
2145 char *rep;
2146 char *f2;
2147
2148 if (sizeof(double) == sizeof(Long_double)) {
2149 /* Assume they're the same, and use non-stdc format */
2150 /* This is for stdc compilers using non-stdc libraries */
2151 f2= "%le"; /* Input */
2152 } else {
2153 /* It had better support Le then */
2154 f2= "%Le";
2155 }
2156 val= val1;
2157 rep= f_rep(precision, (Long_double) val);
2158 if (setjmp(lab)==0) {
2159 sscanf(rep, f2, &new1);
2160 } else {
2161 eek_a_bug("sscanf caused a trap");
2162 printf("%s scanning: %s format: %s%s\n\n", co, rep, f2, oc);
2163 Unexpected(12);
2164 return;
2165 }
2166
2167 if (setjmp(lab)==0) { /* See if new is usable */
2168 new= new1;
2169 if (new != 0.0) {
2170 diff= val/new - 1.0;
2171 if (diff < 0.1) diff= 1.0;
2172 /* That should be enough to generate a trap */
2173 }
2174 } else {
2175 eek_a_bug("sscanf returned an unusable number");
2176 printf("%s scanning: %s with format: %s%s\n\n",
2177 co, rep, f2, oc);
2178 Unexpected(13);
2179 return;
2180 }
2181
2182 Unexpected(14);
2183 if (new != val) {
2184 eek_a_bug("Possibly bad output from printf above");
2185 if (!exponent((Long_double)val, &rem, &e)) {
2186 printf("%s but value was an unusable number%s\n\n",
2187 co, oc);
2188 return;
2189 }
2190 printf("%s expected value around %.*fe%d, bit pattern:\n ",
2191 co, precision, rem, e);
2192 bitpattern((char *) &val, (unsigned)sizeof(val));
2193 printf ("%s\n", oc);
2194 printf("%s sscanf gave %s, bit pattern:\n ",
2195 co, f_rep(precision, (Long_double) new));
2196 bitpattern((char *) &new, (unsigned)sizeof(new));
2197 printf ("%s\n", oc);
2198 if (setjmp(lab) == 0) {
2199 diff= val-new;
2200 printf("%s difference= %s%s\n\n",
2201 co, f_rep(precision, (Long_double) diff), oc);
2202 } /* else forget it */
2203 Unexpected(15);
2204 }
2205 }
2206
2207 #ifdef VERIFY
2208 Procedure Validate(prec, val, req, same) int prec, same; Long_double val, req; {
2209 /* Check that the compiler has read a #define value correctly */
2210 Unexpected(16);
2211 if (!same) {
2212 printf("%s*** Verify failed for above #define!\n", co);
2213 if (setjmp(lab) == 0) { /* for the case that req == nan */
2214 printf(" Compiler has %s for value%s\n",
2215 f_rep(prec, req), oc);
2216 } else {
2217 printf(" Compiler has %s for value%s\n",
2218 "an unusable number", oc);
2219 }
2220 if (setjmp(lab) == 0) {
2221 F_check(prec, (Long_double) req);
2222 } /*else forget it*/
2223 if (setjmp(lab) == 0) {
2224 if (req > 0.0 && val > 0.0) {
2225 printf("%s difference= %s%s\n",
2226 co, f_rep(prec, val-req), oc);
2227 }
2228 } /*else forget it*/
2229 Unexpected(17);
2230 printf("\n");
2231 bugs++;
2232 } else if (val != req) {
2233 if (stdc) eek_a_bug("constant has the wrong precision");
2234 else eek_a_bug("the cast didn't work");
2235 printf("\n");
2236 }
2237 }
2238 #endif /* VERIFY */
2239
2240 int FPROP(bits_per_byte) int bits_per_byte; {
2241 /* Properties of floating types, using algorithms by Cody and Waite
2242 from MA Malcolm, as modified by WM Gentleman and SB Marovich.
2243 Further extended by S Pemberton.
2244
2245 Returns the number of digits in the fraction.
2246 */
2247
2248 Volatile int
2249 i, f_radix, iexp, irnd, mrnd, f_rounds, f_mant_dig,
2250 iz, k, inf, machep, f_max_exp, f_min_exp, mx, negeps,
2251 mantbits, digs, f_dig, trap,
2252 hidden, normal, f_min_10_exp, f_max_10_exp;
2253 Volatile Number
2254 a, b, base, basein, basem1, f_epsilon, epsneg,
2255 eps, epsp1, etop, ebot,
2256 f_max, newxmax, f_min, xminner, y, y1, z, z1, z2;
2257
2258 Unexpected(18);
2259
2260 Vprintf("%sPROPERTIES OF %s%s\n", co, THING, oc);
2261
2262 /* Base and size of significand **************************************/
2263 /* First repeatedly double until adding 1 has no effect. */
2264 /* For instance, if base is 10, with 3 significant digits */
2265 /* it will try 1, 2, 4, 8, ... 512, 1024, and stop there, */
2266 /* since 1024 is only representable as 1020. */
2267 a=1.0;
2268 if (setjmp(lab)==0) { /* inexact trap? */
2269 do { a=Sum(a, a); }
2270 while (Diff(Diff(Sum(a, ONE), a), ONE) == ZERO);
2271 } else {
2272 fprintf(stderr, "*** Program got loss-of-precision trap!\n");
2273 /* And supporting those is just TOO much trouble! */
2274 farewell(bugs+1);
2275 }
2276 Unexpected(19);
2277 /* Now double until you find a number that can be added to the */
2278 /* above number. For 1020 this is 8 or 16, depending whether the */
2279 /* result is rounded or truncated. */
2280 /* In either case the result is 1030. 1030-1020= the base, 10. */
2281 b=1.0;
2282 do { b=Sum(b, b); } while ((base=Diff(Sum(a, b), a)) == ZERO);
2283 f_radix=base;
2284 Vprintf("%sBase = %d%s\n", co, f_radix, oc);
2285
2286 /* Sanity check; if base<2, I can't guarantee the rest will work */
2287 if (f_radix < 2) {
2288 eek_a_bug("Function return or parameter passing faulty? (This is a guess.)");
2289 printf("\n");
2290 return(0);
2291 }
2292
2293 if (PASS == 1) { /* only for FLT */
2294 flt_radix= f_radix;
2295 if (F) i_define(D_FLT_RADIX, "", "FLT", "_RADIX",
2296 (long) f_radix, 0L, (long) F_RADIX, "");
2297 } else if (f_radix != flt_radix) {
2298 printf("\n%s*** WARNING: %s %s (%d) %s%s\n",
2299 co, thing, "arithmetic has a different radix",
2300 f_radix, "from float", oc);
2301 bugs++;
2302 }
2303
2304 /* Now the number of digits precision */
2305 f_mant_dig=0; b=1.0;
2306 do { f_mant_dig++; b=Mul(b, base); }
2307 while (Diff(Diff(Sum(b, ONE), b), ONE) == ZERO);
2308 f_dig=floor_log(10, (Long_double)(b/base)) + (base==10?1:0);
2309 Vprintf("%sSignificant base digits = %d %s %d %s%s\n",
2310 co, f_mant_dig, "(= at least", f_dig, "decimal digits)", oc);
2311 if (F) i_define(D_MANT_DIG, thing, Fname, "_MANT_DIG",
2312 (long) f_mant_dig, 0L, (long) F_MANT_DIG, "");
2313 if (F) i_define(D_DIG, thing, Fname, "_DIG",
2314 (long) f_dig, 0L, (long) F_DIG, "");
2315 digs= ceil_log(10, (Long_double)b); /* the number of digits to printf */
2316
2317 /* Rounding *******************************************************/
2318 basem1=Diff(base, HALF);
2319 if (Diff(Sum(a, basem1), a) != ZERO) {
2320 if (f_radix == 2) basem1=0.375;
2321 else basem1=1.0;
2322 if (Diff(Sum(a, basem1), a) != ZERO) irnd=2; /* away from 0 */
2323 else irnd=1; /* to nearest */
2324 } else irnd=0; /* towards 0 */
2325
2326 basem1=Diff(base, HALF);
2327
2328 if (Diff(Diff(-a, basem1), -a) != ZERO) {
2329 if (f_radix == 2) basem1=0.375;
2330 else basem1=1.0;
2331 if (Diff(Diff(-a, basem1), -a) != ZERO) mrnd=2; /* away from 0*/
2332 else mrnd=1; /* to nearest */
2333 } else mrnd=0; /* towards 0 */
2334
2335 f_rounds= -1; /* Unknown rounding */
2336 if (irnd==0 && mrnd==0) f_rounds=0; /* zero = chops */
2337 if (irnd==1 && mrnd==1) f_rounds=1; /* nearest */
2338 if (irnd==2 && mrnd==0) f_rounds=2; /* +inf */
2339 if (irnd==0 && mrnd==2) f_rounds=3; /* -inf */
2340
2341 if (f_rounds != -1) {
2342 Vprintf("%sArithmetic rounds towards ", co);
2343 switch (f_rounds) {
2344 case 0: Vprintf("zero (i.e. it chops)"); break;
2345 case 1: Vprintf("nearest"); break;
2346 case 2: Vprintf("+infinity"); break;
2347 case 3: Vprintf("-infinity"); break;
2348 default: Vprintf("???"); break;
2349 }
2350 Vprintf("%s\n", oc);
2351 } else { /* Hmm, try to give some help here */
2352 Vprintf("%sArithmetic rounds oddly: %s\n", co, oc);
2353 Vprintf("%s Negative numbers %s%s\n",
2354 co, mrnd==0 ? "towards zero" :
2355 mrnd==1 ? "to nearest" :
2356 "away from zero",
2357 oc);
2358 Vprintf("%s Positive numbers %s%s\n",
2359 co, irnd==0 ? "towards zero" :
2360 irnd==1 ? "to nearest" :
2361 "away from zero",
2362 oc);
2363 }
2364 /* An extra goody */
2365 if (f_radix == 2 && f_rounds == 1) {
2366 if (Diff(Sum(a, ONE), a) != ZERO) {
2367 Vprintf("%s Tie breaking rounds up%s\n", co, oc);
2368 } else if (Diff(Sum(a, THREE), a) == FOUR) {
2369 Vprintf("%s Tie breaking rounds to even%s\n", co, oc);
2370 } else {
2371 Vprintf("%s Tie breaking rounds down%s\n", co, oc);
2372 }
2373 }
2374 if (PASS == 1) { /* only for FLT */
2375 flt_rounds= f_rounds;
2376 if (F)
2377 i_define(D_FLT_ROUNDS, "", "FLT", "_ROUNDS",
2378 (long) f_rounds, 1L, (long) F_ROUNDS, "");
2379 } else if (f_rounds != flt_rounds) {
2380 printf("\n%s*** WARNING: %s %s (%d) %s%s\n",
2381 co, thing, "arithmetic rounds differently",
2382 f_rounds, "from float", oc);
2383 bugs++;
2384 }
2385
2386 /* Various flavours of epsilon ************************************/
2387 negeps=f_mant_dig+f_mant_dig;
2388 basein=1.0/base;
2389 a=1.0;
2390 for(i=1; i<=negeps; i++) a*=basein;
2391
2392 b=a;
2393 while (Diff(Diff(ONE, a), ONE) == ZERO) {
2394 a*=base;
2395 negeps--;
2396 }
2397 negeps= -negeps;
2398 Vprintf("%sSmallest x such that 1.0-base**x != 1.0 = %d%s\n",
2399 co, negeps, oc);
2400
2401 etop = ONE;
2402 ebot = ZERO;
2403 eps = Sum(ebot, Div(Diff(etop, ebot), TWO));
2404 /* find the smallest epsneg (1-epsneg != 1) by binary search.
2405 ebot and etop are the current bounds */
2406 while (eps != ebot && eps != etop) {
2407 epsp1 = Diff(ONE, eps);
2408 if (epsp1 < ONE) etop = eps;
2409 else ebot = eps;
2410 eps = Sum(ebot, Div(Diff(etop, ebot), TWO));
2411 }
2412 eps= etop;
2413 /* Sanity check */
2414 if (Diff(ONE, etop) >= ONE || Diff(ONE, ebot) != ONE) {
2415 eek_a_bug("internal error calculating epsneg");
2416 }
2417 Vprintf("%sSmallest x such that 1.0-x != 1.0 = %s%s\n",
2418 co, f_rep(digs, (Long_double) eps), oc);
2419 if (V) F_check(digs, (Long_double) eps);
2420
2421 epsneg=a;
2422 if ((f_radix!=2) && irnd) {
2423 /* a=(a*(1.0+a))/(1.0+1.0); => */
2424 a=Div(Mul(a, Sum(ONE, a)), Sum(ONE, ONE));
2425 /* if ((1.0-a)-1.0 != 0.0) epsneg=a; => */
2426 if (Diff(Diff(ONE, a), ONE) != ZERO) epsneg=a;
2427 }
2428 /* epsneg is used later */
2429 Unexpected(20);
2430
2431 machep= -f_mant_dig-f_mant_dig;
2432 a=b;
2433 while (Diff(Sum(ONE, a), ONE) == ZERO) { a*=base; machep++; }
2434 Vprintf("%sSmallest x such that 1.0+base**x != 1.0 = %d%s\n",
2435 co, machep, oc);
2436
2437 etop = ONE;
2438 ebot = ZERO;
2439 eps = Sum(ebot, Div(Diff(etop, ebot), TWO));
2440 /* find the smallest eps (1+eps != 1) by binary search.
2441 ebot and etop are the current bounds */
2442 while (eps != ebot && eps != etop) {
2443 epsp1 = Sum(ONE, eps);
2444 if (epsp1 > ONE) etop = eps;
2445 else ebot = eps;
2446 eps = Sum(ebot, Div(Diff(etop, ebot), TWO));
2447 }
2448 /* Sanity check */
2449 if (Sum(ONE, etop) <= ONE || Sum(ONE, ebot) != ONE) {
2450 eek_a_bug("internal error calculating eps");
2451 }
2452 f_epsilon=etop;
2453
2454 Vprintf("%sSmallest x such that 1.0+x != 1.0 = %s%s\n",
2455 co, f_rep(digs, (Long_double) f_epsilon), oc);
2456
2457 f_epsilon= Diff(Sum(ONE, f_epsilon), ONE); /* New C standard defn */
2458 Vprintf("%s(Above number + 1.0) - 1.0 = %s%s\n",
2459 co, f_rep(digs, (Long_double) (f_epsilon)), oc);
2460
2461 /* Possible loss of precision warnings here from non-stdc compilers */
2462 if (F) f_define(D_EPSILON, thing,
2463 Fname, "_EPSILON", digs, (Long_double) f_epsilon, MARK);
2464 if (V || F) F_check(digs, (Long_double) f_epsilon);
2465 Unexpected(21);
2466 if (F) Validate(digs, (Long_double) f_epsilon, (Long_double) F_EPSILON,
2467 f_epsilon == Self(F_EPSILON));
2468 Unexpected(22);
2469
2470 /* Extra chop info *************************************************/
2471 if (f_rounds == 0) {
2472 if (Diff(Mul(Sum(ONE,f_epsilon),ONE),ONE) != ZERO) {
2473 Vprintf("%sAlthough arithmetic chops, it uses guard digits%s\n", co, oc);
2474 }
2475 }
2476
2477 /* Size of and minimum normalised exponent ************************/
2478 y=0; i=0; k=1; z=basein; z1=(1.0+f_epsilon)/base;
2479
2480 /* Coarse search for the largest power of two */
2481 if (setjmp(lab)==0) { /* for underflow trap */ /* Yields i, k, y, y1 */
2482 do {
2483 y=z; y1=z1;
2484 z=Mul(y,y); z1=Mul(z1, y);
2485 a=Mul(z,ONE);
2486 z2=Div(z1,y);
2487 if (z2 != y1) break;
2488 if ((Sum(a,a) == ZERO) || (fabs(z) >= y)) break;
2489 i++;
2490 k+=k;
2491 } while(1);
2492 } else {
2493 Vprintf("%s%s underflow generates a trap%s\n", co, Thing, oc);
2494 }
2495 Unexpected(23);
2496
2497 if (f_radix != 10) {
2498 iexp=i+1; /* for the sign */
2499 mx=k+k;
2500 } else {
2501 iexp=2;
2502 iz=f_radix;
2503 while (k >= iz) { iz*=f_radix; iexp++; }
2504 mx=iz+iz-1;
2505 }
2506
2507 /* Fine tune starting with y and y1 */
2508 if (setjmp(lab)==0) { /* for underflow trap */ /* Yields k, f_min */
2509 do {
2510 f_min=y; z1=y1;
2511 y=Div(y,base); y1=Div(y1,base);
2512 a=Mul(y,ONE);
2513 z2=Mul(y1,base);
2514 if (z2 != z1) break;
2515 if ((Sum(a,a) == ZERO) || (fabs(y) >= f_min)) break;
2516 k++;
2517 } while (1);
2518 }
2519 Unexpected(24);
2520
2521 f_min_exp=(-k)+1;
2522
2523 if ((mx <= k+k-3) && (f_radix != 10)) { mx+=mx; iexp+=1; }
2524 Vprintf("%sNumber of bits used for exponent = %d%s\n", co, iexp, oc);
2525 Vprintf("%sMinimum normalised exponent = %d%s\n", co, f_min_exp-1, oc);
2526 if (F)
2527 i_define(D_MIN_EXP, thing, Fname, "_MIN_EXP",
2528 (long) f_min_exp, (long) maxint, (long) F_MIN_EXP, "");
2529
2530 if (setjmp(lab)==0) {
2531 Vprintf("%sMinimum normalised positive number = %s%s\n",
2532 co, f_rep(digs, (Long_double) f_min), oc);
2533 } else {
2534 eek_a_bug("printf can't print the smallest normalised number");
2535 printf("\n");
2536 }
2537 Unexpected(25);
2538 /* Possible loss of precision warnings here from non-stdc compilers */
2539 if (setjmp(lab) == 0) {
2540 if (F) f_define(D_MIN, thing,
2541 Fname, "_MIN", digs, (Long_double) f_min, MARK);
2542 if (V || F) F_check(digs, (Long_double) f_min);
2543 } else {
2544 eek_a_bug("xxx_MIN caused a trap");
2545 printf("\n");
2546 }
2547
2548 if (setjmp(lab) == 0) {
2549 if (F) Validate(digs, (Long_double) f_min, (Long_double) F_MIN,
2550 f_min == Self(F_MIN));
2551 } else {
2552 printf("%s*** Verify failed for above #define!\n %s %s\n\n",
2553 co, "Compiler has an unusable number for value", oc);
2554 bugs++;
2555 }
2556 Unexpected(26);
2557
2558 a=1.0; f_min_10_exp=0;
2559 while (a > f_min*10.0) { a/=10.0; f_min_10_exp--; }
2560 if (F) i_define(D_MIN_10_EXP, thing, Fname, "_MIN_10_EXP",
2561 (long) f_min_10_exp, (long) maxint,
2562 (long) F_MIN_10_EXP, "");
2563
2564 /* Minimum exponent ************************************************/
2565 if (setjmp(lab)==0) { /* for underflow trap */ /* Yields xminner */
2566 do {
2567 xminner=y;
2568 y=Div(y,base);
2569 a=Mul(y,ONE);
2570 if ((Sum(a,a) == ZERO) || (fabs(y) >= xminner)) break;
2571 } while (1);
2572 }
2573 Unexpected(27);
2574
2575 if (xminner != 0.0 && xminner != f_min) {
2576 normal= 0;
2577 Vprintf("%sThe smallest numbers are not kept normalised%s\n",
2578 co, oc);
2579 if (setjmp(lab)==0) {
2580 Vprintf("%sSmallest unnormalised positive number = %s%s\n",
2581 co, f_rep(digs, (Long_double) xminner), oc);
2582 if (V) F_check(digs, (Long_double) xminner);
2583 } else {
2584 eek_a_bug("printf can't print the smallest unnormalised number.");
2585 printf("\n");
2586 }
2587 Unexpected(28);
2588 } else {
2589 normal= 1;
2590 Vprintf("%sThe smallest numbers are normalised%s\n", co, oc);
2591 }
2592
2593 /* Maximum exponent ************************************************/
2594 f_max_exp=2; f_max=1.0; newxmax=base+1.0;
2595 inf=0; trap=0;
2596 while (f_max<newxmax) {
2597 f_max=newxmax;
2598 if (setjmp(lab) == 0) { /* Yields inf, f_max_exp */
2599 newxmax=Mul(newxmax, base);
2600 } else {
2601 trap=1;
2602 break;
2603 }
2604 if (Div(newxmax, base) != f_max) {
2605 inf=1; /* ieee infinity */
2606 break;
2607 }
2608 f_max_exp++;
2609 }
2610 Unexpected(29);
2611 if (trap) {
2612 Vprintf("%s%s overflow generates a trap%s\n", co, Thing, oc);
2613 }
2614
2615 if (inf) Vprintf("%sThere is an 'infinite' value%s\n", co, oc);
2616 Vprintf("%sMaximum exponent = %d%s\n", co, f_max_exp, oc);
2617 if (F) i_define(D_MAX_EXP, thing, Fname, "_MAX_EXP",
2618 (long) f_max_exp, 0L, (long) F_MAX_EXP, "");
2619
2620 /* Largest number ***************************************************/
2621 f_max=Diff(ONE, epsneg);
2622 if (Mul(f_max,ONE) != f_max) f_max=Diff(ONE, Mul(base,epsneg));
2623 for (i=1; i<=f_max_exp; i++) f_max=Mul(f_max, base);
2624
2625 if (setjmp(lab)==0) {
2626 Vprintf("%sMaximum number = %s%s\n",
2627 co, f_rep(digs, (Long_double) f_max), oc);
2628 } else {
2629 eek_a_bug("printf can't print the largest double.");
2630 printf("\n");
2631 }
2632 if (setjmp(lab)==0) {
2633 /* Possible loss of precision warnings here from non-stdc compilers */
2634 if (F) f_define(D_MAX, thing,
2635 Fname, "_MAX", digs, (Long_double) f_max, MARK);
2636 if (V || F) F_check(digs, (Long_double) f_max);
2637 } else {
2638 eek_a_bug("xxx_MAX caused a trap");
2639 printf("\n");
2640 }
2641 if (setjmp(lab)==0) {
2642 if (F) Validate(digs, (Long_double) f_max, (Long_double) F_MAX,
2643 f_max == Self(F_MAX));
2644 } else {
2645 printf("%s*** Verify failed for above #define!\n %s %s\n\n",
2646 co, "Compiler has an unusable number for value", oc);
2647 bugs++;
2648 }
2649 Unexpected(30);
2650
2651 a=1.0; f_max_10_exp=0;
2652 while (a < f_max/10.0) { a*=10.0; f_max_10_exp++; }
2653 if (F) i_define(D_MAX_10_EXP, thing, Fname, "_MAX_10_EXP",
2654 (long) f_max_10_exp, 0L, (long) F_MAX_10_EXP, "");
2655
2656 /* Hidden bit + sanity check ****************************************/
2657 if (f_radix != 10) {
2658 hidden=0;
2659 mantbits=floor_log(2, (Long_double)f_radix)*f_mant_dig;
2660 if (mantbits+iexp == (int)sizeof(Number)*bits_per_byte) {
2661 hidden=1;
2662 Vprintf("%sArithmetic uses a hidden bit%s\n", co, oc);
2663 } else if (mantbits+iexp+1 == (int)sizeof(Number)*bits_per_byte) {
2664 Vprintf("%sArithmetic doesn't use a hidden bit%s\n",
2665 co, oc);
2666 } else {
2667 printf("\n%s%s\n %s %s %s!%s\n\n",
2668 co,
2669 "*** Something fishy here!",
2670 "Exponent size + significand size doesn't match",
2671 "with the size of a", thing,
2672 oc);
2673 }
2674 if (hidden && f_radix == 2 && f_max_exp+f_min_exp==3) {
2675 Vprintf("%sIt looks like %s length IEEE format%s\n",
2676 co, f_mant_dig==24 ? "single" :
2677 f_mant_dig==53 ? "double" :
2678 f_mant_dig >53 ? "extended" :
2679 "some", oc);
2680 if (f_rounds != 1 || normal) {
2681 Vprintf("%s though ", co);
2682 if (f_rounds != 1) {
2683 Vprintf("the rounding is unusual");
2684 if (normal) Vprintf(" and ");
2685 }
2686 if (normal) Vprintf("the normalisation is unusual");
2687 Vprintf("%s\n", oc);
2688 }
2689 } else {
2690 Vprintf("%sIt doesn't look like IEEE format%s\n",
2691 co, oc);
2692 }
2693 }
2694 printf("\n"); /* regardless of verbosity */
2695 return f_mant_dig;
2696 }
2697
2698 Procedure EPROP(fprec, dprec, lprec) int fprec, dprec, lprec; {
2699 /* See if expressions are evaluated in extended precision.
2700 Some compilers optimise even if you don't want it,
2701 and then this function fails to produce the right result.
2702 We try to diagnose this if it happens.
2703 */
2704 Volatile int eprec;
2705 Volatile double a, b, base, old;
2706 Volatile Number d, oldd, dbase, one, zero;
2707 Volatile int bad=0;
2708
2709 /* Size of significand **************************************/
2710 a=1.0;
2711 if (setjmp(lab) == 0) { /* Yields nothing */
2712 do { old=a; a=a+a; }
2713 while ((((a+1.0)-a)-1.0) == 0.0 && a>old);
2714 } else bad=1;
2715
2716 /* Avoid the comparison if bad is set,
2717 to avoid trouble on the convex. */
2718 if (!bad && (a <= old)) bad=1;
2719
2720 if (!bad) {
2721 b=1.0;
2722 if (setjmp(lab) == 0) { /* Yields nothing */
2723 do { old=b; b=b+b; }
2724 while ((base=((a+b)-a)) == 0.0 && b>old);
2725 if (b <= old) bad=1;
2726 } else bad=1;
2727 }
2728
2729 if (!bad) {
2730 eprec=0; d=1.0; dbase=base; one=1.0; zero=0.0;
2731 if (setjmp(lab) == 0) { /* Yields nothing */
2732 do { eprec++; oldd=d; d=d*dbase; }
2733 while ((((d+one)-d)-one) == zero && d>oldd);
2734 if (d <= oldd) bad=1;
2735 } else bad=1;
2736 }
2737
2738 Unexpected(31);
2739
2740 if (bad) {
2741 Vprintf("%sCan't determine precision for %s expressions:\n%s%s\n",
2742 co, thing, " check that you compiled without optimisation!",
2743 oc);
2744 } else if (eprec==dprec) {
2745 Vprintf("%s%s expressions are evaluated in double precision%s\n",
2746 co, Thing, oc);
2747 } else if (eprec==fprec) {
2748 Vprintf("%s%s expressions are evaluated in float precision%s\n",
2749 co, Thing, oc);
2750 } else if (eprec==lprec) {
2751 Vprintf("%s%s expressions are evaluated in long double precision%s\n",
2752 co, Thing, oc);
2753 } else {
2754 Vprintf("%s%s expressions are evaluated in a %s %s %d %s%s\n",
2755 co, Thing, eprec>dprec ? "higher" : "lower",
2756 "precision than double,\n using",
2757 eprec, "base digits",
2758 oc);
2759 }
2760 }
2761
2762 #else /* not Number */
2763
2764 #ifdef FPROP /* Then create dummy routines for long double */
2765 /* ARGSUSED */
2766 int FPROP(bits_per_byte) int bits_per_byte; { return 0; }
2767 #endif
2768 #ifdef EPROP
2769 /* ARGSUSED */
2770 Procedure EPROP(fprec, dprec, lprec) int fprec, dprec, lprec; {}
2771 #endif
2772
2773 #endif /* ifdef Number */
2774
2775 /* Increment the pass number */
2776 #undef PASS
2777
2778 #ifdef PASS2
2779 #undef PASS2
2780 #define PASS 3
2781 #define PASS3 1
2782 #endif
2783
2784 #ifdef PASS1
2785 #undef PASS1
2786 #define PASS 2
2787 #define PASS2 1
2788 #endif
2789
2790 #ifdef PASS0
2791 #undef PASS0
2792 #endif
2793
2794 #ifdef PASS /* then rescan this file */
2795 #ifdef NO_FILE
2796 #include "enquire.c"
2797 #else
2798 #include FILENAME /* if this line fails to compile, define NO_FILE */
2799 #endif
2800 #endif /* PASS */
2801
GNU Compiler Collection
This page took 0.156166 seconds and 5 git commands to generate.