home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mitsch75.zip / scheme-7_5_17-src.zip / scheme-7.5.17 / src / microcode / hard-par.c < prev    next >
Text File  |  1992-08-29  |  51KB  |  1,758 lines
  1. /* Everything you wanted to know about your machine and C compiler,
  2.    but didn't know who to ask.
  3.    Author: Steven Pemberton, CWI, Amsterdam; steven@cwi.nl
  4.    Bugfixes and upgrades gratefully received.
  5.  
  6.    Name changed to `hard-params' by Richard Stallman, April 89.
  7.    xmalloc function defined, Richard Stallman, June 89.
  8.    Some changes to make it compile and generate "safer" output
  9.    for compilers that predefine some of these constants by
  10.    Matt Birkholz and the MIT Scheme Team.
  11.  
  12.    Copyright (c) 1988, 1989 Steven Pemberton, CWI, Amsterdam.
  13.    All rights reserved.
  14.  
  15.    COMPILING
  16.    With luck and a following wind, just the following will work:
  17.     cc hard-params.c -o hard-params
  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.     signal(), or setjmp/longjmp()        -DNO_SIG
  24.  
  25.    Try it first with no flags, and see if you get any errors - you might be
  26.    surprised. (Most non-ANSI compilers need -DNO_SC, though.)
  27.    Some compilers need a -f flag for floating point.
  28.  
  29.    Don't use any optimisation flags: the program may not work if you do.
  30.    Though "while (a+1.0-a-1.0 == 0.0)" may look like "while(1)" to an
  31.    optimiser, to a floating-point unit there's a world of difference.
  32.  
  33.    Some compilers offer various flags for different floating point
  34.    modes; it's worth trying all possible combinations of these.
  35.  
  36.    Add -DID=\"name\" if you want the machine/flags identified in the output.
  37.  
  38.    SYSTEM DEPENDENCIES
  39.    You may possibly need to add some calls to signal() for other sorts of
  40.    exception on your machine than SIGFPE, and SIGOVER.  See lines beginning
  41.    #ifdef SIGxxx in main() (and communicate the differences to me!).
  42.  
  43.    If your C preprocessor doesn't have the predefined __FILE__ macro, and
  44.    you want to call this file anything other than hard-params.c, change the
  45.    #define command for __FILE__ accordingly.  If it doesn't accept macro
  46.    names at all in #include lines, order a new C compiler. While you're
  47.    waiting for it to arrive, change the last #include in this file (the
  48.    last but one line) accordingly.
  49.  
  50.    OUTPUT
  51.    Run without argument to get the information as English text.  If run
  52.    with argument -l (e.g. hard-params -l), output is a series of #define's for
  53.    the ANSI standard limits.h include file, excluding MB_MAX_CHAR.  If run
  54.    with argument -f, output is a series of #define's for the ANSI standard
  55.    float.h include file.  Flag -v gives verbose output: output includes the
  56.    English text above as C comments.  The program exit(0)'s if everything
  57.    went ok, otherwise it exits with a positive number, telling how many
  58.    problems there were.
  59.  
  60.    VERIFYING THE COMPILER
  61.    If, having produced the float.h and limits.h header files, you want to
  62.    verify that the compiler reads them back correctly (there are a lot of
  63.    boundary cases, of course, like minimum and maximum numbers), you can
  64.    recompile hard-params.c with -DVERIFY set (plus the other flags that you used
  65.    when compiling the version that produced the header files).  This then
  66.    recompiles the program so that it #includes "limits.h" and "float.h",
  67.    and checks that the constants it finds there are the same as the
  68.    constants it produces. Run the resulting program with hard-params -fl.  As of
  69.    this writing, of 21 compiler/flags combinations only 1 compiler has
  70.    passed without error! (The honour goes to 'pcc' on an IBM RT.)
  71.  
  72.    You can also use this option if your compiler already has both files,
  73.    and you want to confirm that this program produces the right results.
  74.  
  75.    TROUBLE SHOOTING.
  76.    This program is now quite trustworthy, and suspicious and wrong output
  77.    may well be caused by bugs in the compiler, not in the program (however
  78.    of course, this is not guaranteed, and no responsibility can be
  79.    accepted, etc.)
  80.  
  81.    The program only works if overflows are ignored by the C system or
  82.    are catchable with signal().
  83.  
  84.    If the program fails to run to completion (often with the error message
  85.    "Unexpected signal at point x"), this often turns out to be a bug in the
  86.    C compiler's run-time system. Check what was about to be printed, and
  87.    try to narrow the problem down.
  88.  
  89.    Another possible problem is that you have compiled the program to produce
  90.    loss-of-precision arithmetic traps. The program cannot cope with these,
  91.    and you should re-compile without them. (They should never be the default).
  92.  
  93.    Make sure you compiled with optimisation turned off.
  94.  
  95.    Output preceded by *** WARNING: identifies behaviour of the C system
  96.    deemed incorrect by the program. Likely problems are that printf or
  97.    scanf don't cope properly with certain boundary numbers.  For each float
  98.    and double that is printed, the printed value is checked that it is
  99.    correct by using sscanf to read it back.  Care is taken that numbers are
  100.    printed with enough digits to uniquely identify them, and therefore that
  101.    they can be read back identically. If the number read back is different,
  102.    the program prints a warning message. If the two numbers in the warning
  103.    look identical, then printf is more than likely rounding the last
  104.    digit(s) incorrectly.  To put you at ease that the two really are
  105.    different, the bit patterns of the two numbers are also printed.  The
  106.    difference is very likely in the last bit.  Many scanf's read the
  107.    minimum double back as 0.0, and similarly cause overflow when reading
  108.    the maximum double.  The program quite ruthlessly declares all these
  109.    behaviours faulty.
  110.  
  111.    The warning that "a cast didn't work" refers to cases like this:
  112.  
  113.       float f;
  114.       #define C 1.234567890123456789
  115.       f= C;
  116.       if (f != (float) C) printf ("Wrong!");
  117.  
  118.    A faulty compiler will widen f to double and ignore the cast to float,
  119.    and because there is more accuracy in a double than a float, fail to
  120.    recognise that they are the same. In the actual case in point, f and C
  121.    are passed as parameters to a function that discovers they are not equal,
  122.    so it's just possible that the error was in the parameter passing,
  123.    not in the cast (see function Validate()).
  124.    For ANSI C, which has float constants, the error message is "constant has
  125.    wrong precision".
  126.  
  127.    REPORTING PROBLEMS
  128.    If the program doesn't work for you for any reason that can't be
  129.    narrowed down to a problem in the C compiler, or it has to be changed in
  130.    order to get it to compile, or it produces suspicious output (like a very
  131.    low maximum float, for instance), please mail the problem and an example
  132.    of the incorrect output to steven@cwi.nl or mcvax!steven.uucp, so that
  133.    improvements can be worked into future versions; mcvax/cwi.nl is the
  134.    European backbone, and is connected to uunet and other fine hosts.
  135.  
  136.    This version of the program is the first to try to catch and diagnose
  137.    bugs in the compiler/run-time system. I would be especially pleased to
  138.    have reports of failures so that I can improve this service.
  139.  
  140.    I apologise unreservedly for the contorted use of the preprocessor...
  141.  
  142.    THE SMALL PRINT
  143.    You may copy and distribute verbatim copies of this source file.
  144.  
  145.    You may modify this source file, and copy and distribute such
  146.    modified versions, provided that you leave the copyright notice
  147.    at the top of the file and also cause the modified file to carry
  148.    prominent notices stating that you changed the files and the date
  149.    of any change; and cause the whole of any work that you distribute
  150.    or publish, that in whole or in part contains or is a derivative of
  151.    this program or any part thereof, to be licensed at no charge to
  152.    all third parties on terms identical to those here.
  153.  
  154.    If you do have a fix to any problem, please send it to me, so that
  155.    other people can have the benefits.
  156.  
  157.    While every effort has been taken to make this program as reliable as
  158.    possible, no responsibility can be taken for the correctness of the
  159.    output, or suitability for any particular use.
  160.  
  161.    ACKNOWLEDGEMENTS
  162.    Many people have given time and ideas to making this program what it is.
  163.    To all of them thanks, and apologies for not mentioning them by name.
  164. */
  165.  
  166. #ifndef __FILE__
  167. #define __FILE__ "hard-params.c"
  168. #endif
  169.  
  170. #ifndef PASS
  171. #define PASS 1
  172. #define PASS1 1
  173. #define VERSION "4.1"
  174.  
  175. /* Procedure just marks the functions that don't return a result */
  176. #ifdef Procedure
  177. #undef Procedure
  178. #endif
  179. #define Procedure
  180.  
  181. #define Vprintf if (V) printf
  182.  
  183. /* stdc is used in tests like if (stdc) */
  184. #ifdef __STDC__
  185. #define stdc 1
  186. #else
  187. #define stdc 0
  188. #endif
  189.  
  190. /* volatile is used to reduce the chance of optimisation,
  191.    and to prevent variables being put in registers (when setjmp/longjmp
  192.    wouldn't work as we want)  */
  193. #ifndef __STDC__
  194. #define volatile
  195. #endif
  196.  
  197. #include <stdio.h>
  198.  
  199. #ifdef VERIFY
  200. #include "limits.h"
  201. #include "float.h"
  202. #endif
  203.  
  204. #ifdef NO_SIG  /* There's no signal(), or setjmp/longjmp() */
  205.  
  206.     /* Dummy routines instead */
  207.     int lab=1;
  208.     int setjmp(lab) int lab; { return(0); }
  209.     signal(i, p) int i, (*p)(); {}
  210.  
  211. #else
  212.  
  213. #include <signal.h>
  214. #include <setjmp.h>
  215.  
  216.     jmp_buf lab;
  217.     overflow(sig) int sig; { /* what to do on overflow/underflow */
  218.         signal(sig, overflow);
  219.         longjmp(lab, 1);
  220.     }
  221.  
  222. #endif /*NO_SIG*/
  223.  
  224. #define Unexpected(place) if (setjmp(lab)!=0) croak(place)
  225.  
  226. int V= 0,    /* verbose */
  227.     L= 0,    /* produce limits.h */
  228.     F= 0,    /* produce float.h  */
  229.     bugs=0;    /* The number of (possible) bugs in the output */
  230.  
  231. char co[4], oc[4]; /* Comment starter and ender symbols */
  232.  
  233. int bits_per_byte; /* the number of bits per unit returned by sizeof() */
  234.  
  235. #ifdef TEST
  236. /* Set the fp modes on a SUN with 68881 chip, to check that different
  237.    rounding modes etc. get properly detected.
  238.    Compile with additional flag -DTEST, and run with additional parameter
  239.    +hex-number, to set the 68881 mode register to hex-number
  240. */
  241.  
  242. /* Bits 0x30 = rounding mode: */
  243. #define ROUND_BITS    0x30
  244. #define TO_NEAREST    0x00
  245. #define TO_ZERO        0x10
  246. #define TO_MINUS_INF    0x20
  247. #define TO_PLUS_INF    0x30 /* The SUN FP user's guide seems to be wrong here */
  248.  
  249. /* Bits 0xc0 = extended rounding: */
  250. #define EXT_BITS    0xc0
  251. #define ROUND_EXTENDED    0x00
  252. #define ROUND_SINGLE     0x40
  253. #define ROUND_DOUBLE    0x80
  254.  
  255. /* Enabled traps: */
  256. #define EXE_INEX1  0x100
  257. #define EXE_INEX2  0x200
  258. #define EXE_DZ       0x400
  259. #define EXE_UNFL   0x800
  260. #define EXE_OVFL  0x1000
  261. #define EXE_OPERR 0x2000
  262. #define EXE_SNAN  0x4000
  263. #define EXE_BSUN  0x8000
  264.  
  265. printmode(new) unsigned new; {
  266.     fpmode_(&new);
  267.     printf("New fp mode:\n");
  268.     printf("  Round toward ");
  269.     switch (new & ROUND_BITS) {
  270.           case TO_NEAREST:   printf("nearest"); break;
  271.           case TO_ZERO:      printf("zero"); break;
  272.           case TO_MINUS_INF: printf("minus infinity"); break;
  273.           case TO_PLUS_INF:  printf("plus infinity"); break;
  274.           default: printf("???"); break;
  275.     }
  276.  
  277.     printf("\n  Extended rounding precision: ");
  278.  
  279.     switch (new & EXT_BITS) {
  280.           case ROUND_EXTENDED: printf("extended"); break;
  281.           case ROUND_SINGLE:   printf("single"); break;
  282.           case ROUND_DOUBLE:   printf("double"); break;
  283.           default: printf("???"); break;
  284.     }
  285.  
  286.     printf("\n  Enabled exceptions:");
  287.     if (new & (unsigned) EXE_INEX1) printf(" inex1");
  288.     if (new & (unsigned) EXE_INEX2) printf(" inex2");
  289.     if (new & (unsigned) EXE_DZ)    printf(" dz"); 
  290.     if (new & (unsigned) EXE_UNFL)  printf(" unfl"); 
  291.     if (new & (unsigned) EXE_OVFL)  printf(" ovfl"); 
  292.     if (new & (unsigned) EXE_OPERR) printf(" operr"); 
  293.     if (new & (unsigned) EXE_SNAN)  printf(" snan"); 
  294.     if (new & (unsigned) EXE_BSUN)  printf(" bsun"); 
  295.     printf("\n");
  296. }
  297.  
  298. int setmode(s) char *s; {
  299.     unsigned mode=0, dig;
  300.     char c;
  301.  
  302.     while (*s) {
  303.         c= *s++;
  304.         if  (c>='0' && c<='9') dig= c-'0';
  305.         else if (c>='a' && c<='f') dig= c-'a'+10;
  306.         else if (c>='A' && c<='F') dig= c-'A'+10;
  307.         else return 1;
  308.         mode= mode<<4 | dig;
  309.     }
  310.     printmode(mode);
  311.     return 0;
  312. }
  313. #else
  314. int setmode(s) char *s; {
  315.     fprintf(stderr, "Can't set mode: not compiled with TEST\n");
  316.     return(1);
  317. }
  318. #endif
  319.  
  320. croak(place) int place; {
  321.     printf("*** Unexpected signal at point %d\n", place);
  322.     exit(bugs+1); /* An exit isn't essential here, but avoids loops */
  323. }
  324.  
  325. /* This is here in case alloca.c is used.  That wants to call this.  */
  326.  
  327. char *
  328. xmalloc(size) unsigned size; {
  329.     char *malloc();
  330.     char *value = malloc(size);
  331.     if (value == 0) {
  332.         fprintf(stderr, "Virtual memory exceeded\n");
  333.         exit(bugs+1);
  334.     }
  335.     return value;
  336. }
  337.  
  338. main(argc, argv) int argc; char *argv[]; {
  339.     int dprec, fprec, lprec, basic(), fprop(), dprop(), efprop(), edprop();
  340.     char *malloc();
  341.     unsigned int size;
  342.     long total;
  343.     int i; char *s; int bad;
  344.  
  345. #ifdef SIGFPE
  346.     signal(SIGFPE, overflow);
  347. #endif
  348. #ifdef SIGOVER
  349.     signal(SIGOVER, overflow);
  350. #endif
  351. /* Add more calls as necessary */
  352.  
  353.     Unexpected(1);
  354.  
  355.     bad=0;
  356.     for (i=1; i < argc; i++) {
  357.         s= argv[i];
  358.         if (*s == '-') {
  359.             s++;
  360.             while (*s) {
  361.                 switch (*(s++)) {
  362.                       case 'v': V=1; break;
  363.                       case 'l': L=1; break;
  364.                       case 'f': F=1; break;
  365.                       default: bad=1; break;
  366.                 }
  367.             }
  368.         } else if (*s == '+') {
  369.             s++;
  370.             bad= setmode(s);
  371.         } else bad= 1;
  372.     }
  373.     if (bad) {
  374.         fprintf(stderr,
  375.             "Usage: %s [-vlf]\n  v=Verbose l=Limits.h f=Float.h\n",
  376.             argv[0]);
  377.         exit(1);
  378.     }
  379.     if (L || F) {
  380.         co[0]= '/'; oc[0]= ' ';
  381.         co[1]= '*'; oc[1]= '*';
  382.         co[2]= ' '; oc[2]= '/';
  383.         co[3]= '\0'; oc[3]= '\0';
  384.     } else {
  385.         co[0]= '\0'; oc[0]= '\0';
  386.         V=1;
  387.     }
  388.  
  389.     if (L) printf("%slimits.h%s\n", co, oc);
  390.     if (F) printf("%sfloat.h%s\n", co, oc);
  391. #ifdef ID
  392.     printf("%sProduced on %s by hard-params version %s, CWI, Amsterdam%s\n",
  393.            co, ID, VERSION, oc);
  394. #else
  395.     printf("%sProduced by hard-params version %s, CWI, Amsterdam%s\n",
  396.            co, VERSION, oc);
  397. #endif
  398.     if (F) printf ("\n#ifndef _FLOAT_H_\n");
  399.  
  400. #ifdef VERIFY
  401.     printf("%sVerification phase%s\n", co, oc);
  402. #endif
  403.  
  404. #ifdef NO_SIG
  405.     Vprintf("%sCompiled without signal(): %s%s\n",
  406.         co,
  407.         "there's nothing that can be done if overflow occurs",
  408.         oc);
  409. #endif
  410. #ifdef NO_SC
  411.     Vprintf("%sCompiled without signed char%s\n", co, oc);
  412. #endif
  413. #ifdef NO_UC
  414.     Vprintf("%Compiled without unsigned char%s\n", co, oc);
  415. #endif
  416. #ifdef NO_UI
  417.     Vprintf("%Compiled without unsigned short or long%s\n", co, oc);
  418. #endif
  419. #ifdef __STDC__
  420.     Vprintf("%sCompiler claims to be ANSI C level %d%s\n",
  421.         co, __STDC__, oc);
  422. #else
  423.     Vprintf("%sCompiler does not claim to be ANSI C%s\n", co, oc);
  424. #endif
  425.     printf("\n");
  426.     bits_per_byte= basic();
  427.     Vprintf("\n");
  428.     if (F||V) {
  429.         fprec= fprop(bits_per_byte);
  430.         dprec= dprop(bits_per_byte);
  431.         lprec= ldprop(bits_per_byte);
  432.         efprop(fprec, dprec, lprec);
  433.         edprop(fprec, dprec, lprec);
  434.         eldprop(fprec, dprec, lprec);
  435.     }
  436.     if (V) {
  437.         /* An extra goody: the approximate amount of data-space */
  438.         /* Allocate store until no more available */
  439.         size=1<<((bits_per_byte*sizeof(int))-2);
  440.         total=0;
  441.         while (size!=0) {
  442.             while (malloc(size)!=(char *)NULL) total+=(size/2);
  443.             size/=2;
  444.         }
  445.  
  446.         Vprintf("%sMemory mallocatable ~= %ld Kbytes%s\n",
  447.             co, (total+511)/512, oc);
  448.     }
  449.  
  450.     if (F) printf ("\n#endif %snot _FLOAT_H_%s\n", co, oc);
  451.  
  452.     exit(bugs);
  453. }
  454.  
  455. Procedure eek_a_bug(problem) char *problem; {
  456.     printf("\n%s*** WARNING: %s%s\n", co, problem, oc);
  457.     bugs++;
  458. }
  459.  
  460. Procedure i_define(sort, name, val, req) char *sort, *name; long val, req;
  461. {
  462.   printf ("\n#ifndef %s%s\n", sort, name);
  463.   if (val >= 0)
  464.   {
  465.     printf("#define %s%s %ld\n", sort, name, val);
  466.   } else
  467.   {
  468.     printf("#define %s%s (%ld)\n", sort, name, val);
  469.   }
  470.   if (val != req)
  471.   {
  472.     printf("%s*** Verify failed for above #define!\n", co);
  473.     printf("       Compiler has %ld for value%s\n\n", req, oc);
  474.     bugs++;
  475.   }
  476.   printf ("#endif %s%s%s%s\n", co, sort, name, oc);
  477.   Vprintf("\n");
  478. }
  479.  
  480. #ifndef NO_UI
  481.  
  482. #ifdef __STDC__
  483. #define U "U"
  484. #else
  485. #define U ""
  486. #endif
  487.  
  488. Procedure u_define(sort, name, val, req)
  489.      char *sort, *name; unsigned long val, req;
  490. {
  491.   printf ("\n#ifndef %s%s\n", sort, name);
  492.   printf("#define %s%s %lu%s\n", sort, name, val, U);
  493.   if (val != req) {
  494.     printf("%s*** Verify failed for above #define!\n", co);
  495.     printf("       Compiler has %lu for value%s\n\n", req, oc);
  496.     bugs++;
  497.   }
  498.   printf ("#endif %s%s%s%s\n", co, sort, name, oc);
  499.   Vprintf("\n");
  500. }
  501. #endif
  502.  
  503. /* Long_double is the longest floating point type available: */
  504. #ifdef __STDC__
  505. #define Long_double long double
  506. #else
  507. #define Long_double double
  508. #endif
  509.  
  510. char *f_rep();
  511.  
  512. Procedure f_define(sort, name, precision, val, mark)
  513.      char *sort, *name; int precision; Long_double val; char *mark;
  514. {
  515.   printf ("\n#ifndef %s%s\n", sort, name);
  516.   if (stdc)
  517.   {
  518.     printf("#define %s%s %s%s\n",
  519.        sort, name, f_rep(precision, val), mark);
  520.   } else if (*mark == 'F')
  521.   {
  522.     /* non-ANSI C has no float constants, so cast the constant */
  523.     printf("#define %s%s ((float)%s)\n",
  524.        sort, name, f_rep(precision, val));
  525.   } else
  526.   {
  527.     printf("#define %s%s %s\n", sort, name, f_rep(precision, val));
  528.   }
  529.   printf ("#endif %s%s%s%s\n", co, sort, name, oc);
  530.   Vprintf("\n");
  531. }
  532.  
  533. int floor_log(base, x) int base; Long_double x; { /* return floor(log base(x)) */
  534.     int r=0;
  535.     while (x>=base) { r++; x/=base; }
  536.     return r;
  537. }
  538.  
  539. int ceil_log(base, x) int base; Long_double x; {
  540.     int r=0;
  541.     while (x>1.0) { r++; x/=base; }
  542.     return r;
  543. }
  544.  
  545. int exponent(x, fract, exp) Long_double x; double *fract; int *exp; {
  546.     /* Split x into a fraction and a power of ten;
  547.        returns 0 if x is unusable, 1 otherwise.
  548.        Only used for error messages about faulty output.
  549.     */
  550.     int r=0, neg=0;
  551.     Long_double old;
  552.     *fract=0.0; *exp=0;
  553.     if (x<0.0) {
  554.         x= -x;
  555.         neg= 1;
  556.     }
  557.     if (x==0.0) return 1;
  558.     if (x>=10.0) {
  559.         while (x>=10.0) {
  560.             old=x; r++; x/=10.0;
  561.             if (old==x) return 0;
  562.         }
  563.     } else {
  564.         while (x<1.0) {
  565.             old=x; r--; x*=10.0;
  566.             if (old==x) return 0;
  567.         }
  568.     }
  569.     if (neg) *fract= -x;
  570.     else *fract=x;
  571.     *exp=r;
  572.     return 1;
  573. }
  574.  
  575. #define fabs(x) (((x)<0.0)?(-x):(x))
  576.  
  577. char *f_rep(precision, val) int precision; Long_double val; {
  578.     static char buf[1024];
  579.     char *f1;
  580.     if (sizeof(double) == sizeof(Long_double)) {
  581.         /* Assume they're the same, and use non-stdc format */
  582.         /* This is for stdc compilers using non-stdc libraries */
  583.         f1= "%.*e";
  584.     } else {
  585.         /* It had better support Le then */
  586.         f1= "%.*Le";
  587.     }
  588.     sprintf(buf, f1, precision, val);
  589.     return buf;
  590. }
  591.  
  592. Procedure bitpattern(p, size) char *p; int size; {
  593.     char c;
  594.     int i, j;
  595.  
  596.     for (i=1; i<=size; i++) {
  597.         c= *p;
  598.         p++;
  599.         for (j=bits_per_byte-1; j>=0; j--)
  600.             printf("%c", (c>>j)&1 ? '1' : '0');
  601.         if (i!=size) printf(" ");
  602.     }
  603. }
  604.  
  605. #define Order(x, px, mode)\
  606.    printf("%s    %s ", co, mode); for (i=0; i<sizeof(x); i++) px[i]= c[i]; \
  607.    for (i=1; i<=sizeof(x); i++) { putchar((char)((x>>(bits_per_byte*(sizeof(x)-i)))&mask)); }\
  608.    printf("%s\n", oc);
  609.  
  610. Procedure endian(bits_per_byte) int bits_per_byte; {
  611.     /*unsigned*/ short s=0;
  612.     /*unsigned*/ int j=0;
  613.     /*unsigned*/ long l=0;
  614.  
  615.     char *ps= (char *) &s,
  616.          *pj= (char *) &j,
  617.          *pl= (char *) &l,
  618.          *c= "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  619.     unsigned int mask, i;
  620.  
  621.     mask=0;
  622.     for (i=1; i<=bits_per_byte; i++) mask= (mask<<1)|1;
  623.  
  624.     if (V) {
  625.         printf("%sCharacter order:%s\n", co, oc);
  626.         Order(s, ps, "short:");
  627.         Order(j, pj, "int:  ");
  628.         Order(l, pl, "long: ");
  629.     }
  630. }
  631.  
  632. #ifdef VERIFY
  633. #ifndef SCHAR_MAX
  634. #define SCHAR_MAX char_max
  635. #define SCHAR_MIN char_min
  636. #endif
  637. #ifndef UCHAR_MAX
  638. #define UCHAR_MAX char_max
  639. #endif
  640. #else
  641. #ifdef CHAR_BIT
  642. #undef CHAR_BIT
  643. #endif
  644. #define CHAR_BIT char_bit
  645. #ifdef CHAR_MAX
  646. #undef CHAR_MAX
  647. #endif
  648. #define CHAR_MAX char_max
  649. #ifdef CHAR_MIN
  650. #undef CHAR_MIN
  651. #endif
  652. #define CHAR_MIN char_min
  653. #ifdef SCHAR_MAX
  654. #undef SCHAR_MAX
  655. #endif
  656. #define SCHAR_MAX char_max
  657. #ifdef SCHAR_MIN
  658. #undef SCHAR_MIN
  659. #endif
  660. #define SCHAR_MIN char_min
  661. #ifdef UCHAR_MAX
  662. #undef UCHAR_MAX
  663. #endif
  664. #define UCHAR_MAX char_max
  665. #endif /* not VERIFY */
  666.  
  667. int cprop() { /* Properties of character */
  668.     volatile char c, char_max, char_min;
  669.     volatile int bits_per_byte, is_signed;
  670.     long char_bit;
  671.  
  672.     Unexpected(2);
  673.  
  674.     /* Calculate number of bits per character *************************/
  675.     c=1; bits_per_byte=0;
  676.     do { c=c<<1; bits_per_byte++; } while(c!=0);
  677.     c= (char)(-1);
  678.     if (((int)c)<0) is_signed=1;
  679.     else is_signed=0;
  680.     Vprintf("%sChar = %d bits, %ssigned%s\n",
  681.         co, (int)sizeof(c)*bits_per_byte, (is_signed?"":"un"), oc);
  682.     char_bit=(long)(sizeof(c)*bits_per_byte);
  683.     if (L) i_define("CHAR", "_BIT", char_bit, (long) CHAR_BIT);
  684.  
  685.     c=0; char_max=0;
  686.     c++;
  687.     if (setjmp(lab)==0) { /* Yields char_max */
  688.         while (c>char_max) {
  689.             char_max=c;
  690.             c++;
  691.         }
  692.     } else {
  693.         Vprintf("%sCharacter overflow generates a trap!%s\n", co, oc);
  694.     }
  695.     c=0; char_min=0;
  696.     c--;
  697.     if (setjmp(lab)==0) { /* Yields char_min */
  698.         while (c<char_min) {
  699.             char_min=c;
  700.             c--;
  701.         }
  702.     }
  703.     Unexpected(3);
  704.  
  705.     if (L) {
  706.         i_define("CHAR", "_MAX", (long) char_max, (long) CHAR_MAX);
  707.         i_define("CHAR", "_MIN", (long) char_min, (long) CHAR_MIN);
  708.         if (is_signed) {
  709.             i_define("SCHAR", "_MAX", (long) char_max,
  710.                  (long) SCHAR_MAX);
  711.             i_define("SCHAR", "_MIN", (long) char_min,
  712.                  (long) SCHAR_MIN);
  713.         } else {
  714.             i_define("UCHAR", "_MAX", (long) char_max,
  715.                  (long) UCHAR_MAX);
  716.         }
  717.  
  718.         if (is_signed) {
  719. #ifndef NO_UC
  720.             volatile unsigned char c, char_max;
  721.             c=0; char_max=0;
  722.             c++;
  723.             if (setjmp(lab)==0) { /* Yields char_max */
  724.                 while (c>char_max) {
  725.                     char_max=c;
  726.                     c++;
  727.                 }
  728.             }
  729.             Unexpected(4);
  730.             i_define("UCHAR", "_MAX", (long) char_max,
  731.                  (long) UCHAR_MAX);
  732. #endif
  733.         } else {
  734. #ifndef NO_SC /* Define NO_SC if the next line gives a syntax error */
  735.             volatile signed char c, char_max, char_min;
  736.             c=0; char_max=0;
  737.             c++;
  738.             if (setjmp(lab)==0) { /* Yields char_max */
  739.                 while (c>char_max) {
  740.                     char_max=c;
  741.                     c++;
  742.                 }
  743.             }
  744.             c=0; char_min=0;
  745.             c--;
  746.             if (setjmp(lab)==0) { /* Yields char_min */
  747.                 while (c<char_min) {
  748.                     char_min=c;
  749.                     c--;
  750.                 }
  751.             }
  752.             Unexpected(5);
  753.             i_define("SCHAR", "_MIN", (long) char_min,
  754.                  (long) SCHAR_MIN);
  755.             i_define("SCHAR", "_MAX", (long) char_max,
  756.                  (long) SCHAR_MAX);
  757. #endif /* NO_SC */
  758.         }
  759.     }
  760.     return bits_per_byte;
  761. }
  762.  
  763. int basic() {
  764.     /* The properties of the basic types.
  765.        Returns number of bits per sizeof unit */
  766.     volatile int bits_per_byte;
  767.  
  768.     bits_per_byte= cprop();
  769.  
  770.     /* Shorts, ints and longs *****************************************/
  771.     Vprintf("%sShort=%d int=%d long=%d float=%d double=%d bits %s\n",
  772.         co,
  773.         (int) sizeof(short)*bits_per_byte,
  774.         (int) sizeof(int)*bits_per_byte,
  775.         (int) sizeof(long)*bits_per_byte,
  776.         (int) sizeof(float)*bits_per_byte,
  777.         (int) sizeof(double)*bits_per_byte, oc);
  778.     if (stdc) {
  779.         Vprintf("%sLong double=%d bits%s\n",
  780.             co, (int) sizeof(Long_double)*bits_per_byte, oc);
  781.     }
  782.     Vprintf("%sChar pointers = %d bits%s%s\n",
  783.         co, (int)sizeof(char *)*bits_per_byte,
  784.         sizeof(char *)>sizeof(int)?" BEWARE! larger than int!":"",
  785.         oc);
  786.     Vprintf("%sInt pointers = %d bits%s%s\n",
  787.         co, (int)sizeof(int *)*bits_per_byte,
  788.         sizeof(int *)>sizeof(int)?" BEWARE! larger than int!":"",
  789.         oc);
  790.     sprop();
  791.     iprop();
  792.     lprop();
  793.     usprop();
  794.     uiprop();
  795.     ulprop();
  796.  
  797.     Unexpected(6);
  798.  
  799.     /* Alignment constants ********************************************/
  800.     Vprintf("%sAlignments used for char=%d short=%d int=%d long=%d%s\n",
  801.         co,
  802.         (int)sizeof(struct{char i1; char c1;})-(int)sizeof(char),
  803.         (int)sizeof(struct{short i2; char c2;})-(int)sizeof(short),
  804.         (int)sizeof(struct{int i3; char c3;})-(int)sizeof(int),
  805.         (int)sizeof(struct{long i4; char c4;})-(int)sizeof(long),
  806.         oc);
  807.  
  808.     /* Ten little endians *********************************************/
  809.  
  810.     endian(bits_per_byte);
  811.  
  812.     /* Pointers *******************************************************/
  813.     if (V) {
  814.         if ("abcd"=="abcd")
  815.             printf("%sStrings are shared%s\n", co, oc);
  816.         else printf("%sStrings are not shared%s\n", co, oc);
  817.     }
  818.  
  819.     return bits_per_byte;
  820. }
  821.  
  822. #endif /* ifndef PASS */
  823.  
  824. /* As I said, I apologise for the contortions below. The functions are
  825.    expanded by the preprocessor twice or three times (for float and double,
  826.    and maybe for long double, and for short, int and long). That way,
  827.    I never make a change to one that I forget to make to the other.
  828.    You can look on it as C's fault for not supporting multi-line macro's.
  829.    This whole file is read 3 times by the preprocessor, with PASSn set for
  830.    n=1, 2 or 3, to decide which parts to reprocess.
  831. */
  832.  
  833. /* #undef on an already undefined thing is (wrongly) flagged as an error
  834.    by some compilers, therefore the #ifdef that follows: 
  835. */
  836. #ifdef Number
  837. #undef Number
  838. #undef THING
  839. #undef Thing
  840. #undef thing
  841. #undef FPROP
  842. #undef Fname
  843. #undef Store
  844. #undef Sum
  845. #undef Diff
  846. #undef Mul
  847. #undef Div
  848. #undef Self
  849. #undef F_check
  850. #undef Validate
  851. #undef EPROP
  852. #undef MARK
  853.  
  854. #undef F_RADIX
  855. #undef F_MANT_DIG
  856. #undef F_DIG
  857. #undef F_ROUNDS
  858. #undef F_EPSILON
  859. #undef F_MIN_EXP
  860. #undef F_MIN
  861. #undef F_MIN_10_EXP
  862. #undef F_MAX_EXP
  863. #undef F_MAX
  864. #undef F_MAX_10_EXP
  865. #endif
  866.  
  867. #ifdef Integer
  868. #undef Integer
  869. #undef INT
  870. #undef IPROP
  871. #undef Iname
  872. #undef UPROP
  873. #undef Uname
  874. #undef OK_UI
  875.  
  876. #undef I_MAX
  877. #undef I_MIN
  878. #undef U_MAX
  879. #endif
  880.  
  881. #ifdef PASS1
  882.  
  883. #define Number float
  884. #define THING "FLOAT"
  885. #define Thing "Float"
  886. #define thing "float"
  887. #define Fname "FLT"
  888. #define FPROP fprop
  889. #define Store fStore
  890. #define Sum fSum
  891. #define Diff fDiff
  892. #define Mul fMul
  893. #define Div fDiv
  894. #define Self fSelf
  895. #define F_check fCheck
  896. #define Validate fValidate
  897. #define MARK "F"
  898.  
  899. #define EPROP efprop
  900.  
  901. #define Integer short
  902. #define INT "short"
  903. #define IPROP sprop
  904. #define Iname "SHRT"
  905. #ifndef NO_UI
  906. #define OK_UI 1
  907. #endif
  908.  
  909. #define UPROP usprop
  910. #define Uname "USHRT"
  911.  
  912. #ifdef VERIFY
  913. #define I_MAX SHRT_MAX
  914. #define I_MIN SHRT_MIN
  915. #define U_MAX USHRT_MAX
  916.  
  917. #define F_RADIX FLT_RADIX
  918. #define F_MANT_DIG FLT_MANT_DIG
  919. #define F_DIG FLT_DIG
  920. #define F_ROUNDS FLT_ROUNDS
  921. #define F_EPSILON FLT_EPSILON
  922. #define F_MIN_EXP FLT_MIN_EXP
  923. #define F_MIN FLT_MIN
  924. #define F_MIN_10_EXP FLT_MIN_10_EXP
  925. #define F_MAX_EXP FLT_MAX_EXP
  926. #define F_MAX FLT_MAX
  927. #define F_MAX_10_EXP FLT_MAX_10_EXP
  928. #endif /* VERIFY */
  929.  
  930. #endif /* PASS1 */
  931.  
  932. #ifdef PASS2
  933.  
  934. #define Number double
  935. #define THING "DOUBLE"
  936. #define Thing "Double"
  937. #define thing "double"
  938. #define Fname "DBL"
  939. #define FPROP dprop
  940. #define Store dStore
  941. #define Sum dSum
  942. #define Diff dDiff
  943. #define Mul dMul
  944. #define Div dDiv
  945. #define Self dSelf
  946. #define F_check dCheck
  947. #define Validate dValidate
  948. #define MARK ""
  949.  
  950. #define EPROP edprop
  951.  
  952. #define Integer int
  953. #define INT "int"
  954. #define IPROP iprop
  955. #define Iname "INT"
  956. #define OK_UI 1 /* Unsigned int is always possible */
  957.  
  958. #define UPROP uiprop
  959. #define Uname "UINT"
  960.  
  961. #ifdef VERIFY
  962. #define I_MAX INT_MAX
  963. #define I_MIN INT_MIN
  964. #define U_MAX UINT_MAX
  965.  
  966. #define F_MANT_DIG DBL_MANT_DIG
  967. #define F_DIG DBL_DIG
  968. #define F_EPSILON DBL_EPSILON
  969. #define F_MIN_EXP DBL_MIN_EXP
  970. #define F_MIN DBL_MIN
  971. #define F_MIN_10_EXP DBL_MIN_10_EXP
  972. #define F_MAX_EXP DBL_MAX_EXP
  973. #define F_MAX DBL_MAX
  974. #define F_MAX_10_EXP DBL_MAX_10_EXP
  975. #endif /* VERIFY */
  976.  
  977. #endif /* PASS2 */
  978.  
  979. #ifdef PASS3
  980.  
  981. #ifdef __STDC__
  982. #define Number long double
  983. #endif
  984.  
  985. #define THING "LONG DOUBLE"
  986. #define Thing "Long double"
  987. #define thing "long double"
  988. #define Fname "LDBL"
  989. #define FPROP ldprop
  990. #define Store ldStore
  991. #define Sum ldSum
  992. #define Diff ldDiff
  993. #define Mul ldMul
  994. #define Div ldDiv
  995. #define Self ldSelf
  996. #define F_check ldCheck
  997. #define Validate ldValidate
  998. #define MARK "L"
  999.  
  1000. #define EPROP eldprop
  1001.  
  1002. #define Integer long
  1003. #define INT "long"
  1004. #define IPROP lprop
  1005. #define Iname "LONG"
  1006. #ifndef NO_UI
  1007. #define OK_UI 1
  1008. #endif
  1009.  
  1010. #define UPROP ulprop
  1011. #define Uname "ULONG"
  1012.  
  1013. #ifdef VERIFY
  1014. #define I_MAX LONG_MAX
  1015. #define I_MIN LONG_MIN
  1016. #define U_MAX ULONG_MAX
  1017.  
  1018. #define F_MANT_DIG LDBL_MANT_DIG
  1019. #define F_DIG LDBL_DIG
  1020. #define F_EPSILON LDBL_EPSILON
  1021. #define F_MIN_EXP LDBL_MIN_EXP
  1022. #define F_MIN LDBL_MIN
  1023. #define F_MIN_10_EXP LDBL_MIN_10_EXP
  1024. #define F_MAX_EXP LDBL_MAX_EXP
  1025. #define F_MAX LDBL_MAX
  1026. #define F_MAX_10_EXP LDBL_MAX_10_EXP
  1027. #endif /* VERIFY */
  1028.  
  1029. #endif /* PASS3 */
  1030.  
  1031. #ifndef VERIFY
  1032. #define I_MAX int_max
  1033. #define I_MIN int_min
  1034. #define U_MAX int_max
  1035.  
  1036. #define F_RADIX f_radix
  1037. #define F_MANT_DIG f_mant_dig
  1038. #define F_DIG f_dig
  1039. #define F_ROUNDS f_rounds
  1040. #define F_EPSILON f_epsilon
  1041. #define F_MIN_EXP f_min_exp
  1042. #define F_MIN f_min
  1043. #define F_MIN_10_EXP f_min_10_exp
  1044. #define F_MAX_EXP f_max_exp
  1045. #define F_MAX f_max
  1046. #define F_MAX_10_EXP f_max_10_exp
  1047. #endif
  1048.  
  1049. Procedure IPROP() { /* for short, int, and long */
  1050.     volatile Integer newi, int_max, maxeri, int_min, minneri;
  1051.     volatile int ibits, ipower, two=2;
  1052.  
  1053.     /* Calculate max short/int/long ***********************************/
  1054.     /* Calculate 2**n-1 until overflow - then use the previous value  */
  1055.  
  1056.     newi=1; int_max=0;
  1057.  
  1058.     if (setjmp(lab)==0) { /* Yields int_max */
  1059.         for(ipower=0; newi>int_max; ipower++) {
  1060.             int_max=newi;
  1061.             newi=newi*two+1;
  1062.         }
  1063.         Vprintf("%sOverflow of a%s %s does not generate a trap%s\n",
  1064.             co, INT[0]=='i'?"n":"", INT, oc);
  1065.     } else {
  1066.         Vprintf("%sOverflow of a%s %s generates a trap%s\n",
  1067.             co, INT[0]=='i'?"n":"", INT, oc);
  1068.     }
  1069.     Unexpected(7);
  1070.  
  1071.     /* Minimum value: assume either two's or one's complement *********/
  1072.     int_min= -int_max;
  1073.     if (setjmp(lab)==0) { /* Yields int_min */
  1074.         if (int_min-1 < int_min) int_min--;
  1075.     }
  1076.     Unexpected(8);
  1077.  
  1078.     /* Now for those daft Cybers: */
  1079.  
  1080.     maxeri=0; newi=int_max;
  1081.  
  1082.     if (setjmp(lab)==0) { /* Yields maxeri */
  1083.         for(ibits=ipower; newi>maxeri; ibits++) {
  1084.             maxeri=newi;
  1085.             newi=newi+newi+1;
  1086.         }
  1087.     }
  1088.     Unexpected(9);
  1089.  
  1090.     minneri= -maxeri;
  1091.     if (setjmp(lab)==0) { /* Yields minneri */
  1092.         if (minneri-1 < minneri) minneri--;
  1093.     }
  1094.     Unexpected(10);
  1095.  
  1096.     Vprintf("%sMaximum %s = %ld (= 2**%d-1)%s\n",
  1097.         co, INT, (long)int_max, ipower, oc);
  1098.     Vprintf("%sMinimum %s = %ld%s\n", co, INT, (long)int_min, oc);
  1099.  
  1100.     if (L) i_define(Iname, "_MAX", (long) int_max, (long) I_MAX);
  1101.     if (L) i_define(Iname, "_MIN", (long) int_min, (long) I_MIN);
  1102.  
  1103.     if (maxeri>int_max) {
  1104.         Vprintf("%sThere is a larger %s, %ld (= 2**%d-1), %s %s%s\n",
  1105.             co, INT, (long)maxeri, ibits, 
  1106.             "but only for addition, not multiplication",
  1107.             "(I smell a Cyber!)",
  1108.             oc);
  1109.     }
  1110.  
  1111.     if (minneri<int_min) {
  1112.         Vprintf("%sThere is a smaller %s, %ld, %s %s%s\n",
  1113.             co, INT, (long)minneri, 
  1114.             "but only for addition, not multiplication",
  1115.             "(I smell a Cyber!)",
  1116.             oc);
  1117.     }
  1118. }
  1119.  
  1120. Procedure UPROP () { /* unsigned short/int/long */
  1121. #ifdef OK_UI
  1122.     volatile unsigned Integer int_max, newi, two;
  1123.     newi=1; int_max=0; two=2;
  1124.  
  1125.     if (setjmp(lab)==0) { /* Yields int_max */
  1126.         while(newi>int_max) {
  1127.             int_max=newi;
  1128.             newi=newi*two+1;
  1129.         }
  1130.     }
  1131.     Unexpected(11);
  1132.     Vprintf("%sMaximum unsigned %s = %lu%s\n",
  1133.         co, INT, (unsigned long) int_max, oc);
  1134.     if (L) u_define(Uname, "_MAX", (unsigned long) int_max,
  1135.             (unsigned long) U_MAX);
  1136. #endif
  1137. }
  1138.  
  1139.  
  1140. #ifdef Number
  1141.  
  1142. /* These routines are intended to defeat any attempt at optimisation
  1143.    or use of extended precision, and to defeat faulty narrowing casts:
  1144. */
  1145. Procedure Store(a, b) Number a, *b; { *b=a; }
  1146. Number Sum(a, b) Number a, b; { Number r; Store(a+b, &r); return (r); }
  1147. Number Diff(a, b) Number a, b; { Number r; Store(a-b, &r); return (r); }
  1148. Number Mul(a, b) Number a, b; { Number r; Store(a*b, &r); return (r); }
  1149. Number Div(a, b) Number a, b; { Number r; Store(a/b, &r); return (r); }
  1150. Number Self(a) Number a; { Number r; Store(a, &r); return (r); }
  1151.  
  1152. Procedure F_check(precision, val1) int precision; Long_double val1; {
  1153.     /* You don't think I'm going to go to all the trouble of writing
  1154.        a program that works out what all sorts of values are, only to
  1155.        have printf go and print the wrong values out, do you?
  1156.        No, you're right, so this function tries to see if printf
  1157.        has written the right value, by reading it back again.
  1158.        This introduces a new problem of course: suppose printf writes
  1159.        the correct value, and scanf reads it back wrong... oh well.
  1160.        But I'm adamant about this: the precision given is enough
  1161.        to uniquely identify the printed number, therefore I insist
  1162.        that sscanf read the number back identically. Harsh yes, but
  1163.        sometimes you've got to be cruel to be kind.
  1164.     */
  1165.     Long_double new1;
  1166.     Number val, new, diff;
  1167.     double rem;
  1168.     int e;
  1169.     char *rep;
  1170.     char *f2;
  1171.  
  1172.     if (sizeof(double) == sizeof(Long_double)) {
  1173.         /* Assume they're the same, and use non-stdc format */
  1174.         /* This is for stdc compilers using non-stdc libraries */
  1175.         f2= "%le";   /* Input */
  1176.     } else {
  1177.         /* It had better support Le then */
  1178.         f2= "%Le";
  1179.     }
  1180.     val= val1;
  1181.     rep= f_rep(precision, (Long_double) val);
  1182.     if (setjmp(lab)==0) {
  1183.         sscanf(rep, f2, &new1);
  1184.     } else {
  1185.         eek_a_bug("sscanf caused a trap");
  1186.         printf("%s    scanning: %s format: %s%s\n\n", co, rep, f2, oc);
  1187.         Unexpected(12);
  1188.         return;
  1189.     }
  1190.  
  1191.     if (setjmp(lab)==0) { /* See if new is usable */
  1192.         new= new1;
  1193.         if (new != 0.0) {
  1194.             diff= val/new - 1.0;
  1195.             if (diff < 0.1) diff= 1.0;
  1196.             /* That should be enough to generate a trap */
  1197.         }
  1198.     } else {
  1199.         eek_a_bug("sscanf returned an unusable number");
  1200.         printf("%s    scanning: %s with format: %s%s\n\n",
  1201.                co, rep, f2, oc);
  1202.         Unexpected(13);
  1203.         return;
  1204.     }
  1205.  
  1206.     Unexpected(14);
  1207.     if (new != val) {
  1208.         eek_a_bug("Possibly bad output from printf above");
  1209.         if (!exponent(val, &rem, &e)) {
  1210.             printf("%s    but value was an unusable number%s\n\n",
  1211.                    co, oc);
  1212.             return;
  1213.         }
  1214.         printf("%s    expected value around %.*fe%d, bit pattern:\n    ",
  1215.                co, precision, rem, e);
  1216.         bitpattern((char *) &val, sizeof(val));
  1217.         printf ("%s\n", oc);
  1218.         printf("%s    sscanf gave           %s, bit pattern:\n    ",
  1219.                co, f_rep(precision, (Long_double) new));
  1220.         bitpattern((char *) &new, sizeof(new));
  1221.         printf ("%s\n", oc);
  1222.         printf("%s    difference= %s%s\n\n", 
  1223.                co, f_rep(precision, (Long_double) (val-new)), oc);
  1224.     }
  1225. }
  1226.  
  1227. Procedure Validate(prec, val, req, same) int prec, same; Long_double val, req; {
  1228.     Unexpected(15);
  1229.     if (!same) {
  1230.         printf("%s*** Verify failed for above #define!\n", co);
  1231.         if (setjmp(lab) == 0) { /* for the case that req == nan */
  1232.             printf("       Compiler has %s for value%s\n", 
  1233.                    f_rep(prec, req), oc);
  1234.         } else {
  1235.             printf("       Compiler has %s for value%s\n",
  1236.                    "an unusable number", oc);
  1237.         }
  1238.         if (setjmp(lab) == 0) {
  1239.             F_check(prec, (Long_double) req);
  1240.         } /*else forget it*/
  1241.         if (setjmp(lab) == 0) {        
  1242.             if (req > 0.0 && val > 0.0) {
  1243.                 printf("%s    difference= %s%s\n",
  1244.                        co, f_rep(prec, val-req), oc);
  1245.             }
  1246.         } /*else forget it*/
  1247.         Unexpected(16);
  1248.         printf("\n");
  1249.         bugs++;
  1250.     } else if (val != req) {
  1251.         if (stdc) {
  1252.             printf("%s*** Verify failed for above #define!\n", co);
  1253.             printf("       Constant has the wrong precision%s\n",
  1254.                    oc);
  1255.             bugs++;
  1256.         } else eek_a_bug("the cast didn't work");
  1257.         printf("\n");
  1258.     }
  1259. }
  1260.  
  1261. int FPROP(bits_per_byte) int bits_per_byte; {
  1262.     /* Properties of floating types, using algorithms by Cody and Waite
  1263.        from MA Malcolm, as modified by WM Gentleman and SB Marovich.
  1264.        Further extended by S Pemberton.
  1265.  
  1266.        Returns the number of digits in the fraction.
  1267.     */
  1268.  
  1269.     volatile int i, f_radix, iexp, irnd, mrnd, f_rounds, f_mant_dig,
  1270.         iz, k, inf, machep, f_max_exp, f_min_exp, mx, negeps,
  1271.         mantbits, digs, f_dig, trap,
  1272.         hidden, normal, f_min_10_exp, f_max_10_exp;
  1273.     volatile Number a, b, base, basein, basem1, f_epsilon, epsneg,
  1274.            f_max, newxmax, f_min, xminner, y, y1, z, z1, z2;
  1275.  
  1276.     Unexpected(17);
  1277.  
  1278.     Vprintf("%sPROPERTIES OF %s:%s\n", co, THING, oc);
  1279.  
  1280.     /* Base and size of mantissa **************************************/
  1281.     /* First repeatedly double until adding 1 has no effect.      */
  1282.     /* For instance, if base is 10, with 3 significant digits      */
  1283.     /* it will try 1, 2, 4, 8, ... 512, 1024, and stop there,      */
  1284.     /* since 1024 is only representable as 1020.              */
  1285.     a=1.0;
  1286.     if (setjmp(lab)==0) { /* inexact trap? */
  1287.         do { a=Sum(a, a); }
  1288.         while (Diff(Diff(Sum(a, 1.0), a), 1.0) == 0.0);
  1289.     } else {
  1290.         fprintf(stderr, "*** Program got loss-of-precision trap!\n");
  1291.         /* And supporting those is just TOO much trouble! */
  1292.         exit(bugs+1);
  1293.     }
  1294.     Unexpected(18);
  1295.     /* Now double until you find a number that can be added to the      */
  1296.     /* above number. For 1020 this is 8 or 16, depending whether the  */
  1297.     /* result is rounded or truncated.                  */
  1298.     /* In either case the result is 1030. 1030-1020= the base, 10.      */
  1299.     b=1.0;
  1300.     do { b=Sum(b, b); } while ((base=Diff(Sum(a, b), a)) == 0.0);
  1301.     f_radix=base;
  1302.     Vprintf("%sBase = %d%s\n", co, f_radix, oc);
  1303.  
  1304.     /* Sanity check; if base<2, I can't guarantee the rest will work  */
  1305.     if (f_radix < 2) {
  1306.         eek_a_bug("Function return or parameter passing faulty? (This is a guess.)");
  1307.         printf("\n");
  1308.         return(0);
  1309.     }
  1310.  
  1311. #ifdef PASS1 /* only for FLT */
  1312.     if (F) i_define("FLT", "_RADIX", (long) f_radix, (long) F_RADIX);
  1313. #endif
  1314.  
  1315.     /* Now the number of digits precision: */
  1316.     f_mant_dig=0; b=1.0;
  1317.     do { f_mant_dig++; b=Mul(b, base); }
  1318.     while (Diff(Diff(Sum(b,1.0),b),1.0) == 0.0);
  1319.     f_dig=floor_log(10, (Long_double)(b/base)) + (base==10?1:0);
  1320.     Vprintf("%sSignificant base digits = %d %s %d %s%s\n",
  1321.         co, f_mant_dig, "(= at least", f_dig, "decimal digits)", oc);
  1322.     if (F) i_define(Fname, "_MANT_DIG", (long) f_mant_dig,
  1323.             (long) F_MANT_DIG);
  1324.     if (F) i_define(Fname, "_DIG", (long) f_dig, (long) F_DIG);
  1325.     digs= ceil_log(10, (Long_double)b); /* the number of digits to printf */
  1326.  
  1327.     /* Rounding *******************************************************/
  1328.     basem1=Diff(base, 0.5);
  1329.     if (Diff(Sum(a, basem1), a) != 0.0) {
  1330.         if (f_radix == 2) basem1=0.375;
  1331.         else basem1=1.0;
  1332.         if (Diff(Sum(a, basem1), a) != 0.0) irnd=2; /* away from 0 */
  1333.         else irnd=1; /* to nearest */
  1334.     } else irnd=0; /* towards 0 */
  1335.  
  1336.     basem1=Diff(base, 0.5);
  1337.  
  1338.     if (Diff(Diff(-a, basem1), -a) != 0.0) {
  1339.         if (f_radix == 2) basem1=0.375;
  1340.         else basem1=1.0;
  1341.         if (Diff(Diff(-a, basem1), -a) != 0.0) mrnd=2; /* away from 0*/
  1342.         else mrnd=1; /* to nearest */
  1343.     } else mrnd=0; /* towards 0 */
  1344.  
  1345.     f_rounds=4; /* Unknown rounding */
  1346.     if (irnd==0 && mrnd==0) f_rounds=0; /* zero = chops */
  1347.     if (irnd==1 && mrnd==1) f_rounds=1; /* nearest */
  1348.     if (irnd==2 && mrnd==0) f_rounds=2; /* +inf */
  1349.     if (irnd==0 && mrnd==2) f_rounds=3; /* -inf */
  1350.  
  1351.     if (f_rounds != 4) {
  1352.         Vprintf("%sArithmetic rounds towards ", co);
  1353.         switch (f_rounds) {
  1354.               case 0: Vprintf("zero (i.e. it chops)"); break;
  1355.               case 1: Vprintf("nearest"); break;
  1356.               case 2: Vprintf("+infinity"); break;
  1357.               case 3: Vprintf("-infinity"); break;
  1358.               default: Vprintf("???"); break;
  1359.         }
  1360.         Vprintf("%s\n", oc);
  1361.     } else { /* Hmm, try to give some help here: */
  1362.         Vprintf("%sArithmetic rounds oddly: %s\n", co, oc);
  1363.         Vprintf("%s    Negative numbers %s%s\n",
  1364.             co, mrnd==0 ? "towards zero" :
  1365.                 mrnd==1 ? "to nearest" :
  1366.                       "away from zero",
  1367.             oc);
  1368.         Vprintf("%s    Positive numbers %s%s\n",
  1369.             co, irnd==0 ? "towards zero" :
  1370.                 irnd==1 ? "to nearest" :
  1371.                       "away from zero",
  1372.             oc);
  1373.     }
  1374.     /* An extra goody */
  1375.     if (f_radix == 2 && f_rounds == 1) {
  1376.         if (Diff(Sum(a, 1.0), a) != 0.0) {
  1377.             Vprintf("%s   Tie breaking rounds up%s\n", co, oc);
  1378.         } else if (Diff(Sum(a, 3.0), a) == 4.0) {
  1379.             Vprintf("%s   Tie breaking rounds to even%s\n", co, oc);
  1380.         } else {
  1381.             Vprintf("%s   Tie breaking rounds down%s\n", co, oc);
  1382.         }
  1383.     }
  1384. #ifdef PASS1 /* only for FLT */
  1385.     if (F) i_define("FLT", "_ROUNDS", (long) f_rounds, (long) F_ROUNDS);
  1386. #endif
  1387.  
  1388.     /* Various flavours of epsilon ************************************/
  1389.     negeps=f_mant_dig+f_mant_dig;
  1390.     basein=1.0/base;
  1391.     a=1.0;
  1392.     for(i=1; i<=negeps; i++) a*=basein;
  1393.  
  1394.     b=a;
  1395.     while (Diff(Diff(1.0, a), 1.0) == 0.0) {
  1396.         a*=base;
  1397.         negeps--;
  1398.     }
  1399.     negeps= -negeps;
  1400.     Vprintf("%sSmallest x such that 1.0-base**x != 1.0 = %d%s\n",
  1401.         co, negeps, oc);
  1402.  
  1403.     epsneg=a;
  1404.     if ((f_radix!=2) && irnd) {
  1405.     /*    a=(a*(1.0+a))/(1.0+1.0); => */
  1406.         a=Div(Mul(a, Sum(1.0, a)), Sum(1.0, 1.0));
  1407.     /*    if ((1.0-a)-1.0 != 0.0) epsneg=a; => */
  1408.         if (Diff(Diff(1.0, a), 1.0) != 0.0) epsneg=a;
  1409.     }
  1410.     Vprintf("%sSmall x such that 1.0-x != 1.0 = %s%s\n",
  1411.         co, f_rep(digs, (Long_double) epsneg), oc);
  1412.     /* it may not be the smallest */
  1413.     if (V) F_check(digs, (Long_double) epsneg);
  1414.     Unexpected(19);
  1415.  
  1416.     machep= -f_mant_dig-f_mant_dig;
  1417.     a=b;
  1418.     while (Diff(Sum(1.0, a), 1.0) == 0.0) { a*=base; machep++; }
  1419.     Vprintf("%sSmallest x such that 1.0+base**x != 1.0 = %d%s\n",
  1420.         co, machep, oc);
  1421.  
  1422.     f_epsilon=a;
  1423.     if ((f_radix!=2) && irnd) {
  1424.     /*    a=(a*(1.0+a))/(1.0+1.0); => */
  1425.         a=Div(Mul(a, Sum(1.0, a)), Sum(1.0, 1.0));
  1426.     /*    if ((1.0+a)-1.0 != 0.0) f_epsilon=a; => */
  1427.         if (Diff(Sum(1.0, a), 1.0) != 0.0) f_epsilon=a;
  1428.     }
  1429.     Vprintf("%sSmallest x such that 1.0+x != 1.0 = %s%s\n",
  1430.         co, f_rep(digs, (Long_double) f_epsilon), oc);
  1431.     /* Possible loss of precision warnings here from non-stdc compilers: */
  1432.     if (F) f_define(Fname, "_EPSILON", digs, (Long_double) f_epsilon, MARK);
  1433.     if (V || F) F_check(digs, (Long_double) f_epsilon);
  1434.     Unexpected(20);
  1435.     if (F) Validate(digs, (Long_double) f_epsilon, (Long_double) F_EPSILON,
  1436.             f_epsilon == Self(F_EPSILON));
  1437.     Unexpected(21);
  1438.  
  1439.     /* Extra chop info *************************************************/
  1440.     if (f_rounds == 0) {
  1441.         if (Diff(Mul(Sum(1.0,f_epsilon),1.0),1.0) !=  0.0) {
  1442.             Vprintf("%sAlthough arithmetic chops, it uses guard digits%s\n", co, oc);
  1443.         }
  1444.     }
  1445.  
  1446.     /* Size of and minimum normalised exponent ************************/
  1447.     y=0; i=0; k=1; z=basein; z1=(1.0+f_epsilon)/base;
  1448.  
  1449.     /* Coarse search for the largest power of two */
  1450.     if (setjmp(lab)==0) { /* for underflow trap */ /* Yields i, k, y, y1 */
  1451.         do {
  1452.             y=z; y1=z1;
  1453.             z=Mul(y,y); z1=Mul(z1, y);
  1454.             a=Mul(z,1.0);
  1455.             z2=Div(z1,y);
  1456.             if (z2 != y1) break;
  1457.             if ((Sum(a,a) == 0.0) || (fabs(z) >= y)) break;
  1458.             i++;
  1459.             k+=k;
  1460.         } while(1);
  1461.     } else {
  1462.         Vprintf("%s%s underflow generates a trap%s\n", co, Thing, oc);
  1463.     }
  1464.     Unexpected(22);
  1465.  
  1466.     if (f_radix != 10) {
  1467.         iexp=i+1; /* for the sign */
  1468.         mx=k+k;
  1469.     } else {
  1470.         iexp=2;
  1471.         iz=f_radix;
  1472.         while (k >= iz) { iz*=f_radix; iexp++; }
  1473.         mx=iz+iz-1;
  1474.     }
  1475.  
  1476.     /* Fine tune starting with y and y1 */
  1477.     if (setjmp(lab)==0) { /* for underflow trap */ /* Yields k, f_min */
  1478.         do {
  1479.             f_min=y; z1=y1;
  1480.             y=Div(y,base); y1=Div(y1,base);
  1481.             a=Mul(y,1.0);
  1482.             z2=Mul(y1,base);
  1483.             if (z2 != z1) break;
  1484.             if ((Sum(a,a) == 0.0) || (fabs(y) >= f_min)) break;
  1485.             k++;
  1486.         } while (1);
  1487.     }
  1488.     Unexpected(23);
  1489.  
  1490.     f_min_exp=(-k)+1;
  1491.  
  1492.     if ((mx <= k+k-3) && (f_radix != 10)) { mx+=mx; iexp+=1; }
  1493.     Vprintf("%sNumber of bits used for exponent = %d%s\n", co, iexp, oc);
  1494.     Vprintf("%sMinimum normalised exponent = %d%s\n", co, f_min_exp, oc);
  1495.     if (F) i_define(Fname, "_MIN_EXP", (long) f_min_exp, (long) F_MIN_EXP);
  1496.  
  1497.     if (setjmp(lab)==0) {
  1498.         Vprintf("%sMinimum normalised positive number = %s%s\n",
  1499.             co, f_rep(digs, (Long_double) f_min), oc);
  1500.     } else {
  1501.         eek_a_bug("printf can't print the smallest normalised number");
  1502.         printf("\n");
  1503.     }
  1504.     Unexpected(24);
  1505.     /* Possible loss of precision warnings here from non-stdc compilers: */
  1506.     if (setjmp(lab) == 0) {
  1507.         if (F) f_define(Fname, "_MIN", digs, (Long_double) f_min, MARK);
  1508.         if (V || F) F_check(digs, (Long_double) f_min);
  1509.     } else {
  1510.         eek_a_bug("xxx_MIN caused a trap");
  1511.         printf("\n");
  1512.     }
  1513.  
  1514.     if (setjmp(lab) == 0) {
  1515.         if (F) Validate(digs, (Long_double) f_min, (Long_double) F_MIN,
  1516.                 f_min == Self(F_MIN));
  1517.     } else {
  1518.         printf("%s*** Verify failed for above #define!\n    %s %s\n\n",
  1519.                co, "Compiler has an unusable number for value", oc);
  1520.         bugs++;
  1521.     }
  1522.     Unexpected(25);
  1523.  
  1524.     a=1.0; f_min_10_exp=0;
  1525.     while (a > f_min*10.0) { a/=10.0; f_min_10_exp--; }
  1526.     if (F) i_define(Fname, "_MIN_10_EXP", (long) f_min_10_exp,
  1527.             (long) F_MIN_10_EXP);
  1528.  
  1529.     /* Minimum exponent ************************************************/
  1530.     if (setjmp(lab)==0) { /* for underflow trap */ /* Yields xminner */
  1531.         do {
  1532.             xminner=y;
  1533.             y=Div(y,base);
  1534.             a=Mul(y,1.0);
  1535.             if ((Sum(a,a) == 0.0) || (fabs(y) >= xminner)) break;
  1536.         } while (1);
  1537.     }
  1538.     Unexpected(26);
  1539.  
  1540.     if (xminner != 0.0 && xminner != f_min) {
  1541.         normal= 0;
  1542.         Vprintf("%sThe smallest numbers are not kept normalised%s\n",
  1543.             co, oc);
  1544.         if (setjmp(lab)==0) {
  1545.             Vprintf("%sSmallest unnormalised positive number = %s%s\n",
  1546.                 co, f_rep(digs, (Long_double) xminner), oc);
  1547.             if (V) F_check(digs, (Long_double) xminner);
  1548.         } else {
  1549.             eek_a_bug("printf can't print the smallest unnormalised number.");
  1550.             printf("\n");
  1551.         }
  1552.         Unexpected(27);
  1553.     } else {
  1554.         normal= 1;
  1555.         Vprintf("%sThe smallest numbers are normalised%s\n", co, oc);
  1556.     }
  1557.  
  1558.     /* Maximum exponent ************************************************/
  1559.     f_max_exp=2; f_max=1.0; newxmax=base+1.0;
  1560.     inf=0; trap=0;
  1561.     while (f_max<newxmax) {
  1562.         f_max=newxmax;
  1563.         if (setjmp(lab) == 0) { /* Yields inf, f_max_exp */
  1564.             newxmax=Mul(newxmax, base);
  1565.         } else {
  1566.             trap=1;
  1567.             break;
  1568.         }
  1569.         if (Div(newxmax, base) != f_max) {
  1570.             inf=1; /* ieee infinity */
  1571.             break;
  1572.         }
  1573.         f_max_exp++;
  1574.     }
  1575.     Unexpected(28);
  1576.     if (trap) {
  1577.         Vprintf("%s%s overflow generates a trap%s\n", co, Thing, oc);
  1578.     }
  1579.  
  1580.     if (inf) Vprintf("%sThere is an 'infinite' value%s\n", co, oc);
  1581.     Vprintf("%sMaximum exponent = %d%s\n", co, f_max_exp, oc);
  1582.     if (F) i_define(Fname, "_MAX_EXP", (long) f_max_exp, (long) F_MAX_EXP);
  1583.  
  1584.     /* Largest number ***************************************************/
  1585.     f_max=Diff(1.0, epsneg);
  1586.     if (Mul(f_max,1.0) != f_max) f_max=Diff(1.0, Mul(base,epsneg));
  1587.     for (i=1; i<=f_max_exp; i++) f_max=Mul(f_max, base);
  1588.  
  1589.     if (setjmp(lab)==0) {
  1590.         Vprintf("%sMaximum number = %s%s\n",
  1591.             co, f_rep(digs, (Long_double) f_max), oc);
  1592.     } else {
  1593.         eek_a_bug("printf can't print the largest double.");
  1594.         printf("\n");
  1595.     }
  1596.     if (setjmp(lab)==0) {
  1597.     /* Possible loss of precision warnings here from non-stdc compilers: */
  1598.         if (F) f_define(Fname, "_MAX", digs, (Long_double) f_max, MARK);
  1599.         if (V || F) F_check(digs, (Long_double) f_max);
  1600.     } else {
  1601.         eek_a_bug("xxx_MAX caused a trap");
  1602.         printf("\n");
  1603.     }
  1604.     if (setjmp(lab)==0) {
  1605.         if (F) Validate(digs, (Long_double) f_max, (Long_double) F_MAX,
  1606.                 f_max == Self(F_MAX));
  1607.     } else {
  1608.         printf("%s*** Verify failed for above #define!\n    %s %s\n\n",
  1609.                co, "Compiler has an unusable number for value", oc);
  1610.         bugs++;
  1611.     }
  1612.     Unexpected(29);
  1613.  
  1614.     a=1.0; f_max_10_exp=0;
  1615.     while (a < f_max/10.0) { a*=10.0; f_max_10_exp++; }
  1616.     if (F) i_define(Fname, "_MAX_10_EXP", (long) f_max_10_exp,
  1617.             (long) F_MAX_10_EXP);
  1618.  
  1619.     /* Hidden bit + sanity check ****************************************/
  1620.     if (f_radix != 10) {
  1621.         hidden=0;
  1622.         mantbits=floor_log(2, (Long_double)f_radix)*f_mant_dig;
  1623.         if (mantbits+iexp == (int)sizeof(Number)*bits_per_byte) {
  1624.             hidden=1;
  1625.             Vprintf("%sArithmetic uses a hidden bit%s\n", co, oc);
  1626.         } else if (mantbits+iexp+1 == (int)sizeof(Number)*bits_per_byte) {
  1627.             Vprintf("%sArithmetic doesn't use a hidden bit%s\n",
  1628.                 co, oc);
  1629.         } else {
  1630.             printf("\n%s%s\n    %s %s %s!%s\n\n",
  1631.                    co,
  1632.                    "*** Something fishy here!",
  1633.                    "Exponent size + mantissa size doesn't match",
  1634.                    "with the size of a", thing,
  1635.                    oc);
  1636.         }
  1637.         if (hidden && f_radix == 2 && f_max_exp+f_min_exp==3) {
  1638.             Vprintf("%sIt looks like %s length IEEE format%s\n",
  1639.                 co, f_mant_dig==24 ? "single" :
  1640.                     f_mant_dig==53 ? "double" :
  1641.                     f_mant_dig >53 ? "extended" :
  1642.                         "some", oc);
  1643.             if (f_rounds != 1 || normal) {
  1644.                 Vprintf("%s   though ", co);
  1645.                 if (f_rounds != 1) {
  1646.                     Vprintf("the rounding is unusual");
  1647.                     if (normal) Vprintf(" and ");
  1648.                 }
  1649.                 if (normal) Vprintf("the normalisation is unusual");
  1650.                 Vprintf("%s\n", oc);
  1651.             }
  1652.         } else {
  1653.             Vprintf("%sIt doesn't look like IEEE format%s\n",
  1654.                 co, oc);
  1655.         }
  1656.     }
  1657.     printf("\n"); /* regardless of verbosity */
  1658.     return f_mant_dig;
  1659. }
  1660.  
  1661. Procedure EPROP(fprec, dprec, lprec) int fprec, dprec, lprec; {
  1662.     /* See if expressions are evaluated in extended precision.
  1663.        Some compilers optimise even if you don't want it,
  1664.        and then this function fails to produce the right result.
  1665.        We try to diagnose this if it happens.
  1666.     */
  1667.     volatile int eprec;
  1668.     volatile double a, b, base, old;
  1669.     volatile Number d, oldd, dbase, one, zero;
  1670.     volatile int bad=0;
  1671.  
  1672.     /* Size of mantissa **************************************/
  1673.     a=1.0;
  1674.     if (setjmp(lab) == 0) { /* Yields nothing */
  1675.         do { old=a; a=a+a; }
  1676.         while ((((a+1.0)-a)-1.0) == 0.0 && a>old);
  1677.     } else bad=1;
  1678.     if (a <= old) bad=1;
  1679.  
  1680.     if (!bad) {
  1681.         b=1.0;
  1682.         if (setjmp(lab) == 0) { /* Yields nothing */
  1683.             do { old=b; b=b+b; }
  1684.             while ((base=((a+b)-a)) == 0.0 && b>old);
  1685.             if (b <= old) bad=1;
  1686.         } else bad=1;
  1687.     }
  1688.  
  1689.     if (!bad) {
  1690.         eprec=0; d=1.0; dbase=base; one=1.0; zero=0.0;
  1691.         if (setjmp(lab) == 0) { /* Yields nothing */
  1692.             do { eprec++; oldd=d; d=d*dbase; }
  1693.             while ((((d+one)-d)-one) == zero && d>oldd);
  1694.             if (d <= oldd) bad=1;
  1695.         } else bad=1;
  1696.     }
  1697.  
  1698.     Unexpected(30);
  1699.  
  1700.     if (bad) {
  1701.       Vprintf("%sCan't determine precision for %s expressions:\n%s%s\n", 
  1702.          co, thing, "   check that you compiled without optimisation!",
  1703.          oc);
  1704.     } else if (eprec==dprec) {
  1705.       Vprintf("%s%s expressions are evaluated in double precision%s\n",
  1706.           co, Thing, oc);
  1707.     } else if (eprec==fprec) {
  1708.       Vprintf("%s%s expressions are evaluated in float precision%s\n",
  1709.           co, Thing, oc);
  1710.     } else if (eprec==lprec) {
  1711.       Vprintf("%s%s expressions are evaluated in long double precision%s\n",
  1712.           co, Thing, oc);
  1713.     } else {
  1714.         Vprintf("%s%s expressions are evaluated in a %s %s %d %s%s\n",
  1715.             co, Thing, eprec>dprec ? "higher" : "lower",
  1716.             "precision than double,\n   using",
  1717.             eprec, "base digits",
  1718.                 oc);
  1719.     }
  1720. }
  1721.  
  1722. #else /* Number */
  1723.  
  1724. #ifdef FPROP
  1725. /* ARGSUSED */
  1726. int FPROP(bits_per_byte) int bits_per_byte; {
  1727.     return 0;
  1728. }
  1729. #endif
  1730. #ifdef EPROP
  1731. /* ARGSUSED */
  1732. Procedure EPROP(fprec, dprec, lprec) int fprec, dprec, lprec; {}
  1733. #endif
  1734.  
  1735. #endif /* ifdef Number */
  1736.  
  1737. #ifdef PASS3
  1738. #undef PASS
  1739. #endif
  1740.  
  1741. #ifdef PASS2
  1742. #undef PASS2
  1743. #define PASS3 1
  1744. #endif
  1745.  
  1746. #ifdef PASS1
  1747. #undef PASS1
  1748. #define PASS2 1
  1749. #endif
  1750.  
  1751. /* If your C compiler doesn't accept the next #include,
  1752.    replace __FILE__ with the file name - and get a new C compiler... */
  1753.  
  1754. #ifdef PASS
  1755. #include __FILE__
  1756. #endif
  1757.  
  1758.