4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Every thing you wanted to know about your compiler but didn't know whom to ask.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync COPYRIGHT(c) 1993-9 Steven Pemberton, CWI. All rights reserved.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Steven Pemberton, CWI, Amsterdam; "Steven.Pemberton@cwi.nl"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Used with permission.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync This program and the accompanying materials
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync are licensed and made available under the terms and conditions of the BSD License
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync which accompanies this distribution. The full text of the license may be found at
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#if defined(_MSC_VER) /* Handle Microsoft VC++ compiler specifics. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* defined(_MSC_VER) */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#define NO_SC 1 // Compiler doesn't support signed char
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#define NO_UC 1 // Compiler doesn't support unsigned char
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#define NO_UI 1 // Compiler doesn't support unsigned short and long
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#define NO_VOID 1 // Compiler doesn't support void
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#define NO_SIG 1 // Compiler doesn't support signal() or setjmp/longjmp()
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Some compilers can't cope with "#ifdef __FILE__". Use
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync either the FILENAME or BAD_CPP macro as described below.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* If your C preprocessor doesn't have the predefined __FILE__
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncmacro, and you don't want to call this file enquire.c but, say,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsynctell.c, uncomment the following and change enquire.c to tell.c.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#define FILENAME "enquire.c"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Some compilers won't accept the line "#include FILENAME". Uncomment
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the following macro. In that case, this file *must* be called enquire.c.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#define BAD_CPP 1
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Some naughty compilers define __STDC__, but don't really
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync support it. Some define it as 0, in which case we ignore it.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync But if your compiler defines it, and isn't really ANSI C,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync uncomment the BAD_STDC macro. (To those compiler writers: for shame).
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#define BAD_STDC 1
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Some naughty compilers define __STDC__, but don't have the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync stddef.h include file. Uncomment the BAD_STDDEF macro. (Gcc needs this on
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync some machines, due to clashes between stddef.h and other include files.)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#define BAD_STDDEF 1
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Some systems crash when you try to malloc all store. To save users of such
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync defective systems too much grief, they may uncomment the BAD_MALLOC macro,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync which ignores that bit of the code.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#define BAD_MALLOC 1
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define PURPOSE Everything you wanted to know about your machine and C compiler
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define AUTHOR Steven Pemberton, CWI, Amsterdam; "Steven.Pemberton@cwi.nl"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define COPYRIGHT(c) 1993-9 Steven Pemberton, CWI. All rights reserved.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define NOTE Improvements gratefully received. Please mention the version.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define COMPILE On Unix compile with: "sh enquire.c"; see below for details
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define WEB "http://www.cwi.nl/~steven/enquire.html"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef NOTDEFINED /* This is how you compile it; see below for details */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync sh) echo 'Use "sh enquire.c", not "sh < enquire.c"' >&2; exit 1;;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync then echo Would overwrite test.c - try it somewhere safer >&2; exit 1
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync echo '*** "'$CC ${1+"$@"} -o enquire test.c $LIBS'" failed'
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync echo "main(){unsigned short s;unsigned long l;s=0;l=0;}" > test.c
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync echo " Unsigned short or long not accepted; using $CFLAGS"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 0) : check bug in interpreting "$@" in some shells, if no parameters
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "1 2") echo ' *** There is a bug in your shell expanding "$@"!'
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *) echo " $CC" $CFLAGS "$@" -DID="\"$ID\"" $0 -o enquire $LIBS
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync $CC $CFLAGS ${1+"$@"} -DID="\"$ID\"" $0 -o enquire $LIBS ||
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync echo "Producing enquire.out limits.h and float.h ..."
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ./enquire > enquire.out || echo ' *** Some problems: see enquire.out'
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ./enquire -l > limits.h || echo ' *** Some problems: see limits.h'
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ./enquire -f > float.h || echo ' *** Some problems: see float.h'
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync echo "Verifying the contents of limits.h and float.h ..."
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync echo " $CC" -DVERIFY $CFLAGS "$@" $0 -o verify $LIBS
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync $CC -DVERIFY $CFLAGS ${@+"$@"} $0 -o verify $LIBS ||
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync This is a program that determines many properties of the C
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync compiler and machine that it is run on, such as minimum and
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync maximum [un]signed char/int/long, many properties of float/ [long]
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync double, and so on.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync As an option it produces the ANSI C float.h and limits.h files.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync As a further option, it even checks that the compiler reads the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync header files correctly.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync It is a good test-case for compilers, since it exercises them with
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync many limiting values, such as the minimum and maximum floating-point
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync COMPILING AND RUNNING ON UNIX MACHINES
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync With luck and a following wind, on Unix systems just the following
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync sh enquire.c (or whatever filename you chose).
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Any parameters are passed to the C compiler, so if the compilation
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync fails for any reason curable as explained below, you can do the following:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync If you do get compilation errors, check the line in question.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Very often there is a comment attached saying which define to set.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync You can use a different C compiler than the default cc by setting CC:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync CC=gcc sh enquire.c -ansi
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync You can load extra libraries by setting LIBS:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync CC=gcc LIBS=-lflong sh enquire.c -ansi
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Add ID="string" for the string to be added to the output; for instance:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ID="`hostname` cc -ansi" sh enquire.c -ansi
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Compiling may give messages about unreachable code. These you can ignore.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Some compilers offer various flags for different floating point
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync modes; it's worth trying all possible combinations of these.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Don't say I haven't tried to make life easy for you...
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync COMPILING AND RUNNING ON NON-UNIX SYSTEMS
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync On non-Unix systems, you must say (the equivalent of):
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync cc enquire.c -o enquire
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync enquire > enquire.out
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync enquire -l > limits.h
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync enquire -f > float.h
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync cc -DVERIFY enquire.c -o verify #this includes limits.h and float.h
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync verify -fl > verify.out
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync If your compiler doesn't support: add flag:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync signed char (eg pcc) -DNO_SC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync unsigned char -DNO_UC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync unsigned short and long -DNO_UI
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync void -DNO_VOID
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync signal(), or setjmp/longjmp() -DNO_SIG
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Try to compile first with no flags, and see if you get any errors
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync - you might be surprised. (Most non-ANSI compilers need -DNO_SC,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync though.) Some compilers need a -f flag for floating point.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Don't use any optimisation flags: the program may not work if you
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync do. Though "while (a+1.0-a-1.0 == 0.0)" may look like "while(1)"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync to an optimiser, to a floating-point unit there's a world of difference.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Compiling may give messages about unreachable code. These you can ignore.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Some compilers offer various flags for different floating point
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync modes; it's worth trying all possible combinations of these.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync FAULTY COMPILERS
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Because of bugs and/or inadequacies, some compilers need the following
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync - If your C preprocessor doesn't have the predefined __FILE__
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync macro, and you don't want to call this file enquire.c but, say,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync tell.c, add the flag -DFILENAME=\"tell.c\" .
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync - Some compilers won't accept the line "#include FILENAME". Add
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync flag -DBAD_CPP. In that case, this file *must* be called
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync - Some compilers can't cope with "#ifdef __FILE__". Use
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync -DFILENAME= or -DBAD_CPP as above.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync - Some naughty compilers define __STDC__, but don't really
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync support it. Some define it as 0, in which case we ignore it.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync But if your compiler defines it, and isn't really ANSI C, add
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync flag -DBAD_STDC. (To those compiler writers: for shame).
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync - Some naughty compilers define __STDC__, but don't have the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync stddef.h include file. Add flag -DBAD_STDDEF. (Gcc needs this
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync on some machines, due to clashes between stddef.h and other
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync include files.)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync - Some systems crash when you try to malloc all store. To save
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync users of such defective systems too much grief, they may
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync compile with -DBAD_MALLOC, which ignores that bit of the code.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Summary of naughty-compiler flags:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync If your compiler doesn't support: add flag:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync __FILE__ (and you changed the filename) -DFILENAME=\"name.c\"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync #ifdef __FILE__ -DBAD_CPP or -DFILENAME=...
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync #include FILENAME -DBAD_CPP
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync __STDC__ (properly) -DBAD_STDC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync stddef.h -DBAD_STDDEF
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync malloc(LOTS) == NULL -DBAD_MALLOC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync While it is not our policy to support defective compilers, pity has been
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync taken on people with compilers that can't produce object files bigger than
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 32k (especially since it was an easy addition). Compile the program
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync into separate parts like this:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync cc -c -DSEP -DPASS0 -o p0.o <other flags> enquire.c
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync cc -c -DSEP -DPASS1 -o p1.o <other flags> enquire.c
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync cc -c -DSEP -DPASS2 -o p2.o <other flags> enquire.c
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync cc -c -DSEP -DPASS3 -o p3.o <other flags> enquire.c
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync cc -o enquire p0.o p1.o p2.o p3.o
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync SYSTEM DEPENDENCIES
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync You may possibly need to add some calls to signal() for other sorts of
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync exception on your machine than SIGFPE, SIGOVER, SIGBUS, and SIGSEGV.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync See lines beginning #ifdef SIGxxx (and communicate the differences to me!).
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Running without argument gives the information as English text. If run
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync with argument -l (e.g. enquire -l), output is a series of #define's for
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the ANSI standard limits.h include file, excluding MB_MAX_CHAR. If run
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync with argument -f, output is a series of #define's for the ANSI standard
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync float.h include file (according to ANSI C Draft of Dec 7, 1988).
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Flag -v gives verbose output: output includes the English text above
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync as C comments. The program exit(0)'s if everything went ok, otherwise
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync it exits with a positive number, telling how many problems there were.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync VERIFYING THE COMPILER
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync If, having produced the float.h and limits.h header files, you want to
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync verify that the compiler reads them back correctly (there are a lot of
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync boundary cases, of course, like minimum and maximum numbers), you can
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync recompile enquire.c with -DVERIFY set (plus the other flags that you used
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync when compiling the version that produced the header files). This then
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync recompiles the program so that it #includes "limits.h" and "float.h",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync and checks that the constants it finds there are the same as the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync constants it produces. Run the resulting program with enquire -fl.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Many compilers fail this test.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NB: You *must* recompile with the same compiler and flags, otherwise
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync you may get odd results.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync You can also use this option if your compiler already has both files,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync and you want to confirm that this program produces the right results.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync TROUBLESHOOTING.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync This program is now quite trustworthy, and suspicious and wrong output
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync may well be caused by bugs in the compiler, not in the program (however
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync of course, this is not guaranteed, and no responsibility can be
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync accepted, etc.)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync The program only works if overflows are ignored by the C system or
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync are catchable with signal().
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync If the program fails to run to completion (often with the error message
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "Unexpected signal at point x"), this often turns out to be a bug in the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync C compiler's run-time system. Check what was about to be printed, and
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync try to narrow the problem down.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Another possible problem is that you have compiled the program to produce
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync loss-of-precision arithmetic traps. The program cannot cope with these,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync and you should re-compile without them. (They should never be the default).
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Make sure you compiled with optimisation turned off.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Output preceded by *** WARNING: identifies behaviour of the C system
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync deemed incorrect by the program. Likely problems are that printf or
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync scanf don't cope properly with certain boundary numbers: this program
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync goes to a lot of trouble to calculate its values, and these values
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync are mostly boundary numbers. Experience has shown that often printf
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync cannot cope with these values, and so in an attempt to increase
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync confidence in the output, for each float and double that is printed,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the printed value is checked by using sscanf to read it back.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Care is taken that numbers are printed with enough digits to uniquely
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync identify them, and therefore that they can be read back identically.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync If the number read back is different, then there is probably a bug in
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf or sscanf, and the program prints the warning message.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync If the two numbers in the warning look identical, then printf is more
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync than likely rounding the last digit(s) incorrectly. To put you at ease
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync that the two really are different, the bit patterns of the two numbers
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync are also printed. The difference is very likely in the last bit.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Many scanf's read the minimum double back as 0.0, and similarly cause
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync overflow when reading the maximum double. This program quite ruthlessly
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync declares all these behaviours faulty. The point is that if you get
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync one of these warnings, the output may be wrong, so you should check
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the result carefully if you intend to use the results. Of course, printf
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync and sscanf may both be wrong, and cancel each other out, so you should
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync check the output carefully anyway.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync The warning that "a cast didn't work" refers to cases like this:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync #define C 1.234567890123456789
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (f != (float) C) printf ("Wrong!");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync A faulty compiler will widen f to double and ignore the cast to float,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync and because there is more accuracy in a double than a float, fail to
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync recognise that they are the same. In the actual case in point, f and C
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync are passed as parameters to a function that discovers they are not equal,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync so it's just possible that the error was in the parameter passing,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync not in the cast (see function Verify()).
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync For ANSI C, which has float constants, the error message is "constant has
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync wrong precision".
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync REPORTING PROBLEMS
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync If the program doesn't work for you for any reason that can't be
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync narrowed down to a problem in the C compiler, or it has to be
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync changed in order to get it to compile, or it produces suspicious
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync output (like a very low maximum float, for instance), please mail
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the problem and an example of the incorrect output to
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Steven.Pemberton@cwi.nl so that improvements can be worked into
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync future versions. Try to give as much information as possible;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync DON'T FORGET TO MENTION THE VERSION NUMBER!
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync The program tries to catch and diagnose bugs in the compiler/run-time
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync system. I would be especially pleased to have reports of failures so
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync that I can improve this service.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync I apologise unreservedly for the contorted use of the preprocessor...
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync but it was fun!
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NEW VERSIONS
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Worried that you may not have the latest version? Ftp to
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ftp.cwi.nl, and look in directory pub/steven/enquire
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync for file enquireXX.c; XX is the version number. Or look at
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync HOW DOES ENQUIRE WORK?
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync There is an article that explains a lot of the workings: The
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Ergonomics of Portability; available from the above addresses as file
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync enquire.ps.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync THE SMALL PRINT
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync This is not a public domain program; nor is any other program that
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync carries a copyright notice. It is however freely copyable under the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync following conditions:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync You may copy and distribute verbatim copies of this source file.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync You may modify this source file, and copy and distribute such
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync modified versions, provided that you leave the copyright notice
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync at the top of the file and also cause the modified file to carry
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync prominent notices stating that you changed the files and the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync date of any change; and cause the whole of any work that you
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync distribute or publish, that in whole or in part contains or is a
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync derivative of this program or any part thereof, to be licensed
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync at no charge to all third parties on terms identical to those
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync While every effort has been taken to make this program as reliable as
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync possible, no responsibility can be taken for the correctness of the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync output, nor suitability for any particular use.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync If you do have a fix to any problem, please send it to me, so that
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync other people can have the benefits.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync This program is an offshoot of a project funded by public funds.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync If you use this program for research or commercial use (i.e. more
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync than just for the fun of knowing about your compiler) mailing a short
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync note of acknowledgement may help keep enquire.c supported.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ACKNOWLEDGEMENTS
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Many people have given time and ideas to making this program what it is.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync To all of them thanks, and apologies for not mentioning them by name.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Originally started as a program to generate configuration constants
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync for a large piece of software we were writing, which later took on
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync a life of its own...
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 1.0 Length 6658!; end 1984?
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Unix only. Only printed a dozen maximum int/double values.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 2.0 Length 10535; Spring 1985
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Prints values as #defines (about 20 of them)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync More extensive floating point, using Cody and Waite
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Handles signals better
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Programs around optimisations
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Handles Cybers
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 3.0 Length 12648; Aug 1987; prints about 42 values
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added PASS stuff, so treats float as well as double
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 4.0 Length 33891; Feb 1989; prints around 85 values
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync First GNU version (for gcc, where they called it hard-params.c)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Generates float.h and limits.h files
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Handles long double
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Generates warnings for dubious output
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 4.1 Length 47738; April 1989
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added VERIFY and TEST
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 4.2 Length 63442; Feb 1990
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added check for pseudo-unsigned chars
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added description for each #define output
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added check for absence of defines during verify
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added prototypes
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added BAD_STDC and BAD_CPP
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fixed alignments output
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 4.3 Length 75000; Oct 1990; around 114 lines of output
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Function xmalloc defined, Richard Stallman, June 89.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Alignments computed from member offsets rather than structure sizes,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Richard Stallman, Oct 89
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Print whether char* and int* pointers have the same format;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync also char * and function *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Update to Draft C version Dec 7, 1988
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync - types of constants produced in limits.h
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync (whether to put a U after unsigned shorts and chars and
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync whether to output -1024 as (-1023-1))
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync - values of *_EPSILON (not the smallest but the effective smallest)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added FILENAME, since ANSI C doesn't allow #define __FILE__
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Renamed from config.c to enquire.c
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added size_t and ptrdiff_t enquiries
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added promotion enquiries
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added type checks of #defines
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added BAD_STDDEF
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Changed endian to allow for cases where not all bits are used
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Sanity check for max integrals
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fixed definition of setjmp for -DNO_SIG
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Moved #define ... 0.0L inside #ifdef STDC, in case some cpp's tokenize
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added BAD_MALLOC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 5.0 Length 88228; February 1993; around 120 lines of output
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync (depends on what you count)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added the 'sh enquire.c' horror/delight: thanks David Mankins@think
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added checks for long names: thanks Steve Simon@leeds-poly
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added FPE signal checks: thanks Leonid A. Broukhis
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added check for dereferencing NULL
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added TESTI
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added LIBS, fixed showtype: thanks Rainer Orth@TechFak.Uni-Bielefeld.DE
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added a free(): thanks nickc@perihelion.co.uk
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Added signal catching to the malloc part
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Renamed naughty-compiler defines to BAD_*
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Renamed and altered Verify() to better check faulty compilers
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Shut some compilers up from giving incorrect warnings.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fixed sign_of(): thanks Hugh Redelmeier@redvax
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fixed USHRT_MAX for sizeof(short)=sizeof(int) but INT_MAX > SHRT_MAX
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fixed NO_UI
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fixed -DSEP: thanks Mike Black@seismo
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fixed the case where stdio.h includes limits.h: thanks rms@gnu
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fixed exponent(): thanks Christophe BINOT
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync <chb%hpvpta.france.hp.com@hplb.hpl.hp.com>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 5.0a Aug 1997
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Made handling of ID= easier
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Improved the reporting of use of bits in Floating values.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 5.1 Length 88739; Sep 1998
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fixed detection of infinity for machines with no overflow trap
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Speeded up search for max char (first 32 bit char machine turned up...)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 5.1a Length 88832; Feb 1999
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Changed identification message
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 5.1b Length 88926; Oct 2002
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fixed a missing \n in an output line; thanks Leonid Broukhis again
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Set FILENAME to the name of this file */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef __FILE__ /* It's a compiler bug if this fails. Define BAD_CPP */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* __FILE__ */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* BAD_CPP */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* FILENAME */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* This file is read three times (it #includes itself), to generate
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync otherwise identical code for each of short+float, int+double,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync long+long double. If PASS isn't defined, then this is the first pass.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Code bracketed by 'PASS0' is for stuff independent of all three,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync but is read during the first pass.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef SEP /* so we're only interested if this is pass 1 or not */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#else /* no SEP, so this is the first pass */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* SEP */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Void just marks the functions that don't return a result */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define Void void
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Set STDC to whether this is *really* an ANSI C compiler.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Some bad compilers define __STDC__, when they don't support it.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Compile with -DBAD_STDC to get round this.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#if __STDC__ /* If __STDC__ is 0, assume it isn't supported */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Stuff different for ANSI C, and old C:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ARGS and NOARGS are used for function prototypes.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Volatile is used to reduce the chance of optimisation,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync and to prevent variables being put in registers (when setjmp/longjmp
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync wouldn't work as we want)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Long_double is the longest floating point type available.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync stdc is used in tests like "if (stdc)", which is less ugly than #ifdef.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync U is output after unsigned constants.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define U "U"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#else /* Old style C */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define ARGS(x) ()
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define Volatile static
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define Long_double double
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define U ""
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* STDC */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* include files */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <stddef.h> /* for size_t: if this fails, define BAD_STDDEF */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <signal.h> /* if this fails, define NO_SIG */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <setjmp.h> /* if this fails, define NO_SIG */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#ifndef NO_SIG
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#include <signal.h> /* if this fails, define NO_SIG */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync//#include <setjmp.h> /* if this fails, define NO_SIG */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Kludge around the possiblity that <stdio.h> includes <limits.h> */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* The largest unsigned type */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define ulong unsigned long
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Some shorthands */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define Unexpected(place) if (setjmp(lab)!=0) croak(place)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* PASS */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* A description of the ANSI constants */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_CHAR_BIT "Number of bits in a storage unit"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_UCHAR_MAX "Maximum unsigned char (minimum is always 0)"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_UINT_MAX "Maximum unsigned %s (minimum is always 0)"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_FLT_ROUNDS "Addition rounds to 0: zero, 1: nearest, 2: +inf, 3: -inf, -1: unknown"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_FLT_RADIX "Radix of exponent representation"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_MANT_DIG "Number of base-FLT_RADIX digits in the significand of a %s"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_DIG "Number of decimal digits of precision in a %s"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_MIN_EXP "Minimum int x such that FLT_RADIX**(x-1) is a normalised %s"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_MIN_10_EXP "Minimum int x such that 10**x is a normalised %s"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_MAX_EXP "Maximum int x such that FLT_RADIX**(x-1) is a representable %s"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_MAX_10_EXP "Maximum int x such that 10**x is a representable %s"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define D_EPSILON "Difference between 1.0 and the minimum %s greater than 1.0"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Prototypes for what's to come: */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncchar *malloc (); /* Old style prototype, since we don't know what size_t is */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncVoid free ARGS((char *p)); /* Syntax error here? Try -DNO_VOID */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncVoid efprop ARGS((int fprec, int dprec, int lprec));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncVoid edprop ARGS((int fprec, int dprec, int lprec));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncVoid eldprop ARGS((int fprec, int dprec, int lprec));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncVoid describe ARGS((char *description, char *extra));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncint exponent ARGS((Long_double x, Long_double *fract, int *exp));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncVoid f_define ARGS((char *desc, char *extra, char *sort, char *name,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncVoid i_define ARGS((char *desc, char *extra, char *sort, char *name,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncVoid u_define ARGS((char *desc, char *extra, char *sort, char *name,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef NO_SIG /* There's no signal(), or setjmp/longjmp() */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Dummy routines instead */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync { /* what to do on over/underflow */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync { /* what to do on an address error */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /*NO_SIG*/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncint V= 0, /* verbose */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync L= 0, /* produce limits.h */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync F= 0, /* produce float.h */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync bugs=0; /* The number of (possible) bugs in the output */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncchar co[4], oc[4]; /* Comment starter and ender symbols */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncint bits_per_byte; /* the number of bits per unit returned by sizeof() */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncint flt_rounds; /* The calculated value of FLT_ROUNDS */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncint flt_radix; /* The calculated value of FLT_RADIX */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Set the fp modes on a SUN with 68881 chip, to check that different
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync rounding modes etc. get properly detected.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Compile with -f68881 for cc, -m68881 for gcc, and with additional flag
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync -DTEST. Run with additional parameter +hex-number, to set the 68881 mode
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync register to hex-number
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Bits 0x30 = rounding mode */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define TO_PLUS_INF 0x30 /* The SUN FP user's guide seems to be wrong here */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Bits 0xc0 = extended rounding */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Enabled traps */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Only used for testing, on a Sun with 68881 chip */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Print the FP mode */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync case TO_MINUS_INF: printf("minus infinity"); break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Only used for testing, on a Sun with 68881 chip */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Set the FP mode */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync while (*s) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync else return 1;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef TESTI /* Test mode using SunOs IEEE routines */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync while (*s) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync switch (c= *s++) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync case '+': cmd= "direction"; val= "positive"; break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync case '-': cmd= "direction"; val= "negative"; break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync case '3': cmd= "precision"; val= "extended"; break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync case '/': cmd= "exception"; val= "division"; break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync case '>': cmd= "exception"; val= "overflow"; break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync case '<': cmd= "exception"; val= "underflow"; break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* ARGSUSED */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync fprintf(stderr, "Can't set mode: not compiled with TEST\n");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* See if two blocks of store are identical */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf(" above\n see the section 'TROUBLESHOOTING' in the file ");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* The program has received a signal where it wasn't expecting one */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("*** Unexpected signal at point %d\n", place);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync farewell(bugs+1); /* An exit isn't essential here, but avoids loops */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* This is here in case alloca.c is used, which calls this. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Find the maximum integer */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Calculate maxint ***********************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Calculate 2**n-1 until overflow - then use the previous value */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* How long are my identifiers? I could go further here, but some compilers
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync have line length limits that I don't want to break.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncint zzzzzzzzz1zzzzzzzzz2zzzzzzzzz3zzzzzzzzz4zzzzzzzzz5zzzzzzzzz6zzzz=64;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync zzzzzzzzz1zzzzzzzzz2zzzzzzzzz3zzzzzzzzz4zzzzzzzzz5zzzzzzzzz6zzzz;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define aaaaaaaaa1aaaaaaaaa2aaaaaaaaa3aaaaaaaaa4aaaaaaaaa5aaaaaaaaa6aaaa 64
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#undef aaaaaaaaa1aaaaaaaaa2aaaaaaaaa3aaaaaaaaa4aaaaaaaaa5aaaaaaaaa6aaaa
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("Compiler names are at least %d chars long", l);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (l != 64)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("Preprocessor names are at least %d long", LENGTH);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Used by FPROP to see if FP traps are generated, and if they may return */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Add more calls as necessary */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (*s == L'-') {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync while (*s) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync switch (*(s++)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } else if (*s == L'+') {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "Usage: %ls [-vlf]\n v=Verbose l=Limits.h f=Float.h\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (L || F) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%sProduced by enquire version %s (%s), CWI, Amsterdam\n %s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%sProduced by enquire version %s, CWI, Amsterdam\n %s %s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "there's nothing that can be done if overflow occurs",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sCompiled without signed char%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sCompiled without unsigned char%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sCompiled without unsigned short or long%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sCompiler claims to be ANSI C level %d%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sCompiler does not claim to be ANSI C%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (F||V) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* An extra goody: the approximate amount of data-space */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Allocate store until no more available */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Different implementations have a different argument type
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync to malloc. Here we assume that it's the same type as
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync that which sizeof() returns */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync while (size!=0) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync while ((ptr= malloc((false()?sizeof(int):size))) != (char *)NULL) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync //if (save == NULL) save= ptr; /* save the biggest chunk */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Save pointer to first allocated chunk
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Build list of all subsequently allocated chunks, LIFO
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync eek_a_bug("Trying to malloc all store generates a trap");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync //if (save != NULL) free(save);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sMemory mallocatable ~= %ld %cbytes%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync return bugs; /* To keep compilers and lint happy */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* The program has discovered a problem */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("\n%s*** WARNING: %s%s\n", co, problem, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Produce the description for a #define */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Produce a #define for a signed int type */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (val >= 0) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("#define %s%s %ld%s\n", sort, name, val, mark);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* We may not produce a constant like -1024 if the max
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync allowable value is 1023. It has then to be output as
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync -1023-1. lim is the max allowable value. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("#define %s%s (%ld%s)\n", sort, name, val, mark);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* If VERIFY is not set, val and req are just the same value;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if it is set, val is the value as calculated, and req is
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the #defined constant
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%s*** Verify failed for above #define!\n", co);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf(" Compiler has %ld for value%s\n\n", req, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Produce a #define for an unsigned value */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("#define %s%s %lu%s%s\n", sort, name, val, U, mark);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%s*** Verify failed for above #define!\n", co);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf(" Compiler has %lu for value%s\n\n", req, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Produce a #define for a float/double/long double */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* non-ANSI C has no float constants, so cast the constant */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("#define %s%s %s\n", sort, name, f_rep(precision, val));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* return floor(log base(x)) */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncexponent(Long_double x, Long_double *fract, int *exp)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Split x into a fraction and a power of ten;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync returns 0 if x is unusable, 1 otherwise.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Only used for error messages about faulty output.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (x<0.0) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (x>=10.0) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync while (x>=10.0) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (old==x) return 0;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync while (x<1.0) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (old==x) return 0;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Return the floating representation of val */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (sizeof(double) == sizeof(Long_double)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Assume they're the same, and use non-stdc format */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* This is for stdc compilers using non-stdc libraries */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* It had better support Le then */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Printf the bit-pattern of p */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync unsigned int i;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync for (i=0; i<size; i++)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%s%s ", co, mode); fill((char *)&x, sizeof(x)); \
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync for (i=1; i<=sizeof(x); i++) { c=((x>>(byte_size*(sizeof(x)-i)))&mask);\
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Printf the byte-order used on this machine */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /*unsigned*/ short s=0;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /*unsigned*/ int j=0;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /*unsigned*/ long l=0;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync for (i=1; i<=(unsigned)byte_size; i++) mask= (mask<<1)|1;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%s*** #define %s missing from limits.h%s\n", co, s, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%s*** #define %s missing from float.h%s\n", co, s, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* To try and fool optimisers */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncint false( void ) { return 0; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define sign_of(x) (is_signed(x)?"signed":"unsigned")
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define showtype(t, x) Vprintf("%s%s %s %s%s\n", co, t, sign_of(x), type_of((int)sizeof(x)), oc)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (x == sizeof(char)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (sizeof(char) == sizeof(int)) return "char/short/int";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (sizeof(char) == sizeof(short)) return "char/short";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync return "char";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (x == sizeof(short)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (sizeof(short) == sizeof(int)) return "short/int";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync return "short";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (x == sizeof(int)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (sizeof(int) == sizeof(long)) return "int/long";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync return "int";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (x == sizeof(long)) return "long";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync return "unknown-type";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (x == sizeof(float)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync return "float";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (x == sizeof(double)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (sizeof(double) == sizeof(Long_double))
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync return "(long)double";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync return "double";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (x == sizeof(Long_double)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync return "long double";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync return "unknown-type";
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncVoid typerr(char *name, int esign, int esize, int sign, int size)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("*** %s has wrong type: expected %s %s, found %s %s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("*** %s has wrong type: expected %s, found %s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync unsigned long ul; /* if this fails, define NO_UI */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync unsigned short us; /* if this fails, define NO_UI */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Shut compiler warnings up: */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Sanity checks. Possible warnings here; should be no problem */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync eek_a_bug("unsigned int doesn't promote to int!\n");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync eek_a_bug("unsigned long doesn't promote to long!\n");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync showtype("unsigned short promotes to", Promoted(us));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#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));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define fchecktype(x, n, t) if (sizeof(x) != sizeof(t)) ftyperr(n, (int)sizeof(x), (int)sizeof(t));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* ensure that all #defines are present and have the correct type */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Implementations promote unsigned short differently */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } /* if (L) */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(FLT_MANT_DIG, "FLT_MANT_DIG", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(FLT_MIN_EXP, "FLT_MIN_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(FLT_MIN_10_EXP, "FLT_MIN_10_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(FLT_MAX_EXP, "FLT_MAX_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(FLT_MAX_10_EXP, "FLT_MAX_10_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(DBL_MANT_DIG, "DBL_MANT_DIG", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(DBL_MIN_EXP, "DBL_MIN_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(DBL_MIN_10_EXP, "DBL_MIN_10_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(DBL_MAX_EXP, "DBL_MAX_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(DBL_MAX_10_EXP, "DBL_MAX_10_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(LDBL_MANT_DIG, "LDBL_MANT_DIG", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync fchecktype(LDBL_EPSILON, "LDBL_EPSILON", long double);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(LDBL_MIN_EXP, "LDBL_MIN_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(LDBL_MIN_10_EXP, "LDBL_MIN_10_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(LDBL_MAX_EXP, "LDBL_MAX_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync checktype(LDBL_MAX_10_EXP, "LDBL_MAX_10_EXP", Signed, int);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* STDC */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } /* if (F) */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* VERIFY */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* VERIFY */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Properties of type char */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Calculate number of bits per character *************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync c= (char)(-1);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync co, (int)sizeof(c)*byte_size, (c_signed?"":"un"), oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sCharacter overflow generates a trap!%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Minimum value: assume either two's or one's complement *********/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sBEWARE! Chars are pseudo-unsigned:%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "They contain only nonnegative values, ",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Because of the integer promotions, you must use a U after
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the MAX_CHARS in the following cases */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((sizeof(char) == sizeof(int)) && !c_signed) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (sizeof(char) == sizeof(int)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Syntax error? Define NO_UC */ Volatile unsigned char c1, char_max;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (sizeof(char) == sizeof(int)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Syntax error? Define NO_SC */ Volatile signed char c1, char_max, char_min;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* NO_SC */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* The properties of the basic types.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Returns number of bits per sizeof unit */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync int *p, *q;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Shorts, ints and longs *****************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sshort=%d int=%d long=%d float=%d double=%d bits %s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync (int) sizeof(short)*byte_size,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync (int) sizeof(int)*byte_size,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync (int) sizeof(long)*byte_size,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync (int) sizeof(float)*byte_size,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync sizeof(char *)>sizeof(int)?" BEWARE! larger than int!":"",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync sizeof(int *)>sizeof(int)?" BEWARE! larger than int!":"",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync sizeof(function *)>sizeof(int)?" BEWARE! larger than int!":"",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Alignment constants ********************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ((long)((char *)&((struct{char c; TYPE d;}*)0)->d - (char *)0))
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%schar=%ld short=%ld int=%ld long=%ld%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync alignment(char *), alignment(int *), alignment(function *),
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Ten little endians *********************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Pointers *******************************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (memeq((char *) &cp, sizeof(cp), (char *) &ip, sizeof(ip))) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sChar and function pointer formats ", co);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (memeq((char *) &cp, sizeof(cp), (char *) &fp, sizeof(fp))) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync else printf("%sStrings are not shared%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync //if (setjmp(mlab) == 0) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // variable= *p;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Vprintf("%sBEWARE! Dereferencing NULL doesn't cause a trap%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Vprintf("%sDereferencing NULL causes a trap%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("\n%sPROPERTIES OF INTEGRAL TYPES%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#else /* not PASS0 */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* The global variables used by several passes */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncextern char *f_rep();
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* SEP */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* ifdef PASS0 */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* As I said, I apologise for the contortions below. The functions are
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync expanded by the preprocessor twice or three times (for float and double,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync and maybe for long double, and for short, int and long). That way,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync I never make a change to one that I forget to make to the other.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync You can look on it as C's fault for not supporting multi-line macros.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync This whole file is read 3 times by the preprocessor, with PASSn set for
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync n=1, 2 or 3, to decide which parts to reprocess.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* #undef on an already undefined thing is (wrongly) flagged as an error
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync by some compilers, therefore the #ifdef that follows:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* These are the float.h constants */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Define the things we're going to use this pass */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* VERIFY */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* PASS1 */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define OK_UI 1 /* Unsigned int is always possible */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* VERIFY */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* PASS2 */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* VERIFY */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* PASS3 */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* The rest of the file gets read all three times;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the differences are encoded in the things #defined above.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* the properties of short, int, and long */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Volatile Integer newi, int_max, maxeri, int_min, minneri;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Calculate max short/int/long ***********************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Calculate 2**n-1 until overflow - then use the previous value */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sOverflow of a%s %s does not generate a trap%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sOverflow of a%s %s generates a trap%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Minimum value: assume either two's or one's complement *********/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Now for those daft Cybers */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sMinimum %s = %ld%s\n", co, INT, (long)int_min, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if(int_max < 0) { /* It has happened (on a Cray) */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sThere is a larger %s, %ld (= 2**%d-1), %s %s%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "but only for addition, not multiplication",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "(I smell a Cyber!)",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "but only for addition, not multiplication",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "(I smell a Cyber!)",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* The properties of unsigned short/int/long */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Oh woe: new standard C defines value preserving promotions:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync 3.2.1.1: "If an int can represent all values of the original type,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the value is converted to an int;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync otherwise it is converted to an unsigned int."
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync && u_max <= maxint /* an int can represent all values */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync { /* the value is converted to an int */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } else { /* it is converted to an unsigned int */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync (unsigned long) u_max,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* Integer */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* The following routines are intended to defeat any attempt at optimisation
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync or use of extended precision, and to defeat faulty narrowing casts.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync The weird prototypes are because of widening incompatibilities.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define ARGS5(A, a, B, b, C, c, D, d, E, e) (A a, B b, C c, D d, E e)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#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;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncNumber Sum ARGS2(Number, a, Number, b) {Number r; Store(a+b, &r); return r; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncNumber Diff ARGS2(Number, a, Number, b){Number r; Store(a-b, &r); return r; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncNumber Mul ARGS2(Number, a, Number, b) {Number r; Store(a*b, &r); return r; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncNumber Div ARGS2(Number, a, Number, b) {Number r; Store(a/b, &r); return r; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncNumber Self ARGS1(Number, a) {Number r; Store(a, &r); return r; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncVoid F_check ARGS((int precision, Long_double val1));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* You don't think I'm going to go to all the trouble of writing
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync a program that works out what all sorts of values are, only to
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync have printf go and print the wrong values out, do you?
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync No, you're right, so this function tries to see if printf
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync has written the right value, by reading it back again.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync This introduces a new problem of course: suppose printf writes
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the correct value, and scanf reads it back wrong... oh well.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync But I'm adamant about this: the precision given is enough
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync to uniquely identify the printed number, therefore I insist
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync that sscanf read the number back identically. Harsh yes, but
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync sometimes you've got to be cruel to be kind.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (sizeof(double) == sizeof(Long_double)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Assume they're the same, and use non-stdc format */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* This is for stdc compilers using non-stdc libraries */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* It had better support Le then */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%s scanning: %s format: %s%s\n\n", co, rep, f2, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* That should be enough to generate a trap */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync eek_a_bug("Possibly bad output from printf above");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%s but value was an unusable number%s\n\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync //if (sizeof(double) == sizeof(Long_double)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Assume they're the same, and use non-stdc format */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* This is for stdc compilers using non-stdc libraries */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync //printf("%.*fe%d, bit pattern:\n ", precision, rem, e);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* It had better support Lfe then */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%.*Lfe%d, bit pattern:\n ", precision, rem, e);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } /* else forget it */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncVoid Verify ARGS5(int, prec, Number, val, Number, req, int, same, int, same1)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Check that the compiler has read a #define value correctly */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%s*** Verify failed for above #define!\n", co);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (setjmp(lab) == 0) { /* for the case that req == nan */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "an unusable number");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } /*else forget it*/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } /*else forget it*/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } else if (!same1) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (stdc) eek_a_bug("constant has the wrong precision");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* VERIFY */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Properties of floating types, using algorithms by Cody and Waite
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync from MA Malcolm, as modified by WM Gentleman and SB Marovich.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Further extended by S Pemberton.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Returns the number of digits in the fraction.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync i, f_radix, iexp, irnd, mrnd, f_rounds, f_mant_dig,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync iz, k, inf, machep, f_max_exp, f_min_exp, mx, negeps,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Base and size of significand **************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* First repeatedly double until adding 1 has no effect. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* For instance, if base is 10, with 3 significant digits */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* it will try 1, 2, 4, 8, ... 512, 1024, and stop there, */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* since 1024 is only representable as 1020. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync do { a=Sum(a, a); }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync fprintf(stderr, "*** Program got loss-of-precision trap!\n");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* And supporting those is just TOO much trouble! */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Now double until you find a number that can be added to the */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* above number. For 1020 this is 8 or 16, depending whether the */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* result is rounded or truncated. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* In either case the result is 1030. 1030-1020= the base, 10. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync do { b=Sum(b, b); } while ((base=Diff(Sum(a, b), a)) == ZERO);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Sanity check; if base<2, I can't guarantee the rest will work */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync eek_a_bug("Function return or parameter passing faulty? (This is a guess.)");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Now the number of digits precision */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync f_dig=floor_log(10, (Long_double)(b/base)) + (base==10?1:0);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sSignificant base digits = %d %s %d %s%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync co, f_mant_dig, "(= at least", f_dig, "decimal digits)", oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (F) i_define(D_MANT_DIG, thing, Fname, "_MANT_DIG",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync digs= ceil_log(10, (Long_double)b); /* the number of digits to printf */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Rounding *******************************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (Diff(Sum(a, basem1), a) != ZERO) irnd=2; /* away from 0 */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (Diff(Diff(-a, basem1), -a) != ZERO) mrnd=2; /* away from 0*/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (irnd==0 && mrnd==0) f_rounds=0; /* zero = chops */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } else { /* Hmm, try to give some help here */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sArithmetic rounds oddly: %s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "away from zero",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "away from zero",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* An extra goody */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%s Tie breaking rounds to even%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%s Tie breaking rounds down%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Various flavours of epsilon ************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sSmallest x such that 1.0-base**x != 1.0 = %d%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* find the smallest epsneg (1-epsneg != 1) by binary search.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ebot and etop are the current bounds */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Sanity check */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (Diff(ONE, etop) >= ONE || Diff(ONE, ebot) != ONE) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sSmallest x such that 1.0-x != 1.0 = %s%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* a=(a*(1.0+a))/(1.0+1.0); => */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* if ((1.0-a)-1.0 != 0.0) epsneg=a; => */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* epsneg is used later */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync while (Diff(Sum(ONE, a), ONE) == ZERO) { a*=base; machep++; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sSmallest x such that 1.0+base**x != 1.0 = %d%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* find the smallest eps (1+eps != 1) by binary search.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ebot and etop are the current bounds */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Sanity check */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (Sum(ONE, etop) <= ONE || Sum(ONE, ebot) != ONE) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sSmallest x such that 1.0+x != 1.0 = %s%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync f_epsilon= Diff(Sum(ONE, f_epsilon), ONE); /* New C standard defn */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Possible loss of precision warnings here from non-stdc compilers */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fname, "_EPSILON", digs, (Long_double) f_epsilon, MARK);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (V || F) F_check(digs, (Long_double) f_epsilon);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync (Long_double) f_epsilon == (Long_double) F_EPSILON);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Extra chop info *************************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (Diff(Mul(Sum(ONE,f_epsilon),ONE),ONE) != ZERO) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sAlthough arithmetic chops, it uses guard digits%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Size of and minimum normalised exponent ************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Coarse search for the largest power of two */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (setjmp(lab)==0) { /* for underflow trap */ /* Yields i, k, y, y1 */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } while(1);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%s%s underflow generates a trap%s\n", co, Thing, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Fine tune starting with y and y1 */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (setjmp(lab)==0) { /* for underflow trap */ /* Yields k, f_min */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((Sum(a,a) == ZERO) || (fabs(y) >= f_min)) break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } while (1);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((mx <= k+k-3) && (f_radix != 10)) { mx+=mx; iexp+=1; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sNumber of bits used for exponent = %d%s\n", co, iexp, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sMinimum normalised exponent = %d%s\n", co, f_min_exp-1, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync (long) f_min_exp, (long) maxint, (long) F_MIN_EXP, "");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sMinimum normalised positive number = %s%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync eek_a_bug("printf can't print the smallest normalised number");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Possible loss of precision warnings here from non-stdc compilers */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%s*** Verify failed for above #define!\n %s %s\n\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync co, "Compiler has an unusable number for value", oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync while (a > f_min*10.0) { a/=10.0; f_min_10_exp--; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (F) i_define(D_MIN_10_EXP, thing, Fname, "_MIN_10_EXP",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Minimum exponent ************************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (setjmp(lab)==0) { /* for underflow trap */ /* Yields xminner */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((Sum(a,a) == ZERO) || (fabs(y) >= xminner)) break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } while (1);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sThe smallest numbers are not kept normalised%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sSmallest unnormalised positive number = %s%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync eek_a_bug("printf can't print the smallest unnormalised number.");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sThe smallest numbers are normalised%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Maximum exponent ************************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (setjmp(lab) == 0) { /* Yields inf, f_max_exp */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sMaximum exponent = %d%s\n", co, f_max_exp, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (F) i_define(D_MAX_EXP, thing, Fname, "_MAX_EXP",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Largest number ***************************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (Mul(f_max,ONE) != f_max) f_max=Diff(ONE, Mul(base,epsneg));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync for (i=1; i<=f_max_exp; i++) f_max=Mul(f_max, base);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync eek_a_bug("printf can't print the largest double.");
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Possible loss of precision warnings here from non-stdc compilers */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("%s*** Verify failed for above #define!\n %s %s\n\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync co, "Compiler has an unusable number for value", oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync while (a < f_max/10.0) { a*=10.0; f_max_10_exp++; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (F) i_define(D_MAX_10_EXP, thing, Fname, "_MAX_10_EXP",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Traps and infinities ********************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sOverflow generates a trap%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sOverflow doesn't seem to generate a trap%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (inf) { Vprintf("%sThere is an 'infinite' value%s\n", co, oc); }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync a= (1.0/b)/b;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sDivide by zero doesn't generate a trap%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sDivide by zero generates a trap%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sBEWARE! FP signal handlers can NOT return%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Hidden bit + sanity check ****************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync mantbits=floor_log(2, (Long_double)f_radix)*f_mant_dig;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (mantbits+iexp == (int)sizeof(Number)*byte_size) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sArithmetic uses a hidden bit%s\n", co, oc);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } else if (mantbits+iexp+1 == (int)sizeof(Number)*byte_size) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sArithmetic doesn't use a hidden bit%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } else if (mantbits+iexp+1 < (int)sizeof(Number)*byte_size) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "are actually used",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync printf("\n%s%s\n %s (%d) %s (%d) %s %s (%d)!%s\n\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "*** Something fishy here!",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "Exponent size",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "+ significand size",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "doesn't match with the size of a",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (hidden && f_radix == 2 && f_max_exp+f_min_exp==3) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sIt looks like %s length IEEE format%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* See if expressions are evaluated in extended precision.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Some compilers optimise even if you don't want it,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync and then this function fails to produce the right result.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync We try to diagnose this if it happens.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync /* Size of significand **************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync do { old=a; a=a+a; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync do { old=b; b=b+b; }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%sCan't determine precision for %s expressions:\n%s%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync co, thing, " check that you compiled without optimisation!",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%s%s expressions are evaluated in double precision%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%s%s expressions are evaluated in float precision%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%s%s expressions are evaluated in long double precision%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Vprintf("%s%s expressions are evaluated in a %s %s %d %s%s\n",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync "precision than double,\n using",
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#else /* not Number */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef FPROP /* Then create dummy routines for long double */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* ARGSUSED */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* ARGSUSED */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* ifdef Number */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* Increment the pass number */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include FILENAME /* if this line fails to compile, define BAD_CPP */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* PASS */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* SEP */