]> git.sur5r.net Git - cc65/blob - test/val/cq72.c
All regression-tests subdirectories are cleaned before the first test starts, so...
[cc65] / test / val / cq72.c
1 /*
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
5 */
6
7 #include "common.h"
8
9 struct defs {
10      int cbits;          /* No. of bits per char           */
11      int ibits;          /*                 int            */
12      int sbits;          /*                 short          */
13      int lbits;          /*                 long           */
14      int ubits;          /*                 unsigned       */
15      int fbits;          /*                 float          */
16      int dbits;          /*                 double         */
17      #ifndef NO_FLOATS
18         float fprec;        /* Smallest number that can be    */
19         float dprec;        /* significantly added to 1.      */
20      #endif
21      int flgs;           /* Print return codes, by section */
22      int flgm;           /* Announce machine dependencies  */
23      int flgd;           /* give explicit diagnostics      */
24      int flgl;           /* Report local return codes.     */
25      int rrc;            /* recent return code             */
26      int crc;            /* Cumulative return code         */
27      char rfs[8];        /* Return from section            */
28 };
29
30      int lbits;          /*                 long           */
31      int ubits;          /*                 unsigned       */
32      int fbits;          /*                 float          */
33      int dbits;          /*                 double         */
34      #ifndef NO_FLOATS
35         float fprec;        /* Smallest number that can be    */
36         float dprec;        /* significantly added to 1.      */
37      #endif
38      int flgs;           /* Print return codes, by section */
39      int flgm;           /* Announce machine dependencies  */
40      int flgd;           /* give explicit diagnostics      */
41      int flgl;           /* Report local return codes.     */
42      int rrc;            /* recent return code             */
43      int crc;            /* Cumulative return code         */
44      char rfs[8];        /* Return from section            */
45
46 #define CQ26_INCLUDED
47 /*
48   section s26, which pokes around at the hardware
49   trying to figure out the characteristics of the machine that
50   it is running on, saves information that is subsequently
51   used by sections s626, s72, and s757. If this program is
52   to be broken up into smallish pieces, say for running on
53   a microcomputer, take care to see that s26 is called before
54   calling any of the latter three sections.
55 */
56
57 /*
58         2.6  Hardware Characteristics
59 */
60
61 #ifndef NO_OLD_FUNC_DECL
62 s26(pd0)
63 struct defs *pd0;
64 {
65 #else
66 s26(struct defs *pd0) {
67 #endif
68    static char qs26[8] = "s26    ";
69    char *ps, *pt;
70    char c0, c1;
71    #ifndef NO_FLOATS
72         float temp, one, delta;
73         double tempd, oned;
74    #endif
75    static char s[] = "%3d bits in %ss.\n";
76    static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
77
78    ps = qs26;
79    pt = pd0->rfs;
80
81    while(*pt++ = *ps++);
82
83           /* Here, we shake the machinery a little to see what falls
84              out.  First, we find out how many bits are in a char.  */
85
86    pd0->cbits = 0;
87    c0 = 0;
88    c1 = 1;
89
90    while(c0 != c1) {
91      c1 = c1<<1;
92      pd0->cbits = pd0->cbits+1;
93    }
94           /* That information lets us determine the size of everything else. */
95
96    pd0->ibits = pd0->cbits * sizeof(int);
97    pd0->sbits = pd0->cbits * sizeof(short);
98    pd0->lbits = pd0->cbits * sizeof(long);
99    pd0->ubits = pd0->cbits * sizeof(unsigned);
100    #ifndef NO_FLOATS
101         pd0->fbits = pd0->cbits * sizeof(float);
102         pd0->dbits = pd0->cbits * sizeof(double);
103    #endif
104
105           /* We have now almost reconstructed the table in section 2.6, the
106              exception being the range of the floating point hardware.
107              Now there are just so many ways to conjure up a floating point
108              representation system that it's damned near impossible to guess
109              what's going on by writing a program to interpret bit patterns.
110              Further, the information isn't all that useful, if we consider
111              the fact that machines that won't handle numbers between 10**30
112              and 10**-30 are very hard to find, and that people playing with
113              numbers outside that range have a lot more to worry about than
114              just the capacity of the characteristic.
115
116              A much more useful measure is the precision, which can be ex-
117              pressed in terms of the smallest number that can be added to
118              1. without loss of significance. We calculate that here, for
119              float and double.                       */
120
121 #ifndef NO_FLOATS
122    one = 1.;
123    delta = 1.;
124    temp = 0.;
125    while(temp != one) {
126      temp = one+delta;
127      delta = delta/2.;
128    }
129    pd0->fprec = delta * 4.;
130    oned = 1.;
131    delta = 1.;
132    tempd = 0.;
133    while(tempd != oned) {
134      tempd = oned+delta;
135      delta = delta/2.;
136    }
137    pd0->dprec = delta * 4.;
138 #endif
139
140           /* Now, if anyone's interested, we publish the results.       */
141
142 #ifndef CQ26_INCLUDED
143    if(pd0->flgm != 0) {
144      printf(s,pd0->cbits,"char");
145      printf(s,pd0->ibits,"int");
146      printf(s,pd0->sbits,"short");
147      printf(s,pd0->lbits,"long");
148      printf(s,pd0->ubits,"unsigned");
149      printf(s,pd0->fbits,"float");
150      printf(s,pd0->dbits,"double");
151      #ifndef NO_FLOATS
152         printf(s2,pd0->fprec,"float");
153         printf(s2,pd0->dprec,"double");
154      #else
155         printf("NO_FLOATS\n");
156      #endif
157    }
158 #endif
159           /* Since we are only exploring and perhaps reporting, but not
160              testing any features, we cannot return an error code.  */
161
162    return 0;
163 }
164
165 #ifndef NO_OLD_FUNC_DECL
166 s72(pd0)          /*  7.2  Unary operators  */
167 struct defs *pd0;
168 {
169 #else
170 int s72(struct defs *pd0){
171 #endif
172    static char s72er[] = "s72,er%d\n";
173    static char qs72[8] = "s72    ";
174    int rc;
175    char *ps, *pt;
176    int k, j, i, lrc;
177    char c;
178    short s;
179    long l;
180    unsigned u;
181
182    #ifndef NO_FLOATS
183         double d;
184         float f;
185    #else
186         signed d;
187         signed f;
188    #endif
189
190    ps = qs72;
191    pt = pd0->rfs;
192    rc = 0;
193    while (*pt++ = *ps++);
194
195         /* The *, denoting indirection, and the &, denoting a
196         pointer, are duals of each other, and ought to behave as
197         such...                                                 */
198
199    k = 2;
200    if(*&*&k != 2){
201      rc = rc+1;
202      printf(s72er,1);
203    }
204
205         /* The unary minus has the conventional meaning.        */
206
207    if(k+(-k) != 0){
208      rc = rc+2;
209      printf(s72er,2);
210    }
211
212         /*  The negation operator (!) has been thoroughly checked out,
213         perhaps more thoroughly than any of the others. The ~ oper-
214         ator gets us a ones complement.                         */
215
216    k = 0;
217    for(j=0;j<pd0->ibits;j++) k = (k<<1)|1;
218    if(~k != 0){
219      rc = rc+4;
220      printf(s72er,4);
221    }
222
223         /*  Now we look at the ++ and -- operators, which can be
224         used in either prefix or suffix form. With side
225         effects they're loaded.                                 */
226
227    k = 5;
228
229    if( ++k != 6 || --k != 5
230     || k++ != 5 || k-- != 6
231     ||   k != 5 ){
232      rc = rc+8;
233      printf(s72er,8);
234    }
235
236         /*  An expression preceded by the parenthesised name of a
237         data type causes conversion of the value of the expression
238         to the named type. This construction is called a cast.
239         Here, we check to see that all of the possible casts and
240         their simple combinations are accepted by the compiler,
241         and that they all produce a correct result for this sample
242         of size one.                                            */
243
244    c = 26;  l = 26;
245    s = 26;  u = 26;
246    i = 26;
247    #ifndef NO_FLOATS
248    f = 26.;
249    d = 26.;
250    #else
251    f = 26;
252    d = 26;
253    #endif
254
255    lrc = 0;
256
257    if( (char)s != 26 || (char)i != 26
258     || (char)l != 26 || (char)u != 26
259     || (char)f != 26 || (char)d != 26 ) lrc = lrc+1;
260
261    if( (short)c != 26 || (short)i != 26
262     || (short)l != 26 || (short)u != 26
263     || (short)f != 26 || (short)d != 26) lrc = lrc+2;
264
265    if( (int)c != 26 || (int)s != 26
266     || (int)l != 26 || (int)u != 26
267     || (int)f != 26 || (int)d != 26 ) lrc = lrc+4;
268
269    if( (long)c != 26 || (long)s != 26
270     || (long)i != 26 || (long)u != 26
271     || (long)f != 26 || (long)d != 26 ) lrc = lrc+8;
272
273    if( (unsigned)c != 26 || (unsigned)s != 26
274     || (unsigned)i != 26 || (unsigned)l != 26
275     || (unsigned)f != 26 || (unsigned)d != 26 ) lrc = lrc+16;
276
277    #ifndef NO_FLOATS
278    if( (float)c != 26. || (float)s != 26.
279     || (float)i != 26. || (float)l != 26.
280     || (float)u != 26. || (float)d != 26. ) lrc = lrc+32;
281
282    if( (double)c != 26. || (double)s != 26.
283     || (double)i != 26. || (double)l != 26.
284     || (double)u != 26. || (double)f != 26. ) lrc = lrc+64;
285    #endif
286
287    if(lrc != 0){
288      rc = rc+16;
289      printf(s72er,16);
290    }
291
292         /*  The sizeof operator has been tested previously.     */
293
294    return rc;
295 }
296
297 /*********************************************************************************************
298  the main loop that launches the sections
299 *********************************************************************************************/
300
301 #ifndef NO_TYPELESS_STRUCT_PTR
302         int section(int j,struct* pd0){
303 #else
304         int section(int j,void* pd0){
305 #endif
306         switch(j){
307                 case 0: return s26(pd0);
308                 case 1: return s72(pd0);
309         }
310 }
311
312 #define cq_sections 2
313
314 /*
315         C REFERENCE MANUAL (main)
316 */
317
318 #ifndef NO_OLD_FUNC_DECL
319 main(n,args)
320 int n;
321 char **args;
322 {
323 #else
324 int main(int n,char **args) {
325 #endif
326
327 int j;
328 static struct defs d0, *pd0;
329         
330    d0.flgs = 1;          /* These flags dictate            */
331    d0.flgm = 1;          /*     the verbosity of           */
332    d0.flgd = 1;          /*         the program.           */
333    d0.flgl = 1;
334
335    pd0 = &d0;
336
337    for (j=0; j<cq_sections; j++) {
338      d0.rrc=section(j,pd0);
339      d0.crc=d0.crc+d0.rrc;
340      if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
341    }
342
343    if(d0.crc == 0) printf("\nNo errors detected.\n");
344    else printf("\nFailed.\n");
345
346    return d0.crc;
347 }