![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c33b.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 c33b.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 SKIP33B
12: /*
13: * c33b.c - extension of 3.3 (Expressions).
14: */
15: #include "defs.h"
16: static void c3_3_5();
17: static void c3_3_6();
18: static void c3_3_7();
19: static void c3_3_8();
20: static void c3_3_9();
21: static void c3_3_10();
22: static void c3_3_11();
23: static void c3_3_12();
24: static void c3_3_13();
25: static void c3_3_14();
26: static void c3_3_15();
27: static void c3_3_16();
28: static void c3_3_16_1();
29: static void c3_3_16_2();
30: static void c3_3_17();
31: static long larray[10] = {0,1,2,3,4,5,6,7,8,9};
32: void c3_3b()
33: {
34: Filename = "c33b.c";
35: c3_3_5();
36: c3_3_6();
37: c3_3_7();
38: c3_3_8();
39: c3_3_9();
40: c3_3_10();
41: c3_3_11();
42: c3_3_12();
43: c3_3_13();
44: c3_3_14();
45: c3_3_15();
46: c3_3_16();
47: c3_3_16_1((generic_ptr)Filename);
48: c3_3_16_2();
49: c3_3_17();
50: }
51:
52: /*
53: * 3.3.5 - Multiplicative operators
54: */
55: static void c3_3_5()
56: {
57: double d = 1.9, e = 2.7;
58: int i = 4, j = 7;
59:
60: /* commutativity */
61: iequals(__LINE__, i*j, j*i);
62:
63: /* associates L->R */
64: dequals(__LINE__, j % i * d, d * 3);
65:
66: /* "usual arith conversions" (ANSI) are value-preserving */
67: #if ANSI
68: {
69: unsigned char uc = 5;
70:
71: #if MAX_UCHAR <= MAX_INT
72: checkthat(__LINE__, uc / -2 == -3 || uc / -2 == -2);
73: #endif
74: }
75: #endif
76:
77: /* positive result of division must round toward 0 */
78: iequals(__LINE__, j / i, 1);
79: iequals(__LINE__, -j / -i, 1);
80:
81: /* mixed mode arithmetic -- this is done as double */
82: iequals(__LINE__, (int)(d * i), 7);
83: iequals(__LINE__, (int)(i * d), 7);
84: iequals(__LINE__, (int)(i / d), 2);
85:
86: /* but not this */
87: iequals(__LINE__, i % (int)e, 0);
88:
89: /* definitive property */
90: iequals(__LINE__, (i/j)*j + i%j, i);
91: i = -4;
92: iequals(__LINE__, (i/j)*j + i%j, i);
93:
94: }
95:
96:
97:
98:
99:
100:
101:
102: /*
103: * 3.3.6 - Additive operators
104: */
105: static void c3_3_6()
106: {
107: double d = 4.2;
108: long *pd1, *pd2;
109: int i = 1;
110:
111: /* check out mixed mode addition/subtraction */
112: dequals(__LINE__, d+ivalue(7), 11.2);
113:
114: /* adding/subtracting an integral expression from a pointer */
115: pd1 = &larray[4];
116: pd2 = &larray[7];
117: lequals(__LINE__, *(pd1 - ivalue(3)), 1L);
118: lequals(__LINE__, *(pd2 - ivalue(3)), 4L);
119:
120: /* pointer - pointer */
121: iequals(__LINE__, pd2 - pd1, 3);
122: iequals(__LINE__, pd1 - pd2, -3);
123: pd1 = &larray[9];
124: pd2 = pd1 + 1;
125: checkthat(__LINE__, pd2 - pd1 == 1);
126:
127: /* no re-grouping, except by "as-if" rule */
128: #if ANSI
129: {
130: unsigned ui = MAX_UINT;
131: ULONG ul = 0;
132: double d1 = dvalue((DBL_MAX/3.)*2. + DBL_MAX/10.);
133:
134: ul = (ui + 1) + ul;
135: checkthat(__LINE__, ul == 0L);
136: #define SUM (d1 + -(DBL_MAX/3.)*2.)
137: dequals(__LINE__, SUM + SUM, dvalue(DBL_MAX/10. + DBL_MAX/10.)); /* no re-grouping */
138: }
139: #endif
140: } /* end c3_3_6 */
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152: /*
153: * 3.3.7 - Bitwise shift operators
154: */
155: static void c3_3_7()
156: {
157: unsigned char c = 1;
158: int i = 4;
159: unsigned int ui = 0xffff;
160: int count;
161:
162: /* how many bits in a char ? */
163: for (count = 0; c; c <<= 1, ++count)
164: ;
165: /* bits in a long */
166: count *= sizeof(long);
167:
168: #if !ANSI
169: /* before ANSI, if either operand was long, the shift was long */
170: lequals(__LINE__, 1 << (count - 1L), 1L << (long)(count - 1L));
171: #else
172: iequals(__LINE__, sizeof(c << 2L), sizeof(int));
173: iequals(__LINE__, count, CHAR_BIT * sizeof(long));
174: #endif
175:
176: /* make sure that 'vacated bits' are filled with 0 */
177: checkthat(__LINE__, ((int)0xff << i) == (int)0xff0);
178:
179: /* shift of unsigned must 0 fill */
180: iequals(__LINE__, (ui >> i), (int)0x0fff);
181:
182: /* right shift of signed item -- behavior is implem-defined */
183: checkthat( - __LINE__, (~0 >> 1) == ~0 || (~0 >> 1) == ((unsigned)~0 >> 1));
184: }
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202: /*
203: * 3.3.8 - Relational operators
204: */
205: static void c3_3_8()
206: {
207: long *pl1 = &larray[3];
208: long *pl2 = &larray[5];
209: double d = 11.0;
210: unsigned ui1 = 5;
211: int i = -2;
212:
213: /* (non-intuitive?) integer promotions */
214: checkthat(__LINE__, ui1 < i);
215:
216: /* value context */
217: iequals(__LINE__, pl1 < pl2, 1);
218: iequals(__LINE__, d > *pl1, 1);
219: iequals(__LINE__, pl1 <= pl2, 1);
220: iequals(__LINE__, d >= *pl1, 1);
221:
222: /* condition context */
223: if(pl1 < pl2)
224: ;
225: else
226: complain(__LINE__);
227: if(d > *pl1)
228: ;
229: else
230: complain(__LINE__);
231:
232: if(pl1 <= pl2)
233: ;
234: else
235: complain(__LINE__);
236: if(d >= *pl1)
237: ;
238: else
239: complain(__LINE__);
240:
241: /* check out associativity */
242: iequals(__LINE__, pl1[0] < d < pl1[1] , 1);
243: iequals(__LINE__, pl1[0] < d < 1 , 0);
244: iequals(__LINE__, pl1[0] < d <= 1 , 1);
245: iequals(__LINE__, *pl1 > d >= 0, 1);
246:
247:
248:
249:
250:
251:
252: #if ANSI8706 /* 3.3.8 (cont.) */
253: {
254: struct known { int i; } s = {0};
255: struct unknown *psu;
256: void *gp; volatile void *vgp;
257:
258: psu = (struct unknown *)&s;
259: vgp = gp = psu;
260: checkthat(__LINE__, gp == psu);
261: iequals(__LINE__, gp < vgp, 0);
262: iequals(__LINE__, (const struct unknown *)psu < (struct unknown *)avalue(psu), 0);
263: }
264: #endif
265: #if ANSI8709
266: iequals(__LINE__, (const char *)avalue(pl1) < (char *)avalue(pl1), 0);
267: #endif
268:
269: /* special cases for "last-plus-one" members */
270: {
271: long a[10];
272: long *p = &a[9];
273: iequals(__LINE__, &a[9] < &a[10], 1);
274: iequals(__LINE__, p+1 > p, 1);
275: iequals(__LINE__, p+1 < p, 0);
276: iequals(__LINE__, &a[9] < a+10 , 1);
277: }
278:
279: /* result has type int */
280: #if ANSI
281: { double x=0, y=0; iequals(__LINE__, sizeof(x < y), sizeof(int)); }
282: #endif
283: } /* end c3_3_8 */
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302: /*
303: * 3.3.9 - Equality operators
304: */
305: static void c3_3_9()
306: {
307: long *pl1 = &larray[4];
308: long *pl2 = &larray[6];
309: generic_ptr gp = (generic_ptr)pl1;
310: void (*p3_8)() = c3_3_8;
311: void (*p3_9)() = c3_3_9;
312:
313: /* equality of pointers */
314: checkthat(__LINE__, p3_8 == c3_3_8);
315: checkthat(__LINE__, p3_9 != c3_3_8);
316: #if ANSI
317: checkthat(__LINE__, gp == pl1);
318: #else
319: checkthat(__LINE__, gp == (generic_ptr)pl1);
320: #endif
321: #if ANSI8709
322: checkthat(__LINE__, (char *)pl1 == (void *)pl1);
323: checkthat(__LINE__, (const char *)pl1 == (char *)pl1);
324: checkthat(__LINE__, pl1 != (void *)0);
325: checkthat(__LINE__, pl1 != (const void *)pl2);
326: #endif
327:
328: /* value context */
329: iequals(__LINE__, pl1 == &larray[4], 1);
330: iequals(__LINE__, pl1 == pl2, 0);
331: iequals(__LINE__, pl1 != 0, 1);
332: iequals(__LINE__, *pl1 != *pl2, 1);
333:
334: /* condition context */
335: if (pl1 == &larray[4])
336: ;
337: else
338: complain(__LINE__);
339:
340: if (pl1 != pl2)
341: ;
342: else
343: complain(__LINE__);
344: if (pl1 != 0)
345: ;
346: else
347: complain(__LINE__);
348: if (*pl1 != *pl2)
349: ;
350: else
351: complain(__LINE__);
352: /* 3.3.9 (cont.) */
353: /* associativity */
354: iequals(__LINE__, *pl1 == *pl2 == 1, 0);
355: iequals(__LINE__, *pl1 != *pl2 == 1, 1);
356: iequals(__LINE__, pl1 < pl2 != pl2 < pl1, 1);
357:
358: /* result has type int */
359: #if ANSI
360: { double x=0, y=0; iequals(__LINE__, sizeof(x != y), sizeof(int)); }
361: #endif
362: }
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402: /*
403: * 3.3.10 - Bitwise AND operator
404: */
405: static void c3_3_10()
406: {
407: int a = 7, b = 2;
408: long l = 6;
409: #if ANSI
410: iequals(__LINE__, sizeof(a & l), sizeof(long));
411: #endif
412: lequals(__LINE__, a & l, 6L);
413: iequals(__LINE__, a & b, 2);
414: iequals(__LINE__, b & a, 2);
415: iequals(__LINE__, a & 0, 0);
416: iequals(__LINE__, a & ~0, a);
417: }
418: /*
419: * 3.3.11 - Bitwise exclusive OR operator
420: */
421: static void c3_3_11()
422: {
423: int a = 7, b = 2;
424: long l = 6;
425: #if ANSI
426: iequals(__LINE__, sizeof(a ^ l), sizeof(long));
427: #endif
428: lequals(__LINE__, a ^ l, 1L);
429: iequals(__LINE__, a ^ b, 5);
430: iequals(__LINE__, b ^ a, 5);
431: a = a^b; b = a^b; a = a^b; /* swap a and b */
432: iequals(__LINE__, a, 2);
433: iequals(__LINE__, b, 7);
434: }
435: /*
436: * 3.3.12 - Bitwise OR operator
437: */
438: static void c3_3_12()
439: {
440: int a = 5, b = 2;
441: long l = 6;
442: #if ANSI
443: iequals(__LINE__, sizeof(a | l), sizeof(long));
444: #endif
445: lequals(__LINE__, a | l, 7L);
446: iequals(__LINE__, a | b, 7);
447: iequals(__LINE__, b | a, 7);
448: iequals(__LINE__, a | 0, a);
449: iequals(__LINE__, a | ~0, ~0);
450: }
451:
452: /*
453: * 3.3.13 - Logical AND operator
454: */
455: static void c3_3_13()
456: {
457: int zero = 0;
458: int one = 1;
459: extern int Side;
460:
461: /* side effect checks in a value producing context */
462: Side = 0;
463: scheck(__LINE__, ++Side && zero, 1, 0);
464: scheck(__LINE__, ++Side && one, 1, 1);
465: scheck(__LINE__, zero && ++Side, 0, 0);
466: scheck(__LINE__, one && ++Side, 1, 1);
467:
468: /* side effects in a condition producing context */
469: if (++Side && zero)
470: complain(__LINE__);
471: iequals(__LINE__, Side--, 1);
472:
473: if (++Side && one)
474: ;
475: else
476: complain(__LINE__);
477: iequals(__LINE__, Side--, 1);
478:
479: if (zero && ++Side)
480: complain(__LINE__);
481: iequals(__LINE__, Side, 0);
482:
483: if (one && ++Side)
484: ;
485: else
486: complain(__LINE__);
487: iequals(__LINE__, Side--, 1);
488:
489: #if ANSI
490: /* result is of type int */
491: { double x=0, y=0; iequals(__LINE__, sizeof(x && y), sizeof(int)); }
492: #endif
493: /* operands are of scalar type */
494: { double x=0, y=0; iequals(__LINE__, x && y, 0); }
495: { generic_ptr x=0, y=0; iequals(__LINE__, x && y, 0); }
496: { enum {z} x=0, y=0; iequals(__LINE__, x && y, 0); }
497: } /* end c3_3_14 */
498:
499:
500:
501:
502: /*
503: * 3.3.14 - Logical OR operator
504: */
505: static void c3_3_14()
506: {
507: int zero = 0;
508: int one = 1;
509: extern int Side;
510:
511: /* side effect checks in a value producing context */
512: Side = 0;
513: scheck(__LINE__, ++Side || zero, 1, 1);
514: scheck(__LINE__, ++Side || one, 1, 1);
515: scheck(__LINE__, zero || ++Side, 1, 1);
516: scheck(__LINE__, one || ++Side, 0, 1);
517:
518: /* side effects in a condition producing context */
519: if (++Side || zero)
520: ;
521: else
522: complain(__LINE__);
523: iequals(__LINE__, Side--, 1);
524:
525: if (++Side || one)
526: ;
527: else
528: complain(__LINE__);
529: iequals(__LINE__, Side--, 1);
530:
531: if (zero || ++Side)
532: ;
533: else
534: complain(__LINE__);
535: iequals(__LINE__, Side--, 1);
536:
537: if (one || ++Side)
538: ;
539: else
540: complain(__LINE__);
541: iequals(__LINE__, Side, 0);
542:
543: #if ANSI
544: /* result is of type int */
545: { double x=0, y=0; iequals(__LINE__, sizeof(x || y), sizeof(int)); }
546: #endif
547: /* operands are of scalar type */
548: { double x=0, y=0; iequals(__LINE__, x || y, 0); }
549: { generic_ptr x=0, y=0; iequals(__LINE__, x || y, 0); }
550: { enum {z} x=0, y=0; iequals(__LINE__, x || y, 0); }
551: } /* end c3_3_13 */
552: /*
553: * 3.3.15 - Conditional operator
554: */
555: static int If1, If2;
556: void f1(){If1 = 7;}
557: void f2(){If2 = 11;}
558: static int iarray[] = {7, 11};
559: static void c3_3_15()
560: {
561: int one = ivalue(1), zero = ivalue(0);
562: int *p1 = &one, *p0 = &zero;
563: generic_ptr gp = (generic_ptr)p1;
564: extern int Side;
565: char *pc;
566:
567: Side = 0;
568: /* side effect checks in a value producing context */
569: scheck(__LINE__, ++Side ? one : zero, 1, 1);
570: scheck(__LINE__, zero ? one : ++Side, 1, 1);
571: scheck(__LINE__, one ? one : ++Side, 0, 1);
572:
573: /* side effects in a condition producing context */
574: if (++Side ? one : zero)
575: ;
576: else
577: complain(__LINE__);
578: iequals(__LINE__, Side--, 1);
579:
580: if (zero ? one : ++Side)
581: ;
582: else
583: complain(__LINE__);
584: iequals(__LINE__, Side--, 1);
585:
586: if (one ? ++Side: zero)
587: ;
588: else
589: complain(__LINE__);
590: iequals(__LINE__, Side, 1);
591:
592: #if ANSI8709
593: checkthat(__LINE__, (one ? Side=5 : 6) == 5);
594: checkthat(__LINE__, (one ? 2,3 : 4) == 3);
595: checkthat(__LINE__, (one ? (char *)p1 : (const char *)p0) == (const char *)p1);
596: checkthat(__LINE__, (one ? (char *)p1 : (void *)p0) == /* (void *) */ p1);
597: pc = zero ? (char *)p1 : 0;
598: checkthat(__LINE__, pc == 0);
599: { double x=0; char y=1; checkthat(__LINE__, sizeof(one ? x : y) == sizeof(x) && (one ? x : y) == 0); }
600: #endif
601:
602: /* arms can be scalar, void, struct, pointer */ /* 3.3.15 (cont.) */
603: iequals(__LINE__, one ? one : zero, one);
604: iequals(__LINE__, zero ? one : zero, zero);
605: aequals(__LINE__, one ? p1 : p0, p1);
606: aequals(__LINE__, zero ? p1 : p0, p0);
607: aequals(__LINE__, one ? NULL : p0, NULL);
608: aequals(__LINE__, zero ? p1 : NULL, NULL);
609: iequals(__LINE__, *(one ? p1 : p0), 1);
610: iequals(__LINE__, *(zero ? p1 : p0), 0);
611: #if ANSI
612: aequals(__LINE__, one ? gp : p0, gp);
613: checkthat(__LINE__, (zero ? &f1 : 0) == 0);
614: #endif
615: checkthat(__LINE__, (one ? f1 : 0) == f1);
616: #if ANSI
617: /* function calls in both arms -- only one should be called */
618: If1 = If2 = 0;
619: one ? f1(): f2();
620: iequals(__LINE__, If1, 7);
621: iequals(__LINE__, If2, 0);
622: If1 = If2 = 0;
623: zero ? f1(): f2();
624: iequals(__LINE__, If1, 0);
625: iequals(__LINE__, If2, 11);
626: #endif
627: /* function pointers in both arms */
628: If1 = If2 = 0;
629: (*(one ? f1 : f2))();
630: iequals(__LINE__, If1, 7);
631: iequals(__LINE__, If2, 0);
632: If1 = If2 = 0;
633: (*(zero ? f1 : f2))();
634: iequals(__LINE__, If1, 0);
635: iequals(__LINE__, If2, 11);
636:
637: /* struct/union in arms are tested in structures() in c33c.c */
638:
639: /* check out nested question ops */
640: iequals(__LINE__,
641: zero ? 1 : zero ? 2 : zero ? 3 : zero ? 4 : 5, 5);
642: iequals(__LINE__,
643: one ? one ? one ? one ? one ? 1 : 2 : 3 : 4 : 5 : 6, 1);
644:
645: /* questions as array indexes */
646: iequals(__LINE__, iarray[zero ? zero : one], 11);
647: iequals(__LINE__, iarray[one ? zero : one], 7);
648:
649:
650:
651:
652: /* question in a switch */ /* 3.3.15 (cont.) */
653: switch (one ? one : zero)
654: {
655: case 1 :
656: break;
657: default :
658: complain(__LINE__);
659: }
660:
661: /* conditional is a sequence point */
662: {
663: int i = ivalue(1);
664:
665: iequals(__LINE__, i++ == 1 ? i : 0, ivalue(2));
666: iequals(__LINE__, i++ != 2 ? 0 : i, ivalue(3));
667: }
668:
669: } /* end c3_3_15 */
670:
671:
672:
673:
674:
675:
676:
677:
678:
679:
680:
681: /*
682: * 3.3.16 - Assignment operators
683: */
684: static void c3_3_16()
685: {
686: int i = 3;
687: double d = 4.0;
688: /* takes type and value from the left operand */
689: iequals(__LINE__, i = d, 4);
690: i = 2;
691: dequals(__LINE__, d = i, 2.0);
692: iequals(__LINE__, i += d, 4);
693: #if ANSI
694: { char x=0; double y=1; checkthat(__LINE__, sizeof(x = y) == sizeof(x) && (x = y) == 1); }
695: #endif
696: }
697:
698:
699:
700:
701:
702: /*
703: * 3.3.16.1 - Simple assignment
704: */
705: static void c3_3_16_1(q)
706: generic_ptr q;
707: {
708: char *p;
709: unsigned ui;
710:
711: #if ANSI8712
712: struct unk; /* structure of unkown contents */
713:
714: /* The constraints for assignment are quite detailed:
715: * Define a "sufficiently-qualified" (or "suf-qual") left operand type
716: * to be one that has all the qualifiers of the type pointed to by the
717: * right operand (and perhaps others).
718: * Let qual=qualified, arith=arithmetic, ptr=pointer.
719: * Then, as the Standard says, one of the folllowing
720: * shall hold:
721:
722: Left operand Right operand
723: 1. qual arith type arith type
724: 2. unqual arith type arith type
725: 3. qual struct type compatible struct type
726: 4. qual union type compatible union type
727: 5. unqual struct type compatible struct type
728: 6. unqual union type compatible union type
729: 7. ptr to suf-qual type ptr to compatible qual type
730: 8. ptr to suf-qual type ptr to compatible unqual type
731: 9. ptr to suf-qual object ptr to qual void
732: 10. ptr to suf-qual object ptr to unqual void
733: 11. ptr to suf-qual incomplete ptr to qual void
734: 12. ptr to suf-qual incomplete ptr to unqual void
735: 13. any ptr null ptr constant ...
736: */
737: /* 1 */ { volatile int a; int b={1}; a = b; iequals(__LINE__, a, b); }
738: /* 2 */ { int a; int b={2}; a = b; iequals(__LINE__, a, b); }
739: /* 3 */ { volatile struct s {int i;} a; struct s b={3}; a = b; iequals(__LINE__, a.i, b.i); }
740: /* 4 */ { volatile union u {int i;} a; union u b={4}; a = b; iequals(__LINE__, a.i, b.i); }
741: /* 5 */ { struct s {int i;} a; struct s b={5}; a = b; iequals(__LINE__, a.i, b.i); }
742: /* 6 */ { union u {int i;} a; union u b={6}; a = b; iequals(__LINE__, a.i, b.i); }
743: /* 7 */ { const int *a; const signed *b=q; a = b; aequals(__LINE__, a, b); }
744: /* 8 */ { const int *a; signed *b=q; a = b; aequals(__LINE__, a, b); }
745: /* 9 */ { const int *a; const void *b=q; a = b; aequals(__LINE__, a, (int *)b); }
746: /* 10*/ { volatile int *a; void *b=q; a = b; aequals(__LINE__, (int *)a, (int *)b); }
747: /* 11*/ { const struct unk *a; const void *b=q; a = b; aequals(__LINE__, a, (struct unk *)b); }
748: /* 12*/ { struct unk *a; void *b=q; a = b; aequals(__LINE__, a, (struct unk *)b); }
749: /* 13*/ { struct unk *a; a = (void *)0L; aequals(__LINE__, a, 0); }
750: #endif
751:
752: /* struct/union assignments are done in structures() in c33c.c */
753: /* 3.3.16.1 (cont.) */
754:
755: /* assignment of pointers */
756: p = q;
757: aequals(__LINE__, p, Filename);
758: q = 0L;
759: aequals(__LINE__, q, NULL);
760: q = p;
761: aequals(__LINE__, p, q);
762:
763: /* integral constant expression with value 0 */
764: p = 0;
765: aequals(__LINE__, p, NULL);
766:
767: #if (V7 || ANSI)
768: {
769: UCHAR c;
770:
771: /* right side values are converted to the type on the left */
772: c = MAX_ULONG;
773: iequals(__LINE__, c, MAX_UCHAR);
774: }
775: #endif
776:
777: /* right side values are converted to the type on the left */
778: ui = MAX_ULONG;
779: checkthat(__LINE__, ui == MAX_UINT);
780: }
781:
782:
783:
784:
785:
786:
787:
788:
789:
790:
791:
792:
793:
794:
795:
796:
797:
798:
799:
800:
801:
802:
803: /*
804: * 3.3.16.2 - Compound assignment
805: */
806: static int *fpi() { ++If1; return & If2;}
807: static void c3_3_16_2()
808: {
809: long *pl1 = &larray[4];
810: long *pl2 = &larray[6];
811: char c = 10;
812: double d = 1.21;
813:
814: /* allow pointer ops on += and -= */
815: aequals(__LINE__, pl1+=2, pl2);
816: aequals(__LINE__, pl1-=6, larray);
817: /* make sure that the left side is only evaluated once */
818: If2 = ivalue(5);
819: If1 = ivalue(0);
820: *fpi()*=2;
821: iequals(__LINE__, If1, 1);
822: iequals(__LINE__, If2, 10);
823: *fpi()/=2;
824: iequals(__LINE__, If1, 2);
825: iequals(__LINE__, If2, 5);
826: *fpi()%=2;
827: iequals(__LINE__, If1, 3);
828: iequals(__LINE__, If2, 1);
829: *fpi()+=2;
830: iequals(__LINE__, If1, 4);
831: iequals(__LINE__, If2, 3);
832: *fpi()-=2;
833: iequals(__LINE__, If1, 5);
834: iequals(__LINE__, If2, 1);
835: *fpi()<<=2;
836: iequals(__LINE__, If1, 6);
837: iequals(__LINE__, If2, 4);
838: *fpi()>>=2;
839: iequals(__LINE__, If1, 7);
840: iequals(__LINE__, If2, 1);
841: *fpi()&=7;
842: iequals(__LINE__, If1, 8);
843: iequals(__LINE__, If2, 1);
844: *fpi()^=7;
845: iequals(__LINE__, If1, 9);
846: iequals(__LINE__, If2, 6);
847: *fpi()|=1;
848: iequals(__LINE__, If1, 10);
849: iequals(__LINE__, If2, 7);
850:
851:
852: /* 3.3.16.2 (cont.) */
853: /* make sure that mixed mode ops are done right */
854: iequals(__LINE__, c *= d, 12);
855: iequals(__LINE__, c /= d, 9);
856: }
857:
858: /*
859: * 3.3.17 - Comma operator
860: */
861: static void c3_3_17()
862: {
863: If1 = ivalue(0);
864: iequals(__LINE__, (If1++,If1++,If1++,If1++,If1++,If1++,0), 0);
865: iequals(__LINE__, If1, 6);
866: iequals(__LINE__, (If1 = 6, If1 >>= 1, If1 + 2), 5);
867: If2 = ivalue(5);
868: If1 = ivalue(0);
869: iequals(__LINE__, (*fpi(), If1), 1);
870: #if ANSI8809
871: {
872: char arr[100];
873: char c;
874:
875: /* array-conversion takes place in comma (3.2.2.1 doesn't mention it), ... */
876: /* but integral conversions do not take place (because no mention in Semantics of comma */
877: iequals(__LINE__, sizeof(0,arr), sizeof(&arr[0]));
878: iequals(__LINE__, sizeof(0,c), ivalue(1));
879: }
880: #endif
881: }
882:
883: #else /* if SKIP33B */
884:
885: void c3_3b() { pr_skip("c3_3b: SKIPPED ENTIRELY\n"); }
886: #endif /* SKIP33B */
887:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.