Context Navigation

source: trunk/third/gcc/enquire.c @ 8834

Visit:

Revision 8834, 76.9 KB checked in by ghudson, 28 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r8833, which included commits to RCS files with non-trunk default branches.

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: