Skip to content

Instantly share code, notes, and snippets.

@awnumar

awnumar/enquire.c

Created February 24, 2019 15:36
Show Gist options
  • Star 1 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save awnumar/5ff2cc9ed29d550c1511dfcd63f9516b to your computer and use it in GitHub Desktop.
Save awnumar/5ff2cc9ed29d550c1511dfcd63f9516b to your computer and use it in GitHub Desktop.
Download ZIP
Raw
enquire.c
#ifndef PROGRAM
#define PROGRAM enquire.c
#define VERSION "5.1a"
#define PURPOSE Everything you wanted to know about your machine and C compiler
#define BUT didnt know who to ask
#define FOR Any OS, any C compiler
#define AUTHOR Steven Pemberton, CWI, Amsterdam; "Steven.Pemberton@cwi.nl"
#define COPYRIGHT(c) 1993-9 Steven Pemberton, CWI. All rights reserved.
#define NOTE Improvements gratefully received. Please mention the version.
#define COMPILE On Unix compile with: "sh enquire.c"; see below for details
#define WEB "http://www.cwi.nl/~steven/enquire.html"
#endif
#ifdef NOTDEFINED /* This is how you compile it; see below for details */
case $0 in
*.c) ;;
sh) echo 'Use "sh enquire.c", not "sh < enquire.c"' >&2; exit 1;;
*) echo 'Filename must end in ".c"' >&2; exit 1;;
esac
if test -r test.c
then echo Would overwrite test.c - try it somewhere safer >&2; exit 1
fi
CFLAGS=
echo Testing for needed CFLAGS ...
echo "main(){char c; c=0;}" > test.c
if ${CC=cc} ${1+"$@"} -o enquire test.c $LIBS
then :
else
echo '*** "'$CC ${1+"$@"} -o enquire test.c $LIBS'" failed'
echo '*** Giving up'
/bin/rm -f test.c
exit 1
fi
echo "main(){signed char c; c=0;}" > test.c
if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null
then echo " Signed char ok"
else
CFLAGS=-DNO_SC
echo " Signed char not accepted; using $CFLAGS"
fi
echo "main(){unsigned char c; c=0;}" > test.c
if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null
then echo " Unsigned char ok"
else
CFLAGS="$CFLAGS -DNO_UC"
echo " Unsigned char not accepted; using $CFLAGS"
fi
echo "main(){unsigned short s;unsigned long l;s=0;l=0;}" > test.c
if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null
then echo " Unsigned short and long ok"
else
CFLAGS="$CFLAGS -DNO_UI"
echo " Unsigned short or long not accepted; using $CFLAGS"
fi
echo "void foo(){} main(){foo();}" > test.c
if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null
then echo " Void ok"
else
CFLAGS="$CFLAGS -DNO_VOID"
echo " Void not accepted; using $CFLAGS"
fi
/bin/rm -f test.c a.out
echo Compiling $0 ...
case $# in
0) : check bug in interpreting "$@" in some shells, if no parameters
case `echo 1 "$@" 2` in
"1 2") echo ' *** There is a bug in your shell expanding "$@"!'
echo ' *** Taking remedial action' ;;
"1 2") ;;
esac
esac
case $ID in
"") echo " $CC" $CFLAGS "$@" $0 -o enquire $LIBS
$CC $CFLAGS ${1+"$@"} $0 -o enquire $LIBS ||
{ echo '***' Try setting some CFLAGS; exit 1; }
;;
*) echo " $CC" $CFLAGS "$@" -DID="\"$ID\"" $0 -o enquire $LIBS
$CC $CFLAGS ${1+"$@"} -DID="\"$ID\"" $0 -o enquire $LIBS ||
{ echo '***' Try setting some CFLAGS; exit 1; }
esac
echo "Producing enquire.out limits.h and float.h ..."
echo " enquire > enquire.out"
./enquire > enquire.out || echo ' *** Some problems: see enquire.out'
echo " enquire -l > limits.h"
./enquire -l > limits.h || echo ' *** Some problems: see limits.h'
echo " enquire -f > float.h"
./enquire -f > float.h || echo ' *** Some problems: see float.h'
echo "Verifying the contents of limits.h and float.h ..."
echo " $CC" -DVERIFY $CFLAGS "$@" $0 -o verify $LIBS
$CC -DVERIFY $CFLAGS ${@+"$@"} $0 -o verify $LIBS ||
{ echo '***' Failed; exit 1; }
echo " verify -fl > verify.out"
./verify -fl > verify.out ||
echo ' *** Some problems: see verify.out'
echo Done
exit 0
#endif
/*
PURPOSE
This is a program that determines many properties of the C
compiler and machine that it is run on, such as minimum and
maximum [un]signed char/int/long, many properties of float/ [long]
double, and so on.
As an option it produces the ANSI C float.h and limits.h files.
As a further option, it even checks that the compiler reads the
header files correctly.
It is a good test-case for compilers, since it exercises them with
many limiting values, such as the minimum and maximum floating-point
numbers.
COMPILING AND RUNNING ON UNIX MACHINES
With luck and a following wind, on Unix systems just the following
will work:
sh enquire.c (or whatever filename you chose).
Any parameters are passed to the C compiler, so if the compilation
fails for any reason curable as explained below, you can do the following:
sh enquire.c -DBAD_CPP
If you do get compilation errors, check the line in question.
Very often there is a comment attached saying which define to set.
You can use a different C compiler than the default cc by setting CC:
CC=gcc sh enquire.c -ansi
You can load extra libraries by setting LIBS:
CC=gcc LIBS=-lflong sh enquire.c -ansi
Add ID="string" for the string to be added to the output; for instance:
ID="`hostname` cc -ansi" sh enquire.c -ansi
Compiling may give messages about unreachable code. These you can ignore.
Some compilers offer various flags for different floating point
modes; it's worth trying all possible combinations of these.
Don't say I haven't tried to make life easy for you...
COMPILING AND RUNNING ON NON-UNIX SYSTEMS
On non-Unix systems, you must say (the equivalent of):
cc enquire.c -o enquire
enquire > enquire.out
enquire -l > limits.h
enquire -f > float.h
cc -DVERIFY enquire.c -o verify #this includes limits.h and float.h
verify -fl > verify.out
If your compiler doesn't support: add flag:
signed char (eg pcc) -DNO_SC
unsigned char -DNO_UC
unsigned short and long -DNO_UI
void -DNO_VOID
signal(), or setjmp/longjmp() -DNO_SIG
Try to compile first with no flags, and see if you get any errors
- you might be surprised. (Most non-ANSI compilers need -DNO_SC,
though.) Some compilers need a -f flag for floating point.
Don't use any optimisation flags: the program may not work if you
do. Though "while (a+1.0-a-1.0 == 0.0)" may look like "while(1)"
to an optimiser, to a floating-point unit there's a world of difference.
Compiling may give messages about unreachable code. These you can ignore.
Some compilers offer various flags for different floating point
modes; it's worth trying all possible combinations of these.
FAULTY COMPILERS
Because of bugs and/or inadequacies, some compilers need the following
defines:
- If your C preprocessor doesn't have the predefined __FILE__
macro, and you don't want to call this file enquire.c but, say,
tell.c, add the flag -DFILENAME=\"tell.c\" .
- Some compilers won't accept the line "#include FILENAME". Add
flag -DBAD_CPP. In that case, this file *must* be called
enquire.c.
- Some compilers can't cope with "#ifdef __FILE__". Use
-DFILENAME= or -DBAD_CPP as above.
- Some naughty compilers define __STDC__, but don't really
support it. Some define it as 0, in which case we ignore it.
But if your compiler defines it, and isn't really ANSI C, add
flag -DBAD_STDC. (To those compiler writers: for shame).
- Some naughty compilers define __STDC__, but don't have the
stddef.h include file. Add flag -DBAD_STDDEF. (Gcc needs this
on some machines, due to clashes between stddef.h and other
include files.)
- Some systems crash when you try to malloc all store. To save
users of such defective systems too much grief, they may
compile with -DBAD_MALLOC, which ignores that bit of the code.
Summary of naughty-compiler flags:
If your compiler doesn't support: add flag:
__FILE__ (and you changed the filename) -DFILENAME=\"name.c\"
#ifdef __FILE__ -DBAD_CPP or -DFILENAME=...
#include FILENAME -DBAD_CPP
__STDC__ (properly) -DBAD_STDC
stddef.h -DBAD_STDDEF
malloc(LOTS) == NULL -DBAD_MALLOC
While it is not our policy to support defective compilers, pity has been
taken on people with compilers that can't produce object files bigger than
32k (especially since it was an easy addition). Compile the program
into separate parts like this:
cc -c -DSEP -DPASS0 -o p0.o <other flags> enquire.c
cc -c -DSEP -DPASS1 -o p1.o <other flags> enquire.c
cc -c -DSEP -DPASS2 -o p2.o <other flags> enquire.c
cc -c -DSEP -DPASS3 -o p3.o <other flags> enquire.c
cc -o enquire p0.o p1.o p2.o p3.o
SYSTEM DEPENDENCIES
You may possibly need to add some calls to signal() for other sorts of
exception on your machine than SIGFPE, SIGOVER, SIGBUS, and SIGSEGV.
See lines beginning #ifdef SIGxxx (and communicate the differences to me!).
OUTPUT
Running without argument gives the information as English text. If run
with argument -l (e.g. enquire -l), output is a series of #define's for
the ANSI standard limits.h include file, excluding MB_MAX_CHAR. If run
with argument -f, output is a series of #define's for the ANSI standard
float.h include file (according to ANSI C Draft of Dec 7, 1988).
Flag -v gives verbose output: output includes the English text above
as C comments. The program exit(0)'s if everything went ok, otherwise
it exits with a positive number, telling how many problems there were.
VERIFYING THE COMPILER
If, having produced the float.h and limits.h header files, you want to
verify that the compiler reads them back correctly (there are a lot of
boundary cases, of course, like minimum and maximum numbers), you can
recompile enquire.c with -DVERIFY set (plus the other flags that you used
when compiling the version that produced the header files). This then
recompiles the program so that it #includes "limits.h" and "float.h",
and checks that the constants it finds there are the same as the
constants it produces. Run the resulting program with enquire -fl.
Many compilers fail this test.
NB: You *must* recompile with the same compiler and flags, otherwise
you may get odd results.
You can also use this option if your compiler already has both files,
and you want to confirm that this program produces the right results.
TROUBLESHOOTING.
This program is now quite trustworthy, and suspicious and wrong output
may well be caused by bugs in the compiler, not in the program (however
of course, this is not guaranteed, and no responsibility can be
accepted, etc.)
The program only works if overflows are ignored by the C system or
are catchable with signal().
If the program fails to run to completion (often with the error message
"Unexpected signal at point x"), this often turns out to be a bug in the
C compiler's run-time system. Check what was about to be printed, and
try to narrow the problem down.
Another possible problem is that you have compiled the program to produce
loss-of-precision arithmetic traps. The program cannot cope with these,
and you should re-compile without them. (They should never be the default).
Make sure you compiled with optimisation turned off.
Output preceded by *** WARNING: identifies behaviour of the C system
deemed incorrect by the program. Likely problems are that printf or
scanf don't cope properly with certain boundary numbers: this program
goes to a lot of trouble to calculate its values, and these values
are mostly boundary numbers. Experience has shown that often printf
cannot cope with these values, and so in an attempt to increase
confidence in the output, for each float and double that is printed,
the printed value is checked by using sscanf to read it back.
Care is taken that numbers are printed with enough digits to uniquely
identify them, and therefore that they can be read back identically.
If the number read back is different, then there is probably a bug in
printf or sscanf, and the program prints the warning message.
If the two numbers in the warning look identical, then printf is more
than likely rounding the last digit(s) incorrectly. To put you at ease
that the two really are different, the bit patterns of the two numbers
are also printed. The difference is very likely in the last bit.
Many scanf's read the minimum double back as 0.0, and similarly cause
overflow when reading the maximum double. This program quite ruthlessly
declares all these behaviours faulty. The point is that if you get
one of these warnings, the output may be wrong, so you should check
the result carefully if you intend to use the results. Of course, printf
and sscanf may both be wrong, and cancel each other out, so you should
check the output carefully anyway.
The warning that "a cast didn't work" refers to cases like this:
float f;
#define C 1.234567890123456789
f= C;
if (f != (float) C) printf ("Wrong!");
A faulty compiler will widen f to double and ignore the cast to float,
and because there is more accuracy in a double than a float, fail to
recognise that they are the same. In the actual case in point, f and C
are passed as parameters to a function that discovers they are not equal,
so it's just possible that the error was in the parameter passing,
not in the cast (see function Verify()).
For ANSI C, which has float constants, the error message is "constant has
wrong precision".
REPORTING PROBLEMS
If the program doesn't work for you for any reason that can't be
narrowed down to a problem in the C compiler, or it has to be
changed in order to get it to compile, or it produces suspicious
output (like a very low maximum float, for instance), please mail
the problem and an example of the incorrect output to
Steven.Pemberton@cwi.nl so that improvements can be worked into
future versions. Try to give as much information as possible;
DON'T FORGET TO MENTION THE VERSION NUMBER!
The program tries to catch and diagnose bugs in the compiler/run-time
system. I would be especially pleased to have reports of failures so
that I can improve this service.
I apologise unreservedly for the contorted use of the preprocessor...
but it was fun!
NEW VERSIONS
Worried that you may not have the latest version? Ftp to
ftp.cwi.nl, and look in directory pub/steven/enquire
for file enquireXX.c; XX is the version number. Or look at
http://www.cwi.nl/~steven/enquire.html
HOW DOES ENQUIRE WORK?
There is an article that explains a lot of the workings: The
Ergonomics of Portability; available from the above addresses as file
enquire.ps.
THE SMALL PRINT
This is not a public domain program; nor is any other program that
carries a copyright notice. It is however freely copyable under the
following conditions:
You may copy and distribute verbatim copies of this source file.
You may modify this source file, and copy and distribute such
modified versions, provided that you leave the copyright notice
at the top of the file and also cause the modified file to carry
prominent notices stating that you changed the files and the
date of any change; and cause the whole of any work that you
distribute or publish, that in whole or in part contains or is a
derivative of this program or any part thereof, to be licensed
at no charge to all third parties on terms identical to those
here.
While every effort has been taken to make this program as reliable as
possible, no responsibility can be taken for the correctness of the
output, nor suitability for any particular use.
If you do have a fix to any problem, please send it to me, so that
other people can have the benefits.
This program is an offshoot of a project funded by public funds.
If you use this program for research or commercial use (i.e. more
than just for the fun of knowing about your compiler) mailing a short
note of acknowledgement may help keep enquire.c supported.
ACKNOWLEDGEMENTS
Many people have given time and ideas to making this program what it is.
To all of them thanks, and apologies for not mentioning them by name.
HISTORY
Originally started as a program to generate configuration constants
for a large piece of software we were writing, which later took on
a life of its own...
1.0 Length 6658!; end 1984?
Unix only. Only printed a dozen maximum int/double values.
2.0 Length 10535; Spring 1985
Prints values as #defines (about 20 of them)
More extensive floating point, using Cody and Waite
Handles signals better
Programs around optimisations
Handles Cybers
3.0 Length 12648; Aug 1987; prints about 42 values
Added PASS stuff, so treats float as well as double
4.0 Length 33891; Feb 1989; prints around 85 values
First GNU version (for gcc, where they called it hard-params.c)
Generates float.h and limits.h files
Handles long double
Generates warnings for dubious output
4.1 Length 47738; April 1989
Added VERIFY and TEST
4.2 Length 63442; Feb 1990
Added SEP
Fixed eps/epsneg
Added check for pseudo-unsigned chars
Added description for each #define output
Added check for absence of defines during verify
Added prototypes
Added BAD_STDC and BAD_CPP
Fixed alignments output
4.3 Length 75000; Oct 1990; around 114 lines of output
Function xmalloc defined, Richard Stallman, June 89.
Alignments computed from member offsets rather than structure sizes,
Richard Stallman, Oct 89
Print whether char* and int* pointers have the same format;
also char * and function *
Update to Draft C version Dec 7, 1988
- types of constants produced in limits.h
(whether to put a U after unsigned shorts and chars and
whether to output -1024 as (-1023-1))
- values of SCHAR_MIN/MAX
- values of *_EPSILON (not the smallest but the effective smallest)
Added FILENAME, since ANSI C doesn't allow #define __FILE__
Renamed from config.c to enquire.c
Added size_t and ptrdiff_t enquiries
Added promotion enquiries
Added type checks of #defines
Added BAD_STDDEF
Changed endian to allow for cases where not all bits are used
Sanity check for max integrals
Fixed definition of setjmp for -DNO_SIG
Moved #define ... 0.0L inside #ifdef STDC, in case some cpp's tokenize
Added BAD_MALLOC
5.0 Length 88228; February 1993; around 120 lines of output
(depends on what you count)
Added the 'sh enquire.c' horror/delight: thanks David Mankins@think
Added checks for long names: thanks Steve Simon@leeds-poly
Added FPE signal checks: thanks Leonid A. Broukhis
Added check for dereferencing NULL
Added TESTI
Added LIBS, fixed showtype: thanks Rainer Orth@TechFak.Uni-Bielefeld.DE
Added a free(): thanks nickc@perihelion.co.uk
Added signal catching to the malloc part
Renamed naughty-compiler defines to BAD_*
Renamed and altered Verify() to better check faulty compilers
Shut some compilers up from giving incorrect warnings.
Fixed sign_of(): thanks Hugh Redelmeier@redvax
Fixed USHRT_MAX for sizeof(short)=sizeof(int) but INT_MAX > SHRT_MAX
Fixed NO_UI
Fixed -DSEP: thanks Mike Black@seismo
Fixed the case where stdio.h includes limits.h: thanks rms@gnu
Fixed exponent(): thanks Christophe BINOT
<chb%hpvpta.france.hp.com@hplb.hpl.hp.com>
5.0a Aug 1997
Made handling of ID= easier
Improved the reporting of use of bits in Floating values.
5.1 Length 88739; Sep 1998
Fixed detection of infinity for machines with no overflow trap
Speeded up search for max char (first 32 bit char machine turned up...)
5.1a Length 88832; Feb 1999
Changed identification message
5.1b Length 88926; Oct 2002
Fixed a missing \n in an output line; thanks Leonid Broukhis again
*/
/* Set FILENAME to the name of this file */
#ifndef FILENAME
#ifdef BAD_CPP
#define FILENAME "enquire.c"
#else
#ifdef __FILE__ /* It's a compiler bug if this fails. Define BAD_CPP */
#define FILENAME __FILE__
#else
#define FILENAME "enquire.c"
#endif /* __FILE__ */
#endif /* BAD_CPP */
#endif /* FILENAME */
/* This file is read three times (it #includes itself), to generate
otherwise identical code for each of short+float, int+double,
long+long double. If PASS isn't defined, then this is the first pass.
Code bracketed by 'PASS0' is for stuff independent of all three,
but is read during the first pass.
*/
#ifndef PASS
#ifdef SEP /* so we're only interested if this is pass 1 or not */
#ifdef PASS1
#define PASS 1
#else
#define PASS 0
#endif
#else /* no SEP, so this is the first pass */
#define PASS 1
#define PASS0 1
#define PASS1 1
#endif /* SEP */
/* Void just marks the functions that don't return a result */
#ifdef NO_VOID
#define Void int
#else
#define Void void
#endif
/* Set STDC to whether this is *really* an ANSI C compiler.
Some bad compilers define __STDC__, when they don't support it.
Compile with -DBAD_STDC to get round this.
*/
#ifndef BAD_STDC
#ifdef __STDC__
#if __STDC__ /* If __STDC__ is 0, assume it isn't supported */
#define STDC
#endif
#endif
#endif
/* Stuff different for ANSI C, and old C:
ARGS and NOARGS are used for function prototypes.
Volatile is used to reduce the chance of optimisation,
and to prevent variables being put in registers (when setjmp/longjmp
wouldn't work as we want)
Long_double is the longest floating point type available.
stdc is used in tests like "if (stdc)", which is less ugly than #ifdef.
U is output after unsigned constants.
*/
#ifdef STDC
#define ARGS(x) x
#define NOARGS (void)
#define Volatile volatile
#define Long_double long double
#define stdc 1
#define U "U"
#else /* Old style C */
#define ARGS(x) ()
#define NOARGS ()
#define Volatile static
#define Long_double double
#define stdc 0
#define U ""
#endif /* STDC */
/* include files */
#include <stdio.h>
#ifdef STDC
#ifndef BAD_STDDEF
#include <stddef.h> /* for size_t: if this fails, define BAD_STDDEF */
#endif
#endif
#ifdef NO_SIG
#define jmp_buf int
#else
#include <signal.h> /* if this fails, define NO_SIG */
#include <setjmp.h> /* if this fails, define NO_SIG */
#endif
/* Kludge around the possiblity that <stdio.h> includes <limits.h> */
#ifdef CHAR_BIT
#undef CHAR_BIT
#undef CHAR_MAX
#undef CHAR_MIN
#undef SCHAR_MAX
#undef SCHAR_MIN
#undef UCHAR_MAX
#undef UCHAR_MIN
#endif
#ifdef VERIFY
#include "limits.h"
#include "float.h"
#endif
/* The largest unsigned type */
#ifdef NO_UI
#define ulong unsigned int
#else
#define ulong unsigned long
#endif
/* Some shorthands */
#define Vprintf if (V) printf
#define Unexpected(place) if (setjmp(lab)!=0) croak(place)
#define fabs(x) (((x)<0.0)?(-x):(x))
#endif /* PASS */
/* A description of the ANSI constants */
#define D_CHAR_BIT "Number of bits in a storage unit"
#define D_CHAR_MAX "Maximum char"
#define D_CHAR_MIN "Minimum char"
#define D_SCHAR_MAX "Maximum signed char"
#define D_SCHAR_MIN "Minimum signed char"
#define D_UCHAR_MAX "Maximum unsigned char (minimum is always 0)"
#define D_INT_MAX "Maximum %s"
#define D_INT_MIN "Minimum %s"
#define D_UINT_MAX "Maximum unsigned %s (minimum is always 0)"
#define D_FLT_ROUNDS "Addition rounds to 0: zero, 1: nearest, 2: +inf, 3: -inf, -1: unknown"
#define D_FLT_RADIX "Radix of exponent representation"
#define D_MANT_DIG "Number of base-FLT_RADIX digits in the significand of a %s"
#define D_DIG "Number of decimal digits of precision in a %s"
#define D_MIN_EXP "Minimum int x such that FLT_RADIX**(x-1) is a normalised %s"
#define D_MIN_10_EXP "Minimum int x such that 10**x is a normalised %s"
#define D_MAX_EXP "Maximum int x such that FLT_RADIX**(x-1) is a representable %s"
#define D_MAX_10_EXP "Maximum int x such that 10**x is a representable %s"
#define D_MAX "Maximum %s"
#define D_EPSILON "Difference between 1.0 and the minimum %s greater than 1.0"
#define D_MIN "Minimum normalised %s"
#ifdef PASS0
/* Prototypes for what's to come: */
int false NOARGS;
#ifdef BAD_STDDEF
char *malloc (); /* Old style prototype, since we don't know what size_t is */
#else
char *malloc ARGS((size_t size));
#endif
Void free ARGS((char *p)); /* Syntax error here? Try -DNO_VOID */
Void exit ARGS((int status));
char *f_rep ARGS((int precision, Long_double val));
int maximum_int NOARGS;
int cprop NOARGS;
int basic NOARGS;
Void sprop NOARGS;
Void iprop NOARGS;
Void lprop NOARGS;
Void usprop NOARGS;
Void uiprop NOARGS;
Void ulprop NOARGS;
int fprop ARGS((int byte_size));
int dprop ARGS((int byte_size));
int ldprop ARGS((int byte_size));
Void efprop ARGS((int fprec, int dprec, int lprec));
Void edprop ARGS((int fprec, int dprec, int lprec));
Void eldprop ARGS((int fprec, int dprec, int lprec));
int setmode ARGS((char *s));
Void farewell ARGS((int bugs));
Void describe ARGS((char *description, char *extra));
Void missing ARGS((char *s));
Void fmissing ARGS((char *s));
Void check_defines NOARGS;
Void bitpattern ARGS((char *p, unsigned int size));
int ceil_log ARGS((int base, Long_double x));
Void croak ARGS((int place));
Void trap1 ARGS((int sig));
Void eek_a_bug ARGS((char *problem));
Void endian ARGS((int byte_size));
int exponent ARGS((Long_double x, Long_double *fract, int *exp));
int floor_log ARGS((int base, Long_double x));
Void f_define ARGS((char *desc, char *extra, char *sort, char *name,
int prec, Long_double val, char *mark));
Void i_define ARGS((char *desc, char *extra, char *sort, char *name,
long val, long lim, long req, char *mark));
Void u_define ARGS((char *desc, char *extra, char *sort, char *name,
ulong val, ulong req, char *mark));
#ifdef NO_SIG /* There's no signal(), or setjmp/longjmp() */
/* Dummy routines instead */
typedef int jmp_buf;
int setjmp ARGS((jmp_buf lab));
jmp_buf lab, mlab;
int setjmp(lab) jmp_buf lab; { return(0); }
Void signal(i, p) int i, (*p)(); {}
#else
jmp_buf lab, mlab;
Void overflow(sig) int sig; { /* what to do on over/underflow */
signal(sig, overflow);
longjmp(lab, 1);
}
Void address(sig) int sig; { /* what to do on an address error */
signal(sig, address);
longjmp(mlab, 1);
}
#endif /*NO_SIG*/
int V= 0, /* verbose */
L= 0, /* produce limits.h */
F= 0, /* produce float.h */
bugs=0; /* The number of (possible) bugs in the output */
char co[4], oc[4]; /* Comment starter and ender symbols */
int bits_per_byte; /* the number of bits per unit returned by sizeof() */
int flt_rounds; /* The calculated value of FLT_ROUNDS */
int flt_radix; /* The calculated value of FLT_RADIX */
Volatile int trapped; /* For testing FPE traps */
#ifdef TEST
/* Set the fp modes on a SUN with 68881 chip, to check that different
rounding modes etc. get properly detected.
Compile with -f68881 for cc, -m68881 for gcc, and with additional flag
-DTEST. Run with additional parameter +hex-number, to set the 68881 mode
register to hex-number
*/
/* Bits 0x30 = rounding mode */
#define ROUND_BITS 0x30
#define TO_NEAREST 0x00
#define TO_ZERO 0x10
#define TO_MINUS_INF 0x20
#define TO_PLUS_INF 0x30 /* The SUN FP user's guide seems to be wrong here */
/* Bits 0xc0 = extended rounding */
#define EXT_BITS 0xc0
#define ROUND_EXTENDED 0x00
#define ROUND_SINGLE 0x40
#define ROUND_DOUBLE 0x80
/* Enabled traps */
#define EXE_INEX1 0x100
#define EXE_INEX2 0x200
#define EXE_DZ 0x400
#define EXE_UNFL 0x800
#define EXE_OVFL 0x1000
#define EXE_OPERR 0x2000
#define EXE_SNAN 0x4000
#define EXE_BSUN 0x8000
/* Only used for testing, on a Sun with 68881 chip */
/* Print the FP mode */
printmode(new) unsigned new; {
fpmode_(&new);
printf("New fp mode:\n");
printf(" Round toward ");
switch (new & ROUND_BITS) {
case TO_NEAREST: printf("nearest"); break;
case TO_ZERO: printf("zero"); break;
case TO_MINUS_INF: printf("minus infinity"); break;
case TO_PLUS_INF: printf("plus infinity"); break;
default: printf("???"); break;
}
printf("\n Extended rounding precision: ");
switch (new & EXT_BITS) {
case ROUND_EXTENDED: printf("extended"); break;
case ROUND_SINGLE: printf("single"); break;
case ROUND_DOUBLE: printf("double"); break;
default: printf("???"); break;
}
printf("\n Enabled exceptions:");
if (new & (unsigned) EXE_INEX1) printf(" inex1");
if (new & (unsigned) EXE_INEX2) printf(" inex2");
if (new & (unsigned) EXE_DZ) printf(" divz");
if (new & (unsigned) EXE_UNFL) printf(" unfl");
if (new & (unsigned) EXE_OVFL) printf(" ovfl");
if (new & (unsigned) EXE_OPERR) printf(" operr");
if (new & (unsigned) EXE_SNAN) printf(" snan");
if (new & (unsigned) EXE_BSUN) printf(" bsun");
printf("\n");
}
/* Only used for testing, on a Sun with 68881 chip */
/* Set the FP mode */
int setmode(s) char *s; {
unsigned mode=0, dig;
char c;
while (*s) {
c= *s++;
if (c>='0' && c<='9') dig= c-'0';
else if (c>='a' && c<='f') dig= c-'a'+10;
else if (c>='A' && c<='F') dig= c-'A'+10;
else return 1;
mode= mode<<4 | dig;
}
printmode(mode);
return 0;
}
#define SETMODE
#endif
#ifdef TESTI /* Test mode using SunOs IEEE routines */
#include <sys/ieeefp.h>
int setmode(s) char *s; {
char *dummy, c, *cmd, *val;
while (*s) {
switch (c= *s++) {
case '=': cmd= "direction"; val= "nearest"; break;
case '0': cmd= "direction"; val= "tozero"; break;
case '+': cmd= "direction"; val= "positive"; break;
case '-': cmd= "direction"; val= "negative"; break;
case '1': cmd= "precision"; val= "single"; break;
case '2': cmd= "precision"; val= "double"; break;
case '3': cmd= "precision"; val= "extended"; break;
case '~': cmd= "exception"; val= "inexact"; break;
case '/': cmd= "exception"; val= "division"; break;
case '>': cmd= "exception"; val= "overflow"; break;
case '<': cmd= "exception"; val= "underflow"; break;
default:
printf("Bad setmode character: %c\n", c);
return 1;
break;
}
printf("Set %s %s", cmd, val);
if (ieee_flags("set", cmd, val, &dummy)) {
printf(": failed\n");
return 1;
}
printf("\n");
}
return 0;
}
#define SETMODE
#endif
#ifndef SETMODE
/* ARGSUSED */
int setmode(s) char *s; {
fprintf(stderr, "Can't set mode: not compiled with TEST\n");
return(1);
}
#endif
int memeq(p1, size1, p2, size2) char *p1, *p2; int size1, size2; {
/* See if two blocks of store are identical */
int i;
if (size1 != size2) return 0;
for (i=1; i<=size1; i++) {
if (*p1++ != *p2++) return 0;
}
return 1;
}
Void farewell(bugs) int bugs; {
if (bugs == 0) exit(0);
printf("\n%sFor hints on dealing with the ", co);
if (bugs == 1) printf("problem");
else printf("%d problems", bugs);
printf(" above\n see the section 'TROUBLESHOOTING' in the file ");
printf("%s%s\n", FILENAME, oc);
exit(bugs);
}
/* The program has received a signal where it wasn't expecting one */
Void croak(place) int place; {
printf("*** Unexpected signal at point %d\n", place);
farewell(bugs+1); /* An exit isn't essential here, but avoids loops */
}
/* This is here in case alloca.c is used, which calls this. */
char *xmalloc(size) unsigned size; {
char *value = malloc(size);
if (value == 0) {
fprintf(stderr, "Virtual memory exceeded\n");
exit(bugs+1);
}
return value;
}
int maxint;
int maximum_int() {
/* Find the maximum integer */
Volatile int newi, int_max, two=2;
/* Calculate maxint ***********************************/
/* Calculate 2**n-1 until overflow - then use the previous value */
newi=1; int_max=0;
if (setjmp(lab)==0) { /* Yields int_max */
while(newi>int_max) {
int_max=newi;
newi=newi*two+1;
}
}
Unexpected(0);
return int_max;
}
/* How long are my identifiers? I could go further here, but some compilers
have line length limits that I don't want to break.
*/
int zzzzzzzzz1zzzzzzzzz2zzzzzzzzz3zzzzzzzzz4zzzzzzzzz5zzzzzzzzz6zzzz=64;
int name_len() {
int zzzzzzzzz1zzzzzzzzz2zzzzzzzzz3zz=32;
{ int zzzzzzzzz1zzzzzz=16;
{ int zzzzzzzz=8;
{ int zzzzzzz=7;
{ int zzzzzz=6;
return
zzzzzzzzz1zzzzzzzzz2zzzzzzzzz3zzzzzzzzz4zzzzzzzzz5zzzzzzzzz6zzzz;
}
}
}
}
}
#define aaaaaaaaa1aaaaaaaaa2aaaaaaaaa3aaaaaaaaa4aaaaaaaaa5aaaaaaaaa6aaaa 64
#define LENGTH 64
#ifdef aaaaaaaaa1aaaaaaaaa2aaaaaaaaa3aa
#undef LENGTH
#define LENGTH 32
#endif
#ifdef aaaaaaaaa1aaaaaa
#undef LENGTH
#define LENGTH 16
#endif
#ifdef aaaaaaaa
#undef LENGTH
#define LENGTH 8
#endif
#undef aaaaaaaaa1aaaaaaaaa2aaaaaaaaa3aaaaaaaaa4aaaaaaaaa5aaaaaaaaa6aaaa
Void long_names() {
int l= name_len();
Vprintf("Compiler names are at least %d chars long", l);
if (l != 64)
Vprintf(" (but less than %d)", l*2);
Vprintf("\n");
Vprintf("Preprocessor names are at least %d long", LENGTH);
if (LENGTH != 64)
Vprintf(" (but less than %d)", LENGTH*2);
Vprintf("\n\n");
}
/* Used by FPROP to see if FP traps are generated, and if they may return */
Void trap2(sig) int sig; {
longjmp(lab, 1);
}
Void trap1(sig) int sig; {
trapped= 1; /* A global */
signal(sig, trap2);
}
Void setsignals() {
#ifdef SIGFPE
signal(SIGFPE, overflow);
#endif
#ifdef SIGOVER
signal(SIGOVER, overflow);
#endif
#ifdef SIGBUS
signal(SIGBUS, address);
#endif
#ifdef SIGSEGV
signal(SIGSEGV, address);
#endif
/* Add more calls as necessary */
}
#undef LENGTH
int main(argc, argv) int argc; char *argv[]; {
int dprec, fprec, lprec;
int i; char *s; int bad;
setsignals();
Unexpected(1);
bad=0;
for (i=1; i < argc; i++) {
s= argv[i];
if (*s == '-') {
s++;
while (*s) {
switch (*(s++)) {
case 'v': V=1; break;
case 'l': L=1; break;
case 'f': F=1; break;
default: bad=1; break;
}
}
} else if (*s == '+') {
s++;
bad= setmode(s);
} else bad= 1;
}
if (bad) {
fprintf(stderr,
"Usage: %s [-vlf]\n v=Verbose l=Limits.h f=Float.h\n",
argv[0]);
exit(1);
}
if (L || F) {
co[0]= '/'; oc[0]= ' ';
co[1]= '*'; oc[1]= '*';
co[2]= ' '; oc[2]= '/';
co[3]= '\0'; oc[3]= '\0';
} else {
co[0]= '\0'; oc[0]= '\0';
V=1;
}
if (L) printf("%slimits.h%s\n", co, oc);
if (F) printf("%sfloat.h%s\n", co, oc);
#ifdef ID
printf("%sProduced by enquire version %s (%s), CWI, Amsterdam\n %s\n",
co, VERSION, ID, WEB, oc);
#else
printf("%sProduced by enquire version %s, CWI, Amsterdam\n %s %s\n",
co, VERSION, WEB, oc);
#endif
#ifdef VERIFY
printf("%sVerification phase%s\n", co, oc);
#endif
#ifdef NO_SIG
Vprintf("%sCompiled without signal(): %s%s\n",
co,
"there's nothing that can be done if overflow occurs",
oc);
#endif
#ifdef NO_SC
Vprintf("%sCompiled without signed char%s\n", co, oc);
#endif
#ifdef NO_UC
Vprintf("%sCompiled without unsigned char%s\n", co, oc);
#endif
#ifdef NO_UI
Vprintf("%sCompiled without unsigned short or long%s\n", co, oc);
#endif
#ifdef __STDC__
Vprintf("%sCompiler claims to be ANSI C level %d%s\n",
co, __STDC__, oc);
#else
Vprintf("%sCompiler does not claim to be ANSI C%s\n", co, oc);
#endif
printf("\n");
long_names();
check_defines();
maxint= maximum_int();
bits_per_byte= basic();
Vprintf("\n");
if (F||V) {
fprec= fprop(bits_per_byte);
dprec= dprop(bits_per_byte);
lprec= ldprop(bits_per_byte);
efprop(fprec, dprec, lprec);
edprop(fprec, dprec, lprec);
eldprop(fprec, dprec, lprec);
}
#ifndef BAD_MALLOC
if (V) {
/* An extra goody: the approximate amount of data-space */
/* Allocate store until no more available */
/* Different implementations have a different argument type
to malloc. Here we assume that it's the same type as
that which sizeof() returns */
unsigned int size;
Volatile long total;
char kmg, *ptr, *save;
save= NULL;
size=maximum_int()/4;
total=0;
while (size!=0) {
if (setjmp(mlab) == 0) {
while ((ptr= malloc((false()?sizeof(int):size))) != (char *)NULL) {
if (save == NULL) save= ptr; /* save the biggest chunk */
total+=(size/2);
}
} else {
eek_a_bug("Trying to malloc all store generates a trap");
}
size/=2;
}
if (setjmp(mlab)!=0) croak(-1);
if (save != NULL) free(save);
total= (total+511)/512; /* Sic */ kmg= 'K';
if (total > 10000) {
total= (total+999)/1000; kmg= 'M';
}
if (total > 10000) {
total= (total+999)/1000; kmg= 'G';
}
if (total > 10000) {
total= (total+999)/1000; kmg= 'T';
}
Vprintf("%sMemory mallocatable ~= %ld %cbytes%s\n",
co, total, kmg, oc);
}
#endif
farewell(bugs);
return bugs; /* To keep compilers and lint happy */
}
Void eek_a_bug(problem) char *problem; {
/* The program has discovered a problem */
printf("\n%s*** WARNING: %s%s\n", co, problem, oc);
bugs++;
}
Void describe(description, extra) char *description, *extra; {
/* Produce the description for a #define */
printf(" %s", co);
printf(description, extra);
printf("%s\n", oc);
}
Void i_define(desc, extra, sort, name, val, lim, req, mark)
char *desc, *extra, *sort, *name; long val, lim, req; char *mark; {
/* Produce a #define for a signed int type */
describe(desc, extra);
if (val >= 0) {
printf("#define %s%s %ld%s\n", sort, name, val, mark);
} else if (val + lim < 0) {
/* We may not produce a constant like -1024 if the max
allowable value is 1023. It has then to be output as
-1023-1. lim is the max allowable value. */
printf("#define %s%s (%ld%s%ld%s)\n",
sort, name, -lim, mark, val+lim, mark);
} else {
printf("#define %s%s (%ld%s)\n", sort, name, val, mark);
}
/* If VERIFY is not set, val and req are just the same value;
if it is set, val is the value as calculated, and req is
the #defined constant
*/
if (val != req) {
printf("%s*** Verify failed for above #define!\n", co);
printf(" Compiler has %ld for value%s\n\n", req, oc);
bugs++;
}
Vprintf("\n");
}
Void u_define(desc, extra, sort, name, val, req, mark)
char *desc, *extra, *sort, *name; ulong val, req; char *mark; {
/* Produce a #define for an unsigned value */
describe(desc, extra);
printf("#define %s%s %lu%s%s\n", sort, name, val, U, mark);
if (val != req) {
printf("%s*** Verify failed for above #define!\n", co);
printf(" Compiler has %lu for value%s\n\n", req, oc);
bugs++;
}
Vprintf("\n");
}
Void f_define(desc, extra, sort, name, precision, val, mark)
char *desc, *extra, *sort, *name; int precision;
Long_double val; char *mark; {
/* Produce a #define for a float/double/long double */
describe(desc, extra);
if (stdc) {
printf("#define %s%s %s%s\n",
sort, name, f_rep(precision, val), mark);
} else if (*mark == 'F') {
/* non-ANSI C has no float constants, so cast the constant */
printf("#define %s%s ((float)%s)\n",
sort, name, f_rep(precision, val));
} else {
printf("#define %s%s %s\n", sort, name, f_rep(precision, val));
}
Vprintf("\n");
}
int floor_log(base, x) int base; Long_double x; {
/* return floor(log base(x)) */
int r=0;
while (x>=base) { r++; x/=base; }
return r;
}
int ceil_log(base, x) int base; Long_double x; {
int r=0;
while (x>1.0) { r++; x/=base; }
return r;
}
int exponent(x, fract, exp) Long_double x; Long_double *fract; int *exp; {
/* Split x into a fraction and a power of ten;
returns 0 if x is unusable, 1 otherwise.
Only used for error messages about faulty output.
*/
int r=0, neg=0;
Long_double old;
*fract=0.0; *exp=0;
if (x<0.0) {
x= -x;
neg= 1;
}
if (x==0.0) return 1;
if (x>=10.0) {
while (x>=10.0) {
old=x; r++; x/=10.0;
if (old==x) return 0;
}
} else {
while (x<1.0) {
old=x; r--; x*=10.0;
if (old==x) return 0;
}
}
if (neg) *fract= -x;
else *fract= x;
*exp=r;
return 1;
}
char *f_rep(precision, val) int precision; Long_double val; {
/* Return the floating representation of val */
static char buf[1024];
char *f1;
if (sizeof(double) == sizeof(Long_double)) {
/* Assume they're the same, and use non-stdc format */
/* This is for stdc compilers using non-stdc libraries */
f1= "%.*e";
} else {
/* It had better support Le then */
f1= "%.*Le";
}
sprintf(buf, f1, precision, val);
return buf;
}
Void bitpattern(p, size) char *p; unsigned int size; {
/* Printf the bit-pattern of p */
char c;
unsigned int i;
int j;
for (i=1; i<=size; i++) {
c= *p;
p++;
for (j=bits_per_byte-1; j>=0; j--)
printf("%c", (c>>j)&1 ? '1' : '0');
if (i!=size) printf(" ");
}
}
Void fill(p, size) char *p; int size; {
char *ab= "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int i;
for (i=0; i<size; i++)
p[i]= ab[i];
}
#define Order(x, mode)\
printf("%s%s ", co, mode); fill((char *)&x, sizeof(x)); \
for (i=1; i<=sizeof(x); i++) { c=((x>>(byte_size*(sizeof(x)-i)))&mask);\
putchar(c==0 ? '?' : (char)c); }\
printf("%s\n", oc);
Void endian(byte_size) int byte_size; {
/* Printf the byte-order used on this machine */
/*unsigned*/ short s=0;
/*unsigned*/ int j=0;
/*unsigned*/ long l=0;
unsigned int mask, i, c;
mask=0;
for (i=1; i<=(unsigned)byte_size; i++) mask= (mask<<1)|1;
if (V) {
printf("%sCHARACTER ORDER%s\n", co, oc);
Order(s, "short:");
Order(j, "int: ");
Order(l, "long: ");
}
}
Void missing(s) char *s; {
printf("%s*** #define %s missing from limits.h%s\n", co, s, oc);
bugs++;
}
Void fmissing(s) char *s; {
printf("%s*** #define %s missing from float.h%s\n", co, s, oc);
bugs++;
}
/* To try and fool optimisers */
int false() { return 0; }
#define Promoted(x) (false()?(x):(-1))
#define is_signed(x) (Promoted(x) < 0)
#define sign_of(x) (is_signed(x)?"signed":"unsigned")
#define Signed 1
#define Unsigned 0
#define sgn(x) ((is_signed(x))?Signed:Unsigned)
#define showtype(t, x) Vprintf("%s%s %s %s%s\n", co, t, sign_of(x), type_of((int)sizeof(x)), oc)
char *type_of(x) int x; {
if (x == sizeof(char)) {
if (sizeof(char) == sizeof(int)) return "char/short/int";
if (sizeof(char) == sizeof(short)) return "char/short";
return "char";
}
if (x == sizeof(short)) {
if (sizeof(short) == sizeof(int)) return "short/int";
return "short";
}
if (x == sizeof(int)) {
if (sizeof(int) == sizeof(long)) return "int/long";
return "int";
}
if (x == sizeof(long)) return "long";
return "unknown-type";
}
char *ftype_of(x) int x; {
if (x == sizeof(float)) {
return "float";
}
if (x == sizeof(double)) {
if (sizeof(double) == sizeof(Long_double))
return "(long)double";
return "double";
}
if (x == sizeof(Long_double)) {
return "long double";
}
return "unknown-type";
}
Void typerr(name, esign, esize, sign, size)
char *name; int esign, esize, sign, size;
{
Vprintf("*** %s has wrong type: expected %s %s, found %s %s\n",
name, sign_of(esign), type_of(esize),
sign_of(sign), type_of(size));
}
Void ftyperr(name, esize, size) char *name; int esize, size; {
Vprintf("*** %s has wrong type: expected %s, found %s\n",
name, ftype_of(esize), ftype_of(size));
}
Void promotions() {
int si; long sl;
unsigned int ui;
short ss;
#ifndef NO_UI
unsigned long ul; /* if this fails, define NO_UI */
unsigned short us; /* if this fails, define NO_UI */
ul=0; us=0;
#endif
/* Shut compiler warnings up: */
si=0; sl=0; ui=0; ss=0;
Vprintf("\n%sPROMOTIONS%s\n", co, oc);
/* Sanity checks. Possible warnings here; should be no problem */
if (is_signed(ui))
eek_a_bug("unsigned int promotes to signed!\n");
if (!is_signed(si))
eek_a_bug("signed int promotes to unsigned!\n");
if (!is_signed(sl))
eek_a_bug("signed long promotes to unsigned!\n");
if (sizeof(Promoted(si)) != sizeof(int))
eek_a_bug("int doesn't promote to int!\n");
if (sizeof(Promoted(sl)) != sizeof(long))
eek_a_bug("long doesn't promote to long!\n");
if (sizeof(Promoted(ss)) != sizeof(int))
eek_a_bug("short doesn't promote to int!\n");
if (sizeof(Promoted(ui)) != sizeof(int))
eek_a_bug("unsigned int doesn't promote to int!\n");
#ifndef NO_UI
if (sizeof(Promoted(ul)) != sizeof(long))
eek_a_bug("unsigned long doesn't promote to long!\n");
if (is_signed(ul))
eek_a_bug("unsigned long promotes to signed!\n");
#endif
#ifndef NO_UI
showtype("unsigned short promotes to", Promoted(us));
#endif
showtype("long+unsigned gives", sl+ui);
}
#define checktype(x, n, s, t) if((sgn(x)!=s)||(sizeof(x)!=sizeof(t))) typerr(n, s, (int)sizeof(t), sgn(x), (int)sizeof(x));
#define fchecktype(x, n, t) if (sizeof(x) != sizeof(t)) ftyperr(n, (int)sizeof(x), (int)sizeof(t));
Void check_defines() {
/* ensure that all #defines are present and have the correct type */
#ifdef VERIFY
int usign;
#ifdef NO_UI
usign= Signed;
#else
/* Implementations promote unsigned short differently */
usign= is_signed((unsigned short)0);
#endif
if (L) {
#ifdef CHAR_BIT
checktype(CHAR_BIT, "CHAR_BIT", Signed, int);
#else
missing("CHAR_BIT");
#endif
#ifdef CHAR_MAX
checktype(CHAR_MAX, "CHAR_MAX", Signed, int);
#else
missing("CHAR_MAX");
#endif
#ifdef CHAR_MIN
checktype(CHAR_MIN, "CHAR_MIN", Signed, int);
#else
missing("CHAR_MIN");
#endif
#ifdef SCHAR_MAX
checktype(SCHAR_MAX, "SCHAR_MAX", Signed, int);
#else
missing("SCHAR_MAX");
#endif
#ifdef SCHAR_MIN
checktype(SCHAR_MIN, "SCHAR_MIN", Signed, int);
#else
missing("SCHAR_MIN");
#endif
#ifdef UCHAR_MAX
checktype(UCHAR_MAX, "UCHAR_MAX", Signed, int);
#else
missing("UCHAR_MAX");
#endif
#ifdef SHRT_MAX
checktype(SHRT_MAX, "SHRT_MAX", Signed, int);
#else
missing("SHRT_MAX");
#endif
#ifdef SHRT_MIN
checktype(SHRT_MIN, "SHRT_MIN", Signed, int);
#else
missing("SHRT_MIN");
#endif
#ifdef INT_MAX
checktype(INT_MAX, "INT_MAX", Signed, int);
#else
missing("INT_MAX");
#endif
#ifdef INT_MIN
checktype(INT_MIN, "INT_MIN", Signed, int);
#else
missing("INT_MIN");
#endif
#ifdef LONG_MAX
checktype(LONG_MAX, "LONG_MAX", Signed, long);
#else
missing("LONG_MAX");
#endif
#ifdef LONG_MIN
checktype(LONG_MIN, "LONG_MIN", Signed, long);
#else
missing("LONG_MIN");
#endif
#ifdef USHRT_MAX
checktype(USHRT_MAX, "USHRT_MAX", usign, int);
#else
missing("USHRT_MAX");
#endif
#ifdef UINT_MAX
checktype(UINT_MAX, "UINT_MAX", Unsigned, int);
#else
missing("UINT_MAX");
#endif
#ifdef ULONG_MAX
checktype(ULONG_MAX, "ULONG_MAX", Unsigned, long);
#else
missing("ULONG_MAX");
#endif
} /* if (L) */
if (F) {
#ifdef FLT_RADIX
checktype(FLT_RADIX, "FLT_RADIX", Signed, int);
#else
fmissing("FLT_RADIX");
#endif
#ifdef FLT_MANT_DIG
checktype(FLT_MANT_DIG, "FLT_MANT_DIG", Signed, int);
#else
fmissing("FLT_MANT_DIG");
#endif
#ifdef FLT_DIG
checktype(FLT_DIG, "FLT_DIG", Signed, int);
#else
fmissing("FLT_DIG");
#endif
#ifdef FLT_ROUNDS
checktype(FLT_ROUNDS, "FLT_ROUNDS", Signed, int);
#else
fmissing("FLT_ROUNDS");
#endif
#ifdef FLT_EPSILON
fchecktype(FLT_EPSILON, "FLT_EPSILON", float);
#else
fmissing("FLT_EPSILON");
#endif
#ifdef FLT_MIN_EXP
checktype(FLT_MIN_EXP, "FLT_MIN_EXP", Signed, int);
#else
fmissing("FLT_MIN_EXP");
#endif
#ifdef FLT_MIN
fchecktype(FLT_MIN, "FLT_MIN", float);
#else
fmissing("FLT_MIN");
#endif
#ifdef FLT_MIN_10_EXP
checktype(FLT_MIN_10_EXP, "FLT_MIN_10_EXP", Signed, int);
#else
fmissing("FLT_MIN_10_EXP");
#endif
#ifdef FLT_MAX_EXP
checktype(FLT_MAX_EXP, "FLT_MAX_EXP", Signed, int);
#else
fmissing("FLT_MAX_EXP");
#endif
#ifdef FLT_MAX
fchecktype(FLT_MAX, "FLT_MAX", float);
#else
fmissing("FLT_MAX");
#endif
#ifdef FLT_MAX_10_EXP
checktype(FLT_MAX_10_EXP, "FLT_MAX_10_EXP", Signed, int);
#else
fmissing("FLT_MAX_10_EXP");
#endif
#ifdef DBL_MANT_DIG
checktype(DBL_MANT_DIG, "DBL_MANT_DIG", Signed, int);
#else
fmissing("DBL_MANT_DIG");
#endif
#ifdef DBL_DIG
checktype(DBL_DIG, "DBL_DIG", Signed, int);
#else
fmissing("DBL_DIG");
#endif
#ifdef DBL_EPSILON
fchecktype(DBL_EPSILON, "DBL_EPSILON", double);
#else
fmissing("DBL_EPSILON");
#endif
#ifdef DBL_MIN_EXP
checktype(DBL_MIN_EXP, "DBL_MIN_EXP", Signed, int);
#else
fmissing("DBL_MIN_EXP");
#endif
#ifdef DBL_MIN
fchecktype(DBL_MIN, "DBL_MIN", double);
#else
fmissing("DBL_MIN");
#endif
#ifdef DBL_MIN_10_EXP
checktype(DBL_MIN_10_EXP, "DBL_MIN_10_EXP", Signed, int);
#else
fmissing("DBL_MIN_10_EXP");
#endif
#ifdef DBL_MAX_EXP
checktype(DBL_MAX_EXP, "DBL_MAX_EXP", Signed, int);
#else
fmissing("DBL_MAX_EXP");
#endif
#ifdef DBL_MAX
fchecktype(DBL_MAX, "DBL_MAX", double);
#else
fmissing("DBL_MAX");
#endif
#ifdef DBL_MAX_10_EXP
checktype(DBL_MAX_10_EXP, "DBL_MAX_10_EXP", Signed, int);
#else
fmissing("DBL_MAX_10_EXP");
#endif
#ifdef STDC
#ifdef LDBL_MANT_DIG
checktype(LDBL_MANT_DIG, "LDBL_MANT_DIG", Signed, int);
#else
fmissing("LDBL_MANT_DIG");
#endif
#ifdef LDBL_DIG
checktype(LDBL_DIG, "LDBL_DIG", Signed, int);
#else
fmissing("LDBL_DIG");
#endif
#ifdef LDBL_EPSILON
fchecktype(LDBL_EPSILON, "LDBL_EPSILON", long double);
#else
fmissing("LDBL_EPSILON");
#endif
#ifdef LDBL_MIN_EXP
checktype(LDBL_MIN_EXP, "LDBL_MIN_EXP", Signed, int);
#else
fmissing("LDBL_MIN_EXP");
#endif
#ifdef LDBL_MIN
fchecktype(LDBL_MIN, "LDBL_MIN", long double);
#else
fmissing("LDBL_MIN");
#endif
#ifdef LDBL_MIN_10_EXP
checktype(LDBL_MIN_10_EXP, "LDBL_MIN_10_EXP", Signed, int);
#else
fmissing("LDBL_MIN_10_EXP");
#endif
#ifdef LDBL_MAX_EXP
checktype(LDBL_MAX_EXP, "LDBL_MAX_EXP", Signed, int);
#else
fmissing("LDBL_MAX_EXP");
#endif
#ifdef LDBL_MAX
fchecktype(LDBL_MAX, "LDBL_MAX", long double);
#else
fmissing("LDBL_MAX");
#endif
#ifdef LDBL_MAX_10_EXP
checktype(LDBL_MAX_10_EXP, "LDBL_MAX_10_EXP", Signed, int);
#else
fmissing("LDBL_MAX_10_EXP");
#endif
#endif /* STDC */
} /* if (F) */
#endif /* VERIFY */
}
#ifdef VERIFY
#ifndef SCHAR_MAX
#define SCHAR_MAX char_max
#endif
#ifndef SCHAR_MIN
#define SCHAR_MIN char_min
#endif
#ifndef UCHAR_MAX
#define UCHAR_MAX char_max
#endif
#endif /* VERIFY */
#ifndef CHAR_BIT
#define CHAR_BIT char_bit
#endif
#ifndef CHAR_MAX
#define CHAR_MAX char_max
#endif
#ifndef CHAR_MIN
#define CHAR_MIN char_min
#endif
#ifndef SCHAR_MAX
#define SCHAR_MAX char_max
#endif
#ifndef SCHAR_MIN
#define SCHAR_MIN char_min
#endif
#ifndef UCHAR_MAX
#define UCHAR_MAX char_max
#endif
int cprop() {
/* Properties of type char */
Volatile char c, char_max, char_min;
Volatile int byte_size, c_signed;
long char_bit;
Unexpected(2);
/* Calculate number of bits per character *************************/
c=1; byte_size=0;
do { c=c<<1; byte_size++; } while(c!=0);
c= (char)(-1);
if (((int)c)<0) c_signed=1;
else c_signed=0;
Vprintf("%schar = %d bits, %ssigned%s\n",
co, (int)sizeof(c)*byte_size, (c_signed?"":"un"), oc);
char_bit=(long)(sizeof(c)*byte_size);
if (L) i_define(D_CHAR_BIT, "", "CHAR", "_BIT",
char_bit, 0L, (long) CHAR_BIT, "");
c=0; char_max=0;
c++;
if (setjmp(lab)==0) { /* Yields char_max */
while (c>char_max) {
char_max=c;
c=(char)(c*2+1);
}
} else {
Vprintf("%sCharacter overflow generates a trap!%s\n", co, oc);
}
c=0; char_min=0;
c--;
if (c<char_min) /* then the min char < 0 */ {
/* Minimum value: assume either two's or one's complement *********/
char_min= -char_max;
if (setjmp(lab)==0) { /* Yields char_min */
if (char_min-1 < char_min) char_min--;
}
}
Unexpected(8);
if (c_signed && char_min == 0) {
Vprintf("%sBEWARE! Chars are pseudo-unsigned:%s\n", co, oc);
Vprintf("%s %s%s%s\n",
"They contain only nonnegative values, ",
"but sign extend when used as integers.", co, oc);
}
Unexpected(3);
if (L) {
/* Because of the integer promotions, you must use a U after
the MAX_CHARS in the following cases */
if ((sizeof(char) == sizeof(int)) && !c_signed) {
u_define(D_CHAR_MAX, "", "CHAR", "_MAX",
(ulong) char_max,
(ulong) CHAR_MAX, "");
} else {
i_define(D_CHAR_MAX, "", "CHAR", "_MAX",
(long) char_max, 0L,
(long) CHAR_MAX, "");
}
i_define(D_CHAR_MIN, "", "CHAR", "_MIN",
(long) char_min, (long) maxint,
(long) CHAR_MIN, "");
if (c_signed) {
i_define(D_SCHAR_MAX, "", "SCHAR", "_MAX",
(long) char_max, 0L,
(long) SCHAR_MAX, "");
i_define(D_SCHAR_MIN, "", "SCHAR", "_MIN",
(long) char_min, (long) maxint,
(long) SCHAR_MIN, "");
} else {
if (sizeof(char) == sizeof(int)) {
u_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",
(ulong) char_max,
(ulong) UCHAR_MAX, "");
} else {
i_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",
(long) char_max, 0L,
(long) UCHAR_MAX, "");
}
}
if (c_signed) {
#ifndef NO_UC
/* Syntax error? Define NO_UC */ Volatile unsigned char c1, char_max;
c1=0; char_max=0;
c1++;
if (setjmp(lab)==0) { /* Yields char_max */
while (c1>char_max) {
char_max=c1;
c1++;
}
}
Unexpected(4);
if (sizeof(char) == sizeof(int)) {
u_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",
(ulong) char_max,
(ulong) UCHAR_MAX, "");
} else {
i_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",
(long) char_max, 0L,
(long) UCHAR_MAX, "");
}
#endif
} else {
#ifndef NO_SC
/* Syntax error? Define NO_SC */ Volatile signed char c1, char_max, char_min;
c1=0; char_max=0;
c1++;
if (setjmp(lab)==0) { /* Yields char_max */
while (c1>char_max) {
char_max=c1;
c1++;
}
}
c1=0; char_min=0;
c1--;
if (setjmp(lab)==0) { /* Yields char_min */
while (c1<char_min) {
char_min=c1;
c1--;
}
}
Unexpected(5);
i_define(D_SCHAR_MIN, "", "SCHAR", "_MIN",
(long) char_min, (long) maxint,
(long) SCHAR_MIN, "");
i_define(D_SCHAR_MAX, "", "SCHAR", "_MAX",
(long) char_max, 0L,
(long) SCHAR_MAX, "");
#endif /* NO_SC */
}
}
return byte_size;
}
int basic() {
/* The properties of the basic types.
Returns number of bits per sizeof unit */
Volatile int byte_size;
typedef int function ();
int variable;
char *cp; int *ip; function *fp;
int *p, *q;
Vprintf("%sSIZES%s\n", co, oc);
byte_size= cprop();
/* Shorts, ints and longs *****************************************/
Vprintf("%sshort=%d int=%d long=%d float=%d double=%d bits %s\n",
co,
(int) sizeof(short)*byte_size,
(int) sizeof(int)*byte_size,
(int) sizeof(long)*byte_size,
(int) sizeof(float)*byte_size,
(int) sizeof(double)*byte_size, oc);
if (stdc) {
Vprintf("%slong double=%d bits%s\n",
co, (int) sizeof(Long_double)*byte_size, oc);
}
Vprintf("%schar*=%d bits%s%s\n",
co, (int)sizeof(char *)*byte_size,
sizeof(char *)>sizeof(int)?" BEWARE! larger than int!":"",
oc);
Vprintf("%sint* =%d bits%s%s\n",
co, (int)sizeof(int *)*byte_size,
sizeof(int *)>sizeof(int)?" BEWARE! larger than int!":"",
oc);
Vprintf("%sfunc*=%d bits%s%s\n",
co, (int)sizeof(function *)*byte_size,
sizeof(function *)>sizeof(int)?" BEWARE! larger than int!":"",
oc);
showtype("Type size_t is", sizeof(0));
#ifdef STDC
showtype("Type wchar_t is", L'x');
#endif
/* Alignment constants ********************************************/
#define alignment(TYPE) \
((long)((char *)&((struct{char c; TYPE d;}*)0)->d - (char *)0))
Vprintf("\n%sALIGNMENTS%s\n", co, oc);
Vprintf("%schar=%ld short=%ld int=%ld long=%ld%s\n",
co,
alignment(char), alignment(short),
alignment(int), alignment(long),
oc);
Vprintf("%sfloat=%ld double=%ld%s\n",
co,
alignment(float), alignment(double),
oc);
if (stdc) {
Vprintf("%slong double=%ld%s\n",
co,
alignment(Long_double),
oc);
}
Vprintf("%schar*=%ld int*=%ld func*=%ld%s\n",
co,
alignment(char *), alignment(int *), alignment(function *),
oc);
Vprintf("\n");
/* Ten little endians *********************************************/
endian(byte_size);
/* Pointers *******************************************************/
Vprintf("\n%sPROPERTIES OF POINTERS%s\n", co, oc);
cp= (char *) &variable;
ip= (int *) &variable;
fp= (function *) &variable;
Vprintf("%sChar and int pointer formats ", co);
if (memeq((char *) &cp, sizeof(cp), (char *) &ip, sizeof(ip))) {
Vprintf("seem identical%s\n", oc);
} else {
Vprintf("are different%s\n", oc);
}
Vprintf("%sChar and function pointer formats ", co);
if (memeq((char *) &cp, sizeof(cp), (char *) &fp, sizeof(fp))) {
Vprintf("seem identical%s\n", oc);
} else {
Vprintf("are different%s\n", oc);
}
if (V) {
if ("abcd"=="abcd")
printf("%sStrings are shared%s\n", co, oc);
else printf("%sStrings are not shared%s\n", co, oc);
}
p=0; q=0;
showtype("Type ptrdiff_t is", p-q);
if (setjmp(mlab) == 0) {
variable= *p;
Vprintf("%sBEWARE! Dereferencing NULL doesn't cause a trap%s\n",
co, oc);
} else {
Vprintf("%sDereferencing NULL causes a trap%s\n", co, oc);
}
if (setjmp(mlab)!=0) croak(-2);
Vprintf("\n%sPROPERTIES OF INTEGRAL TYPES%s\n", co, oc);
sprop();
iprop();
lprop();
usprop();
uiprop();
ulprop();
promotions();
Unexpected(6);
return byte_size;
}
#else /* not PASS0 */
#ifdef SEP
/* The global variables used by several passes */
extern jmp_buf lab;
extern int V, L, F, bugs, bits_per_byte;
extern int maxint, flt_radix, flt_rounds;
extern Volatile int trapped;
extern char co[], oc[];
extern char *f_rep();
extern Void trap1();
#endif /* SEP */
#endif /* ifdef PASS0 */
/* As I said, I apologise for the contortions below. The functions are
expanded by the preprocessor twice or three times (for float and double,
and maybe for long double, and for short, int and long). That way,
I never make a change to one that I forget to make to the other.
You can look on it as C's fault for not supporting multi-line macros.
This whole file is read 3 times by the preprocessor, with PASSn set for
n=1, 2 or 3, to decide which parts to reprocess.
*/
/* #undef on an already undefined thing is (wrongly) flagged as an error
by some compilers, therefore the #ifdef that follows:
*/
#ifdef Number
#undef Number
#undef THING
#undef Thing
#undef thing
#undef FPROP
#undef Fname
#undef Store
#undef Sum
#undef Diff
#undef Mul
#undef Div
#undef ZERO
#undef HALF
#undef ONE
#undef TWO
#undef THREE
#undef FOUR
#undef Self
#undef F_check
#undef Verify
#undef EPROP
#undef MARK
/* These are the float.h constants */
#undef F_RADIX
#undef F_MANT_DIG
#undef F_DIG
#undef F_ROUNDS
#undef F_EPSILON
#undef F_MIN_EXP
#undef F_MIN
#undef F_MIN_10_EXP
#undef F_MAX_EXP
#undef F_MAX
#undef F_MAX_10_EXP
#endif
#ifdef Integer
#undef Integer
#undef INT
#undef IPROP
#undef Iname
#undef UPROP
#undef Uname
#undef OK_UI
#undef IMARK
#undef I_MAX
#undef I_MIN
#undef U_MAX
#endif
#ifdef PASS1
/* Define the things we're going to use this pass */
#define Number float
#define THING "FLOAT"
#define Thing "Float"
#define thing "float"
#define Fname "FLT"
#define FPROP fprop
#define Store fStore
#define Sum fSum
#define Diff fDiff
#define Mul fMul
#define Div fDiv
#define ZERO 0.0
#define HALF 0.5
#define ONE 1.0
#define TWO 2.0
#define THREE 3.0
#define FOUR 4.0
#define Self fSelf
#define F_check fCheck
#define MARK "F"
#ifdef VERIFY
#define Verify fVerify
#endif
#define EPROP efprop
#define Integer short
#define INT "short"
#define IPROP sprop
#define Iname "SHRT"
#ifndef NO_UI
#define OK_UI 1
#endif
#define IMARK ""
#define UPROP usprop
#define Uname "USHRT"
#ifdef VERIFY
#ifdef SHRT_MAX
#define I_MAX SHRT_MAX
#endif
#ifdef SHRT_MIN
#define I_MIN SHRT_MIN
#endif
#ifdef USHRT_MAX
#define U_MAX USHRT_MAX
#endif
#ifdef FLT_RADIX
#define F_RADIX FLT_RADIX
#endif
#ifdef FLT_MANT_DIG
#define F_MANT_DIG FLT_MANT_DIG
#endif
#ifdef FLT_DIG
#define F_DIG FLT_DIG
#endif
#ifdef FLT_ROUNDS
#define F_ROUNDS FLT_ROUNDS
#endif
#ifdef FLT_EPSILON
#define F_EPSILON FLT_EPSILON
#endif
#ifdef FLT_MIN_EXP
#define F_MIN_EXP FLT_MIN_EXP
#endif
#ifdef FLT_MIN
#define F_MIN FLT_MIN
#endif
#ifdef FLT_MIN_10_EXP
#define F_MIN_10_EXP FLT_MIN_10_EXP
#endif
#ifdef FLT_MAX_EXP
#define F_MAX_EXP FLT_MAX_EXP
#endif
#ifdef FLT_MAX
#define F_MAX FLT_MAX
#endif
#ifdef FLT_MAX_10_EXP
#define F_MAX_10_EXP FLT_MAX_10_EXP
#endif
#endif /* VERIFY */
#endif /* PASS1 */
#ifdef PASS2
#define Number double
#define THING "DOUBLE"
#define Thing "Double"
#define thing "double"
#define Fname "DBL"
#define FPROP dprop
#define Store dStore
#define Sum dSum
#define Diff dDiff
#define Mul dMul
#define Div dDiv
#define ZERO 0.0
#define HALF 0.5
#define ONE 1.0
#define TWO 2.0
#define THREE 3.0
#define FOUR 4.0
#define Self dSelf
#define F_check dCheck
#define MARK ""
#ifdef VERIFY
#define Verify dVerify
#endif
#define EPROP edprop
#define Integer int
#define INT "int"
#define IPROP iprop
#define Iname "INT"
#define OK_UI 1 /* Unsigned int is always possible */
#define IMARK ""
#define UPROP uiprop
#define Uname "UINT"
#ifdef VERIFY
#ifdef INT_MAX
#define I_MAX INT_MAX
#endif
#ifdef INT_MIN
#define I_MIN INT_MIN
#endif
#ifdef UINT_MAX
#define U_MAX UINT_MAX
#endif
#ifdef DBL_MANT_DIG
#define F_MANT_DIG DBL_MANT_DIG
#endif
#ifdef DBL_DIG
#define F_DIG DBL_DIG
#endif
#ifdef DBL_EPSILON
#define F_EPSILON DBL_EPSILON
#endif
#ifdef DBL_MIN_EXP
#define F_MIN_EXP DBL_MIN_EXP
#endif
#ifdef DBL_MIN
#define F_MIN DBL_MIN
#endif
#ifdef DBL_MIN_10_EXP
#define F_MIN_10_EXP DBL_MIN_10_EXP
#endif
#ifdef DBL_MAX_EXP
#define F_MAX_EXP DBL_MAX_EXP
#endif
#ifdef DBL_MAX
#define F_MAX DBL_MAX
#endif
#ifdef DBL_MAX_10_EXP
#define F_MAX_10_EXP DBL_MAX_10_EXP
#endif
#endif /* VERIFY */
#endif /* PASS2 */
#ifdef PASS3
#ifdef STDC
#define Number long double
#define ZERO 0.0L
#define HALF 0.5L
#define ONE 1.0L
#define TWO 2.0L
#define THREE 3.0L
#define FOUR 4.0L
#endif
#define THING "LONG DOUBLE"
#define Thing "Long double"
#define thing "long double"
#define Fname "LDBL"
#define FPROP ldprop
#define Store ldStore
#define Sum ldSum
#define Diff ldDiff
#define Mul ldMul
#define Div ldDiv
#define Self ldSelf
#define F_check ldCheck
#define MARK "L"
#ifdef VERIFY
#define Verify ldVerify
#endif
#define EPROP eldprop
#define Integer long
#define INT "long"
#define IPROP lprop
#define Iname "LONG"
#ifndef NO_UI
#define OK_UI 1
#endif
#define IMARK "L"
#define UPROP ulprop
#define Uname "ULONG"
#ifdef VERIFY
#ifdef LONG_MAX
#define I_MAX LONG_MAX
#endif
#ifdef LONG_MIN
#define I_MIN LONG_MIN
#endif
#ifdef ULONG_MAX
#define U_MAX ULONG_MAX
#endif
#ifdef LDBL_MANT_DIG
#define F_MANT_DIG LDBL_MANT_DIG
#endif
#ifdef LDBL_DIG
#define F_DIG LDBL_DIG
#endif
#ifdef LDBL_EPSILON
#define F_EPSILON LDBL_EPSILON
#endif
#ifdef LDBL_MIN_EXP
#define F_MIN_EXP LDBL_MIN_EXP
#endif
#ifdef LDBL_MIN
#define F_MIN LDBL_MIN
#endif
#ifdef LDBL_MIN_10_EXP
#define F_MIN_10_EXP LDBL_MIN_10_EXP
#endif
#ifdef LDBL_MAX_EXP
#define F_MAX_EXP LDBL_MAX_EXP
#endif
#ifdef LDBL_MAX
#define F_MAX LDBL_MAX
#endif
#ifdef LDBL_MAX_10_EXP
#define F_MAX_10_EXP LDBL_MAX_10_EXP
#endif
#endif /* VERIFY */
#endif /* PASS3 */
/* The rest of the file gets read all three times;
the differences are encoded in the things #defined above.
*/
#ifndef I_MAX
#define I_MAX int_max
#endif
#ifndef I_MIN
#define I_MIN int_min
#endif
#ifndef U_MAX
#define U_MAX u_max
#endif
#ifndef F_RADIX
#define F_RADIX f_radix
#endif
#ifndef F_MANT_DIG
#define F_MANT_DIG f_mant_dig
#endif
#ifndef F_DIG
#define F_DIG f_dig
#endif
#ifndef F_ROUNDS
#define F_ROUNDS f_rounds
#endif
#ifndef F_EPSILON
#define F_EPSILON f_epsilon
#endif
#ifndef F_MIN_EXP
#define F_MIN_EXP f_min_exp
#endif
#ifndef F_MIN
#define F_MIN f_min
#endif
#ifndef F_MIN_10_EXP
#define F_MIN_10_EXP f_min_10_exp
#endif
#ifndef F_MAX_EXP
#define F_MAX_EXP f_max_exp
#endif
#ifndef F_MAX
#define F_MAX f_max
#endif
#ifndef F_MAX_10_EXP
#define F_MAX_10_EXP f_max_10_exp
#endif
#ifndef VERIFY
#define Verify(prec, val, req, same, same1) {;}
#endif
#ifdef Integer
Void IPROP() {
/* the properties of short, int, and long */
Volatile Integer newi, int_max, maxeri, int_min, minneri;
Volatile int ibits, ipower, two=2;
/* Calculate max short/int/long ***********************************/
/* Calculate 2**n-1 until overflow - then use the previous value */
newi=1; int_max=0;
if (setjmp(lab)==0) { /* Yields int_max */
for(ipower=0; newi>int_max; ipower++) {
int_max=newi;
newi=newi*two+1;
}
Vprintf("%sOverflow of a%s %s does not generate a trap%s\n",
co, INT[0]=='i'?"n":"", INT, oc);
} else {
Vprintf("%sOverflow of a%s %s generates a trap%s\n",
co, INT[0]=='i'?"n":"", INT, oc);
}
Unexpected(7);
/* Minimum value: assume either two's or one's complement *********/
int_min= -int_max;
if (setjmp(lab)==0) { /* Yields int_min */
if (int_min-1 < int_min) int_min--;
}
Unexpected(8);
/* Now for those daft Cybers */
maxeri=0; newi=int_max;
if (setjmp(lab)==0) { /* Yields maxeri */
for(ibits=ipower; newi>maxeri; ibits++) {
maxeri=newi;
newi=newi+newi+1;
}
}
Unexpected(9);
minneri= -maxeri;
if (setjmp(lab)==0) { /* Yields minneri */
if (minneri-1 < minneri) minneri--;
}
Unexpected(10);
Vprintf("%sMaximum %s = %ld (= 2**%d-1)%s\n",
co, INT, (long)int_max, ipower, oc);
Vprintf("%sMinimum %s = %ld%s\n", co, INT, (long)int_min, oc);
if (L) i_define(D_INT_MAX, INT, Iname, "_MAX",
(long) int_max, 0L,
(long) I_MAX, IMARK);
if (L) i_define(D_INT_MIN, INT, Iname, "_MIN",
(long) int_min, (long) (PASS==1?maxint:int_max),
(long) I_MIN, IMARK);
if(int_max < 0) { /* It has happened (on a Cray) */
eek_a_bug("signed integral comparison faulty?");
}
if (maxeri>int_max) {
Vprintf("%sThere is a larger %s, %ld (= 2**%d-1), %s %s%s\n",
co, INT, (long)maxeri, ibits,
"but only for addition, not multiplication",
"(I smell a Cyber!)",
oc);
}
if (minneri<int_min) {
Vprintf("%sThere is a smaller %s, %ld, %s %s%s\n",
co, INT, (long)minneri,
"but only for addition, not multiplication",
"(I smell a Cyber!)",
oc);
}
}
Void UPROP () {
/* The properties of unsigned short/int/long */
#ifdef OK_UI
Volatile unsigned Integer u_max, newi, two;
newi=1; u_max=0; two=2;
if (setjmp(lab)==0) { /* Yields u_max */
while(newi>u_max) {
u_max=newi;
newi=newi*two+1;
}
}
Unexpected(11);
Vprintf("%sMaximum unsigned %s = %lu%s\n",
co, INT, (unsigned long) u_max, oc);
/* Oh woe: new standard C defines value preserving promotions:
3.2.1.1: "If an int can represent all values of the original type,
the value is converted to an int;
otherwise it is converted to an unsigned int."
*/
if (L) {
if (PASS == 1 /* we're dealing with short */
&& u_max <= maxint /* an int can represent all values */
)
{ /* the value is converted to an int */
i_define(D_UINT_MAX, INT, Uname, "_MAX",
(long) u_max, 0L,
(long) U_MAX, IMARK);
} else { /* it is converted to an unsigned int */
u_define(D_UINT_MAX, INT, Uname, "_MAX",
(unsigned long) u_max,
(unsigned long) U_MAX, IMARK);
}
}
#endif
}
#endif /* Integer */
#ifdef Number
/* The following routines are intended to defeat any attempt at optimisation
or use of extended precision, and to defeat faulty narrowing casts.
The weird prototypes are because of widening incompatibilities.
*/
#ifdef STDC
#define ARGS1(A, a) (A a)
#define ARGS2(A, a, B, b) (A a, B b)
#define ARGS5(A, a, B, b, C, c, D, d, E, e) (A a, B b, C c, D d, E e)
#else
#define ARGS1(A, a) (a) A a;
#define ARGS2(A, a, B, b) (a, b) A a; B b;
#define ARGS5(A, a, B, b, C, c, D, d, E, e) (a,b,c,d,e)A a; B b; C c; D d; E e;
#endif
Void Store ARGS2(Number, a, Number *, b) { *b=a; }
Number Sum ARGS2(Number, a, Number, b) {Number r; Store(a+b, &r); return r; }
Number Diff ARGS2(Number, a, Number, b){Number r; Store(a-b, &r); return r; }
Number Mul ARGS2(Number, a, Number, b) {Number r; Store(a*b, &r); return r; }
Number Div ARGS2(Number, a, Number, b) {Number r; Store(a/b, &r); return r; }
Number Self ARGS1(Number, a) {Number r; Store(a, &r); return r; }
Void F_check ARGS((int precision, Long_double val1));
Void F_check(precision, val1) int precision; Long_double val1; {
/* You don't think I'm going to go to all the trouble of writing
a program that works out what all sorts of values are, only to
have printf go and print the wrong values out, do you?
No, you're right, so this function tries to see if printf
has written the right value, by reading it back again.
This introduces a new problem of course: suppose printf writes
the correct value, and scanf reads it back wrong... oh well.
But I'm adamant about this: the precision given is enough
to uniquely identify the printed number, therefore I insist
that sscanf read the number back identically. Harsh yes, but
sometimes you've got to be cruel to be kind.
*/
Long_double new1, rem;
Number val, new, diff;
int e;
char *rep, *f2;
if (sizeof(double) == sizeof(Long_double)) {
/* Assume they're the same, and use non-stdc format */
/* This is for stdc compilers using non-stdc libraries */
f2= "%le"; /* Input */
} else {
/* It had better support Le then */
f2= "%Le";
}
val= (Number) val1;
rep= f_rep(precision, (Long_double) val);
if (setjmp(lab)==0) {
sscanf(rep, f2, &new1);
} else {
eek_a_bug("sscanf caused a trap");
printf("%s scanning: %s format: %s%s\n\n", co, rep, f2, oc);
Unexpected(12);
return;
}
if (setjmp(lab)==0) { /* See if new is usable */
new= new1;
if (new != 0.0) {
diff= val/new - 1.0;
if (diff < 0.1) diff= 1.0;
/* That should be enough to generate a trap */
}
} else {
eek_a_bug("sscanf returned an unusable number");
printf("%s scanning: %s with format: %s%s\n\n",
co, rep, f2, oc);
Unexpected(13);
return;
}
Unexpected(14);
if (new != val) {
eek_a_bug("Possibly bad output from printf above");
if (!exponent((Long_double)val, &rem, &e)) {
printf("%s but value was an unusable number%s\n\n",
co, oc);
return;
}
printf("%s expected value around ", co);
if (sizeof(double) == sizeof(Long_double)) {
/* Assume they're the same, and use non-stdc format */
/* This is for stdc compilers using non-stdc libraries */
printf("%.*fe%d, bit pattern:\n ", precision, rem, e);
} else {
/* It had better support Lfe then */
printf("%.*Lfe%d, bit pattern:\n ", precision, rem, e);
}
bitpattern((char *) &val, (unsigned)sizeof(val));
printf ("%s\n", oc);
printf("%s sscanf gave %s, bit pattern:\n ",
co, f_rep(precision, (Long_double) new));
bitpattern((char *) &new, (unsigned)sizeof(new));
printf ("%s\n", oc);
if (setjmp(lab) == 0) {
diff= val-new;
printf("%s difference= %s%s\n\n",
co, f_rep(precision, (Long_double) diff), oc);
} /* else forget it */
Unexpected(15);
}
}
#ifdef VERIFY
Void Verify ARGS5(int, prec, Number, val, Number, req, int, same, int, same1) {
/* Check that the compiler has read a #define value correctly */
Unexpected(16);
if (!same) {
printf("%s*** Verify failed for above #define!\n", co);
if (setjmp(lab) == 0) { /* for the case that req == nan */
printf(" Compiler has %s for value\n",
f_rep(prec, req));
} else {
printf(" Compiler has %s for value\n",
"an unusable number");
}
if (setjmp(lab) == 0) {
F_check(prec, (Long_double) req);
} /*else forget it*/
if (setjmp(lab) == 0) {
if (req > 0.0 && val > 0.0) {
printf(" difference= %s\n",
f_rep(prec, val-req));
}
} /*else forget it*/
Unexpected(17);
printf("%s\n", oc);
bugs++;
} else if (!same1) {
if (stdc) eek_a_bug("constant has the wrong precision");
else eek_a_bug("the cast didn't work");
printf("\n");
}
}
#endif /* VERIFY */
int FPROP(byte_size) int byte_size; {
/* Properties of floating types, using algorithms by Cody and Waite
from MA Malcolm, as modified by WM Gentleman and SB Marovich.
Further extended by S Pemberton.
Returns the number of digits in the fraction.
*/
Volatile int
i, f_radix, iexp, irnd, mrnd, f_rounds, f_mant_dig,
iz, k, inf, machep, f_max_exp, f_min_exp, mx, negeps,
mantbits, digs, f_dig, trap,
hidden, normal, f_min_10_exp, f_max_10_exp;
Volatile Number
a, b, base, basein, basem1, f_epsilon, epsneg,
eps, epsp1, etop, ebot,
f_max, newxmax, f_min, xminner, y, y1, z, z1, z2;
Unexpected(18);
Vprintf("%sPROPERTIES OF %s%s\n", co, THING, oc);
/* Base and size of significand **************************************/
/* First repeatedly double until adding 1 has no effect. */
/* For instance, if base is 10, with 3 significant digits */
/* it will try 1, 2, 4, 8, ... 512, 1024, and stop there, */
/* since 1024 is only representable as 1020. */
a=1.0;
if (setjmp(lab)==0) { /* inexact trap? */
do { a=Sum(a, a); }
while (Diff(Diff(Sum(a, ONE), a), ONE) == ZERO);
} else {
fprintf(stderr, "*** Program got loss-of-precision trap!\n");
/* And supporting those is just TOO much trouble! */
farewell(bugs+1);
}
Unexpected(19);
/* Now double until you find a number that can be added to the */
/* above number. For 1020 this is 8 or 16, depending whether the */
/* result is rounded or truncated. */
/* In either case the result is 1030. 1030-1020= the base, 10. */
b=1.0;
do { b=Sum(b, b); } while ((base=Diff(Sum(a, b), a)) == ZERO);
f_radix=base;
Vprintf("%sBase = %d%s\n", co, f_radix, oc);
/* Sanity check; if base<2, I can't guarantee the rest will work */
if (f_radix < 2) {
eek_a_bug("Function return or parameter passing faulty? (This is a guess.)");
printf("\n");
return(0);
}
if (PASS == 1) { /* only for FLT */
flt_radix= f_radix;
if (F) i_define(D_FLT_RADIX, "", "FLT", "_RADIX",
(long) f_radix, 0L, (long) F_RADIX, "");
} else if (f_radix != flt_radix) {
printf("\n%s*** WARNING: %s %s (%d) %s%s\n",
co, thing, "arithmetic has a different radix",
f_radix, "from float", oc);
bugs++;
}
/* Now the number of digits precision */
f_mant_dig=0; b=1.0;
do { f_mant_dig++; b=Mul(b, base); }
while (Diff(Diff(Sum(b, ONE), b), ONE) == ZERO);
f_dig=floor_log(10, (Long_double)(b/base)) + (base==10?1:0);
Vprintf("%sSignificant base digits = %d %s %d %s%s\n",
co, f_mant_dig, "(= at least", f_dig, "decimal digits)", oc);
if (F) i_define(D_MANT_DIG, thing, Fname, "_MANT_DIG",
(long) f_mant_dig, 0L, (long) F_MANT_DIG, "");
if (F) i_define(D_DIG, thing, Fname, "_DIG",
(long) f_dig, 0L, (long) F_DIG, "");
digs= ceil_log(10, (Long_double)b); /* the number of digits to printf */
/* Rounding *******************************************************/
basem1=Diff(base, HALF);
if (Diff(Sum(a, basem1), a) != ZERO) {
if (f_radix == 2) basem1=0.375;
else basem1=1.0;
if (Diff(Sum(a, basem1), a) != ZERO) irnd=2; /* away from 0 */
else irnd=1; /* to nearest */
} else irnd=0; /* towards 0 */
basem1=Diff(base, HALF);
if (Diff(Diff(-a, basem1), -a) != ZERO) {
if (f_radix == 2) basem1=0.375;
else basem1=1.0;
if (Diff(Diff(-a, basem1), -a) != ZERO) mrnd=2; /* away from 0*/
else mrnd=1; /* to nearest */
} else mrnd=0; /* towards 0 */
f_rounds= -1; /* Unknown rounding */
if (irnd==0 && mrnd==0) f_rounds=0; /* zero = chops */
if (irnd==1 && mrnd==1) f_rounds=1; /* nearest */
if (irnd==2 && mrnd==0) f_rounds=2; /* +inf */
if (irnd==0 && mrnd==2) f_rounds=3; /* -inf */
if (f_rounds != -1) {
Vprintf("%sArithmetic rounds towards ", co);
switch (f_rounds) {
case 0: Vprintf("zero (i.e. it chops)"); break;
case 1: Vprintf("nearest"); break;
case 2: Vprintf("+infinity"); break;
case 3: Vprintf("-infinity"); break;
default: Vprintf("???"); break;
}
Vprintf("%s\n", oc);
} else { /* Hmm, try to give some help here */
Vprintf("%sArithmetic rounds oddly: %s\n", co, oc);
Vprintf("%s Negative numbers %s%s\n",
co, mrnd==0 ? "towards zero" :
mrnd==1 ? "to nearest" :
"away from zero",
oc);
Vprintf("%s Positive numbers %s%s\n",
co, irnd==0 ? "towards zero" :
irnd==1 ? "to nearest" :
"away from zero",
oc);
}
/* An extra goody */
if (f_radix == 2 && f_rounds == 1) {
if (Diff(Sum(a, ONE), a) != ZERO) {
Vprintf("%s Tie breaking rounds up%s\n", co, oc);
} else if (Diff(Sum(a, THREE), a) == FOUR) {
Vprintf("%s Tie breaking rounds to even%s\n", co, oc);
} else {
Vprintf("%s Tie breaking rounds down%s\n", co, oc);
}
}
if (PASS == 1) { /* only for FLT */
flt_rounds= f_rounds;
if (F)
i_define(D_FLT_ROUNDS, "", "FLT", "_ROUNDS",
(long) f_rounds, 1L, (long) F_ROUNDS, "");
} else if (f_rounds != flt_rounds) {
printf("\n%s*** WARNING: %s %s (%d) %s%s\n\n",
co, thing, "arithmetic rounds differently",
f_rounds, "from float", oc);
bugs++;
}
/* Various flavours of epsilon ************************************/
negeps=f_mant_dig+f_mant_dig;
basein=1.0/base;
a=1.0;
for(i=1; i<=negeps; i++) a*=basein;
b=a;
while (Diff(Diff(ONE, a), ONE) == ZERO) {
a*=base;
negeps--;
}
negeps= -negeps;
Vprintf("%sSmallest x such that 1.0-base**x != 1.0 = %d%s\n",
co, negeps, oc);
etop = ONE;
ebot = ZERO;
eps = Sum(ebot, Div(Diff(etop, ebot), TWO));
/* find the smallest epsneg (1-epsneg != 1) by binary search.
ebot and etop are the current bounds */
while (eps != ebot && eps != etop) {
epsp1 = Diff(ONE, eps);
if (epsp1 < ONE) etop = eps;
else ebot = eps;
eps = Sum(ebot, Div(Diff(etop, ebot), TWO));
}
eps= etop;
/* Sanity check */
if (Diff(ONE, etop) >= ONE || Diff(ONE, ebot) != ONE) {
eek_a_bug("internal error calculating epsneg");
}
Vprintf("%sSmallest x such that 1.0-x != 1.0 = %s%s\n",
co, f_rep(digs, (Long_double) eps), oc);
if (V) F_check(digs, (Long_double) eps);
epsneg=a;
if ((f_radix!=2) && irnd) {
/* a=(a*(1.0+a))/(1.0+1.0); => */
a=Div(Mul(a, Sum(ONE, a)), Sum(ONE, ONE));
/* if ((1.0-a)-1.0 != 0.0) epsneg=a; => */
if (Diff(Diff(ONE, a), ONE) != ZERO) epsneg=a;
}
/* epsneg is used later */
Unexpected(20);
machep= -f_mant_dig-f_mant_dig;
a=b;
while (Diff(Sum(ONE, a), ONE) == ZERO) { a*=base; machep++; }
Vprintf("%sSmallest x such that 1.0+base**x != 1.0 = %d%s\n",
co, machep, oc);
etop = ONE;
ebot = ZERO;
eps = Sum(ebot, Div(Diff(etop, ebot), TWO));
/* find the smallest eps (1+eps != 1) by binary search.
ebot and etop are the current bounds */
while (eps != ebot && eps != etop) {
epsp1 = Sum(ONE, eps);
if (epsp1 > ONE) etop = eps;
else ebot = eps;
eps = Sum(ebot, Div(Diff(etop, ebot), TWO));
}
/* Sanity check */
if (Sum(ONE, etop) <= ONE || Sum(ONE, ebot) != ONE) {
eek_a_bug("internal error calculating eps");
}
f_epsilon=etop;
Vprintf("%sSmallest x such that 1.0+x != 1.0 = %s%s\n",
co, f_rep(digs, (Long_double) f_epsilon), oc);
f_epsilon= Diff(Sum(ONE, f_epsilon), ONE); /* New C standard defn */
Vprintf("%s(Above number + 1.0) - 1.0 = %s%s\n",
co, f_rep(digs, (Long_double) (f_epsilon)), oc);
/* Possible loss of precision warnings here from non-stdc compilers */
if (F) f_define(D_EPSILON, thing,
Fname, "_EPSILON", digs, (Long_double) f_epsilon, MARK);
if (V || F) F_check(digs, (Long_double) f_epsilon);
Unexpected(21);
if (F) Verify(digs, f_epsilon, F_EPSILON,
f_epsilon == Self(F_EPSILON),
(Long_double) f_epsilon == (Long_double) F_EPSILON);
Unexpected(22);
/* Extra chop info *************************************************/
if (f_rounds == 0) {
if (Diff(Mul(Sum(ONE,f_epsilon),ONE),ONE) != ZERO) {
Vprintf("%sAlthough arithmetic chops, it uses guard digits%s\n", co, oc);
}
}
/* Size of and minimum normalised exponent ************************/
y=0; i=0; k=1; z=basein; z1=(1.0+f_epsilon)/base;
/* Coarse search for the largest power of two */
if (setjmp(lab)==0) { /* for underflow trap */ /* Yields i, k, y, y1 */
do {
y=z; y1=z1;
z=Mul(y,y); z1=Mul(z1, y);
a=Mul(z,ONE);
z2=Div(z1,y);
if (z2 != y1) break;
if ((Sum(a,a) == ZERO) || (fabs(z) >= y)) break;
i++;
k+=k;
} while(1);
} else {
Vprintf("%s%s underflow generates a trap%s\n", co, Thing, oc);
}
Unexpected(23);
if (f_radix != 10) {
iexp=i+1; /* for the sign */
mx=k+k;
} else {
iexp=2;
iz=f_radix;
while (k >= iz) { iz*=f_radix; iexp++; }
mx=iz+iz-1;
}
/* Fine tune starting with y and y1 */
if (setjmp(lab)==0) { /* for underflow trap */ /* Yields k, f_min */
do {
f_min=y; z1=y1;
y=Div(y,base); y1=Div(y1,base);
a=Mul(y,ONE);
z2=Mul(y1,base);
if (z2 != z1) break;
if ((Sum(a,a) == ZERO) || (fabs(y) >= f_min)) break;
k++;
} while (1);
}
Unexpected(24);
f_min_exp=(-k)+1;
if ((mx <= k+k-3) && (f_radix != 10)) { mx+=mx; iexp+=1; }
Vprintf("%sNumber of bits used for exponent = %d%s\n", co, iexp, oc);
Vprintf("%sMinimum normalised exponent = %d%s\n", co, f_min_exp-1, oc);
if (F)
i_define(D_MIN_EXP, thing, Fname, "_MIN_EXP",
(long) f_min_exp, (long) maxint, (long) F_MIN_EXP, "");
if (setjmp(lab)==0) {
Vprintf("%sMinimum normalised positive number = %s%s\n",
co, f_rep(digs, (Long_double) f_min), oc);
} else {
eek_a_bug("printf can't print the smallest normalised number");
printf("\n");
}
Unexpected(25);
/* Possible loss of precision warnings here from non-stdc compilers */
if (setjmp(lab) == 0) {
if (F) f_define(D_MIN, thing,
Fname, "_MIN", digs, (Long_double) f_min, MARK);
if (V || F) F_check(digs, (Long_double) f_min);
} else {
eek_a_bug("xxx_MIN caused a trap");
printf("\n");
}
if (setjmp(lab) == 0) {
if (F) Verify(digs, f_min, F_MIN,
f_min == Self(F_MIN),
(Long_double) f_min == (Long_double) F_MIN);
} else {
printf("%s*** Verify failed for above #define!\n %s %s\n\n",
co, "Compiler has an unusable number for value", oc);
bugs++;
}
Unexpected(26);
a=1.0; f_min_10_exp=0;
while (a > f_min*10.0) { a/=10.0; f_min_10_exp--; }
if (F) i_define(D_MIN_10_EXP, thing, Fname, "_MIN_10_EXP",
(long) f_min_10_exp, (long) maxint,
(long) F_MIN_10_EXP, "");
/* Minimum exponent ************************************************/
if (setjmp(lab)==0) { /* for underflow trap */ /* Yields xminner */
do {
xminner=y;
y=Div(y,base);
a=Mul(y,ONE);
if ((Sum(a,a) == ZERO) || (fabs(y) >= xminner)) break;
} while (1);
}
Unexpected(27);
if (xminner != 0.0 && xminner != f_min) {
normal= 0;
Vprintf("%sThe smallest numbers are not kept normalised%s\n",
co, oc);
if (setjmp(lab)==0) {
Vprintf("%sSmallest unnormalised positive number = %s%s\n",
co, f_rep(digs, (Long_double) xminner), oc);
if (V) F_check(digs, (Long_double) xminner);
} else {
eek_a_bug("printf can't print the smallest unnormalised number.");
printf("\n");
}
Unexpected(28);
} else {
normal= 1;
Vprintf("%sThe smallest numbers are normalised%s\n", co, oc);
}
/* Maximum exponent ************************************************/
f_max_exp=2; f_max=1.0; newxmax=base+1.0;
inf=0; trap=0;
while (f_max<newxmax) {
f_max=newxmax;
if (setjmp(lab) == 0) { /* Yields inf, f_max_exp */
newxmax=Mul(newxmax, base);
} else {
trap=1;
break;
}
if (Div(newxmax, base) != f_max) {
if (newxmax > f_max) inf=1; /* ieee infinity */
break;
}
f_max_exp++;
}
Unexpected(29);
Vprintf("%sMaximum exponent = %d%s\n", co, f_max_exp, oc);
if (F) i_define(D_MAX_EXP, thing, Fname, "_MAX_EXP",
(long) f_max_exp, 0L, (long) F_MAX_EXP, "");
/* Largest number ***************************************************/
f_max=Diff(ONE, epsneg);
if (Mul(f_max,ONE) != f_max) f_max=Diff(ONE, Mul(base,epsneg));
for (i=1; i<=f_max_exp; i++) f_max=Mul(f_max, base);
if (setjmp(lab)==0) {
Vprintf("%sMaximum number = %s%s\n",
co, f_rep(digs, (Long_double) f_max), oc);
} else {
eek_a_bug("printf can't print the largest double.");
printf("\n");
}
if (setjmp(lab)==0) {
/* Possible loss of precision warnings here from non-stdc compilers */
if (F) f_define(D_MAX, thing,
Fname, "_MAX", digs, (Long_double) f_max, MARK);
if (V || F) F_check(digs, (Long_double) f_max);
} else {
eek_a_bug("xxx_MAX caused a trap");
printf("\n");
}
if (setjmp(lab)==0) {
if (F) Verify(digs, f_max, F_MAX,
f_max == Self(F_MAX),
(Long_double) f_max == (Long_double) F_MAX);
} else {
printf("%s*** Verify failed for above #define!\n %s %s\n\n",
co, "Compiler has an unusable number for value", oc);
bugs++;
}
Unexpected(30);
a=1.0; f_max_10_exp=0;
while (a < f_max/10.0) { a*=10.0; f_max_10_exp++; }
if (F) i_define(D_MAX_10_EXP, thing, Fname, "_MAX_10_EXP",
(long) f_max_10_exp, 0L, (long) F_MAX_10_EXP, "");
/* Traps and infinities ********************************************/
if (trap) {
Vprintf("%sOverflow generates a trap%s\n", co, oc);
} else {
Vprintf("%sOverflow doesn't seem to generate a trap%s\n",
co, oc);
}
if (inf) { Vprintf("%sThere is an 'infinite' value%s\n", co, oc); }
#ifdef SIGFPE
signal(SIGFPE, trap1);
#endif
if (setjmp(lab) == 0) {
trapped= 0; /* A global variable */
b= 0.0;
a= (1.0/b)/b;
if (!trapped) {
Vprintf("%sDivide by zero doesn't generate a trap%s\n",
co, oc);
} else {
Vprintf("%sDivide by zero generates a trap%s\n",
co, oc);
Vprintf("%sFP signal handlers return safely%s\n",
co, oc);
}
} else {
Vprintf("%sDivide by zero generates a trap%s\n", co, oc);
Vprintf("%sBEWARE! FP signal handlers can NOT return%s\n",
co, oc);
}
setsignals();
Unexpected(31);
/* Hidden bit + sanity check ****************************************/
if (f_radix != 10) {
hidden=0;
mantbits=floor_log(2, (Long_double)f_radix)*f_mant_dig;
if (mantbits+iexp == (int)sizeof(Number)*byte_size) {
hidden=1;
Vprintf("%sArithmetic uses a hidden bit%s\n", co, oc);
} else if (mantbits+iexp+1 == (int)sizeof(Number)*byte_size) {
Vprintf("%sArithmetic doesn't use a hidden bit%s\n",
co, oc);
} else if (mantbits+iexp+1 < (int)sizeof(Number)*byte_size) {
Vprintf("%sOnly %d of the %d bits of a %s %s%s\n",
co,
mantbits+iexp,
(int)sizeof(Number)*byte_size,
thing,
"are actually used",
oc);
} else {
printf("\n%s%s\n %s (%d) %s (%d) %s %s (%d)!%s\n\n",
co,
"*** Something fishy here!",
"Exponent size",
iexp,
"+ significand size",
mantbits,
"doesn't match with the size of a",
thing,
(int)sizeof(Number)*byte_size,
oc);
}
if (hidden && f_radix == 2 && f_max_exp+f_min_exp==3) {
Vprintf("%sIt looks like %s length IEEE format%s\n",
co, f_mant_dig==24 ? "single" :
f_mant_dig==53 ? "double" :
f_mant_dig >53 ? "extended" :
"some", oc);
if (f_rounds != 1 || normal) {
Vprintf("%s though ", co);
if (f_rounds != 1) {
Vprintf("the rounding is unusual");
if (normal) { Vprintf(" and "); }
}
if (normal) {
Vprintf("the normalisation is unusual");
}
Vprintf("%s\n", oc);
}
} else {
Vprintf("%sIt doesn't look like IEEE format%s\n",
co, oc);
}
}
printf("\n"); /* regardless of verbosity */
return f_mant_dig;
}
Void EPROP(fprec, dprec, lprec) int fprec, dprec, lprec; {
/* See if expressions are evaluated in extended precision.
Some compilers optimise even if you don't want it,
and then this function fails to produce the right result.
We try to diagnose this if it happens.
*/
Volatile int eprec;
Volatile double a, b, base, old;
Volatile Number d, oldd, dbase, one, zero;
Volatile int bad=0;
/* Size of significand **************************************/
a=1.0;
if (setjmp(lab) == 0) { /* Yields nothing */
do { old=a; a=a+a; }
while ((((a+1.0)-a)-1.0) == 0.0 && a>old);
} else bad=1;
if (!bad && a <= old) bad=1;
if (!bad) {
b=1.0;
if (setjmp(lab) == 0) { /* Yields nothing */
do { old=b; b=b+b; }
while ((base=((a+b)-a)) == 0.0 && b>old);
if (b <= old) bad=1;
} else bad=1;
}
if (!bad) {
eprec=0; d=1.0; dbase=base; one=1.0; zero=0.0;
if (setjmp(lab) == 0) { /* Yields nothing */
do { eprec++; oldd=d; d=d*dbase; }
while ((((d+one)-d)-one) == zero && d>oldd);
if (d <= oldd) bad=1;
} else bad=1;
}
Unexpected(32);
if (bad) {
Vprintf("%sCan't determine precision for %s expressions:\n%s%s\n",
co, thing, " check that you compiled without optimisation!",
oc);
} else if (eprec==dprec) {
Vprintf("%s%s expressions are evaluated in double precision%s\n",
co, Thing, oc);
} else if (eprec==fprec) {
Vprintf("%s%s expressions are evaluated in float precision%s\n",
co, Thing, oc);
} else if (eprec==lprec) {
Vprintf("%s%s expressions are evaluated in long double precision%s\n",
co, Thing, oc);
} else {
Vprintf("%s%s expressions are evaluated in a %s %s %d %s%s\n",
co, Thing, eprec>dprec ? "higher" : "lower",
"precision than double,\n using",
eprec, "base digits",
oc);
}
}
#else /* not Number */
#ifdef FPROP /* Then create dummy routines for long double */
/* ARGSUSED */
int FPROP(byte_size) int byte_size; { return 0; }
#endif
#ifdef EPROP
/* ARGSUSED */
Void EPROP(fprec, dprec, lprec) int fprec, dprec, lprec; {}
#endif
#endif /* ifdef Number */
/* Increment the pass number */
#undef PASS
#ifdef PASS2
#undef PASS2
#define PASS 3
#define PASS3 1
#endif
#ifdef PASS1
#undef PASS1
#define PASS 2
#define PASS2 1
#endif
#ifdef PASS0
#undef PASS0
#endif
#ifndef SEP
#ifdef PASS /* then rescan this file */
#ifdef BAD_CPP
#include "enquire.c"
#else
#include FILENAME /* if this line fails to compile, define BAD_CPP */
#endif
#endif /* PASS */
#endif /* SEP */
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment