gcc/enquire.c

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