![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c31.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 c31.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 SKIP31
12: /*
13: * 3.1 - Lexical Elements
14: */
15: #include "defs.h"
16: #if ANSI
17: #include <stddef.h>
18: #endif
19: /*
20: * 3.1.1 - Keywords. These are tested throughout.
21: */
22: static void c3_1_1(){}
23:
24: /*
25: * 3.1.2 - Identifiers. A few checks for valid identifiers.
26: */
27: static void c3_1_2()
28: {
29: int abcdefghijklmnopqrstuvwxyz = 1;
30: int ABCDEFGHIJKLMNOPQRSTUVWXYZ = 2;
31: int a23456789012345678901234567890a = 3;
32: #if ANSI
33: int a23456789012345678901234567890b = 4;
34:
35: /* ANSI requires 31 characters of significance */
36: inotequals(__LINE__,
37: a23456789012345678901234567890b,
38: a23456789012345678901234567890a);
39: #endif
40:
41: /* upper and lower cases are significant */
42: inotequals(__LINE__,
43: abcdefghijklmnopqrstuvwxyz,
44: ABCDEFGHIJKLMNOPQRSTUVWXYZ);
45:
46: #if !(LONG_IDENTIFIERS || ANSI)
47: /* K&R/V7 declares that significance is ONLY to 8 characters */
48: iequals(__LINE__, a23456789, a2345678);
49: #endif
50: }
51:
52:
53: /*
54: * 3.1.2.1 - Scopes of Identifiers
55: */
56: #if ANSI && HAS_PROTOTYPES
57: /* function prototype scope */
58: int nofunc(int i);
59: #endif
60:
61: /* file scope */
62: static int i = 17;
63: enum {AA, BB};
64: #if ANSI
65: static int f(enum {BB, AA} n) { iequals(__LINE__, BB, 0); return BB; }
66: #endif /* ANSI */
67: struct tag1 { int stuff; }; /* at file level */
68: static void c3_1_2_1(i)
69: int i; /* block scope (set to 19 from call above) */
70: {
71: {
72: /* block scope */
73: int i = ivalue(18);
74: iequals(__LINE__, i, 18);
75: }
76: iequals(__LINE__, i, 19);
77: iequals(__LINE__, BB, 1);
78: #if ANSI8703
79: {
80: enum { A, B = A+7 } e = A;
81: int i;
82: static struct tag1 { struct tag1 *next; } s1 = {&s1}; /* new scope */
83: iequals(__LINE__, f(0), 0);
84: checkthat(__LINE__, s1.next == &s1);
85: {
86: #if ANSI8809
87: void nonexist(union tag2 *junk); /* tag2, in prototype scope, disappears */
88: #endif
89: i = sizeof(struct tag2 { int stuff; }); /* declares tag2 */
90: {
91: struct tag2 s = {1};
92: checkthat(__LINE__, s.stuff == 1);
93: }
94: }
95: }
96: #endif
97: #if ANSI
98: goto a;
99: { iequals(__LINE__, 1, 0); /* should not be reached */ a: ; }
100: #endif
101: }
102:
103: /*
104: * 3.1.2.2 - Linkages of identifiers
105: */
106: static int s11 = 11; /* "lex 1st decl w file scope" says "static" --> internal */
107: int g13 = 13; /* no "static" --> external */
108: int g13; /* no sc --> external */
109: extern int s11; /* same linkage as previous --> internal */
110: extern int g13; /* same linkage as previous --> external */
111: static int s16(); /* internal linkage */
112: int s16(); /* no sc (on fn) --> as though "extern" (same as previous) */
113:
114: static void c3_1_2_2()
115: {
116: int j9 = ivalue(9); /* no linkage */
117: extern int s11; /* internal linkage (already defined) */
118: static int e12 = 12; /* no linkage */
119: extern int g13; /* external linkage (already defined) */
120: extern int g14; /* external linkage (forward reference) */
121: extern int e15; /* external linkage (defined in main1.c) */
122:
123: /* this is not referenced and shouldn't require any linkage */
124: extern int notdefinedanywhere;
125: iequals(__LINE__, j9, 9);
126: iequals(__LINE__, s11, 11);
127: iequals(__LINE__, g13, 13);
128: iequals(__LINE__, g14, 14);
129: iequals(__LINE__, e15, 15);
130: iequals(__LINE__, s16(), 16);
131:
132: /* this should have internal linkage -- it is erroneous to link
133: * to the static variable below.
134: */
135: iequals(__LINE__, e12, 12);
136:
137: /* scope testing of 'static i' from c3_1_2_1 */
138: iequals(__LINE__, i, 17);
139:
140: /* test scoping into and out of include files */
141: {
142: int i = 9;
143: #include "c31sco.h"
144: iequals(__LINE__, i, 10);
145: }
146: iequals(__LINE__, i, 17);
147: }
148:
149: static int e12 = 0;
150: int g14 = 14;
151:
152: static int s16() { return ivalue(16); }
153: /*
154: * 3.1.2.3 - Name spaces of identifiers.
155: * K&R and V7 have 2 (variables/labels and tags/members);
156: * later UNIX (set TAG_AND_MEMB_SPACES to 1) has 3 (var/labels, tags, members);
157: * ANSI has 4 (variables, labels, tags, members).
158: */
159: static void c3_1_2_3()
160: {
161: int ident;
162:
163: #if (TAG_AND_MEMB_SPACES || ANSI)
164: struct ident
165: {
166: int xxx;
167: int ident; /* members and variables in different spaces */
168: }p;
169: #endif
170: struct a
171: {
172: int ident2;
173: } pa;
174: #if (ANSI || UNIQ_MEMB_NAMES)
175: struct b
176: {
177: long ident2;
178: } pb;
179: #endif
180:
181: ident = ivalue(7);
182: pa.ident2 = ivalue(8);
183: #if ANSI
184: {
185: struct x { int x; } x = { 6 };
186: iequals(__LINE__, x.x, ivalue(6));
187: }
188: if (ident)
189: goto ident;
190: #else
191: if (ident)
192: goto ident1;
193: #endif
194:
195: /* this statement should never be reached */
196: complain(__LINE__);
197:
198:
199:
200:
201:
202:
203: /* 3.1.2.3 (cont.) */
204: #if ANSI
205: ident:
206: #else
207: ident1:
208: #endif
209: iequals(__LINE__, pa.ident2, 8);
210:
211: #if (TAG_AND_MEMB_SPACES || ANSI)
212: p.ident = ivalue(9);
213: iequals(__LINE__, p.ident, 9);
214: #endif
215: }
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253: /*
254: * 3.1.2.4 - Storage classes of objects.
255: */
256: static void c3_1_2_4(arg)
257: int arg;
258: {
259: static int i = 0;
260: int j = 17;
261:
262: /* make sure static items are still alive at each invocation */
263: if (arg == 0)
264: {
265: i = 13;
266: /* recursion ensures that stack frames (if any) don't coincide */
267: c3_1_2_4(1);
268: }
269: else
270: {
271: iequals(__LINE__, i, 13);
272: goto label;
273: }
274:
275: for (i = 1; i <= 2; ++i)
276: {
277: int j = i + 1;
278:
279: iequals(__LINE__, j, i + 1); /* auto var of inner block */
280: }
281: {
282: int j = 14;
283: label:
284: j = 15;
285: }
286:
287: iequals(__LINE__, j, 17);
288:
289: /* local items might hold their values, but it is only coincidence */
290: }
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303: /*
304: * 3.1.2.5 - Types
305: */
306: char a_incomplete[]; char a_incomplete[3] = "ab";
307: static void c3_1_2_5()
308: {
309: static char Carray[] =
310: {
311: 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
312: 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
313: 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
314: 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
315: ',', '.', '/', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
316: '-', '=', '|', '<', '>', '?', '!', '#', '%', '^', '&',
317: '"', '~', '[', ']', '{', '}', '*', '(', ')', '_', '+', '\\',
318: '\'',
319: }; /* dollar-sign, accent-grave, and at-sign are not in C source set */
320:
321: #if ANSI
322: signed char sc;
323: signed short ss;
324: signed int si;
325: signed long sl;
326: long double ld;
327: struct s_incomplete *psinc;
328: struct s_incomplete { int i; } sinc = {3};
329: #endif
330: char c;
331: short int s;
332: int i;
333: long int li;
334: float f;
335: double d;
336: unsigned int ui;
337:
338:
339: UCHAR uc;
340: USHORT us;
341: ULONG int ul;
342:
343: checkthat(__LINE__, sizeof(a_incomplete) == 3);
344: checkthat(__LINE__, sizeof(c) <= sizeof(s));
345: checkthat(__LINE__, sizeof(s) <= sizeof(i));
346: checkthat(__LINE__, sizeof(i) <= sizeof(li));
347: checkthat(__LINE__, sizeof(f) <= sizeof(d));
348: checkthat(__LINE__, sizeof(uc) == sizeof(c));
349: checkthat(__LINE__, sizeof(us) == sizeof(s));
350: checkthat(__LINE__, sizeof(ui) == sizeof(i));
351: checkthat(__LINE__, sizeof(ul) == sizeof(li));
352:
353: #if ANSI /* 3.1.2.5 (cont.) */
354: psinc = &sinc;
355: iequals(__LINE__, psinc->i, 3);
356: checkthat(__LINE__, sizeof(d) <= sizeof(ld));
357: checkthat(__LINE__, sizeof(uc) == sizeof(sc));
358: checkthat(__LINE__, sizeof(us) == sizeof(ss));
359: checkthat(__LINE__, sizeof(ui) == sizeof(si));
360: checkthat(__LINE__, sizeof(ul) == sizeof(sl));
361: #endif
362:
363: /* all source char constants are positive */
364: for (i = 0; i < sizeof(Carray); ++i)
365: checkthat(__LINE__, Carray[i] > 0);
366: #if ANSI
367: /* <limits.h> is included in the "defs.h" for ANSI */
368: checkthat(__LINE__, (int)INT_MAX == (unsigned int)INT_MAX);
369: checkthat(__LINE__, (long)LONG_MAX == (unsigned long)LONG_MAX);
370:
371: checkthat(__LINE__, ULONG_MAX >= LONG_MAX);
372: checkthat(__LINE__, UINT_MAX >= INT_MAX);
373: checkthat(__LINE__, USHRT_MAX >= SHRT_MAX);
374: ul = ULONG_MAX;
375: {
376: struct ints { char c; short s; int i; long l; };
377: struct uints { UCHAR c; USHORT s; unsigned int i; ULONG l; };
378: union { short s; unsigned short us; } u1;
379: static char str2[] = "abc", str3[] = "abc";
380: union { void *v2; char *s2; } u2;
381: union { void *v3; char *s3; } u3;
382:
383: checkthat(__LINE__, sizeof(struct ints) == sizeof(struct uints)); /* ANSI8703 same alignments */
384:
385: /* ANSI8809 - "same representation and alignment" means interchangeable in args, returned values, and unions */
386: u1.s = 10;
387: iequals(__LINE__, abs(u1.us), ivalue(10)); /* no prototype for abs at this point, defaults */
388: u2.s2 = str2, u3.s3 = str3;
389: iequals(__LINE__, str_cmp(u2.v2, u3.v3), 0); /* no prototype for str_cmp at this point, defaults */
390:
391: }
392: checkthat(__LINE__, ul + ULONG_MAX > 0); /* unsigned "can't oflo" */
393: ui = UINT_MAX;
394: checkthat(__LINE__, ui + UINT_MAX > 0); /* unsigned "can't oflo" */
395: us = USHRT_MAX;
396: checkthat(__LINE__, us + USHRT_MAX > 0); /* unsigned "can't oflo" */
397: ldequals(__LINE__, (ul += 1), 0); /* unsigned "can't oflo" */
398: ldequals(__LINE__, (ui += 1), 0); /* unsigned "can't oflo" */
399: ldequals(__LINE__, (us += 1u), 0); /* unsigned "can't oflo" */
400: #endif /* ANSI */
401: }
402:
403: #if ANSI8709
404: /*
405: * 3.1.2.6 - Compatible type and composite type
406: */
407: typedef char CHAR_COMPATIBLE;
408: extern struct s3126 { CHAR_COMPATIBLE i; signed int j; } s3126; /* link with lang.c */
409: extern union u3126 { signed int j; CHAR_COMPATIBLE i; } u3126; /* link with lang.c */
410: extern enum e3126 { E3126B=5, E3126A=4 } e3126; /* link with lang.c */
411: typedef void VF(); /* no parm list */
412: typedef void VF_VF(VF *); /* one parm of type VF * */
413: static void c3_1_2_6();
414: static void c3_1_2_6(VF *);
415: static void c3_1_2_6(VF_VF *);
416: static void c3_1_2_6(
417: VF_VF *pf)
418: {
419: iequals(__LINE__, s3126.j, 2);
420: iequals(__LINE__, u3126.i, 3);
421: iequals(__LINE__, e3126, 5);
422: checkthat(__LINE__, pf == c3_1_2_6);
423: }
424: #endif
425:
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.1.3.1 - Floating constants
455: */
456: static void c3_1_3_1()
457: {
458:
459: /* check multiple representations for equality */
460: dequals(__LINE__, 123., 123.0);
461: dequals(__LINE__, 123.0, 12.3e1);
462: dequals(__LINE__, 12.3e1, 12.3E1);
463: dequals(__LINE__, 12.3E1, 1.23E+2);
464: dequals(__LINE__, 123.e-2, 12.3e-1);
465: dequals(__LINE__, .9, 9e-1);
466: checkthat(__LINE__, sizeof(double) == sizeof(1.0));
467:
468: #if ANSI
469: /* check for existance of long double constants */
470: ldequals(__LINE__, 101.L, 101.0l);
471: fequals(__LINE__, 202.f, 202.0F);
472: checkthat(__LINE__, sizeof(1.F) == sizeof(float) && sizeof(1.f) == sizeof(float));
473: checkthat(__LINE__, sizeof(1.L) == sizeof(long double) && sizeof(1.l) == sizeof(long double));
474: #endif
475: }
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503: /*
504: * 3.1.3.2 - Integer constants.
505: */
506: static void c3_1_3_2()
507: {
508: /* make sure all hex digits are accepted */
509: iequals(__LINE__, 0xabc, 0xABC);
510: iequals(__LINE__, 0xdef, 0xDEF);
511:
512: /* equivalence checking */
513: iequals(__LINE__, 456, 0x1c8);
514: iequals(__LINE__, 456, 0710);
515:
516: /* size checking */
517: iequals(__LINE__, sizeof(1), sizeof(int));
518: iequals(__LINE__, sizeof(0xabc), sizeof(int));
519: iequals(__LINE__, sizeof(0123), sizeof(int));
520: iequals(__LINE__, sizeof(1L), sizeof(long));
521: iequals(__LINE__, sizeof(0xabcL), sizeof(long));
522: iequals(__LINE__, sizeof(0123L), sizeof(long));
523: iequals(__LINE__, sizeof(1l), sizeof(long));
524: iequals(__LINE__, sizeof(0xabcl), sizeof(long));
525: iequals(__LINE__, sizeof(0123l), sizeof(long));
526: iequals( - __LINE__, sizeof(999999999), sizeof(long));
527: iequals( - __LINE__, sizeof(0x9999999), sizeof(long));
528: iequals( - __LINE__, sizeof(0777777777), sizeof(long));
529: /* the 3 lines above are not strict - could fit a very large int */
530: #if ANSI
531: /* check for existence of both U and L suffixes */
532: iequals(__LINE__, sizeof(1u), sizeof(unsigned int));
533: iequals(__LINE__, sizeof(1U), sizeof(unsigned int));
534: iequals(__LINE__, sizeof(1LU), sizeof(unsigned long));
535: iequals(__LINE__, sizeof(1lU), sizeof(unsigned long));
536: iequals(__LINE__, sizeof(01uL), sizeof(unsigned long));
537: iequals(__LINE__, sizeof(0x1ul), sizeof(unsigned long));
538: #endif
539:
540: /* ANSI requires that 0xffff be unsigned int (if too big for int),
541: * but that 65535 be long (if too big for int).
542: */
543: #if ANSI
544: iequals(__LINE__, sizeof(0xffff), sizeof(unsigned int));
545: if (MAX_UINT == 65535)
546: {
547: iequals(__LINE__, sizeof(65535), sizeof(long));
548: iequals(__LINE__, sizeof(65535u), sizeof(unsigned int));
549: iequals(__LINE__, sizeof(0xffff), sizeof(int));
550: }
551: else
552: {
553: checkthat(__LINE__, sizeof(65535) <= sizeof(long));
554: iequals(__LINE__, sizeof(65535u), sizeof(unsigned int));
555: iequals(__LINE__, sizeof(0xffff), sizeof(int));
556: }
557: #endif
558: }
559: /*
560: * 3.1.3.3 - Enumeration constants.
561: */
562: static void c3_1_3_3()
563: {
564: #if (V7 || ANSI)
565: enum color { red = -1, blue = -2, green = (MAX_INT-1-MAX_INT) /* i.e., -1 again */ };
566: checkthat(__LINE__, sizeof(red) <= sizeof(int));
567: iequals(__LINE__, red, ivalue(-1));
568: iequals(__LINE__, blue, ivalue(-2));
569: iequals(__LINE__, green, ivalue(-1));
570: #endif
571: }
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
596:
597:
598:
599:
600:
601:
602:
603:
604:
605:
606:
607:
608:
609: /*
610: * 3.1.3.4 - Character constants.
611: */
612: static void c3_1_3_4()
613: {
614: int c;
615:
616: /* the basic set of character constants was tested above */
617:
618: /* escape sequence character constants */
619: inotequals(__LINE__, '\b', 'b');
620: inotequals(__LINE__, '\f', 'f');
621: inotequals(__LINE__, '\n', 'n');
622: inotequals(__LINE__, '\r', 'r');
623: inotequals(__LINE__, '\t', 't');
624: iequals(__LINE__, '\"', '"');
625: iequals(__LINE__, '\\', "\\"[0]);
626:
627: #if ANSI
628: inotequals(__LINE__, '\a', 'a');
629: inotequals(__LINE__, '\v', 'v');
630:
631: /* hex digit form */
632: iequals(__LINE__, '\xa', 0xa);
633: iequals(__LINE__, '\x7b', 0x7b);
634: iequals(__LINE__, '\x001', 1);
635: #if WIDE_CHARS
636: #include "c3134.h" /* to hide the following lines from non-ANSI lexical scan */
637: /* checkthat(__LINE__, sizeof(L'x') == sizeof(wchar_t)); */
638: /* iequals(__LINE__, L'a', 'a'); */
639: /* iequals(__LINE__, L'\0', 0); */
640: #endif
641:
642: #endif
643:
644: /* octal digit form */
645: iequals(__LINE__, '\0', 0);
646: iequals(__LINE__, '\1', 1);
647: iequals(__LINE__, '\12', 012);
648: iequals(__LINE__, '\123', 0123);
649:
650: iequals(__LINE__, sizeof('0'), sizeof(int));
651:
652:
653:
654:
655:
656:
657:
658:
659: #if (SIGNED_CHAR == 1 && MAX_UCHAR == 0xff) /* 3.1.3.4 (cont.) */
660: /* character constants sign extend */
661: iequals(__LINE__, '\377', -1);
662: #else
663: #if UNSIGNED_CHAR
664: /* character constants do not sign extend */
665: iequals(__LINE__, '\377', 255);
666: #endif
667: #endif
668: }
669:
670: /*
671: * 3.1.4 - String literals.
672: */
673: int distinct(s)
674: char *s;
675: {
676: int i, j;
677:
678: for (i = 0; s[i] != '\0'; ++i)
679: {
680: for (j = 0; s[j] != s[i]; ++j)
681: ;
682: if (i != j)
683: return (0); /* s[i] is dup'ed by an earlier char */
684: }
685: return (1);
686: }
687: #define OLD_ESC_CHARS "\"\\\b\f\n\r\t"
688: #define SOURCE_CHARS "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\
689: 0123456789!#%&'()*+,-./:;<=>?[]^_{|}~"
690: static void c3_1_4()
691: {
692: static char *p = "abc";
693: static char *q = OLD_ESC_CHARS;
694: static char *r = "abc";
695: /* check out all legal characters */
696: static char *s = SOURCE_CHARS;
697: static char *z = "";
698:
699: /* empty string */
700: iequals(__LINE__, z[0], 0);
701:
702: /* check for "array of char" behaviour and trailing null */
703: iequals(__LINE__, p[0], 'a');
704: iequals(__LINE__, p[1], 'b');
705: iequals(__LINE__, p[2], 'c');
706: iequals(__LINE__, p[3], '\0');
707:
708:
709: /* 3.1.3.4 (cont.) */
710: /* check escape sequences */
711: checkthat(__LINE__, distinct(q));
712: checkthat(__LINE__, distinct(s));
713: iequals(__LINE__, q[0], '\"');
714: iequals(__LINE__, q[1], '\\');
715: iequals(__LINE__, q[2], '\b');
716: iequals(__LINE__, q[3], '\f');
717: iequals(__LINE__, q[4], '\n');
718: iequals(__LINE__, q[5], '\r');
719: iequals(__LINE__, q[6], '\t');
720:
721: #if ANSI
722: #define NEW_ESC_CHARS "\a\v"
723: {
724: /* extra escape characters and string catenation */
725: static char *s = NEW_ESC_CHARS;
726: static char *t = "abc""def";
727: static char *u = SOURCE_CHARS OLD_ESC_CHARS NEW_ESC_CHARS ;
728: iequals(__LINE__, s[0], '\a');
729: iequals(__LINE__, s[1], '\v');
730: iequals(__LINE__, t[3], 'd');
731: iequals(__LINE__, t[6], '\0');
732: checkthat(__LINE__, distinct(u));
733: }
734: #endif
735:
736: #if V7 /* this changed in ANSI */
737: /* check for distinctness and writability of strings */
738: {
739: static char *u = "xyz";
740: static char *t = "xyz";
741:
742: u[0] = ivalue(0);
743: iequals(__LINE__, u[0], 0);
744: inotequals(__LINE__, t[0], 0);
745: }
746: #endif
747: /* pure numbers through escapes */
748: s = "\0123";
749: iequals(__LINE__, 012, s[0]);
750: iequals(__LINE__, '3', s[1]);
751: #if ANSI
752: s = "\x012""3"; /* The catenation "" is needed for ANSI8706 */
753: iequals(__LINE__, 0x12, s[0]); /* See 3.1.4 Example */
754: iequals(__LINE__, '3', s[1]);
755: #if ANSI8706
756: checkthat(__LINE__, str_cmp("\x023", "\x02""3") != 0); /* ANSI8706 */
757: #endif
758: #endif
759: /* 3.1.4 (cont.) */
760: /* strings are arrays of chars */
761: iequals(__LINE__, "abcd"[0], 'a');
762: iequals(__LINE__, "abcd"[1], 'b');
763: iequals(__LINE__, "abcd"[2], 'c');
764: iequals(__LINE__, "abcd"[3], 'd');
765: iequals(__LINE__, "abcd"[4], 0);
766: }
767:
768: /*
769: * Operators.
770: * No capability requirements.
771: * Each operator will be tested later (c3_3 etc.).
772: */
773: static void c3_1_5(){}
774:
775: /*
776: * Punctuators.
777: * No capability requirements.
778: * Each use of punctuator in syntax will be tested later (c3_5, c3_6, c3_7, c3_8).
779: */
780: static void c3_1_6(){}
781:
782: /* 3.1.7 - Header names (tested throughout) */
783:
784: /*
785: * 3.1.8 - Preprocessing numbers
786: */
787: #if ANSI
788: #define STR(a) NXSTR(a)
789: #define NXSTR(a) #a
790: #endif
791: static void c3_1_8()
792: {
793: #if PP_CAT_AND_STR
794: #include "c318.h" /* to prevent non-ANSI lexical scan of ... */
795: /* #define CAT(a, b) NXCAT(a, b) */
796: /* #define NXCAT(a, b) a ## b */
797: /* iequals(__LINE__, str_cmp(STR(CAT(1., E9)), "1.E9"), 0); */
798: /* iequals(__LINE__, str_cmp(STR(CAT(1.u, 1E+)), "1.u1E+"), 0); */
799: /* #define E 2 */
800: /* checkthat(__LINE__, 1E1 == 10.); */
801: #endif
802: }
803:
804:
805:
806:
807:
808:
809: /*
810: * Comments - 3.1.9
811: */
812: /* /* no nesting */
813: /* comment prevents preprocessing of its contents...
814: #include "unknown"
815: */
816:
817: static void c3_1_9()
818: {
819: int i;
820: char c;
821: char *s;
822:
823:
824:
825:
826:
827: i = 2; s = "/*"; i = 3; /* no comment in string literal */
828: iequals(__LINE__, i, 3);
829: /* comment prevents compilation of its contents...
830: complain(__LINE__);
831: */
832: }
833:
834:
835:
836:
837:
838:
839:
840:
841:
842:
843:
844:
845:
846:
847:
848:
849:
850:
851:
852:
853:
854:
855:
856:
857:
858:
859: /*
860: * 3.1 - Lexical elements
861: */
862: void c3_1()
863: {
864: int a = 1;
865: int b = 2;
866: int c = 3;
867:
868: Filename = "c31.c";
869:
870: /* check for insignificance of white space */
871: #if ANSI
872: #include "c31h.h"
873: Filename = "c31.c";
874: #else
875: iequals(__LINE__, (a+b-c), (a + b
876: /* */-
877: c));
878: #endif
879:
880: /* a token uses the longest sequence of characters */
881: iequals(__LINE__, c+++b, 5);
882: iequals(__LINE__, b, 2);
883: iequals(__LINE__, c, 4);
884:
885: c3_1_1();
886: c3_1_2();
887: c3_1_2_1(19);
888: c3_1_2_2();
889: c3_1_2_3();
890: c3_1_2_4(0);
891: c3_1_2_5();
892: #if ANSI8709
893: c3_1_2_6(&c3_1_2_6);
894: #endif
895: c3_1_3_1();
896: c3_1_3_2();
897: c3_1_3_3();
898: c3_1_3_4();
899: c3_1_4();
900: c3_1_5();
901: c3_1_6();
902: c3_1_8();
903: c3_1_9();
904: }
905: #else /* if SKIP31 */
906:
907: void c3_1() { pr_skip("c3_1: SKIPPED ENTIRELY\n"); }
908: #endif /* SKIP31 */
909:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.