![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c32.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / ph|
Return to c32.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / ph |
1.1 root 1: /* The Plum Hall Validation Suite for C
2: * Unpublished copyright (c) 1986-1991, Chiron Systems Inc and Plum Hall Inc.
3: * VERSION: 4
4: * DATE: 1993-01-01
5: * The "ANSI" mode of this suite corresponds to official ANSI C, X3.159-1989.
6: * As per your license agreement, your distribution is not to be moved or copied outside the Designated Site
7: * without specific permission from Plum Hall Inc.
8: */
9:
10: #include "flags.h"
11: #ifndef SKIP32
12: /*
13: * 3.2 - Conversions.
14: */
15: #include "defs.h"
16:
17: static void c3_2_1_1();
18: static void c3_2_1_2();
19: static void c3_2_1_3();
20: static void c3_2_1_4();
21: static void c3_2_1_5();
22: static void c3_2_2_1();
23: static void c3_2_2_2();
24: static void c3_2_2_3();
25:
26:
27: void c3_2()
28: {
29: Filename = "c32.c";
30: c3_2_1_1();
31: c3_2_1_2();
32: c3_2_1_3();
33: c3_2_1_4();
34: c3_2_1_5();
35: c3_2_2_1();
36: c3_2_2_2();
37: c3_2_2_3();
38: }
39:
40: /*
41: * 3.2.1.1 - Characters and integers
42: */
43: static void c3_2_1_1()
44: {
45: char c;
46: short ss;
47: #if ANSI
48: signed char sc;
49: #endif
50:
51:
52:
53: #if ANSI /* 3.2.1.1 (cont.) */
54: UCHAR uc;
55: USHORT us;
56: #endif
57:
58: #if ANSI
59: /* check signed and unsigned integral promotions */
60: sc = ivalue(4);
61: ss = ivalue(5);
62: dequals(__LINE__, (double)(sc-5), -1.);
63: dequals(__LINE__, (double)(ss-6), -1.);
64: uc = ivalue(4);
65: us = ivalue(5);
66: if (MAX_UCHAR <= MAX_INT)
67: dequals(__LINE__, (double)(uc-5), -1.);
68: else
69: dequals(__LINE__, (double)(uc-5), (double)MAX_UINT);
70:
71: if (MAX_USHORT <= MAX_INT)
72: dequals(__LINE__, (double)(us-6), -1.);
73: else
74: dequals(__LINE__, (double)(us-6), (double)MAX_UINT);
75:
76: #endif
77:
78: /* sign of "plain" char is implem-def */
79: #if SIGNED_CHAR
80: c = ivalue(-1);
81: iequals(__LINE__, c, -1);
82: #endif
83: #if ANSI
84: #if UNSIGNED_CHAR
85: c = ~0u;
86: iequals(__LINE__, c, MAX_UCHAR);
87: #endif /* UNSIGNED_CHAR */
88: /* demotion to shorter signed */
89: sc = ivalue(-1);
90: iequals(__LINE__, sc, -1);
91: #endif /* ANSI */
92: ss = ivalue(-1);
93: iequals(__LINE__, ss, -1);
94:
95: #if ANSI
96: uc = ~0u;
97: checkthat(__LINE__, uc == MAX_UCHAR);
98: us = ~0u;
99: checkthat(__LINE__, us == MAX_USHORT);
100: #endif
101: }
102:
103: /*
104: * 3.2.1.2 - Signed and unsigned integers
105: */
106: static void c3_2_1_2()
107: {
108: #if ANSI
109: signed int si;
110: int i;
111: signed short int ssi;
112: short int ss;
113: signed long int sl;
114: long int l;
115: signed int *psi = &i; /* allowable, compatible type */
116: signed short int *pssi = &ss;
117: signed long int *psli = &l;
118: ULONG ul;
119: struct {
120: unsigned ubf2 : 2;
121: signed sbf2 : 2;
122: int ibf2 : 2;
123: } bf;
124: UCHAR uc=ivalue(4);
125: USHORT us=ivalue(5);
126: unsigned int ui;
127:
128: /* each of the pairs are compatible types */
129: iequals(__LINE__, sizeof(signed int), sizeof(int));
130: iequals(__LINE__, sizeof(signed short int), sizeof(short int));
131: iequals(__LINE__, sizeof(signed long int), sizeof(long int));
132:
133: /* when unsigned integers are converted to representable signed values, the value is unchanged. */
134: uc = lvalue(MAX_UCHAR);
135: sl = uc;
136: /* allow for the rare case where sizeof(UCHAR) == sizeof(long) */
137: if (sizeof(sl) > sizeof(uc))
138: dequals(__LINE__, (double)sl, (double)MAX_UCHAR);
139: us = lvalue(MAX_USHORT);
140: sl = us;
141: /* allow for the rare case where sizeof(USHORT) == sizeof(long) */
142: if (sizeof(sl) > sizeof(us))
143: dequals(__LINE__, (double)sl, (double)MAX_USHORT);
144:
145: checkthat(__LINE__, (unsigned char)(long)(UCHAR_MAX+1+ivalue(2)) == 2);
146: checkthat(__LINE__, (unsigned long)(short)ivalue(-2) == (ULONG_MAX-1));
147: bf.ubf2 = ivalue(-1);
148: iequals(__LINE__, bf.ubf2, 3);
149: bf.sbf2 = ivalue(-1);
150: iequals(__LINE__, bf.sbf2, -1);
151: bf.ibf2 = ivalue(-1);
152: checkthat(__LINE__, bf.ibf2 == -1 || bf.ibf2 == 3);
153:
154: /* signed to unsigned of equal or greater length: if non-negative, value unchanged */ /* 3.2.1.2 (cont.) */
155: ssi = ivalue(4);
156: ui = ssi;
157: checkthat(__LINE__, ui == 4);
158: /* signed to unsigned of equal or greater length: if negative, converted modulo "largest plus one" */
159: ssi = ivalue(-1);
160: ul = (unsigned long) ivalue(ssi);
161: checkthat(__LINE__, ul == MAX_ULONG);
162: us = ssi;
163: checkthat(__LINE__, us == MAX_USHORT);
164:
165: /* integer demoted to smaller unsigned: modulo "largest plus one" */
166: sl = ivalue(-3);
167: uc = sl;
168: iequals(__LINE__, uc, MAX_UCHAR-2);
169: #endif
170: }
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203: /*
204: * 3.2.1.3 - floating and integral
205: */
206: static void c3_2_1_3()
207: {
208: #if ANSI
209: float f;
210: double d;
211: char c;
212: short ss;
213: int si;
214: long sl;
215: unsigned int ui;
216: unsigned char uc;
217: unsigned short us;
218: unsigned long ul;
219: signed char sc;
220: enum { a, b } en;
221: struct { unsigned u : 7; signed i : 7; } su;
222:
223: /* conversion from floating->integral truncates positive numbers */
224: f = dvalue(99.999);
225: c = f; iequals(__LINE__, c, ivalue(99));
226: sc = f; iequals(__LINE__, sc, ivalue(99));
227: uc = f; iequals(__LINE__, uc, ivalue(99));
228: ss = f; iequals(__LINE__, ss, ivalue(99));
229: us = f; iequals(__LINE__, us, ivalue(99));
230: si = f; iequals(__LINE__, si, ivalue(99));
231: ui = f; iequals(__LINE__, ui, ivalue(99));
232: en = f; iequals(__LINE__, en, ivalue(99));
233: su.u = f; iequals(__LINE__, su.u, ivalue(99));
234: su.i = 33.333; iequals(__LINE__, su.i, ivalue(33));
235: sl = f; lequals(__LINE__, sl, lvalue(99L));
236: ul = f; lequals(__LINE__, ul, lvalue(99L));
237: d = dvalue(99.999);
238: c = d; iequals(__LINE__, c, ivalue(99));
239: sc = d; iequals(__LINE__, sc, ivalue(99));
240: uc = d; iequals(__LINE__, uc, ivalue(99));
241: ss = d; iequals(__LINE__, ss, ivalue(99));
242: us = d; iequals(__LINE__, us, ivalue(99));
243: si = d; iequals(__LINE__, si, ivalue(99));
244: ui = d; iequals(__LINE__, ui, ivalue(99));
245: en = d; iequals(__LINE__, en, ivalue(99));
246: su.u = d; iequals(__LINE__, su.u, ivalue(99));
247: su.i = 33.333; iequals(__LINE__, su.i, ivalue(33));
248: sl = d; lequals(__LINE__, sl, lvalue(99L));
249: ul = d; lequals(__LINE__, ul, lvalue(99L));
250: #endif
251: }
252:
253: /*
254: * 3.2.1.4 - Floating types
255: */
256: static void c3_2_1_4()
257: {
258: float f;
259: double d;
260: #if ANSI
261: long double l;
262: #endif
263:
264: /* float->double, etc. has no value change */
265: f = dvalue(1.23456789012345);
266: d = dvalue(f);
267: dequals(__LINE__, f, d);
268: #if ANSI
269: l = dvalue(f);
270: ldequals(__LINE__, (long double)f, l);
271: d = dvalue(1.23456789012345);
272: l = d;
273: ldequals(__LINE__, (long double)d, l);
274: #endif
275:
276: d = dvalue(.25);
277: f = dvalue(d);
278: checkthat(__LINE__, f == .25);
279:
280: /* conversion downward has undefined behavior if not representable */
281:
282: }
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303: /*
304: * 3.2.1.5 - Usual arithmetic conversions
305: * These will be checked in greater detail in 'expressions'.
306: */
307: static void c3_2_1_5()
308: {
309: #if ANSI
310: long double ld = dvalue(3.0);
311: signed char sc = ivalue(4);
312: char c = ivalue(5);
313: int si = ivalue(6);
314: short ss = ivalue(7);
315: long sl = ivalue(8);
316: unsigned int ui = ivalue(9);
317: float f = ivalue(10);
318: double d = ivalue(11);
319: UCHAR uc = ivalue(12);
320: USHORT us = ivalue(13);
321: ULONG ul = ivalue(14);
322:
323: /* if either argument is long double, that is the type of the result */
324: ldequals(__LINE__, ld+sc, 7.0L);
325:
326: /* if either argument is double, that is the type of the result */
327: dequals(__LINE__, d+f, 21.0);
328: dequals(__LINE__, d+si, 17.0);
329: dequals(__LINE__, (double)f+si, 16.0);
330:
331: /* otherwise, if either float, then float */
332: iequals(__LINE__, sizeof(d+c), sizeof(double));
333: iequals(__LINE__, sizeof(f+c), sizeof(float));
334: /* otherwise, int promotions are performed. Then, following rules: */
335:
336: /* if either unsigned long int, then that */
337: ldequals(__LINE__, (long double)(ss-ul), (long double)(MAX_ULONG-6));
338: /* otherwise, if long vs unsigned int: */
339: if (UINT_MAX <= LONG_MAX) /* if unsigned int can be held in long, then long */
340: ldequals(__LINE__, sl-ui, -1);
341: else /* if unsigned int cannot be held in long, then unsigned long */
342: ldequals(__LINE__, sl-ui, MAX_ULONG);
343: /* otherwise, if either long int, then that */
344: ldequals(__LINE__, (long double)(si-sl), (long double)(-2));
345: iequals(__LINE__, sizeof(si-sl), sizeof(long));
346:
347: /* otherwise, if either unsigned int, then that */
348: ldequals(__LINE__, (long double)(ss-ui), (long double)(MAX_UINT - 1));
349: /* integral widening has been tested in 3.2.1.1 */
350: #endif
351: }
352:
353: /*
354: * 3.2.2.1 - Lvalues and function designators
355: */
356: #if ANSI
357: static char iarray[6] = "abcdef";
358: #else
359: static char iarray[6] = "abcde";
360: #endif
361: static void c3_2_2_1()
362: {
363: char *p;
364:
365: /* the name of an array is equivalent to a pointer to the first element */
366: aequals(__LINE__, iarray, &iarray[0]);
367:
368: /* except for use in 'sizeof' */
369: iequals(__LINE__, sizeof(iarray), 6 * sizeof(char));
370: #if ANSI
371: /* ... or as operand of & */
372: {
373: char (*pa)[6] = &iarray;
374:
375: checkthat(__LINE__, pa == &iarray);
376: }
377: #endif
378:
379: /* or except as a string literal initializer */
380: iequals(__LINE__, iarray[0], 'a');
381: iequals(__LINE__, iarray[1], 'b');
382: iequals(__LINE__, iarray[2], 'c');
383: iequals(__LINE__, iarray[3], 'd');
384: iequals(__LINE__, iarray[4], 'e');
385: iequals(__LINE__, iarray[5], ANSI ? 'f' : '\0');
386:
387: /* similarly we can overaddress and check a pointer */
388: for (p = iarray; p < &iarray[6]; ++p)
389: ;
390: aequals(__LINE__, p, iarray+6);
391:
392: /* function name takes on type 'pointer to function returning type' */
393: checkthat(__LINE__, c3_2_2_1 != 0);
394: #if ANSI
395: checkthat(__LINE__, &c3_2_2_1 == c3_2_2_1);
396: #endif
397: }
398:
399:
400:
401:
402:
403: /*
404: * 3.2.2.2 - Void
405: */
406: static void c3_2_2_2()
407: {
408: static int iterations = 0;
409:
410: if (iterations++ == 0)
411: #if ANSI8709
412: (void)c3_2_2_2();
413: #else
414: c3_2_2_2();
415: #endif
416: else
417: {
418: (void)1;
419: (void)iequals(__LINE__, 1, ivalue(1));
420: (void)(iterations + 1);
421: iequals(__LINE__, 7, ((void)3, ivalue(7)));
422: (void)++iterations;
423: return;
424: }
425: iequals(__LINE__, iterations, 3);
426: }
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453: /*
454: * 3.2.2.3 - Pointers
455: */
456: static void c3_2_2_3()
457: {
458: long li, *pl = (long *)avalue(&li);
459: double d, *pd = (double *)avalue(&d);
460: char *pc;
461:
462: int (*ipf)();
463: #if ANSI
464: /* pointer to void can be converted to any ptr-to-object */
465: void *gp;
466:
467: gp = avalue(pl);
468: aequals(__LINE__, pl, gp);
469: #endif
470: #if ANSI8706
471: {
472: struct unknown *pu;
473:
474: pu = avalue(gp);
475: gp = avalue(pu);
476: pu = avalue(gp);
477: aequals(__LINE__, gp, pu);
478: }
479: #endif
480:
481: /* A pointer can be converted to one of less strict alignment
482: * and back again without loss of information. (See 3.3.4.)
483: */
484: li = ivalue(1234); pc = (char *)pl; do_nothing(&pc, &pl); pl = (long *)pc;
485: lequals(__LINE__, *pl, 1234L);
486:
487: d = dvalue(3.1416); pc = (char *)pd; do_nothing(&pc, &pd); pd = (double *)pc;
488: dequals(__LINE__, *pd, 3.1416);
489:
490: /* null pointers */
491: pc = 0;
492: do_nothing(&pc);
493: checkthat(__LINE__, pc == 0);
494: pd = 0;
495: do_nothing(&pd);
496: checkthat(__LINE__, pd == 0);
497: pd = &d; /* again */
498:
499:
500:
501:
502:
503: #if ANSI8712 /* 3.2.2.3 (cont.) */
504: {
505: void *gp;
506: struct unknown *pu, *pu2;
507: const long *pcl;
508:
509: /* a ptr-to-void may be converted to/from a ptr to any object type */
510: li = ivalue(1234); gp = pl; do_nothing(&gp, &pl); pl = gp;
511: lequals(__LINE__, *pl, 1234L);
512:
513: d = dvalue(3.1416); gp = pd; do_nothing(&gp, &pd); pd = gp;
514: dequals(__LINE__, *pd, 3.1416);
515:
516: /* a ptr-to-void may be converted to/from a ptr to any incomplete type */
517: pu = (struct unknown *)pl; gp = pu; pu2 = gp;
518: checkthat(__LINE__, pu == pu2);
519:
520: /* qualifiers do not affect comparisons */
521: pcl = (const long *)pl;
522: checkthat(__LINE__, pcl == pl);
523:
524: /* null pointer can be e.g. 0L or (void *)0 */
525: pc = 0L;
526: do_nothing(&pc);
527: checkthat(__LINE__, pc == 0L);
528: pd = 0L;
529: do_nothing(&pd);
530: checkthat(__LINE__, pd == 0L);
531:
532: pc = (void *)0;
533: do_nothing(&pc);
534: checkthat(__LINE__, pc == (void *)0);
535: pd = (void *)0;
536: do_nothing(&pd);
537: checkthat(__LINE__, pd == (void *)0);
538:
539: /* two null pointers, thru different cast sequences, compare equal */
540: checkthat(__LINE__, (char *)(long *)pc == (char *)(float *)pd);
541: }
542: #endif
543: }
544: #else /* if SKIP32 */
545:
546: void c3_2() { pr_skip("c3_2: SKIPPED ENTIRELY\n"); }
547: #endif /* SKIP32 */
548:
549: /*
550: * Section 3.2.2.4 (const and volatile) has been moved to 3.5.3
551: * See c35.c
552: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.