![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c35.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 c35.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 SKIP35 ! 12: /* ! 13: * 3.5 - Declarations ! 14: */ ! 15: #include "defs.h" ! 16: ! 17: ! 18: ! 19: ! 20: static void c3_5_1(); ! 21: static void c3_5_2(); ! 22: static void c3_5_2_1(); ! 23: static void c3_5_2_2(); ! 24: static void c3_5_2_3(); ! 25: static void c3_5_3(); ! 26: static void c3_5_4(); ! 27: static void c3_5_4_1(); ! 28: static void c3_5_4_2(); ! 29: static void c3_5_4_3(); ! 30: static void c3_5_5(); ! 31: static void c3_5_6(); ! 32: static void c3_5_7(); ! 33: extern void bitfields(); ! 34: ! 35: void c3_5() ! 36: { ! 37: Filename = "c35.c"; ! 38: c3_5_1(); ! 39: c3_5_2(); ! 40: c3_5_2_1(); ! 41: c3_5_2_2(); ! 42: c3_5_2_3(); ! 43: c3_5_3(); ! 44: c3_5_4(); ! 45: c3_5_4_1(); ! 46: c3_5_4_2(); ! 47: c3_5_4_3(); ! 48: c3_5_5(); ! 49: c3_5_6(); ! 50: c3_5_7(); ! 51: bitfields(); ! 52: } ! 53: ! 54: ! 55: /* ! 56: * 3.5.1 - Storage-class specifiers ! 57: */ ! 58: #if ANSI ! 59: extern void (*pc3_5_2)() = c3_5_2; /* extern allowed with initializer */ ! 60: #else ! 61: void (*pc3_5_2)() = c3_5_2; ! 62: #endif ! 63: static void c3_5_1() ! 64: { ! 65: /* just check for existence of the keywords here */ ! 66: auto int i; ! 67: register int j; ! 68: static int k; ! 69: extern int l; ! 70: typedef int M; ! 71: M m; ! 72: ! 73: i = j = k = l = m = 0; ! 74: checkthat(__LINE__, !(i || j || k || l || m)); ! 75: checkthat(__LINE__, pc3_5_2 == c3_5_2); ! 76: } ! 77: int l = 0; ! 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: /* ! 104: * 3.5.2 - Type specifiers ! 105: */ ! 106: static void c3_5_2() ! 107: { ! 108: /* verify that all forms are handled */ ! 109: int x1; ! 110: short int x2; ! 111: short x3; ! 112: long x4; ! 113: int long x5; ! 114: unsigned x6; ! 115: int unsigned x7; ! 116: char x8; ! 117: #if (ANSI || V7) ! 118: UCHAR x9; ! 119: USHORT x10; ! 120: int USHORT x11; ! 121: ULONG x12; ! 122: ULONG int x13; ! 123: #endif ! 124: ! 125: #if ANSI ! 126: typedef int INT; ! 127: typedef signed SIGNED; ! 128: { ! 129: signed char x14; ! 130: short signed x15; ! 131: short int signed x16; ! 132: signed long x17; ! 133: signed int long x18; ! 134: signed x19; ! 135: signed int x20; ! 136: double long x21; ! 137: const x22 = 22; ! 138: int short const x23 = 23; ! 139: volatile x24; ! 140: long volatile int x25; ! 141: const INT x26 = 26; ! 142: INT volatile x27; ! 143: INT const volatile x27a = 27; ! 144: ! 145: checkthat(__LINE__, sizeof(x24) == sizeof(int)); ! 146: } ! 147: #endif /* ANSI */ ! 148: ! 149: ! 150: ! 151: ! 152: ! 153: #if ANSI8712 /* 3.5.2 (cont.) */ ! 154: #define COMPATIBLE(t1, t2) { t1 v1={0}, *p1=&v1; t2 v2={0}, *p2=&v2; p1=p2; \ ! 155: checkthat(__LINE__, 0==mem_cmp((void *)p1, (void *)p2, sizeof(*p1))); } ! 156: #else ! 157: #define COMPATIBLE(t1, t2) { } ! 158: #endif ! 159: #if ANSI ! 160: { ! 161: struct s { int i:2; unsigned u:2; signed si:2; INT it:2; SIGNED st:2; } s = {-1, -1, -1, -1, -1}; ! 162: ! 163: iequals(__LINE__, s.u, 3); ! 164: iequals(__LINE__, s.si, -1); ! 165: iequals(__LINE__, s.st, -1); ! 166: #if ANSI8804 ! 167: if (s.i == 3) /* if "plain int" bitfield is unsigned */ ! 168: iequals(__LINE__, s.it, 3); ! 169: else if (s.i == -1) /* else if "plain int" bitfield is signed */ ! 170: iequals(__LINE__, s.it, -1); ! 171: else ! 172: complain(__LINE__); /* should take one of previous choices */ ! 173: #endif /* ANSI8804 */ ! 174: ! 175: COMPATIBLE(short, signed short); ! 176: COMPATIBLE(short, signed short int); ! 177: COMPATIBLE(unsigned short, unsigned short int); ! 178: COMPATIBLE(int, signed int); ! 179: COMPATIBLE(signed, signed int); ! 180: COMPATIBLE(unsigned, unsigned int); ! 181: COMPATIBLE(long, signed long); ! 182: COMPATIBLE(long, signed long int); ! 183: COMPATIBLE(unsigned long, unsigned long int); ! 184: COMPATIBLE(long unsigned, long int unsigned); ! 185: COMPATIBLE(short unsigned, unsigned int short); ! 186: ! 187: } ! 188: #endif /* ANSI */ ! 189: ! 190: { ! 191: float x28; ! 192: double x29; ! 193: void (*x30)(); ! 194: static x31 = 31; ! 195: ! 196: checkthat(__LINE__, sizeof(x31) == sizeof(int)); ! 197: iequals(__LINE__, x31, 31); ! 198: } ! 199: } /* end c3_5_2 */ ! 200: ! 201: ! 202: ! 203: /* ! 204: * 3.5.2.1 - Structure and union specifiers. ! 205: */ ! 206: static void c3_5_2_1() ! 207: { ! 208: /* structures and unions have the same form */ ! 209: struct S1 ! 210: { ! 211: char a; ! 212: short b; ! 213: int c; ! 214: long d; ! 215: float e; ! 216: double f; ! 217: unsigned g:1; ! 218: } s; ! 219: ! 220: union U1 ! 221: { ! 222: char u1_a; ! 223: short u1_b; ! 224: int u1_c; ! 225: unsigned u1_d; ! 226: long u1_e; ! 227: float u1_f; ! 228: double u1_g; ! 229: #if (ANSI || V7) ! 230: UCHAR u1_h; ! 231: USHORT u1_i; ! 232: ULONG u1_j; ! 233: #endif ! 234: #if ANSI ! 235: signed char u1_k; ! 236: long double u1_l; ! 237: #endif ! 238: } u, *pu = &u; ! 239: ! 240: #if (ANSI || UNIQ_MEMB_NAMES) ! 241: struct uniqnames ! 242: { ! 243: double a; ! 244: }; ! 245: #endif ! 246: ! 247: struct ! 248: { ! 249: unsigned x:1; ! 250: } onefield; ! 251: ! 252: ! 253: /* 3.5.2.1 (cont.) */ ! 254: struct ! 255: { ! 256: unsigned fa_f:1; ! 257: unsigned :0; /* break storage boundry */ ! 258: unsigned fa_g:1; ! 259: } forcealign; ! 260: #if ANSI ! 261: union ufields ! 262: { ! 263: unsigned x1 : 1; ! 264: unsigned x3 : 2+1; ! 265: } uf1; ! 266: enum { ONE=1, TWO }; ! 267: #endif /* ANSI */ ! 268: ! 269: struct fields ! 270: { ! 271: unsigned x1:1; ! 272: unsigned x2:2; ! 273: unsigned x3:3; ! 274: unsigned :1; /* just because it can be done */ ! 275: unsigned x4:4; ! 276: #if ANSI ! 277: int x5:'\2'; /* char-constant width */ ! 278: signed int x6:TWO; /* enum width */ ! 279: #endif /* ANSI */ ! 280: } b, b2, *p = &b2; ! 281: ! 282: #if !ANSI ! 283: checkthat(__LINE__, sizeof(onefield) == sizeof(unsigned)); ! 284: #endif ! 285: ! 286: #if ANSI ! 287: b.x6 = -1; ! 288: dequals(__LINE__, (double)b.x6, -1.); ! 289: #endif ! 290: b2.x4 = 0; ! 291: b.x1 = p->x1 = 1; ! 292: p->x2 = b.x1 + 2*p->x1; ! 293: b.x3 = p->x2 + 4*b.x1; ! 294: p->x4 += (b.x3 - b.x1) * p->x2; /* unsigned wraparound (3.2.1.1) */ ! 295: iequals(__LINE__, b.x1, 1); ! 296: iequals(__LINE__, p->x2, 3); ! 297: iequals(__LINE__, b.x3, 7); ! 298: iequals(__LINE__, p->x4, 2); ! 299: ! 300: ! 301: ! 302: ! 303: /* any interactions? */ /* 3.5.2.1 (cont.) */ ! 304: b.x2 = p->x3 = b.x4 = 0; ! 305: iequals(__LINE__, b.x1, 1); ! 306: iequals(__LINE__, p->x2, 3); ! 307: iequals(__LINE__, b.x3, 7); ! 308: iequals(__LINE__, p->x4, 2); ! 309: ! 310: ! 311: /* unsigned values convert modulo largest+1 */ ! 312: b.x1 = 2; ! 313: b.x2 = 4; ! 314: b.x3 = 8; ! 315: b.x4 = 16; ! 316: iequals(__LINE__, b.x1, 0); ! 317: iequals(__LINE__, b.x2, 0); ! 318: iequals(__LINE__, b.x3, 0); ! 319: iequals(__LINE__, b.x4, 0); ! 320: ! 321: /* there are not very many things about fields that are not ! 322: * implementation dependent. ! 323: * ! 324: */ ! 325: checkthat( - __LINE__, sizeof(forcealign) >= 2 * sizeof(onefield)); ! 326: ! 327: /* size of union is size of greatest element (+ padding?) */ ! 328: checkthat(__LINE__, sizeof(u) >= sizeof(double)); ! 329: #if ANSI ! 330: checkthat(__LINE__, sizeof(u) >= sizeof(long double)); ! 331: #endif ! 332: /* make sure all union members are accessible and have the right value */ ! 333: #if SIGNED_CHAR ! 334: u.u1_a = -1; ! 335: iequals(__LINE__, u.u1_a, -1); ! 336: #else ! 337: u.u1_a = 255; ! 338: iequals(__LINE__, u.u1_a, 255); ! 339: #endif ! 340: pu->u1_b = -1; ! 341: iequals(__LINE__, u.u1_b, -1); ! 342: u.u1_c = -2; ! 343: iequals(__LINE__, u.u1_c, -2); ! 344: u.u1_d = MAX_UINT; ! 345: checkthat(__LINE__, u.u1_d == MAX_UINT); ! 346: u.u1_e = -1; ! 347: lequals(__LINE__, u.u1_e, -1L); ! 348: u.u1_f = 1.0; ! 349: dequals(__LINE__, u.u1_f, 1.0); ! 350: u.u1_g = 2.2; ! 351: dequals(__LINE__, u.u1_g, 2.2); ! 352: ! 353: /* 3.5.2.1 (cont.) */ ! 354: ! 355: ! 356: ! 357: ! 358: ! 359: ! 360: #if ANSI ! 361: u.u1_h = MAX_UCHAR; ! 362: iequals(__LINE__, u.u1_h, MAX_UCHAR); ! 363: u.u1_i = MAX_USHORT; ! 364: checkthat(__LINE__, u.u1_i == MAX_USHORT); ! 365: u.u1_j = MAX_ULONG; ! 366: checkthat(__LINE__, u.u1_j == MAX_ULONG); ! 367: ! 368: u.u1_k = -1; ! 369: iequals(__LINE__, u.u1_k, -1); ! 370: u.u1_l = 3.3L; ! 371: ldequals(__LINE__, u.u1_l, 3.3L); ! 372: ! 373: #endif ! 374: ! 375: /* addresses of members must be monotonically increasing */ ! 376: checkthat(__LINE__, (char *)&s.a < (char *)&s.b); ! 377: checkthat(__LINE__, (char *)&s.b < (char *)&s.c); ! 378: checkthat(__LINE__, (char *)&s.c < (char *)&s.d); ! 379: checkthat(__LINE__, (char *)&s.d < (char *)&s.e); ! 380: checkthat(__LINE__, (char *)&s.e < (char *)&s.f); ! 381: ! 382: /* also, the address of the first member is the address of the structure */ ! 383: checkthat(__LINE__, (char *)&s.a == (char *)&s); ! 384: ! 385: /* structs and unions are padded, to allow array alignment */ ! 386: { ! 387: struct S1 as[2]; ! 388: union U1 au[2]; ! 389: ! 390: checkthat(__LINE__, &as[1] == (struct S1 *)(sizeof(struct S1) + (char *)&as[0])); ! 391: checkthat(__LINE__, &au[1] == (union U1 *)(sizeof(union U1) + (char *)&au[0])); ! 392: } ! 393: } /* end c3_5_2_1 */ ! 394: ! 395: ! 396: ! 397: ! 398: ! 399: ! 400: ! 401: ! 402: ! 403: /* ! 404: * 3.5.2.2 - Enumeration specifiers ! 405: */ ! 406: static void c3_5_2_2() ! 407: { ! 408: int i; ! 409: #if (V7 || ANSI) ! 410: /* number from 0 */ ! 411: enum a { a0, a1, a2, a3} aset; ! 412: ! 413: /* number explicitly, with the order picked up in the middle */ ! 414: enum b { b2=2, b1=1, b0=0, b1a, b2a, b2b=2} bset, *pbset; ! 415: ! 416: /* check aset */ ! 417: iequals(__LINE__, a0, 0); ! 418: iequals(__LINE__, a1, 1); ! 419: iequals(__LINE__, a2, 2); ! 420: iequals(__LINE__, a3, 3); ! 421: ! 422: /* check bset */ ! 423: iequals(__LINE__, b2, 2); ! 424: iequals(__LINE__, b1, 1); ! 425: iequals(__LINE__, b0, 0); ! 426: iequals(__LINE__, b1a, 1); ! 427: iequals(__LINE__, b2a, 2); ! 428: iequals(__LINE__, b2b, 2); ! 429: ! 430: /* before ANSI the use of enums was limited */ ! 431: bset = b2a; ! 432: pbset = &bset; ! 433: iequals(__LINE__, bset, b2a); ! 434: checkthat(__LINE__, bset==b2a); ! 435: checkthat(__LINE__, bset!=b1); ! 436: iequals(__LINE__, *pbset, bset); ! 437: ! 438: ! 439: ! 440: ! 441: ! 442: ! 443: ! 444: ! 445: ! 446: ! 447: ! 448: ! 449: ! 450: ! 451: ! 452: ! 453: /* 3.5.2.2 (cont.) */ ! 454: /* with ANSI, enums can be used anywhere an int can be used */ ! 455: #if ANSI ! 456: { ! 457: int a[b2b] = { 0, 1 }; ! 458: ! 459: iequals(__LINE__, a[b0], ivalue(0)); ! 460: switch (bset) ! 461: { ! 462: case b0: ! 463: i = 999; ! 464: break; ! 465: case b2: ! 466: i = 0; ! 467: break; ! 468: default : ! 469: i = 999; ! 470: break; ! 471: case a1: ! 472: /* not wise, but possible */ ! 473: i = 999; ! 474: break; ! 475: } ! 476: iequals(__LINE__, i, 0); ! 477: ! 478: iequals(__LINE__, ++bset, 3); ! 479: checkthat(__LINE__, sizeof(aset) <= sizeof(int)); ! 480: } ! 481: #endif /* ANSI */ ! 482: #endif /* V& || ANSI */ ! 483: } /* end c3_5_2_2 */ ! 484: ! 485: ! 486: ! 487: ! 488: ! 489: ! 490: ! 491: ! 492: ! 493: ! 494: ! 495: ! 496: ! 497: ! 498: ! 499: ! 500: ! 501: ! 502: ! 503: /* ! 504: * 3.5.2.3 - Tags. ! 505: */ ! 506: ! 507: /* mutually-referencing structures */ ! 508: struct mutrefa /* mutrefa is "tag" */ ! 509: { /* followed by "{ struct-decl-list }" */ ! 510: struct mutrefb *refb; /* "incomplete structure spec" for ptr-to-struct */ ! 511: int vala; ! 512: }; ! 513: struct mutrefb ! 514: { ! 515: struct mutrefa *refa; /* uses previously-decl "tag" */ ! 516: int valb; ! 517: }; ! 518: #if ANSI ! 519: struct mutrefb strb; /* "tentative def" -- 3.7.2 */ ! 520: #else ! 521: extern struct mutrefb strb; /* ordinary "extern" ref */ ! 522: #endif ! 523: struct mutrefa stra = { &strb, 11}; ! 524: struct mutrefb strb = { &stra, 13}; ! 525: /* "incomplete structure spec" must work for typedefs */ ! 526: typedef struct s2 S2; /* "incomplete structure spec" for typedef */ ! 527: struct s2 /* must be "completed" before size is needed */ ! 528: { ! 529: struct s2 * ps1; /* "incomplete spec" ok for ptr-to-struct */ ! 530: S2 *ps2; /* so is the equivalent typedef */ ! 531: int val; ! 532: } x1; /* "tentative def" of x1 */ ! 533: S2 x2; /* "tentative def" of x2 */ ! 534: ! 535: #if ANSI ! 536: /* "incomplete structure spec" must work for functions returning structures */ ! 537: struct s3 rets3(); ! 538: struct s3 /* "incomplete spec" must be completed before size is needed */ ! 539: { ! 540: int s3_1, s3_2, s3_3, s3_4; ! 541: } R3 = {1, 2, 3, 4}; ! 542: ! 543: ! 544: ! 545: ! 546: ! 547: ! 548: ! 549: ! 550: ! 551: ! 552: ! 553: /* 3.5.2.3 (cont.) */ ! 554: /* watch out for nested scope in structure tag ... */ ! 555: typedef struct nest NEST; ! 556: struct s3 rets3() ! 557: { /* introduces new block scope */ ! 558: /* should be ignored by typedef NEST */ ! 559: struct nest { int a, b;}; ! 560: ! 561: /* use "vacuous structure spec" to disambiguate */ ! 562: struct mutrefb; /* introduces new tag */ ! 563: struct mutrefa ! 564: { ! 565: struct mutrefb *refb; ! 566: }; ! 567: struct mutrefb ! 568: { ! 569: struct mutrefa *refa; ! 570: }; ! 571: return R3; ! 572: } ! 573: struct nest /* completing the spec from typedef NEST */ ! 574: { ! 575: int nest_1; ! 576: int nest_2; ! 577: } Nest = { 1, 2}; ! 578: #endif ! 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: /* 3.5.2.3 (cont.) */ ! 604: /* mutually-referencing unions */ ! 605: union mutrefua /* mutrefua is "tag" */ ! 606: { /* followed by "{ union-decl-list }" */ ! 607: union mutrefub *refub; /* "incomplete union spec" for ptr-to-union */ ! 608: int vala; ! 609: }; ! 610: union mutrefub ! 611: { ! 612: union mutrefua *refua; /* uses previously-decl "tag" */ ! 613: int valb; ! 614: }; ! 615: #if ANSI ! 616: union mutrefub unb; /* "tentative def" -- 3.7.2 */ ! 617: union mutrefua una = { &unb }; ! 618: union mutrefub unb = { &una }; ! 619: #else ! 620: extern union mutrefub unb; /* ordinary "extern" ref */ ! 621: union mutrefua una; ! 622: union mutrefub unb; ! 623: #endif ! 624: /* "incomplete union spec" must work for typedefs */ ! 625: typedef union u2 U2; /* "incomplete union spec" for typedef */ ! 626: union u2 /* must be "completed" before size is needed */ ! 627: { ! 628: union u2 * pu1; /* "incomplete spec" ok for ptr-to-union */ ! 629: U2 *pu2; /* so is the equivalent typedef */ ! 630: int val; ! 631: } ux1; /* "tentative def" of ux1 */ ! 632: U2 ux2; /* "tentative def" of ux2 */ ! 633: ! 634: #if ANSI ! 635: /* "incomplete union spec" must work for functions returning unions */ ! 636: union u3 retu3(); ! 637: union u3 /* "incomplete spec" must be completed before size is needed */ ! 638: { ! 639: int u3_1; char u3_2; ! 640: } U3 = {1}; ! 641: ! 642: ! 643: ! 644: ! 645: ! 646: ! 647: ! 648: ! 649: ! 650: ! 651: ! 652: ! 653: /* 3.5.2.3 (cont.) */ ! 654: /* watch out for nested scope in union tag ... */ ! 655: typedef union unest UNEST; ! 656: union u3 retu3() ! 657: { /* introduces new block scope */ ! 658: /* should be ignored by typedef UNEST */ ! 659: union unest { int a, b;}; ! 660: ! 661: /* use "vacuous union spec" to disambiguate */ ! 662: union mutrefub; /* introduces new tag */ ! 663: union mutrefua ! 664: { ! 665: union mutrefub *refub; ! 666: }; ! 667: union mutrefub ! 668: { ! 669: union mutrefua *refua; ! 670: }; ! 671: return U3; ! 672: } ! 673: union unest /* completing the spec from typedef UNEST */ ! 674: { ! 675: int unest_1; ! 676: float unest_2; ! 677: } UNest = { 1 }; ! 678: #endif /* ANSI */ ! 679: ! 680: ! 681: ! 682: ! 683: /* 3.5.2.3 (cont.) */ ! 684: static void c3_5_2_3() ! 685: { ! 686: char *p = 0; /* This ptr will be used to test ptr-to-struct cast */ ! 687: /* make declarations using struct/union tags */ ! 688: struct s1 ! 689: { ! 690: int a, b, c; /* unique struct member name spaces were tested in 3.1.2.3; */ ! 691: }; /* here we use K&R-compatible name rules */ ! 692: struct s1 a, b, c; ! 693: union u1 ! 694: { ! 695: int i; ! 696: double d; ! 697: }; ! 698: ! 699: ! 700: ! 701: ! 702: ! 703: /* 3.5.2.3 (cont.) */ ! 704: union u1 u1; ! 705: ! 706: auto struct astr /* test syntax of stor-cl with struct */ ! 707: { ! 708: int a; ! 709: } astr; ! 710: ! 711: static struct astr sstr = {123}; ! 712: ! 713: /* make sure that they exist */ ! 714: a.a = 1; ! 715: iequals(__LINE__, a.a, 1); /* (auto) local struct holds proper value */ ! 716: u1.i = 2; ! 717: iequals(__LINE__, u1.i, 2); /* (auto) local union holds proper value */ ! 718: ! 719: /* make sure forward references work (see x1 and x2 on prev page) */ ! 720: x1.val = 3; ! 721: x2.val = 4; ! 722: x2.ps1 = &x1; ! 723: x2.ps2 = &x2; /* points to itself !! */ ! 724: iequals(__LINE__, x2.ps1->val, 3); /* ptr-to-struct in struct works */ ! 725: iequals(__LINE__, x2.ps2->val, 4); /* ptr-to-struct in struct works */ ! 726: ! 727: /* unions can accept and hold properly-typed values */ ! 728: ux1.val = 3; ! 729: ux2.val = 4; ! 730: iequals(__LINE__, ux1.val, ivalue(3)); ! 731: iequals(__LINE__, ux2.val, ivalue(4)); ! 732: ux2.pu1 = &ux1; ! 733: aequals(__LINE__, (char *)ux2.pu1, (char *)avalue(&ux1)); ! 734: ! 735: /* mutually-referencing structs */ ! 736: iequals(__LINE__, stra.vala, 11); ! 737: iequals(__LINE__, strb.valb, 13); ! 738: iequals(__LINE__, stra.refb->valb, 13); ! 739: iequals(__LINE__, strb.refa->vala, 11); ! 740: #if ANSI ! 741: /* mutually-referencing unions */ ! 742: aequals(__LINE__, (char *)una.refub, (char *)avalue(&unb)); ! 743: aequals(__LINE__, (char *)unb.refua, (char *)avalue(&una)); ! 744: #endif ! 745: /* astr and sstr are different */ ! 746: astr.a = 1; ! 747: iequals(__LINE__, sstr.a, 123); ! 748: ! 749: ! 750: ! 751: ! 752: ! 753: /* 3.5.2.3 (cont.) */ ! 754: #if ANSI ! 755: iequals(__LINE__, Nest.nest_2, 2); /* test that block-local "nest" was not */ ! 756: iequals(__LINE__, rets3().s3_4, 4); /* seen outside its block */ ! 757: ! 758: /* A cast (3.3.4) uses a "type-name" (3.5.5), which can decl a tag */ ! 759: p = (char *)(struct incast { int a; int b; } * )p; /* decls tag "incast" */ ! 760: checkthat(__LINE__, sizeof(struct incast) > 0); /* test that struct incast decl'ed properly */ ! 761: ! 762: { ! 763: struct s1; /* new scope */ ! 764: struct s1 { char c; } sc; ! 765: ! 766: sc.c = ivalue('a'); ! 767: iequals(__LINE__, sc.c, 'a'); ! 768: } ! 769: ! 770: #endif /* ANSI */ ! 771: } /* end c3_5_2_3 */ ! 772: ! 773: ! 774: ! 775: ! 776: ! 777: ! 778: ! 779: ! 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.5.3 - const and volatile ! 805: */ ! 806: static void c3_5_3() ! 807: { ! 808: #if ANSI ! 809: const char c1; ! 810: const UCHAR c2; ! 811: const signed char c3; ! 812: const short c4; ! 813: const USHORT c5; ! 814: const int c6; ! 815: const unsigned int c7; ! 816: const long c8; ! 817: const ULONG c9; ! 818: const float c10; ! 819: const double c11; ! 820: const long double c12; ! 821: volatile char v1; ! 822: volatile UCHAR v2; ! 823: volatile signed char v3; ! 824: volatile short v4; ! 825: volatile USHORT v5; ! 826: volatile int v6; ! 827: volatile unsigned int v7; ! 828: volatile long v8; ! 829: volatile ULONG v9; ! 830: volatile float v10; ! 831: volatile double v11; ! 832: volatile long double v12; ! 833: volatile int * const cv1; ! 834: const int * volatile cv2; ! 835: int *pi; ! 836: int i; ! 837: const int *pci = &i; /* may be assigned */ ! 838: volatile int *pvi = &i; ! 839: const struct sa { int i; } csa; ! 840: struct sa sa2; /* doesn't inherit const */ ! 841: ! 842: pi = (int *)pci; /* ok with cast */ ! 843: checkthat(__LINE__, pi == &i); ! 844: pi = (int *)pvi; ! 845: checkthat(__LINE__, pi == &i); ! 846: sa2.i = 1; /* ok, not const */ ! 847: iequals(__LINE__, sa2.i, 1); ! 848: COMPATIBLE(volatile int, int volatile); ! 849: COMPATIBLE(signed volatile int, int volatile); ! 850: COMPATIBLE(short volatile, signed volatile short int); ! 851: ! 852: #endif /* ANSI */ ! 853: } /* end c3_5_3 */ ! 854: ! 855: ! 856: /* ! 857: * 3.5.4 - Declarators ! 858: */ ! 859: typedef int INT; ! 860: int func1() { return 7;} ! 861: INT func2() { return 11;} ! 862: int (*fpfi1())(){return func1;} /* func ret ptr to func ret int */ ! 863: typedef int (*PFI)(); /* ptr to func ret ptr to int */ ! 864: PFI fpfi2(){return func2;} /* func ret ptr to func ret int */ ! 865: static void c3_5_4() ! 866: { ! 867: /* 2d-arr of ptr to func ret ptr to func ret int */ ! 868: int (*(*apfpfi1[2][3])())(); ! 869: int i, j; ! 870: int *p1 = &i; ! 871: int (*p2); ! 872: int ((*p3)); /* declarator in parens is identical to unadorned */ ! 873: int (func1)(); /* declarator in parens is identical to unadorned */ ! 874: ! 875: /* try the same thing with typedefs */ ! 876: typedef PFI (*PFPFI)(); /* ptr to func ret ptr to func ret int */ ! 877: PFPFI apfpfi2[2][3]; ! 878: ! 879: p2 = (int *)avalue(p1); ! 880: p3 = p2; ! 881: checkthat(__LINE__, p3 == p1); ! 882: apfpfi1[1][2] = fpfi1; ! 883: apfpfi2[1][2] = fpfi2; ! 884: i = 1, j = 2; ! 885: iequals(__LINE__, (*(*apfpfi1[i][j])())(), 7); ! 886: iequals(__LINE__, (*(*apfpfi2[i][j])())(), 11); ! 887: ! 888: #if ANSI ! 889: { ! 890: struct { int i1; const int i2; } x = { 1, 2 }; ! 891: ! 892: x.i1 = ivalue(3); /* not const */ ! 893: iequals(__LINE__, x.i1, 3); ! 894: } ! 895: #endif /* ANSI */ ! 896: } /* end c3_5_4 */ ! 897: ! 898: ! 899: ! 900: ! 901: ! 902: ! 903: ! 904: /* ! 905: * 3.5.4.1 - Pointer declarators ! 906: */ ! 907: static void c3_5_4_1() ! 908: { ! 909: char c = 'x'; ! 910: char *pc = &c; ! 911: char **ppc = &pc; ! 912: char ***pppc = &ppc; ! 913: char ****ppppc = &pppc; ! 914: char *****pppppc = &ppppc; ! 915: char ******ppppppc = &pppppc; ! 916: typedef char C; ! 917: typedef C *PC; ! 918: typedef PC *PPC; ! 919: typedef PPC *PPPC; ! 920: typedef PPPC *PPPPC; ! 921: typedef PPPPC *PPPPPC; ! 922: typedef PPPPPC *PPPPPPC; ! 923: C d = 'y'; ! 924: PC pd = &d; ! 925: PPC ppd = &pd; ! 926: PPPC pppd = &ppd; ! 927: PPPPC ppppd = &pppd; ! 928: PPPPPC pppppd = &ppppd; ! 929: PPPPPPC ppppppd = &pppppd; ! 930: ! 931: #if ANSI ! 932: const char *pconst = "constant string literal"; ! 933: char carray[] = "variable string literal"; char *const constp = carray; ! 934: volatile int *vp = 0; ! 935: const char * volatile * pvpconst = &pconst; ! 936: ! 937: ++pconst; ! 938: iequals(__LINE__, *pconst, 'o'); ! 939: ++*constp; ! 940: iequals(__LINE__, *constp, 'v'+1); ! 941: vp; ! 942: iequals(__LINE__, **pvpconst, 'o'); ! 943: { /* Now test that volatile int * and int signed volatile * are compatible... */ ! 944: volatile int *v1={0}, **p1=&v1; ! 945: int signed volatile *v2={0}, **p2=&v2; ! 946: p1=p2; ! 947: checkthat(__LINE__, 0==mem_cmp((void *)p1, (void *)p2, sizeof(*p1))); ! 948: } ! 949: #endif ! 950: iequals(__LINE__, ******ppppppc, 'x'); ! 951: iequals(__LINE__, ******ppppppd, 'y'); ! 952: } /* end c3_5_4_1 */ ! 953: ! 954: /* ! 955: * 3.5.4.2 - Array declarators ! 956: */ ! 957: /* dimension can be omitted for first dimension on external */ ! 958: extern int INTarray[][3][2][3]; /* links with INTarray on next page */ ! 959: ! 960: static void check_array(iarray) ! 961: /* first dimension can be left off on formal parameter */ ! 962: int iarray[][3][2][3]; ! 963: { ! 964: int i, j, k, l, count; ! 965: ! 966: /* as initialized below, there are 36 sequential items in the array */ ! 967: for (count=0, i=0; i < 2; ++i) ! 968: for (j = 0; j < 3; ++j) ! 969: for (k = 0; k < 2; ++k) ! 970: for (l = 0; l < 3; ++l, ++count) ! 971: iequals(__LINE__, iarray[i][j][k][l], count); ! 972: } ! 973: ! 974: static void c3_5_4_2() ! 975: { ! 976: double d[2], *dp[2]; ! 977: ! 978: /* make sure that the first dimension gets handled correctly */ ! 979: check_array(INTarray); ! 980: ! 981: /* array of doubles vs. array of pointers to doubles */ ! 982: d[0] = 0.0; ! 983: d[1] = 2.0; ! 984: dp[0] = d; ! 985: dp[1] = d+1; ! 986: dequals(__LINE__, *dp[1], 2.0); ! 987: ! 988: /* just to be perverse */ ! 989: *dp[0] = (d[0] && d[1]) ^ (d[0] || d[1]); ! 990: dequals(__LINE__, d[0], 1.0); ! 991: #if ANSI ! 992: { ! 993: void ckarr(); ! 994: ! 995: ckarr(); ! 996: } ! 997: #endif /* ANSI */ ! 998: } /* end c3_5_4_2 */ ! 999: ! 1000: ! 1001: ! 1002: ! 1003: ! 1004: /* 3.5.4.2 (cont.) */ ! 1005: /* array with size is compatible to one lacking size */ ! 1006: /* dimension can be omitted for first dimension if initialized */ ! 1007: int INTarray[][3][2][3] = ! 1008: { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20, ! 1009: 21,22,23,24,25,26,27,28,29,30,31,32,33,34,35}; ! 1010: ! 1011: #if ANSI ! 1012: int arrfn1(); ! 1013: int arrfn1 PARMS((int [][3][2][3])); ! 1014: #if NEW_STYLE_FN_DEF ! 1015: int arrfn1(int a[2][3][2][3]) ! 1016: #else ! 1017: int arrfn1(a) ! 1018: int a[2][3][2][3]; ! 1019: #endif /* NEW_STYLE_FN_DEF */ ! 1020: { ! 1021: return (a[0][0][0][1]); ! 1022: } ! 1023: void ckarr() ! 1024: { ! 1025: int (*parf1)() = arrfn1; ! 1026: int (*parf2) PARMS((int (*a)[3][2][3])) = &arrfn1; ! 1027: ! 1028: iequals(__LINE__, arrfn1(INTarray), 1); ! 1029: iequals(__LINE__, parf1(INTarray), 1); ! 1030: iequals(__LINE__, (*parf2)(INTarray), 1); ! 1031: } ! 1032: #endif /* ANSI */ ! 1033: ! 1034: ! 1035: ! 1036: ! 1037: ! 1038: ! 1039: ! 1040: ! 1041: ! 1042: ! 1043: ! 1044: ! 1045: ! 1046: ! 1047: ! 1048: ! 1049: ! 1050: ! 1051: ! 1052: ! 1053: ! 1054: /* ! 1055: * 3.5.4.3 - Function declarators ! 1056: */ ! 1057: ! 1058: /* ANSI rules for compatible function types: ! 1059: First, convert parameters of type fn or array. ! 1060: Then, delete any qualifiers on top type of any parameter. ! 1061: Then, for all cases, return types must be compatible. ! 1062: Then, one of the following must be true, for compatible fn types: ! 1063: ! 1064: 1. Both fn types are old-style (no parameter information). ! 1065: 2. If both are prototypes, they agree in number of parms, ! 1066: they agree in use of ellipsis, and parms are compatible. ! 1067: 3. If one is prototype and other is old-style declaration (with ! 1068: empty parentheses), the prototype must not have ellipsis ! 1069: or non-default parm types. ! 1070: 4. Otherwise, one is a prototype and the other is an old-style ! 1071: function definition. The number of parms must agree, and ! 1072: each prototype parm must be compatible with the promoted(!) ! 1073: definition parm. ! 1074: */ ! 1075: ! 1076: #if ANSI && HAS_PROTOTYPES ! 1077: int niladic(void) { return 99; } ! 1078: int fn_char(int); ! 1079: int fn_char(); /* ok by rule 3 */ ! 1080: int fn_dbl(double); ! 1081: ! 1082: #if ANSI8703 /* now old-style fn parms are taken as widened before type-matching */ ! 1083: int fn_char(c) char c; { return 98; } /* ok by rule 4 */ ! 1084: int fn_dbl(f) float f; { return 97; } /* ok by rule 4 */ ! 1085: #else ! 1086: int fn_char(c) int c; { return 98; } ! 1087: int fn_dbl(f) double f; { return 97; } ! 1088: #endif /* ANSI8703 */ ! 1089: int proto(char, short const int, int, int volatile long, float, double, long double); ! 1090: ! 1091: static void c3_5_4_3() ! 1092: { ! 1093: int proto(char, const short, int, volatile long, float, double, register long double); /* ok by rule 2 */ ! 1094: ! 1095: iequals(__LINE__, niladic(), 99); ! 1096: iequals(__LINE__, fn_char(1), 98); ! 1097: iequals(__LINE__, fn_dbl(0.), 97); ! 1098: iequals(__LINE__, proto(1L, 1.0, 1L, '\01', 1, 1, 1), 7); ! 1099: ! 1100: ! 1101: ! 1102: ! 1103: ! 1104: /* 3.5.4.3 (cont.) */ ! 1105: #if ANSI8804 ! 1106: { ! 1107: int arrfn1(); ! 1108: signed int arrfn1(); /* ok by rule 1 */ ! 1109: ! 1110: /* ambiguity of typedef vs identifier is always resolved to typedef */ ! 1111: /* so, single typedef name in parentheses is taken as fn of one parm, */ ! 1112: /* not as redundant parentheses on a new identifier */ ! 1113: typedef int I; ! 1114: int fpfi(int (*)(I)); /* parm is ptr to function of int arg returning int */ ! 1115: iequals(__LINE__, fpfi(fn_char), ivalue(98)); ! 1116: } ! 1117: #endif /* ANSI8804 */ ! 1118: } /* end c3_5_4_3 (ANSI version) */ ! 1119: ! 1120: #if ANSI8804 ! 1121: int fpfi(int pfi(int)) { return pfi(0); } ! 1122: #endif ! 1123: ! 1124: ! 1125: int arrfn1(); ! 1126: signed int arrfn1(); /* ok by rule 1 */ ! 1127: ! 1128: #if NEW_STYLE_FN_DEF ! 1129: int proto(char x1, const short x2, int x3, volatile long x4, float x5, double x6, long double x7) ! 1130: #else ! 1131: int proto(x1, x2, x3, x4, x5, x6, x7) ! 1132: char x1; const short x2; register int x3; volatile long x4; float x5; double x6; long double x7; ! 1133: #endif /* NEW_STYLE_FN_DEF */ ! 1134: { ! 1135: return((int)(x1+x2+x3+x4+x5+x6+x7)); ! 1136: } ! 1137: #else /* if !ANSI || !HAS_PROTOTYPES */ ! 1138: static void c3_5_4_3() ! 1139: { ! 1140: /* nothing to test, if no prototypes */ ! 1141: } ! 1142: #endif /* ANSI && HAS_PROTOTYPES */ ! 1143: ! 1144: ! 1145: ! 1146: ! 1147: ! 1148: ! 1149: ! 1150: ! 1151: ! 1152: ! 1153: ! 1154: /* ! 1155: * 3.5.5 - Type names ! 1156: */ ! 1157: static void c3_5_5() ! 1158: { ! 1159: /* these are tested all over, but a few extra ones here ... */ ! 1160: ! 1161: #if ANSI ! 1162: char *(*(*pfpapc1)(int, ...))[10]; ! 1163: char *(*(*pfpapc2)(char *(*)()))[11] = 0; ! 1164: iequals(__LINE__, sizeof( char *(*(*)(int, ...))[10]), sizeof pfpapc1); ! 1165: pfpapc1 = (char *(*(*)(int, ...))[10])pfpapc2; ! 1166: #else ! 1167: char *(*(*pfpapc1)())[10]; ! 1168: char *(*(*pfpapc2)())[11] = 0; ! 1169: iequals(__LINE__, sizeof(char *(*(*)())[10]), sizeof pfpapc1); ! 1170: pfpapc1 = (char *(*(*)())[10])pfpapc2; ! 1171: #endif ! 1172: checkthat( - __LINE__, pfpapc1 == 0); ! 1173: } ! 1174: ! 1175: ! 1176: ! 1177: ! 1178: ! 1179: ! 1180: ! 1181: ! 1182: ! 1183: ! 1184: ! 1185: ! 1186: ! 1187: ! 1188: ! 1189: ! 1190: ! 1191: ! 1192: ! 1193: ! 1194: ! 1195: ! 1196: ! 1197: ! 1198: ! 1199: ! 1200: ! 1201: ! 1202: ! 1203: ! 1204: /* ! 1205: * 3.5.6 - Type definitions ! 1206: */ ! 1207: static void c3_5_6() ! 1208: { ! 1209: /* typedef is not a new type, but rather a synonym. */ ! 1210: struct x ! 1211: { ! 1212: unsigned a:1; ! 1213: unsigned b:2; ! 1214: }; ! 1215: typedef struct x X; ! 1216: X x1; ! 1217: struct x x2; ! 1218: unsigned us1; ! 1219: typedef unsigned US; ! 1220: US us2; ! 1221: ! 1222: x1.a = 2; ! 1223: x2.a = 2; ! 1224: iequals(__LINE__, x1.a, 0); ! 1225: iequals(__LINE__, x2.a, 0); ! 1226: us1 = us2 = MAX_UINT; ! 1227: iequals(__LINE__, ++us1, 0); ! 1228: iequals(__LINE__, ++us2, 0); ! 1229: ! 1230: /* ambiguity of typedef vs identifier is always resolved to typedef */ ! 1231: /* In this case, "type spec shall not be omitted" means that if a symbol */ ! 1232: /* could be either a type-name on an un-named field, or an identifier naming a field, */ ! 1233: /* then it must be the former. */ ! 1234: #if ANSI8804 ! 1235: { ! 1236: typedef int I; ! 1237: struct { const I : 2; int j : 2; } x = {1}; /* "const I" is the type of un-named field */ ! 1238: ! 1239: iequals(__LINE__, x.j, 1); ! 1240: } ! 1241: #endif /* ANSI8804 */ ! 1242: ! 1243: ! 1244: ! 1245: ! 1246: ! 1247: ! 1248: ! 1249: ! 1250: ! 1251: ! 1252: ! 1253: ! 1254: /* 3.5.6 (cont.) */ ! 1255: #if ANSI ! 1256: { ! 1257: /* typedefs can be nested */ ! 1258: typedef int X; ! 1259: X a = 0; ! 1260: iequals(__LINE__, a, 0); ! 1261: { ! 1262: /* and redefined in other nested contexts */ ! 1263: X X = 3; ! 1264: iequals(__LINE__, X, 3); ! 1265: } ! 1266: /* also, they don't interfere with other name spaces */ ! 1267: { ! 1268: #if TAG_AND_MEMB_SPACES ! 1269: static struct X { int X; } x = {7}; ! 1270: static struct Y { int Y; } y = {8}; ! 1271: #else ! 1272: static struct X { int X1; } x = {7}; ! 1273: static struct Y { int Y1; } y = {8}; ! 1274: #endif ! 1275: static enum Z { e0, e1, e2 = (X)3 } e; ! 1276: struct X *px = (struct X *)&y; ! 1277: ! 1278: e = e2; ! 1279: iequals(__LINE__, a, 0); ! 1280: iequals(__LINE__, e, 3); ! 1281: #if TAG_AND_MEMB_SPACES ! 1282: iequals(__LINE__, x.X, 7); ! 1283: iequals(__LINE__, (X) px->X, 8); ! 1284: #else ! 1285: iequals(__LINE__, x.X1, 7); ! 1286: iequals(__LINE__, (X) px->X1, 8); ! 1287: #endif ! 1288: } ! 1289: } ! 1290: #endif /* ANSI */ ! 1291: } /* end c3_5_6 */ ! 1292: ! 1293: ! 1294: ! 1295: ! 1296: ! 1297: ! 1298: ! 1299: ! 1300: ! 1301: ! 1302: ! 1303: ! 1304: /* ! 1305: * 3.5.7 - Initialization ! 1306: */ ! 1307: static int sarray[5]; ! 1308: static struct { int a, b;} st; ! 1309: static struct s1 {int a, b;} s1_init = {3, 4}; ! 1310: ! 1311: struct ! 1312: { ! 1313: char *strings[2]; ! 1314: struct ! 1315: { ! 1316: int a; ! 1317: int nums[2][3]; ! 1318: }s; ! 1319: }x3[] = ! 1320: /* note that each explicit initializer list can have an extra comma */ ! 1321: {{{"abc", "def", }, {1, {{2,3,4,},{5,6,7,},},},}, ! 1322: {{"ghi", "jkl"}, {9, {{8,7,6},{5,4,3}}}}}, ! 1323: #if ANSI /* very strict about the "Ritchie" rules */ ! 1324: x4[] = {"abc", "def", 1,2,3,4,5,6,7, {"ghi", "jkl", {9, {8,7,6,{5,4,3}}}}}; ! 1325: int a1[2][2][2] = { 0, 1, 2, 3, {4, 5, 6, 7}}; ! 1326: #else /* other compilers, e.g. PCC, vary, so use full braces */ ! 1327: x4[] = {{{"abc", "def", }, {1, {{2,3,4,},{5,6,7,},},},}, {{"ghi", "jkl"}, {9, {{8,7,6},{5,4,3}}}}}; ! 1328: int a1[2][2][2] = { 0, 1, 2, 3, 4, 5, 6, 7}; ! 1329: #endif ! 1330: int a2[2][2][2] = { 0, 1, 2, 3, 4, 5, 6, 7}; ! 1331: ! 1332: /* special case of a string literal */ ! 1333: char s1[] = "abc"; ! 1334: char s2[] = {'a', 'b', 'c', 0}; ! 1335: #if ANSI ! 1336: char s3[3] = { "def" } ; /* optional braces */ ! 1337: #else ! 1338: char s3[3] = "de"; ! 1339: #endif ! 1340: #if ANSI8712 && WIDE_CHARS ! 1341: wchar_t s4[] = L"abc"; /* "wide-char" string */ ! 1342: #endif ! 1343: ! 1344: /* if there are not enough initializers, close off the aggregate with 0 */ ! 1345: int a3[2][2][2] = ! 1346: {{{99}}, {{98}}}; ! 1347: struct ! 1348: { ! 1349: struct { int a, b;} sm1; ! 1350: struct { int a, b;} sm2; ! 1351: } s = ! 1352: {{11},{13}}; ! 1353: ! 1354: ! 1355: /* 3.5.7 (cont.) */ ! 1356: #if ANSI ! 1357: /* unions can be intiialized to their first element */ ! 1358: union ! 1359: { ! 1360: double d; ! 1361: int i; ! 1362: } u1 = {2.2}; ! 1363: #endif ! 1364: ! 1365: static void c3_5_7() ! 1366: { ! 1367: int i = {2}; ! 1368: int j, k, count; ! 1369: /* auto variables can be initialized to arbitrary expressions */ ! 1370: int a = {1}, b = a*3, c = ivalue(5); /* braces optional on single scalar */ ! 1371: ! 1372: #if ANSI ! 1373: union ! 1374: { ! 1375: double d; ! 1376: int i; ! 1377: } u2 = {3.3}; ! 1378: /* aggregates can be initialized */ ! 1379: int aarray[4] = {0, 1, 2, 3}; ! 1380: struct { int a[3], b; } w[] = { {1}, 2 }; /* "inconsistent-braces" example from 3.5.7 */ ! 1381: ! 1382: for (i = 0; i < 4; ++i) ! 1383: iequals(__LINE__, aarray[i], i); ! 1384: iequals(__LINE__, w[0].a[0], 1); ! 1385: iequals(__LINE__, w[1].a[0], 2); ! 1386: iequals(__LINE__, w[0].a[1], 0); ! 1387: iequals(__LINE__, w[1].a[1], 0); ! 1388: iequals(__LINE__, w[0].b, 0); ! 1389: #endif /* ANSI */ ! 1390: ! 1391: #if ANSI ! 1392: /* initialize one structure with another */ ! 1393: { ! 1394: struct s1 x = s1_init; ! 1395: iequals(__LINE__, x.a, 3); ! 1396: iequals(__LINE__, x.b, 4); ! 1397: } ! 1398: #endif ! 1399: ! 1400: ! 1401: ! 1402: ! 1403: ! 1404: /* 3.5.7 (cont.) */ ! 1405: iequals(__LINE__, a, 1); ! 1406: iequals(__LINE__, b, 3); ! 1407: iequals(__LINE__, c, 5); ! 1408: ! 1409: /* static items without initializers are initialized to 0 */ ! 1410: for (i = 0; i < 5; ++i) ! 1411: iequals(__LINE__, sarray[i], 0); ! 1412: iequals(__LINE__, st.a, 0); ! 1413: iequals(__LINE__, st.b, 0); ! 1414: ! 1415: /* x3 used the explicit form for sub aggregates */ ! 1416: checkthat(__LINE__, 0 == str_cmp(x3[1].strings[1], "jkl")); ! 1417: iequals(__LINE__, x3[0].s.nums[0][0], 2); ! 1418: iequals(__LINE__, x3[0].s.nums[1][2], 7); ! 1419: iequals(__LINE__, x3[1].s.nums[0][0], 8); ! 1420: iequals(__LINE__, x3[1].s.nums[1][2], 3); ! 1421: ! 1422: /* x4 left out some of them , but should look the same */ ! 1423: checkthat(__LINE__, 0 == str_cmp(x4[1].strings[1], "jkl")); ! 1424: iequals(__LINE__, x4[0].s.nums[0][0], 2); ! 1425: iequals(__LINE__, x4[0].s.nums[1][2], 7); ! 1426: iequals(__LINE__, x4[1].s.nums[0][0], 8); ! 1427: iequals(__LINE__, x4[1].s.nums[1][2], 3); ! 1428: ! 1429: /* the two should be identical */ ! 1430: checkthat(__LINE__, sizeof x3 == sizeof x4); ! 1431: ! 1432: /* elision of braces */ ! 1433: for (i = 0, count = 0; i < 2; ++i) ! 1434: for (j = 0; j < 2; ++j) ! 1435: for (k = 0; k < 2; ++k, ++count) ! 1436: iequals(__LINE__, a1[i][j][k], count); ! 1437: for (i = 0, count = 0; i < 2; ++i) ! 1438: for (j = 0; j < 2; ++j) ! 1439: for (k = 0; k < 2; ++k, ++count) ! 1440: iequals(__LINE__, a2[i][j][k], count); ! 1441: ! 1442: /* special forms using string literal initialization */ ! 1443: checkthat(__LINE__, !str_cmp(s1, s2)); ! 1444: iequals(__LINE__, s3[0], 'd'); ! 1445: iequals(__LINE__, s3[1], 'e'); ! 1446: iequals(__LINE__, s3[2], ANSI ? 'f' : '\0'); ! 1447: ! 1448: ! 1449: ! 1450: ! 1451: ! 1452: ! 1453: ! 1454: /* 3.5.7 (cont.) */ ! 1455: /* partial intialization fills with 0 */ ! 1456: for (i = 0, count = 0; i < 2; ++i) ! 1457: for (j = 0; j < 2; ++j) ! 1458: for (k = 0; k < 2; ++k, ++count) ! 1459: if (count == 0) ! 1460: iequals(__LINE__, a3[i][j][k], 99); ! 1461: else if (count == 4) ! 1462: iequals(__LINE__, a3[i][j][k], 98); ! 1463: else ! 1464: iequals(__LINE__, a3[i][j][k], 0); ! 1465: iequals(__LINE__, s.sm1.a, 11); ! 1466: iequals(__LINE__, s.sm1.b, 0); ! 1467: iequals(__LINE__, s.sm2.a, 13); ! 1468: iequals(__LINE__, s.sm2.b, 0); ! 1469: ! 1470: #if ANSI ! 1471: /* check union initialization */ ! 1472: dequals(__LINE__, u1.d, 2.2); ! 1473: dequals(__LINE__, u2.d, 3.3); ! 1474: ! 1475: /* auto aggregates are zero-padded */ ! 1476: { ! 1477: auto int a[10] = {1}; ! 1478: int i; ! 1479: ! 1480: for (i = 1; i < 10; ++i) ! 1481: iequals(__LINE__, a[i], 0); ! 1482: } ! 1483: /* full-expr in initializer is sequence point */ ! 1484: { ! 1485: int a = ivalue(1), b = a++, c = ++b; ! 1486: ! 1487: iequals(__LINE__, a, ivalue(2)); ! 1488: iequals(__LINE__, b, ivalue(2)); ! 1489: iequals(__LINE__, c, ivalue(2)); ! 1490: } ! 1491: ! 1492: #endif /* ANSI */ ! 1493: ! 1494: ! 1495: ! 1496: ! 1497: ! 1498: ! 1499: ! 1500: ! 1501: ! 1502: ! 1503: ! 1504: /* 3.5.7 (cont.) */ ! 1505: #if ANSI8804 ! 1506: /* un-named members are ignored during initialization */ ! 1507: { ! 1508: struct s1 ! 1509: { ! 1510: unsigned m1:2; ! 1511: unsigned :2; ! 1512: unsigned m2:2; ! 1513: unsigned m3:2; ! 1514: } s1 = { 1, 2 }; ! 1515: iequals(__LINE__, s1.m1, 1); ! 1516: iequals(__LINE__, s1.m2, 2); ! 1517: iequals(__LINE__, s1.m3, 0); ! 1518: } ! 1519: #endif /* ANSI8804 */ ! 1520: ! 1521: } /* end c3_5_7 */ ! 1522: ! 1523: #else /* if SKIP35 */ ! 1524: void c3_5() { pr_skip("c3_5: SKIPPED ENTIRELY\n"); } ! 1525: #endif /* SKIP35 */ ! 1526:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.