2 !!DESCRIPTION!! C-Manual Chapter 6.2: Float and double, 6.3 Floating and integral, 6.4 Pointers and integers, 6.5 Unsigned, 6.6 Arithmetic conversions
3 !!ORIGIN!! LCC 4.1 Testsuite
4 !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
8 int cbits; /* No. of bits per char */
10 int sbits; /* short */
12 int ubits; /* unsigned */
13 int fbits; /* float */
14 int dbits; /* double */
16 float fprec; /* Smallest number that can be */
17 float dprec; /* significantly added to 1. */
19 int flgs; /* Print return codes, by section */
20 int flgm; /* Announce machine dependencies */
21 int flgd; /* give explicit diagnostics */
22 int flgl; /* Report local return codes. */
23 int rrc; /* recent return code */
24 int crc; /* Cumulative return code */
25 char rfs[8]; /* Return from section */
29 int ubits; /* unsigned */
30 int fbits; /* float */
31 int dbits; /* double */
33 float fprec; /* Smallest number that can be */
34 float dprec; /* significantly added to 1. */
36 int flgs; /* Print return codes, by section */
37 int flgm; /* Announce machine dependencies */
38 int flgd; /* give explicit diagnostics */
39 int flgl; /* Report local return codes. */
40 int rrc; /* recent return code */
41 int crc; /* Cumulative return code */
42 char rfs[8]; /* Return from section */
46 section s26, which pokes around at the hardware
47 trying to figure out the characteristics of the machine that
48 it is running on, saves information that is subsequently
49 used by sections s626, s72, and s757. If this program is
50 to be broken up into smallish pieces, say for running on
51 a microcomputer, take care to see that s26 is called before
52 calling any of the latter three sections.
56 2.6 Hardware Characteristics
59 #ifndef NO_OLD_FUNC_DECL
64 s26(struct defs *pd0) {
66 static char qs26[8] = "s26 ";
70 float temp, one, delta;
73 static char s[] = "%3d bits in %ss.\n";
74 static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
81 /* Here, we shake the machinery a little to see what falls
82 out. First, we find out how many bits are in a char. */
90 pd0->cbits = pd0->cbits+1;
92 /* That information lets us determine the size of everything else. */
94 pd0->ibits = pd0->cbits * sizeof(int);
95 pd0->sbits = pd0->cbits * sizeof(short);
96 pd0->lbits = pd0->cbits * sizeof(long);
97 pd0->ubits = pd0->cbits * sizeof(unsigned);
99 pd0->fbits = pd0->cbits * sizeof(float);
100 pd0->dbits = pd0->cbits * sizeof(double);
103 /* We have now almost reconstructed the table in section 2.6, the
104 exception being the range of the floating point hardware.
105 Now there are just so many ways to conjure up a floating point
106 representation system that it's damned near impossible to guess
107 what's going on by writing a program to interpret bit patterns.
108 Further, the information isn't all that useful, if we consider
109 the fact that machines that won't handle numbers between 10**30
110 and 10**-30 are very hard to find, and that people playing with
111 numbers outside that range have a lot more to worry about than
112 just the capacity of the characteristic.
114 A much more useful measure is the precision, which can be ex-
115 pressed in terms of the smallest number that can be added to
116 1. without loss of significance. We calculate that here, for
127 pd0->fprec = delta * 4.;
131 while(tempd != oned) {
135 pd0->dprec = delta * 4.;
138 /* Now, if anyone's interested, we publish the results. */
140 #ifndef CQ26_INCLUDED
142 printf(s,pd0->cbits,"char");
143 printf(s,pd0->ibits,"int");
144 printf(s,pd0->sbits,"short");
145 printf(s,pd0->lbits,"long");
146 printf(s,pd0->ubits,"unsigned");
147 printf(s,pd0->fbits,"float");
148 printf(s,pd0->dbits,"double");
150 printf(s2,pd0->fprec,"float");
151 printf(s2,pd0->dprec,"double");
153 printf("NO_FLOATS\n");
157 /* Since we are only exploring and perhaps reporting, but not
158 testing any features, we cannot return an error code. */
165 #ifndef NO_OLD_FUNC_DECL
166 s626(pd0) /* 6.2 Float and double */
167 /* 6.3 Floating and integral */
168 /* 6.4 Pointers and integers */
170 /* 6.6 Arithmetic conversions */
174 int s626(struct defs *pd0){
176 static char s626er[] = "s626,er%d\n";
177 static char qs626[8] = "s626 ";
181 float eps, f1, f2, f3, f4, f;
183 long lint1, lint2, l, ls;
194 while (*pt++ = *ps++);
198 /* Conversions of integral values to floating type are
205 for(j=0;j<pd0->lbits-2;j++){
207 lint2 = (lint2<<1)|lint1;
211 if(f1>2.*pd0->fprec){
213 if(pd0->flgd != 0) printf(s626er,2);
216 /* Pointer-integer combinations are discussed in s74,
217 "Additive operators". The unsigned-int combination
226 d = 125.; ds = 15625.;
228 for(j=0;j<28;j++) t[j] = 0;
230 if(c*c != is) t[ 0] = 1;
231 if(s*c != is) t[ 1] = 1;
232 if(s*s != is) t[ 2] = 1;
233 if(i*c != is) t[ 3] = 1;
234 if(i*s != is) t[ 4] = 1;
235 if(i*i != is) t[ 5] = 1;
236 if(u*c != us) t[ 6] = 1;
237 if(u*s != us) t[ 7] = 1;
238 if(u*i != us) t[ 8] = 1;
239 if(u*u != us) t[ 9] = 1;
240 if(l*c != ls) t[10] = 1;
241 if(l*s != ls) t[11] = 1;
242 if(l*i != ls) t[12] = 1;
243 if(l*u != us) t[13] = 1;
244 if(l*l != ls) t[14] = 1;
245 if(f*c != ds) t[15] = 1;
246 if(f*s != ds) t[16] = 1;
247 if(f*i != ds) t[17] = 1;
248 if(f*u != ds) t[18] = 1;
249 if(f*l != ds) t[19] = 1;
250 if(f*f != ds) t[20] = 1;
251 if(d*c != ds) t[21] = 1;
252 if(d*s != ds) t[22] = 1;
253 if(d*i != ds) t[23] = 1;
254 if(d*u != ds) t[24] = 1;
255 if(d*l != ds) t[25] = 1;
256 if(d*f != ds) t[26] = 1;
257 if(d*d != ds) t[27] = 1;
260 for(j=0; j<28; j++) t0 = t0+t[j];
267 for(j=0;j<28;j++) printf("%d",t[j]);
274 /* When an unsigned integer is converted to long,
275 the value of the result is the same numerically
276 as that of the unsigned integer. */
278 l = (unsigned)0100000;
279 if((long)l > (unsigned)0100000){
281 if(pd0->flgd != 0) printf(s626er,8);
287 /*********************************************************************************************
288 the main loop that launches the sections
289 *********************************************************************************************/
291 #ifndef NO_TYPELESS_STRUCT_PTR
292 int section(int j,struct* pd0){
294 int section(int j,void* pd0){
297 case 0: return s26(pd0);
298 case 1: return s626(pd0);
302 #define cq_sections 2
305 C REFERENCE MANUAL (main)
308 #ifndef NO_OLD_FUNC_DECL
314 int main(int n,char **args) {
318 static struct defs d0, *pd0;
320 d0.flgs = 1; /* These flags dictate */
321 d0.flgm = 1; /* the verbosity of */
322 d0.flgd = 1; /* the program. */
327 for (j=0; j<cq_sections; j++) {
328 d0.rrc=section(j,pd0);
329 d0.crc=d0.crc+d0.rrc;
330 if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
333 if(d0.crc == 0) printf("\nNo errors detected.\n");
334 else printf("\nFailed.\n");