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