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