5331 lines
123 KiB
C
5331 lines
123 KiB
C
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[])() = {
|
|
#ifndef NO22TO71
|
|
s22,
|
|
s241,
|
|
s243,
|
|
s244,
|
|
s25,
|
|
s26,
|
|
s4,
|
|
s61,
|
|
s626,
|
|
s71,
|
|
#endif
|
|
#ifndef NO714
|
|
s714,
|
|
#endif
|
|
#ifndef NO715TO9
|
|
s715,
|
|
s72,
|
|
s757,
|
|
s7813,
|
|
s81,
|
|
s84,
|
|
s85,
|
|
s86,
|
|
s88,
|
|
s9
|
|
#endif
|
|
};
|
|
|
|
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;
|
|
}
|
|
#ifndef NO22TO71
|
|
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;
|
|
}
|
|
#endif
|
|
#ifndef NO714
|
|
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;
|
|
}
|
|
#endif
|
|
#ifndef NO715TO9
|
|
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;
|
|
}
|
|
#endif
|
|
#ifndef NO22TO71
|
|
setev(){ /* Sets an external variable. Used */
|
|
extern int extvar; /* by s4, and should be compiled */
|
|
extvar = 1066; /* separately from s4. */
|
|
}
|
|
#endif
|
|
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 */
|