![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c36.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 c36.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 SKIP36
12: /*
13: * 3.6 - Statements
14: */
15: #include "defs.h"
16:
17: static void c3_6_1();
18: static void c3_6_2();
19: static void c3_6_3();
20: static void c3_6_4_1();
21: static void c3_6_4_2();
22: static void c3_6_5_1();
23: static void c3_6_5_2();
24: static void c3_6_5_3();
25: static void c3_6_6_1();
26: static void c3_6_6_2();
27: static void c3_6_6_3();
28: static void c3_6_6_4();
29:
30: void c3_6()
31: {
32: Filename = "c36.c";
33: c3_6_1();
34: c3_6_2();
35: c3_6_3();
36: c3_6_4_1();
37: c3_6_4_2();
38: c3_6_5_1();
39: c3_6_5_2();
40: c3_6_5_3();
41: c3_6_6_1();
42: c3_6_6_2();
43: c3_6_6_3();
44: c3_6_6_4();
45: }
46:
47:
48:
49:
50:
51:
52: /*
53: * 3.6.1 - Labeled statements
54: */
55: static void c3_6_1()
56: {
57: int i;
58: /* labels do not interfere with the flow of control */
59: i = 1;
60: a:
61: iequals(__LINE__, i, 1);
62: i = 2;
63: b:
64: iequals(__LINE__, i, 2);
65: i = 3;
66: c: d: e:
67: iequals(__LINE__, i, 3);
68: }
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102: /*
103: * 3.6.2 - Compound statement or block
104: */
105: static void c3_6_2()
106: {
107: int i = 1;
108: {
109: int i = 2;
110: {
111: int i = 3, j = i + 1;
112: static float c3_6var = 5.; /* see also 3.1.2.1 Scope */
113: {
114: /* initialize the block each time it is entered */
115: int j;
116: for (j = 7; j < 10; ++j)
117: lab:{
118: int i = j;
119: static int k = 9;
120: #if ANSI
121: extern int c3_6var;
122: iequals(__LINE__, i, j);
123: iequals(__LINE__, k, 9);
124: iequals(__LINE__, c3_6var, 12);
125: #endif /* ANSI */
126: }
127: }
128: iequals(__LINE__, i, 3);
129: iequals(__LINE__, j, 4);
130: dequals(__LINE__, c3_6var, 5.);
131: }
132: iequals(__LINE__, i, 2);
133: }
134: iequals(__LINE__, i, 1);
135: }
136: int c3_6var = 12;
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152: /*
153: * 3.6.3 Expression and null statement
154: */
155: static void c3_6_3()
156: {
157: int i, j, k;
158: char p[4];
159: /* expressions don't have to do anything */
160: i = ivalue(11);
161: ;;;;;
162: i;
163: 1;2;(void)3;
164: iequals(__LINE__, i, 11);
165:
166: #if (V7 || ANSI)
167: /* evaluate an expression for its side effects */
168: (void)str_cpye(p, "abc");
169: checkthat(__LINE__, str_cmp(p, "abc") == 0);
170: str_cpye(p, "xyz");
171: checkthat(__LINE__, str_cmp(p, "xyz") == 0);
172: #endif
173:
174: /* null statement in use */
175: for (i = 0; i < 10; ++i)
176: ;
177: iequals(__LINE__, i, 10);
178: label: ;
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: * 3.6.4 - Selection statements
204: */
205:
206: /*
207: * 3.6.4.1 - The 'if' statement
208: */
209: static void c3_6_4_1()
210: {
211: int i = ivalue(1), j = ivalue(2), k = ivalue(3);
212: double d = dvalue(1.);
213: char *p = 0;
214:
215: /* the controlling expr is of scalar type */
216: if (d) dequals(__LINE__, d, 1.);
217: else complain(__LINE__);
218:
219: if (p) complain(__LINE__);
220: else aequals(__LINE__, p, (char *)0);
221:
222: /* check else binding (nearest if) */
223: if (ivalue(i+j) == 0)
224: complain(__LINE__);
225: else if (ivalue(j+k) == 0)
226: complain(__LINE__);
227: else
228: lab: i = 4;
229: iequals(__LINE__, i, 4);
230:
231: /* and in the presence of labels */
232: goto lab1;
233: if (i != 0)
234: lab1: i = 5;
235: else
236: i = 6;
237: iequals(__LINE__, i, 5);
238:
239: goto lab2;
240: if (i != 0)
241: i = 7;
242: else
243: lab2: i = 8;
244: iequals(__LINE__, i, 8);
245:
246: /* The tested expr is a sequence point. */
247: i = ivalue(8);
248: if (i == 0) { complain(__LINE__); if ( i > 0 ) complain(__LINE__); }
249: else iequals(__LINE__, i, 8);
250: }
251:
252: /*
253: * 3.6.4.2 - The 'switch' statement
254: */
255: static char carray[] = { 0, 1, 2, 3};
256: static short sarray[] = { 0, 1, 2, 3};
257: static long larray[] = { 0xff00000, 0xff10000, 0xff20000, 3};
258: static void c3_6_4_2()
259: {
260: #if (ANSI || V7)
261: enum e {zero, one, two, three} e;
262: #endif
263: char c;
264: int i, sum, flag;
265: unsigned u;
266: long l;
267: short s;
268:
269: #if ANSI
270: {
271: int a = 1;
272:
273: /* syntax does not require a block, only a stmt */
274: switch (a) default: switch (a+1) default: a = 9;
275: iequals(__LINE__, a, 9);
276: switch(a) ; /* do-nothing */
277: }
278: #endif
279:
280: flag = sum = 0;
281: for (i = 0; i < 10; ++i)
282: {
283: switch(i)
284: {
285: inswitch:
286: case 0:
287: case 9:
288: sum += 1;
289: /* falls through */
290: case 1:
291: case 8:
292: sum += 2;
293: break;
294: default:
295: sum += 4;
296: }
297: if (flag)
298: break;
299: }
300:
301:
302: /* 3.6.4.2 (cont.) */
303: if (flag)
304: /* gets here via goto below */
305: iequals(__LINE__, sum, 37);
306: else
307: {
308: iequals(__LINE__, sum, 34);
309: /* check that switch control works on obscure entry */
310: flag = 1;
311: goto inswitch;
312: }
313:
314: /* nested switch */
315: for (i = 0; i < 2; ++i)
316: switch(i)
317: {
318: default :
319: switch(i)
320: {
321: case 0:
322: sum = 0;
323: break;
324: case 1 :
325: sum += 1;
326: break;
327: }
328: break;
329: case 11:
330: sum = 123;
331: }
332: iequals(__LINE__, sum, 1);
333:
334: /* the tested expr is a sequence point */
335: i = ivalue(9);
336: switch (i++)
337: {
338: case 9:
339: iequals(__LINE__, i, 10);
340: break;
341: default:
342: complain(__LINE__);
343: }
344:
345:
346:
347:
348:
349:
350:
351:
352: /* 3.6.4.2 (cont.) */
353: /* switch with no match */
354: switch(sum)
355: {
356: case 0:
357: case 2:
358: case 3:
359: sum = 123;
360: break;
361: }
362: iequals(__LINE__, sum, 1);
363:
364: /* unsigned should work correctly at the zero crossing */
365: for (u = (unsigned)-1, sum = 0; u != 2; ++u)
366: switch (u)
367: {
368: case -1: /* promoted to unsigned */
369: sum += 1;
370: break;
371: case 0:
372: sum += 2;
373: break;
374: case 1:
375: sum += 4;
376: break;
377: default:
378: complain(__LINE__);
379: }
380: iequals(__LINE__, sum, 7);
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402: /* 3.6.4.2 (cont.) */
403: #if ANSI
404: /* ANSI allows all integral types to be used in a switch */
405: for (i = 0, sum = 0; i <= 3; ++i)
406: {
407: switch (carray[i])
408: {
409: case 0:
410: sum += 1;
411: break;
412: case 1:
413: sum += 2;
414: break;
415: case 2:
416: sum += 4;
417: break;
418: case 3:
419: sum += 8;
420: break;
421: default:
422: complain(__LINE__);
423: }
424: }
425: iequals(__LINE__, sum, 15);
426:
427: for (i = 0, sum = 0; i <= 3; ++i)
428: {
429: switch (sarray[i])
430: {
431: case 0:
432: sum += 1;
433: break;
434: case 1:
435: sum += 2;
436: break;
437: case 2:
438: sum += 4;
439: break;
440: case 3:
441: sum += 8;
442: break;
443: default:
444: complain(__LINE__);
445: }
446: }
447: iequals(__LINE__, sum, 15);
448:
449:
450:
451:
452: /* 3.6.4.2 (cont.) */
453: for (i = 0, sum = 0; i <= 3; ++i)
454: {
455: switch (larray[i])
456: {
457: case 0xff00000:
458: sum += 1;
459: break;
460: case 0xff10000:
461: sum += 2;
462: break;
463: case 0xff20000:
464: sum += 4;
465: break;
466: case 3: /* must convert to long */
467: sum += 8;
468: break;
469: default:
470: complain(__LINE__);
471: }
472: }
473: iequals(__LINE__, sum, 15);
474: for (e = (enum e)(i = 0), sum = 0; i <= 3; ++i, e = (enum e)i)
475: {
476: switch (e)
477: {
478: case zero:
479: sum += 1;
480: break;
481: case one:
482: sum += 2;
483: break;
484: case two:
485: sum += 4;
486: break;
487: case three:
488: sum += 8;
489: break;
490: default:
491: complain(__LINE__);
492: }
493: }
494: iequals(__LINE__, sum, 15);
495: #endif /* ANSI */
496: } /* end c3_6_4_2 */
497:
498:
499:
500:
501:
502: /*
503: * 3.6.5 - Iteration statements
504: */
505:
506: /*
507: * 3.6.5.1 - The 'while' statement
508: */
509: static void c3_6_5_1()
510: {
511: int sum, i;
512:
513: /* the controlling expr is of scalar type */
514: { float v=0; while (v) { complain(__LINE__); break; } }
515: { int (*v)()=0; while (v) { complain(__LINE__); break; } }
516: { char *v=0; while (v) { complain(__LINE__); break; } }
517: { struct unk *v=0; while (v) { complain(__LINE__); break; } }
518: { enum {z} v=0; while (v) { complain(__LINE__); break; } }
519: { char v=0; while (v) { complain(__LINE__); break; } }
520: { unsigned v=0; while (v) { complain(__LINE__); break; } }
521:
522: i = 10;
523: sum = 0;
524: /* make sure the bounds are computed each time through */
525: while (i)
526: {
527: sum += i;
528: if (--i == 5)
529: i = 0;
530: }
531: iequals(__LINE__, sum, 40);
532:
533: /* zero execution loop */
534: sum = 0;
535: while (i)
536: sum = 99;
537: iequals(__LINE__, sum, 0);
538:
539: /* the controlling expr is a sequence point */
540: i = ivalue(1);
541: while ( i -- )
542: iequals(__LINE__, i, 0);
543: }
544:
545:
546:
547:
548:
549:
550:
551:
552: /*
553: * 3.6.5.2 - The 'do' statement
554: */
555: static void c3_6_5_2()
556: {
557: int sum, i;
558:
559: /* the controlling expr is of scalar type */
560: { float v=0; do { checkthat(__LINE__, v == 0); } while (v); }
561: { int (*v)()=0; do { checkthat(__LINE__, v == 0); } while (v); }
562: { char *v=0; do { checkthat(__LINE__, v == 0); } while (v); }
563: { struct unk *v=0; do { checkthat(__LINE__, v == 0); } while (v); }
564: { enum {z} v=0; do { checkthat(__LINE__, v == 0); } while (v); }
565: { char v=0; do { checkthat(__LINE__, v == 0); } while (v); }
566: { unsigned v=0; do { checkthat(__LINE__, v == 0); } while (v); }
567: i = 10;
568: sum = 0;
569: /* make sure the bounds are computed each time through */
570: do
571: {
572: sum += i;
573: if (--i == 5)
574: i = 0;
575: } while(i);
576: iequals(__LINE__, sum, 40);
577:
578: /* guarantee one execution of the loop */
579: sum = 0;
580: do
581: {
582: i = 0;
583: sum ++;
584: } while(i);
585: iequals(__LINE__, sum, 1);
586:
587: /* the controlling expr is a sequence point */
588: i = ivalue(1);
589: do { } while (i-- == 1); iequals(__LINE__, i, -1);
590: }
591:
592:
593:
594:
595:
596:
597:
598:
599:
600:
601:
602: /*
603: * 3.6.5.3 - The 'for' loop.
604: */
605: static void c3_6_5_3()
606: {
607: int i, j;
608:
609: /* check that the for loop behaves the same as its decomposition */
610: for (i = 0, j = 0; i < 10; ++i)
611: j += i;
612: iequals(__LINE__, j, 45);
613:
614: i = 0; j = 0;
615: while(i < 10)
616: {
617: j += i;
618: ++i;
619: }
620: iequals(__LINE__, j, 45);
621:
622: /* any of the three fields can be left out */
623: i = 0; j = 0;
624: for (; i < 10; ++i)
625: j += i;
626: iequals(__LINE__, j, 45);
627:
628: for (i = 0, j = 0; ; (void)++i)
629: {
630: j += i;
631: if (i >= 10)
632: break;
633: }
634: iequals(__LINE__, j, 55);
635:
636: for (i = 0, (void)(j = 0); i < 10;)
637: {
638: j += i;
639: ++i;
640: }
641: iequals(__LINE__, j, 45);
642:
643: /* a for loop can be jumped into */
644: i = 5, j = 0;
645: goto forloop;
646: for (i = 0, j = 0; i < 10; ++i)
647: forloop: j += i;
648: iequals(__LINE__, j, 35);
649:
650:
651:
652: /* each 'for' line expr is a sequence point */
653: for (i = ivalue(1); i-- ; )
654: iequals(__LINE__, i, 0);
655: } /* end 3.6.5.3 */
656:
657:
658: /*
659: * 3.6.6 - Jump statements
660: */
661:
662: /*
663: * 3.6.6.1 - The goto statement
664: */
665: static void c3_6_6_1()
666: {
667: goto label;
668: complain(__LINE__);
669: {
670: complain(__LINE__);
671: label:;
672: goto label2;
673: complain(__LINE__);
674: }
675: complain(__LINE__);
676: label2: ;
677: }
678:
679:
680:
681:
682:
683:
684:
685:
686:
687:
688:
689:
690:
691:
692:
693:
694:
695:
696:
697:
698:
699:
700:
701:
702: /*
703: * 3.6.6.2 - The 'continue' statement
704: */
705: static void c3_6_6_2()
706: {
707: int i, j, k;
708: /* check them out in for/while/do loops */
709: /* a nested example ... */
710: i = ivalue(0);
711: for (k = 0; k < 3; ++k)
712: {
713: iequals(__LINE__, i, 0);
714: for (i = 0, j = 0; i < 10; ++i)
715: if (i%2)
716: continue;
717: else
718: j += i;
719: iequals(__LINE__, j, 20);
720: i = ivalue(0);
721: }
722:
723: i = ivalue(10);
724: j = ivalue(0);
725: while (--i)
726: if (i%2)
727: continue;
728: else
729: j += i;
730: iequals(__LINE__, j, 20);
731:
732: j = ivalue(0);
733: do
734: if (i%2)
735: continue;
736: else
737: j += i;
738: while (++i < 10);
739: iequals(__LINE__, j, 20);
740: }
741:
742:
743:
744:
745:
746:
747:
748:
749:
750:
751:
752: /*
753: * 3.6.6.3 - The 'break' statement
754: */
755: static void c3_6_6_3()
756: {
757: int i, j, k;
758:
759: /* test in each of for/while/do/switch */
760: /* a nested example ... */
761: for (k = 0; k < 3; ++k)
762: {
763: j = 0;
764: for (i = 0; i < 10; ++i)
765: if (i == 4)
766: break;
767: else
768: j += i;
769: iequals(__LINE__, j, 6);
770: }
771: iequals(__LINE__, k, 3);
772:
773: while (i--)
774: if (i == 1)
775: break;
776: else
777: --j;
778: iequals(__LINE__, j, 4);
779:
780: do
781: if (--j == 3)
782: break;
783: else
784: ++i;
785: while (j);
786: iequals(__LINE__, i, 1);
787:
788: switch(i)
789: {
790: case 1:
791: break;
792: default:
793: i = 99;
794: }
795: iequals(__LINE__, i, 1);
796: }
797:
798:
799:
800:
801:
802: /*
803: * 3.6.6.4 - The 'return' statement
804: */
805: double fc3_664() { return 99; } /* must convert */
806:
807: static void c3_6_6_4()
808: {
809: int i;
810:
811: dequals(__LINE__, fc3_664(), 99.);
812: i = ivalue(0);
813: if (!i)
814: return;
815: complain(__LINE__);
816:
817: /* the expression on the return stmt is a sequence point, */
818: /* but so too is any means of examining its side-effects */
819: }
820:
821: #else /* if SKIP36 */
822:
823: void c3_6() { pr_skip("c3_6: SKIPPED ENTIRELY\n"); }
824: #endif /* SKIP36 */
825:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.