home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / compsrcs / misc / volume10 / config42 < prev    next >
Encoding:
Internet Message Format  |  1991-08-27  |  65.6 KB

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