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