2 !!DESCRIPTION!! C-Manual Chapter 7.2: Unary Operators
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. */
163 #ifndef NO_OLD_FUNC_DECL
164 s72(pd0) /* 7.2 Unary operators */
168 int s72(struct defs *pd0){
170 static char s72er[] = "s72,er%d\n";
171 static char qs72[8] = "s72 ";
191 while (*pt++ = *ps++);
193 /* The *, denoting indirection, and the &, denoting a
194 pointer, are duals of each other, and ought to behave as
203 /* The unary minus has the conventional meaning. */
210 /* The negation operator (!) has been thoroughly checked out,
211 perhaps more thoroughly than any of the others. The ~ oper-
212 ator gets us a ones complement. */
215 for(j=0;j<pd0->ibits;j++) k = (k<<1)|1;
221 /* Now we look at the ++ and -- operators, which can be
222 used in either prefix or suffix form. With side
223 effects they're loaded. */
227 if( ++k != 6 || --k != 5
228 || k++ != 5 || k-- != 6
234 /* An expression preceded by the parenthesised name of a
235 data type causes conversion of the value of the expression
236 to the named type. This construction is called a cast.
237 Here, we check to see that all of the possible casts and
238 their simple combinations are accepted by the compiler,
239 and that they all produce a correct result for this sample
255 if( (char)s != 26 || (char)i != 26
256 || (char)l != 26 || (char)u != 26
257 || (char)f != 26 || (char)d != 26 ) lrc = lrc+1;
259 if( (short)c != 26 || (short)i != 26
260 || (short)l != 26 || (short)u != 26
261 || (short)f != 26 || (short)d != 26) lrc = lrc+2;
263 if( (int)c != 26 || (int)s != 26
264 || (int)l != 26 || (int)u != 26
265 || (int)f != 26 || (int)d != 26 ) lrc = lrc+4;
267 if( (long)c != 26 || (long)s != 26
268 || (long)i != 26 || (long)u != 26
269 || (long)f != 26 || (long)d != 26 ) lrc = lrc+8;
271 if( (unsigned)c != 26 || (unsigned)s != 26
272 || (unsigned)i != 26 || (unsigned)l != 26
273 || (unsigned)f != 26 || (unsigned)d != 26 ) lrc = lrc+16;
276 if( (float)c != 26. || (float)s != 26.
277 || (float)i != 26. || (float)l != 26.
278 || (float)u != 26. || (float)d != 26. ) lrc = lrc+32;
280 if( (double)c != 26. || (double)s != 26.
281 || (double)i != 26. || (double)l != 26.
282 || (double)u != 26. || (double)f != 26. ) lrc = lrc+64;
290 /* The sizeof operator has been tested previously. */
295 /*********************************************************************************************
296 the main loop that launches the sections
297 *********************************************************************************************/
299 #ifndef NO_TYPELESS_STRUCT_PTR
300 int section(int j,struct* pd0){
302 int section(int j,void* pd0){
305 case 0: return s26(pd0);
306 case 1: return s72(pd0);
310 #define cq_sections 2
313 C REFERENCE MANUAL (main)
316 #ifndef NO_OLD_FUNC_DECL
322 int main(int n,char **args) {
326 static struct defs d0, *pd0;
328 d0.flgs = 1; /* These flags dictate */
329 d0.flgm = 1; /* the verbosity of */
330 d0.flgd = 1; /* the program. */
335 for (j=0; j<cq_sections; j++) {
336 d0.rrc=section(j,pd0);
337 d0.crc=d0.crc+d0.rrc;
338 if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
341 if(d0.crc == 0) printf("\nNo errors detected.\n");
342 else printf("\nFailed.\n");