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