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