| struct defs { |
| int cbits; /* No. of bits per char */ |
| int ibits; /* int */ |
| int sbits; /* short */ |
| int lbits; /* long */ |
| int ubits; /* unsigned */ |
| int fbits; /* float */ |
| int dbits; /* double */ |
| float fprec; /* Smallest number that can be */ |
| float dprec; /* significantly added to 1. */ |
| int flgs; /* Print return codes, by section */ |
| int flgm; /* Announce machine dependencies */ |
| int flgd; /* give explicit diagnostics */ |
| int flgl; /* Report local return codes. */ |
| int rrc; /* recent return code */ |
| int crc; /* Cumulative return code */ |
| char rfs[8]; /* Return from section */ |
| }; |
| main(n,args) /* C REFERENCE MANUAL */ |
| int n; |
| char **args; |
| { |
| |
| /* This program performs a series of tests on a C compiler, |
| based on information in the |
| |
| C REFERENCE MANUAL |
| |
| which appears as Appendix A to the book "The C Programming |
| Language" by Brian W. Kernighan and Dennis M. Ritchie |
| (Prentice-Hall, 1978, $10.95). This Appendix is hereafter |
| referred to as "the Manual". |
| |
| The rules followed in writing this program are: |
| |
| 1. The entire program is written in legal C, according |
| to the Manual. It should compile with no error messages, |
| although some warning messages may be produced by some |
| compilers. Failure to compile should be interpreted as |
| a compiler error. |
| |
| 2. The program is clean, in that it does not make use |
| of any features of the operating system on which it runs, |
| with the sole exceptions of the printf() function, and an |
| internal "options" routine, which is easily excised. |
| |
| 3. No global variables are used, except for the spec- |
| ific purpose of testing the global variable facility. |
| |
| The program is divided into modules having names of the |
| form snnn... These modules correspond to those sections of the |
| Manual, as identified by boldface type headings, in which |
| there is something to test. For example, s241() corresponds |
| to section 2.4.1 of the Manual (Integer constants) and tests |
| the facilities described therein. The module numbering |
| scheme is ambiguous, especially when it names modules |
| referring to more than one section; module s7813, for ex- |
| ample, deals with sections 7.8 through 7.13. Nonetheless, |
| it is surprisingly easy to find a section in the Manual |
| corresponding to a section of code, and vice versa. |
| |
| Note also that there seem to be "holes" in the program, |
| at least from the point of view that there exist sections in the |
| Manual for which there is no corresponding code. Such holes |
| arise from three causes: (a) there is nothing in that partic- |
| ular section to test, (b) everything in that section is tested |
| elsewhere, and (c) it was deemed advisable not to check cer- |
| tain features like preprocessor or listing control features. |
| |
| Modules are called by a main program main(). The mod- |
| ules that are called, and the sequence in which they are |
| called, are determined by two lists in main(), in which the |
| module names appear. The first list (an extern statement) |
| declares the module names to be external. The second (a stat- |
| ic int statement) names the modules and defines the sequence |
| in which they are called. There is no need for these lists |
| to be in the same order, but it is probably a good idea to keep |
| them that way in the interest of clarity. Since there are no |
| cross-linkages between modules, new modules may be added, |
| or old ones deleted, simply by editing the lists, with one |
| exception: section s26, which pokes around at the hardware |
| trying to figure out the characteristics of the machine that |
| it is running on, saves information that is subsequently |
| used by sections s626, s72, and s757. If this program is |
| to be broken up into smallish pieces, say for running on |
| a microcomputer, take care to see that s26 is called before |
| calling any of the latter three sections. The size |
| of the lists, i.e., the number of modules to be called, is |
| not explicitly specified as a program parameter, but is |
| determined dynamically using the sizeof operator. |
| |
| Communication between the main program and the modules |
| takes place in two ways. In all cases, a pointer to a structure |
| is passed to the called module. The structure contains flags |
| that will determine the type of information to be published |
| by the module, and fields that may be written in by the |
| module. The former include "flgm" and "flgd", which, if set |
| to a nonzero value, specify that machine dependencies are to |
| be announced or that error messages are to be printed, re- |
| spectively. The called module's name, and the hardware char- |
| acteristics probed in s26() comprise the latter. |
| |
| |
| Also, in all cases, a return code is returned by the called |
| module. A return code of zero indicates that all has gone well; |
| nonzero indicates otherwise. Since more than one type of error |
| may be detected by a module, the return code is a composite |
| of error indicators, which, individually, are given as numbers |
| that are powers of two. Thus, a return code of 10 indicates |
| that two specific errors, 8 and 2, were detected. Whether or |
| not the codes returned by the modules are printed by the main |
| program is determined by setting "flgs" to 1 (resp. 0). |
| |
| The entire logic of the main program is contained in the |
| half-dozen or so lines at the end. The somewhat cryptic |
| statement: |
| |
| d0.rrc = (*sec[j])(pd0); |
| |
| in the for loop calls the modules. The rest of the code is |
| reasonably straightforward. |
| |
| Finally, in each of the modules, there is the following |
| prologue: |
| |
| snnn(pd0) |
| struct defs *pd0; |
| { |
| static char snnner[] = "snnn,er%d\n"; |
| static char qsnnn[8] = "snnn "; |
| char *ps, *pt; |
| int rc; |
| |
| rc = 0; |
| ps = qsnnn; |
| pt = pd0->rfs; |
| while(*pt++ = *ps++); |
| |
| used for housekeeping, handshaking and module initialization. |
| |
| */ |
| extern |
| s22(struct defs *), |
| s241(struct defs *), |
| s243(struct defs *), |
| s244(struct defs *), |
| s25(struct defs *), |
| s26(struct defs *), |
| s4(struct defs *), |
| s61(struct defs *), |
| s626(struct defs *), |
| s71(struct defs *), |
| s72(struct defs *), |
| s757(struct defs *), |
| s7813(struct defs *), |
| s714(struct defs *), |
| s715(struct defs *), |
| s81(struct defs *), |
| s84(struct defs *), |
| s85(struct defs *), |
| s86(struct defs *), |
| s88(struct defs *), |
| s9(struct defs *) |
| ; |
| |
| int j; |
| static int (*sec[])() = { |
| s22, |
| s241, |
| s243, |
| s244, |
| s25, |
| s26, |
| s4, |
| s61, |
| s626, |
| s71, |
| s72, |
| s757, |
| s7813, |
| s714, |
| s715, |
| s81, |
| s84, |
| s85, |
| s86, |
| s88, |
| s9 |
| }; |
| |
| static struct defs d0, *pd0; |
| |
| d0.flgs = 1; /* These flags dictate */ |
| d0.flgm = 1; /* the verbosity of */ |
| d0.flgd = 1; /* the program. */ |
| d0.flgl = 1; |
| |
| pd0 = &d0; |
| |
| for (j=0; j<sizeof(sec) / sizeof(sec[0]); j++) { |
| d0.rrc = (*sec[j])(pd0); |
| d0.crc = d0.crc+d0.rrc; |
| if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc); |
| } |
| |
| if(d0.crc == 0) printf("\nNo errors detected.\n"); |
| else printf("\nFailed.\n"); |
| return 0; |
| } |
| s22(pd0) /* 2.2 Identifiers (Names) */ |
| struct defs *pd0; |
| { |
| int a234, a; |
| int _, _234, A, rc; |
| |
| static char s22er[] = "s22,er%d\n"; |
| static char qs22[8] = "s22 "; |
| |
| char *ps, *pt; |
| /* Initialize */ |
| |
| rc = 0; |
| ps = qs22; |
| pt = pd0 -> rfs; |
| while (*pt++ = *ps++); |
| |
| /* An identifier is a sequence of letters and digits; |
| the first character must be a letter. The under- |
| score _ counts as a letter. */ |
| |
| a=1; |
| _=2; |
| _234=3; |
| a234=4; |
| if(a+_+_234+a234 != 10) { |
| rc = rc+1; |
| if(pd0->flgd != 0) printf(s22er,1); |
| } |
| |
| /* Upper and lower case letters are different. */ |
| |
| A = 2; |
| if (A == a) { |
| rc = rc+4; |
| if (pd0->flgd != 0) printf(s22er,4); |
| } |
| |
| return(rc); |
| } |
| s241(pd0) /* 2.4.1 Integer constants |
| 2.4.2 Explicit long constants */ |
| struct defs *pd0; |
| { |
| long pow2(); |
| static char s241er[] = "s241,er%d\n"; |
| static char qs241[8] = "s241 "; |
| char *ps, *pt; |
| int rc, j, lrc; |
| static long g[39] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
| 0,6,0,8,0,12,0,16,0,18,0,20,0,24, |
| 0,28,0,30,0,32,0,36}; |
| long d[39], o[39], x[39]; |
| |
| rc = 0; |
| lrc = 0; |
| ps = qs241; |
| pt = pd0 -> rfs; |
| while (*pt++ = *ps++); |
| |
| /* An integer constant consisting of a sequence of digits is |
| taken to be octal if it begins with 0 (digit zero), decimal |
| otherwise. */ |
| |
| if ( 8 != 010 |
| || 16 != 020 |
| || 24 != 030 |
| || 32 != 040 |
| || 40 != 050 |
| || 48 != 060 |
| || 56 != 070 |
| || 64 != 0100 |
| || 72 != 0110 |
| || 80 != 0120 |
| || 9 != 0011 |
| || 17 != 0021 |
| || 25 != 0031 |
| || 33 != 0041 |
| || 41 != 0051 |
| || 49 != 0061 |
| || 57 != 0071 |
| || 65 != 0101 |
| || 73 != 0111 |
| || 81 != 0121 ){ |
| |
| rc = rc+1; |
| if( pd0->flgd != 0 ) printf(s241er,1); |
| } |
| |
| /* A sequence of digits preceded by 0x or 0X (digit zero) |
| is taken to be a hexadecimal integer. The hexadecimal |
| digits include a or A through f or F with values 10 |
| through 15. */ |
| |
| if ( 0x00abcdef != 0xabcdef |
| || 0xabcdef != 0Xabcdef || 0Xabcdef != 0XAbcdef |
| || 0XAbcdef != 0XABcdef || 0XABcdef != 0XABCdef |
| || 0XABCdef != 0XABCDef || 0XABCDef != 0XABCDEf |
| || 0XABCDEf != 0XABCDEF || 0xABCDEF != 11259375 ){ |
| |
| rc = rc+2; |
| if( pd0->flgd != 0 ) printf(s241er,2); |
| } |
| |
| /* A decimal constant whose value exceeds the largest signed |
| machine integer is taken to be long; an octal or hex con- |
| stant which exceeds the largest unsigned machine integer |
| is likewise taken to be long. */ |
| |
| if ( sizeof 010000000000 != sizeof(long) /* 2**30 */ |
| || sizeof 1073741824 != sizeof(long) /* ditto */ |
| || sizeof 0x40000000 != sizeof(long) ){ /* " */ |
| |
| rc = rc+4; |
| if( pd0->flgd != 0 ) printf(s241er,4); |
| } |
| |
| /* A decimal, octal, or hexadecimal constant immediately followed |
| by l (letter ell) or L is a long constant. */ |
| |
| if ( sizeof 67l != sizeof(long) |
| || sizeof 67L != sizeof(long) |
| || sizeof 067l != sizeof(long) |
| || sizeof 067L != sizeof(long) |
| || sizeof 0X67l != sizeof(long) |
| || sizeof 0x67L != sizeof(long) ){ |
| |
| rc = rc+8; |
| if( pd0 -> flgd != 0 ) printf(s241er,8); |
| } |
| |
| /* Finally, we test to see that decimal (d), octal (o), |
| and hexadecimal (x) constants representing the same values |
| agree among themselves, and with computed values, at spec- |
| ified points over an appropriate range. The points select- |
| ed here are those with the greatest potential for caus- |
| ing trouble, i.e., zero, 1-16, and values of 2**n and |
| 2**n - 1 where n is some multiple of 4 or 6. Unfortunately, |
| just what happens when a value is too big to fit in a |
| long is undefined; however, it would be nice if what |
| happened were at least consistent... */ |
| |
| for ( j=0; j<17; j++ ) g[j] = j; |
| for ( j=18; j<39; ) { |
| g[j] = pow2(g[j]); |
| g[j-1] = g[j] - 1; |
| j = j+2; |
| } |
| |
| d[0] = 0; o[0] = 00; x[0] = 0x0; |
| d[1] = 1; o[1] = 01; x[1] = 0x1; |
| d[2] = 2; o[2] = 02; x[2] = 0x2; |
| d[3] = 3; o[3] = 03; x[3] = 0x3; |
| d[4] = 4; o[4] = 04; x[4] = 0x4; |
| d[5] = 5; o[5] = 05; x[5] = 0x5; |
| d[6] = 6; o[6] = 06; x[6] = 0x6; |
| d[7] = 7; o[7] = 07; x[7] = 0x7; |
| d[8] = 8; o[8] = 010; x[8] = 0x8; |
| d[9] = 9; o[9] = 011; x[9] = 0x9; |
| d[10] = 10; o[10] = 012; x[10] = 0xa; |
| d[11] = 11; o[11] = 013; x[11] = 0xb; |
| d[12] = 12; o[12] = 014; x[12] = 0xc; |
| d[13] = 13; o[13] = 015; x[13] = 0xd; |
| d[14] = 14; o[14] = 016; x[14] = 0xe; |
| d[15] = 15; o[15] = 017; x[15] = 0xf; |
| d[16] = 16; o[16] = 020; x[16] = 0x10; |
| d[17] = 63; o[17] = 077; x[17] = 0x3f; |
| d[18] = 64; o[18] = 0100; x[18] = 0x40; |
| d[19] = 255; o[19] = 0377; x[19] = 0xff; |
| d[20] = 256; o[20] = 0400; x[20] = 0x100; |
| d[21] = 4095; o[21] = 07777; x[21] = 0xfff; |
| d[22] = 4096; o[22] = 010000; x[22] = 0x1000; |
| d[23] = 65535; o[23] = 0177777; x[23] = 0xffff; |
| d[24] = 65536; o[24] = 0200000; x[24] = 0x10000; |
| d[25] = 262143; o[25] = 0777777; x[25] = 0x3ffff; |
| d[26] = 262144; o[26] = 01000000; x[26] = 0x40000; |
| d[27] = 1048575; o[27] = 03777777; x[27] = 0xfffff; |
| d[28] = 1048576; o[28] = 04000000; x[28] = 0x100000; |
| d[29] = 16777215; o[29] = 077777777; x[29] = 0xffffff; |
| d[30] = 16777216; o[30] = 0100000000; x[30] = 0x1000000; |
| d[31] = 268435455; o[31] = 01777777777; x[31] = 0xfffffff; |
| d[32] = 268435456; o[32] = 02000000000; x[32] = 0x10000000; |
| d[33] = 1073741823; o[33] = 07777777777; x[33] = 0x3fffffff; |
| d[34] = 1073741824; o[34] = 010000000000; x[34] = 0x40000000; |
| d[35] = 4294967295; o[35] = 037777777777; x[35] = 0xffffffff; |
| d[36] = 4294967296; o[36] = 040000000000; x[36] = 0x100000000; |
| d[37] = 68719476735; o[37] = 0777777777777; x[37] = 0xfffffffff; |
| d[38] = 68719476736; o[38] = 01000000000000; x[38] = 0x1000000000; |
| |
| /* WHEW! */ |
| |
| for (j=0; j<39; j++){ |
| if ( g[j] != d[j] |
| || d[j] != o[j] |
| || o[j] != x[j]) { |
| |
| if( pd0 -> flgm != 0 ) { |
| /* printf(s241er,16); save in case opinions change... */ |
| printf("Decimal and octal/hex constants sometimes give\n"); |
| printf(" different results when assigned to longs.\n"); |
| } |
| /* lrc = 1; save... */ |
| } |
| } |
| |
| if (lrc != 0) rc =16; |
| |
| return rc; |
| } |
| |
| long pow2(n) /* Calculate 2**n by multiplying, not shifting */ |
| long n; |
| { |
| long s; |
| s = 1; |
| while(n--) s = s*2; |
| return s; |
| } |
| s243(pd0) /* 2.4.3 Character constants */ |
| struct defs *pd0; |
| { |
| static char s243er[] = "s243,er%d\n"; |
| static char qs243[8] = "s243 "; |
| char *ps, *pt; |
| int rc; |
| char chars[256]; |
| |
| rc = 0; |
| ps = qs243; |
| pt = pd0->rfs; |
| while(*pt++ = *ps++); |
| |
| /* One of the problems that arises when testing character constants |
| is that of definition: What, exactly, is the character set? |
| In order to guarantee a certain amount of machine independence, |
| the character set we will use here is the set of characters writ- |
| able as escape sequences in C, plus those characters used in writ- |
| ing C programs, i.e., |
| |
| letters: |
| ABCDEFGHIJKLMNOPQRSTUVWXYZ 26 |
| abcdefghijklmnopqrstuvwxyz 26 |
| numbers: |
| 0123456789 10 |
| special characters: |
| ~!"#%&()_=-^|{}[]+;*:<>,.?/ 27 |
| extra special characters: |
| newline \n |
| horizontal tab \t |
| backspace \b |
| carriage return \r |
| form feed \f |
| backslash \\ |
| single quote \' 7 |
| blank & NUL 2 |
| --- |
| 98 |
| |
| Any specific implementation of C may of course support additional |
| characters. */ |
| |
| /* Since the value of a character constant is the numerical value |
| of the character in the machine's character set, there should |
| be a one-to-one correspondence between characters and values. */ |
| |
| zerofill(chars); |
| |
| chars['a'] = 1; chars['A'] = 1; chars['~'] = 1; chars['0'] = 1; |
| chars['b'] = 1; chars['B'] = 1; chars['!'] = 1; chars['1'] = 1; |
| chars['c'] = 1; chars['C'] = 1; chars['"'] = 1; chars['2'] = 1; |
| chars['d'] = 1; chars['D'] = 1; chars['#'] = 1; chars['3'] = 1; |
| chars['e'] = 1; chars['E'] = 1; chars['%'] = 1; chars['4'] = 1; |
| chars['f'] = 1; chars['F'] = 1; chars['&'] = 1; chars['5'] = 1; |
| chars['g'] = 1; chars['G'] = 1; chars['('] = 1; chars['6'] = 1; |
| chars['h'] = 1; chars['H'] = 1; chars[')'] = 1; chars['7'] = 1; |
| chars['i'] = 1; chars['I'] = 1; chars['_'] = 1; chars['8'] = 1; |
| chars['j'] = 1; chars['J'] = 1; chars['='] = 1; chars['9'] = 1; |
| chars['k'] = 1; chars['K'] = 1; chars['-'] = 1; |
| chars['l'] = 1; chars['L'] = 1; chars['^'] = 1; |
| chars['m'] = 1; chars['M'] = 1; chars['|'] = 1; chars['\n'] = 1; |
| chars['n'] = 1; chars['N'] = 1; chars['\t'] = 1; |
| chars['o'] = 1; chars['O'] = 1; chars['{'] = 1; chars['\b'] = 1; |
| chars['p'] = 1; chars['P'] = 1; chars['}'] = 1; chars['\r'] = 1; |
| chars['q'] = 1; chars['Q'] = 1; chars['['] = 1; chars['\f'] = 1; |
| chars['r'] = 1; chars['R'] = 1; chars[']'] = 1; |
| chars['s'] = 1; chars['S'] = 1; chars['+'] = 1; chars['\\'] = 1; |
| chars['t'] = 1; chars['T'] = 1; chars[';'] = 1; chars['\''] = 1; |
| chars['u'] = 1; chars['U'] = 1; chars['*'] = 1; |
| chars['v'] = 1; chars['V'] = 1; chars[':'] = 1; chars['\0'] = 1; |
| chars['w'] = 1; chars['W'] = 1; chars['<'] = 1; chars[' '] = 1; |
| chars['x'] = 1; chars['X'] = 1; chars['>'] = 1; |
| chars['y'] = 1; chars['Y'] = 1; chars[','] = 1; |
| chars['z'] = 1; chars['Z'] = 1; chars['.'] = 1; |
| chars['?'] = 1; |
| chars['/'] = 1; |
| |
| if(sumof(chars) != 98){ |
| rc = rc+1; |
| if(pd0->flgd != 0) printf(s243er,1); |
| } |
| |
| /* Finally, the escape \ddd consists of the backslash followed |
| by 1, 2, or 3 octal digits which are taken to specify the |
| desired character. */ |
| |
| if( '\0' != 0 || '\01' != 1 || '\02' != 2 |
| || '\03' != 3 || '\04' != 4 || '\05' != 5 |
| || '\06' != 6 || '\07' != 7 || '\10' != 8 |
| || '\17' != 15 || '\20' != 16 || '\77' != 63 |
| || '\100' != 64 || '\177' != 127 ){ |
| |
| rc = rc+8; |
| if(pd0->flgd != 0) printf(s243er,8); |
| } |
| |
| return rc; |
| } |
| zerofill(x) |
| char *x; |
| { |
| int j; |
| |
| for (j=0; j<256; j++) *x++ = 0; |
| } |
| sumof(x) |
| char *x; |
| { |
| char *p; |
| int total, j; |
| |
| p = x; |
| total = 0; |
| |
| for(j=0; j<256; j++) total = total+ *p++; |
| return total; |
| } |
| s244(pd0) |
| struct defs *pd0; |
| { |
| double a[8]; |
| int rc, lrc, j; |
| static char s244er[] = "s244,er%d\n"; |
| static char qs244[8] = "s244 "; |
| char *ps, *pt; |
| |
| ps = qs244; |
| pt = pd0->rfs; |
| while(*pt++ = *ps++); |
| rc = 0; |
| lrc = 0; |
| |
| /* Unfortunately, there's not a lot we can do with floating constants. |
| We can check to see that the various representations can be com- |
| piled, that the conversion is such that they yield the same hard- |
| ware representations in all cases, and that all representations |
| thus checked are double precision. */ |
| |
| a[0] = .1250E+04; |
| a[1] = 1.250E3; |
| a[2] = 12.50E02; |
| a[3] = 125.0e+1; |
| a[4] = 1250e00; |
| a[5] = 12500.e-01; |
| a[6] = 125000e-2; |
| a[7] = 1250.; |
| |
| lrc = 0; |
| for (j=0; j<7; j++) if(a[j] != a[j+1]) lrc = 1; |
| |
| if(lrc != 0) { |
| if(pd0->flgd != 0) printf(s244er,1); |
| rc = rc+1; |
| } |
| |
| if ( (sizeof .1250E+04 ) != sizeof(double) |
| || (sizeof 1.250E3 ) != sizeof(double) |
| || (sizeof 12.50E02 ) != sizeof(double) |
| || (sizeof 1.250e+1 ) != sizeof(double) |
| || (sizeof 1250e00 ) != sizeof(double) |
| || (sizeof 12500.e-01) != sizeof(double) |
| || (sizeof 125000e-2 ) != sizeof(double) |
| || (sizeof 1250. ) != sizeof(double)){ |
| |
| if(pd0->flgd != 0) printf(s244er,2); |
| rc = rc+2; |
| } |
| |
| return rc; |
| } |
| s25(pd0) |
| struct defs *pd0; |
| { |
| char *s, *s2; |
| int rc, lrc, j; |
| static char s25er[] = "s25,er%d\n"; |
| static char qs25[8] = "s25 "; |
| char *ps, *pt; |
| |
| ps = qs25; |
| pt = pd0->rfs; |
| while(*pt++ = *ps++); |
| rc = 0; |
| |
| /* A string is a sequence of characters surrounded by double |
| quotes, as in "...". */ |
| |
| s = "..."; |
| |
| /* A string has type "array of characters" and storage class |
| static and is initialized with the given characters. */ |
| |
| if ( s[0] != s[1] || s[1] != s[2] |
| || s[2] != '.' ) { |
| |
| rc = rc+1; |
| if(pd0->flgd != 0) printf(s25er,1); |
| } |
| |
| /* The compiler places a null byte \0 at the end of each string |
| so the program which scans the string can find its end. */ |
| |
| if( s[3] != '\0' ){ |
| rc = rc+4; |
| if(pd0->flgd != 0) printf(s25er,4); |
| } |
| |
| /* In a string, the double quote character " must be preceded |
| by a \. */ |
| |
| if( ".\"."[1] != '"' ){ |
| rc = rc+8; |
| if(pd0->flgd != 0) printf(s25er,8); |
| } |
| |
| /* In addition, the same escapes described for character constants |
| may be used. */ |
| |
| s = "\n\t\b\r\f\\\'"; |
| |
| if( s[0] != '\n' |
| || s[1] != '\t' |
| || s[2] != '\b' |
| || s[3] != '\r' |
| || s[4] != '\f' |
| || s[5] != '\\' |
| || s[6] != '\'' ){ |
| |
| rc = rc+16; |
| if( pd0->flgd != 0) printf(s25er,16); |
| } |
| |
| /* Finally, a \ and an immediately following newline are ignored */ |
| |
| s2 = "queep!"; |
| s = "queep!"; |
| |
| lrc = 0; |
| for (j=0; j<sizeof "queep!"; j++) if(s[j] != s2[j]) lrc = 1; |
| if (lrc != 0){ |
| rc = rc+32; |
| if(pd0->flgd != 0) printf(s25er,32); |
| } |
| return rc; |
| } |
| s26(pd0) /* 2.6 Hardware Characteristics */ |
| struct defs *pd0; |
| { |
| static char qs26[8] = "s26 "; |
| char *ps, *pt; |
| char c0, c1; |
| float temp, one, delta; |
| double tempd, oned; |
| static char s[] = "%3d bits in %ss.\n"; |
| static char s2[] = "%e is the least number that can be added to 1. (%s).\n"; |
| |
| ps = qs26; |
| pt = pd0->rfs; |
| |
| while(*pt++ = *ps++); |
| |
| /* Here, we shake the machinery a little to see what falls |
| out. First, we find out how many bits are in a char. */ |
| |
| pd0->cbits = 0; |
| c0 = 0; |
| c1 = 1; |
| |
| while(c0 != c1) { |
| c1 = c1<<1; |
| pd0->cbits = pd0->cbits+1; |
| } |
| /* That information lets us determine the size of everything else. */ |
| |
| pd0->ibits = pd0->cbits * sizeof(int); |
| pd0->sbits = pd0->cbits * sizeof(short); |
| pd0->lbits = pd0->cbits * sizeof(long); |
| pd0->ubits = pd0->cbits * sizeof(unsigned); |
| pd0->fbits = pd0->cbits * sizeof(float); |
| pd0->dbits = pd0->cbits * sizeof(double); |
| |
| /* We have now almost reconstructed the table in section 2.6, the |
| exception being the range of the floating point hardware. |
| Now there are just so many ways to conjure up a floating point |
| representation system that it's damned near impossible to guess |
| what's going on by writing a program to interpret bit patterns. |
| Further, the information isn't all that useful, if we consider |
| the fact that machines that won't handle numbers between 10**30 |
| and 10**-30 are very hard to find, and that people playing with |
| numbers outside that range have a lot more to worry about than |
| just the capacity of the characteristic. |
| |
| A much more useful measure is the precision, which can be ex- |
| pressed in terms of the smallest number that can be added to |
| 1. without loss of significance. We calculate that here, for |
| float and double. */ |
| |
| one = 1.; |
| delta = 1.; |
| temp = 0.; |
| while(temp != one) { |
| temp = one+delta; |
| delta = delta/2.; |
| } |
| pd0->fprec = delta * 4.; |
| oned = 1.; |
| delta = 1.; |
| tempd = 0.; |
| while(tempd != oned) { |
| tempd = oned+delta; |
| delta = delta/2.; |
| } |
| pd0->dprec = delta * 4.; |
| |
| /* Now, if anyone's interested, we publish the results. */ |
| |
| if(pd0->flgm != 0) { |
| printf(s,pd0->cbits,"char"); |
| printf(s,pd0->ibits,"int"); |
| printf(s,pd0->sbits,"short"); |
| printf(s,pd0->lbits,"long"); |
| printf(s,pd0->ubits,"unsigned"); |
| printf(s,pd0->fbits,"float"); |
| printf(s,pd0->dbits,"double"); |
| printf(s2,pd0->fprec,"float"); |
| printf(s2,pd0->dprec,"double"); |
| } |
| /* Since we are only exploring and perhaps reporting, but not |
| testing any features, we cannot return an error code. */ |
| |
| return 0; |
| } |
| int extvar; |
| s4(pd0) /* 4. What's in a name? */ |
| struct defs *pd0; |
| { |
| static char s4er[] = "s4,er%d\n"; |
| static char qs4[8] = "s4 "; |
| char *ps, *pt; |
| int j, rc; |
| |
| short sint; /* short integer, for size test */ |
| int pint; /* plain */ |
| long lint; /* long */ |
| unsigned target; |
| unsigned int mask; |
| |
| rc = 0; |
| ps = qs4; |
| pt = pd0->rfs; |
| |
| while(*pt++ = *ps++); |
| |
| /* There are four declarable storage classes: automatic, |
| static, external, and register. Automatic variables have |
| been dealt with extensively thus far, and will not be specif- |
| ically treated in this section. Register variables are treated |
| in section s81. |
| |
| Static variables are local to a block, but retain their |
| values upon reentry to a block, even after control has left |
| the block. */ |
| |
| for (j=0; j<3; j++) |
| if(svtest(j) != zero()){ |
| rc = 1; |
| if(pd0->flgd != 0) printf(s4er,1); |
| } |
| ; |
| |
| /* External variables exist and retain their values throughout |
| the execution of the entire program, and may be used for comm- |
| unication between functions, even separately compiled functions. |
| */ |
| |
| setev(); |
| if(testev() != 0){ |
| rc=rc+2; |
| if(pd0->flgd != 0) printf(s4er,2); |
| } |
| /* |
| Characters have been tested elsewhere (in s243). |
| |
| Up to three sizes of integer, declared short int, int, and |
| long int, are available. Longer integers provide no less storage |
| than shorter ones, but implementation may make either short |
| integers, or long integers, or both, equivalent to plain |
| integers. |
| */ |
| |
| if(sizeof lint < sizeof pint || sizeof pint < sizeof sint){ |
| |
| rc = rc+4; |
| if(pd0->flgd != 0) printf(s4er,4); |
| } |
| |
| /* Unsigned integers, declared unsigned, obey the laws of |
| arithmetic modulo 2**n, where n is the number of bits in the |
| implementation */ |
| |
| target = ~0U; |
| mask = 1; |
| |
| for(j=0; j<(sizeof target)*pd0->cbits; j++){ |
| |
| mask = mask⌖ |
| target = target>>1; |
| } |
| |
| if(mask != 1 || target != 0){ |
| |
| rc = rc+8; |
| if(pd0->flgd != 0) printf(s4er,8); |
| } |
| |
| return rc; |
| } |
| svtest(n) |
| int n; |
| { |
| static k; |
| int rc; |
| switch (n) { |
| |
| case 0: k = 1978; |
| rc = 0; |
| break; |
| |
| case 1: if(k != 1978) rc = 1; |
| else{ |
| k = 1929; |
| rc = 0; |
| } |
| break; |
| |
| case 2: if(k != 1929) rc = 1; |
| else rc = 0; |
| break; |
| } |
| return rc; |
| } |
| zero(){ /* Returns a value of zero, possibly */ |
| static k; /* with side effects, as it's called */ |
| int rc; /* alternately with svtest, above, */ |
| k = 2; /* and has the same internal storage */ |
| rc = 0; /* requirements. */ |
| return rc; |
| } |
| testev(){ |
| if(extvar != 1066) return 1; |
| else return 0; |
| } |
| s61(pd0) /* Characters and integers */ |
| struct defs *pd0; |
| { |
| static char s61er[] = "s61,er%d\n"; |
| static char qs61[8] = "s61 "; |
| short from, shortint; |
| long int to, longint; |
| int rc, lrc; |
| int j; |
| char fromc, charint; |
| char *wd, *pc[6]; |
| |
| static char upper_alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; |
| static char lower_alpha[] = "abcdefghijklmnopqrstuvwxyz"; |
| static char numbers[] = "0123456789"; |
| static char special_characters[] = "~!\"#%&()_=-^|{}[]+;*:<>,.?/"; |
| static char extra_special_characters[] = "\n\t\b\r\f\\\'"; |
| static char blank_and_NUL[] = " \0"; |
| |
| char *ps, *pt; |
| ps = qs61; |
| pt = pd0->rfs; |
| rc = 0; |
| while (*pt++ = *ps++); |
| |
| /* A character or a short integer may be used wherever |
| an integer may be used. In all cases, the value is converted |
| to integer. This principle is extensively used throughout this |
| program, and will not be explicitly tested here. */ |
| |
| /* Conversion of a shorter integer to a longer always |
| involves sign extension. */ |
| |
| from = -19; |
| to = from; |
| |
| if(to != -19){ |
| rc = rc+1; |
| if(pd0->flgd != 0) printf(s61er,1); |
| } |
| |
| /* It is guaranteed that a member of the standard char- |
| acter set is nonnegative. */ |
| |
| pc[0] = upper_alpha; |
| pc[1] = lower_alpha; |
| pc[2] = numbers; |
| pc[3] = special_characters; |
| pc[4] = extra_special_characters; |
| pc[5] = blank_and_NUL; |
| |
| lrc = 0; |
| for (j=0; j<6; j++) |
| while(*pc[j]) if(*pc[j]++ < 0) lrc =1; |
| |
| if(lrc != 0){ |
| rc=rc+2; |
| if(pd0->flgd != 0) printf(s61er,2); |
| } |
| |
| /* When a longer integer is converted to a shorter or |
| to a char, it is truncated on the left; excess bits are |
| simply discarded. */ |
| |
| longint = 1048579; /* =2**20+3 */ |
| shortint = longint; |
| charint = longint; |
| |
| if((shortint != longint && shortint != 3) || |
| (charint != longint && charint != 3)) { |
| rc = rc+8; |
| if(pd0->flgd != 0) printf(s61er,8); |
| } |
| |
| return rc; |
| } |
| s626(pd0) /* 6.2 Float and double */ |
| /* 6.3 Floating and integral */ |
| /* 6.4 Pointers and integers */ |
| /* 6.5 Unsigned */ |
| /* 6.6 Arithmetic conversions */ |
| struct defs *pd0; |
| { |
| static char s626er[] = "s626,er%d\n"; |
| static char qs626[8] = "s626 "; |
| int rc; |
| char *ps, *pt; |
| float eps, f1, f2, f3, f4, f; |
| long lint1, lint2, l, ls; |
| char c, t[28], t0; |
| short s; |
| int is, i, j; |
| unsigned u, us; |
| double d, ds; |
| ps = qs626; |
| pt = pd0->rfs; |
| rc = 0; |
| while (*pt++ = *ps++); |
| |
| /* Conversions of integral values to floating type are |
| well-behaved. */ |
| |
| f1 = 1.; |
| lint1 = 1.; |
| lint2 = 1.; |
| |
| for(j=0;j<pd0->lbits-2;j++){ |
| f1 = f1*2; |
| lint2 = (lint2<<1)|lint1; |
| } |
| f2 = lint2; |
| f1 = (f1-f2)/f1; |
| if(f1>2.*pd0->fprec){ |
| |
| rc = rc+2; |
| if(pd0->flgd != 0) printf(s626er,2); |
| } |
| |
| /* Pointer-integer combinations are discussed in s74, |
| "Additive operators". The unsigned-int combination |
| appears below. */ |
| |
| c = 125; |
| s = 125; |
| i = 125; is = 15625; |
| u = 125; us = 15625; |
| l = 125; ls = 15625; |
| f = 125.; |
| d = 125.; ds = 15625.; |
| |
| for(j=0;j<28;j++) t[j] = 0; |
| |
| if(c*c != is) t[ 0] = 1; |
| if(s*c != is) t[ 1] = 1; |
| if(s*s != is) t[ 2] = 1; |
| if(i*c != is) t[ 3] = 1; |
| if(i*s != is) t[ 4] = 1; |
| if(i*i != is) t[ 5] = 1; |
| if(u*c != us) t[ 6] = 1; |
| if(u*s != us) t[ 7] = 1; |
| if(u*i != us) t[ 8] = 1; |
| if(u*u != us) t[ 9] = 1; |
| if(l*c != ls) t[10] = 1; |
| if(l*s != ls) t[11] = 1; |
| if(l*i != ls) t[12] = 1; |
| if(l*u != us) t[13] = 1; |
| if(l*l != ls) t[14] = 1; |
| if(f*c != ds) t[15] = 1; |
| if(f*s != ds) t[16] = 1; |
| if(f*i != ds) t[17] = 1; |
| if(f*u != ds) t[18] = 1; |
| if(f*l != ds) t[19] = 1; |
| if(f*f != ds) t[20] = 1; |
| if(d*c != ds) t[21] = 1; |
| if(d*s != ds) t[22] = 1; |
| if(d*i != ds) t[23] = 1; |
| if(d*u != ds) t[24] = 1; |
| if(d*l != ds) t[25] = 1; |
| if(d*f != ds) t[26] = 1; |
| if(d*d != ds) t[27] = 1; |
| |
| t0 = 0; |
| for(j=0; j<28; j++) t0 = t0+t[j]; |
| |
| if(t0 != 0){ |
| |
| rc = rc+4; |
| if(pd0->flgd != 0){ |
| |
| printf(s626er,4); |
| printf(" key="); |
| for(j=0;j<28;j++) printf("%d",t[j]); |
| printf("\n"); |
| } |
| } |
| |
| /* When an unsigned integer is converted to long, |
| the value of the result is the same numerically |
| as that of the unsigned integer. */ |
| |
| l = (unsigned)0100000; |
| if((long)l > (unsigned)0100000){ |
| |
| rc = rc+8; |
| if(pd0->flgd != 0) printf(s626er,8); |
| } |
| |
| return rc; |
| } |
| s71(pd0) /* 7.1 Primary expressions */ |
| struct defs *pd0; |
| { |
| static char s71er[] = "s71,er%d\n"; |
| static char qs71[8] = "s71 "; |
| int rc; |
| char *ps, *pt; |
| static char q = 'q'; |
| int x[10], McCarthy(), clobber(), a, b, *p; |
| ps = qs71; |
| pt = pd0->rfs; |
| rc = 0; |
| while (*pt++ = *ps++); |
| |
| /* Testing of expressions and operators is quite complicated, |
| because (a) problems are apt to surface in queer combinations |
| of operators and operands, rather than in isolation, |
| and (b) the number of expressions needed to provoke a case |
| of improper behaviour may be quite large. Hence, we take the |
| following approach: for this section, and for subsequent |
| sections through 7.15, we will check the primitive operations |
| in isolation, thus verifying that the primitives work, |
| after a fashion. The job of testing combinations, we will |
| leave to a separate, machine-generated program, to be included |
| in the C test package at some later date. |
| */ |
| |
| /* A string is a primary expression. The identifier points to |
| the first character of a string. |
| */ |
| |
| if(*"queep" != q){ |
| rc = rc+1; |
| if(pd0->flgd != 0) printf(s71er,1); |
| } |
| /* A parenthesized expression is a primary expression whose |
| type and value are the same as those of the unadorned |
| expression. |
| */ |
| if((2+3) != 2+3) { |
| rc = rc+2; |
| if(pd0->flgd != 0) printf(s71er,2); |
| } |
| |
| /* A primary expression followed by an expression in square |
| brackets is a primary expression. The intuitive meaning is |
| that of a subscript. The expression E1[E2] is identical |
| (by definition) to *((E1)+(E2)). |
| */ |
| |
| x[5] = 1942; |
| if(x[5] != 1942 || x[5] != *((x)+(5))){ |
| rc = rc+4; |
| if(pd0->flgd != 0) printf(s71er,4); |
| } |
| |
| /* If the various flavors of function calls didn't work, we |
| would never have gotten this far; however, we do need to |
| show that functions can be recursive... |
| */ |
| |
| if ( McCarthy(-5) != 91){ |
| rc = rc+8; |
| if(pd0->flgd != 0) printf(s71er,8); |
| } |
| |
| /* and that argument passing is strictly by value. */ |
| |
| a = 2; |
| b = 3; |
| p = &b; |
| |
| clobber(a,p); |
| |
| if(a != 2 || b != 2){ |
| rc = rc+16; |
| if(pd0->flgd != 0) printf(s71er,16); |
| } |
| |
| /* Finally, structures and unions are addressed thusly: */ |
| |
| if(pd0->dprec != (*pd0).dprec){ |
| rc = rc+32; |
| if(pd0->flgd != 0) printf(s71er,32); |
| } |
| |
| return rc; |
| } |
| McCarthy(x) |
| int x; |
| { |
| if(x>100) return x-10; |
| else return McCarthy( McCarthy(x+11)); |
| } |
| clobber(x,y) |
| int x, *y; |
| { |
| x = 3; |
| *y = 2; |
| } |
| s714(pd0) /* 7.14 Assignment operators */ |
| struct defs *pd0; |
| { |
| static char f[] = "Local error %d.\n"; |
| static char s714er[] = "s714,er%d\n"; |
| static char qs714[8] = "s714 "; |
| register int prlc, lrc; |
| int rc; |
| char cl, cr; |
| short sl, sr; |
| int il, ir; |
| long ll, lr; |
| unsigned ul, ur; |
| float fl, fr; |
| double dl, dr; |
| char *ps, *pt; |
| ps = qs714; |
| pt = pd0->rfs; |
| rc = 0; |
| lrc = 0; |
| prlc = pd0->flgl; |
| while (*pt++ = *ps++); |
| |
| /* This section tests the assignment operators. |
| |
| It is an exhaustive test of all assignment statements |
| of the form: |
| |
| vl op vr |
| |
| where vl and vr are variables from the set |
| {char,short,int,long,unsigned,float,double} and op is |
| one of the assignment operators. There are 395 such |
| statements. |
| |
| The initial values for the variables have been chosen |
| so that both the initial values and the results will |
| "fit" in just about any implementation, and that the re- |
| sults will be such that they test for the proper form- |
| ation of composite operators, rather than checking for |
| the valid operation of those operators' components. |
| For example, in checking >>=, we want to verify that |
| a right shift and a move take place, rather than |
| whether or not there may be some peculiarities about |
| the right shift. Such tests have been made previously, |
| and to repeat them here would be to throw out a red |
| herring. |
| |
| The table below lists the operators, assignment targets, |
| initial values for left and right operands, and the |
| expected values of the results. |
| |
| |
| = += -= *= /= %= >>= <<= &= ^= |= |
| char 2 7 3 10 2 1 1 20 8 6 14 |
| short 2 7 3 10 2 1 1 20 8 6 14 |
| int 2 7 3 10 2 1 1 20 8 6 14 |
| long 2 7 3 10 2 1 1 20 8 6 14 |
| unsigned 2 7 3 10 2 1 1 20 8 6 14 |
| float 2 7 3 10 2.5 | | |
| double 2 7 3 10 2.5 | | |
| | | |
| initial (5,2) | (5,2) | (12,10) |
| |
| The following machine-generated program reflects the |
| tests described in the table. |
| */ |
| |
| cl = 5; cr = 2; |
| cl = cr; |
| if(cl != 2){ |
| lrc = 1; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; sr = 2; |
| cl = sr; |
| if(cl != 2){ |
| lrc = 2; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ir = 2; |
| cl = ir; |
| if(cl != 2){ |
| lrc = 3; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; lr = 2; |
| cl = lr; |
| if(cl != 2){ |
| lrc = 4; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ur = 2; |
| cl = ur; |
| if(cl != 2){ |
| lrc = 5; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; fr = 2; |
| cl = fr; |
| if(cl != 2){ |
| lrc = 6; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; dr = 2; |
| cl = dr; |
| if(cl != 2){ |
| lrc = 7; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; cr = 2; |
| sl = cr; |
| if(sl != 2){ |
| lrc = 8; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; sr = 2; |
| sl = sr; |
| if(sl != 2){ |
| lrc = 9; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ir = 2; |
| sl = ir; |
| if(sl != 2){ |
| lrc = 10; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; lr = 2; |
| sl = lr; |
| if(sl != 2){ |
| lrc = 11; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ur = 2; |
| sl = ur; |
| if(sl != 2){ |
| lrc = 12; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; fr = 2; |
| sl = fr; |
| if(sl != 2){ |
| lrc = 13; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; dr = 2; |
| sl = dr; |
| if(sl != 2){ |
| lrc = 14; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; cr = 2; |
| il = cr; |
| if(il != 2){ |
| lrc = 15; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; sr = 2; |
| il = sr; |
| if(il != 2){ |
| lrc = 16; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ir = 2; |
| il = ir; |
| if(il != 2){ |
| lrc = 17; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; lr = 2; |
| il = lr; |
| if(il != 2){ |
| lrc = 18; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ur = 2; |
| il = ur; |
| if(il != 2){ |
| lrc = 19; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; fr = 2; |
| il = fr; |
| if(il != 2){ |
| lrc = 20; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; dr = 2; |
| il = dr; |
| if(il != 2){ |
| lrc = 21; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; cr = 2; |
| ll = cr; |
| if(ll != 2){ |
| lrc = 22; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; sr = 2; |
| ll = sr; |
| if(ll != 2){ |
| lrc = 23; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ir = 2; |
| ll = ir; |
| if(ll != 2){ |
| lrc = 24; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; lr = 2; |
| ll = lr; |
| if(ll != 2){ |
| lrc = 25; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ur = 2; |
| ll = ur; |
| if(ll != 2){ |
| lrc = 26; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; fr = 2; |
| ll = fr; |
| if(ll != 2){ |
| lrc = 27; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; dr = 2; |
| ll = dr; |
| if(ll != 2){ |
| lrc = 28; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; cr = 2; |
| ul = cr; |
| if(ul != 2){ |
| lrc = 29; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; sr = 2; |
| ul = sr; |
| if(ul != 2){ |
| lrc = 30; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ir = 2; |
| ul = ir; |
| if(ul != 2){ |
| lrc = 31; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; lr = 2; |
| ul = lr; |
| if(ul != 2){ |
| lrc = 32; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ur = 2; |
| ul = ur; |
| if(ul != 2){ |
| lrc = 33; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; fr = 2; |
| ul = fr; |
| if(ul != 2){ |
| lrc = 34; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; dr = 2; |
| ul = dr; |
| if(ul != 2){ |
| lrc = 35; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; cr = 2; |
| fl = cr; |
| if(fl != 2){ |
| lrc = 36; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; sr = 2; |
| fl = sr; |
| if(fl != 2){ |
| lrc = 37; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; ir = 2; |
| fl = ir; |
| if(fl != 2){ |
| lrc = 38; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; lr = 2; |
| fl = lr; |
| if(fl != 2){ |
| lrc = 39; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; ur = 2; |
| fl = ur; |
| if(fl != 2){ |
| lrc = 40; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; fr = 2; |
| fl = fr; |
| if(fl != 2){ |
| lrc = 41; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; dr = 2; |
| fl = dr; |
| if(fl != 2){ |
| lrc = 42; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; cr = 2; |
| dl = cr; |
| if(dl != 2){ |
| lrc = 43; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; sr = 2; |
| dl = sr; |
| if(dl != 2){ |
| lrc = 44; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; ir = 2; |
| dl = ir; |
| if(dl != 2){ |
| lrc = 45; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; lr = 2; |
| dl = lr; |
| if(dl != 2){ |
| lrc = 46; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; ur = 2; |
| dl = ur; |
| if(dl != 2){ |
| lrc = 47; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; fr = 2; |
| dl = fr; |
| if(dl != 2){ |
| lrc = 48; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; dr = 2; |
| dl = dr; |
| if(dl != 2){ |
| lrc = 49; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; cr = 2; |
| cl += cr; |
| if(cl != 7){ |
| lrc = 50; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; sr = 2; |
| cl += sr; |
| if(cl != 7){ |
| lrc = 51; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ir = 2; |
| cl += ir; |
| if(cl != 7){ |
| lrc = 52; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; lr = 2; |
| cl += lr; |
| if(cl != 7){ |
| lrc = 53; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ur = 2; |
| cl += ur; |
| if(cl != 7){ |
| lrc = 54; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; fr = 2; |
| cl += fr; |
| if(cl != 7){ |
| lrc = 55; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; dr = 2; |
| cl += dr; |
| if(cl != 7){ |
| lrc = 56; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; cr = 2; |
| sl += cr; |
| if(sl != 7){ |
| lrc = 57; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; sr = 2; |
| sl += sr; |
| if(sl != 7){ |
| lrc = 58; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ir = 2; |
| sl += ir; |
| if(sl != 7){ |
| lrc = 59; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; lr = 2; |
| sl += lr; |
| if(sl != 7){ |
| lrc = 60; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ur = 2; |
| sl += ur; |
| if(sl != 7){ |
| lrc = 61; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; fr = 2; |
| sl += fr; |
| if(sl != 7){ |
| lrc = 62; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; dr = 2; |
| sl += dr; |
| if(sl != 7){ |
| lrc = 63; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; cr = 2; |
| il += cr; |
| if(il != 7){ |
| lrc = 64; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; sr = 2; |
| il += sr; |
| if(il != 7){ |
| lrc = 65; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ir = 2; |
| il += ir; |
| if(il != 7){ |
| lrc = 66; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; lr = 2; |
| il += lr; |
| if(il != 7){ |
| lrc = 67; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ur = 2; |
| il += ur; |
| if(il != 7){ |
| lrc = 68; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; fr = 2; |
| il += fr; |
| if(il != 7){ |
| lrc = 69; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; dr = 2; |
| il += dr; |
| if(il != 7){ |
| lrc = 70; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; cr = 2; |
| ll += cr; |
| if(ll != 7){ |
| lrc = 71; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; sr = 2; |
| ll += sr; |
| if(ll != 7){ |
| lrc = 72; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ir = 2; |
| ll += ir; |
| if(ll != 7){ |
| lrc = 73; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; lr = 2; |
| ll += lr; |
| if(ll != 7){ |
| lrc = 74; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ur = 2; |
| ll += ur; |
| if(ll != 7){ |
| lrc = 75; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; fr = 2; |
| ll += fr; |
| if(ll != 7){ |
| lrc = 76; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; dr = 2; |
| ll += dr; |
| if(ll != 7){ |
| lrc = 77; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; cr = 2; |
| ul += cr; |
| if(ul != 7){ |
| lrc = 78; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; sr = 2; |
| ul += sr; |
| if(ul != 7){ |
| lrc = 79; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ir = 2; |
| ul += ir; |
| if(ul != 7){ |
| lrc = 80; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; lr = 2; |
| ul += lr; |
| if(ul != 7){ |
| lrc = 81; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ur = 2; |
| ul += ur; |
| if(ul != 7){ |
| lrc = 82; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; fr = 2; |
| ul += fr; |
| if(ul != 7){ |
| lrc = 83; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; dr = 2; |
| ul += dr; |
| if(ul != 7){ |
| lrc = 84; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; cr = 2; |
| fl += cr; |
| if(fl != 7){ |
| lrc = 85; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; sr = 2; |
| fl += sr; |
| if(fl != 7){ |
| lrc = 86; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; ir = 2; |
| fl += ir; |
| if(fl != 7){ |
| lrc = 87; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; lr = 2; |
| fl += lr; |
| if(fl != 7){ |
| lrc = 88; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; ur = 2; |
| fl += ur; |
| if(fl != 7){ |
| lrc = 89; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; fr = 2; |
| fl += fr; |
| if(fl != 7){ |
| lrc = 90; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; dr = 2; |
| fl += dr; |
| if(fl != 7){ |
| lrc = 91; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; cr = 2; |
| dl += cr; |
| if(dl != 7){ |
| lrc = 92; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; sr = 2; |
| dl += sr; |
| if(dl != 7){ |
| lrc = 93; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; ir = 2; |
| dl += ir; |
| if(dl != 7){ |
| lrc = 94; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; lr = 2; |
| dl += lr; |
| if(dl != 7){ |
| lrc = 95; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; ur = 2; |
| dl += ur; |
| if(dl != 7){ |
| lrc = 96; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; fr = 2; |
| dl += fr; |
| if(dl != 7){ |
| lrc = 97; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; dr = 2; |
| dl += dr; |
| if(dl != 7){ |
| lrc = 98; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; cr = 2; |
| cl -= cr; |
| if(cl != 3){ |
| lrc = 99; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; sr = 2; |
| cl -= sr; |
| if(cl != 3){ |
| lrc = 100; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ir = 2; |
| cl -= ir; |
| if(cl != 3){ |
| lrc = 101; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; lr = 2; |
| cl -= lr; |
| if(cl != 3){ |
| lrc = 102; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ur = 2; |
| cl -= ur; |
| if(cl != 3){ |
| lrc = 103; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; fr = 2; |
| cl -= fr; |
| if(cl != 3){ |
| lrc = 104; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; dr = 2; |
| cl -= dr; |
| if(cl != 3){ |
| lrc = 105; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; cr = 2; |
| sl -= cr; |
| if(sl != 3){ |
| lrc = 106; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; sr = 2; |
| sl -= sr; |
| if(sl != 3){ |
| lrc = 107; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ir = 2; |
| sl -= ir; |
| if(sl != 3){ |
| lrc = 108; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; lr = 2; |
| sl -= lr; |
| if(sl != 3){ |
| lrc = 109; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ur = 2; |
| sl -= ur; |
| if(sl != 3){ |
| lrc = 110; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; fr = 2; |
| sl -= fr; |
| if(sl != 3){ |
| lrc = 111; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; dr = 2; |
| sl -= dr; |
| if(sl != 3){ |
| lrc = 112; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; cr = 2; |
| il -= cr; |
| if(il != 3){ |
| lrc = 113; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; sr = 2; |
| il -= sr; |
| if(il != 3){ |
| lrc = 114; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ir = 2; |
| il -= ir; |
| if(il != 3){ |
| lrc = 115; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; lr = 2; |
| il -= lr; |
| if(il != 3){ |
| lrc = 116; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ur = 2; |
| il -= ur; |
| if(il != 3){ |
| lrc = 117; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; fr = 2; |
| il -= fr; |
| if(il != 3){ |
| lrc = 118; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; dr = 2; |
| il -= dr; |
| if(il != 3){ |
| lrc = 119; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; cr = 2; |
| ll -= cr; |
| if(ll != 3){ |
| lrc = 120; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; sr = 2; |
| ll -= sr; |
| if(ll != 3){ |
| lrc = 121; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ir = 2; |
| ll -= ir; |
| if(ll != 3){ |
| lrc = 122; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; lr = 2; |
| ll -= lr; |
| if(ll != 3){ |
| lrc = 123; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ur = 2; |
| ll -= ur; |
| if(ll != 3){ |
| lrc = 124; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; fr = 2; |
| ll -= fr; |
| if(ll != 3){ |
| lrc = 125; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; dr = 2; |
| ll -= dr; |
| if(ll != 3){ |
| lrc = 126; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; cr = 2; |
| ul -= cr; |
| if(ul != 3){ |
| lrc = 127; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; sr = 2; |
| ul -= sr; |
| if(ul != 3){ |
| lrc = 128; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ir = 2; |
| ul -= ir; |
| if(ul != 3){ |
| lrc = 129; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; lr = 2; |
| ul -= lr; |
| if(ul != 3){ |
| lrc = 130; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ur = 2; |
| ul -= ur; |
| if(ul != 3){ |
| lrc = 131; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; fr = 2; |
| ul -= fr; |
| if(ul != 3){ |
| lrc = 132; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; dr = 2; |
| ul -= dr; |
| if(ul != 3){ |
| lrc = 133; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; cr = 2; |
| fl -= cr; |
| if(fl != 3){ |
| lrc = 134; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; sr = 2; |
| fl -= sr; |
| if(fl != 3){ |
| lrc = 135; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; ir = 2; |
| fl -= ir; |
| if(fl != 3){ |
| lrc = 136; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; lr = 2; |
| fl -= lr; |
| if(fl != 3){ |
| lrc = 137; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; ur = 2; |
| fl -= ur; |
| if(fl != 3){ |
| lrc = 138; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; fr = 2; |
| fl -= fr; |
| if(fl != 3){ |
| lrc = 139; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; dr = 2; |
| fl -= dr; |
| if(fl != 3){ |
| lrc = 140; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; cr = 2; |
| dl -= cr; |
| if(dl != 3){ |
| lrc = 141; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; sr = 2; |
| dl -= sr; |
| if(dl != 3){ |
| lrc = 142; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; ir = 2; |
| dl -= ir; |
| if(dl != 3){ |
| lrc = 143; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; lr = 2; |
| dl -= lr; |
| if(dl != 3){ |
| lrc = 144; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; ur = 2; |
| dl -= ur; |
| if(dl != 3){ |
| lrc = 145; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; fr = 2; |
| dl -= fr; |
| if(dl != 3){ |
| lrc = 146; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; dr = 2; |
| dl -= dr; |
| if(dl != 3){ |
| lrc = 147; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; cr = 2; |
| cl *= cr; |
| if(cl != 10){ |
| lrc = 148; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; sr = 2; |
| cl *= sr; |
| if(cl != 10){ |
| lrc = 149; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ir = 2; |
| cl *= ir; |
| if(cl != 10){ |
| lrc = 150; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; lr = 2; |
| cl *= lr; |
| if(cl != 10){ |
| lrc = 151; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ur = 2; |
| cl *= ur; |
| if(cl != 10){ |
| lrc = 152; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; fr = 2; |
| cl *= fr; |
| if(cl != 10){ |
| lrc = 153; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; dr = 2; |
| cl *= dr; |
| if(cl != 10){ |
| lrc = 154; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; cr = 2; |
| sl *= cr; |
| if(sl != 10){ |
| lrc = 155; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; sr = 2; |
| sl *= sr; |
| if(sl != 10){ |
| lrc = 156; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ir = 2; |
| sl *= ir; |
| if(sl != 10){ |
| lrc = 157; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; lr = 2; |
| sl *= lr; |
| if(sl != 10){ |
| lrc = 158; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ur = 2; |
| sl *= ur; |
| if(sl != 10){ |
| lrc = 159; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; fr = 2; |
| sl *= fr; |
| if(sl != 10){ |
| lrc = 160; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; dr = 2; |
| sl *= dr; |
| if(sl != 10){ |
| lrc = 161; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; cr = 2; |
| il *= cr; |
| if(il != 10){ |
| lrc = 162; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; sr = 2; |
| il *= sr; |
| if(il != 10){ |
| lrc = 163; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ir = 2; |
| il *= ir; |
| if(il != 10){ |
| lrc = 164; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; lr = 2; |
| il *= lr; |
| if(il != 10){ |
| lrc = 165; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ur = 2; |
| il *= ur; |
| if(il != 10){ |
| lrc = 166; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; fr = 2; |
| il *= fr; |
| if(il != 10){ |
| lrc = 167; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; dr = 2; |
| il *= dr; |
| if(il != 10){ |
| lrc = 168; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; cr = 2; |
| ll *= cr; |
| if(ll != 10){ |
| lrc = 169; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; sr = 2; |
| ll *= sr; |
| if(ll != 10){ |
| lrc = 170; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ir = 2; |
| ll *= ir; |
| if(ll != 10){ |
| lrc = 171; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; lr = 2; |
| ll *= lr; |
| if(ll != 10){ |
| lrc = 172; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ur = 2; |
| ll *= ur; |
| if(ll != 10){ |
| lrc = 173; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; fr = 2; |
| ll *= fr; |
| if(ll != 10){ |
| lrc = 174; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; dr = 2; |
| ll *= dr; |
| if(ll != 10){ |
| lrc = 175; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; cr = 2; |
| ul *= cr; |
| if(ul != 10){ |
| lrc = 176; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; sr = 2; |
| ul *= sr; |
| if(ul != 10){ |
| lrc = 177; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ir = 2; |
| ul *= ir; |
| if(ul != 10){ |
| lrc = 178; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; lr = 2; |
| ul *= lr; |
| if(ul != 10){ |
| lrc = 179; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ur = 2; |
| ul *= ur; |
| if(ul != 10){ |
| lrc = 180; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; fr = 2; |
| ul *= fr; |
| if(ul != 10){ |
| lrc = 181; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; dr = 2; |
| ul *= dr; |
| if(ul != 10){ |
| lrc = 182; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; cr = 2; |
| fl *= cr; |
| if(fl != 10){ |
| lrc = 183; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; sr = 2; |
| fl *= sr; |
| if(fl != 10){ |
| lrc = 184; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; ir = 2; |
| fl *= ir; |
| if(fl != 10){ |
| lrc = 185; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; lr = 2; |
| fl *= lr; |
| if(fl != 10){ |
| lrc = 186; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; ur = 2; |
| fl *= ur; |
| if(fl != 10){ |
| lrc = 187; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; fr = 2; |
| fl *= fr; |
| if(fl != 10){ |
| lrc = 188; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; dr = 2; |
| fl *= dr; |
| if(fl != 10){ |
| lrc = 189; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; cr = 2; |
| dl *= cr; |
| if(dl != 10){ |
| lrc = 190; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; sr = 2; |
| dl *= sr; |
| if(dl != 10){ |
| lrc = 191; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; ir = 2; |
| dl *= ir; |
| if(dl != 10){ |
| lrc = 192; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; lr = 2; |
| dl *= lr; |
| if(dl != 10){ |
| lrc = 193; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; ur = 2; |
| dl *= ur; |
| if(dl != 10){ |
| lrc = 194; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; fr = 2; |
| dl *= fr; |
| if(dl != 10){ |
| lrc = 195; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; dr = 2; |
| dl *= dr; |
| if(dl != 10){ |
| lrc = 196; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; cr = 2; |
| cl /= cr; |
| if(cl != 2){ |
| lrc = 197; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; sr = 2; |
| cl /= sr; |
| if(cl != 2){ |
| lrc = 198; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ir = 2; |
| cl /= ir; |
| if(cl != 2){ |
| lrc = 199; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; lr = 2; |
| cl /= lr; |
| if(cl != 2){ |
| lrc = 200; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ur = 2; |
| cl /= ur; |
| if(cl != 2){ |
| lrc = 201; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; fr = 2; |
| cl /= fr; |
| if(cl != 2){ |
| lrc = 202; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; dr = 2; |
| cl /= dr; |
| if(cl != 2){ |
| lrc = 203; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; cr = 2; |
| sl /= cr; |
| if(sl != 2){ |
| lrc = 204; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; sr = 2; |
| sl /= sr; |
| if(sl != 2){ |
| lrc = 205; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ir = 2; |
| sl /= ir; |
| if(sl != 2){ |
| lrc = 206; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; lr = 2; |
| sl /= lr; |
| if(sl != 2){ |
| lrc = 207; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ur = 2; |
| sl /= ur; |
| if(sl != 2){ |
| lrc = 208; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; fr = 2; |
| sl /= fr; |
| if(sl != 2){ |
| lrc = 209; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; dr = 2; |
| sl /= dr; |
| if(sl != 2){ |
| lrc = 210; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; cr = 2; |
| il /= cr; |
| if(il != 2){ |
| lrc = 211; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; sr = 2; |
| il /= sr; |
| if(il != 2){ |
| lrc = 212; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ir = 2; |
| il /= ir; |
| if(il != 2){ |
| lrc = 213; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; lr = 2; |
| il /= lr; |
| if(il != 2){ |
| lrc = 214; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ur = 2; |
| il /= ur; |
| if(il != 2){ |
| lrc = 215; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; fr = 2; |
| il /= fr; |
| if(il != 2){ |
| lrc = 216; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; dr = 2; |
| il /= dr; |
| if(il != 2){ |
| lrc = 217; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; cr = 2; |
| ll /= cr; |
| if(ll != 2){ |
| lrc = 218; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; sr = 2; |
| ll /= sr; |
| if(ll != 2){ |
| lrc = 219; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ir = 2; |
| ll /= ir; |
| if(ll != 2){ |
| lrc = 220; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; lr = 2; |
| ll /= lr; |
| if(ll != 2){ |
| lrc = 221; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ur = 2; |
| ll /= ur; |
| if(ll != 2){ |
| lrc = 222; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; fr = 2; |
| ll /= fr; |
| if(ll != 2){ |
| lrc = 223; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; dr = 2; |
| ll /= dr; |
| if(ll != 2){ |
| lrc = 224; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; cr = 2; |
| ul /= cr; |
| if(ul != 2){ |
| lrc = 225; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; sr = 2; |
| ul /= sr; |
| if(ul != 2){ |
| lrc = 226; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ir = 2; |
| ul /= ir; |
| if(ul != 2){ |
| lrc = 227; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; lr = 2; |
| ul /= lr; |
| if(ul != 2){ |
| lrc = 228; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ur = 2; |
| ul /= ur; |
| if(ul != 2){ |
| lrc = 229; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; fr = 2; |
| ul /= fr; |
| if(ul != 2){ |
| lrc = 230; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; dr = 2; |
| ul /= dr; |
| if(ul != 2){ |
| lrc = 231; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; cr = 2; |
| fl /= cr; |
| if(fl != 2.5){ |
| lrc = 232; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; sr = 2; |
| fl /= sr; |
| if(fl != 2.5){ |
| lrc = 233; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; ir = 2; |
| fl /= ir; |
| if(fl != 2.5){ |
| lrc = 234; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; lr = 2; |
| fl /= lr; |
| if(fl != 2.5){ |
| lrc = 235; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; ur = 2; |
| fl /= ur; |
| if(fl != 2.5){ |
| lrc = 236; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; fr = 2; |
| fl /= fr; |
| if(fl != 2.5){ |
| lrc = 237; |
| if(prlc) printf(f,lrc); |
| } |
| fl = 5; dr = 2; |
| fl /= dr; |
| if(fl != 2.5){ |
| lrc = 238; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; cr = 2; |
| dl /= cr; |
| if(dl != 2.5){ |
| lrc = 239; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; sr = 2; |
| dl /= sr; |
| if(dl != 2.5){ |
| lrc = 240; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; ir = 2; |
| dl /= ir; |
| if(dl != 2.5){ |
| lrc = 241; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; lr = 2; |
| dl /= lr; |
| if(dl != 2.5){ |
| lrc = 242; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; ur = 2; |
| dl /= ur; |
| if(dl != 2.5){ |
| lrc = 243; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; fr = 2; |
| dl /= fr; |
| if(dl != 2.5){ |
| lrc = 244; |
| if(prlc) printf(f,lrc); |
| } |
| dl = 5; dr = 2; |
| dl /= dr; |
| if(dl != 2.5){ |
| lrc = 245; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; cr = 2; |
| cl %= cr; |
| if(cl != 1){ |
| lrc = 246; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; sr = 2; |
| cl %= sr; |
| if(cl != 1){ |
| lrc = 247; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ir = 2; |
| cl %= ir; |
| if(cl != 1){ |
| lrc = 248; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; lr = 2; |
| cl %= lr; |
| if(cl != 1){ |
| lrc = 249; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ur = 2; |
| cl %= ur; |
| if(cl != 1){ |
| lrc = 250; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; cr = 2; |
| sl %= cr; |
| if(sl != 1){ |
| lrc = 251; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; sr = 2; |
| sl %= sr; |
| if(sl != 1){ |
| lrc = 252; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ir = 2; |
| sl %= ir; |
| if(sl != 1){ |
| lrc = 253; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; lr = 2; |
| sl %= lr; |
| if(sl != 1){ |
| lrc = 254; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ur = 2; |
| sl %= ur; |
| if(sl != 1){ |
| lrc = 255; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; cr = 2; |
| il %= cr; |
| if(il != 1){ |
| lrc = 256; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; sr = 2; |
| il %= sr; |
| if(il != 1){ |
| lrc = 257; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ir = 2; |
| il %= ir; |
| if(il != 1){ |
| lrc = 258; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; lr = 2; |
| il %= lr; |
| if(il != 1){ |
| lrc = 259; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ur = 2; |
| il %= ur; |
| if(il != 1){ |
| lrc = 260; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; cr = 2; |
| ll %= cr; |
| if(ll != 1){ |
| lrc = 261; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; sr = 2; |
| ll %= sr; |
| if(ll != 1){ |
| lrc = 262; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ir = 2; |
| ll %= ir; |
| if(ll != 1){ |
| lrc = 263; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; lr = 2; |
| ll %= lr; |
| if(ll != 1){ |
| lrc = 264; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ur = 2; |
| ll %= ur; |
| if(ll != 1){ |
| lrc = 265; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; cr = 2; |
| ul %= cr; |
| if(ul != 1){ |
| lrc = 266; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; sr = 2; |
| ul %= sr; |
| if(ul != 1){ |
| lrc = 267; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ir = 2; |
| ul %= ir; |
| if(ul != 1){ |
| lrc = 268; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; lr = 2; |
| ul %= lr; |
| if(ul != 1){ |
| lrc = 269; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ur = 2; |
| ul %= ur; |
| if(ul != 1){ |
| lrc = 270; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; cr = 2; |
| cl >>= cr; |
| if(cl != 1){ |
| lrc = 271; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; sr = 2; |
| cl >>= sr; |
| if(cl != 1){ |
| lrc = 272; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ir = 2; |
| cl >>= ir; |
| if(cl != 1){ |
| lrc = 273; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; lr = 2; |
| cl >>= lr; |
| if(cl != 1){ |
| lrc = 274; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ur = 2; |
| cl >>= ur; |
| if(cl != 1){ |
| lrc = 275; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; cr = 2; |
| sl >>= cr; |
| if(sl != 1){ |
| lrc = 276; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; sr = 2; |
| sl >>= sr; |
| if(sl != 1){ |
| lrc = 277; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ir = 2; |
| sl >>= ir; |
| if(sl != 1){ |
| lrc = 278; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; lr = 2; |
| sl >>= lr; |
| if(sl != 1){ |
| lrc = 279; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ur = 2; |
| sl >>= ur; |
| if(sl != 1){ |
| lrc = 280; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; cr = 2; |
| il >>= cr; |
| if(il != 1){ |
| lrc = 281; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; sr = 2; |
| il >>= sr; |
| if(il != 1){ |
| lrc = 282; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ir = 2; |
| il >>= ir; |
| if(il != 1){ |
| lrc = 283; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; lr = 2; |
| il >>= lr; |
| if(il != 1){ |
| lrc = 284; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ur = 2; |
| il >>= ur; |
| if(il != 1){ |
| lrc = 285; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; cr = 2; |
| ll >>= cr; |
| if(ll != 1){ |
| lrc = 286; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; sr = 2; |
| ll >>= sr; |
| if(ll != 1){ |
| lrc = 287; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ir = 2; |
| ll >>= ir; |
| if(ll != 1){ |
| lrc = 288; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; lr = 2; |
| ll >>= lr; |
| if(ll != 1){ |
| lrc = 289; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ur = 2; |
| ll >>= ur; |
| if(ll != 1){ |
| lrc = 290; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; cr = 2; |
| ul >>= cr; |
| if(ul != 1){ |
| lrc = 291; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; sr = 2; |
| ul >>= sr; |
| if(ul != 1){ |
| lrc = 292; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ir = 2; |
| ul >>= ir; |
| if(ul != 1){ |
| lrc = 293; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; lr = 2; |
| ul >>= lr; |
| if(ul != 1){ |
| lrc = 294; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ur = 2; |
| ul >>= ur; |
| if(ul != 1){ |
| lrc = 295; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; cr = 2; |
| cl <<= cr; |
| if(cl != 20){ |
| lrc = 296; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; sr = 2; |
| cl <<= sr; |
| if(cl != 20){ |
| lrc = 297; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ir = 2; |
| cl <<= ir; |
| if(cl != 20){ |
| lrc = 298; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; lr = 2; |
| cl <<= lr; |
| if(cl != 20){ |
| lrc = 299; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 5; ur = 2; |
| cl <<= ur; |
| if(cl != 20){ |
| lrc = 300; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; cr = 2; |
| sl <<= cr; |
| if(sl != 20){ |
| lrc = 301; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; sr = 2; |
| sl <<= sr; |
| if(sl != 20){ |
| lrc = 302; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ir = 2; |
| sl <<= ir; |
| if(sl != 20){ |
| lrc = 303; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; lr = 2; |
| sl <<= lr; |
| if(sl != 20){ |
| lrc = 304; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 5; ur = 2; |
| sl <<= ur; |
| if(sl != 20){ |
| lrc = 305; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; cr = 2; |
| il <<= cr; |
| if(il != 20){ |
| lrc = 306; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; sr = 2; |
| il <<= sr; |
| if(il != 20){ |
| lrc = 307; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ir = 2; |
| il <<= ir; |
| if(il != 20){ |
| lrc = 308; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; lr = 2; |
| il <<= lr; |
| if(il != 20){ |
| lrc = 309; |
| if(prlc) printf(f,lrc); |
| } |
| il = 5; ur = 2; |
| il <<= ur; |
| if(il != 20){ |
| lrc = 310; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; cr = 2; |
| ll <<= cr; |
| if(ll != 20){ |
| lrc = 311; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; sr = 2; |
| ll <<= sr; |
| if(ll != 20){ |
| lrc = 312; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ir = 2; |
| ll <<= ir; |
| if(ll != 20){ |
| lrc = 313; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; lr = 2; |
| ll <<= lr; |
| if(ll != 20){ |
| lrc = 314; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 5; ur = 2; |
| ll <<= ur; |
| if(ll != 20){ |
| lrc = 315; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; cr = 2; |
| ul <<= cr; |
| if(ul != 20){ |
| lrc = 316; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; sr = 2; |
| ul <<= sr; |
| if(ul != 20){ |
| lrc = 317; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ir = 2; |
| ul <<= ir; |
| if(ul != 20){ |
| lrc = 318; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; lr = 2; |
| ul <<= lr; |
| if(ul != 20){ |
| lrc = 319; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 5; ur = 2; |
| ul <<= ur; |
| if(ul != 20){ |
| lrc = 320; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; cr = 10; |
| cl &= cr; |
| if(cl != 8){ |
| lrc = 321; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; sr = 10; |
| cl &= sr; |
| if(cl != 8){ |
| lrc = 322; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; ir = 10; |
| cl &= ir; |
| if(cl != 8){ |
| lrc = 323; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; lr = 10; |
| cl &= lr; |
| if(cl != 8){ |
| lrc = 324; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; ur = 10; |
| cl &= ur; |
| if(cl != 8){ |
| lrc = 325; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; cr = 10; |
| sl &= cr; |
| if(sl != 8){ |
| lrc = 326; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; sr = 10; |
| sl &= sr; |
| if(sl != 8){ |
| lrc = 327; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; ir = 10; |
| sl &= ir; |
| if(sl != 8){ |
| lrc = 328; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; lr = 10; |
| sl &= lr; |
| if(sl != 8){ |
| lrc = 329; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; ur = 10; |
| sl &= ur; |
| if(sl != 8){ |
| lrc = 330; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; cr = 10; |
| il &= cr; |
| if(il != 8){ |
| lrc = 331; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; sr = 10; |
| il &= sr; |
| if(il != 8){ |
| lrc = 332; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; ir = 10; |
| il &= ir; |
| if(il != 8){ |
| lrc = 333; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; lr = 10; |
| il &= lr; |
| if(il != 8){ |
| lrc = 334; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; ur = 10; |
| il &= ur; |
| if(il != 8){ |
| lrc = 335; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; cr = 10; |
| ll &= cr; |
| if(ll != 8){ |
| lrc = 336; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; sr = 10; |
| ll &= sr; |
| if(ll != 8){ |
| lrc = 337; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; ir = 10; |
| ll &= ir; |
| if(ll != 8){ |
| lrc = 338; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; lr = 10; |
| ll &= lr; |
| if(ll != 8){ |
| lrc = 339; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; ur = 10; |
| ll &= ur; |
| if(ll != 8){ |
| lrc = 340; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; cr = 10; |
| ul &= cr; |
| if(ul != 8){ |
| lrc = 341; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; sr = 10; |
| ul &= sr; |
| if(ul != 8){ |
| lrc = 342; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; ir = 10; |
| ul &= ir; |
| if(ul != 8){ |
| lrc = 343; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; lr = 10; |
| ul &= lr; |
| if(ul != 8){ |
| lrc = 344; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; ur = 10; |
| ul &= ur; |
| if(ul != 8){ |
| lrc = 345; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; cr = 10; |
| cl ^= cr; |
| if(cl != 6){ |
| lrc = 346; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; sr = 10; |
| cl ^= sr; |
| if(cl != 6){ |
| lrc = 347; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; ir = 10; |
| cl ^= ir; |
| if(cl != 6){ |
| lrc = 348; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; lr = 10; |
| cl ^= lr; |
| if(cl != 6){ |
| lrc = 349; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; ur = 10; |
| cl ^= ur; |
| if(cl != 6){ |
| lrc = 350; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; cr = 10; |
| sl ^= cr; |
| if(sl != 6){ |
| lrc = 351; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; sr = 10; |
| sl ^= sr; |
| if(sl != 6){ |
| lrc = 352; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; ir = 10; |
| sl ^= ir; |
| if(sl != 6){ |
| lrc = 353; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; lr = 10; |
| sl ^= lr; |
| if(sl != 6){ |
| lrc = 354; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; ur = 10; |
| sl ^= ur; |
| if(sl != 6){ |
| lrc = 355; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; cr = 10; |
| il ^= cr; |
| if(il != 6){ |
| lrc = 356; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; sr = 10; |
| il ^= sr; |
| if(il != 6){ |
| lrc = 357; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; ir = 10; |
| il ^= ir; |
| if(il != 6){ |
| lrc = 358; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; lr = 10; |
| il ^= lr; |
| if(il != 6){ |
| lrc = 359; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; ur = 10; |
| il ^= ur; |
| if(il != 6){ |
| lrc = 360; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; cr = 10; |
| ll ^= cr; |
| if(ll != 6){ |
| lrc = 361; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; sr = 10; |
| ll ^= sr; |
| if(ll != 6){ |
| lrc = 362; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; ir = 10; |
| ll ^= ir; |
| if(ll != 6){ |
| lrc = 363; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; lr = 10; |
| ll ^= lr; |
| if(ll != 6){ |
| lrc = 364; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; ur = 10; |
| ll ^= ur; |
| if(ll != 6){ |
| lrc = 365; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; cr = 10; |
| ul ^= cr; |
| if(ul != 6){ |
| lrc = 366; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; sr = 10; |
| ul ^= sr; |
| if(ul != 6){ |
| lrc = 367; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; ir = 10; |
| ul ^= ir; |
| if(ul != 6){ |
| lrc = 368; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; lr = 10; |
| ul ^= lr; |
| if(ul != 6){ |
| lrc = 369; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; ur = 10; |
| ul ^= ur; |
| if(ul != 6){ |
| lrc = 370; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; cr = 10; |
| cl |= cr; |
| if(cl != 14){ |
| lrc = 371; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; sr = 10; |
| cl |= sr; |
| if(cl != 14){ |
| lrc = 372; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; ir = 10; |
| cl |= ir; |
| if(cl != 14){ |
| lrc = 373; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; lr = 10; |
| cl |= lr; |
| if(cl != 14){ |
| lrc = 374; |
| if(prlc) printf(f,lrc); |
| } |
| cl = 12; ur = 10; |
| cl |= ur; |
| if(cl != 14){ |
| lrc = 375; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; cr = 10; |
| sl |= cr; |
| if(sl != 14){ |
| lrc = 376; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; sr = 10; |
| sl |= sr; |
| if(sl != 14){ |
| lrc = 377; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; ir = 10; |
| sl |= ir; |
| if(sl != 14){ |
| lrc = 378; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; lr = 10; |
| sl |= lr; |
| if(sl != 14){ |
| lrc = 379; |
| if(prlc) printf(f,lrc); |
| } |
| sl = 12; ur = 10; |
| sl |= ur; |
| if(sl != 14){ |
| lrc = 380; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; cr = 10; |
| il |= cr; |
| if(il != 14){ |
| lrc = 381; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; sr = 10; |
| il |= sr; |
| if(il != 14){ |
| lrc = 382; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; ir = 10; |
| il |= ir; |
| if(il != 14){ |
| lrc = 383; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; lr = 10; |
| il |= lr; |
| if(il != 14){ |
| lrc = 384; |
| if(prlc) printf(f,lrc); |
| } |
| il = 12; ur = 10; |
| il |= ur; |
| if(il != 14){ |
| lrc = 385; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; cr = 10; |
| ll |= cr; |
| if(ll != 14){ |
| lrc = 386; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; sr = 10; |
| ll |= sr; |
| if(ll != 14){ |
| lrc = 387; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; ir = 10; |
| ll |= ir; |
| if(ll != 14){ |
| lrc = 388; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; lr = 10; |
| ll |= lr; |
| if(ll != 14){ |
| lrc = 389; |
| if(prlc) printf(f,lrc); |
| } |
| ll = 12; ur = 10; |
| ll |= ur; |
| if(ll != 14){ |
| lrc = 390; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; cr = 10; |
| ul |= cr; |
| if(ul != 14){ |
| lrc = 391; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; sr = 10; |
| ul |= sr; |
| if(ul != 14){ |
| lrc = 392; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; ir = 10; |
| ul |= ir; |
| if(ul != 14){ |
| lrc = 393; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; lr = 10; |
| ul |= lr; |
| if(ul != 14){ |
| lrc = 394; |
| if(prlc) printf(f,lrc); |
| } |
| ul = 12; ur = 10; |
| ul |= ur; |
| if(ul != 14){ |
| lrc = 395; |
| if(prlc) printf(f,lrc); |
| } |
| if(lrc != 0) { |
| rc = 1; |
| if(pd0->flgd != 0) printf(s714er,1); |
| } |
| return rc; |
| } |
| s715(pd0) /* 7.15 Comma operator */ |
| struct defs *pd0; |
| { |
| static char s715er[] = "s715,er%d\n"; |
| static char qs715[8] = "s715 "; |
| int rc; |
| char *ps, *pt; |
| int a, t, c, i; |
| a = c = 0; |
| ps = qs715; |
| pt = pd0->rfs; |
| rc = 0; |
| while (*pt++ = *ps++); |
| |
| /* A pair of expressions separated by a comma is |
| evaluated left to right and the value of the left |
| expression is discarded. |
| */ |
| i = 1; |
| if( i++,i++,i++,i++,++i != 6 ){ |
| if(pd0->flgd != 0) printf(s715er,1); |
| rc = rc+1; |
| } |
| |
| /* In contexts where the comma is given a special mean- |
| ing, for example in a list of actual arguments to |
| functions (sic) and lists of initializers, the comma |
| operator as described in this section can only appear |
| in parentheses; for example |
| |
| f( a, (t=3, t+2), c) |
| |
| has three arguments, the second of which has the |
| value 5. |
| */ |
| |
| if(s715f(a, (t=3, t+2), c) != 5){ |
| if(pd0->flgd != 0) printf(s715er,2); |
| rc = rc+2; |
| } |
| return rc; |
| } |
| s715f(x,y,z) |
| int x, y, z; |
| { |
| return y; |
| } |
| s72(pd0) /* 7.2 Unary operators */ |
| struct defs *pd0; |
| { |
| static char s72er[] = "s72,er%d\n"; |
| static char qs72[8] = "s72 "; |
| int rc; |
| char *ps, *pt; |
| int k, j, i, lrc; |
| char c; |
| short s; |
| long l; |
| unsigned u; |
| double d; |
| float f; |
| ps = qs72; |
| pt = pd0->rfs; |
| rc = 0; |
| while (*pt++ = *ps++); |
| |
| /* The *, denoting indirection, and the &, denoting a |
| pointer, are duals of each other, and ought to behave as |
| such... */ |
| |
| k = 2; |
| if(*&*&k != 2){ |
| rc = rc+1; |
| printf(s72er,1); |
| } |
| |
| /* The unary minus has the conventional meaning. */ |
| |
| if(k+(-k) != 0){ |
| rc = rc+2; |
| printf(s72er,2); |
| } |
| |
| /* The negation operator (!) has been thoroughly checked out, |
| perhaps more thoroughly than any of the others. The ~ oper- |
| ator gets us a ones complement. */ |
| |
| k = 0; |
| for(j=0;j<pd0->ibits;j++) k = (k<<1)|1; |
| if(~k != 0){ |
| rc = rc+4; |
| printf(s72er,4); |
| } |
| |
| /* Now we look at the ++ and -- operators, which can be |
| used in either prefix or suffix form. With side |
| effects they're loaded. */ |
| |
| k = 5; |
| |
| if( ++k != 6 || --k != 5 |
| || k++ != 5 || k-- != 6 |
| || k != 5 ){ |
| rc = rc+8; |
| printf(s72er,8); |
| } |
| |
| /* An expression preceded by the parenthesised name of a |
| data type causes conversion of the value of the expression |
| to the named type. This construction is called a cast. |
| Here, we check to see that all of the possible casts and |
| their simple combinations are accepted by the compiler, |
| and that they all produce a correct result for this sample |
| of size one. */ |
| |
| c = 26; l = 26; d = 26.; |
| s = 26; u = 26; |
| i = 26; f = 26.; |
| |
| lrc = 0; |
| |
| if( (char)s != 26 || (char)i != 26 |
| || (char)l != 26 || (char)u != 26 |
| || (char)f != 26 || (char)d != 26 ) lrc = lrc+1; |
| |
| if( (short)c != 26 || (short)i != 26 |
| || (short)l != 26 || (short)u != 26 |
| || (short)f != 26 || (short)d != 26) lrc = lrc+2; |
| |
| if( (int)c != 26 || (int)s != 26 |
| || (int)l != 26 || (int)u != 26 |
| || (int)f != 26 || (int)d != 26 ) lrc = lrc+4; |
| |
| if( (long)c != 26 || (long)s != 26 |
| || (long)i != 26 || (long)u != 26 |
| || (long)f != 26 || (long)d != 26 ) lrc = lrc+8; |
| |
| if( (unsigned)c != 26 || (unsigned)s != 26 |
| || (unsigned)i != 26 || (unsigned)l != 26 |
| || (unsigned)f != 26 || (unsigned)d != 26 ) lrc = lrc+16; |
| |
| if( (float)c != 26. || (float)s != 26. |
| || (float)i != 26. || (float)l != 26. |
| || (float)u != 26. || (float)d != 26. ) lrc = lrc+32; |
| |
| if( (double)c != 26. || (double)s != 26. |
| || (double)i != 26. || (double)l != 26. |
| || (double)u != 26. || (double)f != 26. ) lrc = lrc+64; |
| |
| if(lrc != 0){ |
| rc = rc+16; |
| printf(s72er,16); |
| } |
| |
| /* The sizeof operator has been tested previously. */ |
| |
| return rc; |
| } |
| s757(pd0) /* 7.5 Shift operators */ |
| /* 7.6 Relational operators */ |
| /* 7.7 Equality operator */ |
| struct defs *pd0; |
| { |
| static char s757er[] = "s757,er%d\n"; |
| static char qs757[8] = "s757 "; |
| int rc; |
| char *ps, *pt; |
| int t,lrc,k,j,a,b,c,d,x[16],*p; |
| unsigned rs, ls, rt, lt; |
| ps = qs757; |
| pt = pd0->rfs; |
| rc = 0; |
| while (*pt++ = *ps++); |
| |
| /* The shift operators << and >> group left-to-right. |
| */ |
| |
| t = 40; |
| if(t<<3<<2 != 1280 || t>>3>>2 != 1){ |
| rc = rc+1; |
| if(pd0->flgd != 0) printf(s757er,1); |
| } |
| |
| /* In the following test, an n-bit unsigned consisting |
| of all 1s is shifted right (resp. left) k bits, 0<=k<n. |
| We expect to find k 0s followed by n-k 1s (resp. n-k 1s |
| followed by k 0s). If not, we complain. |
| */ |
| |
| lrc = 0; |
| for(k=0; k<pd0->ubits; k++){ |
| rs = 1; |
| ls = rs<<(pd0->ubits-1); |
| |
| rt = 0; |
| lt = ~rt>>k; |
| rt = ~rt<<k; |
| |
| for(j=0; j<pd0->ubits;j++){ |
| if((j<k) != ((rs&rt) == 0) || (j<k) != ((ls<) == 0)) lrc = 1; |
| rs = rs<<1; |
| ls = ls>>1; |
| } |
| } |
| |
| if(lrc != 0){ |
| rc = rc+2; |
| if(pd0->flgd != 0) printf(s757er,2); |
| } |
| |
| /* The relational operators group left-to-right, but this |
| fact is not very useful; a<b<c does not mean what it |
| seems to... |
| */ |
| |
| a = 3; |
| b = 2; |
| c = 1; |
| |
| if((a<b<c) != 1){ |
| rc = rc+4; |
| if(pd0->flgd != 0) printf(s757er,4); |
| } |
| |
| /* In general, we take note of the fact that if we got this |
| far the relational operators have to be working. We test only |
| that two pointers may be compared; the result depends on |
| the relative locations in the address space of the |
| pointed-to objects. |
| */ |
| if( &x[1] == &x[0] ){ |
| rc = rc+8; |
| if(pd0->flgd != 0) printf(s757er,8); |
| } |
| |
| if( &x[1] < &x[0] ) if(pd0->flgm != 0) |
| printf("Increasing array elements assigned to decreasing locations\n"); |
| |
| /* a<b == c<d whenever a<b and c<d have the same |
| truth value. */ |
| |
| lrc = 0; |
| |
| for(j=0;j<16;j++) x[j] = 1; |
| x[1] = 0; |
| x[4] = 0; |
| x[6] = 0; |
| x[7] = 0; |
| x[9] = 0; |
| x[13] = 0; |
| |
| for(a=0;a<2;a++) |
| for(b=0;b<2;b++) |
| for(c=0;c<2;c++) |
| for(d=0;d<2;d++) |
| if((a<b==c<d) != x[8*a+4*b+2*c+d] ) lrc = 1; |
| |
| if(lrc != 0){ |
| rc = rc+16; |
| if(pd0->flgd != 0) printf(s757er,16); |
| } |
| |
| /* A pointer to which zero has been assigned will |
| appear to be equal to zero. |
| */ |
| |
| p = 0; |
| |
| if(p != 0){ |
| rc = rc+32; |
| if(pd0->flgd != 0) printf(s757er,32); |
| } |
| |
| return rc; |
| } |
| s7813(pd0) /* 7.8 Bitwise AND operator |
| 7.9 Bitwise OR operator |
| 7.10 Bitwise exclusive OR operator |
| 7.11 Logical AND operator |
| 7.12 Logical OR operator |
| 7.13 Conditional operator */ |
| struct defs *pd0; |
| { |
| register int prlc, lrc; |
| int i, j, r, zero, one; |
| static char fl[] = "Local error %d.\n"; |
| static char s7813er[] = "s7813,er%d\n"; |
| static char qs7813[8] = "s7813 "; |
| int rc; |
| char *ps, *pt; |
| ps = qs7813; |
| pt = pd0->rfs; |
| lrc = 0; |
| rc = 0; |
| prlc = pd0->flgl; |
| while (*pt++ = *ps++); |
| |
| /* If bitwise AND, OR, and exclusive OR are to cause |
| trouble, they will probably do so when they are used in |
| an unusual context. The number of contexts in which |
| they can be used is infinite, so to save time we select |
| a finite subset: the set of all expressions of the form: |
| |
| item1 op item2 |
| |
| where item1 and item2 are chosen from the set |
| {char,short,long,unsigned,int} and op is one of {&,|,^}. |
| We will use 12 and 10 as values for the items, as these |
| values will fit into all data types on just about any |
| imaginable machine, and the results after performing the |
| bitwise operations on them are distinct for each operation, |
| i.e., |
| |
| 12 | 10 -> 1100 | 1010 -> 1110 -> 14 |
| 12 ^ 10 -> 1100 ^ 1010 -> 0110 -> 6 |
| 12 & 10 -> 1100 & 1010 -> 1000 -> 8 |
| |
| There are 75 such combinations: |
| */ |
| |
| if(((char)12 & (char)10) != 8) {lrc = 1; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 | (char)10) != 14) {lrc = 2; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 ^ (char)10) != 6) {lrc = 3; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 & (short)10) != 8) {lrc = 4; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 | (short)10) != 14) {lrc = 5; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 ^ (short)10) != 6) {lrc = 6; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 & (long)10) != 8) {lrc = 7; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 | (long)10) != 14) {lrc = 8; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 ^ (long)10) != 6) {lrc = 9; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 & (unsigned)10) != 8) {lrc = 10; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 | (unsigned)10) != 14) {lrc = 11; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 ^ (unsigned)10) != 6) {lrc = 12; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 & (int)10) != 8) {lrc = 13; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 | (int)10) != 14) {lrc = 14; |
| if(prlc) printf(fl,lrc);} |
| if(((char)12 ^ (int)10) != 6) {lrc = 15; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 & (char)10) != 8) {lrc = 16; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 | (char)10) != 14) {lrc = 17; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 ^ (char)10) != 6) {lrc = 18; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 & (short)10) != 8) {lrc = 16; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 | (short)10) != 14) {lrc = 20; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 ^ (short)10) != 6) {lrc = 21; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 & (long)10) != 8) {lrc = 22; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 | (long)10) != 14) {lrc = 23; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 ^ (long)10) != 6) {lrc = 24; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 & (unsigned)10) != 8) {lrc = 25; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 | (unsigned)10) != 14) {lrc = 26; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 ^ (unsigned)10) != 6) {lrc = 27; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 & (int)10) != 8) {lrc = 28; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 | (int)10) != 14) {lrc = 26; |
| if(prlc) printf(fl,lrc);} |
| if(((short)12 ^ (int)10) != 6) {lrc = 30; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 & (char)10) != 8) {lrc = 31; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 | (char)10) != 14) {lrc = 32; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 ^ (char)10) != 6) {lrc = 33; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 & (short)10) != 8) {lrc = 34; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 | (short)10) != 14) {lrc = 35; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 ^ (short)10) != 6) {lrc = 36; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 & (long)10) != 8) {lrc = 37; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 | (long)10) != 14) {lrc = 38; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 ^ (long)10) != 6) {lrc = 39; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 & (unsigned)10) != 8) {lrc = 40; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 | (unsigned)10) != 14) {lrc = 41; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 ^ (unsigned)10) != 6) {lrc = 42; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 & (int)10) != 8) {lrc = 43; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 | (int)10) != 14) {lrc = 44; |
| if(prlc) printf(fl,lrc);} |
| if(((long)12 ^ (int)10) != 6) {lrc = 45; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 & (char)10) != 8) {lrc = 46; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 | (char)10) != 14) {lrc = 47; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 ^ (char)10) != 6) {lrc = 48; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 & (short)10) != 8) {lrc = 49; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 | (short)10) != 14) {lrc = 50; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 ^ (short)10) != 6) {lrc = 51; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 & (long)10) != 8) {lrc = 52; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 | (long)10) != 14) {lrc = 53; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 ^ (long)10) != 6) {lrc = 54; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 & (unsigned)10) != 8) {lrc = 55; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 | (unsigned)10) != 14) {lrc = 56; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 ^ (unsigned)10) != 6) {lrc = 57; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 & (int)10) != 8) {lrc = 58; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 | (int)10) != 14) {lrc = 56; |
| if(prlc) printf(fl,lrc);} |
| if(((unsigned)12 ^ (int)10) != 6) {lrc = 60; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 & (char)10) != 8) {lrc = 61; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 | (char)10) != 14) {lrc = 62; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 ^ (char)10) != 6) {lrc = 63; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 & (short)10) != 8) {lrc = 64; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 | (short)10) != 14) {lrc = 65; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 ^ (short)10) != 6) {lrc = 66; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 & (long)10) != 8) {lrc = 67; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 | (long)10) != 14) {lrc = 68; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 ^ (long)10) != 6) {lrc = 69; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 & (unsigned)10) != 8) {lrc = 70; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 | (unsigned)10) != 14) {lrc = 71; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 ^ (unsigned)10) != 6) {lrc = 72; |
| if(prlc) printf(fl,lrc);} |
| if(((int)12 & (int)10) != 8) {lrc = 73; if(prlc) printf(fl,lrc);} |
| if(((int)12 | (int)10) != 14) {lrc = 74; if(prlc) printf(fl,lrc);} |
| if(((int)12 ^ (int)10) != 6) {lrc = 75; if(prlc) printf(fl,lrc);} |
| |
| if(lrc != 0){ |
| if(pd0->flgd != 0) printf(s7813er,1); |
| rc = rc+1; |
| } |
| |
| /* The && operator groups left to right. It returns 1 |
| if both of the operands are nonzero; 0 otherwise. |
| It guarantees left to right evaluation; moreover, the |
| second operand is not evaluated if the value of the |
| first operand is 0. |
| */ |
| |
| lrc = 0; |
| i = j = 0; |
| |
| r = i++ && j++; |
| if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);} |
| if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);} |
| if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);} |
| r = i && j++; |
| if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);} |
| if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);} |
| if(r!=0) {lrc = 6; if(prlc) printf(fl,lrc);} |
| r = i-- && j; |
| if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);} |
| if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);} |
| if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);} |
| r = i && j--; |
| if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);} |
| if(j!=1) {lrc = 11; if(prlc) printf(fl,lrc);} |
| if(r!=0) {lrc = 12; if(prlc) printf(fl,lrc);} |
| |
| if(lrc!=0){ |
| if(pd0->flgd != 0) printf(s7813er,2); |
| rc = rc+2; |
| } |
| |
| /* The || operator groups left to right. It returns 1 |
| if either of its operands is nonzero; 0 otherwise. It |
| guarantees left to right evaluation; moreover, the second |
| operand is not evaluated if the value of the first |
| operand is nonzero. |
| */ |
| |
| lrc = 0; |
| i = j = 0; |
| r = i++ || j; |
| if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);} |
| if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);} |
| if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);} |
| r = j++ || i; |
| if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);} |
| if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);} |
| if(r!=1) {lrc = 6; if(prlc) printf(fl,lrc);} |
| r = i-- || j--; |
| if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);} |
| if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);} |
| if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);} |
| r = i || j--; |
| if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);} |
| if(j!=0) {lrc = 11; if(prlc) printf(fl,lrc);} |
| if(r!=1) {lrc = 12; if(prlc) printf(fl,lrc);} |
| |
| if(lrc!=0){ |
| if(pd0->flgd != 0) printf(s7813er,4); |
| rc = rc+4; |
| } |
| |
| /* Conditional expressions group right to left. */ |
| |
| i = j = 0; |
| zero = 0; |
| one = 1; |
| r = one?zero:one?i++:j++; |
| if(r!=0 || i!=0 || j!=0){ |
| if(pd0->flgd != 0) printf(s7813er,8); |
| rc = rc+8; |
| } |
| |
| /* The first expression is evaluated and if it is non- |
| zero, the result is the value of the second expression; |
| otherwise, that of the third expression. |
| */ |
| |
| if((one?zero:1) != 0 || (zero?1:zero) != 0){ |
| if(pd0->flgd != 0) printf(s7813er,16); |
| rc = rc+16; |
| } |
| return rc; |
| } |
| s81(pd0) /* 8.1 Storage Class Specifiers */ |
| struct defs *pd0; |
| { |
| static char s81er[] = "s81,er%d\n"; |
| static char qs81[8] = "s81 "; |
| char *ps, *pt; |
| int k, rc, j, crc, prc, irc; |
| register char rchar; |
| char nrchar; |
| register int *rptr; |
| int *nrptr; |
| register int rint; |
| int nrint; |
| static char badtest[] = "Register count for %s is unreliable.\n"; |
| static char goodtest[] = "%d registers assigned to %s variables.\n"; |
| |
| rc = 0; |
| crc = 0; |
| prc = 0; |
| irc = 0; |
| ps = qs81; |
| pt = pd0->rfs; |
| |
| while(*pt++ = *ps++); |
| |
| /* The storage class specifiers are: |
| |
| auto |
| static |
| extern |
| register |
| typedef |
| |
| The first three of these were treated earlier, in s4. The last |
| will be checked in s88. "Register" remains. |
| |
| There are three flavors of register, viz., char, int and pointer. |
| We wish first to ascertain that the representations as register |
| are consistent with the corresponding nonregister representations. |
| */ |
| |
| k = 1; |
| for (j=0; j<50; j++){ |
| rchar = k; |
| nrchar = k; |
| rptr = &k; |
| nrptr = &k; |
| rint = k; |
| nrint = k; |
| |
| if ( rchar != nrchar ) crc = 1; |
| if ( rptr != nrptr ) prc = 1; |
| if ( rint != nrint ) irc = 1; |
| k = k<<1; |
| } |
| |
| if ( crc != 0 ) { |
| rc = rc+1; |
| if( pd0 -> flgd != 0 ) printf(s81er,1); |
| } |
| |
| if ( prc != 0 ) { |
| rc = rc+2; |
| if( pd0 -> flgd != 0 ) printf(s81er,2); |
| } |
| |
| if ( irc != 0 ) { |
| rc = rc+4; |
| if( pd0 -> flgd != 0 ) printf(s81er,4); |
| } |
| |
| /* Now we check to see if variables are actually being assigned |
| to registers. */ |
| |
| k = regc(); |
| if ( pd0->flgm != 0 ) { |
| if ( k < 0 ) printf(badtest,"char"); |
| else printf(goodtest,k,"char"); |
| } |
| |
| k = regp(); |
| if ( pd0->flgm != 0 ) { |
| if ( k<0 ) printf(badtest,"pointer"); |
| else printf(goodtest,k,"pointer"); |
| } |
| |
| k = regi(); |
| if ( pd0->flgm != 0 ) { |
| if ( k<0 ) printf(badtest,"int"); |
| else printf(goodtest,k,"int"); |
| } |
| |
| return rc; |
| } |
| regc() { /* char to register assignment */ |
| /* Testing a variable whose storage class has been spec- |
| ified as "register" is somewhat tricky, but it can be done in a |
| fairly reliable fashion by taking advantage of our knowledge of the |
| ways in which compilers operate. If we declare a collection of vari- |
| ables of the same storage class, we would expect that, when storage |
| for these variables is actually allocated, the variables will be |
| bunched together and ordered according to one of the following |
| criteria: |
| |
| (a) the order in which they were defined. |
| (b) the order in which they are used. |
| (c) alphabetically. |
| (d) the order in which they appear in the compiler's |
| symbol table. |
| (e) some other way. |
| |
| Hence, if we define a sequence of variables in close alpha- |
| betical order, and use them in the same order in which we define |
| them, we would expect the differences between the addresses of |
| successive variables to be constant, except in case (d) where the |
| symbol table is a hash table, or in case (e). If a subsequence in |
| the middle of this sequence is selected, and for this subsequence, |
| every other variable is specified to be "register", and address |
| differences are taken between adjacent nonregister variables, we would |
| still expect to find constant differences if the "register" vari- |
| ables were actually assigned to registers, and some other diff- |
| erences if they were not. Specifically, if we had N variables |
| specified as "register" of which the first n were actually ass- |
| igned to registers, we would expect the sequence of differences |
| to consist of a number of occurrences of some number, followed by |
| N-n occurrences of some other number, followed by several occurr- |
| ences of the first number. If we get a sequence like this, we can |
| determine, by simple subtraction, how many (if any) variables are |
| being assigned to registers. If we get some other sequence, we know |
| that the test is invalid. */ |
| |
| char r00; |
| char r01; |
| char r02; |
| char r03; |
| register char r04; |
| char r05; |
| register char r06; |
| char r07; |
| register char r08; |
| char r09; |
| register char r10; |
| char r11; |
| register char r12; |
| char r13; |
| register char r14; |
| char r15; |
| register char r16; |
| char r17; |
| register char r18; |
| char r19; |
| register char r20; |
| char r21; |
| register char r22; |
| char r23; |
| register char r24; |
| char r25; |
| register char r26; |
| char r27; |
| register char r28; |
| char r29; |
| register char r30; |
| char r31; |
| register char r32; |
| char r33; |
| register char r34; |
| char r35; |
| char r36; |
| char r37; |
| char r38; |
| |
| int s, n1, n2, nr, j, d[22]; |
| r00 = 0; |
| r01 = 1; |
| r02 = 2; |
| r03 = 3; |
| r04 = 4; |
| r05 = 5; |
| r06 = 6; |
| r07 = 7; |
| r08 = 8; |
| r09 = 9; |
| r10 = 10; |
| r11 = 11; |
| r12 = 12; |
| r13 = 13; |
| r14 = 14; |
| r15 = 15; |
| r16 = 16; |
| r17 = 17; |
| r18 = 18; |
| r19 = 19; |
| r20 = 20; |
| r21 = 21; |
| r22 = 22; |
| r23 = 23; |
| r24 = 24; |
| r25 = 25; |
| r26 = 26; |
| r27 = 27; |
| r28 = 28; |
| r29 = 29; |
| r30 = 30; |
| r31 = 31; |
| r32 = 32; |
| r33 = 33; |
| r34 = 34; |
| r35 = 35; |
| r36 = 36; |
| r37 = 37; |
| r38 = 38; |
| |
| d[0] = &r01 - &r00; |
| d[1] = &r02 - &r01; |
| d[2] = &r03 - &r02; |
| d[3] = &r05 - &r03; |
| d[4] = &r07 - &r05; |
| d[5] = &r09 - &r07; |
| d[6] = &r11 - &r09; |
| d[7] = &r13 - &r11; |
| d[8] = &r15 - &r13; |
| d[9] = &r17 - &r15; |
| d[10] = &r19 - &r17; |
| d[11] = &r21 - &r19; |
| d[12] = &r23 - &r21; |
| d[13] = &r25 - &r23; |
| d[14] = &r27 - &r25; |
| d[15] = &r29 - &r27; |
| d[16] = &r31 - &r29; |
| d[17] = &r33 - &r31; |
| d[18] = &r35 - &r33; |
| d[19] = &r36 - &r35; |
| d[20] = &r37 - &r36; |
| d[21] = &r38 - &r37; |
| |
| |
| /* The following FSM analyzes the string of differences. It accepts |
| strings of the form a+b+a+ and returns 16 minus the number of bs, |
| which is the number of variables that actually got into registers. |
| Otherwise it signals rejection by returning -1., indicating that the |
| test is unreliable. */ |
| |
| n1 = d[0]; |
| s = 1; |
| |
| for (j=0; j<22; j++) |
| switch (s) { |
| case 1: if (d[j] != n1) { |
| n2 = d[j]; |
| s = 2; |
| nr = 1; |
| } |
| break; |
| case 2: if (d[j] == n1) { |
| s = 3; |
| break; |
| } |
| if (d[j] == n2) { |
| nr = nr+1; |
| break; |
| } |
| s = 4; |
| break; |
| case 3: if (d[j] != n1) s = 4; |
| break; |
| } |
| ; |
| |
| if (s == 3) return 16-nr; |
| else return -1; |
| } |
| regi() { /* int to register assignment */ |
| /* Testing a variable whose storage class has been spec- |
| ified as "register" is somewhat tricky, but it can be done in a |
| fairly reliable fashion by taking advantage of our knowledge of the |
| ways in which compilers operate. If we declare a collection of vari- |
| ables of the same storage class, we would expect that, when storage |
| for these variables is actually allocated, the variables will be |
| bunched together and ordered according to one of the following |
| criteria: |
| |
| (a) the order in which they were defined. |
| (b) the order in which they are used. |
| (c) alphabetically. |
| (d) the order in which they appear in the compiler's |
| symbol table. |
| (e) some other way. |
| |
| Hence, if we define a sequence of variables in close alpha- |
| betical order, and use them in the same order in which we define |
| them, we would expect the differences between the addresses of |
| successive variables to be constant, except in case (d) where the |
| symbol table is a hash table, or in case (e). If a subsequence in |
| the middle of this sequence is selected, and for this subsequence, |
| every other variable is specified to be "register", and address |
| differences are taken between adjacent nonregister variables, we would |
| still expect to find constant differences if the "register" vari- |
| ables were actually assigned to registers, and some other diff- |
| erences if they were not. Specifically, if we had N variables |
| specified as "register" of which the first n were actually ass- |
| igned to registers, we would expect the sequence of differences |
| to consist of a number of occurrences of some number, followed by |
| N-n occurrences of some other number, followed by several occurr- |
| ences of the first number. If we get a sequence like this, we can |
| determine, by simple subtraction, how many (if any) variables are |
| being assigned to registers. If we get some other sequence, we know |
| that the test is invalid. */ |
| |
| |
| int r00; |
| int r01; |
| int r02; |
| int r03; |
| register int r04; |
| int r05; |
| register int r06; |
| int r07; |
| register int r08; |
| int r09; |
| register int r10; |
| int r11; |
| register int r12; |
| int r13; |
| register int r14; |
| int r15; |
| register int r16; |
| int r17; |
| register int r18; |
| int r19; |
| register int r20; |
| int r21; |
| register int r22; |
| int r23; |
| register int r24; |
| int r25; |
| register int r26; |
| int r27; |
| register int r28; |
| int r29; |
| register int r30; |
| int r31; |
| register int r32; |
| int r33; |
| register int r34; |
| int r35; |
| int r36; |
| int r37; |
| int r38; |
| |
| int s, n1, n2, nr, j, d[22]; |
| |
| r00 = 0; |
| r01 = 1; |
| r02 = 2; |
| r03 = 3; |
| r04 = 4; |
| r05 = 5; |
| r06 = 6; |
| r07 = 7; |
| r08 = 8; |
| r09 = 9; |
| r10 = 10; |
| r11 = 11; |
| r12 = 12; |
| r13 = 13; |
| r14 = 14; |
| r15 = 15; |
| r16 = 16; |
| r17 = 17; |
| r18 = 18; |
| r19 = 19; |
| r20 = 20; |
| r21 = 21; |
| r22 = 22; |
| r23 = 23; |
| r24 = 24; |
| r25 = 25; |
| r26 = 26; |
| r27 = 27; |
| r28 = 28; |
| r29 = 29; |
| r30 = 30; |
| r31 = 31; |
| r32 = 32; |
| r33 = 33; |
| r34 = 34; |
| r35 = 35; |
| r36 = 36; |
| r37 = 37; |
| r38 = 38; |
| |
| d[0] = &r01 - &r00; |
| d[1] = &r02 - &r01; |
| d[2] = &r03 - &r02; |
| d[3] = &r05 - &r03; |
| d[4] = &r07 - &r05; |
| d[5] = &r09 - &r07; |
| d[6] = &r11 - &r09; |
| d[7] = &r13 - &r11; |
| d[8] = &r15 - &r13; |
| d[9] = &r17 - &r15; |
| d[10] = &r19 - &r17; |
| d[11] = &r21 - &r19; |
| d[12] = &r23 - &r21; |
| d[13] = &r25 - &r23; |
| d[14] = &r27 - &r25; |
| d[15] = &r29 - &r27; |
| d[16] = &r31 - &r29; |
| d[17] = &r33 - &r31; |
| d[18] = &r35 - &r33; |
| d[19] = &r36 - &r35; |
| d[20] = &r37 - &r36; |
| d[21] = &r38 - &r37; |
| |
| |
| /* The following FSM analyzes the string of differences. It accepts |
| strings of the form a+b+a+ and returns 16 minus the number of bs, |
| which is the number of variables that actually got into registers. |
| Otherwise it signals rejection by returning -1., indicating that the |
| test is unreliable. */ |
| |
| n1 = d[0]; |
| s = 1; |
| |
| for (j=0; j<22; j++) |
| switch (s) { |
| case 1: if (d[j] != n1) { |
| n2 = d[j]; |
| s = 2; |
| nr = 1; |
| } |
| break; |
| case 2: if (d[j] == n1) { |
| s = 3; |
| break; |
| } |
| if (d[j] == n2) { |
| nr = nr+1; |
| break; |
| } |
| s = 4; |
| break; |
| case 3: if (d[j] != n1) s = 4; |
| break; |
| } |
| ; |
| |
| if (s == 3) return 16-nr; |
| else return -1; |
| } |
| regp() { /* pointer to register assignment */ |
| /* Testing a variable whose storage class has been spec- |
| ified as "register" is somewhat tricky, but it can be done in a |
| fairly reliable fashion by taking advantage of our knowledge of the |
| ways in which compilers operate. If we declare a collection of vari- |
| ables of the same storage class, we would expect that, when storage |
| for these variables is actually allocated, the variables will be |
| bunched together and ordered according to one of the following |
| criteria: |
| |
| (a) the order in which they were defined. |
| (b) the order in which they are used. |
| (c) alphabetically. |
| (d) the order in which they appear in the compiler's |
| symbol table. |
| (e) some other way. |
| |
| Hence, if we define a sequence of variables in close alpha- |
| betical order, and use them in the same order in which we define |
| them, we would expect the differences between the addresses of |
| successive variables to be constant, except in case (d) where the |
| symbol table is a hash table, or in case (e). If a subsequence in |
| the middle of this sequence is selected, and for this subsequence, |
| every other variable is specified to be "register", and address |
| differences are taken between adjacent nonregister variables, we would |
| still expect to find constant differences if the "register" vari- |
| ables were actually assigned to registers, and some other diff- |
| erences if they were not. Specifically, if we had N variables |
| specified as "register" of which the first n were actually ass- |
| igned to registers, we would expect the sequence of differences |
| to consist of a number of occurrences of some number, followed by |
| N-n occurrences of some other number, followed by several occurr- |
| ences of the first number. If we get a sequence like this, we can |
| determine, by simple subtraction, how many (if any) variables are |
| being assigned to registers. If we get some other sequence, we know |
| that the test is invalid. */ |
| |
| |
| int *r00; |
| int *r01; |
| int *r02; |
| int *r03; |
| register int *r04; |
| int *r05; |
| register int *r06; |
| int *r07; |
| register int *r08; |
| int *r09; |
| register int *r10; |
| int *r11; |
| register int *r12; |
| int *r13; |
| register int *r14; |
| int *r15; |
| register int *r16; |
| int *r17; |
| register int *r18; |
| int *r19; |
| register int *r20; |
| int *r21; |
| register int *r22; |
| int *r23; |
| register int *r24; |
| int *r25; |
| register int *r26; |
| int *r27; |
| register int *r28; |
| int *r29; |
| register int *r30; |
| int *r31; |
| register int *r32; |
| int *r33; |
| register int *r34; |
| int *r35; |
| int *r36; |
| int *r37; |
| int *r38; |
| |
| int s, n1, n2, nr, j, d[22]; |
| |
| r00 = (int *)&r00; |
| r01 = (int *)&r01; |
| r02 = (int *)&r02; |
| r03 = (int *)&r03; |
| r04 = (int *)&r05; |
| r05 = (int *)&r05; |
| r06 = (int *)&r07; |
| r07 = (int *)&r07; |
| r08 = (int *)&r09; |
| r09 = (int *)&r09; |
| r10 = (int *)&r11; |
| r11 = (int *)&r11; |
| r12 = (int *)&r13; |
| r13 = (int *)&r13; |
| r14 = (int *)&r15; |
| r15 = (int *)&r15; |
| r16 = (int *)&r17; |
| r17 = (int *)&r17; |
| r18 = (int *)&r19; |
| r19 = (int *)&r19; |
| r20 = (int *)&r21; |
| r21 = (int *)&r21; |
| r22 = (int *)&r23; |
| r23 = (int *)&r23; |
| r24 = (int *)&r25; |
| r25 = (int *)&r25; |
| r26 = (int *)&r27; |
| r27 = (int *)&r27; |
| r28 = (int *)&r29; |
| r29 = (int *)&r29; |
| r30 = (int *)&r31; |
| r31 = (int *)&r31; |
| r32 = (int *)&r33; |
| r33 = (int *)&r33; |
| r34 = (int *)&r35; |
| r35 = (int *)&r35; |
| r36 = (int *)&r36; |
| r37 = (int *)&r37; |
| r38 = (int *)&r38; |
| |
| d[0] = &r01 - &r00; |
| d[1] = &r02 - &r01; |
| d[2] = &r03 - &r02; |
| d[3] = &r05 - &r03; |
| d[4] = &r07 - &r05; |
| d[5] = &r09 - &r07; |
| d[6] = &r11 - &r09; |
| d[7] = &r13 - &r11; |
| d[8] = &r15 - &r13; |
| d[9] = &r17 - &r15; |
| d[10] = &r19 - &r17; |
| d[11] = &r21 - &r19; |
| d[12] = &r23 - &r21; |
| d[13] = &r25 - &r23; |
| d[14] = &r27 - &r25; |
| d[15] = &r29 - &r27; |
| d[16] = &r31 - &r29; |
| d[17] = &r33 - &r31; |
| d[18] = &r35 - &r33; |
| d[19] = &r36 - &r35; |
| d[20] = &r37 - &r36; |
| d[21] = &r38 - &r37; |
| |
| |
| /* The following FSM analyzes the string of differences. It accepts |
| strings of the form a+b+a+ and returns 16 minus the number of bs, |
| which is the number of variables that actually got into registers. |
| Otherwise it signals rejection by returning -1., indicating that the |
| test is unreliable. */ |
| |
| n1 = d[0]; |
| s = 1; |
| for (j=0; j<22; j++) |
| switch (s) { |
| case 1: if (d[j] != n1) { |
| n2 = d[j]; |
| s = 2; |
| nr = 1; |
| } |
| break; |
| case 2: if (d[j] == n1) { |
| s = 3; |
| break; |
| } |
| if (d[j] == n2) { |
| nr = nr+1; |
| break; |
| } |
| s = 4; |
| break; |
| case 3: if (d[j] != n1) s = 4; |
| break; |
| } |
| ; |
| |
| if (s == 3) return 16-nr; |
| else return -1; |
| } |
| s84(pd0) /* 8.4 Meaning of declarators */ |
| struct defs *pd0; |
| { |
| int *ip, i, *fip(), (*pfi)(), j, k, array(), glork(int); |
| static int x3d[3][5][7]; |
| float fa[17], *afp[17], sum; |
| static char s84er[] = "s84,er%d\n"; |
| static char qs84[8] = "s84 "; |
| int rc; |
| char *ps, *pt; |
| ps = qs84; |
| pt = pd0->rfs; |
| rc = 0; |
| while (*pt++ = *ps++); |
| |
| /* The more common varieties of declarators have al- |
| ready been touched upon, some more than others. It |
| is useful to compare *fip() and (*pfi)(). |
| */ |
| |
| ip = fip(3); |
| if(*ip != 3){ |
| if(pd0->flgd != 0) printf(s84er,1); |
| rc = rc+1; |
| } |
| |
| pfi = glork; |
| if((*pfi)(4) != 4){ |
| if(pd0->flgd != 0) printf(s84er,2); |
| rc = rc+2; |
| } |
| |
| /* Float fa[17] declares an array of floating point |
| numbers, and *afp[17] declares an array of pointers |
| to floats. |
| */ |
| |
| for(j=0; j<17; j++){ |
| fa[j] = j; |
| afp[j] = &fa[j]; |
| } |
| |
| sum = 0.; |
| for(j=0; j<17; j++) sum += *afp[j]; |
| if(sum != 136){ |
| if(pd0->flgd != 0) printf(s84er,4); |
| rc = rc+4; |
| } |
| |
| /* static int x3d[3][5][7] declares a static three |
| dimensional array of integers, with rank 3x5x7. |
| In complete detail, x3d is an array of three items; |
| each item is an array of five arrays, and each of |
| the latter arrays is an array of seven integers. |
| Any of the expressions x3d, x3d[i], x3d[i][j], |
| and x3d[i][j][k] may reasonably appear in an express- |
| ion. The first three have type "array"; the last has |
| type int. |
| */ |
| |
| for (i=0; i<3; i++) |
| for (j=0; j<5; j++) |
| for (k=0; k<7; k++) |
| x3d[i][j][k] = i*35+j*7+k; |
| |
| i = 1; j = 2; k = 3; |
| |
| if( array(x3d,105,0) |
| +array(x3d[i],35,35) |
| +array(x3d[i][j],7,49) |
| + x3d[i][j][k]-52){ |
| |
| if(pd0->flgd != 0) printf(s84er,8); |
| rc = rc+8; |
| } |
| |
| return rc; |
| } |
| array(a,size,start) |
| int a[], size, start; |
| { |
| int i; |
| for(i=0; i<size; i++) |
| if(a[i] != i+start) return 1; |
| |
| return 0; |
| } |
| int *fip(x) |
| int x; |
| { |
| static int y; |
| y = x; |
| return &y; |
| } |
| glork(x) |
| int x; |
| {return x;} |
| s85(pd0) /* 8.5 Structure and union declarations */ |
| struct defs *pd0; |
| { |
| static char s85er[] = "s85,er%d\n"; |
| static char qs85[8] = "s85 "; |
| int rc; |
| char *ps, *pt; |
| |
| struct tnode { |
| char tword[20]; |
| int count; |
| struct tnode *left; |
| struct tnode *right; |
| }; |
| |
| struct tnode s1, s2, *sp; |
| |
| struct{ |
| char cdummy; |
| char c; |
| } sc; |
| |
| struct{ |
| char cdummy; |
| short s; |
| } ss; |
| |
| struct{ |
| char cdummy; |
| int i; |
| } si; |
| |
| struct{ |
| char cdummy; |
| long l; |
| } sl; |
| |
| struct{ |
| char cdummy; |
| unsigned u; |
| } su; |
| |
| struct{ |
| char cdummy; |
| float f; |
| } sf; |
| |
| struct{ |
| char cdummy; |
| double d; |
| } sd; |
| |
| int diff[7], j; |
| |
| static char *type[] = { |
| "char", |
| "short", |
| "int", |
| "long", |
| "unsigned", |
| "float", |
| "double" |
| }; |
| |
| static char aln[] = " alignment: "; |
| |
| struct{ |
| int twobit:2; |
| int :1; |
| int threebit:3; |
| int onebit:1; |
| } s3; |
| |
| union{ |
| char u1[30]; |
| short u2[30]; |
| int u3[30]; |
| long u4[30]; |
| unsigned u5[30]; |
| float u6[30]; |
| double u7[30]; |
| } u0; |
| |
| ps = qs85; |
| pt = pd0->rfs; |
| rc = 0; |
| while (*pt++ = *ps++); |
| |
| /* Within a structure, the objects declared have |
| addresses which increase as their declarations are |
| read left to right. |
| */ |
| |
| if( (char *)&s1.count - &s1.tword[0] <= 0 |
| ||(char *)&s1.left - (char *)&s1.count <= 0 |
| ||(char *)&s1.right - (char *)&s1.left <= 0){ |
| if(pd0->flgd != 0) printf(s85er,1); |
| rc = rc+1; |
| } |
| |
| /* Each non-field member of a structure begins on an |
| addressing boundary appropriate to its type. |
| */ |
| |
| diff[0] = &sc.c - &sc.cdummy; |
| diff[1] = (char *)&ss.s - &ss.cdummy; |
| diff[2] = (char *)&si.i - &si.cdummy; |
| diff[3] = (char *)&sl.l - &sl.cdummy; |
| diff[4] = (char *)&su.u - &su.cdummy; |
| diff[5] = (char *)&sf.f - &sf.cdummy; |
| diff[6] = (char *)&sd.d - &sd.cdummy; |
| |
| if(pd0->flgm != 0) |
| for(j=0; j<7; j++) |
| printf("%s%s%d\n",type[j],aln,diff[j]); |
| |
| /* Field specifications are highly implementation de- |
| pendent. About the only thing we can do here is to |
| check is that the compiler accepts the field constructs, |
| and that they seem to work, after a fashion, at |
| run time... |
| */ |
| |
| s3.threebit = 7; |
| s3.twobit = s3.threebit; |
| s3.threebit = s3.twobit; |
| |
| if(s3.threebit != 3){ |
| if(s3.threebit == -1){ |
| if(pd0->flgm != 0) printf("Sign extension in fields\n"); |
| } |
| else{ |
| if(pd0->flgd != 0) printf(s85er,2); |
| rc = rc+2; |
| } |
| } |
| |
| s3.onebit = 1; |
| if(s3.onebit != 1){ |
| if(pd0->flgm != 0) |
| printf("Be especially careful with 1-bit fields!\n"); |
| } |
| |
| /* A union may be thought of as a structure all of whose |
| members begin at offset 0 and whose size is sufficient |
| to contain any of its members. |
| */ |
| |
| if( (char *)u0.u1 - (char *)&u0 != 0 |
| ||(char *)u0.u2 - (char *)&u0 != 0 |
| ||(char *)u0.u3 - (char *)&u0 != 0 |
| ||(char *)u0.u4 - (char *)&u0 != 0 |
| ||(char *)u0.u5 - (char *)&u0 != 0 |
| ||(char *)u0.u6 - (char *)&u0 != 0 |
| ||(char *)u0.u7 - (char *)&u0 != 0){ |
| |
| if(pd0->flgd != 0) printf(s85er,4); |
| rc = rc+4; |
| } |
| |
| if( sizeof u0 < sizeof u0.u1 |
| ||sizeof u0 < sizeof u0.u2 |
| ||sizeof u0 < sizeof u0.u3 |
| ||sizeof u0 < sizeof u0.u4 |
| ||sizeof u0 < sizeof u0.u5 |
| ||sizeof u0 < sizeof u0.u6 |
| ||sizeof u0 < sizeof u0.u7){ |
| |
| if(pd0->flgd != 0) printf(s85er,8); |
| rc = rc+8; |
| } |
| |
| /* Finally, we check that the pointers work. */ |
| |
| s1.right = &s2; |
| s2.tword[0] = 2; |
| s1.right->tword[0] += 1; |
| if(s2.tword[0] != 3){ |
| if(pd0->flgd != 0) printf(s85er,16); |
| rc = rc+16; |
| } |
| return rc; |
| } |
| s86(pd0) /* 8.6 Initialization */ |
| struct defs *pd0; |
| { |
| static char s86er[] = "s86,er%d\n"; |
| static char qs86[8] = "s86 "; |
| int lrc, rc; |
| char *ps, *pt; |
| int one(), i, j, k; |
| static int x[] = {1,3,5}; |
| static int *pint = x+2; |
| static int zero[10]; |
| int *apint = pint-1; |
| register int *rpint = apint+one(); |
| static float y0[] = {1,3,5,2,4,6,3,5,7,0,0,0}; |
| static float y1[4][3] = { |
| {1,3,5}, |
| {2,4,6}, |
| {3,5,7}, |
| }; |
| static float y2[4][3] = {1,3,5,2,4,6,3,5,7}; |
| static float y3[4][3] = { |
| {1},{2},{3},{4} |
| }; |
| ps = qs86; |
| pt = pd0->rfs; |
| rc = 0; |
| while (*pt++ = *ps++); |
| |
| /* The expression in an initializer for a static or |
| external variable must be a constant expression or |
| an expression that reduces to the address of a pre- |
| viously declared variable, possibly offset by a |
| constant expression. |
| */ |
| |
| if(*pint != 5){ |
| if(pd0->flgd != 0) printf(s86er,1); |
| rc = rc+1; |
| } |
| |
| /* Automatic and register variables may be initialized |
| by arbitrary expressions involving constants and previously |
| declared variables and functions. |
| */ |
| |
| if(*apint != 3){ |
| if(pd0->flgd != 0) printf(s86er,2); |
| rc = rc+2; |
| } |
| |
| if(*rpint != 5){ |
| if(pd0->flgd != 0) printf(s86er,4); |
| rc = rc+4; |
| } |
| |
| /* Static variables that are not initialized are guar- |
| anteed to start off as zero. |
| */ |
| |
| lrc = 0; |
| for(j=0; j<10; j++) |
| if(zero[j] != 0) lrc = 1; |
| if(lrc != 0){ |
| if(pd0->flgd != 0) printf(s86er,8); |
| rc = rc+8; |
| } |
| |
| /* y0, y1, and y2, as declared, should define and |
| initialize identical arrays. |
| */ |
| lrc = 0; |
| for(i=0; i<4; i++) |
| for(j=0; j<3; j++){ |
| k = 3*i+j; |
| if( y1[i][j] != y2[i][j] |
| ||y1[i][j] != y0[k]) lrc = 1; |
| } |
| |
| if(lrc != 0){ |
| if(pd0->flgd != 0) printf(s86er,16); |
| rc = rc+16; |
| } |
| |
| /* y3 initializes the first column of the array and |
| leaves the rest zero. |
| */ |
| |
| lrc = 0; |
| for(j=0; j<4; j++) if(y3[j][0] != j+1) lrc = 1; |
| |
| if(lrc != 0){ |
| if(pd0->flgd != 0) printf(s86er,32); |
| rc = rc+32; |
| } |
| return rc; |
| } |
| one(){ |
| return 1; |
| } |
| int *metricp; |
| s88(pd0) /* 8.8 Typedef */ |
| struct defs *pd0; |
| { |
| static char s88er[] = "s88,er%d\n"; |
| static char qs88[8] = "s88 "; |
| int rc; |
| char *ps, *pt; |
| |
| /* Declarations whose "storage class" is typdef do not |
| define storage, but instead define identifiers which |
| can later be used as if they were type keywords naming |
| fundamental or derived types. |
| */ |
| |
| typedef int MILES, *KLICKSP; |
| typedef struct {double re, im;} complex; |
| |
| MILES distance; |
| extern KLICKSP metricp; |
| complex z, *zp; |
| |
| ps = qs88; |
| pt = pd0->rfs; |
| rc = 0; |
| while(*pt++ = *ps++); |
| |
| /* Hopefully, all of this stuff will compile. After that, |
| we can only make some superficial tests. |
| |
| The type of distance is int, |
| */ |
| |
| if(sizeof distance != sizeof(int)){ |
| if(pd0->flgd != 0) printf(s88er,1); |
| rc = rc+1; |
| } |
| |
| /* that of metricp is "pointer to int", */ |
| |
| metricp = &distance; |
| distance = 2; |
| *metricp = 3; |
| |
| if(distance != 3){ |
| if(pd0->flgd != 0) printf(s88er,2); |
| rc = rc+2; |
| } |
| |
| /* and that of z is the specified structure. zp is a |
| pointer to such a structure. |
| */ |
| |
| z.re = 0.; |
| z.im = 0.; |
| zp = &z; |
| zp->re = 1.; |
| zp->im = 1.; |
| if(z.re+z.im != 2.){ |
| if(pd0->flgd != 0) printf(s88er,4); |
| rc = rc+4; |
| } |
| |
| return rc; |
| } |
| s9(pd0) /* 9 Statements */ |
| struct defs *pd0; |
| { |
| static char s9er[] = "s9,er%d\n"; |
| static char qs9[8] = "s9 "; |
| int rc; |
| char *ps, *pt; |
| int lrc, i; |
| |
| ps = qs9; |
| pt = pd0->rfs; |
| rc = 0; |
| while (*pt++ = *ps++); |
| |
| /* One would think that the section on statements would |
| provide the most variety in the entire sequence of tests. |
| As it turns out, most of the material in this section has |
| already been checked in the process of checking out |
| everything else, and the section at this point is somewhat |
| anticlimactic. For this reason, we restrict ourselves |
| to testing two features not already covered. |
| |
| Compound statements are delimited by braces. They have the |
| nice property that identifiers of the auto and register |
| variety are pushed and popped. It is currently legal to |
| transfer into a block, but we wont... |
| */ |
| |
| lrc = 0; |
| for(i=0; i<2; i++){ |
| int j; |
| register int k; |
| j = k = 2; |
| { |
| int j; |
| register int k; |
| j = k = 3; |
| if((j != 3) || (k != 3)) lrc = 1; |
| } |
| if((j != 2) || (k != 2)) lrc = 1; |
| } |
| |
| if(lrc != 0){ |
| if(pd0->flgd != 0) printf(s9er,1); |
| rc = rc+1; |
| } |
| |
| /* Goto statements go to labeled statements, we hope. */ |
| |
| goto nobarf; |
| if(pd0->flgd != 0) printf(s9er,2); |
| rc = rc+2; |
| nobarf:; |
| |
| return rc; |
| } |
| setev(){ /* Sets an external variable. Used */ |
| extern int extvar; /* by s4, and should be compiled */ |
| extvar = 1066; /* separately from s4. */ |
| } |
| int lbits; /* long */ |
| int ubits; /* unsigned */ |
| int fbits; /* float */ |
| int dbits; /* double */ |
| float fprec; /* Smallest number that can be */ |
| float dprec; /* significantly added to 1. */ |
| int flgs; /* Print return codes, by section */ |
| int flgm; /* Announce machine dependencies */ |
| int flgd; /* give explicit diagnostics */ |
| int flgl; /* Report local return codes. */ |
| int rrc; /* recent return code */ |
| int crc; /* Cumulative return code */ |
| char rfs[8]; /* Return from section */ |