![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c33a.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 c33a.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 SKIP33 ! 12: /* ! 13: * 3.3 - Expressions ! 14: */ ! 15: #include "defs.h" ! 16: ! 17: ! 18: static void c3_3_1(); ! 19: static void c3_3_2_1(); ! 20: static void c3_3_2_2(); ! 21: static void c3_3_2_3(); ! 22: static void c3_3_2_4(); ! 23: static void c3_3_3(); ! 24: static void c3_3_3_1(); ! 25: static void c3_3_3_2(); ! 26: static void c3_3_3_3(); ! 27: static void c3_3_3_4(); ! 28: static void c3_3_4(); ! 29: extern void c3_3b(); /* in c33b.c */ ! 30: extern void structures(); /* in c33c.c */ ! 31: static long f() { return 99; } ! 32: /* ! 33: * 3.3 - Expressions ! 34: */ ! 35: void c3_3() ! 36: { ! 37: Filename = "c33a.c"; ! 38: ! 39: c3_3_1(); ! 40: c3_3_2_1(); ! 41: c3_3_2_2(); ! 42: c3_3_2_3(); ! 43: c3_3_2_4(); ! 44: c3_3_3(); ! 45: c3_3_3_1(); ! 46: c3_3_3_2(); ! 47: c3_3_3_3(); ! 48: c3_3_3_4(); ! 49: c3_3_4(); ! 50: /* too big for one module */ ! 51: c3_3b(); ! 52: } ! 53: /* ! 54: * 3.3.1 - Primary expressions ! 55: */ ! 56: static int x; ! 57: static int *fp(){ return &x;} ! 58: static void c3_3_1() ! 59: { ! 60: char c = 0; ! 61: char *pc = &c; ! 62: char **ppc = &pc; ! 63: char ***pppc = &ppc; ! 64: char ****ppppc = &pppc; ! 65: char *****pppppc = &ppppc; ! 66: long int larray[2][3][4]; ! 67: int i=1,j=2,k=3; ! 68: ! 69: i = 1; j = 2; k = 3; ! 70: do_nothing(&i,&j,&k); ! 71: *fp() = 7; ! 72: iequals(__LINE__, x, 7); ! 73: *****pppppc = 17; ! 74: iequals(__LINE__, c, 17); ! 75: larray[i][j][k] = 277777; ! 76: lequals(__LINE__, larray[1][2][3], 277777L); ! 77: ! 78: /* parentheses do not affect lvalues -- try the above examples */ ! 79: { ! 80: char (((c))) = 0; ! 81: char (*(pc)) = &c; ! 82: char (*(*(ppc))) = &pc; ! 83: char (*(*(*(pppc)))) = &ppc; ! 84: char (*(*(*(*(ppppc))))) = &pppc; ! 85: char (*(*(*(*(*(pppppc)))))) = &ppppc; ! 86: long int larray[2][3][4]; ! 87: int i=1,j=2,k=3; ! 88: ! 89: do_nothing(&i,&j,&k); ! 90: (*(fp())) = 8; ! 91: ((iequals(__LINE__, x, 8))); ! 92: (*(*(*(*(*(pppppc)))))) = 18; ! 93: iequals(__LINE__, c, 18); ! 94: (larray[i][j][k]) = 288888; ! 95: lequals(__LINE__, larray[1][2][3], 288888L); ! 96: } ! 97: } /* end c3_3_1 */ ! 98: ! 99: ! 100: ! 101: ! 102: ! 103: /* ! 104: * 3.3.2.1 - Array subscripting ! 105: */ ! 106: static void c3_3_2_1() ! 107: { ! 108: int iarray[10], *pi = iarray, i = 3, j = -3, k; ! 109: int i3d[2][3][4], count; ! 110: ! 111: iarray[0] = 17; ! 112: iarray[3] = 3; ! 113: ! 114: /* the array name is equivalent to a pointer to the first element */ ! 115: iequals(__LINE__, *iarray, 17); ! 116: iequals(__LINE__, iarray[i], 3); ! 117: iequals(__LINE__, *(iarray + i), 3); ! 118: iequals(__LINE__, *(i + iarray), 3); ! 119: iequals(__LINE__, i[iarray], 3); ! 120: iequals(__LINE__, (pi+3)[j], 17); ! 121: iequals(__LINE__, *(pi + 3 + j), 17); ! 122: iequals(__LINE__, *(j + pi + 3), 17); ! 123: iequals(__LINE__, j[pi + 3], 17); ! 124: ! 125: /* multi dimensional arrays */ ! 126: for (i = 0, count = 0; i < 2; ++i) ! 127: for (j = 0; j < 3; ++j) ! 128: for (k = 0; k < 4; ++k) ! 129: i3d[i][j][k] = count++; ! 130: i = ivalue(1); ! 131: j = ivalue(2); ! 132: k = ivalue(3); ! 133: pi = (int *)i3d[i]; ! 134: iequals(__LINE__, *pi, 12); ! 135: pi = (int *)i3d[i][j]; ! 136: iequals(__LINE__, *pi, 20); ! 137: pi = &i3d[i][j][k]; ! 138: iequals(__LINE__, *pi, 23); ! 139: ! 140: /* partial addressing yields pointers to sub-dimensions */ ! 141: aequals(__LINE__, i3d+1, &i3d[i][0][0]); ! 142: aequals(__LINE__, i3d+1, &i3d[1][0][0]); ! 143: aequals(__LINE__, i3d+2, &i3d[i+1][0][0]); ! 144: aequals(__LINE__, i3d+2, &i3d[2][0][0]); ! 145: aequals(__LINE__, i3d+2, &i3d[i][j][k+1]); ! 146: aequals(__LINE__, i3d+2, &i3d[1][2][4]); ! 147: aequals(__LINE__, i3d[i], &i3d[1][0][0]); ! 148: aequals(__LINE__, i3d[i]+1, &i3d[1][1][0]); ! 149: aequals(__LINE__, i3d[i][j], &i3d[1][2][0]); ! 150: aequals(__LINE__, i3d[i][j]+1, &i3d[1][2][1]); ! 151: aequals(__LINE__, j[i3d[i]]+1, &i3d[1][2][1]); ! 152: } ! 153: ! 154: ! 155: ! 156: ! 157: /* ! 158: * 3.3.2.2 - Function calls ! 159: */ ! 160: char cfun(){return ivalue(1);} ! 161: int ifun(){return ivalue(2);} ! 162: long lfun(){return lvalue(3L);} ! 163: float ffun(){return dvalue(4.0);} ! 164: double dfun(){return dvalue(5.0);} ! 165: #if ANSI ! 166: long double ldfun(){return dvalue(6.0L);} ! 167: #endif ! 168: #if ANSI && HAS_PROTOTYPES ! 169: unsigned knothole(unsigned char uc) { return uc; } ! 170: int f_int(int i) { return ivalue(i); } ! 171: typedef int (*pfi)(int i); ! 172: pfi f_dbl(double x) { return &f_int; } ! 173: #endif ! 174: static void c3_3_2_2(); ! 175: void (*fpfun())(){return c3_3_2_2;} ! 176: static void c3_3_2_2() ! 177: { ! 178: int i = 0; ! 179: extern int Side; ! 180: ! 181: /* Functions can return any type. Test for the simple types */ ! 182: iequals(__LINE__, cfun(), 1); ! 183: iequals(__LINE__, ifun(), 2); ! 184: lequals(__LINE__, lfun(), 3L); ! 185: dequals(__LINE__, ffun(), 4.0); ! 186: dequals(__LINE__, dfun(), 5.0); ! 187: #if ANSI ! 188: { ! 189: long double (*pldfun)() = ldfun; ! 190: ! 191: ldequals(__LINE__, ldfun(), 6.0L); ! 192: ldequals(__LINE__, (*ldfun)(), 6.0L); ! 193: ldequals(__LINE__, (**ldfun)(), 6.0L); ! 194: ldequals(__LINE__, pldfun(), 6.0L); ! 195: ldequals(__LINE__, (*pldfun)(), 6.0L); ! 196: ldequals(__LINE__, (**pldfun)(), 6.0L); ! 197: } ! 198: #endif ! 199: checkthat(__LINE__, fpfun() == c3_3_2_2); ! 200: ! 201: /* this tests calls/returns involving structs and unions */ ! 202: structures(); ! 203: Filename = "c33a.c"; ! 204: ! 205: ! 206: /* make sure that argument passing is by value */ /* 3.3.2.2 (cont.) */ ! 207: (void) wfunc(i); /* tests call with no decl in scope */ ! 208: iequals(__LINE__, i, 0); ! 209: ! 210: #if ANSI && HAS_PROTOTYPES ! 211: /* check argument coercion in the presence of a prototype */ ! 212: { ! 213: iequals(__LINE__, knothole(ULONG_MAX), UCHAR_MAX); ! 214: iequals(__LINE__, 2.0, 2L); ! 215: lequals(__LINE__, 3, 3.0); ! 216: dequals(__LINE__, 4, 4L); ! 217: do_nothing(&i, 1, 2, 3, 4, 5, 6, 7, 8, 9); ! 218: } ! 219: /* check calling through pointer-to-function */ ! 220: iequals(__LINE__, f_dbl(1.)(2), 2); ! 221: #endif ! 222: ! 223: /* side effects are completed before a function call */ ! 224: xfunc(Side++); ! 225: Side = 0; ! 226: { ! 227: int zfunc(); ! 228: ! 229: /* recursion must be possible */ ! 230: yfunc(3, zfunc, &i); /* no proto, default conversions */ ! 231: ! 232: /* zfunc changes a value through a pointer */ ! 233: iequals(__LINE__, i, 99); ! 234: } ! 235: } /* end c3_3_2_2 */ ! 236: ! 237: ! 238: ! 239: ! 240: ! 241: ! 242: ! 243: ! 244: ! 245: ! 246: ! 247: ! 248: ! 249: ! 250: ! 251: ! 252: ! 253: ! 254: ! 255: ! 256: ! 257: ! 258: wfunc(i) int i; { i = ivalue(17); return i; } /* 3.3.2.2 (cont.) */ ! 259: ! 260: xfunc(i) /* no return type, default to int */ ! 261: int i; ! 262: { ! 263: extern int Side; ! 264: ! 265: /* the side effect will have been completed at this point */ ! 266: iequals(__LINE__, i, 0); ! 267: iequals(__LINE__, Side, 1); ! 268: } /* no return expression, would be erroneous to use value */ ! 269: ! 270: yfunc(i, pfn, pi) /* no return type, default to int */ ! 271: int i; ! 272: #if ANSI ! 273: int pfn(); /* parm w fn type becomes ptr-to-fn */ ! 274: #else ! 275: int (*pfn)(); ! 276: #endif ! 277: int *pi; ! 278: { ! 279: static int j = 3; ! 280: ! 281: iequals(__LINE__, i, j); ! 282: if (--i == 0) ! 283: return; ! 284: --j; ! 285: yfunc(i, pfn, pi); ! 286: iequals(__LINE__, i, j); ! 287: ++j; ! 288: #if ANSI ! 289: pfn(pi); /* converts to (*pfn)() */ ! 290: #else ! 291: (*pfn)(pi); ! 292: #endif ! 293: } /* no return expression, would be erroneous to use value */ ! 294: ! 295: zfunc(pi) /* no return type, default to int */ ! 296: int pi[2]; /* array parm is converted to ptr */ ! 297: { ! 298: *pi = 99; ! 299: } /* no return expression, would be erroneous to use value */ ! 300: ! 301: ! 302: ! 303: ! 304: ! 305: ! 306: ! 307: ! 308: /* ! 309: * 3.3.2.3 - Structure and union members ! 310: */ ! 311: static void c3_3_2_3() ! 312: { ! 313: /* See strucs() in c33c.c (appx lines 50-90) for lvalue uses. ! 314: * These have been tested all over. One special assurance to check: ! 315: * if the union begins with several structures with identical initial ! 316: * sequences, then the common part may be inspected. Otherwise, the ! 317: * only guarantee is that the member you put in comes back out ! 318: * correctly. ! 319: */ ! 320: union ! 321: { ! 322: struct { int a; double d; } s1; ! 323: struct { int b; long l; } s2; /* ANSI8804 - types matter, names don't */ ! 324: }u; ! 325: ! 326: u.s1.a = 1; ! 327: u.s1.d = 2.0; ! 328: if (u.s2.b == 1) ! 329: dequals(__LINE__, u.s1.d, 2.0); ! 330: else ! 331: complain(__LINE__); ! 332: } ! 333: ! 334: ! 335: ! 336: ! 337: ! 338: ! 339: ! 340: ! 341: ! 342: ! 343: ! 344: ! 345: ! 346: ! 347: ! 348: ! 349: ! 350: ! 351: ! 352: ! 353: ! 354: ! 355: ! 356: ! 357: ! 358: /* ! 359: * 3.3.2.4 - Postfix increment and decrement operators ! 360: */ ! 361: static long larray[] = {1, 2}; ! 362: static void c3_3_2_4() ! 363: { ! 364: long *p = larray; ! 365: double d = 2.2; ! 366: int i = 3; ! 367: long l = 4; ! 368: char c = 5; ! 369: ! 370: /* these are tested in several places. make sure that ++ and -- ! 371: * work right together. ! 372: * See prec*.c for combination of ++ and other ops. ! 373: * See bitfields() in c35b.c for ++ with bitfield. ! 374: */ ! 375: lequals(__LINE__, *p++, 1L); ! 376: lequals(__LINE__, *p--, 2L); ! 377: lequals(__LINE__, *p, 1L); ! 378: ! 379: /* make sure that they work on scalar types correctly */ ! 380: dequals(__LINE__, d++, 2.2); ! 381: dequals(__LINE__, d--, 3.2); ! 382: dequals(__LINE__, d, 2.2); ! 383: iequals(__LINE__, i++, 3); ! 384: iequals(__LINE__, i--, 4); ! 385: iequals(__LINE__, i, 3); ! 386: lequals(__LINE__, l++, 4L); ! 387: lequals(__LINE__, l--, 5L); ! 388: lequals(__LINE__, l, 4L); ! 389: iequals(__LINE__, c++, 5); ! 390: iequals(__LINE__, c--, 6); ! 391: iequals(__LINE__, c, 5); ! 392: #if ANSI ! 393: { ! 394: enum {ZERO, ONE, TWO} x = ivalue(0); ! 395: long double ld = dvalue(1E9); ! 396: ! 397: iequals(__LINE__, x++, 0); ! 398: iequals(__LINE__, x++, ONE); ! 399: iequals(__LINE__, x--, TWO); ! 400: iequals(__LINE__, x, 1); ! 401: ldequals(__LINE__, ld++, 1E9); ! 402: ldequals(__LINE__, ld--, 1E9 + 1); ! 403: ldequals(__LINE__, --ld, 999999999); ! 404: } ! 405: #endif ! 406: } /* end c3_3_2_4 */ ! 407: ! 408: /* ! 409: * 3.3.3 - Unary operators. ! 410: */ ! 411: static void c3_3_3() {} ! 412: ! 413: /* ! 414: * 3.3.3.1 - Prefix increment and decrement operators ! 415: */ ! 416: static void c3_3_3_1() ! 417: { ! 418: long *p = larray; ! 419: long *q; ! 420: double d = 2.2; ! 421: int i = 3; ! 422: long l = 4; ! 423: char c = 5; ! 424: ! 425: /* these are tested in several places. make sure that ++ and -- ! 426: * work right together. ! 427: * See prec*.c for combination of ++ and other ops. ! 428: * See bitfield.c for ++ with bitfield. ! 429: */ ! 430: lequals(__LINE__, *++p, 2L); ! 431: lequals(__LINE__, *--p, 1L); ! 432: q = p; ! 433: lequals(__LINE__, *++p, *(q+=1)); ! 434: lequals(__LINE__, *--p, *(q-=1)); ! 435: ! 436: /* make sure that they work on scalar types correctly */ ! 437: dequals(__LINE__, ++d, 3.2); ! 438: dequals(__LINE__, --d, 2.2); ! 439: iequals(__LINE__, ++i, 4); ! 440: iequals(__LINE__, --i, 3); ! 441: lequals(__LINE__, ++l, 5L); ! 442: lequals(__LINE__, --l, 4L); ! 443: iequals(__LINE__, ++c, 6); ! 444: iequals(__LINE__, --c, 5); ! 445: } ! 446: ! 447: ! 448: ! 449: ! 450: ! 451: ! 452: ! 453: ! 454: ! 455: ! 456: ! 457: ! 458: /* ! 459: * 3.3.3.2 - Address and indirection operators. ! 460: */ ! 461: static void c3_3_3_2() ! 462: { ! 463: char c; ! 464: char *p = &c; ! 465: long l = 0; ! 466: ! 467: #if ANSI ! 468: { ! 469: void (*pf)() = &c3_3_3_2; /* & with fn designator */ ! 470: char a[2]; ! 471: char (*pa)[2] = &a; /* & with lvalue of array type */ ! 472: struct { int x; } s; ! 473: union { char c; float f; } u; ! 474: ! 475: checkthat(__LINE__, pf == c3_3_3_2); ! 476: aequals(__LINE__, pa, &a); ! 477: aequals(__LINE__, &s.x, &s); ! 478: aequals(__LINE__, &u.c, &u.f); ! 479: checkthat(__LINE__, &*pf == c3_3_3_2); ! 480: } ! 481: #endif ! 482: aequals(__LINE__, *&p, &c); ! 483: aequals(__LINE__, &*p, &c); ! 484: ! 485: #if (V7 || ANSI) ! 486: /* casts of addresses are allowed */ ! 487: p = (char *)&l; ! 488: *(long *)p = 17; ! 489: lequals(__LINE__, l, 17L); ! 490: #endif ! 491: } ! 492: ! 493: ! 494: ! 495: ! 496: ! 497: ! 498: ! 499: ! 500: ! 501: ! 502: ! 503: ! 504: ! 505: ! 506: ! 507: ! 508: /* ! 509: * 3.3.3.3 - Unary arithmetic operators ! 510: */ ! 511: static void c3_3_3_3() ! 512: { ! 513: float f = dvalue(1.1); ! 514: double d = dvalue(2.2); ! 515: int i = ivalue(3); ! 516: long l = ivalue(4); ! 517: char c = ivalue(5); ! 518: char *p = &c, *q = 0; ! 519: ! 520: /* test on arithmetic operands */ ! 521: #if ANSI ! 522: checkthat(__LINE__, ~(unsigned)i == (UINT_MAX - 3)); ! 523: checkthat(__LINE__, ~(unsigned long)l == (ULONG_MAX - 4)); ! 524: fequals(__LINE__, +f, 1.1); ! 525: dequals(__LINE__, +d, 2.2); ! 526: iequals(__LINE__, +i, 3); ! 527: lequals(__LINE__, +l, 4L); ! 528: iequals(__LINE__, +c, 5); ! 529: /* aequals(__LINE__, +p, &c); DELETED, ACCORDING TO LATEST ANSI */ ! 530: #endif ! 531: dequals(__LINE__, -d, -2.2); ! 532: iequals(__LINE__, -i, -3); ! 533: lequals(__LINE__, -l, -4L); ! 534: iequals(__LINE__, -c, -5); ! 535: ! 536: /* a few miscellaneous checks */ ! 537: iequals(__LINE__, -i, 0-i); ! 538: iequals(__LINE__, - -i, i); ! 539: iequals(__LINE__, ~i, ~3); ! 540: iequals(__LINE__, !i, 0); ! 541: iequals(__LINE__, !i, 0 == i); ! 542: iequals(__LINE__, !!i, 1); ! 543: iequals(__LINE__, !!!i, 0); ! 544: ! 545: /* ! can take any scalar type */ ! 546: iequals(__LINE__, !p, 0); ! 547: iequals(__LINE__, !q, 1); ! 548: } ! 549: ! 550: ! 551: ! 552: ! 553: ! 554: ! 555: ! 556: ! 557: ! 558: #if ANSI ! 559: #include <stddef.h> /* for size_t below */ ! 560: #endif ! 561: /* ! 562: * 3.3.3.4 - The 'sizeof' operator ! 563: */ ! 564: static void c3_3_3_4() ! 565: { ! 566: int iarray[10]; ! 567: double *pd = 0; ! 568: int i = 1; ! 569: ! 570: /* get the size of objects */ ! 571: checkthat(__LINE__, sizeof iarray == 10 * sizeof(int)); ! 572: checkthat(__LINE__, sizeof *pd == sizeof(double)); ! 573: ! 574: /* works on types too */ ! 575: checkthat(__LINE__, sizeof (int [10]) == 10 * sizeof(int)); ! 576: checkthat(__LINE__, sizeof (struct x { int a, b, c;}) == sizeof (struct x)); ! 577: checkthat(__LINE__, sizeof(char) == 1); ! 578: ! 579: #if ANSI ! 580: /* the operand of sizeof is not evaluated */ ! 581: checkthat(__LINE__, sizeof(++i) == sizeof(int)); ! 582: iequals(__LINE__, i, 1); ! 583: /* test the size of sizeof */ ! 584: { ! 585: size_t usize = 0; ! 586: unsigned char uc; ! 587: ! 588: checkthat(__LINE__, usize - 1 > 0); /* must be an unsigned type */ ! 589: checkthat(__LINE__, sizeof(size_t) == sizeof(sizeof(int))); ! 590: checkthat(__LINE__, sizeof(size_t) == sizeof(sizeof(const char *const))); ! 591: checkthat(__LINE__, sizeof(size_t) == sizeof(sizeof(const char *))); ! 592: checkthat(__LINE__, sizeof(size_t) == sizeof(sizeof(const int))); ! 593: iequals(__LINE__, sizeof(+uc), sizeof(int)); ! 594: iequals(__LINE__, sizeof(-uc), sizeof(int)); ! 595: } ! 596: checkthat(__LINE__, sizeof("123456") == 7); ! 597: #endif ! 598: } ! 599: ! 600: ! 601: ! 602: ! 603: ! 604: ! 605: ! 606: ! 607: ! 608: /* ! 609: * 3.3.4 - Cast operators ! 610: */ ! 611: static void c3_3_4() ! 612: { ! 613: short i, j; ! 614: long l, *pl = &l; ! 615: char c, *pc = &c; ! 616: double (*fp)(); ! 617: ! 618: i = (char)(short)(long)(float)(double)(double)(float)(long)(short)(char)dvalue(3.0); ! 619: iequals(__LINE__, i, ivalue(3)); ! 620: i = ivalue(-1); ! 621: lequals(__LINE__, (long)i, -1L); ! 622: iequals(__LINE__, (int)3.1416, 3); ! 623: dequals(__LINE__, (double)4, 4.0); ! 624: ! 625: /* pointer to integer conversion (implem-def, strictly speaking) */ ! 626: l = (long)pc; ! 627: aequals( - __LINE__, pc, (char *)l); ! 628: /* and back again should preserve original value */ ! 629: pc = (char *)l; ! 630: aequals( - __LINE__, pc, &c); ! 631: ! 632: /* pointer type conversion */ ! 633: l = 7; ! 634: pc = (char *)pl; ! 635: lequals(__LINE__, *(long *)pc, 7L); ! 636: ! 637: /* function pointer type conversion */ ! 638: fp = (double (*)())f; ! 639: lequals(__LINE__, (*(long(*)())fp)(), 99L); ! 640: #if ANSI ! 641: { ! 642: float f = (float)1. / (float)2.; ! 643: long double ld = dvalue(1.234 - 90 - 90 - 9); ! 644: ! 645: checkthat(__LINE__, f == .5F); ! 646: f = ld; ! 647: dequals(__LINE__, dvalue(f), (float)ld); ! 648: } ! 649: #endif ! 650: ! 651: ! 652: ! 653: ! 654: ! 655: ! 656: ! 657: ! 658: #if ANSI8706 /* 3.3.4 (cont.) */ ! 659: { ! 660: struct known { int i; } s = {0}; ! 661: struct unknown *psu; ! 662: char *pc; ! 663: ! 664: psu = (struct unknown *)avalue(&s); ! 665: pc = (char *)avalue(psu); ! 666: checkthat(__LINE__, pc == (char *)psu); ! 667: } ! 668: #endif ! 669: } /* end c3_3_4 */ ! 670: ! 671: #else /* if SKIP33 */ ! 672: ! 673: void c3_3() { pr_skip("c3_3: SKIPPED ENTIRELY\n"); } ! 674: #endif /* SKIP33 */ ! 675:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.