![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cq.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / tst|
Return to cq.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / tst |
1.1 root 1: struct defs {
2: int cbits; /* No. of bits per char */
3: int ibits; /* int */
4: int sbits; /* short */
5: int lbits; /* long */
6: int ubits; /* unsigned */
7: int fbits; /* float */
8: int dbits; /* double */
9: float fprec; /* Smallest number that can be */
10: float dprec; /* significantly added to 1. */
11: int flgs; /* Print return codes, by section */
12: int flgm; /* Announce machine dependencies */
13: int flgd; /* give explicit diagnostics */
14: int flgl; /* Report local return codes. */
15: int rrc; /* recent return code */
16: int crc; /* Cumulative return code */
17: char rfs[8]; /* Return from section */
18: };
19: main(n,args) /* C REFERENCE MANUAL */
20: int n;
21: char **args;
22: {
23:
24: /* This program performs a series of tests on a C compiler,
25: based on information in the
26:
27: C REFERENCE MANUAL
28:
29: which appears as Appendix A to the book "The C Programming
30: Language" by Brian W. Kernighan and Dennis M. Ritchie
31: (Prentice-Hall, 1978, $10.95). This Appendix is hereafter
32: referred to as "the Manual".
33:
34: The rules followed in writing this program are:
35:
36: 1. The entire program is written in legal C, according
37: to the Manual. It should compile with no error messages,
38: although some warning messages may be produced by some
39: compilers. Failure to compile should be interpreted as
40: a compiler error.
41:
42: 2. The program is clean, in that it does not make use
43: of any features of the operating system on which it runs,
44: with the sole exceptions of the printf() function, and an
45: internal "options" routine, which is easily excised.
46:
47: 3. No global variables are used, except for the spec-
48: ific purpose of testing the global variable facility.
49:
50: The program is divided into modules having names of the
51: form snnn... These modules correspond to those sections of the
52: Manual, as identified by boldface type headings, in which
53: there is something to test. For example, s241() corresponds
54: to section 2.4.1 of the Manual (Integer constants) and tests
55: the facilities described therein. The module numbering
56: scheme is ambiguous, especially when it names modules
57: referring to more than one section; module s7813, for ex-
58: ample, deals with sections 7.8 through 7.13. Nonetheless,
59: it is surprisingly easy to find a section in the Manual
60: corresponding to a section of code, and vice versa.
61:
62: Note also that there seem to be "holes" in the program,
63: at least from the point of view that there exist sections in the
64: Manual for which there is no corresponding code. Such holes
65: arise from three causes: (a) there is nothing in that partic-
66: ular section to test, (b) everything in that section is tested
67: elsewhere, and (c) it was deemed advisable not to check cer-
68: tain features like preprocessor or listing control features.
69:
70: Modules are called by a main program main(). The mod-
71: ules that are called, and the sequence in which they are
72: called, are determined by two lists in main(), in which the
73: module names appear. The first list (an extern statement)
74: declares the module names to be external. The second (a stat-
75: ic int statement) names the modules and defines the sequence
76: in which they are called. There is no need for these lists
77: to be in the same order, but it is probably a good idea to keep
78: them that way in the interest of clarity. Since there are no
79: cross-linkages between modules, new modules may be added,
80: or old ones deleted, simply by editing the lists, with one
81: exception: section s26, which pokes around at the hardware
82: trying to figure out the characteristics of the machine that
83: it is running on, saves information that is subsequently
84: used by sections s626, s72, and s757. If this program is
85: to be broken up into smallish pieces, say for running on
86: a microcomputer, take care to see that s26 is called before
87: calling any of the latter three sections. The size
88: of the lists, i.e., the number of modules to be called, is
89: not explicitly specified as a program parameter, but is
90: determined dynamically using the sizeof operator.
91:
92: Communication between the main program and the modules
93: takes place in two ways. In all cases, a pointer to a structure
94: is passed to the called module. The structure contains flags
95: that will determine the type of information to be published
96: by the module, and fields that may be written in by the
97: module. The former include "flgm" and "flgd", which, if set
98: to a nonzero value, specify that machine dependencies are to
99: be announced or that error messages are to be printed, re-
100: spectively. The called module's name, and the hardware char-
101: acteristics probed in s26() comprise the latter.
102:
103:
104: Also, in all cases, a return code is returned by the called
105: module. A return code of zero indicates that all has gone well;
106: nonzero indicates otherwise. Since more than one type of error
107: may be detected by a module, the return code is a composite
108: of error indicators, which, individually, are given as numbers
109: that are powers of two. Thus, a return code of 10 indicates
110: that two specific errors, 8 and 2, were detected. Whether or
111: not the codes returned by the modules are printed by the main
112: program is determined by setting "flgs" to 1 (resp. 0).
113:
114: The entire logic of the main program is contained in the
115: half-dozen or so lines at the end. The somewhat cryptic
116: statement:
117:
118: d0.rrc = (*sec[j])(pd0);
119:
120: in the for loop calls the modules. The rest of the code is
121: reasonably straightforward.
122:
123: Finally, in each of the modules, there is the following
124: prologue:
125:
126: snnn(pd0)
127: struct defs *pd0;
128: {
129: static char snnner[] = "snnn,er%d\n";
130: static char qsnnn[8] = "snnn ";
131: char *ps, *pt;
132: int rc;
133:
134: rc = 0;
135: ps = qsnnn;
136: pt = pd0->rfs;
137: while(*pt++ = *ps++);
138:
139: used for housekeeping, handshaking and module initialization.
140:
141: */
142: extern
143: s22(),
144: s241(),
145: s243(),
146: s244(),
147: s25(),
148: s26(),
149: s4(),
150: s61(),
151: s626(),
152: s71(),
153: s72(),
154: s757(),
155: s7813(),
156: s714(),
157: s715(),
158: s81(),
159: s84(),
160: s85(),
161: s86(),
162: s88(),
163: s9()
164: ;
165:
166: int j;
167: static int (*sec[])() = {
168: s22,
169: s241,
170: s243,
171: s244,
172: s25,
173: s26,
174: s4,
175: s61,
176: s626,
177: s71,
178: s72,
179: s757,
180: s7813,
181: s714,
182: s715,
183: s81,
184: s84,
185: s85,
186: s86,
187: s88,
188: s9
189: };
190:
191: static struct defs d0, *pd0;
192:
193: d0.flgs = 1; /* These flags dictate */
194: d0.flgm = 1; /* the verbosity of */
195: d0.flgd = 1; /* the program. */
196: d0.flgl = 1;
197:
198: pd0 = &d0;
199:
200: for (j=0; j<sizeof(sec) / sizeof(sec[0]); j++) {
201: d0.rrc = (*sec[j])(pd0);
202: d0.crc = d0.crc+d0.rrc;
203: if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
204: }
205:
206: if(d0.crc == 0) printf("\nNo errors detected.\n");
207: else printf("\nFailed.\n");
208: return 0;
209: }
210: s22(pd0) /* 2.2 Identifiers (Names) */
211: struct defs *pd0;
212: {
213: int a234, a;
214: int _, _234, A, rc;
215:
216: static char s22er[] = "s22,er%d\n";
217: static char qs22[8] = "s22 ";
218:
219: char *ps, *pt;
220: /* Initialize */
221:
222: rc = 0;
223: ps = qs22;
224: pt = pd0 -> rfs;
225: while (*pt++ = *ps++);
226:
227: /* An identifier is a sequence of letters and digits;
228: the first character must be a letter. The under-
229: score _ counts as a letter. */
230:
231: a=1;
232: _=2;
233: _234=3;
234: a234=4;
235: if(a+_+_234+a234 != 10) {
236: rc = rc+1;
237: if(pd0->flgd != 0) printf(s22er,1);
238: }
239:
240: /* Upper and lower case letters are different. */
241:
242: A = 2;
243: if (A == a) {
244: rc = rc+4;
245: if (pd0->flgd != 0) printf(s22er,4);
246: }
247:
248: return(rc);
249: }
250: s241(pd0) /* 2.4.1 Integer constants
251: 2.4.2 Explicit long constants */
252: struct defs *pd0;
253: {
254: long pow2();
255: static char s241er[] = "s241,er%d\n";
256: static char qs241[8] = "s241 ";
257: char *ps, *pt;
258: int rc, j, lrc;
259: static long g[39] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
260: 0,6,0,8,0,12,0,16,0,18,0,20,0,24,
261: 0,28,0,30,0,32,0,36};
262: long d[39], o[39], x[39];
263:
264: rc = 0;
265: lrc = 0;
266: ps = qs241;
267: pt = pd0 -> rfs;
268: while (*pt++ = *ps++);
269:
270: /* An integer constant consisting of a sequence of digits is
271: taken to be octal if it begins with 0 (digit zero), decimal
272: otherwise. */
273:
274: if ( 8 != 010
275: || 16 != 020
276: || 24 != 030
277: || 32 != 040
278: || 40 != 050
279: || 48 != 060
280: || 56 != 070
281: || 64 != 0100
282: || 72 != 0110
283: || 80 != 0120
284: || 9 != 0011
285: || 17 != 0021
286: || 25 != 0031
287: || 33 != 0041
288: || 41 != 0051
289: || 49 != 0061
290: || 57 != 0071
291: || 65 != 0101
292: || 73 != 0111
293: || 81 != 0121 ){
294:
295: rc = rc+1;
296: if( pd0->flgd != 0 ) printf(s241er,1);
297: }
298:
299: /* A sequence of digits preceded by 0x or 0X (digit zero)
300: is taken to be a hexadecimal integer. The hexadecimal
301: digits include a or A through f or F with values 10
302: through 15. */
303:
304: if ( 0x00abcdef != 0xabcdef
305: || 0xabcdef != 0Xabcdef || 0Xabcdef != 0XAbcdef
306: || 0XAbcdef != 0XABcdef || 0XABcdef != 0XABCdef
307: || 0XABCdef != 0XABCDef || 0XABCDef != 0XABCDEf
308: || 0XABCDEf != 0XABCDEF || 0xABCDEF != 11259375 ){
309:
310: rc = rc+2;
311: if( pd0->flgd != 0 ) printf(s241er,2);
312: }
313:
314: /* A decimal constant whose value exceeds the largest signed
315: machine integer is taken to be long; an octal or hex con-
316: stant which exceeds the largest unsigned machine integer
317: is likewise taken to be long. */
318:
319: if ( sizeof 010000000000 != sizeof(long) /* 2**30 */
320: || sizeof 1073741824 != sizeof(long) /* ditto */
321: || sizeof 0x40000000 != sizeof(long) ){ /* " */
322:
323: rc = rc+4;
324: if( pd0->flgd != 0 ) printf(s241er,4);
325: }
326:
327: /* A decimal, octal, or hexadecimal constant immediately followed
328: by l (letter ell) or L is a long constant. */
329:
330: if ( sizeof 67l != sizeof(long)
331: || sizeof 67L != sizeof(long)
332: || sizeof 067l != sizeof(long)
333: || sizeof 067L != sizeof(long)
334: || sizeof 0X67l != sizeof(long)
335: || sizeof 0x67L != sizeof(long) ){
336:
337: rc = rc+8;
338: if( pd0 -> flgd != 0 ) printf(s241er,8);
339: }
340:
341: /* Finally, we test to see that decimal (d), octal (o),
342: and hexadecimal (x) constants representing the same values
343: agree among themselves, and with computed values, at spec-
344: ified points over an appropriate range. The points select-
345: ed here are those with the greatest potential for caus-
346: ing trouble, i.e., zero, 1-16, and values of 2**n and
347: 2**n - 1 where n is some multiple of 4 or 6. Unfortunately,
348: just what happens when a value is too big to fit in a
349: long is undefined; however, it would be nice if what
350: happened were at least consistent... */
351:
352: for ( j=0; j<17; j++ ) g[j] = j;
353: for ( j=18; j<39; ) {
354: g[j] = pow2(g[j]);
355: g[j-1] = g[j] - 1;
356: j = j+2;
357: }
358:
359: d[0] = 0; o[0] = 00; x[0] = 0x0;
360: d[1] = 1; o[1] = 01; x[1] = 0x1;
361: d[2] = 2; o[2] = 02; x[2] = 0x2;
362: d[3] = 3; o[3] = 03; x[3] = 0x3;
363: d[4] = 4; o[4] = 04; x[4] = 0x4;
364: d[5] = 5; o[5] = 05; x[5] = 0x5;
365: d[6] = 6; o[6] = 06; x[6] = 0x6;
366: d[7] = 7; o[7] = 07; x[7] = 0x7;
367: d[8] = 8; o[8] = 010; x[8] = 0x8;
368: d[9] = 9; o[9] = 011; x[9] = 0x9;
369: d[10] = 10; o[10] = 012; x[10] = 0xa;
370: d[11] = 11; o[11] = 013; x[11] = 0xb;
371: d[12] = 12; o[12] = 014; x[12] = 0xc;
372: d[13] = 13; o[13] = 015; x[13] = 0xd;
373: d[14] = 14; o[14] = 016; x[14] = 0xe;
374: d[15] = 15; o[15] = 017; x[15] = 0xf;
375: d[16] = 16; o[16] = 020; x[16] = 0x10;
376: d[17] = 63; o[17] = 077; x[17] = 0x3f;
377: d[18] = 64; o[18] = 0100; x[18] = 0x40;
378: d[19] = 255; o[19] = 0377; x[19] = 0xff;
379: d[20] = 256; o[20] = 0400; x[20] = 0x100;
380: d[21] = 4095; o[21] = 07777; x[21] = 0xfff;
381: d[22] = 4096; o[22] = 010000; x[22] = 0x1000;
382: d[23] = 65535; o[23] = 0177777; x[23] = 0xffff;
383: d[24] = 65536; o[24] = 0200000; x[24] = 0x10000;
384: d[25] = 262143; o[25] = 0777777; x[25] = 0x3ffff;
385: d[26] = 262144; o[26] = 01000000; x[26] = 0x40000;
386: d[27] = 1048575; o[27] = 03777777; x[27] = 0xfffff;
387: d[28] = 1048576; o[28] = 04000000; x[28] = 0x100000;
388: d[29] = 16777215; o[29] = 077777777; x[29] = 0xffffff;
389: d[30] = 16777216; o[30] = 0100000000; x[30] = 0x1000000;
390: d[31] = 268435455; o[31] = 01777777777; x[31] = 0xfffffff;
391: d[32] = 268435456; o[32] = 02000000000; x[32] = 0x10000000;
392: d[33] = 1073741823; o[33] = 07777777777; x[33] = 0x3fffffff;
393: d[34] = 1073741824; o[34] = 010000000000; x[34] = 0x40000000;
394: d[35] = 4294967295; o[35] = 037777777777; x[35] = 0xffffffff;
395: d[36] = 4294967296; o[36] = 040000000000; x[36] = 0x100000000;
396: d[37] = 68719476735; o[37] = 0777777777777; x[37] = 0xfffffffff;
397: d[38] = 68719476736; o[38] = 01000000000000; x[38] = 0x1000000000;
398:
399: /* WHEW! */
400:
401: for (j=0; j<39; j++){
402: if ( g[j] != d[j]
403: || d[j] != o[j]
404: || o[j] != x[j]) {
405:
406: if( pd0 -> flgm != 0 ) {
407: /* printf(s241er,16); save in case opinions change... */
408: printf("Decimal and octal/hex constants sometimes give\n");
409: printf(" different results when assigned to longs.\n");
410: }
411: /* lrc = 1; save... */
412: }
413: }
414:
415: if (lrc != 0) rc =16;
416:
417: return rc;
418: }
419:
420: long pow2(n) /* Calculate 2**n by multiplying, not shifting */
421: long n;
422: {
423: long s;
424: s = 1;
425: while(n--) s = s*2;
426: return s;
427: }
428: s243(pd0) /* 2.4.3 Character constants */
429: struct defs *pd0;
430: {
431: static char s243er[] = "s243,er%d\n";
432: static char qs243[8] = "s243 ";
433: char *ps, *pt;
434: int rc;
435: char chars[256];
436:
437: rc = 0;
438: ps = qs243;
439: pt = pd0->rfs;
440: while(*pt++ = *ps++);
441:
442: /* One of the problems that arises when testing character constants
443: is that of definition: What, exactly, is the character set?
444: In order to guarantee a certain amount of machine independence,
445: the character set we will use here is the set of characters writ-
446: able as escape sequences in C, plus those characters used in writ-
447: ing C programs, i.e.,
448:
449: letters:
450: ABCDEFGHIJKLMNOPQRSTUVWXYZ 26
451: abcdefghijklmnopqrstuvwxyz 26
452: numbers:
453: 0123456789 10
454: special characters:
455: ~!"#%&()_=-^|{}[]+;*:<>,.?/ 27
456: extra special characters:
457: newline \n
458: horizontal tab \t
459: backspace \b
460: carriage return \r
461: form feed \f
462: backslash \\
463: single quote \' 7
464: blank & NUL 2
465: ---
466: 98
467:
468: Any specific implementation of C may of course support additional
469: characters. */
470:
471: /* Since the value of a character constant is the numerical value
472: of the character in the machine's character set, there should
473: be a one-to-one correspondence between characters and values. */
474:
475: zerofill(chars);
476:
477: chars['a'] = 1; chars['A'] = 1; chars['~'] = 1; chars['0'] = 1;
478: chars['b'] = 1; chars['B'] = 1; chars['!'] = 1; chars['1'] = 1;
479: chars['c'] = 1; chars['C'] = 1; chars['"'] = 1; chars['2'] = 1;
480: chars['d'] = 1; chars['D'] = 1; chars['#'] = 1; chars['3'] = 1;
481: chars['e'] = 1; chars['E'] = 1; chars['%'] = 1; chars['4'] = 1;
482: chars['f'] = 1; chars['F'] = 1; chars['&'] = 1; chars['5'] = 1;
483: chars['g'] = 1; chars['G'] = 1; chars['('] = 1; chars['6'] = 1;
484: chars['h'] = 1; chars['H'] = 1; chars[')'] = 1; chars['7'] = 1;
485: chars['i'] = 1; chars['I'] = 1; chars['_'] = 1; chars['8'] = 1;
486: chars['j'] = 1; chars['J'] = 1; chars['='] = 1; chars['9'] = 1;
487: chars['k'] = 1; chars['K'] = 1; chars['-'] = 1;
488: chars['l'] = 1; chars['L'] = 1; chars['^'] = 1;
489: chars['m'] = 1; chars['M'] = 1; chars['|'] = 1; chars['\n'] = 1;
490: chars['n'] = 1; chars['N'] = 1; chars['\t'] = 1;
491: chars['o'] = 1; chars['O'] = 1; chars['{'] = 1; chars['\b'] = 1;
492: chars['p'] = 1; chars['P'] = 1; chars['}'] = 1; chars['\r'] = 1;
493: chars['q'] = 1; chars['Q'] = 1; chars['['] = 1; chars['\f'] = 1;
494: chars['r'] = 1; chars['R'] = 1; chars[']'] = 1;
495: chars['s'] = 1; chars['S'] = 1; chars['+'] = 1; chars['\\'] = 1;
496: chars['t'] = 1; chars['T'] = 1; chars[';'] = 1; chars['\''] = 1;
497: chars['u'] = 1; chars['U'] = 1; chars['*'] = 1;
498: chars['v'] = 1; chars['V'] = 1; chars[':'] = 1; chars['\0'] = 1;
499: chars['w'] = 1; chars['W'] = 1; chars['<'] = 1; chars[' '] = 1;
500: chars['x'] = 1; chars['X'] = 1; chars['>'] = 1;
501: chars['y'] = 1; chars['Y'] = 1; chars[','] = 1;
502: chars['z'] = 1; chars['Z'] = 1; chars['.'] = 1;
503: chars['?'] = 1;
504: chars['/'] = 1;
505:
506: if(sumof(chars) != 98){
507: rc = rc+1;
508: if(pd0->flgd != 0) printf(s243er,1);
509: }
510:
511: /* Finally, the escape \ddd consists of the backslash followed
512: by 1, 2, or 3 octal digits which are taken to specify the
513: desired character. */
514:
515: if( '\0' != 0 || '\01' != 1 || '\02' != 2
516: || '\03' != 3 || '\04' != 4 || '\05' != 5
517: || '\06' != 6 || '\07' != 7 || '\10' != 8
518: || '\17' != 15 || '\20' != 16 || '\77' != 63
519: || '\100' != 64 || '\177' != 127 ){
520:
521: rc = rc+8;
522: if(pd0->flgd != 0) printf(s243er,8);
523: }
524:
525: return rc;
526: }
527: zerofill(x)
528: char *x;
529: {
530: int j;
531:
532: for (j=0; j<256; j++) *x++ = 0;
533: }
534: sumof(x)
535: char *x;
536: {
537: char *p;
538: int total, j;
539:
540: p = x;
541: total = 0;
542:
543: for(j=0; j<256; j++) total = total+ *p++;
544: return total;
545: }
546: s244(pd0)
547: struct defs *pd0;
548: {
549: double a[8];
550: int rc, lrc, j;
551: static char s244er[] = "s244,er%d\n";
552: static char qs244[8] = "s244 ";
553: char *ps, *pt;
554:
555: ps = qs244;
556: pt = pd0->rfs;
557: while(*pt++ = *ps++);
558: rc = 0;
559: lrc = 0;
560:
561: /* Unfortunately, there's not a lot we can do with floating constants.
562: We can check to see that the various representations can be com-
563: piled, that the conversion is such that they yield the same hard-
564: ware representations in all cases, and that all representations
565: thus checked are double precision. */
566:
567: a[0] = .1250E+04;
568: a[1] = 1.250E3;
569: a[2] = 12.50E02;
570: a[3] = 125.0e+1;
571: a[4] = 1250e00;
572: a[5] = 12500.e-01;
573: a[6] = 125000e-2;
574: a[7] = 1250.;
575:
576: lrc = 0;
577: for (j=0; j<7; j++) if(a[j] != a[j+1]) lrc = 1;
578:
579: if(lrc != 0) {
580: if(pd0->flgd != 0) printf(s244er,1);
581: rc = rc+1;
582: }
583:
584: if ( (sizeof .1250E+04 ) != sizeof(double)
585: || (sizeof 1.250E3 ) != sizeof(double)
586: || (sizeof 12.50E02 ) != sizeof(double)
587: || (sizeof 1.250e+1 ) != sizeof(double)
588: || (sizeof 1250e00 ) != sizeof(double)
589: || (sizeof 12500.e-01) != sizeof(double)
590: || (sizeof 125000e-2 ) != sizeof(double)
591: || (sizeof 1250. ) != sizeof(double)){
592:
593: if(pd0->flgd != 0) printf(s244er,2);
594: rc = rc+2;
595: }
596:
597: return rc;
598: }
599: s25(pd0)
600: struct defs *pd0;
601: {
602: char *s, *s2;
603: int rc, lrc, j;
604: static char s25er[] = "s25,er%d\n";
605: static char qs25[8] = "s25 ";
606: char *ps, *pt;
607:
608: ps = qs25;
609: pt = pd0->rfs;
610: while(*pt++ = *ps++);
611: rc = 0;
612:
613: /* A string is a sequence of characters surrounded by double
614: quotes, as in "...". */
615:
616: s = "...";
617:
618: /* A string has type "array of characters" and storage class
619: static and is initialized with the given characters. */
620:
621: if ( s[0] != s[1] || s[1] != s[2]
622: || s[2] != '.' ) {
623:
624: rc = rc+1;
625: if(pd0->flgd != 0) printf(s25er,1);
626: }
627:
628: /* The compiler places a null byte \0 at the end of each string
629: so the program which scans the string can find its end. */
630:
631: if( s[3] != '\0' ){
632: rc = rc+4;
633: if(pd0->flgd != 0) printf(s25er,4);
634: }
635:
636: /* In a string, the double quote character " must be preceded
637: by a \. */
638:
639: if( ".\"."[1] != '"' ){
640: rc = rc+8;
641: if(pd0->flgd != 0) printf(s25er,8);
642: }
643:
644: /* In addition, the same escapes described for character constants
645: may be used. */
646:
647: s = "\n\t\b\r\f\\\'";
648:
649: if( s[0] != '\n'
650: || s[1] != '\t'
651: || s[2] != '\b'
652: || s[3] != '\r'
653: || s[4] != '\f'
654: || s[5] != '\\'
655: || s[6] != '\'' ){
656:
657: rc = rc+16;
658: if( pd0->flgd != 0) printf(s25er,16);
659: }
660:
661: /* Finally, a \ and an immediately following newline are ignored */
662:
663: s2 = "queep!";
664: s = "queep!";
665:
666: lrc = 0;
667: for (j=0; j<sizeof "queep!"; j++) if(s[j] != s2[j]) lrc = 1;
668: if (lrc != 0){
669: rc = rc+32;
670: if(pd0->flgd != 0) printf(s25er,32);
671: }
672: return rc;
673: }
674: s26(pd0) /* 2.6 Hardware Characteristics */
675: struct defs *pd0;
676: {
677: static char qs26[8] = "s26 ";
678: char *ps, *pt;
679: char c0, c1;
680: float temp, one, delta;
681: double tempd, oned;
682: static char s[] = "%3d bits in %ss.\n";
683: static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
684:
685: ps = qs26;
686: pt = pd0->rfs;
687:
688: while(*pt++ = *ps++);
689:
690: /* Here, we shake the machinery a little to see what falls
691: out. First, we find out how many bits are in a char. */
692:
693: pd0->cbits = 0;
694: c0 = 0;
695: c1 = 1;
696:
697: while(c0 != c1) {
698: c1 = c1<<1;
699: pd0->cbits = pd0->cbits+1;
700: }
701: /* That information lets us determine the size of everything else. */
702:
703: pd0->ibits = pd0->cbits * sizeof(int);
704: pd0->sbits = pd0->cbits * sizeof(short);
705: pd0->lbits = pd0->cbits * sizeof(long);
706: pd0->ubits = pd0->cbits * sizeof(unsigned);
707: pd0->fbits = pd0->cbits * sizeof(float);
708: pd0->dbits = pd0->cbits * sizeof(double);
709:
710: /* We have now almost reconstructed the table in section 2.6, the
711: exception being the range of the floating point hardware.
712: Now there are just so many ways to conjure up a floating point
713: representation system that it's damned near impossible to guess
714: what's going on by writing a program to interpret bit patterns.
715: Further, the information isn't all that useful, if we consider
716: the fact that machines that won't handle numbers between 10**30
717: and 10**-30 are very hard to find, and that people playing with
718: numbers outside that range have a lot more to worry about than
719: just the capacity of the characteristic.
720:
721: A much more useful measure is the precision, which can be ex-
722: pressed in terms of the smallest number that can be added to
723: 1. without loss of significance. We calculate that here, for
724: float and double. */
725:
726: one = 1.;
727: delta = 1.;
728: temp = 0.;
729: while(temp != one) {
730: temp = one+delta;
731: delta = delta/2.;
732: }
733: pd0->fprec = delta * 4.;
734: oned = 1.;
735: delta = 1.;
736: tempd = 0.;
737: while(tempd != oned) {
738: tempd = oned+delta;
739: delta = delta/2.;
740: }
741: pd0->dprec = delta * 4.;
742:
743: /* Now, if anyone's interested, we publish the results. */
744:
745: if(pd0->flgm != 0) {
746: printf(s,pd0->cbits,"char");
747: printf(s,pd0->ibits,"int");
748: printf(s,pd0->sbits,"short");
749: printf(s,pd0->lbits,"long");
750: printf(s,pd0->ubits,"unsigned");
751: printf(s,pd0->fbits,"float");
752: printf(s,pd0->dbits,"double");
753: printf(s2,pd0->fprec,"float");
754: printf(s2,pd0->dprec,"double");
755: }
756: /* Since we are only exploring and perhaps reporting, but not
757: testing any features, we cannot return an error code. */
758:
759: return 0;
760: }
761: int extvar;
762: s4(pd0) /* 4. What's in a name? */
763: struct defs *pd0;
764: {
765: static char s4er[] = "s4,er%d\n";
766: static char qs4[8] = "s4 ";
767: char *ps, *pt;
768: int j, rc;
769:
770: short sint; /* short integer, for size test */
771: int pint; /* plain */
772: long lint; /* long */
773: unsigned target;
774: unsigned int mask;
775:
776: rc = 0;
777: ps = qs4;
778: pt = pd0->rfs;
779:
780: while(*pt++ = *ps++);
781:
782: /* There are four declarable storage classes: automatic,
783: static, external, and register. Automatic variables have
784: been dealt with extensively thus far, and will not be specif-
785: ically treated in this section. Register variables are treated
786: in section s81.
787:
788: Static variables are local to a block, but retain their
789: values upon reentry to a block, even after control has left
790: the block. */
791:
792: for (j=0; j<3; j++)
793: if(svtest(j) != zero()){
794: rc = 1;
795: if(pd0->flgd != 0) printf(s4er,1);
796: }
797: ;
798:
799: /* External variables exist and retain their values throughout
800: the execution of the entire program, and may be used for comm-
801: unication between functions, even separately compiled functions.
802: */
803:
804: setev();
805: if(testev() != 0){
806: rc=rc+2;
807: if(pd0->flgd != 0) printf(s4er,2);
808: }
809: /*
810: Characters have been tested elsewhere (in s243).
811:
812: Up to three sizes of integer, declared short int, int, and
813: long int, are available. Longer integers provide no less storage
814: than shorter ones, but implementation may make either short
815: integers, or long integers, or both, equivalent to plain
816: integers.
817: */
818:
819: if(sizeof lint < sizeof pint || sizeof pint < sizeof sint){
820:
821: rc = rc+4;
822: if(pd0->flgd != 0) printf(s4er,4);
823: }
824:
825: /* Unsigned integers, declared unsigned, obey the laws of
826: arithmetic modulo 2**n, where n is the number of bits in the
827: implementation */
828:
829: target = 0;
830: target = target-1;
831: mask = 1;
832:
833: for(j=0; j<(sizeof target)*pd0->cbits; j++){
834:
835: mask = mask⌖
836: target = target>>1;
837: }
838:
839: if(mask != 1 || target != 0){
840:
841: rc = rc+8;
842: if(pd0->flgd != 0) printf(s4er,8);
843: }
844:
845: return rc;
846: }
847: svtest(n)
848: int n;
849: {
850: static k;
851: int rc;
852: switch (n) {
853:
854: case 0: k = 1978;
855: rc = 0;
856: break;
857:
858: case 1: if(k != 1978) rc = 1;
859: else{
860: k = 1929;
861: rc = 0;
862: }
863: break;
864:
865: case 2: if(k != 1929) rc = 1;
866: else rc = 0;
867: break;
868: }
869: return rc;
870: }
871: zero(){ /* Returns a value of zero, possibly */
872: static k; /* with side effects, as it's called */
873: int rc; /* alternately with svtest, above, */
874: k = 2; /* and has the same internal storage */
875: rc = 0; /* requirements. */
876: return rc;
877: }
878: testev(){
879: if(extvar != 1066) return 1;
880: else return 0;
881: }
882: s61(pd0) /* Characters and integers */
883: struct defs *pd0;
884: {
885: static char s61er[] = "s61,er%d\n";
886: static char qs61[8] = "s61 ";
887: short from, shortint;
888: long int to, longint;
889: int rc, lrc;
890: int j;
891: char fromc, charint;
892: char *wd, *pc[6];
893:
894: static char upper_alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
895: static char lower_alpha[] = "abcdefghijklmnopqrstuvwxyz";
896: static char numbers[] = "0123456789";
897: static char special_characters[] = "~!\"#%&()_=-^|{}[]+;*:<>,.?/";
898: static char extra_special_characters[] = "\n\t\b\r\f\\\'";
899: static char blank_and_NUL[] = " \0";
900:
901: char *ps, *pt;
902: ps = qs61;
903: pt = pd0->rfs;
904: rc = 0;
905: while (*pt++ = *ps++);
906:
907: /* A character or a short integer may be used wherever
908: an integer may be used. In all cases, the value is converted
909: to integer. This principle is extensively used throughout this
910: program, and will not be explicitly tested here. */
911:
912: /* Conversion of a shorter integer to a longer always
913: involves sign extension. */
914:
915: from = -19;
916: to = from;
917:
918: if(to != -19){
919: rc = rc+1;
920: if(pd0->flgd != 0) printf(s61er,1);
921: }
922:
923: /* It is guaranteed that a member of the standard char-
924: acter set is nonnegative. */
925:
926: pc[0] = upper_alpha;
927: pc[1] = lower_alpha;
928: pc[2] = numbers;
929: pc[3] = special_characters;
930: pc[4] = extra_special_characters;
931: pc[5] = blank_and_NUL;
932:
933: lrc = 0;
934: for (j=0; j<6; j++)
935: while(*pc[j]) if(*pc[j]++ < 0) lrc =1;
936:
937: if(lrc != 0){
938: rc=rc+2;
939: if(pd0->flgd != 0) printf(s61er,2);
940: }
941:
942: /* When a longer integer is converted to a shorter or
943: to a char, it is truncated on the left; excess bits are
944: simply discarded. */
945:
946: longint = 1048579; /* =2**20+3 */
947: shortint = longint;
948: charint = longint;
949:
950: if((shortint != longint && shortint != 3) ||
951: (charint != longint && charint != 3)) {
952: rc = rc+8;
953: if(pd0->flgd != 0) printf(s61er,8);
954: }
955:
956: return rc;
957: }
958: s626(pd0) /* 6.2 Float and double */
959: /* 6.3 Floating and integral */
960: /* 6.4 Pointers and integers */
961: /* 6.5 Unsigned */
962: /* 6.6 Arithmetic conversions */
963: struct defs *pd0;
964: {
965: static char s626er[] = "s626,er%d\n";
966: static char qs626[8] = "s626 ";
967: int rc;
968: char *ps, *pt;
969: float eps, f1, f2, f3, f4, f;
970: long lint1, lint2, l, ls;
971: char c, t[28], t0;
972: short s;
973: int is, i, j;
974: unsigned u, us;
975: double d, ds;
976: ps = qs626;
977: pt = pd0->rfs;
978: rc = 0;
979: while (*pt++ = *ps++);
980:
981: /* Conversions of integral values to floating type are
982: well-behaved. */
983:
984: f1 = 1.;
985: lint1 = 1.;
986: lint2 = 1.;
987:
988: for(j=0;j<pd0->lbits-2;j++){
989: f1 = f1*2;
990: lint2 = (lint2<<1)|lint1;
991: }
992: f2 = lint2;
993: f1 = (f1-f2)/f1;
994: if(f1>2.*pd0->fprec){
995:
996: rc = rc+2;
997: if(pd0->flgd != 0) printf(s626er,2);
998: }
999:
1000: /* Pointer-integer combinations are discussed in s74,
1001: "Additive operators". The unsigned-int combination
1002: appears below. */
1003:
1004: c = 125;
1005: s = 125;
1006: i = 125; is = 15625;
1007: u = 125; us = 15625;
1008: l = 125; ls = 15625;
1009: f = 125.;
1010: d = 125.; ds = 15625.;
1011:
1012: for(j=0;j<28;j++) t[j] = 0;
1013:
1014: if(c*c != is) t[ 0] = 1;
1015: if(s*c != is) t[ 1] = 1;
1016: if(s*s != is) t[ 2] = 1;
1017: if(i*c != is) t[ 3] = 1;
1018: if(i*s != is) t[ 4] = 1;
1019: if(i*i != is) t[ 5] = 1;
1020: if(u*c != us) t[ 6] = 1;
1021: if(u*s != us) t[ 7] = 1;
1022: if(u*i != us) t[ 8] = 1;
1023: if(u*u != us) t[ 9] = 1;
1024: if(l*c != ls) t[10] = 1;
1025: if(l*s != ls) t[11] = 1;
1026: if(l*i != ls) t[12] = 1;
1027: if(l*u != us) t[13] = 1;
1028: if(l*l != ls) t[14] = 1;
1029: if(f*c != ds) t[15] = 1;
1030: if(f*s != ds) t[16] = 1;
1031: if(f*i != ds) t[17] = 1;
1032: if(f*u != ds) t[18] = 1;
1033: if(f*l != ds) t[19] = 1;
1034: if(f*f != ds) t[20] = 1;
1035: if(d*c != ds) t[21] = 1;
1036: if(d*s != ds) t[22] = 1;
1037: if(d*i != ds) t[23] = 1;
1038: if(d*u != ds) t[24] = 1;
1039: if(d*l != ds) t[25] = 1;
1040: if(d*f != ds) t[26] = 1;
1041: if(d*d != ds) t[27] = 1;
1042:
1043: t0 = 0;
1044: for(j=0; j<28; j++) t0 = t0+t[j];
1045:
1046: if(t0 != 0){
1047:
1048: rc = rc+4;
1049: if(pd0->flgd != 0){
1050:
1051: printf(s626er,4);
1052: printf(" key=");
1053: for(j=0;j<28;j++) printf("%d",t[j]);
1054: printf("\n");
1055: }
1056: }
1057:
1058: /* When an unsigned integer is converted to long,
1059: the value of the result is the same numerically
1060: as that of the unsigned integer. */
1061:
1062: l = (unsigned)0100000;
1063: if((long)l > (unsigned)0100000){
1064:
1065: rc = rc+8;
1066: if(pd0->flgd != 0) printf(s626er,8);
1067: }
1068:
1069: return rc;
1070: }
1071: s71(pd0) /* 7.1 Primary expressions */
1072: struct defs *pd0;
1073: {
1074: static char s71er[] = "s71,er%d\n";
1075: static char qs71[8] = "s71 ";
1076: int rc;
1077: char *ps, *pt;
1078: static char q = 'q';
1079: int x[10], McCarthy(), clobber(), a, b, *p;
1080: ps = qs71;
1081: pt = pd0->rfs;
1082: rc = 0;
1083: while (*pt++ = *ps++);
1084:
1085: /* Testing of expressions and operators is quite complicated,
1086: because (a) problems are apt to surface in queer combinations
1087: of operators and operands, rather than in isolation,
1088: and (b) the number of expressions needed to provoke a case
1089: of improper behaviour may be quite large. Hence, we take the
1090: following approach: for this section, and for subsequent
1091: sections through 7.15, we will check the primitive operations
1092: in isolation, thus verifying that the primitives work,
1093: after a fashion. The job of testing combinations, we will
1094: leave to a separate, machine-generated program, to be included
1095: in the C test package at some later date.
1096: */
1097:
1098: /* A string is a primary expression. The identifier points to
1099: the first character of a string.
1100: */
1101:
1102: if(*"queep" != q){
1103: rc = rc+1;
1104: if(pd0->flgd != 0) printf(s71er,1);
1105: }
1106: /* A parenthesized expression is a primary expression whose
1107: type and value are the same as those of the unadorned
1108: expression.
1109: */
1110: if((2+3) != 2+3) {
1111: rc = rc+2;
1112: if(pd0->flgd != 0) printf(s71er,2);
1113: }
1114:
1115: /* A primary expression followed by an expression in square
1116: brackets is a primary expression. The intuitive meaning is
1117: that of a subscript. The expression E1[E2] is identical
1118: (by definition) to *((E1)+(E2)).
1119: */
1120:
1121: x[5] = 1942;
1122: if(x[5] != 1942 || x[5] != *((x)+(5))){
1123: rc = rc+4;
1124: if(pd0->flgd != 0) printf(s71er,4);
1125: }
1126:
1127: /* If the various flavors of function calls didn't work, we
1128: would never have gotten this far; however, we do need to
1129: show that functions can be recursive...
1130: */
1131:
1132: if ( McCarthy(-5) != 91){
1133: rc = rc+8;
1134: if(pd0->flgd != 0) printf(s71er,8);
1135: }
1136:
1137: /* and that argument passing is strictly by value. */
1138:
1139: a = 2;
1140: b = 3;
1141: p = &b;
1142:
1143: clobber(a,p);
1144:
1145: if(a != 2 || b != 2){
1146: rc = rc+16;
1147: if(pd0->flgd != 0) printf(s71er,16);
1148: }
1149:
1150: /* Finally, structures and unions are addressed thusly: */
1151:
1152: if(pd0->dprec != (*pd0).dprec){
1153: rc = rc+32;
1154: if(pd0->flgd != 0) printf(s71er,32);
1155: }
1156:
1157: return rc;
1158: }
1159: McCarthy(x)
1160: int x;
1161: {
1162: if(x>100) return x-10;
1163: else return McCarthy( McCarthy(x+11));
1164: }
1165: clobber(x,y)
1166: int x, *y;
1167: {
1168: x = 3;
1169: *y = 2;
1170: }
1171: s714(pd0) /* 7.14 Assignment operators */
1172: struct defs *pd0;
1173: {
1174: static char f[] = "Local error %d.\n";
1175: static char s714er[] = "s714,er%d\n";
1176: static char qs714[8] = "s714 ";
1177: register int prlc, lrc;
1178: int rc;
1179: char cl, cr;
1180: short sl, sr;
1181: int il, ir;
1182: long ll, lr;
1183: unsigned ul, ur;
1184: float fl, fr;
1185: double dl, dr;
1186: char *ps, *pt;
1187: ps = qs714;
1188: pt = pd0->rfs;
1189: rc = 0;
1190: lrc = 0;
1191: prlc = pd0->flgl;
1192: while (*pt++ = *ps++);
1193:
1194: /* This section tests the assignment operators.
1195:
1196: It is an exhaustive test of all assignment statements
1197: of the form:
1198:
1199: vl op vr
1200:
1201: where vl and vr are variables from the set
1202: {char,short,int,long,unsigned,float,double} and op is
1203: one of the assignment operators. There are 395 such
1204: statements.
1205:
1206: The initial values for the variables have been chosen
1207: so that both the initial values and the results will
1208: "fit" in just about any implementation, and that the re-
1209: sults will be such that they test for the proper form-
1210: ation of composite operators, rather than checking for
1211: the valid operation of those operators' components.
1212: For example, in checking >>=, we want to verify that
1213: a right shift and a move take place, rather than
1214: whether or not there may be some peculiarities about
1215: the right shift. Such tests have been made previously,
1216: and to repeat them here would be to throw out a red
1217: herring.
1218:
1219: The table below lists the operators, assignment targets,
1220: initial values for left and right operands, and the
1221: expected values of the results.
1222:
1223:
1224: = += -= *= /= %= >>= <<= &= ^= |=
1225: char 2 7 3 10 2 1 1 20 8 6 14
1226: short 2 7 3 10 2 1 1 20 8 6 14
1227: int 2 7 3 10 2 1 1 20 8 6 14
1228: long 2 7 3 10 2 1 1 20 8 6 14
1229: unsigned 2 7 3 10 2 1 1 20 8 6 14
1230: float 2 7 3 10 2.5 | |
1231: double 2 7 3 10 2.5 | |
1232: | |
1233: initial (5,2) | (5,2) | (12,10)
1234:
1235: The following machine-generated program reflects the
1236: tests described in the table.
1237: */
1238:
1239: cl = 5; cr = 2;
1240: cl = cr;
1241: if(cl != 2){
1242: lrc = 1;
1243: if(prlc) printf(f,lrc);
1244: }
1245: cl = 5; sr = 2;
1246: cl = sr;
1247: if(cl != 2){
1248: lrc = 2;
1249: if(prlc) printf(f,lrc);
1250: }
1251: cl = 5; ir = 2;
1252: cl = ir;
1253: if(cl != 2){
1254: lrc = 3;
1255: if(prlc) printf(f,lrc);
1256: }
1257: cl = 5; lr = 2;
1258: cl = lr;
1259: if(cl != 2){
1260: lrc = 4;
1261: if(prlc) printf(f,lrc);
1262: }
1263: cl = 5; ur = 2;
1264: cl = ur;
1265: if(cl != 2){
1266: lrc = 5;
1267: if(prlc) printf(f,lrc);
1268: }
1269: cl = 5; fr = 2;
1270: cl = fr;
1271: if(cl != 2){
1272: lrc = 6;
1273: if(prlc) printf(f,lrc);
1274: }
1275: cl = 5; dr = 2;
1276: cl = dr;
1277: if(cl != 2){
1278: lrc = 7;
1279: if(prlc) printf(f,lrc);
1280: }
1281: sl = 5; cr = 2;
1282: sl = cr;
1283: if(sl != 2){
1284: lrc = 8;
1285: if(prlc) printf(f,lrc);
1286: }
1287: sl = 5; sr = 2;
1288: sl = sr;
1289: if(sl != 2){
1290: lrc = 9;
1291: if(prlc) printf(f,lrc);
1292: }
1293: sl = 5; ir = 2;
1294: sl = ir;
1295: if(sl != 2){
1296: lrc = 10;
1297: if(prlc) printf(f,lrc);
1298: }
1299: sl = 5; lr = 2;
1300: sl = lr;
1301: if(sl != 2){
1302: lrc = 11;
1303: if(prlc) printf(f,lrc);
1304: }
1305: sl = 5; ur = 2;
1306: sl = ur;
1307: if(sl != 2){
1308: lrc = 12;
1309: if(prlc) printf(f,lrc);
1310: }
1311: sl = 5; fr = 2;
1312: sl = fr;
1313: if(sl != 2){
1314: lrc = 13;
1315: if(prlc) printf(f,lrc);
1316: }
1317: sl = 5; dr = 2;
1318: sl = dr;
1319: if(sl != 2){
1320: lrc = 14;
1321: if(prlc) printf(f,lrc);
1322: }
1323: il = 5; cr = 2;
1324: il = cr;
1325: if(il != 2){
1326: lrc = 15;
1327: if(prlc) printf(f,lrc);
1328: }
1329: il = 5; sr = 2;
1330: il = sr;
1331: if(il != 2){
1332: lrc = 16;
1333: if(prlc) printf(f,lrc);
1334: }
1335: il = 5; ir = 2;
1336: il = ir;
1337: if(il != 2){
1338: lrc = 17;
1339: if(prlc) printf(f,lrc);
1340: }
1341: il = 5; lr = 2;
1342: il = lr;
1343: if(il != 2){
1344: lrc = 18;
1345: if(prlc) printf(f,lrc);
1346: }
1347: il = 5; ur = 2;
1348: il = ur;
1349: if(il != 2){
1350: lrc = 19;
1351: if(prlc) printf(f,lrc);
1352: }
1353: il = 5; fr = 2;
1354: il = fr;
1355: if(il != 2){
1356: lrc = 20;
1357: if(prlc) printf(f,lrc);
1358: }
1359: il = 5; dr = 2;
1360: il = dr;
1361: if(il != 2){
1362: lrc = 21;
1363: if(prlc) printf(f,lrc);
1364: }
1365: ll = 5; cr = 2;
1366: ll = cr;
1367: if(ll != 2){
1368: lrc = 22;
1369: if(prlc) printf(f,lrc);
1370: }
1371: ll = 5; sr = 2;
1372: ll = sr;
1373: if(ll != 2){
1374: lrc = 23;
1375: if(prlc) printf(f,lrc);
1376: }
1377: ll = 5; ir = 2;
1378: ll = ir;
1379: if(ll != 2){
1380: lrc = 24;
1381: if(prlc) printf(f,lrc);
1382: }
1383: ll = 5; lr = 2;
1384: ll = lr;
1385: if(ll != 2){
1386: lrc = 25;
1387: if(prlc) printf(f,lrc);
1388: }
1389: ll = 5; ur = 2;
1390: ll = ur;
1391: if(ll != 2){
1392: lrc = 26;
1393: if(prlc) printf(f,lrc);
1394: }
1395: ll = 5; fr = 2;
1396: ll = fr;
1397: if(ll != 2){
1398: lrc = 27;
1399: if(prlc) printf(f,lrc);
1400: }
1401: ll = 5; dr = 2;
1402: ll = dr;
1403: if(ll != 2){
1404: lrc = 28;
1405: if(prlc) printf(f,lrc);
1406: }
1407: ul = 5; cr = 2;
1408: ul = cr;
1409: if(ul != 2){
1410: lrc = 29;
1411: if(prlc) printf(f,lrc);
1412: }
1413: ul = 5; sr = 2;
1414: ul = sr;
1415: if(ul != 2){
1416: lrc = 30;
1417: if(prlc) printf(f,lrc);
1418: }
1419: ul = 5; ir = 2;
1420: ul = ir;
1421: if(ul != 2){
1422: lrc = 31;
1423: if(prlc) printf(f,lrc);
1424: }
1425: ul = 5; lr = 2;
1426: ul = lr;
1427: if(ul != 2){
1428: lrc = 32;
1429: if(prlc) printf(f,lrc);
1430: }
1431: ul = 5; ur = 2;
1432: ul = ur;
1433: if(ul != 2){
1434: lrc = 33;
1435: if(prlc) printf(f,lrc);
1436: }
1437: ul = 5; fr = 2;
1438: ul = fr;
1439: if(ul != 2){
1440: lrc = 34;
1441: if(prlc) printf(f,lrc);
1442: }
1443: ul = 5; dr = 2;
1444: ul = dr;
1445: if(ul != 2){
1446: lrc = 35;
1447: if(prlc) printf(f,lrc);
1448: }
1449: fl = 5; cr = 2;
1450: fl = cr;
1451: if(fl != 2){
1452: lrc = 36;
1453: if(prlc) printf(f,lrc);
1454: }
1455: fl = 5; sr = 2;
1456: fl = sr;
1457: if(fl != 2){
1458: lrc = 37;
1459: if(prlc) printf(f,lrc);
1460: }
1461: fl = 5; ir = 2;
1462: fl = ir;
1463: if(fl != 2){
1464: lrc = 38;
1465: if(prlc) printf(f,lrc);
1466: }
1467: fl = 5; lr = 2;
1468: fl = lr;
1469: if(fl != 2){
1470: lrc = 39;
1471: if(prlc) printf(f,lrc);
1472: }
1473: fl = 5; ur = 2;
1474: fl = ur;
1475: if(fl != 2){
1476: lrc = 40;
1477: if(prlc) printf(f,lrc);
1478: }
1479: fl = 5; fr = 2;
1480: fl = fr;
1481: if(fl != 2){
1482: lrc = 41;
1483: if(prlc) printf(f,lrc);
1484: }
1485: fl = 5; dr = 2;
1486: fl = dr;
1487: if(fl != 2){
1488: lrc = 42;
1489: if(prlc) printf(f,lrc);
1490: }
1491: dl = 5; cr = 2;
1492: dl = cr;
1493: if(dl != 2){
1494: lrc = 43;
1495: if(prlc) printf(f,lrc);
1496: }
1497: dl = 5; sr = 2;
1498: dl = sr;
1499: if(dl != 2){
1500: lrc = 44;
1501: if(prlc) printf(f,lrc);
1502: }
1503: dl = 5; ir = 2;
1504: dl = ir;
1505: if(dl != 2){
1506: lrc = 45;
1507: if(prlc) printf(f,lrc);
1508: }
1509: dl = 5; lr = 2;
1510: dl = lr;
1511: if(dl != 2){
1512: lrc = 46;
1513: if(prlc) printf(f,lrc);
1514: }
1515: dl = 5; ur = 2;
1516: dl = ur;
1517: if(dl != 2){
1518: lrc = 47;
1519: if(prlc) printf(f,lrc);
1520: }
1521: dl = 5; fr = 2;
1522: dl = fr;
1523: if(dl != 2){
1524: lrc = 48;
1525: if(prlc) printf(f,lrc);
1526: }
1527: dl = 5; dr = 2;
1528: dl = dr;
1529: if(dl != 2){
1530: lrc = 49;
1531: if(prlc) printf(f,lrc);
1532: }
1533: cl = 5; cr = 2;
1534: cl += cr;
1535: if(cl != 7){
1536: lrc = 50;
1537: if(prlc) printf(f,lrc);
1538: }
1539: cl = 5; sr = 2;
1540: cl += sr;
1541: if(cl != 7){
1542: lrc = 51;
1543: if(prlc) printf(f,lrc);
1544: }
1545: cl = 5; ir = 2;
1546: cl += ir;
1547: if(cl != 7){
1548: lrc = 52;
1549: if(prlc) printf(f,lrc);
1550: }
1551: cl = 5; lr = 2;
1552: cl += lr;
1553: if(cl != 7){
1554: lrc = 53;
1555: if(prlc) printf(f,lrc);
1556: }
1557: cl = 5; ur = 2;
1558: cl += ur;
1559: if(cl != 7){
1560: lrc = 54;
1561: if(prlc) printf(f,lrc);
1562: }
1563: cl = 5; fr = 2;
1564: cl += fr;
1565: if(cl != 7){
1566: lrc = 55;
1567: if(prlc) printf(f,lrc);
1568: }
1569: cl = 5; dr = 2;
1570: cl += dr;
1571: if(cl != 7){
1572: lrc = 56;
1573: if(prlc) printf(f,lrc);
1574: }
1575: sl = 5; cr = 2;
1576: sl += cr;
1577: if(sl != 7){
1578: lrc = 57;
1579: if(prlc) printf(f,lrc);
1580: }
1581: sl = 5; sr = 2;
1582: sl += sr;
1583: if(sl != 7){
1584: lrc = 58;
1585: if(prlc) printf(f,lrc);
1586: }
1587: sl = 5; ir = 2;
1588: sl += ir;
1589: if(sl != 7){
1590: lrc = 59;
1591: if(prlc) printf(f,lrc);
1592: }
1593: sl = 5; lr = 2;
1594: sl += lr;
1595: if(sl != 7){
1596: lrc = 60;
1597: if(prlc) printf(f,lrc);
1598: }
1599: sl = 5; ur = 2;
1600: sl += ur;
1601: if(sl != 7){
1602: lrc = 61;
1603: if(prlc) printf(f,lrc);
1604: }
1605: sl = 5; fr = 2;
1606: sl += fr;
1607: if(sl != 7){
1608: lrc = 62;
1609: if(prlc) printf(f,lrc);
1610: }
1611: sl = 5; dr = 2;
1612: sl += dr;
1613: if(sl != 7){
1614: lrc = 63;
1615: if(prlc) printf(f,lrc);
1616: }
1617: il = 5; cr = 2;
1618: il += cr;
1619: if(il != 7){
1620: lrc = 64;
1621: if(prlc) printf(f,lrc);
1622: }
1623: il = 5; sr = 2;
1624: il += sr;
1625: if(il != 7){
1626: lrc = 65;
1627: if(prlc) printf(f,lrc);
1628: }
1629: il = 5; ir = 2;
1630: il += ir;
1631: if(il != 7){
1632: lrc = 66;
1633: if(prlc) printf(f,lrc);
1634: }
1635: il = 5; lr = 2;
1636: il += lr;
1637: if(il != 7){
1638: lrc = 67;
1639: if(prlc) printf(f,lrc);
1640: }
1641: il = 5; ur = 2;
1642: il += ur;
1643: if(il != 7){
1644: lrc = 68;
1645: if(prlc) printf(f,lrc);
1646: }
1647: il = 5; fr = 2;
1648: il += fr;
1649: if(il != 7){
1650: lrc = 69;
1651: if(prlc) printf(f,lrc);
1652: }
1653: il = 5; dr = 2;
1654: il += dr;
1655: if(il != 7){
1656: lrc = 70;
1657: if(prlc) printf(f,lrc);
1658: }
1659: ll = 5; cr = 2;
1660: ll += cr;
1661: if(ll != 7){
1662: lrc = 71;
1663: if(prlc) printf(f,lrc);
1664: }
1665: ll = 5; sr = 2;
1666: ll += sr;
1667: if(ll != 7){
1668: lrc = 72;
1669: if(prlc) printf(f,lrc);
1670: }
1671: ll = 5; ir = 2;
1672: ll += ir;
1673: if(ll != 7){
1674: lrc = 73;
1675: if(prlc) printf(f,lrc);
1676: }
1677: ll = 5; lr = 2;
1678: ll += lr;
1679: if(ll != 7){
1680: lrc = 74;
1681: if(prlc) printf(f,lrc);
1682: }
1683: ll = 5; ur = 2;
1684: ll += ur;
1685: if(ll != 7){
1686: lrc = 75;
1687: if(prlc) printf(f,lrc);
1688: }
1689: ll = 5; fr = 2;
1690: ll += fr;
1691: if(ll != 7){
1692: lrc = 76;
1693: if(prlc) printf(f,lrc);
1694: }
1695: ll = 5; dr = 2;
1696: ll += dr;
1697: if(ll != 7){
1698: lrc = 77;
1699: if(prlc) printf(f,lrc);
1700: }
1701: ul = 5; cr = 2;
1702: ul += cr;
1703: if(ul != 7){
1704: lrc = 78;
1705: if(prlc) printf(f,lrc);
1706: }
1707: ul = 5; sr = 2;
1708: ul += sr;
1709: if(ul != 7){
1710: lrc = 79;
1711: if(prlc) printf(f,lrc);
1712: }
1713: ul = 5; ir = 2;
1714: ul += ir;
1715: if(ul != 7){
1716: lrc = 80;
1717: if(prlc) printf(f,lrc);
1718: }
1719: ul = 5; lr = 2;
1720: ul += lr;
1721: if(ul != 7){
1722: lrc = 81;
1723: if(prlc) printf(f,lrc);
1724: }
1725: ul = 5; ur = 2;
1726: ul += ur;
1727: if(ul != 7){
1728: lrc = 82;
1729: if(prlc) printf(f,lrc);
1730: }
1731: ul = 5; fr = 2;
1732: ul += fr;
1733: if(ul != 7){
1734: lrc = 83;
1735: if(prlc) printf(f,lrc);
1736: }
1737: ul = 5; dr = 2;
1738: ul += dr;
1739: if(ul != 7){
1740: lrc = 84;
1741: if(prlc) printf(f,lrc);
1742: }
1743: fl = 5; cr = 2;
1744: fl += cr;
1745: if(fl != 7){
1746: lrc = 85;
1747: if(prlc) printf(f,lrc);
1748: }
1749: fl = 5; sr = 2;
1750: fl += sr;
1751: if(fl != 7){
1752: lrc = 86;
1753: if(prlc) printf(f,lrc);
1754: }
1755: fl = 5; ir = 2;
1756: fl += ir;
1757: if(fl != 7){
1758: lrc = 87;
1759: if(prlc) printf(f,lrc);
1760: }
1761: fl = 5; lr = 2;
1762: fl += lr;
1763: if(fl != 7){
1764: lrc = 88;
1765: if(prlc) printf(f,lrc);
1766: }
1767: fl = 5; ur = 2;
1768: fl += ur;
1769: if(fl != 7){
1770: lrc = 89;
1771: if(prlc) printf(f,lrc);
1772: }
1773: fl = 5; fr = 2;
1774: fl += fr;
1775: if(fl != 7){
1776: lrc = 90;
1777: if(prlc) printf(f,lrc);
1778: }
1779: fl = 5; dr = 2;
1780: fl += dr;
1781: if(fl != 7){
1782: lrc = 91;
1783: if(prlc) printf(f,lrc);
1784: }
1785: dl = 5; cr = 2;
1786: dl += cr;
1787: if(dl != 7){
1788: lrc = 92;
1789: if(prlc) printf(f,lrc);
1790: }
1791: dl = 5; sr = 2;
1792: dl += sr;
1793: if(dl != 7){
1794: lrc = 93;
1795: if(prlc) printf(f,lrc);
1796: }
1797: dl = 5; ir = 2;
1798: dl += ir;
1799: if(dl != 7){
1800: lrc = 94;
1801: if(prlc) printf(f,lrc);
1802: }
1803: dl = 5; lr = 2;
1804: dl += lr;
1805: if(dl != 7){
1806: lrc = 95;
1807: if(prlc) printf(f,lrc);
1808: }
1809: dl = 5; ur = 2;
1810: dl += ur;
1811: if(dl != 7){
1812: lrc = 96;
1813: if(prlc) printf(f,lrc);
1814: }
1815: dl = 5; fr = 2;
1816: dl += fr;
1817: if(dl != 7){
1818: lrc = 97;
1819: if(prlc) printf(f,lrc);
1820: }
1821: dl = 5; dr = 2;
1822: dl += dr;
1823: if(dl != 7){
1824: lrc = 98;
1825: if(prlc) printf(f,lrc);
1826: }
1827: cl = 5; cr = 2;
1828: cl -= cr;
1829: if(cl != 3){
1830: lrc = 99;
1831: if(prlc) printf(f,lrc);
1832: }
1833: cl = 5; sr = 2;
1834: cl -= sr;
1835: if(cl != 3){
1836: lrc = 100;
1837: if(prlc) printf(f,lrc);
1838: }
1839: cl = 5; ir = 2;
1840: cl -= ir;
1841: if(cl != 3){
1842: lrc = 101;
1843: if(prlc) printf(f,lrc);
1844: }
1845: cl = 5; lr = 2;
1846: cl -= lr;
1847: if(cl != 3){
1848: lrc = 102;
1849: if(prlc) printf(f,lrc);
1850: }
1851: cl = 5; ur = 2;
1852: cl -= ur;
1853: if(cl != 3){
1854: lrc = 103;
1855: if(prlc) printf(f,lrc);
1856: }
1857: cl = 5; fr = 2;
1858: cl -= fr;
1859: if(cl != 3){
1860: lrc = 104;
1861: if(prlc) printf(f,lrc);
1862: }
1863: cl = 5; dr = 2;
1864: cl -= dr;
1865: if(cl != 3){
1866: lrc = 105;
1867: if(prlc) printf(f,lrc);
1868: }
1869: sl = 5; cr = 2;
1870: sl -= cr;
1871: if(sl != 3){
1872: lrc = 106;
1873: if(prlc) printf(f,lrc);
1874: }
1875: sl = 5; sr = 2;
1876: sl -= sr;
1877: if(sl != 3){
1878: lrc = 107;
1879: if(prlc) printf(f,lrc);
1880: }
1881: sl = 5; ir = 2;
1882: sl -= ir;
1883: if(sl != 3){
1884: lrc = 108;
1885: if(prlc) printf(f,lrc);
1886: }
1887: sl = 5; lr = 2;
1888: sl -= lr;
1889: if(sl != 3){
1890: lrc = 109;
1891: if(prlc) printf(f,lrc);
1892: }
1893: sl = 5; ur = 2;
1894: sl -= ur;
1895: if(sl != 3){
1896: lrc = 110;
1897: if(prlc) printf(f,lrc);
1898: }
1899: sl = 5; fr = 2;
1900: sl -= fr;
1901: if(sl != 3){
1902: lrc = 111;
1903: if(prlc) printf(f,lrc);
1904: }
1905: sl = 5; dr = 2;
1906: sl -= dr;
1907: if(sl != 3){
1908: lrc = 112;
1909: if(prlc) printf(f,lrc);
1910: }
1911: il = 5; cr = 2;
1912: il -= cr;
1913: if(il != 3){
1914: lrc = 113;
1915: if(prlc) printf(f,lrc);
1916: }
1917: il = 5; sr = 2;
1918: il -= sr;
1919: if(il != 3){
1920: lrc = 114;
1921: if(prlc) printf(f,lrc);
1922: }
1923: il = 5; ir = 2;
1924: il -= ir;
1925: if(il != 3){
1926: lrc = 115;
1927: if(prlc) printf(f,lrc);
1928: }
1929: il = 5; lr = 2;
1930: il -= lr;
1931: if(il != 3){
1932: lrc = 116;
1933: if(prlc) printf(f,lrc);
1934: }
1935: il = 5; ur = 2;
1936: il -= ur;
1937: if(il != 3){
1938: lrc = 117;
1939: if(prlc) printf(f,lrc);
1940: }
1941: il = 5; fr = 2;
1942: il -= fr;
1943: if(il != 3){
1944: lrc = 118;
1945: if(prlc) printf(f,lrc);
1946: }
1947: il = 5; dr = 2;
1948: il -= dr;
1949: if(il != 3){
1950: lrc = 119;
1951: if(prlc) printf(f,lrc);
1952: }
1953: ll = 5; cr = 2;
1954: ll -= cr;
1955: if(ll != 3){
1956: lrc = 120;
1957: if(prlc) printf(f,lrc);
1958: }
1959: ll = 5; sr = 2;
1960: ll -= sr;
1961: if(ll != 3){
1962: lrc = 121;
1963: if(prlc) printf(f,lrc);
1964: }
1965: ll = 5; ir = 2;
1966: ll -= ir;
1967: if(ll != 3){
1968: lrc = 122;
1969: if(prlc) printf(f,lrc);
1970: }
1971: ll = 5; lr = 2;
1972: ll -= lr;
1973: if(ll != 3){
1974: lrc = 123;
1975: if(prlc) printf(f,lrc);
1976: }
1977: ll = 5; ur = 2;
1978: ll -= ur;
1979: if(ll != 3){
1980: lrc = 124;
1981: if(prlc) printf(f,lrc);
1982: }
1983: ll = 5; fr = 2;
1984: ll -= fr;
1985: if(ll != 3){
1986: lrc = 125;
1987: if(prlc) printf(f,lrc);
1988: }
1989: ll = 5; dr = 2;
1990: ll -= dr;
1991: if(ll != 3){
1992: lrc = 126;
1993: if(prlc) printf(f,lrc);
1994: }
1995: ul = 5; cr = 2;
1996: ul -= cr;
1997: if(ul != 3){
1998: lrc = 127;
1999: if(prlc) printf(f,lrc);
2000: }
2001: ul = 5; sr = 2;
2002: ul -= sr;
2003: if(ul != 3){
2004: lrc = 128;
2005: if(prlc) printf(f,lrc);
2006: }
2007: ul = 5; ir = 2;
2008: ul -= ir;
2009: if(ul != 3){
2010: lrc = 129;
2011: if(prlc) printf(f,lrc);
2012: }
2013: ul = 5; lr = 2;
2014: ul -= lr;
2015: if(ul != 3){
2016: lrc = 130;
2017: if(prlc) printf(f,lrc);
2018: }
2019: ul = 5; ur = 2;
2020: ul -= ur;
2021: if(ul != 3){
2022: lrc = 131;
2023: if(prlc) printf(f,lrc);
2024: }
2025: ul = 5; fr = 2;
2026: ul -= fr;
2027: if(ul != 3){
2028: lrc = 132;
2029: if(prlc) printf(f,lrc);
2030: }
2031: ul = 5; dr = 2;
2032: ul -= dr;
2033: if(ul != 3){
2034: lrc = 133;
2035: if(prlc) printf(f,lrc);
2036: }
2037: fl = 5; cr = 2;
2038: fl -= cr;
2039: if(fl != 3){
2040: lrc = 134;
2041: if(prlc) printf(f,lrc);
2042: }
2043: fl = 5; sr = 2;
2044: fl -= sr;
2045: if(fl != 3){
2046: lrc = 135;
2047: if(prlc) printf(f,lrc);
2048: }
2049: fl = 5; ir = 2;
2050: fl -= ir;
2051: if(fl != 3){
2052: lrc = 136;
2053: if(prlc) printf(f,lrc);
2054: }
2055: fl = 5; lr = 2;
2056: fl -= lr;
2057: if(fl != 3){
2058: lrc = 137;
2059: if(prlc) printf(f,lrc);
2060: }
2061: fl = 5; ur = 2;
2062: fl -= ur;
2063: if(fl != 3){
2064: lrc = 138;
2065: if(prlc) printf(f,lrc);
2066: }
2067: fl = 5; fr = 2;
2068: fl -= fr;
2069: if(fl != 3){
2070: lrc = 139;
2071: if(prlc) printf(f,lrc);
2072: }
2073: fl = 5; dr = 2;
2074: fl -= dr;
2075: if(fl != 3){
2076: lrc = 140;
2077: if(prlc) printf(f,lrc);
2078: }
2079: dl = 5; cr = 2;
2080: dl -= cr;
2081: if(dl != 3){
2082: lrc = 141;
2083: if(prlc) printf(f,lrc);
2084: }
2085: dl = 5; sr = 2;
2086: dl -= sr;
2087: if(dl != 3){
2088: lrc = 142;
2089: if(prlc) printf(f,lrc);
2090: }
2091: dl = 5; ir = 2;
2092: dl -= ir;
2093: if(dl != 3){
2094: lrc = 143;
2095: if(prlc) printf(f,lrc);
2096: }
2097: dl = 5; lr = 2;
2098: dl -= lr;
2099: if(dl != 3){
2100: lrc = 144;
2101: if(prlc) printf(f,lrc);
2102: }
2103: dl = 5; ur = 2;
2104: dl -= ur;
2105: if(dl != 3){
2106: lrc = 145;
2107: if(prlc) printf(f,lrc);
2108: }
2109: dl = 5; fr = 2;
2110: dl -= fr;
2111: if(dl != 3){
2112: lrc = 146;
2113: if(prlc) printf(f,lrc);
2114: }
2115: dl = 5; dr = 2;
2116: dl -= dr;
2117: if(dl != 3){
2118: lrc = 147;
2119: if(prlc) printf(f,lrc);
2120: }
2121: cl = 5; cr = 2;
2122: cl *= cr;
2123: if(cl != 10){
2124: lrc = 148;
2125: if(prlc) printf(f,lrc);
2126: }
2127: cl = 5; sr = 2;
2128: cl *= sr;
2129: if(cl != 10){
2130: lrc = 149;
2131: if(prlc) printf(f,lrc);
2132: }
2133: cl = 5; ir = 2;
2134: cl *= ir;
2135: if(cl != 10){
2136: lrc = 150;
2137: if(prlc) printf(f,lrc);
2138: }
2139: cl = 5; lr = 2;
2140: cl *= lr;
2141: if(cl != 10){
2142: lrc = 151;
2143: if(prlc) printf(f,lrc);
2144: }
2145: cl = 5; ur = 2;
2146: cl *= ur;
2147: if(cl != 10){
2148: lrc = 152;
2149: if(prlc) printf(f,lrc);
2150: }
2151: cl = 5; fr = 2;
2152: cl *= fr;
2153: if(cl != 10){
2154: lrc = 153;
2155: if(prlc) printf(f,lrc);
2156: }
2157: cl = 5; dr = 2;
2158: cl *= dr;
2159: if(cl != 10){
2160: lrc = 154;
2161: if(prlc) printf(f,lrc);
2162: }
2163: sl = 5; cr = 2;
2164: sl *= cr;
2165: if(sl != 10){
2166: lrc = 155;
2167: if(prlc) printf(f,lrc);
2168: }
2169: sl = 5; sr = 2;
2170: sl *= sr;
2171: if(sl != 10){
2172: lrc = 156;
2173: if(prlc) printf(f,lrc);
2174: }
2175: sl = 5; ir = 2;
2176: sl *= ir;
2177: if(sl != 10){
2178: lrc = 157;
2179: if(prlc) printf(f,lrc);
2180: }
2181: sl = 5; lr = 2;
2182: sl *= lr;
2183: if(sl != 10){
2184: lrc = 158;
2185: if(prlc) printf(f,lrc);
2186: }
2187: sl = 5; ur = 2;
2188: sl *= ur;
2189: if(sl != 10){
2190: lrc = 159;
2191: if(prlc) printf(f,lrc);
2192: }
2193: sl = 5; fr = 2;
2194: sl *= fr;
2195: if(sl != 10){
2196: lrc = 160;
2197: if(prlc) printf(f,lrc);
2198: }
2199: sl = 5; dr = 2;
2200: sl *= dr;
2201: if(sl != 10){
2202: lrc = 161;
2203: if(prlc) printf(f,lrc);
2204: }
2205: il = 5; cr = 2;
2206: il *= cr;
2207: if(il != 10){
2208: lrc = 162;
2209: if(prlc) printf(f,lrc);
2210: }
2211: il = 5; sr = 2;
2212: il *= sr;
2213: if(il != 10){
2214: lrc = 163;
2215: if(prlc) printf(f,lrc);
2216: }
2217: il = 5; ir = 2;
2218: il *= ir;
2219: if(il != 10){
2220: lrc = 164;
2221: if(prlc) printf(f,lrc);
2222: }
2223: il = 5; lr = 2;
2224: il *= lr;
2225: if(il != 10){
2226: lrc = 165;
2227: if(prlc) printf(f,lrc);
2228: }
2229: il = 5; ur = 2;
2230: il *= ur;
2231: if(il != 10){
2232: lrc = 166;
2233: if(prlc) printf(f,lrc);
2234: }
2235: il = 5; fr = 2;
2236: il *= fr;
2237: if(il != 10){
2238: lrc = 167;
2239: if(prlc) printf(f,lrc);
2240: }
2241: il = 5; dr = 2;
2242: il *= dr;
2243: if(il != 10){
2244: lrc = 168;
2245: if(prlc) printf(f,lrc);
2246: }
2247: ll = 5; cr = 2;
2248: ll *= cr;
2249: if(ll != 10){
2250: lrc = 169;
2251: if(prlc) printf(f,lrc);
2252: }
2253: ll = 5; sr = 2;
2254: ll *= sr;
2255: if(ll != 10){
2256: lrc = 170;
2257: if(prlc) printf(f,lrc);
2258: }
2259: ll = 5; ir = 2;
2260: ll *= ir;
2261: if(ll != 10){
2262: lrc = 171;
2263: if(prlc) printf(f,lrc);
2264: }
2265: ll = 5; lr = 2;
2266: ll *= lr;
2267: if(ll != 10){
2268: lrc = 172;
2269: if(prlc) printf(f,lrc);
2270: }
2271: ll = 5; ur = 2;
2272: ll *= ur;
2273: if(ll != 10){
2274: lrc = 173;
2275: if(prlc) printf(f,lrc);
2276: }
2277: ll = 5; fr = 2;
2278: ll *= fr;
2279: if(ll != 10){
2280: lrc = 174;
2281: if(prlc) printf(f,lrc);
2282: }
2283: ll = 5; dr = 2;
2284: ll *= dr;
2285: if(ll != 10){
2286: lrc = 175;
2287: if(prlc) printf(f,lrc);
2288: }
2289: ul = 5; cr = 2;
2290: ul *= cr;
2291: if(ul != 10){
2292: lrc = 176;
2293: if(prlc) printf(f,lrc);
2294: }
2295: ul = 5; sr = 2;
2296: ul *= sr;
2297: if(ul != 10){
2298: lrc = 177;
2299: if(prlc) printf(f,lrc);
2300: }
2301: ul = 5; ir = 2;
2302: ul *= ir;
2303: if(ul != 10){
2304: lrc = 178;
2305: if(prlc) printf(f,lrc);
2306: }
2307: ul = 5; lr = 2;
2308: ul *= lr;
2309: if(ul != 10){
2310: lrc = 179;
2311: if(prlc) printf(f,lrc);
2312: }
2313: ul = 5; ur = 2;
2314: ul *= ur;
2315: if(ul != 10){
2316: lrc = 180;
2317: if(prlc) printf(f,lrc);
2318: }
2319: ul = 5; fr = 2;
2320: ul *= fr;
2321: if(ul != 10){
2322: lrc = 181;
2323: if(prlc) printf(f,lrc);
2324: }
2325: ul = 5; dr = 2;
2326: ul *= dr;
2327: if(ul != 10){
2328: lrc = 182;
2329: if(prlc) printf(f,lrc);
2330: }
2331: fl = 5; cr = 2;
2332: fl *= cr;
2333: if(fl != 10){
2334: lrc = 183;
2335: if(prlc) printf(f,lrc);
2336: }
2337: fl = 5; sr = 2;
2338: fl *= sr;
2339: if(fl != 10){
2340: lrc = 184;
2341: if(prlc) printf(f,lrc);
2342: }
2343: fl = 5; ir = 2;
2344: fl *= ir;
2345: if(fl != 10){
2346: lrc = 185;
2347: if(prlc) printf(f,lrc);
2348: }
2349: fl = 5; lr = 2;
2350: fl *= lr;
2351: if(fl != 10){
2352: lrc = 186;
2353: if(prlc) printf(f,lrc);
2354: }
2355: fl = 5; ur = 2;
2356: fl *= ur;
2357: if(fl != 10){
2358: lrc = 187;
2359: if(prlc) printf(f,lrc);
2360: }
2361: fl = 5; fr = 2;
2362: fl *= fr;
2363: if(fl != 10){
2364: lrc = 188;
2365: if(prlc) printf(f,lrc);
2366: }
2367: fl = 5; dr = 2;
2368: fl *= dr;
2369: if(fl != 10){
2370: lrc = 189;
2371: if(prlc) printf(f,lrc);
2372: }
2373: dl = 5; cr = 2;
2374: dl *= cr;
2375: if(dl != 10){
2376: lrc = 190;
2377: if(prlc) printf(f,lrc);
2378: }
2379: dl = 5; sr = 2;
2380: dl *= sr;
2381: if(dl != 10){
2382: lrc = 191;
2383: if(prlc) printf(f,lrc);
2384: }
2385: dl = 5; ir = 2;
2386: dl *= ir;
2387: if(dl != 10){
2388: lrc = 192;
2389: if(prlc) printf(f,lrc);
2390: }
2391: dl = 5; lr = 2;
2392: dl *= lr;
2393: if(dl != 10){
2394: lrc = 193;
2395: if(prlc) printf(f,lrc);
2396: }
2397: dl = 5; ur = 2;
2398: dl *= ur;
2399: if(dl != 10){
2400: lrc = 194;
2401: if(prlc) printf(f,lrc);
2402: }
2403: dl = 5; fr = 2;
2404: dl *= fr;
2405: if(dl != 10){
2406: lrc = 195;
2407: if(prlc) printf(f,lrc);
2408: }
2409: dl = 5; dr = 2;
2410: dl *= dr;
2411: if(dl != 10){
2412: lrc = 196;
2413: if(prlc) printf(f,lrc);
2414: }
2415: cl = 5; cr = 2;
2416: cl /= cr;
2417: if(cl != 2){
2418: lrc = 197;
2419: if(prlc) printf(f,lrc);
2420: }
2421: cl = 5; sr = 2;
2422: cl /= sr;
2423: if(cl != 2){
2424: lrc = 198;
2425: if(prlc) printf(f,lrc);
2426: }
2427: cl = 5; ir = 2;
2428: cl /= ir;
2429: if(cl != 2){
2430: lrc = 199;
2431: if(prlc) printf(f,lrc);
2432: }
2433: cl = 5; lr = 2;
2434: cl /= lr;
2435: if(cl != 2){
2436: lrc = 200;
2437: if(prlc) printf(f,lrc);
2438: }
2439: cl = 5; ur = 2;
2440: cl /= ur;
2441: if(cl != 2){
2442: lrc = 201;
2443: if(prlc) printf(f,lrc);
2444: }
2445: cl = 5; fr = 2;
2446: cl /= fr;
2447: if(cl != 2){
2448: lrc = 202;
2449: if(prlc) printf(f,lrc);
2450: }
2451: cl = 5; dr = 2;
2452: cl /= dr;
2453: if(cl != 2){
2454: lrc = 203;
2455: if(prlc) printf(f,lrc);
2456: }
2457: sl = 5; cr = 2;
2458: sl /= cr;
2459: if(sl != 2){
2460: lrc = 204;
2461: if(prlc) printf(f,lrc);
2462: }
2463: sl = 5; sr = 2;
2464: sl /= sr;
2465: if(sl != 2){
2466: lrc = 205;
2467: if(prlc) printf(f,lrc);
2468: }
2469: sl = 5; ir = 2;
2470: sl /= ir;
2471: if(sl != 2){
2472: lrc = 206;
2473: if(prlc) printf(f,lrc);
2474: }
2475: sl = 5; lr = 2;
2476: sl /= lr;
2477: if(sl != 2){
2478: lrc = 207;
2479: if(prlc) printf(f,lrc);
2480: }
2481: sl = 5; ur = 2;
2482: sl /= ur;
2483: if(sl != 2){
2484: lrc = 208;
2485: if(prlc) printf(f,lrc);
2486: }
2487: sl = 5; fr = 2;
2488: sl /= fr;
2489: if(sl != 2){
2490: lrc = 209;
2491: if(prlc) printf(f,lrc);
2492: }
2493: sl = 5; dr = 2;
2494: sl /= dr;
2495: if(sl != 2){
2496: lrc = 210;
2497: if(prlc) printf(f,lrc);
2498: }
2499: il = 5; cr = 2;
2500: il /= cr;
2501: if(il != 2){
2502: lrc = 211;
2503: if(prlc) printf(f,lrc);
2504: }
2505: il = 5; sr = 2;
2506: il /= sr;
2507: if(il != 2){
2508: lrc = 212;
2509: if(prlc) printf(f,lrc);
2510: }
2511: il = 5; ir = 2;
2512: il /= ir;
2513: if(il != 2){
2514: lrc = 213;
2515: if(prlc) printf(f,lrc);
2516: }
2517: il = 5; lr = 2;
2518: il /= lr;
2519: if(il != 2){
2520: lrc = 214;
2521: if(prlc) printf(f,lrc);
2522: }
2523: il = 5; ur = 2;
2524: il /= ur;
2525: if(il != 2){
2526: lrc = 215;
2527: if(prlc) printf(f,lrc);
2528: }
2529: il = 5; fr = 2;
2530: il /= fr;
2531: if(il != 2){
2532: lrc = 216;
2533: if(prlc) printf(f,lrc);
2534: }
2535: il = 5; dr = 2;
2536: il /= dr;
2537: if(il != 2){
2538: lrc = 217;
2539: if(prlc) printf(f,lrc);
2540: }
2541: ll = 5; cr = 2;
2542: ll /= cr;
2543: if(ll != 2){
2544: lrc = 218;
2545: if(prlc) printf(f,lrc);
2546: }
2547: ll = 5; sr = 2;
2548: ll /= sr;
2549: if(ll != 2){
2550: lrc = 219;
2551: if(prlc) printf(f,lrc);
2552: }
2553: ll = 5; ir = 2;
2554: ll /= ir;
2555: if(ll != 2){
2556: lrc = 220;
2557: if(prlc) printf(f,lrc);
2558: }
2559: ll = 5; lr = 2;
2560: ll /= lr;
2561: if(ll != 2){
2562: lrc = 221;
2563: if(prlc) printf(f,lrc);
2564: }
2565: ll = 5; ur = 2;
2566: ll /= ur;
2567: if(ll != 2){
2568: lrc = 222;
2569: if(prlc) printf(f,lrc);
2570: }
2571: ll = 5; fr = 2;
2572: ll /= fr;
2573: if(ll != 2){
2574: lrc = 223;
2575: if(prlc) printf(f,lrc);
2576: }
2577: ll = 5; dr = 2;
2578: ll /= dr;
2579: if(ll != 2){
2580: lrc = 224;
2581: if(prlc) printf(f,lrc);
2582: }
2583: ul = 5; cr = 2;
2584: ul /= cr;
2585: if(ul != 2){
2586: lrc = 225;
2587: if(prlc) printf(f,lrc);
2588: }
2589: ul = 5; sr = 2;
2590: ul /= sr;
2591: if(ul != 2){
2592: lrc = 226;
2593: if(prlc) printf(f,lrc);
2594: }
2595: ul = 5; ir = 2;
2596: ul /= ir;
2597: if(ul != 2){
2598: lrc = 227;
2599: if(prlc) printf(f,lrc);
2600: }
2601: ul = 5; lr = 2;
2602: ul /= lr;
2603: if(ul != 2){
2604: lrc = 228;
2605: if(prlc) printf(f,lrc);
2606: }
2607: ul = 5; ur = 2;
2608: ul /= ur;
2609: if(ul != 2){
2610: lrc = 229;
2611: if(prlc) printf(f,lrc);
2612: }
2613: ul = 5; fr = 2;
2614: ul /= fr;
2615: if(ul != 2){
2616: lrc = 230;
2617: if(prlc) printf(f,lrc);
2618: }
2619: ul = 5; dr = 2;
2620: ul /= dr;
2621: if(ul != 2){
2622: lrc = 231;
2623: if(prlc) printf(f,lrc);
2624: }
2625: fl = 5; cr = 2;
2626: fl /= cr;
2627: if(fl != 2.5){
2628: lrc = 232;
2629: if(prlc) printf(f,lrc);
2630: }
2631: fl = 5; sr = 2;
2632: fl /= sr;
2633: if(fl != 2.5){
2634: lrc = 233;
2635: if(prlc) printf(f,lrc);
2636: }
2637: fl = 5; ir = 2;
2638: fl /= ir;
2639: if(fl != 2.5){
2640: lrc = 234;
2641: if(prlc) printf(f,lrc);
2642: }
2643: fl = 5; lr = 2;
2644: fl /= lr;
2645: if(fl != 2.5){
2646: lrc = 235;
2647: if(prlc) printf(f,lrc);
2648: }
2649: fl = 5; ur = 2;
2650: fl /= ur;
2651: if(fl != 2.5){
2652: lrc = 236;
2653: if(prlc) printf(f,lrc);
2654: }
2655: fl = 5; fr = 2;
2656: fl /= fr;
2657: if(fl != 2.5){
2658: lrc = 237;
2659: if(prlc) printf(f,lrc);
2660: }
2661: fl = 5; dr = 2;
2662: fl /= dr;
2663: if(fl != 2.5){
2664: lrc = 238;
2665: if(prlc) printf(f,lrc);
2666: }
2667: dl = 5; cr = 2;
2668: dl /= cr;
2669: if(dl != 2.5){
2670: lrc = 239;
2671: if(prlc) printf(f,lrc);
2672: }
2673: dl = 5; sr = 2;
2674: dl /= sr;
2675: if(dl != 2.5){
2676: lrc = 240;
2677: if(prlc) printf(f,lrc);
2678: }
2679: dl = 5; ir = 2;
2680: dl /= ir;
2681: if(dl != 2.5){
2682: lrc = 241;
2683: if(prlc) printf(f,lrc);
2684: }
2685: dl = 5; lr = 2;
2686: dl /= lr;
2687: if(dl != 2.5){
2688: lrc = 242;
2689: if(prlc) printf(f,lrc);
2690: }
2691: dl = 5; ur = 2;
2692: dl /= ur;
2693: if(dl != 2.5){
2694: lrc = 243;
2695: if(prlc) printf(f,lrc);
2696: }
2697: dl = 5; fr = 2;
2698: dl /= fr;
2699: if(dl != 2.5){
2700: lrc = 244;
2701: if(prlc) printf(f,lrc);
2702: }
2703: dl = 5; dr = 2;
2704: dl /= dr;
2705: if(dl != 2.5){
2706: lrc = 245;
2707: if(prlc) printf(f,lrc);
2708: }
2709: cl = 5; cr = 2;
2710: cl %= cr;
2711: if(cl != 1){
2712: lrc = 246;
2713: if(prlc) printf(f,lrc);
2714: }
2715: cl = 5; sr = 2;
2716: cl %= sr;
2717: if(cl != 1){
2718: lrc = 247;
2719: if(prlc) printf(f,lrc);
2720: }
2721: cl = 5; ir = 2;
2722: cl %= ir;
2723: if(cl != 1){
2724: lrc = 248;
2725: if(prlc) printf(f,lrc);
2726: }
2727: cl = 5; lr = 2;
2728: cl %= lr;
2729: if(cl != 1){
2730: lrc = 249;
2731: if(prlc) printf(f,lrc);
2732: }
2733: cl = 5; ur = 2;
2734: cl %= ur;
2735: if(cl != 1){
2736: lrc = 250;
2737: if(prlc) printf(f,lrc);
2738: }
2739: sl = 5; cr = 2;
2740: sl %= cr;
2741: if(sl != 1){
2742: lrc = 251;
2743: if(prlc) printf(f,lrc);
2744: }
2745: sl = 5; sr = 2;
2746: sl %= sr;
2747: if(sl != 1){
2748: lrc = 252;
2749: if(prlc) printf(f,lrc);
2750: }
2751: sl = 5; ir = 2;
2752: sl %= ir;
2753: if(sl != 1){
2754: lrc = 253;
2755: if(prlc) printf(f,lrc);
2756: }
2757: sl = 5; lr = 2;
2758: sl %= lr;
2759: if(sl != 1){
2760: lrc = 254;
2761: if(prlc) printf(f,lrc);
2762: }
2763: sl = 5; ur = 2;
2764: sl %= ur;
2765: if(sl != 1){
2766: lrc = 255;
2767: if(prlc) printf(f,lrc);
2768: }
2769: il = 5; cr = 2;
2770: il %= cr;
2771: if(il != 1){
2772: lrc = 256;
2773: if(prlc) printf(f,lrc);
2774: }
2775: il = 5; sr = 2;
2776: il %= sr;
2777: if(il != 1){
2778: lrc = 257;
2779: if(prlc) printf(f,lrc);
2780: }
2781: il = 5; ir = 2;
2782: il %= ir;
2783: if(il != 1){
2784: lrc = 258;
2785: if(prlc) printf(f,lrc);
2786: }
2787: il = 5; lr = 2;
2788: il %= lr;
2789: if(il != 1){
2790: lrc = 259;
2791: if(prlc) printf(f,lrc);
2792: }
2793: il = 5; ur = 2;
2794: il %= ur;
2795: if(il != 1){
2796: lrc = 260;
2797: if(prlc) printf(f,lrc);
2798: }
2799: ll = 5; cr = 2;
2800: ll %= cr;
2801: if(ll != 1){
2802: lrc = 261;
2803: if(prlc) printf(f,lrc);
2804: }
2805: ll = 5; sr = 2;
2806: ll %= sr;
2807: if(ll != 1){
2808: lrc = 262;
2809: if(prlc) printf(f,lrc);
2810: }
2811: ll = 5; ir = 2;
2812: ll %= ir;
2813: if(ll != 1){
2814: lrc = 263;
2815: if(prlc) printf(f,lrc);
2816: }
2817: ll = 5; lr = 2;
2818: ll %= lr;
2819: if(ll != 1){
2820: lrc = 264;
2821: if(prlc) printf(f,lrc);
2822: }
2823: ll = 5; ur = 2;
2824: ll %= ur;
2825: if(ll != 1){
2826: lrc = 265;
2827: if(prlc) printf(f,lrc);
2828: }
2829: ul = 5; cr = 2;
2830: ul %= cr;
2831: if(ul != 1){
2832: lrc = 266;
2833: if(prlc) printf(f,lrc);
2834: }
2835: ul = 5; sr = 2;
2836: ul %= sr;
2837: if(ul != 1){
2838: lrc = 267;
2839: if(prlc) printf(f,lrc);
2840: }
2841: ul = 5; ir = 2;
2842: ul %= ir;
2843: if(ul != 1){
2844: lrc = 268;
2845: if(prlc) printf(f,lrc);
2846: }
2847: ul = 5; lr = 2;
2848: ul %= lr;
2849: if(ul != 1){
2850: lrc = 269;
2851: if(prlc) printf(f,lrc);
2852: }
2853: ul = 5; ur = 2;
2854: ul %= ur;
2855: if(ul != 1){
2856: lrc = 270;
2857: if(prlc) printf(f,lrc);
2858: }
2859: cl = 5; cr = 2;
2860: cl >>= cr;
2861: if(cl != 1){
2862: lrc = 271;
2863: if(prlc) printf(f,lrc);
2864: }
2865: cl = 5; sr = 2;
2866: cl >>= sr;
2867: if(cl != 1){
2868: lrc = 272;
2869: if(prlc) printf(f,lrc);
2870: }
2871: cl = 5; ir = 2;
2872: cl >>= ir;
2873: if(cl != 1){
2874: lrc = 273;
2875: if(prlc) printf(f,lrc);
2876: }
2877: cl = 5; lr = 2;
2878: cl >>= lr;
2879: if(cl != 1){
2880: lrc = 274;
2881: if(prlc) printf(f,lrc);
2882: }
2883: cl = 5; ur = 2;
2884: cl >>= ur;
2885: if(cl != 1){
2886: lrc = 275;
2887: if(prlc) printf(f,lrc);
2888: }
2889: sl = 5; cr = 2;
2890: sl >>= cr;
2891: if(sl != 1){
2892: lrc = 276;
2893: if(prlc) printf(f,lrc);
2894: }
2895: sl = 5; sr = 2;
2896: sl >>= sr;
2897: if(sl != 1){
2898: lrc = 277;
2899: if(prlc) printf(f,lrc);
2900: }
2901: sl = 5; ir = 2;
2902: sl >>= ir;
2903: if(sl != 1){
2904: lrc = 278;
2905: if(prlc) printf(f,lrc);
2906: }
2907: sl = 5; lr = 2;
2908: sl >>= lr;
2909: if(sl != 1){
2910: lrc = 279;
2911: if(prlc) printf(f,lrc);
2912: }
2913: sl = 5; ur = 2;
2914: sl >>= ur;
2915: if(sl != 1){
2916: lrc = 280;
2917: if(prlc) printf(f,lrc);
2918: }
2919: il = 5; cr = 2;
2920: il >>= cr;
2921: if(il != 1){
2922: lrc = 281;
2923: if(prlc) printf(f,lrc);
2924: }
2925: il = 5; sr = 2;
2926: il >>= sr;
2927: if(il != 1){
2928: lrc = 282;
2929: if(prlc) printf(f,lrc);
2930: }
2931: il = 5; ir = 2;
2932: il >>= ir;
2933: if(il != 1){
2934: lrc = 283;
2935: if(prlc) printf(f,lrc);
2936: }
2937: il = 5; lr = 2;
2938: il >>= lr;
2939: if(il != 1){
2940: lrc = 284;
2941: if(prlc) printf(f,lrc);
2942: }
2943: il = 5; ur = 2;
2944: il >>= ur;
2945: if(il != 1){
2946: lrc = 285;
2947: if(prlc) printf(f,lrc);
2948: }
2949: ll = 5; cr = 2;
2950: ll >>= cr;
2951: if(ll != 1){
2952: lrc = 286;
2953: if(prlc) printf(f,lrc);
2954: }
2955: ll = 5; sr = 2;
2956: ll >>= sr;
2957: if(ll != 1){
2958: lrc = 287;
2959: if(prlc) printf(f,lrc);
2960: }
2961: ll = 5; ir = 2;
2962: ll >>= ir;
2963: if(ll != 1){
2964: lrc = 288;
2965: if(prlc) printf(f,lrc);
2966: }
2967: ll = 5; lr = 2;
2968: ll >>= lr;
2969: if(ll != 1){
2970: lrc = 289;
2971: if(prlc) printf(f,lrc);
2972: }
2973: ll = 5; ur = 2;
2974: ll >>= ur;
2975: if(ll != 1){
2976: lrc = 290;
2977: if(prlc) printf(f,lrc);
2978: }
2979: ul = 5; cr = 2;
2980: ul >>= cr;
2981: if(ul != 1){
2982: lrc = 291;
2983: if(prlc) printf(f,lrc);
2984: }
2985: ul = 5; sr = 2;
2986: ul >>= sr;
2987: if(ul != 1){
2988: lrc = 292;
2989: if(prlc) printf(f,lrc);
2990: }
2991: ul = 5; ir = 2;
2992: ul >>= ir;
2993: if(ul != 1){
2994: lrc = 293;
2995: if(prlc) printf(f,lrc);
2996: }
2997: ul = 5; lr = 2;
2998: ul >>= lr;
2999: if(ul != 1){
3000: lrc = 294;
3001: if(prlc) printf(f,lrc);
3002: }
3003: ul = 5; ur = 2;
3004: ul >>= ur;
3005: if(ul != 1){
3006: lrc = 295;
3007: if(prlc) printf(f,lrc);
3008: }
3009: cl = 5; cr = 2;
3010: cl <<= cr;
3011: if(cl != 20){
3012: lrc = 296;
3013: if(prlc) printf(f,lrc);
3014: }
3015: cl = 5; sr = 2;
3016: cl <<= sr;
3017: if(cl != 20){
3018: lrc = 297;
3019: if(prlc) printf(f,lrc);
3020: }
3021: cl = 5; ir = 2;
3022: cl <<= ir;
3023: if(cl != 20){
3024: lrc = 298;
3025: if(prlc) printf(f,lrc);
3026: }
3027: cl = 5; lr = 2;
3028: cl <<= lr;
3029: if(cl != 20){
3030: lrc = 299;
3031: if(prlc) printf(f,lrc);
3032: }
3033: cl = 5; ur = 2;
3034: cl <<= ur;
3035: if(cl != 20){
3036: lrc = 300;
3037: if(prlc) printf(f,lrc);
3038: }
3039: sl = 5; cr = 2;
3040: sl <<= cr;
3041: if(sl != 20){
3042: lrc = 301;
3043: if(prlc) printf(f,lrc);
3044: }
3045: sl = 5; sr = 2;
3046: sl <<= sr;
3047: if(sl != 20){
3048: lrc = 302;
3049: if(prlc) printf(f,lrc);
3050: }
3051: sl = 5; ir = 2;
3052: sl <<= ir;
3053: if(sl != 20){
3054: lrc = 303;
3055: if(prlc) printf(f,lrc);
3056: }
3057: sl = 5; lr = 2;
3058: sl <<= lr;
3059: if(sl != 20){
3060: lrc = 304;
3061: if(prlc) printf(f,lrc);
3062: }
3063: sl = 5; ur = 2;
3064: sl <<= ur;
3065: if(sl != 20){
3066: lrc = 305;
3067: if(prlc) printf(f,lrc);
3068: }
3069: il = 5; cr = 2;
3070: il <<= cr;
3071: if(il != 20){
3072: lrc = 306;
3073: if(prlc) printf(f,lrc);
3074: }
3075: il = 5; sr = 2;
3076: il <<= sr;
3077: if(il != 20){
3078: lrc = 307;
3079: if(prlc) printf(f,lrc);
3080: }
3081: il = 5; ir = 2;
3082: il <<= ir;
3083: if(il != 20){
3084: lrc = 308;
3085: if(prlc) printf(f,lrc);
3086: }
3087: il = 5; lr = 2;
3088: il <<= lr;
3089: if(il != 20){
3090: lrc = 309;
3091: if(prlc) printf(f,lrc);
3092: }
3093: il = 5; ur = 2;
3094: il <<= ur;
3095: if(il != 20){
3096: lrc = 310;
3097: if(prlc) printf(f,lrc);
3098: }
3099: ll = 5; cr = 2;
3100: ll <<= cr;
3101: if(ll != 20){
3102: lrc = 311;
3103: if(prlc) printf(f,lrc);
3104: }
3105: ll = 5; sr = 2;
3106: ll <<= sr;
3107: if(ll != 20){
3108: lrc = 312;
3109: if(prlc) printf(f,lrc);
3110: }
3111: ll = 5; ir = 2;
3112: ll <<= ir;
3113: if(ll != 20){
3114: lrc = 313;
3115: if(prlc) printf(f,lrc);
3116: }
3117: ll = 5; lr = 2;
3118: ll <<= lr;
3119: if(ll != 20){
3120: lrc = 314;
3121: if(prlc) printf(f,lrc);
3122: }
3123: ll = 5; ur = 2;
3124: ll <<= ur;
3125: if(ll != 20){
3126: lrc = 315;
3127: if(prlc) printf(f,lrc);
3128: }
3129: ul = 5; cr = 2;
3130: ul <<= cr;
3131: if(ul != 20){
3132: lrc = 316;
3133: if(prlc) printf(f,lrc);
3134: }
3135: ul = 5; sr = 2;
3136: ul <<= sr;
3137: if(ul != 20){
3138: lrc = 317;
3139: if(prlc) printf(f,lrc);
3140: }
3141: ul = 5; ir = 2;
3142: ul <<= ir;
3143: if(ul != 20){
3144: lrc = 318;
3145: if(prlc) printf(f,lrc);
3146: }
3147: ul = 5; lr = 2;
3148: ul <<= lr;
3149: if(ul != 20){
3150: lrc = 319;
3151: if(prlc) printf(f,lrc);
3152: }
3153: ul = 5; ur = 2;
3154: ul <<= ur;
3155: if(ul != 20){
3156: lrc = 320;
3157: if(prlc) printf(f,lrc);
3158: }
3159: cl = 12; cr = 10;
3160: cl &= cr;
3161: if(cl != 8){
3162: lrc = 321;
3163: if(prlc) printf(f,lrc);
3164: }
3165: cl = 12; sr = 10;
3166: cl &= sr;
3167: if(cl != 8){
3168: lrc = 322;
3169: if(prlc) printf(f,lrc);
3170: }
3171: cl = 12; ir = 10;
3172: cl &= ir;
3173: if(cl != 8){
3174: lrc = 323;
3175: if(prlc) printf(f,lrc);
3176: }
3177: cl = 12; lr = 10;
3178: cl &= lr;
3179: if(cl != 8){
3180: lrc = 324;
3181: if(prlc) printf(f,lrc);
3182: }
3183: cl = 12; ur = 10;
3184: cl &= ur;
3185: if(cl != 8){
3186: lrc = 325;
3187: if(prlc) printf(f,lrc);
3188: }
3189: sl = 12; cr = 10;
3190: sl &= cr;
3191: if(sl != 8){
3192: lrc = 326;
3193: if(prlc) printf(f,lrc);
3194: }
3195: sl = 12; sr = 10;
3196: sl &= sr;
3197: if(sl != 8){
3198: lrc = 327;
3199: if(prlc) printf(f,lrc);
3200: }
3201: sl = 12; ir = 10;
3202: sl &= ir;
3203: if(sl != 8){
3204: lrc = 328;
3205: if(prlc) printf(f,lrc);
3206: }
3207: sl = 12; lr = 10;
3208: sl &= lr;
3209: if(sl != 8){
3210: lrc = 329;
3211: if(prlc) printf(f,lrc);
3212: }
3213: sl = 12; ur = 10;
3214: sl &= ur;
3215: if(sl != 8){
3216: lrc = 330;
3217: if(prlc) printf(f,lrc);
3218: }
3219: il = 12; cr = 10;
3220: il &= cr;
3221: if(il != 8){
3222: lrc = 331;
3223: if(prlc) printf(f,lrc);
3224: }
3225: il = 12; sr = 10;
3226: il &= sr;
3227: if(il != 8){
3228: lrc = 332;
3229: if(prlc) printf(f,lrc);
3230: }
3231: il = 12; ir = 10;
3232: il &= ir;
3233: if(il != 8){
3234: lrc = 333;
3235: if(prlc) printf(f,lrc);
3236: }
3237: il = 12; lr = 10;
3238: il &= lr;
3239: if(il != 8){
3240: lrc = 334;
3241: if(prlc) printf(f,lrc);
3242: }
3243: il = 12; ur = 10;
3244: il &= ur;
3245: if(il != 8){
3246: lrc = 335;
3247: if(prlc) printf(f,lrc);
3248: }
3249: ll = 12; cr = 10;
3250: ll &= cr;
3251: if(ll != 8){
3252: lrc = 336;
3253: if(prlc) printf(f,lrc);
3254: }
3255: ll = 12; sr = 10;
3256: ll &= sr;
3257: if(ll != 8){
3258: lrc = 337;
3259: if(prlc) printf(f,lrc);
3260: }
3261: ll = 12; ir = 10;
3262: ll &= ir;
3263: if(ll != 8){
3264: lrc = 338;
3265: if(prlc) printf(f,lrc);
3266: }
3267: ll = 12; lr = 10;
3268: ll &= lr;
3269: if(ll != 8){
3270: lrc = 339;
3271: if(prlc) printf(f,lrc);
3272: }
3273: ll = 12; ur = 10;
3274: ll &= ur;
3275: if(ll != 8){
3276: lrc = 340;
3277: if(prlc) printf(f,lrc);
3278: }
3279: ul = 12; cr = 10;
3280: ul &= cr;
3281: if(ul != 8){
3282: lrc = 341;
3283: if(prlc) printf(f,lrc);
3284: }
3285: ul = 12; sr = 10;
3286: ul &= sr;
3287: if(ul != 8){
3288: lrc = 342;
3289: if(prlc) printf(f,lrc);
3290: }
3291: ul = 12; ir = 10;
3292: ul &= ir;
3293: if(ul != 8){
3294: lrc = 343;
3295: if(prlc) printf(f,lrc);
3296: }
3297: ul = 12; lr = 10;
3298: ul &= lr;
3299: if(ul != 8){
3300: lrc = 344;
3301: if(prlc) printf(f,lrc);
3302: }
3303: ul = 12; ur = 10;
3304: ul &= ur;
3305: if(ul != 8){
3306: lrc = 345;
3307: if(prlc) printf(f,lrc);
3308: }
3309: cl = 12; cr = 10;
3310: cl ^= cr;
3311: if(cl != 6){
3312: lrc = 346;
3313: if(prlc) printf(f,lrc);
3314: }
3315: cl = 12; sr = 10;
3316: cl ^= sr;
3317: if(cl != 6){
3318: lrc = 347;
3319: if(prlc) printf(f,lrc);
3320: }
3321: cl = 12; ir = 10;
3322: cl ^= ir;
3323: if(cl != 6){
3324: lrc = 348;
3325: if(prlc) printf(f,lrc);
3326: }
3327: cl = 12; lr = 10;
3328: cl ^= lr;
3329: if(cl != 6){
3330: lrc = 349;
3331: if(prlc) printf(f,lrc);
3332: }
3333: cl = 12; ur = 10;
3334: cl ^= ur;
3335: if(cl != 6){
3336: lrc = 350;
3337: if(prlc) printf(f,lrc);
3338: }
3339: sl = 12; cr = 10;
3340: sl ^= cr;
3341: if(sl != 6){
3342: lrc = 351;
3343: if(prlc) printf(f,lrc);
3344: }
3345: sl = 12; sr = 10;
3346: sl ^= sr;
3347: if(sl != 6){
3348: lrc = 352;
3349: if(prlc) printf(f,lrc);
3350: }
3351: sl = 12; ir = 10;
3352: sl ^= ir;
3353: if(sl != 6){
3354: lrc = 353;
3355: if(prlc) printf(f,lrc);
3356: }
3357: sl = 12; lr = 10;
3358: sl ^= lr;
3359: if(sl != 6){
3360: lrc = 354;
3361: if(prlc) printf(f,lrc);
3362: }
3363: sl = 12; ur = 10;
3364: sl ^= ur;
3365: if(sl != 6){
3366: lrc = 355;
3367: if(prlc) printf(f,lrc);
3368: }
3369: il = 12; cr = 10;
3370: il ^= cr;
3371: if(il != 6){
3372: lrc = 356;
3373: if(prlc) printf(f,lrc);
3374: }
3375: il = 12; sr = 10;
3376: il ^= sr;
3377: if(il != 6){
3378: lrc = 357;
3379: if(prlc) printf(f,lrc);
3380: }
3381: il = 12; ir = 10;
3382: il ^= ir;
3383: if(il != 6){
3384: lrc = 358;
3385: if(prlc) printf(f,lrc);
3386: }
3387: il = 12; lr = 10;
3388: il ^= lr;
3389: if(il != 6){
3390: lrc = 359;
3391: if(prlc) printf(f,lrc);
3392: }
3393: il = 12; ur = 10;
3394: il ^= ur;
3395: if(il != 6){
3396: lrc = 360;
3397: if(prlc) printf(f,lrc);
3398: }
3399: ll = 12; cr = 10;
3400: ll ^= cr;
3401: if(ll != 6){
3402: lrc = 361;
3403: if(prlc) printf(f,lrc);
3404: }
3405: ll = 12; sr = 10;
3406: ll ^= sr;
3407: if(ll != 6){
3408: lrc = 362;
3409: if(prlc) printf(f,lrc);
3410: }
3411: ll = 12; ir = 10;
3412: ll ^= ir;
3413: if(ll != 6){
3414: lrc = 363;
3415: if(prlc) printf(f,lrc);
3416: }
3417: ll = 12; lr = 10;
3418: ll ^= lr;
3419: if(ll != 6){
3420: lrc = 364;
3421: if(prlc) printf(f,lrc);
3422: }
3423: ll = 12; ur = 10;
3424: ll ^= ur;
3425: if(ll != 6){
3426: lrc = 365;
3427: if(prlc) printf(f,lrc);
3428: }
3429: ul = 12; cr = 10;
3430: ul ^= cr;
3431: if(ul != 6){
3432: lrc = 366;
3433: if(prlc) printf(f,lrc);
3434: }
3435: ul = 12; sr = 10;
3436: ul ^= sr;
3437: if(ul != 6){
3438: lrc = 367;
3439: if(prlc) printf(f,lrc);
3440: }
3441: ul = 12; ir = 10;
3442: ul ^= ir;
3443: if(ul != 6){
3444: lrc = 368;
3445: if(prlc) printf(f,lrc);
3446: }
3447: ul = 12; lr = 10;
3448: ul ^= lr;
3449: if(ul != 6){
3450: lrc = 369;
3451: if(prlc) printf(f,lrc);
3452: }
3453: ul = 12; ur = 10;
3454: ul ^= ur;
3455: if(ul != 6){
3456: lrc = 370;
3457: if(prlc) printf(f,lrc);
3458: }
3459: cl = 12; cr = 10;
3460: cl |= cr;
3461: if(cl != 14){
3462: lrc = 371;
3463: if(prlc) printf(f,lrc);
3464: }
3465: cl = 12; sr = 10;
3466: cl |= sr;
3467: if(cl != 14){
3468: lrc = 372;
3469: if(prlc) printf(f,lrc);
3470: }
3471: cl = 12; ir = 10;
3472: cl |= ir;
3473: if(cl != 14){
3474: lrc = 373;
3475: if(prlc) printf(f,lrc);
3476: }
3477: cl = 12; lr = 10;
3478: cl |= lr;
3479: if(cl != 14){
3480: lrc = 374;
3481: if(prlc) printf(f,lrc);
3482: }
3483: cl = 12; ur = 10;
3484: cl |= ur;
3485: if(cl != 14){
3486: lrc = 375;
3487: if(prlc) printf(f,lrc);
3488: }
3489: sl = 12; cr = 10;
3490: sl |= cr;
3491: if(sl != 14){
3492: lrc = 376;
3493: if(prlc) printf(f,lrc);
3494: }
3495: sl = 12; sr = 10;
3496: sl |= sr;
3497: if(sl != 14){
3498: lrc = 377;
3499: if(prlc) printf(f,lrc);
3500: }
3501: sl = 12; ir = 10;
3502: sl |= ir;
3503: if(sl != 14){
3504: lrc = 378;
3505: if(prlc) printf(f,lrc);
3506: }
3507: sl = 12; lr = 10;
3508: sl |= lr;
3509: if(sl != 14){
3510: lrc = 379;
3511: if(prlc) printf(f,lrc);
3512: }
3513: sl = 12; ur = 10;
3514: sl |= ur;
3515: if(sl != 14){
3516: lrc = 380;
3517: if(prlc) printf(f,lrc);
3518: }
3519: il = 12; cr = 10;
3520: il |= cr;
3521: if(il != 14){
3522: lrc = 381;
3523: if(prlc) printf(f,lrc);
3524: }
3525: il = 12; sr = 10;
3526: il |= sr;
3527: if(il != 14){
3528: lrc = 382;
3529: if(prlc) printf(f,lrc);
3530: }
3531: il = 12; ir = 10;
3532: il |= ir;
3533: if(il != 14){
3534: lrc = 383;
3535: if(prlc) printf(f,lrc);
3536: }
3537: il = 12; lr = 10;
3538: il |= lr;
3539: if(il != 14){
3540: lrc = 384;
3541: if(prlc) printf(f,lrc);
3542: }
3543: il = 12; ur = 10;
3544: il |= ur;
3545: if(il != 14){
3546: lrc = 385;
3547: if(prlc) printf(f,lrc);
3548: }
3549: ll = 12; cr = 10;
3550: ll |= cr;
3551: if(ll != 14){
3552: lrc = 386;
3553: if(prlc) printf(f,lrc);
3554: }
3555: ll = 12; sr = 10;
3556: ll |= sr;
3557: if(ll != 14){
3558: lrc = 387;
3559: if(prlc) printf(f,lrc);
3560: }
3561: ll = 12; ir = 10;
3562: ll |= ir;
3563: if(ll != 14){
3564: lrc = 388;
3565: if(prlc) printf(f,lrc);
3566: }
3567: ll = 12; lr = 10;
3568: ll |= lr;
3569: if(ll != 14){
3570: lrc = 389;
3571: if(prlc) printf(f,lrc);
3572: }
3573: ll = 12; ur = 10;
3574: ll |= ur;
3575: if(ll != 14){
3576: lrc = 390;
3577: if(prlc) printf(f,lrc);
3578: }
3579: ul = 12; cr = 10;
3580: ul |= cr;
3581: if(ul != 14){
3582: lrc = 391;
3583: if(prlc) printf(f,lrc);
3584: }
3585: ul = 12; sr = 10;
3586: ul |= sr;
3587: if(ul != 14){
3588: lrc = 392;
3589: if(prlc) printf(f,lrc);
3590: }
3591: ul = 12; ir = 10;
3592: ul |= ir;
3593: if(ul != 14){
3594: lrc = 393;
3595: if(prlc) printf(f,lrc);
3596: }
3597: ul = 12; lr = 10;
3598: ul |= lr;
3599: if(ul != 14){
3600: lrc = 394;
3601: if(prlc) printf(f,lrc);
3602: }
3603: ul = 12; ur = 10;
3604: ul |= ur;
3605: if(ul != 14){
3606: lrc = 395;
3607: if(prlc) printf(f,lrc);
3608: }
3609: if(lrc != 0) {
3610: rc = 1;
3611: if(pd0->flgd != 0) printf(s714er,1);
3612: }
3613: return rc;
3614: }
3615: s715(pd0) /* 7.15 Comma operator */
3616: struct defs *pd0;
3617: {
3618: static char s715er[] = "s715,er%d\n";
3619: static char qs715[8] = "s715 ";
3620: int rc;
3621: char *ps, *pt;
3622: int a, t, c, i;
3623: a = c = 0;
3624: ps = qs715;
3625: pt = pd0->rfs;
3626: rc = 0;
3627: while (*pt++ = *ps++);
3628:
3629: /* A pair of expressions separated by a comma is
3630: evaluated left to right and the value of the left
3631: expression is discarded.
3632: */
3633: i = 1;
3634: if( i++,i++,i++,i++,++i != 6 ){
3635: if(pd0->flgd != 0) printf(s715er,1);
3636: rc = rc+1;
3637: }
3638:
3639: /* In contexts where the comma is given a special mean-
3640: ing, for example in a list of actual arguments to
3641: functions (sic) and lists of initializers, the comma
3642: operator as described in this section can only appear
3643: in parentheses; for example
3644:
3645: f( a, (t=3, t+2), c)
3646:
3647: has three arguments, the second of which has the
3648: value 5.
3649: */
3650:
3651: if(s715f(a, (t=3, t+2), c) != 5){
3652: if(pd0->flgd != 0) printf(s715er,2);
3653: rc = rc+2;
3654: }
3655: return rc;
3656: }
3657: s715f(x,y,z)
3658: int x, y, z;
3659: {
3660: return y;
3661: }
3662: s72(pd0) /* 7.2 Unary operators */
3663: struct defs *pd0;
3664: {
3665: static char s72er[] = "s72,er%d\n";
3666: static char qs72[8] = "s72 ";
3667: int rc;
3668: char *ps, *pt;
3669: int k, j, i, lrc;
3670: char c;
3671: short s;
3672: long l;
3673: unsigned u;
3674: double d;
3675: float f;
3676: ps = qs72;
3677: pt = pd0->rfs;
3678: rc = 0;
3679: while (*pt++ = *ps++);
3680:
3681: /* The *, denoting indirection, and the &, denoting a
3682: pointer, are duals of each other, and ought to behave as
3683: such... */
3684:
3685: k = 2;
3686: if(*&*&k != 2){
3687: rc = rc+1;
3688: printf(s72er,1);
3689: }
3690:
3691: /* The unary minus has the conventional meaning. */
3692:
3693: if(k+(-k) != 0){
3694: rc = rc+2;
3695: printf(s72er,2);
3696: }
3697:
3698: /* The negation operator (!) has been thoroughly checked out,
3699: perhaps more thoroughly than any of the others. The ~ oper-
3700: ator gets us a ones complement. */
3701:
3702: k = 0;
3703: for(j=0;j<pd0->ibits;j++) k = (k<<1)|1;
3704: if(~k != 0){
3705: rc = rc+4;
3706: printf(s72er,4);
3707: }
3708:
3709: /* Now we look at the ++ and -- operators, which can be
3710: used in either prefix or suffix form. With side
3711: effects they're loaded. */
3712:
3713: k = 5;
3714:
3715: if( ++k != 6 || --k != 5
3716: || k++ != 5 || k-- != 6
3717: || k != 5 ){
3718: rc = rc+8;
3719: printf(s72er,8);
3720: }
3721:
3722: /* An expression preceded by the parenthesised name of a
3723: data type causes conversion of the value of the expression
3724: to the named type. This construction is called a cast.
3725: Here, we check to see that all of the possible casts and
3726: their simple combinations are accepted by the compiler,
3727: and that they all produce a correct result for this sample
3728: of size one. */
3729:
3730: c = 26; l = 26; d = 26.;
3731: s = 26; u = 26;
3732: i = 26; f = 26.;
3733:
3734: lrc = 0;
3735:
3736: if( (char)s != 26 || (char)i != 26
3737: || (char)l != 26 || (char)u != 26
3738: || (char)f != 26 || (char)d != 26 ) lrc = lrc+1;
3739:
3740: if( (short)c != 26 || (short)i != 26
3741: || (short)l != 26 || (short)u != 26
3742: || (short)f != 26 || (short)d != 26) lrc = lrc+2;
3743:
3744: if( (int)c != 26 || (int)s != 26
3745: || (int)l != 26 || (int)u != 26
3746: || (int)f != 26 || (int)d != 26 ) lrc = lrc+4;
3747:
3748: if( (long)c != 26 || (long)s != 26
3749: || (long)i != 26 || (long)u != 26
3750: || (long)f != 26 || (long)d != 26 ) lrc = lrc+8;
3751:
3752: if( (unsigned)c != 26 || (unsigned)s != 26
3753: || (unsigned)i != 26 || (unsigned)l != 26
3754: || (unsigned)f != 26 || (unsigned)d != 26 ) lrc = lrc+16;
3755:
3756: if( (float)c != 26. || (float)s != 26.
3757: || (float)i != 26. || (float)l != 26.
3758: || (float)u != 26. || (float)d != 26. ) lrc = lrc+32;
3759:
3760: if( (double)c != 26. || (double)s != 26.
3761: || (double)i != 26. || (double)l != 26.
3762: || (double)u != 26. || (double)f != 26. ) lrc = lrc+64;
3763:
3764: if(lrc != 0){
3765: rc = rc+16;
3766: printf(s72er,16);
3767: }
3768:
3769: /* The sizeof operator has been tested previously. */
3770:
3771: return rc;
3772: }
3773: s757(pd0) /* 7.5 Shift operators */
3774: /* 7.6 Relational operators */
3775: /* 7.7 Equality operator */
3776: struct defs *pd0;
3777: {
3778: static char s757er[] = "s757,er%d\n";
3779: static char qs757[8] = "s757 ";
3780: int rc;
3781: char *ps, *pt;
3782: int t,lrc,k,j,a,b,c,d,x[16],*p;
3783: unsigned rs, ls, rt, lt;
3784: ps = qs757;
3785: pt = pd0->rfs;
3786: rc = 0;
3787: while (*pt++ = *ps++);
3788:
3789: /* The shift operators << and >> group left-to-right.
3790: */
3791:
3792: t = 40;
3793: if(t<<3<<2 != 1280 || t>>3>>2 != 1){
3794: rc = rc+1;
3795: if(pd0->flgd != 0) printf(s757er,1);
3796: }
3797:
3798: /* In the following test, an n-bit unsigned consisting
3799: of all 1s is shifted right (resp. left) k bits, 0<=k<n.
3800: We expect to find k 0s followed by n-k 1s (resp. n-k 1s
3801: followed by k 0s). If not, we complain.
3802: */
3803:
3804: lrc = 0;
3805: for(k=0; k<pd0->ubits; k++){
3806: rs = 1;
3807: ls = rs<<(pd0->ubits-1);
3808:
3809: rt = 0;
3810: lt = ~rt>>k;
3811: rt = ~rt<<k;
3812:
3813: for(j=0; j<pd0->ubits;j++){
3814: if((j<k) != ((rs&rt) == 0) || (j<k) != ((ls<) == 0)) lrc = 1;
3815: rs = rs<<1;
3816: ls = ls>>1;
3817: }
3818: }
3819:
3820: if(lrc != 0){
3821: rc = rc+2;
3822: if(pd0->flgd != 0) printf(s757er,2);
3823: }
3824:
3825: /* The relational operators group left-to-right, but this
3826: fact is not very useful; a<b<c does not mean what it
3827: seems to...
3828: */
3829:
3830: a = 3;
3831: b = 2;
3832: c = 1;
3833:
3834: if((a<b<c) != 1){
3835: rc = rc+4;
3836: if(pd0->flgd != 0) printf(s757er,4);
3837: }
3838:
3839: /* In general, we take note of the fact that if we got this
3840: far the relational operators have to be working. We test only
3841: that two pointers may be compared; the result depends on
3842: the relative locations in the address space of the
3843: pointed-to objects.
3844: */
3845: if( &x[1] == &x[0] ){
3846: rc = rc+8;
3847: if(pd0->flgd != 0) printf(s757er,8);
3848: }
3849:
3850: if( &x[1] < &x[0] ) if(pd0->flgm != 0)
3851: printf("Increasing array elements assigned to decreasing locations\n");
3852:
3853: /* a<b == c<d whenever a<b and c<d have the same
3854: truth value. */
3855:
3856: lrc = 0;
3857:
3858: for(j=0;j<16;j++) x[j] = 1;
3859: x[1] = 0;
3860: x[4] = 0;
3861: x[6] = 0;
3862: x[7] = 0;
3863: x[9] = 0;
3864: x[13] = 0;
3865:
3866: for(a=0;a<2;a++)
3867: for(b=0;b<2;b++)
3868: for(c=0;c<2;c++)
3869: for(d=0;d<2;d++)
3870: if((a<b==c<d) != x[8*a+4*b+2*c+d] ) lrc = 1;
3871:
3872: if(lrc != 0){
3873: rc = rc+16;
3874: if(pd0->flgd != 0) printf(s757er,16);
3875: }
3876:
3877: /* A pointer to which zero has been assigned will
3878: appear to be equal to zero.
3879: */
3880:
3881: p = 0;
3882:
3883: if(p != 0){
3884: rc = rc+32;
3885: if(pd0->flgd != 0) printf(s757er,32);
3886: }
3887:
3888: return rc;
3889: }
3890: s7813(pd0) /* 7.8 Bitwise AND operator
3891: 7.9 Bitwise OR operator
3892: 7.10 Bitwise exclusive OR operator
3893: 7.11 Logical AND operator
3894: 7.12 Logical OR operator
3895: 7.13 Conditional operator */
3896: struct defs *pd0;
3897: {
3898: register int prlc, lrc;
3899: int i, j, r, zero, one;
3900: static char fl[] = "Local error %d.\n";
3901: static char s7813er[] = "s7813,er%d\n";
3902: static char qs7813[8] = "s7813 ";
3903: int rc;
3904: char *ps, *pt;
3905: ps = qs7813;
3906: pt = pd0->rfs;
3907: lrc = 0;
3908: rc = 0;
3909: prlc = pd0->flgl;
3910: while (*pt++ = *ps++);
3911:
3912: /* If bitwise AND, OR, and exclusive OR are to cause
3913: trouble, they will probably do so when they are used in
3914: an unusual context. The number of contexts in which
3915: they can be used is infinite, so to save time we select
3916: a finite subset: the set of all expressions of the form:
3917:
3918: item1 op item2
3919:
3920: where item1 and item2 are chosen from the set
3921: {char,short,long,unsigned,int} and op is one of {&,|,^}.
3922: We will use 12 and 10 as values for the items, as these
3923: values will fit into all data types on just about any
3924: imaginable machine, and the results after performing the
3925: bitwise operations on them are distinct for each operation,
3926: i.e.,
3927:
3928: 12 | 10 -> 1100 | 1010 -> 1110 -> 14
3929: 12 ^ 10 -> 1100 ^ 1010 -> 0110 -> 6
3930: 12 & 10 -> 1100 & 1010 -> 1000 -> 8
3931:
3932: There are 75 such combinations:
3933: */
3934:
3935: if(((char)12 & (char)10) != 8) {lrc = 1;
3936: if(prlc) printf(fl,lrc);}
3937: if(((char)12 | (char)10) != 14) {lrc = 2;
3938: if(prlc) printf(fl,lrc);}
3939: if(((char)12 ^ (char)10) != 6) {lrc = 3;
3940: if(prlc) printf(fl,lrc);}
3941: if(((char)12 & (short)10) != 8) {lrc = 4;
3942: if(prlc) printf(fl,lrc);}
3943: if(((char)12 | (short)10) != 14) {lrc = 5;
3944: if(prlc) printf(fl,lrc);}
3945: if(((char)12 ^ (short)10) != 6) {lrc = 6;
3946: if(prlc) printf(fl,lrc);}
3947: if(((char)12 & (long)10) != 8) {lrc = 7;
3948: if(prlc) printf(fl,lrc);}
3949: if(((char)12 | (long)10) != 14) {lrc = 8;
3950: if(prlc) printf(fl,lrc);}
3951: if(((char)12 ^ (long)10) != 6) {lrc = 9;
3952: if(prlc) printf(fl,lrc);}
3953: if(((char)12 & (unsigned)10) != 8) {lrc = 10;
3954: if(prlc) printf(fl,lrc);}
3955: if(((char)12 | (unsigned)10) != 14) {lrc = 11;
3956: if(prlc) printf(fl,lrc);}
3957: if(((char)12 ^ (unsigned)10) != 6) {lrc = 12;
3958: if(prlc) printf(fl,lrc);}
3959: if(((char)12 & (int)10) != 8) {lrc = 13;
3960: if(prlc) printf(fl,lrc);}
3961: if(((char)12 | (int)10) != 14) {lrc = 14;
3962: if(prlc) printf(fl,lrc);}
3963: if(((char)12 ^ (int)10) != 6) {lrc = 15;
3964: if(prlc) printf(fl,lrc);}
3965: if(((short)12 & (char)10) != 8) {lrc = 16;
3966: if(prlc) printf(fl,lrc);}
3967: if(((short)12 | (char)10) != 14) {lrc = 17;
3968: if(prlc) printf(fl,lrc);}
3969: if(((short)12 ^ (char)10) != 6) {lrc = 18;
3970: if(prlc) printf(fl,lrc);}
3971: if(((short)12 & (short)10) != 8) {lrc = 16;
3972: if(prlc) printf(fl,lrc);}
3973: if(((short)12 | (short)10) != 14) {lrc = 20;
3974: if(prlc) printf(fl,lrc);}
3975: if(((short)12 ^ (short)10) != 6) {lrc = 21;
3976: if(prlc) printf(fl,lrc);}
3977: if(((short)12 & (long)10) != 8) {lrc = 22;
3978: if(prlc) printf(fl,lrc);}
3979: if(((short)12 | (long)10) != 14) {lrc = 23;
3980: if(prlc) printf(fl,lrc);}
3981: if(((short)12 ^ (long)10) != 6) {lrc = 24;
3982: if(prlc) printf(fl,lrc);}
3983: if(((short)12 & (unsigned)10) != 8) {lrc = 25;
3984: if(prlc) printf(fl,lrc);}
3985: if(((short)12 | (unsigned)10) != 14) {lrc = 26;
3986: if(prlc) printf(fl,lrc);}
3987: if(((short)12 ^ (unsigned)10) != 6) {lrc = 27;
3988: if(prlc) printf(fl,lrc);}
3989: if(((short)12 & (int)10) != 8) {lrc = 28;
3990: if(prlc) printf(fl,lrc);}
3991: if(((short)12 | (int)10) != 14) {lrc = 26;
3992: if(prlc) printf(fl,lrc);}
3993: if(((short)12 ^ (int)10) != 6) {lrc = 30;
3994: if(prlc) printf(fl,lrc);}
3995: if(((long)12 & (char)10) != 8) {lrc = 31;
3996: if(prlc) printf(fl,lrc);}
3997: if(((long)12 | (char)10) != 14) {lrc = 32;
3998: if(prlc) printf(fl,lrc);}
3999: if(((long)12 ^ (char)10) != 6) {lrc = 33;
4000: if(prlc) printf(fl,lrc);}
4001: if(((long)12 & (short)10) != 8) {lrc = 34;
4002: if(prlc) printf(fl,lrc);}
4003: if(((long)12 | (short)10) != 14) {lrc = 35;
4004: if(prlc) printf(fl,lrc);}
4005: if(((long)12 ^ (short)10) != 6) {lrc = 36;
4006: if(prlc) printf(fl,lrc);}
4007: if(((long)12 & (long)10) != 8) {lrc = 37;
4008: if(prlc) printf(fl,lrc);}
4009: if(((long)12 | (long)10) != 14) {lrc = 38;
4010: if(prlc) printf(fl,lrc);}
4011: if(((long)12 ^ (long)10) != 6) {lrc = 39;
4012: if(prlc) printf(fl,lrc);}
4013: if(((long)12 & (unsigned)10) != 8) {lrc = 40;
4014: if(prlc) printf(fl,lrc);}
4015: if(((long)12 | (unsigned)10) != 14) {lrc = 41;
4016: if(prlc) printf(fl,lrc);}
4017: if(((long)12 ^ (unsigned)10) != 6) {lrc = 42;
4018: if(prlc) printf(fl,lrc);}
4019: if(((long)12 & (int)10) != 8) {lrc = 43;
4020: if(prlc) printf(fl,lrc);}
4021: if(((long)12 | (int)10) != 14) {lrc = 44;
4022: if(prlc) printf(fl,lrc);}
4023: if(((long)12 ^ (int)10) != 6) {lrc = 45;
4024: if(prlc) printf(fl,lrc);}
4025: if(((unsigned)12 & (char)10) != 8) {lrc = 46;
4026: if(prlc) printf(fl,lrc);}
4027: if(((unsigned)12 | (char)10) != 14) {lrc = 47;
4028: if(prlc) printf(fl,lrc);}
4029: if(((unsigned)12 ^ (char)10) != 6) {lrc = 48;
4030: if(prlc) printf(fl,lrc);}
4031: if(((unsigned)12 & (short)10) != 8) {lrc = 49;
4032: if(prlc) printf(fl,lrc);}
4033: if(((unsigned)12 | (short)10) != 14) {lrc = 50;
4034: if(prlc) printf(fl,lrc);}
4035: if(((unsigned)12 ^ (short)10) != 6) {lrc = 51;
4036: if(prlc) printf(fl,lrc);}
4037: if(((unsigned)12 & (long)10) != 8) {lrc = 52;
4038: if(prlc) printf(fl,lrc);}
4039: if(((unsigned)12 | (long)10) != 14) {lrc = 53;
4040: if(prlc) printf(fl,lrc);}
4041: if(((unsigned)12 ^ (long)10) != 6) {lrc = 54;
4042: if(prlc) printf(fl,lrc);}
4043: if(((unsigned)12 & (unsigned)10) != 8) {lrc = 55;
4044: if(prlc) printf(fl,lrc);}
4045: if(((unsigned)12 | (unsigned)10) != 14) {lrc = 56;
4046: if(prlc) printf(fl,lrc);}
4047: if(((unsigned)12 ^ (unsigned)10) != 6) {lrc = 57;
4048: if(prlc) printf(fl,lrc);}
4049: if(((unsigned)12 & (int)10) != 8) {lrc = 58;
4050: if(prlc) printf(fl,lrc);}
4051: if(((unsigned)12 | (int)10) != 14) {lrc = 56;
4052: if(prlc) printf(fl,lrc);}
4053: if(((unsigned)12 ^ (int)10) != 6) {lrc = 60;
4054: if(prlc) printf(fl,lrc);}
4055: if(((int)12 & (char)10) != 8) {lrc = 61;
4056: if(prlc) printf(fl,lrc);}
4057: if(((int)12 | (char)10) != 14) {lrc = 62;
4058: if(prlc) printf(fl,lrc);}
4059: if(((int)12 ^ (char)10) != 6) {lrc = 63;
4060: if(prlc) printf(fl,lrc);}
4061: if(((int)12 & (short)10) != 8) {lrc = 64;
4062: if(prlc) printf(fl,lrc);}
4063: if(((int)12 | (short)10) != 14) {lrc = 65;
4064: if(prlc) printf(fl,lrc);}
4065: if(((int)12 ^ (short)10) != 6) {lrc = 66;
4066: if(prlc) printf(fl,lrc);}
4067: if(((int)12 & (long)10) != 8) {lrc = 67;
4068: if(prlc) printf(fl,lrc);}
4069: if(((int)12 | (long)10) != 14) {lrc = 68;
4070: if(prlc) printf(fl,lrc);}
4071: if(((int)12 ^ (long)10) != 6) {lrc = 69;
4072: if(prlc) printf(fl,lrc);}
4073: if(((int)12 & (unsigned)10) != 8) {lrc = 70;
4074: if(prlc) printf(fl,lrc);}
4075: if(((int)12 | (unsigned)10) != 14) {lrc = 71;
4076: if(prlc) printf(fl,lrc);}
4077: if(((int)12 ^ (unsigned)10) != 6) {lrc = 72;
4078: if(prlc) printf(fl,lrc);}
4079: if(((int)12 & (int)10) != 8) {lrc = 73; if(prlc) printf(fl,lrc);}
4080: if(((int)12 | (int)10) != 14) {lrc = 74; if(prlc) printf(fl,lrc);}
4081: if(((int)12 ^ (int)10) != 6) {lrc = 75; if(prlc) printf(fl,lrc);}
4082:
4083: if(lrc != 0){
4084: if(pd0->flgd != 0) printf(s7813er,1);
4085: rc = rc+1;
4086: }
4087:
4088: /* The && operator groups left to right. It returns 1
4089: if both of the operands are nonzero; 0 otherwise.
4090: It guarantees left to right evaluation; moreover, the
4091: second operand is not evaluated if the value of the
4092: first operand is 0.
4093: */
4094:
4095: lrc = 0;
4096: i = j = 0;
4097:
4098: r = i++ && j++;
4099: if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);}
4100: if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);}
4101: if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);}
4102: r = i && j++;
4103: if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);}
4104: if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);}
4105: if(r!=0) {lrc = 6; if(prlc) printf(fl,lrc);}
4106: r = i-- && j;
4107: if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);}
4108: if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);}
4109: if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);}
4110: r = i && j--;
4111: if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);}
4112: if(j!=1) {lrc = 11; if(prlc) printf(fl,lrc);}
4113: if(r!=0) {lrc = 12; if(prlc) printf(fl,lrc);}
4114:
4115: if(lrc!=0){
4116: if(pd0->flgd != 0) printf(s7813er,2);
4117: rc = rc+2;
4118: }
4119:
4120: /* The || operator groups left to right. It returns 1
4121: if either of its operands is nonzero; 0 otherwise. It
4122: guarantees left to right evaluation; moreover, the second
4123: operand is not evaluated if the value of the first
4124: operand is nonzero.
4125: */
4126:
4127: lrc = 0;
4128: i = j = 0;
4129: r = i++ || j;
4130: if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);}
4131: if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);}
4132: if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);}
4133: r = j++ || i;
4134: if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);}
4135: if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);}
4136: if(r!=1) {lrc = 6; if(prlc) printf(fl,lrc);}
4137: r = i-- || j--;
4138: if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);}
4139: if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);}
4140: if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);}
4141: r = i || j--;
4142: if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);}
4143: if(j!=0) {lrc = 11; if(prlc) printf(fl,lrc);}
4144: if(r!=1) {lrc = 12; if(prlc) printf(fl,lrc);}
4145:
4146: if(lrc!=0){
4147: if(pd0->flgd != 0) printf(s7813er,4);
4148: rc = rc+4;
4149: }
4150:
4151: /* Conditional expressions group right to left. */
4152:
4153: i = j = 0;
4154: zero = 0;
4155: one = 1;
4156: r = one?zero:one?i++:j++;
4157: if(r!=0 || i!=0 || j!=0){
4158: if(pd0->flgd != 0) printf(s7813er,8);
4159: rc = rc+8;
4160: }
4161:
4162: /* The first expression is evaluated and if it is non-
4163: zero, the result is the value of the second expression;
4164: otherwise, that of the third expression.
4165: */
4166:
4167: if((one?zero:1) != 0 || (zero?1:zero) != 0){
4168: if(pd0->flgd != 0) printf(s7813er,16);
4169: rc = rc+16;
4170: }
4171: return rc;
4172: }
4173: s81(pd0) /* 8.1 Storage Class Specifiers */
4174: struct defs *pd0;
4175: {
4176: static char s81er[] = "s81,er%d\n";
4177: static char qs81[8] = "s81 ";
4178: char *ps, *pt;
4179: int k, rc, j, crc, prc, irc;
4180: register char rchar;
4181: char nrchar;
4182: register int *rptr;
4183: int *nrptr;
4184: register int rint;
4185: int nrint;
4186: static char badtest[] = "Register count for %s is unreliable.\n";
4187: static char goodtest[] = "%d registers assigned to %s variables.\n";
4188:
4189: rc = 0;
4190: crc = 0;
4191: prc = 0;
4192: irc = 0;
4193: ps = qs81;
4194: pt = pd0->rfs;
4195:
4196: while(*pt++ = *ps++);
4197:
4198: /* The storage class specifiers are:
4199:
4200: auto
4201: static
4202: extern
4203: register
4204: typedef
4205:
4206: The first three of these were treated earlier, in s4. The last
4207: will be checked in s88. "Register" remains.
4208:
4209: There are three flavors of register, viz., char, int and pointer.
4210: We wish first to ascertain that the representations as register
4211: are consistent with the corresponding nonregister representations.
4212: */
4213:
4214: k = 1;
4215: for (j=0; j<50; j++){
4216: rchar = k;
4217: nrchar = k;
4218: rptr = &k;
4219: nrptr = &k;
4220: rint = k;
4221: nrint = k;
4222:
4223: if ( rchar != nrchar ) crc = 1;
4224: if ( rptr != nrptr ) prc = 1;
4225: if ( rint != nrint ) irc = 1;
4226: k = k<<1;
4227: }
4228:
4229: if ( crc != 0 ) {
4230: rc = rc+1;
4231: if( pd0 -> flgd != 0 ) printf(s81er,1);
4232: }
4233:
4234: if ( prc != 0 ) {
4235: rc = rc+2;
4236: if( pd0 -> flgd != 0 ) printf(s81er,2);
4237: }
4238:
4239: if ( irc != 0 ) {
4240: rc = rc+4;
4241: if( pd0 -> flgd != 0 ) printf(s81er,4);
4242: }
4243:
4244: /* Now we check to see if variables are actually being assigned
4245: to registers. */
4246:
4247: k = regc();
4248: if ( pd0->flgm != 0 ) {
4249: if ( k < 0 ) printf(badtest,"char");
4250: else printf(goodtest,k,"char");
4251: }
4252:
4253: k = regp();
4254: if ( pd0->flgm != 0 ) {
4255: if ( k<0 ) printf(badtest,"pointer");
4256: else printf(goodtest,k,"pointer");
4257: }
4258:
4259: k = regi();
4260: if ( pd0->flgm != 0 ) {
4261: if ( k<0 ) printf(badtest,"int");
4262: else printf(goodtest,k,"int");
4263: }
4264:
4265: return rc;
4266: }
4267: regc() { /* char to register assignment */
4268: /* Testing a variable whose storage class has been spec-
4269: ified as "register" is somewhat tricky, but it can be done in a
4270: fairly reliable fashion by taking advantage of our knowledge of the
4271: ways in which compilers operate. If we declare a collection of vari-
4272: ables of the same storage class, we would expect that, when storage
4273: for these variables is actually allocated, the variables will be
4274: bunched together and ordered according to one of the following
4275: criteria:
4276:
4277: (a) the order in which they were defined.
4278: (b) the order in which they are used.
4279: (c) alphabetically.
4280: (d) the order in which they appear in the compiler's
4281: symbol table.
4282: (e) some other way.
4283:
4284: Hence, if we define a sequence of variables in close alpha-
4285: betical order, and use them in the same order in which we define
4286: them, we would expect the differences between the addresses of
4287: successive variables to be constant, except in case (d) where the
4288: symbol table is a hash table, or in case (e). If a subsequence in
4289: the middle of this sequence is selected, and for this subsequence,
4290: every other variable is specified to be "register", and address
4291: differences are taken between adjacent nonregister variables, we would
4292: still expect to find constant differences if the "register" vari-
4293: ables were actually assigned to registers, and some other diff-
4294: erences if they were not. Specifically, if we had N variables
4295: specified as "register" of which the first n were actually ass-
4296: igned to registers, we would expect the sequence of differences
4297: to consist of a number of occurrences of some number, followed by
4298: N-n occurrences of some other number, followed by several occurr-
4299: ences of the first number. If we get a sequence like this, we can
4300: determine, by simple subtraction, how many (if any) variables are
4301: being assigned to registers. If we get some other sequence, we know
4302: that the test is invalid. */
4303:
4304: char r00;
4305: char r01;
4306: char r02;
4307: char r03;
4308: register char r04;
4309: char r05;
4310: register char r06;
4311: char r07;
4312: register char r08;
4313: char r09;
4314: register char r10;
4315: char r11;
4316: register char r12;
4317: char r13;
4318: register char r14;
4319: char r15;
4320: register char r16;
4321: char r17;
4322: register char r18;
4323: char r19;
4324: register char r20;
4325: char r21;
4326: register char r22;
4327: char r23;
4328: register char r24;
4329: char r25;
4330: register char r26;
4331: char r27;
4332: register char r28;
4333: char r29;
4334: register char r30;
4335: char r31;
4336: register char r32;
4337: char r33;
4338: register char r34;
4339: char r35;
4340: char r36;
4341: char r37;
4342: char r38;
4343:
4344: int s, n1, n2, nr, j, d[22];
4345: r00 = 0;
4346: r01 = 1;
4347: r02 = 2;
4348: r03 = 3;
4349: r04 = 4;
4350: r05 = 5;
4351: r06 = 6;
4352: r07 = 7;
4353: r08 = 8;
4354: r09 = 9;
4355: r10 = 10;
4356: r11 = 11;
4357: r12 = 12;
4358: r13 = 13;
4359: r14 = 14;
4360: r15 = 15;
4361: r16 = 16;
4362: r17 = 17;
4363: r18 = 18;
4364: r19 = 19;
4365: r20 = 20;
4366: r21 = 21;
4367: r22 = 22;
4368: r23 = 23;
4369: r24 = 24;
4370: r25 = 25;
4371: r26 = 26;
4372: r27 = 27;
4373: r28 = 28;
4374: r29 = 29;
4375: r30 = 30;
4376: r31 = 31;
4377: r32 = 32;
4378: r33 = 33;
4379: r34 = 34;
4380: r35 = 35;
4381: r36 = 36;
4382: r37 = 37;
4383: r38 = 38;
4384:
4385: d[0] = &r01 - &r00;
4386: d[1] = &r02 - &r01;
4387: d[2] = &r03 - &r02;
4388: d[3] = &r05 - &r03;
4389: d[4] = &r07 - &r05;
4390: d[5] = &r09 - &r07;
4391: d[6] = &r11 - &r09;
4392: d[7] = &r13 - &r11;
4393: d[8] = &r15 - &r13;
4394: d[9] = &r17 - &r15;
4395: d[10] = &r19 - &r17;
4396: d[11] = &r21 - &r19;
4397: d[12] = &r23 - &r21;
4398: d[13] = &r25 - &r23;
4399: d[14] = &r27 - &r25;
4400: d[15] = &r29 - &r27;
4401: d[16] = &r31 - &r29;
4402: d[17] = &r33 - &r31;
4403: d[18] = &r35 - &r33;
4404: d[19] = &r36 - &r35;
4405: d[20] = &r37 - &r36;
4406: d[21] = &r38 - &r37;
4407:
4408:
4409: /* The following FSM analyzes the string of differences. It accepts
4410: strings of the form a+b+a+ and returns 16 minus the number of bs,
4411: which is the number of variables that actually got into registers.
4412: Otherwise it signals rejection by returning -1., indicating that the
4413: test is unreliable. */
4414:
4415: n1 = d[0];
4416: s = 1;
4417:
4418: for (j=0; j<22; j++)
4419: switch (s) {
4420: case 1: if (d[j] != n1) {
4421: n2 = d[j];
4422: s = 2;
4423: nr = 1;
4424: }
4425: break;
4426: case 2: if (d[j] == n1) {
4427: s = 3;
4428: break;
4429: }
4430: if (d[j] == n2) {
4431: nr = nr+1;
4432: break;
4433: }
4434: s = 4;
4435: break;
4436: case 3: if (d[j] != n1) s = 4;
4437: break;
4438: }
4439: ;
4440:
4441: if (s == 3) return 16-nr;
4442: else return -1;
4443: }
4444: regi() { /* int to register assignment */
4445: /* Testing a variable whose storage class has been spec-
4446: ified as "register" is somewhat tricky, but it can be done in a
4447: fairly reliable fashion by taking advantage of our knowledge of the
4448: ways in which compilers operate. If we declare a collection of vari-
4449: ables of the same storage class, we would expect that, when storage
4450: for these variables is actually allocated, the variables will be
4451: bunched together and ordered according to one of the following
4452: criteria:
4453:
4454: (a) the order in which they were defined.
4455: (b) the order in which they are used.
4456: (c) alphabetically.
4457: (d) the order in which they appear in the compiler's
4458: symbol table.
4459: (e) some other way.
4460:
4461: Hence, if we define a sequence of variables in close alpha-
4462: betical order, and use them in the same order in which we define
4463: them, we would expect the differences between the addresses of
4464: successive variables to be constant, except in case (d) where the
4465: symbol table is a hash table, or in case (e). If a subsequence in
4466: the middle of this sequence is selected, and for this subsequence,
4467: every other variable is specified to be "register", and address
4468: differences are taken between adjacent nonregister variables, we would
4469: still expect to find constant differences if the "register" vari-
4470: ables were actually assigned to registers, and some other diff-
4471: erences if they were not. Specifically, if we had N variables
4472: specified as "register" of which the first n were actually ass-
4473: igned to registers, we would expect the sequence of differences
4474: to consist of a number of occurrences of some number, followed by
4475: N-n occurrences of some other number, followed by several occurr-
4476: ences of the first number. If we get a sequence like this, we can
4477: determine, by simple subtraction, how many (if any) variables are
4478: being assigned to registers. If we get some other sequence, we know
4479: that the test is invalid. */
4480:
4481:
4482: int r00;
4483: int r01;
4484: int r02;
4485: int r03;
4486: register int r04;
4487: int r05;
4488: register int r06;
4489: int r07;
4490: register int r08;
4491: int r09;
4492: register int r10;
4493: int r11;
4494: register int r12;
4495: int r13;
4496: register int r14;
4497: int r15;
4498: register int r16;
4499: int r17;
4500: register int r18;
4501: int r19;
4502: register int r20;
4503: int r21;
4504: register int r22;
4505: int r23;
4506: register int r24;
4507: int r25;
4508: register int r26;
4509: int r27;
4510: register int r28;
4511: int r29;
4512: register int r30;
4513: int r31;
4514: register int r32;
4515: int r33;
4516: register int r34;
4517: int r35;
4518: int r36;
4519: int r37;
4520: int r38;
4521:
4522: int s, n1, n2, nr, j, d[22];
4523:
4524: r00 = 0;
4525: r01 = 1;
4526: r02 = 2;
4527: r03 = 3;
4528: r04 = 4;
4529: r05 = 5;
4530: r06 = 6;
4531: r07 = 7;
4532: r08 = 8;
4533: r09 = 9;
4534: r10 = 10;
4535: r11 = 11;
4536: r12 = 12;
4537: r13 = 13;
4538: r14 = 14;
4539: r15 = 15;
4540: r16 = 16;
4541: r17 = 17;
4542: r18 = 18;
4543: r19 = 19;
4544: r20 = 20;
4545: r21 = 21;
4546: r22 = 22;
4547: r23 = 23;
4548: r24 = 24;
4549: r25 = 25;
4550: r26 = 26;
4551: r27 = 27;
4552: r28 = 28;
4553: r29 = 29;
4554: r30 = 30;
4555: r31 = 31;
4556: r32 = 32;
4557: r33 = 33;
4558: r34 = 34;
4559: r35 = 35;
4560: r36 = 36;
4561: r37 = 37;
4562: r38 = 38;
4563:
4564: d[0] = &r01 - &r00;
4565: d[1] = &r02 - &r01;
4566: d[2] = &r03 - &r02;
4567: d[3] = &r05 - &r03;
4568: d[4] = &r07 - &r05;
4569: d[5] = &r09 - &r07;
4570: d[6] = &r11 - &r09;
4571: d[7] = &r13 - &r11;
4572: d[8] = &r15 - &r13;
4573: d[9] = &r17 - &r15;
4574: d[10] = &r19 - &r17;
4575: d[11] = &r21 - &r19;
4576: d[12] = &r23 - &r21;
4577: d[13] = &r25 - &r23;
4578: d[14] = &r27 - &r25;
4579: d[15] = &r29 - &r27;
4580: d[16] = &r31 - &r29;
4581: d[17] = &r33 - &r31;
4582: d[18] = &r35 - &r33;
4583: d[19] = &r36 - &r35;
4584: d[20] = &r37 - &r36;
4585: d[21] = &r38 - &r37;
4586:
4587:
4588: /* The following FSM analyzes the string of differences. It accepts
4589: strings of the form a+b+a+ and returns 16 minus the number of bs,
4590: which is the number of variables that actually got into registers.
4591: Otherwise it signals rejection by returning -1., indicating that the
4592: test is unreliable. */
4593:
4594: n1 = d[0];
4595: s = 1;
4596:
4597: for (j=0; j<22; j++)
4598: switch (s) {
4599: case 1: if (d[j] != n1) {
4600: n2 = d[j];
4601: s = 2;
4602: nr = 1;
4603: }
4604: break;
4605: case 2: if (d[j] == n1) {
4606: s = 3;
4607: break;
4608: }
4609: if (d[j] == n2) {
4610: nr = nr+1;
4611: break;
4612: }
4613: s = 4;
4614: break;
4615: case 3: if (d[j] != n1) s = 4;
4616: break;
4617: }
4618: ;
4619:
4620: if (s == 3) return 16-nr;
4621: else return -1;
4622: }
4623: regp() { /* pointer to register assignment */
4624: /* Testing a variable whose storage class has been spec-
4625: ified as "register" is somewhat tricky, but it can be done in a
4626: fairly reliable fashion by taking advantage of our knowledge of the
4627: ways in which compilers operate. If we declare a collection of vari-
4628: ables of the same storage class, we would expect that, when storage
4629: for these variables is actually allocated, the variables will be
4630: bunched together and ordered according to one of the following
4631: criteria:
4632:
4633: (a) the order in which they were defined.
4634: (b) the order in which they are used.
4635: (c) alphabetically.
4636: (d) the order in which they appear in the compiler's
4637: symbol table.
4638: (e) some other way.
4639:
4640: Hence, if we define a sequence of variables in close alpha-
4641: betical order, and use them in the same order in which we define
4642: them, we would expect the differences between the addresses of
4643: successive variables to be constant, except in case (d) where the
4644: symbol table is a hash table, or in case (e). If a subsequence in
4645: the middle of this sequence is selected, and for this subsequence,
4646: every other variable is specified to be "register", and address
4647: differences are taken between adjacent nonregister variables, we would
4648: still expect to find constant differences if the "register" vari-
4649: ables were actually assigned to registers, and some other diff-
4650: erences if they were not. Specifically, if we had N variables
4651: specified as "register" of which the first n were actually ass-
4652: igned to registers, we would expect the sequence of differences
4653: to consist of a number of occurrences of some number, followed by
4654: N-n occurrences of some other number, followed by several occurr-
4655: ences of the first number. If we get a sequence like this, we can
4656: determine, by simple subtraction, how many (if any) variables are
4657: being assigned to registers. If we get some other sequence, we know
4658: that the test is invalid. */
4659:
4660:
4661: int *r00;
4662: int *r01;
4663: int *r02;
4664: int *r03;
4665: register int *r04;
4666: int *r05;
4667: register int *r06;
4668: int *r07;
4669: register int *r08;
4670: int *r09;
4671: register int *r10;
4672: int *r11;
4673: register int *r12;
4674: int *r13;
4675: register int *r14;
4676: int *r15;
4677: register int *r16;
4678: int *r17;
4679: register int *r18;
4680: int *r19;
4681: register int *r20;
4682: int *r21;
4683: register int *r22;
4684: int *r23;
4685: register int *r24;
4686: int *r25;
4687: register int *r26;
4688: int *r27;
4689: register int *r28;
4690: int *r29;
4691: register int *r30;
4692: int *r31;
4693: register int *r32;
4694: int *r33;
4695: register int *r34;
4696: int *r35;
4697: int *r36;
4698: int *r37;
4699: int *r38;
4700:
4701: int s, n1, n2, nr, j, d[22];
4702:
4703: r00 = (int *)&r00;
4704: r01 = (int *)&r01;
4705: r02 = (int *)&r02;
4706: r03 = (int *)&r03;
4707: r04 = (int *)&r05;
4708: r05 = (int *)&r05;
4709: r06 = (int *)&r07;
4710: r07 = (int *)&r07;
4711: r08 = (int *)&r09;
4712: r09 = (int *)&r09;
4713: r10 = (int *)&r11;
4714: r11 = (int *)&r11;
4715: r12 = (int *)&r13;
4716: r13 = (int *)&r13;
4717: r14 = (int *)&r15;
4718: r15 = (int *)&r15;
4719: r16 = (int *)&r17;
4720: r17 = (int *)&r17;
4721: r18 = (int *)&r19;
4722: r19 = (int *)&r19;
4723: r20 = (int *)&r21;
4724: r21 = (int *)&r21;
4725: r22 = (int *)&r23;
4726: r23 = (int *)&r23;
4727: r24 = (int *)&r25;
4728: r25 = (int *)&r25;
4729: r26 = (int *)&r27;
4730: r27 = (int *)&r27;
4731: r28 = (int *)&r29;
4732: r29 = (int *)&r29;
4733: r30 = (int *)&r31;
4734: r31 = (int *)&r31;
4735: r32 = (int *)&r33;
4736: r33 = (int *)&r33;
4737: r34 = (int *)&r35;
4738: r35 = (int *)&r35;
4739: r36 = (int *)&r36;
4740: r37 = (int *)&r37;
4741: r38 = (int *)&r38;
4742:
4743: d[0] = &r01 - &r00;
4744: d[1] = &r02 - &r01;
4745: d[2] = &r03 - &r02;
4746: d[3] = &r05 - &r03;
4747: d[4] = &r07 - &r05;
4748: d[5] = &r09 - &r07;
4749: d[6] = &r11 - &r09;
4750: d[7] = &r13 - &r11;
4751: d[8] = &r15 - &r13;
4752: d[9] = &r17 - &r15;
4753: d[10] = &r19 - &r17;
4754: d[11] = &r21 - &r19;
4755: d[12] = &r23 - &r21;
4756: d[13] = &r25 - &r23;
4757: d[14] = &r27 - &r25;
4758: d[15] = &r29 - &r27;
4759: d[16] = &r31 - &r29;
4760: d[17] = &r33 - &r31;
4761: d[18] = &r35 - &r33;
4762: d[19] = &r36 - &r35;
4763: d[20] = &r37 - &r36;
4764: d[21] = &r38 - &r37;
4765:
4766:
4767: /* The following FSM analyzes the string of differences. It accepts
4768: strings of the form a+b+a+ and returns 16 minus the number of bs,
4769: which is the number of variables that actually got into registers.
4770: Otherwise it signals rejection by returning -1., indicating that the
4771: test is unreliable. */
4772:
4773: n1 = d[0];
4774: s = 1;
4775: for (j=0; j<22; j++)
4776: switch (s) {
4777: case 1: if (d[j] != n1) {
4778: n2 = d[j];
4779: s = 2;
4780: nr = 1;
4781: }
4782: break;
4783: case 2: if (d[j] == n1) {
4784: s = 3;
4785: break;
4786: }
4787: if (d[j] == n2) {
4788: nr = nr+1;
4789: break;
4790: }
4791: s = 4;
4792: break;
4793: case 3: if (d[j] != n1) s = 4;
4794: break;
4795: }
4796: ;
4797:
4798: if (s == 3) return 16-nr;
4799: else return -1;
4800: }
4801: s84(pd0) /* 8.4 Meaning of declarators */
4802: struct defs *pd0;
4803: {
4804: int *ip, i, *fip(), (*pfi)(), j, k, array(), glork();
4805: static int x3d[3][5][7];
4806: float fa[17], *afp[17], sum;
4807: static char s84er[] = "s84,er%d\n";
4808: static char qs84[8] = "s84 ";
4809: int rc;
4810: char *ps, *pt;
4811: ps = qs84;
4812: pt = pd0->rfs;
4813: rc = 0;
4814: while (*pt++ = *ps++);
4815:
4816: /* The more common varieties of declarators have al-
4817: ready been touched upon, some more than others. It
4818: is useful to compare *fip() and (*pfi)().
4819: */
4820:
4821: ip = fip(3);
4822: if(*ip != 3){
4823: if(pd0->flgd != 0) printf(s84er,1);
4824: rc = rc+1;
4825: }
4826:
4827: pfi = glork;
4828: if((*pfi)(4) != 4){
4829: if(pd0->flgd != 0) printf(s84er,2);
4830: rc = rc+2;
4831: }
4832:
4833: /* Float fa[17] declares an array of floating point
4834: numbers, and *afp[17] declares an array of pointers
4835: to floats.
4836: */
4837:
4838: for(j=0; j<17; j++){
4839: fa[j] = j;
4840: afp[j] = &fa[j];
4841: }
4842:
4843: sum = 0.;
4844: for(j=0; j<17; j++) sum += *afp[j];
4845: if(sum != 136){
4846: if(pd0->flgd != 0) printf(s84er,4);
4847: rc = rc+4;
4848: }
4849:
4850: /* static int x3d[3][5][7] declares a static three
4851: dimensional array of integers, with rank 3x5x7.
4852: In complete detail, x3d is an array of three items;
4853: each item is an array of five arrays, and each of
4854: the latter arrays is an array of seven integers.
4855: Any of the expressions x3d, x3d[i], x3d[i][j],
4856: and x3d[i][j][k] may reasonably appear in an express-
4857: ion. The first three have type "array"; the last has
4858: type int.
4859: */
4860:
4861: for (i=0; i<3; i++)
4862: for (j=0; j<5; j++)
4863: for (k=0; k<7; k++)
4864: x3d[i][j][k] = i*35+j*7+k;
4865:
4866: i = 1; j = 2; k = 3;
4867:
4868: if( array(x3d,105,0)
4869: +array(x3d[i],35,35)
4870: +array(x3d[i][j],7,49)
4871: + x3d[i][j][k]-52){
4872:
4873: if(pd0->flgd != 0) printf(s84er,8);
4874: rc = rc+8;
4875: }
4876:
4877: return rc;
4878: }
4879: array(a,size,start)
4880: int a[], size, start;
4881: {
4882: int i;
4883: for(i=0; i<size; i++)
4884: if(a[i] != i+start) return 1;
4885:
4886: return 0;
4887: }
4888: int *fip(x)
4889: int x;
4890: {
4891: static int y;
4892: y = x;
4893: return &y;
4894: }
4895: glork(x)
4896: int x;
4897: {return x;}
4898: s85(pd0) /* 8.5 Structure and union declarations */
4899: struct defs *pd0;
4900: {
4901: static char s85er[] = "s85,er%d\n";
4902: static char qs85[8] = "s85 ";
4903: int rc;
4904: char *ps, *pt;
4905:
4906: struct tnode {
4907: char tword[20];
4908: int count;
4909: struct tnode *left;
4910: struct tnode *right;
4911: };
4912:
4913: struct tnode s1, s2, *sp;
4914:
4915: struct{
4916: char cdummy;
4917: char c;
4918: } sc;
4919:
4920: struct{
4921: char cdummy;
4922: short s;
4923: } ss;
4924:
4925: struct{
4926: char cdummy;
4927: int i;
4928: } si;
4929:
4930: struct{
4931: char cdummy;
4932: long l;
4933: } sl;
4934:
4935: struct{
4936: char cdummy;
4937: unsigned u;
4938: } su;
4939:
4940: struct{
4941: char cdummy;
4942: float f;
4943: } sf;
4944:
4945: struct{
4946: char cdummy;
4947: double d;
4948: } sd;
4949:
4950: int diff[7], j;
4951:
4952: static char *type[] = {
4953: "char",
4954: "short",
4955: "int",
4956: "long",
4957: "unsigned",
4958: "float",
4959: "double"
4960: };
4961:
4962: static char aln[] = " alignment: ";
4963:
4964: struct{
4965: int twobit:2;
4966: int :1;
4967: int threebit:3;
4968: int onebit:1;
4969: } s3;
4970:
4971: union{
4972: char u1[30];
4973: short u2[30];
4974: int u3[30];
4975: long u4[30];
4976: unsigned u5[30];
4977: float u6[30];
4978: double u7[30];
4979: } u0;
4980:
4981: ps = qs85;
4982: pt = pd0->rfs;
4983: rc = 0;
4984: while (*pt++ = *ps++);
4985:
4986: /* Within a structure, the objects declared have
4987: addresses which increase as their declarations are
4988: read left to right.
4989: */
4990:
4991: if( (char *)&s1.count - &s1.tword[0] <= 0
4992: ||(char *)&s1.left - (char *)&s1.count <= 0
4993: ||(char *)&s1.right - (char *)&s1.left <= 0){
4994: if(pd0->flgd != 0) printf(s85er,1);
4995: rc = rc+1;
4996: }
4997:
4998: /* Each non-field member of a structure begins on an
4999: addressing boundary appropriate to its type.
5000: */
5001:
5002: diff[0] = &sc.c - &sc.cdummy;
5003: diff[1] = (char *)&ss.s - &ss.cdummy;
5004: diff[2] = (char *)&si.i - &si.cdummy;
5005: diff[3] = (char *)&sl.l - &sl.cdummy;
5006: diff[4] = (char *)&su.u - &su.cdummy;
5007: diff[5] = (char *)&sf.f - &sf.cdummy;
5008: diff[6] = (char *)&sd.d - &sd.cdummy;
5009:
5010: if(pd0->flgm != 0)
5011: for(j=0; j<7; j++)
5012: printf("%s%s%d\n",type[j],aln,diff[j]);
5013:
5014: /* Field specifications are highly implementation de-
5015: pendent. About the only thing we can do here is to
5016: check is that the compiler accepts the field constructs,
5017: and that they seem to work, after a fashion, at
5018: run time...
5019: */
5020:
5021: s3.threebit = 7;
5022: s3.twobit = s3.threebit;
5023: s3.threebit = s3.twobit;
5024:
5025: if(s3.threebit != 3){
5026: if(s3.threebit == -1){
5027: if(pd0->flgm != 0) printf("Sign extension in fields\n");
5028: }
5029: else{
5030: if(pd0->flgd != 0) printf(s85er,2);
5031: rc = rc+2;
5032: }
5033: }
5034:
5035: s3.onebit = 1;
5036: if(s3.onebit != 1){
5037: if(pd0->flgm != 0)
5038: printf("Be especially careful with 1-bit fields!\n");
5039: }
5040:
5041: /* A union may be thought of as a structure all of whose
5042: members begin at offset 0 and whose size is sufficient
5043: to contain any of its members.
5044: */
5045:
5046: if( (char *)u0.u1 - (char *)&u0 != 0
5047: ||(char *)u0.u2 - (char *)&u0 != 0
5048: ||(char *)u0.u3 - (char *)&u0 != 0
5049: ||(char *)u0.u4 - (char *)&u0 != 0
5050: ||(char *)u0.u5 - (char *)&u0 != 0
5051: ||(char *)u0.u6 - (char *)&u0 != 0
5052: ||(char *)u0.u7 - (char *)&u0 != 0){
5053:
5054: if(pd0->flgd != 0) printf(s85er,4);
5055: rc = rc+4;
5056: }
5057:
5058: if( sizeof u0 < sizeof u0.u1
5059: ||sizeof u0 < sizeof u0.u2
5060: ||sizeof u0 < sizeof u0.u3
5061: ||sizeof u0 < sizeof u0.u4
5062: ||sizeof u0 < sizeof u0.u5
5063: ||sizeof u0 < sizeof u0.u6
5064: ||sizeof u0 < sizeof u0.u7){
5065:
5066: if(pd0->flgd != 0) printf(s85er,8);
5067: rc = rc+8;
5068: }
5069:
5070: /* Finally, we check that the pointers work. */
5071:
5072: s1.right = &s2;
5073: s2.tword[0] = 2;
5074: s1.right->tword[0] += 1;
5075: if(s2.tword[0] != 3){
5076: if(pd0->flgd != 0) printf(s85er,16);
5077: rc = rc+16;
5078: }
5079: return rc;
5080: }
5081: s86(pd0) /* 8.6 Initialization */
5082: struct defs *pd0;
5083: {
5084: static char s86er[] = "s86,er%d\n";
5085: static char qs86[8] = "s86 ";
5086: int lrc, rc;
5087: char *ps, *pt;
5088: int one(), i, j, k;
5089: static int x[] = {1,3,5};
5090: static int *pint = x+2;
5091: static int zero[10];
5092: int *apint = pint-1;
5093: register int *rpint = apint+one();
5094: static float y0[] = {1,3,5,2,4,6,3,5,7,0,0,0};
5095: static float y1[4][3] = {
5096: {1,3,5},
5097: {2,4,6},
5098: {3,5,7},
5099: };
5100: static float y2[4][3] = {1,3,5,2,4,6,3,5,7};
5101: static float y3[4][3] = {
5102: {1},{2},{3},{4}
5103: };
5104: ps = qs86;
5105: pt = pd0->rfs;
5106: rc = 0;
5107: while (*pt++ = *ps++);
5108:
5109: /* The expression in an initializer for a static or
5110: external variable must be a constant expression or
5111: an expression that reduces to the address of a pre-
5112: viously declared variable, possibly offset by a
5113: constant expression.
5114: */
5115:
5116: if(*pint != 5){
5117: if(pd0->flgd != 0) printf(s86er,1);
5118: rc = rc+1;
5119: }
5120:
5121: /* Automatic and register variables may be initialized
5122: by arbitrary expressions involving constants and previously
5123: declared variables and functions.
5124: */
5125:
5126: if(*apint != 3){
5127: if(pd0->flgd != 0) printf(s86er,2);
5128: rc = rc+2;
5129: }
5130:
5131: if(*rpint != 5){
5132: if(pd0->flgd != 0) printf(s86er,4);
5133: rc = rc+4;
5134: }
5135:
5136: /* Static variables that are not initialized are guar-
5137: anteed to start off as zero.
5138: */
5139:
5140: lrc = 0;
5141: for(j=0; j<10; j++)
5142: if(zero[j] != 0) lrc = 1;
5143: if(lrc != 0){
5144: if(pd0->flgd != 0) printf(s86er,8);
5145: rc = rc+8;
5146: }
5147:
5148: /* y0, y1, and y2, as declared, should define and
5149: initialize identical arrays.
5150: */
5151: lrc = 0;
5152: for(i=0; i<4; i++)
5153: for(j=0; j<3; j++){
5154: k = 3*i+j;
5155: if( y1[i][j] != y2[i][j]
5156: ||y1[i][j] != y0[k]) lrc = 1;
5157: }
5158:
5159: if(lrc != 0){
5160: if(pd0->flgd != 0) printf(s86er,16);
5161: rc = rc+16;
5162: }
5163:
5164: /* y3 initializes the first column of the array and
5165: leaves the rest zero.
5166: */
5167:
5168: lrc = 0;
5169: for(j=0; j<4; j++) if(y3[j][0] != j+1) lrc = 1;
5170:
5171: if(lrc != 0){
5172: if(pd0->flgd != 0) printf(s86er,32);
5173: rc = rc+32;
5174: }
5175: return rc;
5176: }
5177: one(){
5178: return 1;
5179: }
5180: int *metricp;
5181: s88(pd0) /* 8.8 Typedef */
5182: struct defs *pd0;
5183: {
5184: static char s88er[] = "s88,er%d\n";
5185: static char qs88[8] = "s88 ";
5186: int rc;
5187: char *ps, *pt;
5188:
5189: /* Declarations whose "storage class" is typdef do not
5190: define storage, but instead define identifiers which
5191: can later be used as if they were type keywords naming
5192: fundamental or derived types.
5193: */
5194:
5195: typedef int MILES, *KLICKSP;
5196: typedef struct {double re, im;} complex;
5197:
5198: MILES distance;
5199: extern KLICKSP metricp;
5200: complex z, *zp;
5201:
5202: ps = qs88;
5203: pt = pd0->rfs;
5204: rc = 0;
5205: while(*pt++ = *ps++);
5206:
5207: /* Hopefully, all of this stuff will compile. After that,
5208: we can only make some superficial tests.
5209:
5210: The type of distance is int,
5211: */
5212:
5213: if(sizeof distance != sizeof(int)){
5214: if(pd0->flgd != 0) printf(s88er,1);
5215: rc = rc+1;
5216: }
5217:
5218: /* that of metricp is "pointer to int", */
5219:
5220: metricp = &distance;
5221: distance = 2;
5222: *metricp = 3;
5223:
5224: if(distance != 3){
5225: if(pd0->flgd != 0) printf(s88er,2);
5226: rc = rc+2;
5227: }
5228:
5229: /* and that of z is the specified structure. zp is a
5230: pointer to such a structure.
5231: */
5232:
5233: z.re = 0.;
5234: z.im = 0.;
5235: zp = &z;
5236: zp->re = 1.;
5237: zp->im = 1.;
5238: if(z.re+z.im != 2.){
5239: if(pd0->flgd != 0) printf(s88er,4);
5240: rc = rc+4;
5241: }
5242:
5243: return rc;
5244: }
5245: s9(pd0) /* 9 Statements */
5246: struct defs *pd0;
5247: {
5248: static char s9er[] = "s9,er%d\n";
5249: static char qs9[8] = "s9 ";
5250: int rc;
5251: char *ps, *pt;
5252: int lrc, i;
5253:
5254: ps = qs9;
5255: pt = pd0->rfs;
5256: rc = 0;
5257: while (*pt++ = *ps++);
5258:
5259: /* One would think that the section on statements would
5260: provide the most variety in the entire sequence of tests.
5261: As it turns out, most of the material in this section has
5262: already been checked in the process of checking out
5263: everything else, and the section at this point is somewhat
5264: anticlimactic. For this reason, we restrict ourselves
5265: to testing two features not already covered.
5266:
5267: Compound statements are delimited by braces. They have the
5268: nice property that identifiers of the auto and register
5269: variety are pushed and popped. It is currently legal to
5270: transfer into a block, but we wont...
5271: */
5272:
5273: lrc = 0;
5274: for(i=0; i<2; i++){
5275: int j;
5276: register int k;
5277: j = k = 2;
5278: {
5279: int j;
5280: register int k;
5281: j = k = 3;
5282: if((j != 3) || (k != 3)) lrc = 1;
5283: }
5284: if((j != 2) || (k != 2)) lrc = 1;
5285: }
5286:
5287: if(lrc != 0){
5288: if(pd0->flgd != 0) printf(s9er,1);
5289: rc = rc+1;
5290: }
5291:
5292: /* Goto statements go to labeled statements, we hope. */
5293:
5294: goto nobarf;
5295: if(pd0->flgd != 0) printf(s9er,2);
5296: rc = rc+2;
5297: nobarf:;
5298:
5299: return rc;
5300: }
5301: setev(){ /* Sets an external variable. Used */
5302: extern int extvar; /* by s4, and should be compiled */
5303: extvar = 1066; /* separately from s4. */
5304: }
5305: int lbits; /* long */
5306: int ubits; /* unsigned */
5307: int fbits; /* float */
5308: int dbits; /* double */
5309: float fprec; /* Smallest number that can be */
5310: float dprec; /* significantly added to 1. */
5311: int flgs; /* Print return codes, by section */
5312: int flgm; /* Announce machine dependencies */
5313: int flgd; /* give explicit diagnostics */
5314: int flgl; /* Report local return codes. */
5315: int rrc; /* recent return code */
5316: int crc; /* Cumulative return code */
5317: char rfs[8]; /* Return from section */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.