URL
https://opencores.org/ocsvn/eco32/eco32/trunk
Subversion Repositories eco32
Compare Revisions
- This comparison shows the changes necessary to convert path
/eco32/tags/eco32-0.25/lcc/tst
- from Rev 4 to Rev 248
- ↔ Reverse comparison
Rev 4 → Rev 248
/spill.0
--- limits.c (nonexistent)
+++ limits.c (revision 248)
@@ -0,0 +1,19 @@
+#include
+
+main() {
+ printf("UCHAR_MAX: %08x=%d\n", UCHAR_MAX, UCHAR_MAX);
+ printf("USHRT_MAX: %08x=%d\n", USHRT_MAX, USHRT_MAX);
+ printf("UINT_MAX: %08x=%d\n", UINT_MAX, UINT_MAX);
+ printf("ULONG_MAX: %08lx=%ld\n", ULONG_MAX, ULONG_MAX);
+ printf("CHAR_MAX: %08x=%d\n", CHAR_MAX, CHAR_MAX);
+ printf("SCHAR_MAX: %08x=%d\n", SCHAR_MAX, SCHAR_MAX);
+ printf("SHRT_MAX: %08x=%d\n", SHRT_MAX, SHRT_MAX);
+ printf("INT_MAX: %08x=%d\n", INT_MAX, INT_MAX);
+ printf("LONG_MAX: %08lx=%ld\n", LONG_MAX, LONG_MAX);
+ printf("CHAR_MIN: %08x=%d\n", CHAR_MIN, CHAR_MIN);
+ printf("SCHAR_MIN: %08x=%d\n", SCHAR_MIN, SCHAR_MIN);
+ printf("SHRT_MIN: %08x=%d\n", SHRT_MIN, SHRT_MIN);
+ printf("INT_MIN: %08x=%d\n", INT_MIN, INT_MIN);
+ printf("LONG_MIN: %08lx=%ld\n", LONG_MIN, LONG_MIN);
+ return 0;
+}
/struct.0
--- switch.c (nonexistent)
+++ switch.c (revision 248)
@@ -0,0 +1,137 @@
+main()
+{
+ int i; char *s;
+
+ for (s = "bfnrtvx"; *s; s++)
+ printf("%c = 0x%x\n", *s, backslash(*s));
+ f();
+ g();
+ h();
+ for (i = 0x1000000; i&0x7000000; i += 0x1000000)
+ big(i);
+ limit();
+ return 0;
+}
+
+backslash(c)
+{
+ switch (c) {
+ case 'b':
+ return '\b';
+ case 'f':
+ return '\f';
+ case 'n':
+ return '\n';
+ case 'r':
+ return '\r';
+ case 't':
+ return '\t';
+ case 'v':
+ return '\v';
+ }
+ return c;
+}
+
+f() {
+ int i, x = 0, y;
+
+ printf("f:\n");
+ for (i = 0; i <= 20; i++) {
+ y = i;
+ switch (i) {
+ case 1: x = i; break;
+ case 2: x = i; break;
+ case 7: x = i; break;
+ case 8: x = i; break;
+ case 9: x = i; break;
+ case 16: x = i; break;
+ case 17: x = i; break;
+ case 18: x = i; break;
+ case 19: x = i; break;
+ case 20: x = i; break;
+ }
+ printf("x = %d\n", x);
+ }
+}
+
+g() {
+ int i;
+
+ printf("g:\n");
+ for (i = 1; i <= 10; i++)
+ switch (i) {
+ case 1: case 2: printf("1 %d\n", i); break;
+ case 3: case 4: case 5: printf("2 %d\n", i); break;
+ case 6: case 7: case 8: printf("3 %d\n", i);
+ default:
+ printf("d %d\n", i); break;
+ case 1001: case 1002: case 1003: case 1004:
+ printf("5 %d\n", i); break;
+ case 3001: case 3002: case 3003: case 3004:
+ printf("6 %d\n", i); break;
+ }
+}
+
+h()
+{
+ int i, n=0;
+
+ printf("h:\n");
+ for (i = 1; i <= 500; i++)
+ switch (i) {
+ default: n++; continue;
+ case 128: printf("i = %d\n", i); break;
+ case 16: printf("i = %d\n", i); break;
+ case 8: printf("i = %d\n", i); break;
+ case 120: printf("i = %d\n", i); break;
+ case 280: printf("i = %d\n", i); break;
+ case 264: printf("i = %d\n", i); break;
+ case 248: printf("i = %d\n", i); break;
+ case 272: printf("i = %d\n", i); break;
+ case 304: printf("i = %d\n", i); break;
+ case 296: printf("i = %d\n", i); break;
+ case 288: printf("i = %d\n", i); break;
+ case 312: printf("i = %d\n", i); break;
+ }
+ printf("%d defaults\n", n);
+}
+
+big(x) unsigned x; {
+ switch(x&0x6000000){
+ case -1:
+ case -2:
+ case 0x0000000:
+ printf("x = 0x%x\n", x); break;
+ case 0x2000000:
+ printf("x = 0x%x\n", x); break;
+ case 0x4000000:
+ printf("x = 0x%x\n", x); break;
+ default:
+ printf("x = 0x%x (default)\n", x); break;
+ }
+}
+
+#include
+
+limit() {
+ int i;
+
+ for (i = INT_MIN; i <= INT_MIN+5; i++)
+ switch (i) {
+ case INT_MIN: printf("0\n"); break;
+ case INT_MIN+1: printf("1\n"); break;
+ case INT_MIN+2: printf("2\n"); break;
+ case INT_MIN+3: printf("3\n"); break;
+ case INT_MIN+4: printf("4\n"); break;
+ default: printf("5\n"); break;
+ }
+ for (i = INT_MAX; i >= INT_MAX-5; i--)
+ switch (i) {
+ case INT_MAX: printf("0\n"); break;
+ case INT_MAX-1: printf("1\n"); break;
+ case INT_MAX-2: printf("2\n"); break;
+ case INT_MAX-3: printf("3\n"); break;
+ case INT_MAX-4: printf("4\n"); break;
+ default: printf("5\n"); break;
+ }
+}
/stdarg.0
--- init.c (nonexistent)
+++ init.c (revision 248)
@@ -0,0 +1,59 @@
+
+typedef struct { int codes[3]; char name[6]; } Word;
+
+Word words[] = {
+ 1, 2, 3, "if",
+ { { 4, 5 }, { 'f', 'o', 'r' } },
+ 6, 7, 8, {"else"},
+ { { 9, 10, 11,}, 'w', 'h', 'i', 'l', 'e', },
+ { 0 },
+}, *wordlist = words;
+
+int x[][5] = { 1, 2, 3, 4, 0, { 5, 6 }, { 7 } };
+int *y[] = { x[0], x[1], x[2], 0 };
+
+
+main()
+{
+ int i, j;
+
+ for (i = 0; y[i]; i++) {
+ for (j = 0; y[i][j]; j++)
+ printf(" %d", y[i][j]);
+ printf("\n");
+ }
+ f();
+ g(wordlist);
+ return 0;
+}
+
+f() {
+ static char *keywords[] = {"if", "for", "else", "while", 0, };
+ char **p;
+
+ for (p = keywords; *p; p++)
+ printf("%s\n", *p);
+}
+
+g(p)
+Word *p;
+{
+ int i;
+
+ for ( ; p->codes[0]; p++) {
+ for (i = 0; i < sizeof p->codes/sizeof(p->codes[0]); i++)
+ printf("%d ", p->codes[i]);
+ printf("%s\n", p->name);
+ }
+ h();
+}
+
+h()
+{
+ int i;
+
+ for (i = 0; i < sizeof(words)/sizeof(Word); i++)
+ printf("%d %d %d %s\n", words[i].codes[0],
+ words[i].codes[1], words[i].codes[2],
+ &words[i].name[0]);
+}
/cq.c
0,0 → 1,5316
struct defs { |
int cbits; /* No. of bits per char */ |
int ibits; /* int */ |
int sbits; /* short */ |
int lbits; /* long */ |
int ubits; /* unsigned */ |
int fbits; /* float */ |
int dbits; /* double */ |
float fprec; /* Smallest number that can be */ |
float dprec; /* significantly added to 1. */ |
int flgs; /* Print return codes, by section */ |
int flgm; /* Announce machine dependencies */ |
int flgd; /* give explicit diagnostics */ |
int flgl; /* Report local return codes. */ |
int rrc; /* recent return code */ |
int crc; /* Cumulative return code */ |
char rfs[8]; /* Return from section */ |
}; |
main(n,args) /* C REFERENCE MANUAL */ |
int n; |
char **args; |
{ |
|
/* This program performs a series of tests on a C compiler, |
based on information in the |
|
C REFERENCE MANUAL |
|
which appears as Appendix A to the book "The C Programming |
Language" by Brian W. Kernighan and Dennis M. Ritchie |
(Prentice-Hall, 1978, $10.95). This Appendix is hereafter |
referred to as "the Manual". |
|
The rules followed in writing this program are: |
|
1. The entire program is written in legal C, according |
to the Manual. It should compile with no error messages, |
although some warning messages may be produced by some |
compilers. Failure to compile should be interpreted as |
a compiler error. |
|
2. The program is clean, in that it does not make use |
of any features of the operating system on which it runs, |
with the sole exceptions of the printf() function, and an |
internal "options" routine, which is easily excised. |
|
3. No global variables are used, except for the spec- |
ific purpose of testing the global variable facility. |
|
The program is divided into modules having names of the |
form snnn... These modules correspond to those sections of the |
Manual, as identified by boldface type headings, in which |
there is something to test. For example, s241() corresponds |
to section 2.4.1 of the Manual (Integer constants) and tests |
the facilities described therein. The module numbering |
scheme is ambiguous, especially when it names modules |
referring to more than one section; module s7813, for ex- |
ample, deals with sections 7.8 through 7.13. Nonetheless, |
it is surprisingly easy to find a section in the Manual |
corresponding to a section of code, and vice versa. |
|
Note also that there seem to be "holes" in the program, |
at least from the point of view that there exist sections in the |
Manual for which there is no corresponding code. Such holes |
arise from three causes: (a) there is nothing in that partic- |
ular section to test, (b) everything in that section is tested |
elsewhere, and (c) it was deemed advisable not to check cer- |
tain features like preprocessor or listing control features. |
|
Modules are called by a main program main(). The mod- |
ules that are called, and the sequence in which they are |
called, are determined by two lists in main(), in which the |
module names appear. The first list (an extern statement) |
declares the module names to be external. The second (a stat- |
ic int statement) names the modules and defines the sequence |
in which they are called. There is no need for these lists |
to be in the same order, but it is probably a good idea to keep |
them that way in the interest of clarity. Since there are no |
cross-linkages between modules, new modules may be added, |
or old ones deleted, simply by editing the lists, with one |
exception: section s26, which pokes around at the hardware |
trying to figure out the characteristics of the machine that |
it is running on, saves information that is subsequently |
used by sections s626, s72, and s757. If this program is |
to be broken up into smallish pieces, say for running on |
a microcomputer, take care to see that s26 is called before |
calling any of the latter three sections. The size |
of the lists, i.e., the number of modules to be called, is |
not explicitly specified as a program parameter, but is |
determined dynamically using the sizeof operator. |
|
Communication between the main program and the modules |
takes place in two ways. In all cases, a pointer to a structure |
is passed to the called module. The structure contains flags |
that will determine the type of information to be published |
by the module, and fields that may be written in by the |
module. The former include "flgm" and "flgd", which, if set |
to a nonzero value, specify that machine dependencies are to |
be announced or that error messages are to be printed, re- |
spectively. The called module's name, and the hardware char- |
acteristics probed in s26() comprise the latter. |
|
|
Also, in all cases, a return code is returned by the called |
module. A return code of zero indicates that all has gone well; |
nonzero indicates otherwise. Since more than one type of error |
may be detected by a module, the return code is a composite |
of error indicators, which, individually, are given as numbers |
that are powers of two. Thus, a return code of 10 indicates |
that two specific errors, 8 and 2, were detected. Whether or |
not the codes returned by the modules are printed by the main |
program is determined by setting "flgs" to 1 (resp. 0). |
|
The entire logic of the main program is contained in the |
half-dozen or so lines at the end. The somewhat cryptic |
statement: |
|
d0.rrc = (*sec[j])(pd0); |
|
in the for loop calls the modules. The rest of the code is |
reasonably straightforward. |
|
Finally, in each of the modules, there is the following |
prologue: |
|
snnn(pd0) |
struct defs *pd0; |
{ |
static char snnner[] = "snnn,er%d\n"; |
static char qsnnn[8] = "snnn "; |
char *ps, *pt; |
int rc; |
|
rc = 0; |
ps = qsnnn; |
pt = pd0->rfs; |
while(*pt++ = *ps++); |
|
used for housekeeping, handshaking and module initialization. |
|
*/ |
extern |
s22(struct defs *), |
s241(struct defs *), |
s243(struct defs *), |
s244(struct defs *), |
s25(struct defs *), |
s26(struct defs *), |
s4(struct defs *), |
s61(struct defs *), |
s626(struct defs *), |
s71(struct defs *), |
s72(struct defs *), |
s757(struct defs *), |
s7813(struct defs *), |
s714(struct defs *), |
s715(struct defs *), |
s81(struct defs *), |
s84(struct defs *), |
s85(struct defs *), |
s86(struct defs *), |
s88(struct defs *), |
s9(struct defs *) |
; |
|
int j; |
static int (*sec[])() = { |
s22, |
s241, |
s243, |
s244, |
s25, |
s26, |
s4, |
s61, |
s626, |
s71, |
s72, |
s757, |
s7813, |
s714, |
s715, |
s81, |
s84, |
s85, |
s86, |
s88, |
s9 |
}; |
|
static struct defs d0, *pd0; |
|
d0.flgs = 1; /* These flags dictate */ |
d0.flgm = 1; /* the verbosity of */ |
d0.flgd = 1; /* the program. */ |
d0.flgl = 1; |
|
pd0 = &d0; |
|
for (j=0; j<sizeof(sec) / sizeof(sec[0]); j++) { |
d0.rrc = (*sec[j])(pd0); |
d0.crc = d0.crc+d0.rrc; |
if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc); |
} |
|
if(d0.crc == 0) printf("\nNo errors detected.\n"); |
else printf("\nFailed.\n"); |
return 0; |
} |
s22(pd0) /* 2.2 Identifiers (Names) */ |
struct defs *pd0; |
{ |
int a234, a; |
int _, _234, A, rc; |
|
static char s22er[] = "s22,er%d\n"; |
static char qs22[8] = "s22 "; |
|
char *ps, *pt; |
/* Initialize */ |
|
rc = 0; |
ps = qs22; |
pt = pd0 -> rfs; |
while (*pt++ = *ps++); |
|
/* An identifier is a sequence of letters and digits; |
the first character must be a letter. The under- |
score _ counts as a letter. */ |
|
a=1; |
_=2; |
_234=3; |
a234=4; |
if(a+_+_234+a234 != 10) { |
rc = rc+1; |
if(pd0->flgd != 0) printf(s22er,1); |
} |
|
/* Upper and lower case letters are different. */ |
|
A = 2; |
if (A == a) { |
rc = rc+4; |
if (pd0->flgd != 0) printf(s22er,4); |
} |
|
return(rc); |
} |
s241(pd0) /* 2.4.1 Integer constants |
2.4.2 Explicit long constants */ |
struct defs *pd0; |
{ |
long pow2(); |
static char s241er[] = "s241,er%d\n"; |
static char qs241[8] = "s241 "; |
char *ps, *pt; |
int rc, j, lrc; |
static long g[39] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
0,6,0,8,0,12,0,16,0,18,0,20,0,24, |
0,28,0,30,0,32,0,36}; |
long d[39], o[39], x[39]; |
|
rc = 0; |
lrc = 0; |
ps = qs241; |
pt = pd0 -> rfs; |
while (*pt++ = *ps++); |
|
/* An integer constant consisting of a sequence of digits is |
taken to be octal if it begins with 0 (digit zero), decimal |
otherwise. */ |
|
if ( 8 != 010 |
|| 16 != 020 |
|| 24 != 030 |
|| 32 != 040 |
|| 40 != 050 |
|| 48 != 060 |
|| 56 != 070 |
|| 64 != 0100 |
|| 72 != 0110 |
|| 80 != 0120 |
|| 9 != 0011 |
|| 17 != 0021 |
|| 25 != 0031 |
|| 33 != 0041 |
|| 41 != 0051 |
|| 49 != 0061 |
|| 57 != 0071 |
|| 65 != 0101 |
|| 73 != 0111 |
|| 81 != 0121 ){ |
|
rc = rc+1; |
if( pd0->flgd != 0 ) printf(s241er,1); |
} |
|
/* A sequence of digits preceded by 0x or 0X (digit zero) |
is taken to be a hexadecimal integer. The hexadecimal |
digits include a or A through f or F with values 10 |
through 15. */ |
|
if ( 0x00abcdef != 0xabcdef |
|| 0xabcdef != 0Xabcdef || 0Xabcdef != 0XAbcdef |
|| 0XAbcdef != 0XABcdef || 0XABcdef != 0XABCdef |
|| 0XABCdef != 0XABCDef || 0XABCDef != 0XABCDEf |
|| 0XABCDEf != 0XABCDEF || 0xABCDEF != 11259375 ){ |
|
rc = rc+2; |
if( pd0->flgd != 0 ) printf(s241er,2); |
} |
|
/* A decimal constant whose value exceeds the largest signed |
machine integer is taken to be long; an octal or hex con- |
stant which exceeds the largest unsigned machine integer |
is likewise taken to be long. */ |
|
if ( sizeof 010000000000 != sizeof(long) /* 2**30 */ |
|| sizeof 1073741824 != sizeof(long) /* ditto */ |
|| sizeof 0x40000000 != sizeof(long) ){ /* " */ |
|
rc = rc+4; |
if( pd0->flgd != 0 ) printf(s241er,4); |
} |
|
/* A decimal, octal, or hexadecimal constant immediately followed |
by l (letter ell) or L is a long constant. */ |
|
if ( sizeof 67l != sizeof(long) |
|| sizeof 67L != sizeof(long) |
|| sizeof 067l != sizeof(long) |
|| sizeof 067L != sizeof(long) |
|| sizeof 0X67l != sizeof(long) |
|| sizeof 0x67L != sizeof(long) ){ |
|
rc = rc+8; |
if( pd0 -> flgd != 0 ) printf(s241er,8); |
} |
|
/* Finally, we test to see that decimal (d), octal (o), |
and hexadecimal (x) constants representing the same values |
agree among themselves, and with computed values, at spec- |
ified points over an appropriate range. The points select- |
ed here are those with the greatest potential for caus- |
ing trouble, i.e., zero, 1-16, and values of 2**n and |
2**n - 1 where n is some multiple of 4 or 6. Unfortunately, |
just what happens when a value is too big to fit in a |
long is undefined; however, it would be nice if what |
happened were at least consistent... */ |
|
for ( j=0; j<17; j++ ) g[j] = j; |
for ( j=18; j<39; ) { |
g[j] = pow2(g[j]); |
g[j-1] = g[j] - 1; |
j = j+2; |
} |
|
d[0] = 0; o[0] = 00; x[0] = 0x0; |
d[1] = 1; o[1] = 01; x[1] = 0x1; |
d[2] = 2; o[2] = 02; x[2] = 0x2; |
d[3] = 3; o[3] = 03; x[3] = 0x3; |
d[4] = 4; o[4] = 04; x[4] = 0x4; |
d[5] = 5; o[5] = 05; x[5] = 0x5; |
d[6] = 6; o[6] = 06; x[6] = 0x6; |
d[7] = 7; o[7] = 07; x[7] = 0x7; |
d[8] = 8; o[8] = 010; x[8] = 0x8; |
d[9] = 9; o[9] = 011; x[9] = 0x9; |
d[10] = 10; o[10] = 012; x[10] = 0xa; |
d[11] = 11; o[11] = 013; x[11] = 0xb; |
d[12] = 12; o[12] = 014; x[12] = 0xc; |
d[13] = 13; o[13] = 015; x[13] = 0xd; |
d[14] = 14; o[14] = 016; x[14] = 0xe; |
d[15] = 15; o[15] = 017; x[15] = 0xf; |
d[16] = 16; o[16] = 020; x[16] = 0x10; |
d[17] = 63; o[17] = 077; x[17] = 0x3f; |
d[18] = 64; o[18] = 0100; x[18] = 0x40; |
d[19] = 255; o[19] = 0377; x[19] = 0xff; |
d[20] = 256; o[20] = 0400; x[20] = 0x100; |
d[21] = 4095; o[21] = 07777; x[21] = 0xfff; |
d[22] = 4096; o[22] = 010000; x[22] = 0x1000; |
d[23] = 65535; o[23] = 0177777; x[23] = 0xffff; |
d[24] = 65536; o[24] = 0200000; x[24] = 0x10000; |
d[25] = 262143; o[25] = 0777777; x[25] = 0x3ffff; |
d[26] = 262144; o[26] = 01000000; x[26] = 0x40000; |
d[27] = 1048575; o[27] = 03777777; x[27] = 0xfffff; |
d[28] = 1048576; o[28] = 04000000; x[28] = 0x100000; |
d[29] = 16777215; o[29] = 077777777; x[29] = 0xffffff; |
d[30] = 16777216; o[30] = 0100000000; x[30] = 0x1000000; |
d[31] = 268435455; o[31] = 01777777777; x[31] = 0xfffffff; |
d[32] = 268435456; o[32] = 02000000000; x[32] = 0x10000000; |
d[33] = 1073741823; o[33] = 07777777777; x[33] = 0x3fffffff; |
d[34] = 1073741824; o[34] = 010000000000; x[34] = 0x40000000; |
d[35] = 4294967295; o[35] = 037777777777; x[35] = 0xffffffff; |
d[36] = 4294967296; o[36] = 040000000000; x[36] = 0x100000000; |
d[37] = 68719476735; o[37] = 0777777777777; x[37] = 0xfffffffff; |
d[38] = 68719476736; o[38] = 01000000000000; x[38] = 0x1000000000; |
|
/* WHEW! */ |
|
for (j=0; j<39; j++){ |
if ( g[j] != d[j] |
|| d[j] != o[j] |
|| o[j] != x[j]) { |
|
if( pd0 -> flgm != 0 ) { |
/* printf(s241er,16); save in case opinions change... */ |
printf("Decimal and octal/hex constants sometimes give\n"); |
printf(" different results when assigned to longs.\n"); |
} |
/* lrc = 1; save... */ |
} |
} |
|
if (lrc != 0) rc =16; |
|
return rc; |
} |
|
long pow2(n) /* Calculate 2**n by multiplying, not shifting */ |
long n; |
{ |
long s; |
s = 1; |
while(n--) s = s*2; |
return s; |
} |
s243(pd0) /* 2.4.3 Character constants */ |
struct defs *pd0; |
{ |
static char s243er[] = "s243,er%d\n"; |
static char qs243[8] = "s243 "; |
char *ps, *pt; |
int rc; |
char chars[256]; |
|
rc = 0; |
ps = qs243; |
pt = pd0->rfs; |
while(*pt++ = *ps++); |
|
/* One of the problems that arises when testing character constants |
is that of definition: What, exactly, is the character set? |
In order to guarantee a certain amount of machine independence, |
the character set we will use here is the set of characters writ- |
able as escape sequences in C, plus those characters used in writ- |
ing C programs, i.e., |
|
letters: |
ABCDEFGHIJKLMNOPQRSTUVWXYZ 26 |
abcdefghijklmnopqrstuvwxyz 26 |
numbers: |
0123456789 10 |
special characters: |
~!"#%&()_=-^|{}[]+;*:<>,.?/ 27 |
extra special characters: |
newline \n |
horizontal tab \t |
backspace \b |
carriage return \r |
form feed \f |
backslash \\ |
single quote \' 7 |
blank & NUL 2 |
--- |
98 |
|
Any specific implementation of C may of course support additional |
characters. */ |
|
/* Since the value of a character constant is the numerical value |
of the character in the machine's character set, there should |
be a one-to-one correspondence between characters and values. */ |
|
zerofill(chars); |
|
chars['a'] = 1; chars['A'] = 1; chars['~'] = 1; chars['0'] = 1; |
chars['b'] = 1; chars['B'] = 1; chars['!'] = 1; chars['1'] = 1; |
chars['c'] = 1; chars['C'] = 1; chars['"'] = 1; chars['2'] = 1; |
chars['d'] = 1; chars['D'] = 1; chars['#'] = 1; chars['3'] = 1; |
chars['e'] = 1; chars['E'] = 1; chars['%'] = 1; chars['4'] = 1; |
chars['f'] = 1; chars['F'] = 1; chars['&'] = 1; chars['5'] = 1; |
chars['g'] = 1; chars['G'] = 1; chars['('] = 1; chars['6'] = 1; |
chars['h'] = 1; chars['H'] = 1; chars[')'] = 1; chars['7'] = 1; |
chars['i'] = 1; chars['I'] = 1; chars['_'] = 1; chars['8'] = 1; |
chars['j'] = 1; chars['J'] = 1; chars['='] = 1; chars['9'] = 1; |
chars['k'] = 1; chars['K'] = 1; chars['-'] = 1; |
chars['l'] = 1; chars['L'] = 1; chars['^'] = 1; |
chars['m'] = 1; chars['M'] = 1; chars['|'] = 1; chars['\n'] = 1; |
chars['n'] = 1; chars['N'] = 1; chars['\t'] = 1; |
chars['o'] = 1; chars['O'] = 1; chars['{'] = 1; chars['\b'] = 1; |
chars['p'] = 1; chars['P'] = 1; chars['}'] = 1; chars['\r'] = 1; |
chars['q'] = 1; chars['Q'] = 1; chars['['] = 1; chars['\f'] = 1; |
chars['r'] = 1; chars['R'] = 1; chars[']'] = 1; |
chars['s'] = 1; chars['S'] = 1; chars['+'] = 1; chars['\\'] = 1; |
chars['t'] = 1; chars['T'] = 1; chars[';'] = 1; chars['\''] = 1; |
chars['u'] = 1; chars['U'] = 1; chars['*'] = 1; |
chars['v'] = 1; chars['V'] = 1; chars[':'] = 1; chars['\0'] = 1; |
chars['w'] = 1; chars['W'] = 1; chars['<'] = 1; chars[' '] = 1; |
chars['x'] = 1; chars['X'] = 1; chars['>'] = 1; |
chars['y'] = 1; chars['Y'] = 1; chars[','] = 1; |
chars['z'] = 1; chars['Z'] = 1; chars['.'] = 1; |
chars['?'] = 1; |
chars['/'] = 1; |
|
if(sumof(chars) != 98){ |
rc = rc+1; |
if(pd0->flgd != 0) printf(s243er,1); |
} |
|
/* Finally, the escape \ddd consists of the backslash followed |
by 1, 2, or 3 octal digits which are taken to specify the |
desired character. */ |
|
if( '\0' != 0 || '\01' != 1 || '\02' != 2 |
|| '\03' != 3 || '\04' != 4 || '\05' != 5 |
|| '\06' != 6 || '\07' != 7 || '\10' != 8 |
|| '\17' != 15 || '\20' != 16 || '\77' != 63 |
|| '\100' != 64 || '\177' != 127 ){ |
|
rc = rc+8; |
if(pd0->flgd != 0) printf(s243er,8); |
} |
|
return rc; |
} |
zerofill(x) |
char *x; |
{ |
int j; |
|
for (j=0; j<256; j++) *x++ = 0; |
} |
sumof(x) |
char *x; |
{ |
char *p; |
int total, j; |
|
p = x; |
total = 0; |
|
for(j=0; j<256; j++) total = total+ *p++; |
return total; |
} |
s244(pd0) |
struct defs *pd0; |
{ |
double a[8]; |
int rc, lrc, j; |
static char s244er[] = "s244,er%d\n"; |
static char qs244[8] = "s244 "; |
char *ps, *pt; |
|
ps = qs244; |
pt = pd0->rfs; |
while(*pt++ = *ps++); |
rc = 0; |
lrc = 0; |
|
/* Unfortunately, there's not a lot we can do with floating constants. |
We can check to see that the various representations can be com- |
piled, that the conversion is such that they yield the same hard- |
ware representations in all cases, and that all representations |
thus checked are double precision. */ |
|
a[0] = .1250E+04; |
a[1] = 1.250E3; |
a[2] = 12.50E02; |
a[3] = 125.0e+1; |
a[4] = 1250e00; |
a[5] = 12500.e-01; |
a[6] = 125000e-2; |
a[7] = 1250.; |
|
lrc = 0; |
for (j=0; j<7; j++) if(a[j] != a[j+1]) lrc = 1; |
|
if(lrc != 0) { |
if(pd0->flgd != 0) printf(s244er,1); |
rc = rc+1; |
} |
|
if ( (sizeof .1250E+04 ) != sizeof(double) |
|| (sizeof 1.250E3 ) != sizeof(double) |
|| (sizeof 12.50E02 ) != sizeof(double) |
|| (sizeof 1.250e+1 ) != sizeof(double) |
|| (sizeof 1250e00 ) != sizeof(double) |
|| (sizeof 12500.e-01) != sizeof(double) |
|| (sizeof 125000e-2 ) != sizeof(double) |
|| (sizeof 1250. ) != sizeof(double)){ |
|
if(pd0->flgd != 0) printf(s244er,2); |
rc = rc+2; |
} |
|
return rc; |
} |
s25(pd0) |
struct defs *pd0; |
{ |
char *s, *s2; |
int rc, lrc, j; |
static char s25er[] = "s25,er%d\n"; |
static char qs25[8] = "s25 "; |
char *ps, *pt; |
|
ps = qs25; |
pt = pd0->rfs; |
while(*pt++ = *ps++); |
rc = 0; |
|
/* A string is a sequence of characters surrounded by double |
quotes, as in "...". */ |
|
s = "..."; |
|
/* A string has type "array of characters" and storage class |
static and is initialized with the given characters. */ |
|
if ( s[0] != s[1] || s[1] != s[2] |
|| s[2] != '.' ) { |
|
rc = rc+1; |
if(pd0->flgd != 0) printf(s25er,1); |
} |
|
/* The compiler places a null byte \0 at the end of each string |
so the program which scans the string can find its end. */ |
|
if( s[3] != '\0' ){ |
rc = rc+4; |
if(pd0->flgd != 0) printf(s25er,4); |
} |
|
/* In a string, the double quote character " must be preceded |
by a \. */ |
|
if( ".\"."[1] != '"' ){ |
rc = rc+8; |
if(pd0->flgd != 0) printf(s25er,8); |
} |
|
/* In addition, the same escapes described for character constants |
may be used. */ |
|
s = "\n\t\b\r\f\\\'"; |
|
if( s[0] != '\n' |
|| s[1] != '\t' |
|| s[2] != '\b' |
|| s[3] != '\r' |
|| s[4] != '\f' |
|| s[5] != '\\' |
|| s[6] != '\'' ){ |
|
rc = rc+16; |
if( pd0->flgd != 0) printf(s25er,16); |
} |
|
/* Finally, a \ and an immediately following newline are ignored */ |
|
s2 = "queep!"; |
s = "queep!"; |
|
lrc = 0; |
for (j=0; j<sizeof "queep!"; j++) if(s[j] != s2[j]) lrc = 1; |
if (lrc != 0){ |
rc = rc+32; |
if(pd0->flgd != 0) printf(s25er,32); |
} |
return rc; |
} |
s26(pd0) /* 2.6 Hardware Characteristics */ |
struct defs *pd0; |
{ |
static char qs26[8] = "s26 "; |
char *ps, *pt; |
char c0, c1; |
float temp, one, delta; |
double tempd, oned; |
static char s[] = "%3d bits in %ss.\n"; |
static char s2[] = "%e is the least number that can be added to 1. (%s).\n"; |
|
ps = qs26; |
pt = pd0->rfs; |
|
while(*pt++ = *ps++); |
|
/* Here, we shake the machinery a little to see what falls |
out. First, we find out how many bits are in a char. */ |
|
pd0->cbits = 0; |
c0 = 0; |
c1 = 1; |
|
while(c0 != c1) { |
c1 = c1<<1; |
pd0->cbits = pd0->cbits+1; |
} |
/* That information lets us determine the size of everything else. */ |
|
pd0->ibits = pd0->cbits * sizeof(int); |
pd0->sbits = pd0->cbits * sizeof(short); |
pd0->lbits = pd0->cbits * sizeof(long); |
pd0->ubits = pd0->cbits * sizeof(unsigned); |
pd0->fbits = pd0->cbits * sizeof(float); |
pd0->dbits = pd0->cbits * sizeof(double); |
|
/* We have now almost reconstructed the table in section 2.6, the |
exception being the range of the floating point hardware. |
Now there are just so many ways to conjure up a floating point |
representation system that it's damned near impossible to guess |
what's going on by writing a program to interpret bit patterns. |
Further, the information isn't all that useful, if we consider |
the fact that machines that won't handle numbers between 10**30 |
and 10**-30 are very hard to find, and that people playing with |
numbers outside that range have a lot more to worry about than |
just the capacity of the characteristic. |
|
A much more useful measure is the precision, which can be ex- |
pressed in terms of the smallest number that can be added to |
1. without loss of significance. We calculate that here, for |
float and double. */ |
|
one = 1.; |
delta = 1.; |
temp = 0.; |
while(temp != one) { |
temp = one+delta; |
delta = delta/2.; |
} |
pd0->fprec = delta * 4.; |
oned = 1.; |
delta = 1.; |
tempd = 0.; |
while(tempd != oned) { |
tempd = oned+delta; |
delta = delta/2.; |
} |
pd0->dprec = delta * 4.; |
|
/* Now, if anyone's interested, we publish the results. */ |
|
if(pd0->flgm != 0) { |
printf(s,pd0->cbits,"char"); |
printf(s,pd0->ibits,"int"); |
printf(s,pd0->sbits,"short"); |
printf(s,pd0->lbits,"long"); |
printf(s,pd0->ubits,"unsigned"); |
printf(s,pd0->fbits,"float"); |
printf(s,pd0->dbits,"double"); |
printf(s2,pd0->fprec,"float"); |
printf(s2,pd0->dprec,"double"); |
} |
/* Since we are only exploring and perhaps reporting, but not |
testing any features, we cannot return an error code. */ |
|
return 0; |
} |
int extvar; |
s4(pd0) /* 4. What's in a name? */ |
struct defs *pd0; |
{ |
static char s4er[] = "s4,er%d\n"; |
static char qs4[8] = "s4 "; |
char *ps, *pt; |
int j, rc; |
|
short sint; /* short integer, for size test */ |
int pint; /* plain */ |
long lint; /* long */ |
unsigned target; |
unsigned int mask; |
|
rc = 0; |
ps = qs4; |
pt = pd0->rfs; |
|
while(*pt++ = *ps++); |
|
/* There are four declarable storage classes: automatic, |
static, external, and register. Automatic variables have |
been dealt with extensively thus far, and will not be specif- |
ically treated in this section. Register variables are treated |
in section s81. |
|
Static variables are local to a block, but retain their |
values upon reentry to a block, even after control has left |
the block. */ |
|
for (j=0; j<3; j++) |
if(svtest(j) != zero()){ |
rc = 1; |
if(pd0->flgd != 0) printf(s4er,1); |
} |
; |
|
/* External variables exist and retain their values throughout |
the execution of the entire program, and may be used for comm- |
unication between functions, even separately compiled functions. |
*/ |
|
setev(); |
if(testev() != 0){ |
rc=rc+2; |
if(pd0->flgd != 0) printf(s4er,2); |
} |
/* |
Characters have been tested elsewhere (in s243). |
|
Up to three sizes of integer, declared short int, int, and |
long int, are available. Longer integers provide no less storage |
than shorter ones, but implementation may make either short |
integers, or long integers, or both, equivalent to plain |
integers. |
*/ |
|
if(sizeof lint < sizeof pint || sizeof pint < sizeof sint){ |
|
rc = rc+4; |
if(pd0->flgd != 0) printf(s4er,4); |
} |
|
/* Unsigned integers, declared unsigned, obey the laws of |
arithmetic modulo 2**n, where n is the number of bits in the |
implementation */ |
|
target = ~0U; |
mask = 1; |
|
for(j=0; j<(sizeof target)*pd0->cbits; j++){ |
|
mask = mask⌖ |
target = target>>1; |
} |
|
if(mask != 1 || target != 0){ |
|
rc = rc+8; |
if(pd0->flgd != 0) printf(s4er,8); |
} |
|
return rc; |
} |
svtest(n) |
int n; |
{ |
static k; |
int rc; |
switch (n) { |
|
case 0: k = 1978; |
rc = 0; |
break; |
|
case 1: if(k != 1978) rc = 1; |
else{ |
k = 1929; |
rc = 0; |
} |
break; |
|
case 2: if(k != 1929) rc = 1; |
else rc = 0; |
break; |
} |
return rc; |
} |
zero(){ /* Returns a value of zero, possibly */ |
static k; /* with side effects, as it's called */ |
int rc; /* alternately with svtest, above, */ |
k = 2; /* and has the same internal storage */ |
rc = 0; /* requirements. */ |
return rc; |
} |
testev(){ |
if(extvar != 1066) return 1; |
else return 0; |
} |
s61(pd0) /* Characters and integers */ |
struct defs *pd0; |
{ |
static char s61er[] = "s61,er%d\n"; |
static char qs61[8] = "s61 "; |
short from, shortint; |
long int to, longint; |
int rc, lrc; |
int j; |
char fromc, charint; |
char *wd, *pc[6]; |
|
static char upper_alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; |
static char lower_alpha[] = "abcdefghijklmnopqrstuvwxyz"; |
static char numbers[] = "0123456789"; |
static char special_characters[] = "~!\"#%&()_=-^|{}[]+;*:<>,.?/"; |
static char extra_special_characters[] = "\n\t\b\r\f\\\'"; |
static char blank_and_NUL[] = " \0"; |
|
char *ps, *pt; |
ps = qs61; |
pt = pd0->rfs; |
rc = 0; |
while (*pt++ = *ps++); |
|
/* A character or a short integer may be used wherever |
an integer may be used. In all cases, the value is converted |
to integer. This principle is extensively used throughout this |
program, and will not be explicitly tested here. */ |
|
/* Conversion of a shorter integer to a longer always |
involves sign extension. */ |
|
from = -19; |
to = from; |
|
if(to != -19){ |
rc = rc+1; |
if(pd0->flgd != 0) printf(s61er,1); |
} |
|
/* It is guaranteed that a member of the standard char- |
acter set is nonnegative. */ |
|
pc[0] = upper_alpha; |
pc[1] = lower_alpha; |
pc[2] = numbers; |
pc[3] = special_characters; |
pc[4] = extra_special_characters; |
pc[5] = blank_and_NUL; |
|
lrc = 0; |
for (j=0; j<6; j++) |
while(*pc[j]) if(*pc[j]++ < 0) lrc =1; |
|
if(lrc != 0){ |
rc=rc+2; |
if(pd0->flgd != 0) printf(s61er,2); |
} |
|
/* When a longer integer is converted to a shorter or |
to a char, it is truncated on the left; excess bits are |
simply discarded. */ |
|
longint = 1048579; /* =2**20+3 */ |
shortint = longint; |
charint = longint; |
|
if((shortint != longint && shortint != 3) || |
(charint != longint && charint != 3)) { |
rc = rc+8; |
if(pd0->flgd != 0) printf(s61er,8); |
} |
|
return rc; |
} |
s626(pd0) /* 6.2 Float and double */ |
/* 6.3 Floating and integral */ |
/* 6.4 Pointers and integers */ |
/* 6.5 Unsigned */ |
/* 6.6 Arithmetic conversions */ |
struct defs *pd0; |
{ |
static char s626er[] = "s626,er%d\n"; |
static char qs626[8] = "s626 "; |
int rc; |
char *ps, *pt; |
float eps, f1, f2, f3, f4, f; |
long lint1, lint2, l, ls; |
char c, t[28], t0; |
short s; |
int is, i, j; |
unsigned u, us; |
double d, ds; |
ps = qs626; |
pt = pd0->rfs; |
rc = 0; |
while (*pt++ = *ps++); |
|
/* Conversions of integral values to floating type are |
well-behaved. */ |
|
f1 = 1.; |
lint1 = 1.; |
lint2 = 1.; |
|
for(j=0;j<pd0->lbits-2;j++){ |
f1 = f1*2; |
lint2 = (lint2<<1)|lint1; |
} |
f2 = lint2; |
f1 = (f1-f2)/f1; |
if(f1>2.*pd0->fprec){ |
|
rc = rc+2; |
if(pd0->flgd != 0) printf(s626er,2); |
} |
|
/* Pointer-integer combinations are discussed in s74, |
"Additive operators". The unsigned-int combination |
appears below. */ |
|
c = 125; |
s = 125; |
i = 125; is = 15625; |
u = 125; us = 15625; |
l = 125; ls = 15625; |
f = 125.; |
d = 125.; ds = 15625.; |
|
for(j=0;j<28;j++) t[j] = 0; |
|
if(c*c != is) t[ 0] = 1; |
if(s*c != is) t[ 1] = 1; |
if(s*s != is) t[ 2] = 1; |
if(i*c != is) t[ 3] = 1; |
if(i*s != is) t[ 4] = 1; |
if(i*i != is) t[ 5] = 1; |
if(u*c != us) t[ 6] = 1; |
if(u*s != us) t[ 7] = 1; |
if(u*i != us) t[ 8] = 1; |
if(u*u != us) t[ 9] = 1; |
if(l*c != ls) t[10] = 1; |
if(l*s != ls) t[11] = 1; |
if(l*i != ls) t[12] = 1; |
if(l*u != us) t[13] = 1; |
if(l*l != ls) t[14] = 1; |
if(f*c != ds) t[15] = 1; |
if(f*s != ds) t[16] = 1; |
if(f*i != ds) t[17] = 1; |
if(f*u != ds) t[18] = 1; |
if(f*l != ds) t[19] = 1; |
if(f*f != ds) t[20] = 1; |
if(d*c != ds) t[21] = 1; |
if(d*s != ds) t[22] = 1; |
if(d*i != ds) t[23] = 1; |
if(d*u != ds) t[24] = 1; |
if(d*l != ds) t[25] = 1; |
if(d*f != ds) t[26] = 1; |
if(d*d != ds) t[27] = 1; |
|
t0 = 0; |
for(j=0; j<28; j++) t0 = t0+t[j]; |
|
if(t0 != 0){ |
|
rc = rc+4; |
if(pd0->flgd != 0){ |
|
printf(s626er,4); |
printf(" key="); |
for(j=0;j<28;j++) printf("%d",t[j]); |
printf("\n"); |
} |
} |
|
/* When an unsigned integer is converted to long, |
the value of the result is the same numerically |
as that of the unsigned integer. */ |
|
l = (unsigned)0100000; |
if((long)l > (unsigned)0100000){ |
|
rc = rc+8; |
if(pd0->flgd != 0) printf(s626er,8); |
} |
|
return rc; |
} |
s71(pd0) /* 7.1 Primary expressions */ |
struct defs *pd0; |
{ |
static char s71er[] = "s71,er%d\n"; |
static char qs71[8] = "s71 "; |
int rc; |
char *ps, *pt; |
static char q = 'q'; |
int x[10], McCarthy(), clobber(), a, b, *p; |
ps = qs71; |
pt = pd0->rfs; |
rc = 0; |
while (*pt++ = *ps++); |
|
/* Testing of expressions and operators is quite complicated, |
because (a) problems are apt to surface in queer combinations |
of operators and operands, rather than in isolation, |
and (b) the number of expressions needed to provoke a case |
of improper behaviour may be quite large. Hence, we take the |
following approach: for this section, and for subsequent |
sections through 7.15, we will check the primitive operations |
in isolation, thus verifying that the primitives work, |
after a fashion. The job of testing combinations, we will |
leave to a separate, machine-generated program, to be included |
in the C test package at some later date. |
*/ |
|
/* A string is a primary expression. The identifier points to |
the first character of a string. |
*/ |
|
if(*"queep" != q){ |
rc = rc+1; |
if(pd0->flgd != 0) printf(s71er,1); |
} |
/* A parenthesized expression is a primary expression whose |
type and value are the same as those of the unadorned |
expression. |
*/ |
if((2+3) != 2+3) { |
rc = rc+2; |
if(pd0->flgd != 0) printf(s71er,2); |
} |
|
/* A primary expression followed by an expression in square |
brackets is a primary expression. The intuitive meaning is |
that of a subscript. The expression E1[E2] is identical |
(by definition) to *((E1)+(E2)). |
*/ |
|
x[5] = 1942; |
if(x[5] != 1942 || x[5] != *((x)+(5))){ |
rc = rc+4; |
if(pd0->flgd != 0) printf(s71er,4); |
} |
|
/* If the various flavors of function calls didn't work, we |
would never have gotten this far; however, we do need to |
show that functions can be recursive... |
*/ |
|
if ( McCarthy(-5) != 91){ |
rc = rc+8; |
if(pd0->flgd != 0) printf(s71er,8); |
} |
|
/* and that argument passing is strictly by value. */ |
|
a = 2; |
b = 3; |
p = &b; |
|
clobber(a,p); |
|
if(a != 2 || b != 2){ |
rc = rc+16; |
if(pd0->flgd != 0) printf(s71er,16); |
} |
|
/* Finally, structures and unions are addressed thusly: */ |
|
if(pd0->dprec != (*pd0).dprec){ |
rc = rc+32; |
if(pd0->flgd != 0) printf(s71er,32); |
} |
|
return rc; |
} |
McCarthy(x) |
int x; |
{ |
if(x>100) return x-10; |
else return McCarthy( McCarthy(x+11)); |
} |
clobber(x,y) |
int x, *y; |
{ |
x = 3; |
*y = 2; |
} |
s714(pd0) /* 7.14 Assignment operators */ |
struct defs *pd0; |
{ |
static char f[] = "Local error %d.\n"; |
static char s714er[] = "s714,er%d\n"; |
static char qs714[8] = "s714 "; |
register int prlc, lrc; |
int rc; |
char cl, cr; |
short sl, sr; |
int il, ir; |
long ll, lr; |
unsigned ul, ur; |
float fl, fr; |
double dl, dr; |
char *ps, *pt; |
ps = qs714; |
pt = pd0->rfs; |
rc = 0; |
lrc = 0; |
prlc = pd0->flgl; |
while (*pt++ = *ps++); |
|
/* This section tests the assignment operators. |
|
It is an exhaustive test of all assignment statements |
of the form: |
|
vl op vr |
|
where vl and vr are variables from the set |
{char,short,int,long,unsigned,float,double} and op is |
one of the assignment operators. There are 395 such |
statements. |
|
The initial values for the variables have been chosen |
so that both the initial values and the results will |
"fit" in just about any implementation, and that the re- |
sults will be such that they test for the proper form- |
ation of composite operators, rather than checking for |
the valid operation of those operators' components. |
For example, in checking >>=, we want to verify that |
a right shift and a move take place, rather than |
whether or not there may be some peculiarities about |
the right shift. Such tests have been made previously, |
and to repeat them here would be to throw out a red |
herring. |
|
The table below lists the operators, assignment targets, |
initial values for left and right operands, and the |
expected values of the results. |
|
|
= += -= *= /= %= >>= <<= &= ^= |= |
char 2 7 3 10 2 1 1 20 8 6 14 |
short 2 7 3 10 2 1 1 20 8 6 14 |
int 2 7 3 10 2 1 1 20 8 6 14 |
long 2 7 3 10 2 1 1 20 8 6 14 |
unsigned 2 7 3 10 2 1 1 20 8 6 14 |
float 2 7 3 10 2.5 | | |
double 2 7 3 10 2.5 | | |
| | |
initial (5,2) | (5,2) | (12,10) |
|
The following machine-generated program reflects the |
tests described in the table. |
*/ |
|
cl = 5; cr = 2; |
cl = cr; |
if(cl != 2){ |
lrc = 1; |
if(prlc) printf(f,lrc); |
} |
cl = 5; sr = 2; |
cl = sr; |
if(cl != 2){ |
lrc = 2; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ir = 2; |
cl = ir; |
if(cl != 2){ |
lrc = 3; |
if(prlc) printf(f,lrc); |
} |
cl = 5; lr = 2; |
cl = lr; |
if(cl != 2){ |
lrc = 4; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ur = 2; |
cl = ur; |
if(cl != 2){ |
lrc = 5; |
if(prlc) printf(f,lrc); |
} |
cl = 5; fr = 2; |
cl = fr; |
if(cl != 2){ |
lrc = 6; |
if(prlc) printf(f,lrc); |
} |
cl = 5; dr = 2; |
cl = dr; |
if(cl != 2){ |
lrc = 7; |
if(prlc) printf(f,lrc); |
} |
sl = 5; cr = 2; |
sl = cr; |
if(sl != 2){ |
lrc = 8; |
if(prlc) printf(f,lrc); |
} |
sl = 5; sr = 2; |
sl = sr; |
if(sl != 2){ |
lrc = 9; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ir = 2; |
sl = ir; |
if(sl != 2){ |
lrc = 10; |
if(prlc) printf(f,lrc); |
} |
sl = 5; lr = 2; |
sl = lr; |
if(sl != 2){ |
lrc = 11; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ur = 2; |
sl = ur; |
if(sl != 2){ |
lrc = 12; |
if(prlc) printf(f,lrc); |
} |
sl = 5; fr = 2; |
sl = fr; |
if(sl != 2){ |
lrc = 13; |
if(prlc) printf(f,lrc); |
} |
sl = 5; dr = 2; |
sl = dr; |
if(sl != 2){ |
lrc = 14; |
if(prlc) printf(f,lrc); |
} |
il = 5; cr = 2; |
il = cr; |
if(il != 2){ |
lrc = 15; |
if(prlc) printf(f,lrc); |
} |
il = 5; sr = 2; |
il = sr; |
if(il != 2){ |
lrc = 16; |
if(prlc) printf(f,lrc); |
} |
il = 5; ir = 2; |
il = ir; |
if(il != 2){ |
lrc = 17; |
if(prlc) printf(f,lrc); |
} |
il = 5; lr = 2; |
il = lr; |
if(il != 2){ |
lrc = 18; |
if(prlc) printf(f,lrc); |
} |
il = 5; ur = 2; |
il = ur; |
if(il != 2){ |
lrc = 19; |
if(prlc) printf(f,lrc); |
} |
il = 5; fr = 2; |
il = fr; |
if(il != 2){ |
lrc = 20; |
if(prlc) printf(f,lrc); |
} |
il = 5; dr = 2; |
il = dr; |
if(il != 2){ |
lrc = 21; |
if(prlc) printf(f,lrc); |
} |
ll = 5; cr = 2; |
ll = cr; |
if(ll != 2){ |
lrc = 22; |
if(prlc) printf(f,lrc); |
} |
ll = 5; sr = 2; |
ll = sr; |
if(ll != 2){ |
lrc = 23; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ir = 2; |
ll = ir; |
if(ll != 2){ |
lrc = 24; |
if(prlc) printf(f,lrc); |
} |
ll = 5; lr = 2; |
ll = lr; |
if(ll != 2){ |
lrc = 25; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ur = 2; |
ll = ur; |
if(ll != 2){ |
lrc = 26; |
if(prlc) printf(f,lrc); |
} |
ll = 5; fr = 2; |
ll = fr; |
if(ll != 2){ |
lrc = 27; |
if(prlc) printf(f,lrc); |
} |
ll = 5; dr = 2; |
ll = dr; |
if(ll != 2){ |
lrc = 28; |
if(prlc) printf(f,lrc); |
} |
ul = 5; cr = 2; |
ul = cr; |
if(ul != 2){ |
lrc = 29; |
if(prlc) printf(f,lrc); |
} |
ul = 5; sr = 2; |
ul = sr; |
if(ul != 2){ |
lrc = 30; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ir = 2; |
ul = ir; |
if(ul != 2){ |
lrc = 31; |
if(prlc) printf(f,lrc); |
} |
ul = 5; lr = 2; |
ul = lr; |
if(ul != 2){ |
lrc = 32; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ur = 2; |
ul = ur; |
if(ul != 2){ |
lrc = 33; |
if(prlc) printf(f,lrc); |
} |
ul = 5; fr = 2; |
ul = fr; |
if(ul != 2){ |
lrc = 34; |
if(prlc) printf(f,lrc); |
} |
ul = 5; dr = 2; |
ul = dr; |
if(ul != 2){ |
lrc = 35; |
if(prlc) printf(f,lrc); |
} |
fl = 5; cr = 2; |
fl = cr; |
if(fl != 2){ |
lrc = 36; |
if(prlc) printf(f,lrc); |
} |
fl = 5; sr = 2; |
fl = sr; |
if(fl != 2){ |
lrc = 37; |
if(prlc) printf(f,lrc); |
} |
fl = 5; ir = 2; |
fl = ir; |
if(fl != 2){ |
lrc = 38; |
if(prlc) printf(f,lrc); |
} |
fl = 5; lr = 2; |
fl = lr; |
if(fl != 2){ |
lrc = 39; |
if(prlc) printf(f,lrc); |
} |
fl = 5; ur = 2; |
fl = ur; |
if(fl != 2){ |
lrc = 40; |
if(prlc) printf(f,lrc); |
} |
fl = 5; fr = 2; |
fl = fr; |
if(fl != 2){ |
lrc = 41; |
if(prlc) printf(f,lrc); |
} |
fl = 5; dr = 2; |
fl = dr; |
if(fl != 2){ |
lrc = 42; |
if(prlc) printf(f,lrc); |
} |
dl = 5; cr = 2; |
dl = cr; |
if(dl != 2){ |
lrc = 43; |
if(prlc) printf(f,lrc); |
} |
dl = 5; sr = 2; |
dl = sr; |
if(dl != 2){ |
lrc = 44; |
if(prlc) printf(f,lrc); |
} |
dl = 5; ir = 2; |
dl = ir; |
if(dl != 2){ |
lrc = 45; |
if(prlc) printf(f,lrc); |
} |
dl = 5; lr = 2; |
dl = lr; |
if(dl != 2){ |
lrc = 46; |
if(prlc) printf(f,lrc); |
} |
dl = 5; ur = 2; |
dl = ur; |
if(dl != 2){ |
lrc = 47; |
if(prlc) printf(f,lrc); |
} |
dl = 5; fr = 2; |
dl = fr; |
if(dl != 2){ |
lrc = 48; |
if(prlc) printf(f,lrc); |
} |
dl = 5; dr = 2; |
dl = dr; |
if(dl != 2){ |
lrc = 49; |
if(prlc) printf(f,lrc); |
} |
cl = 5; cr = 2; |
cl += cr; |
if(cl != 7){ |
lrc = 50; |
if(prlc) printf(f,lrc); |
} |
cl = 5; sr = 2; |
cl += sr; |
if(cl != 7){ |
lrc = 51; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ir = 2; |
cl += ir; |
if(cl != 7){ |
lrc = 52; |
if(prlc) printf(f,lrc); |
} |
cl = 5; lr = 2; |
cl += lr; |
if(cl != 7){ |
lrc = 53; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ur = 2; |
cl += ur; |
if(cl != 7){ |
lrc = 54; |
if(prlc) printf(f,lrc); |
} |
cl = 5; fr = 2; |
cl += fr; |
if(cl != 7){ |
lrc = 55; |
if(prlc) printf(f,lrc); |
} |
cl = 5; dr = 2; |
cl += dr; |
if(cl != 7){ |
lrc = 56; |
if(prlc) printf(f,lrc); |
} |
sl = 5; cr = 2; |
sl += cr; |
if(sl != 7){ |
lrc = 57; |
if(prlc) printf(f,lrc); |
} |
sl = 5; sr = 2; |
sl += sr; |
if(sl != 7){ |
lrc = 58; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ir = 2; |
sl += ir; |
if(sl != 7){ |
lrc = 59; |
if(prlc) printf(f,lrc); |
} |
sl = 5; lr = 2; |
sl += lr; |
if(sl != 7){ |
lrc = 60; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ur = 2; |
sl += ur; |
if(sl != 7){ |
lrc = 61; |
if(prlc) printf(f,lrc); |
} |
sl = 5; fr = 2; |
sl += fr; |
if(sl != 7){ |
lrc = 62; |
if(prlc) printf(f,lrc); |
} |
sl = 5; dr = 2; |
sl += dr; |
if(sl != 7){ |
lrc = 63; |
if(prlc) printf(f,lrc); |
} |
il = 5; cr = 2; |
il += cr; |
if(il != 7){ |
lrc = 64; |
if(prlc) printf(f,lrc); |
} |
il = 5; sr = 2; |
il += sr; |
if(il != 7){ |
lrc = 65; |
if(prlc) printf(f,lrc); |
} |
il = 5; ir = 2; |
il += ir; |
if(il != 7){ |
lrc = 66; |
if(prlc) printf(f,lrc); |
} |
il = 5; lr = 2; |
il += lr; |
if(il != 7){ |
lrc = 67; |
if(prlc) printf(f,lrc); |
} |
il = 5; ur = 2; |
il += ur; |
if(il != 7){ |
lrc = 68; |
if(prlc) printf(f,lrc); |
} |
il = 5; fr = 2; |
il += fr; |
if(il != 7){ |
lrc = 69; |
if(prlc) printf(f,lrc); |
} |
il = 5; dr = 2; |
il += dr; |
if(il != 7){ |
lrc = 70; |
if(prlc) printf(f,lrc); |
} |
ll = 5; cr = 2; |
ll += cr; |
if(ll != 7){ |
lrc = 71; |
if(prlc) printf(f,lrc); |
} |
ll = 5; sr = 2; |
ll += sr; |
if(ll != 7){ |
lrc = 72; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ir = 2; |
ll += ir; |
if(ll != 7){ |
lrc = 73; |
if(prlc) printf(f,lrc); |
} |
ll = 5; lr = 2; |
ll += lr; |
if(ll != 7){ |
lrc = 74; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ur = 2; |
ll += ur; |
if(ll != 7){ |
lrc = 75; |
if(prlc) printf(f,lrc); |
} |
ll = 5; fr = 2; |
ll += fr; |
if(ll != 7){ |
lrc = 76; |
if(prlc) printf(f,lrc); |
} |
ll = 5; dr = 2; |
ll += dr; |
if(ll != 7){ |
lrc = 77; |
if(prlc) printf(f,lrc); |
} |
ul = 5; cr = 2; |
ul += cr; |
if(ul != 7){ |
lrc = 78; |
if(prlc) printf(f,lrc); |
} |
ul = 5; sr = 2; |
ul += sr; |
if(ul != 7){ |
lrc = 79; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ir = 2; |
ul += ir; |
if(ul != 7){ |
lrc = 80; |
if(prlc) printf(f,lrc); |
} |
ul = 5; lr = 2; |
ul += lr; |
if(ul != 7){ |
lrc = 81; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ur = 2; |
ul += ur; |
if(ul != 7){ |
lrc = 82; |
if(prlc) printf(f,lrc); |
} |
ul = 5; fr = 2; |
ul += fr; |
if(ul != 7){ |
lrc = 83; |
if(prlc) printf(f,lrc); |
} |
ul = 5; dr = 2; |
ul += dr; |
if(ul != 7){ |
lrc = 84; |
if(prlc) printf(f,lrc); |
} |
fl = 5; cr = 2; |
fl += cr; |
if(fl != 7){ |
lrc = 85; |
if(prlc) printf(f,lrc); |
} |
fl = 5; sr = 2; |
fl += sr; |
if(fl != 7){ |
lrc = 86; |
if(prlc) printf(f,lrc); |
} |
fl = 5; ir = 2; |
fl += ir; |
if(fl != 7){ |
lrc = 87; |
if(prlc) printf(f,lrc); |
} |
fl = 5; lr = 2; |
fl += lr; |
if(fl != 7){ |
lrc = 88; |
if(prlc) printf(f,lrc); |
} |
fl = 5; ur = 2; |
fl += ur; |
if(fl != 7){ |
lrc = 89; |
if(prlc) printf(f,lrc); |
} |
fl = 5; fr = 2; |
fl += fr; |
if(fl != 7){ |
lrc = 90; |
if(prlc) printf(f,lrc); |
} |
fl = 5; dr = 2; |
fl += dr; |
if(fl != 7){ |
lrc = 91; |
if(prlc) printf(f,lrc); |
} |
dl = 5; cr = 2; |
dl += cr; |
if(dl != 7){ |
lrc = 92; |
if(prlc) printf(f,lrc); |
} |
dl = 5; sr = 2; |
dl += sr; |
if(dl != 7){ |
lrc = 93; |
if(prlc) printf(f,lrc); |
} |
dl = 5; ir = 2; |
dl += ir; |
if(dl != 7){ |
lrc = 94; |
if(prlc) printf(f,lrc); |
} |
dl = 5; lr = 2; |
dl += lr; |
if(dl != 7){ |
lrc = 95; |
if(prlc) printf(f,lrc); |
} |
dl = 5; ur = 2; |
dl += ur; |
if(dl != 7){ |
lrc = 96; |
if(prlc) printf(f,lrc); |
} |
dl = 5; fr = 2; |
dl += fr; |
if(dl != 7){ |
lrc = 97; |
if(prlc) printf(f,lrc); |
} |
dl = 5; dr = 2; |
dl += dr; |
if(dl != 7){ |
lrc = 98; |
if(prlc) printf(f,lrc); |
} |
cl = 5; cr = 2; |
cl -= cr; |
if(cl != 3){ |
lrc = 99; |
if(prlc) printf(f,lrc); |
} |
cl = 5; sr = 2; |
cl -= sr; |
if(cl != 3){ |
lrc = 100; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ir = 2; |
cl -= ir; |
if(cl != 3){ |
lrc = 101; |
if(prlc) printf(f,lrc); |
} |
cl = 5; lr = 2; |
cl -= lr; |
if(cl != 3){ |
lrc = 102; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ur = 2; |
cl -= ur; |
if(cl != 3){ |
lrc = 103; |
if(prlc) printf(f,lrc); |
} |
cl = 5; fr = 2; |
cl -= fr; |
if(cl != 3){ |
lrc = 104; |
if(prlc) printf(f,lrc); |
} |
cl = 5; dr = 2; |
cl -= dr; |
if(cl != 3){ |
lrc = 105; |
if(prlc) printf(f,lrc); |
} |
sl = 5; cr = 2; |
sl -= cr; |
if(sl != 3){ |
lrc = 106; |
if(prlc) printf(f,lrc); |
} |
sl = 5; sr = 2; |
sl -= sr; |
if(sl != 3){ |
lrc = 107; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ir = 2; |
sl -= ir; |
if(sl != 3){ |
lrc = 108; |
if(prlc) printf(f,lrc); |
} |
sl = 5; lr = 2; |
sl -= lr; |
if(sl != 3){ |
lrc = 109; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ur = 2; |
sl -= ur; |
if(sl != 3){ |
lrc = 110; |
if(prlc) printf(f,lrc); |
} |
sl = 5; fr = 2; |
sl -= fr; |
if(sl != 3){ |
lrc = 111; |
if(prlc) printf(f,lrc); |
} |
sl = 5; dr = 2; |
sl -= dr; |
if(sl != 3){ |
lrc = 112; |
if(prlc) printf(f,lrc); |
} |
il = 5; cr = 2; |
il -= cr; |
if(il != 3){ |
lrc = 113; |
if(prlc) printf(f,lrc); |
} |
il = 5; sr = 2; |
il -= sr; |
if(il != 3){ |
lrc = 114; |
if(prlc) printf(f,lrc); |
} |
il = 5; ir = 2; |
il -= ir; |
if(il != 3){ |
lrc = 115; |
if(prlc) printf(f,lrc); |
} |
il = 5; lr = 2; |
il -= lr; |
if(il != 3){ |
lrc = 116; |
if(prlc) printf(f,lrc); |
} |
il = 5; ur = 2; |
il -= ur; |
if(il != 3){ |
lrc = 117; |
if(prlc) printf(f,lrc); |
} |
il = 5; fr = 2; |
il -= fr; |
if(il != 3){ |
lrc = 118; |
if(prlc) printf(f,lrc); |
} |
il = 5; dr = 2; |
il -= dr; |
if(il != 3){ |
lrc = 119; |
if(prlc) printf(f,lrc); |
} |
ll = 5; cr = 2; |
ll -= cr; |
if(ll != 3){ |
lrc = 120; |
if(prlc) printf(f,lrc); |
} |
ll = 5; sr = 2; |
ll -= sr; |
if(ll != 3){ |
lrc = 121; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ir = 2; |
ll -= ir; |
if(ll != 3){ |
lrc = 122; |
if(prlc) printf(f,lrc); |
} |
ll = 5; lr = 2; |
ll -= lr; |
if(ll != 3){ |
lrc = 123; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ur = 2; |
ll -= ur; |
if(ll != 3){ |
lrc = 124; |
if(prlc) printf(f,lrc); |
} |
ll = 5; fr = 2; |
ll -= fr; |
if(ll != 3){ |
lrc = 125; |
if(prlc) printf(f,lrc); |
} |
ll = 5; dr = 2; |
ll -= dr; |
if(ll != 3){ |
lrc = 126; |
if(prlc) printf(f,lrc); |
} |
ul = 5; cr = 2; |
ul -= cr; |
if(ul != 3){ |
lrc = 127; |
if(prlc) printf(f,lrc); |
} |
ul = 5; sr = 2; |
ul -= sr; |
if(ul != 3){ |
lrc = 128; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ir = 2; |
ul -= ir; |
if(ul != 3){ |
lrc = 129; |
if(prlc) printf(f,lrc); |
} |
ul = 5; lr = 2; |
ul -= lr; |
if(ul != 3){ |
lrc = 130; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ur = 2; |
ul -= ur; |
if(ul != 3){ |
lrc = 131; |
if(prlc) printf(f,lrc); |
} |
ul = 5; fr = 2; |
ul -= fr; |
if(ul != 3){ |
lrc = 132; |
if(prlc) printf(f,lrc); |
} |
ul = 5; dr = 2; |
ul -= dr; |
if(ul != 3){ |
lrc = 133; |
if(prlc) printf(f,lrc); |
} |
fl = 5; cr = 2; |
fl -= cr; |
if(fl != 3){ |
lrc = 134; |
if(prlc) printf(f,lrc); |
} |
fl = 5; sr = 2; |
fl -= sr; |
if(fl != 3){ |
lrc = 135; |
if(prlc) printf(f,lrc); |
} |
fl = 5; ir = 2; |
fl -= ir; |
if(fl != 3){ |
lrc = 136; |
if(prlc) printf(f,lrc); |
} |
fl = 5; lr = 2; |
fl -= lr; |
if(fl != 3){ |
lrc = 137; |
if(prlc) printf(f,lrc); |
} |
fl = 5; ur = 2; |
fl -= ur; |
if(fl != 3){ |
lrc = 138; |
if(prlc) printf(f,lrc); |
} |
fl = 5; fr = 2; |
fl -= fr; |
if(fl != 3){ |
lrc = 139; |
if(prlc) printf(f,lrc); |
} |
fl = 5; dr = 2; |
fl -= dr; |
if(fl != 3){ |
lrc = 140; |
if(prlc) printf(f,lrc); |
} |
dl = 5; cr = 2; |
dl -= cr; |
if(dl != 3){ |
lrc = 141; |
if(prlc) printf(f,lrc); |
} |
dl = 5; sr = 2; |
dl -= sr; |
if(dl != 3){ |
lrc = 142; |
if(prlc) printf(f,lrc); |
} |
dl = 5; ir = 2; |
dl -= ir; |
if(dl != 3){ |
lrc = 143; |
if(prlc) printf(f,lrc); |
} |
dl = 5; lr = 2; |
dl -= lr; |
if(dl != 3){ |
lrc = 144; |
if(prlc) printf(f,lrc); |
} |
dl = 5; ur = 2; |
dl -= ur; |
if(dl != 3){ |
lrc = 145; |
if(prlc) printf(f,lrc); |
} |
dl = 5; fr = 2; |
dl -= fr; |
if(dl != 3){ |
lrc = 146; |
if(prlc) printf(f,lrc); |
} |
dl = 5; dr = 2; |
dl -= dr; |
if(dl != 3){ |
lrc = 147; |
if(prlc) printf(f,lrc); |
} |
cl = 5; cr = 2; |
cl *= cr; |
if(cl != 10){ |
lrc = 148; |
if(prlc) printf(f,lrc); |
} |
cl = 5; sr = 2; |
cl *= sr; |
if(cl != 10){ |
lrc = 149; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ir = 2; |
cl *= ir; |
if(cl != 10){ |
lrc = 150; |
if(prlc) printf(f,lrc); |
} |
cl = 5; lr = 2; |
cl *= lr; |
if(cl != 10){ |
lrc = 151; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ur = 2; |
cl *= ur; |
if(cl != 10){ |
lrc = 152; |
if(prlc) printf(f,lrc); |
} |
cl = 5; fr = 2; |
cl *= fr; |
if(cl != 10){ |
lrc = 153; |
if(prlc) printf(f,lrc); |
} |
cl = 5; dr = 2; |
cl *= dr; |
if(cl != 10){ |
lrc = 154; |
if(prlc) printf(f,lrc); |
} |
sl = 5; cr = 2; |
sl *= cr; |
if(sl != 10){ |
lrc = 155; |
if(prlc) printf(f,lrc); |
} |
sl = 5; sr = 2; |
sl *= sr; |
if(sl != 10){ |
lrc = 156; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ir = 2; |
sl *= ir; |
if(sl != 10){ |
lrc = 157; |
if(prlc) printf(f,lrc); |
} |
sl = 5; lr = 2; |
sl *= lr; |
if(sl != 10){ |
lrc = 158; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ur = 2; |
sl *= ur; |
if(sl != 10){ |
lrc = 159; |
if(prlc) printf(f,lrc); |
} |
sl = 5; fr = 2; |
sl *= fr; |
if(sl != 10){ |
lrc = 160; |
if(prlc) printf(f,lrc); |
} |
sl = 5; dr = 2; |
sl *= dr; |
if(sl != 10){ |
lrc = 161; |
if(prlc) printf(f,lrc); |
} |
il = 5; cr = 2; |
il *= cr; |
if(il != 10){ |
lrc = 162; |
if(prlc) printf(f,lrc); |
} |
il = 5; sr = 2; |
il *= sr; |
if(il != 10){ |
lrc = 163; |
if(prlc) printf(f,lrc); |
} |
il = 5; ir = 2; |
il *= ir; |
if(il != 10){ |
lrc = 164; |
if(prlc) printf(f,lrc); |
} |
il = 5; lr = 2; |
il *= lr; |
if(il != 10){ |
lrc = 165; |
if(prlc) printf(f,lrc); |
} |
il = 5; ur = 2; |
il *= ur; |
if(il != 10){ |
lrc = 166; |
if(prlc) printf(f,lrc); |
} |
il = 5; fr = 2; |
il *= fr; |
if(il != 10){ |
lrc = 167; |
if(prlc) printf(f,lrc); |
} |
il = 5; dr = 2; |
il *= dr; |
if(il != 10){ |
lrc = 168; |
if(prlc) printf(f,lrc); |
} |
ll = 5; cr = 2; |
ll *= cr; |
if(ll != 10){ |
lrc = 169; |
if(prlc) printf(f,lrc); |
} |
ll = 5; sr = 2; |
ll *= sr; |
if(ll != 10){ |
lrc = 170; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ir = 2; |
ll *= ir; |
if(ll != 10){ |
lrc = 171; |
if(prlc) printf(f,lrc); |
} |
ll = 5; lr = 2; |
ll *= lr; |
if(ll != 10){ |
lrc = 172; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ur = 2; |
ll *= ur; |
if(ll != 10){ |
lrc = 173; |
if(prlc) printf(f,lrc); |
} |
ll = 5; fr = 2; |
ll *= fr; |
if(ll != 10){ |
lrc = 174; |
if(prlc) printf(f,lrc); |
} |
ll = 5; dr = 2; |
ll *= dr; |
if(ll != 10){ |
lrc = 175; |
if(prlc) printf(f,lrc); |
} |
ul = 5; cr = 2; |
ul *= cr; |
if(ul != 10){ |
lrc = 176; |
if(prlc) printf(f,lrc); |
} |
ul = 5; sr = 2; |
ul *= sr; |
if(ul != 10){ |
lrc = 177; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ir = 2; |
ul *= ir; |
if(ul != 10){ |
lrc = 178; |
if(prlc) printf(f,lrc); |
} |
ul = 5; lr = 2; |
ul *= lr; |
if(ul != 10){ |
lrc = 179; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ur = 2; |
ul *= ur; |
if(ul != 10){ |
lrc = 180; |
if(prlc) printf(f,lrc); |
} |
ul = 5; fr = 2; |
ul *= fr; |
if(ul != 10){ |
lrc = 181; |
if(prlc) printf(f,lrc); |
} |
ul = 5; dr = 2; |
ul *= dr; |
if(ul != 10){ |
lrc = 182; |
if(prlc) printf(f,lrc); |
} |
fl = 5; cr = 2; |
fl *= cr; |
if(fl != 10){ |
lrc = 183; |
if(prlc) printf(f,lrc); |
} |
fl = 5; sr = 2; |
fl *= sr; |
if(fl != 10){ |
lrc = 184; |
if(prlc) printf(f,lrc); |
} |
fl = 5; ir = 2; |
fl *= ir; |
if(fl != 10){ |
lrc = 185; |
if(prlc) printf(f,lrc); |
} |
fl = 5; lr = 2; |
fl *= lr; |
if(fl != 10){ |
lrc = 186; |
if(prlc) printf(f,lrc); |
} |
fl = 5; ur = 2; |
fl *= ur; |
if(fl != 10){ |
lrc = 187; |
if(prlc) printf(f,lrc); |
} |
fl = 5; fr = 2; |
fl *= fr; |
if(fl != 10){ |
lrc = 188; |
if(prlc) printf(f,lrc); |
} |
fl = 5; dr = 2; |
fl *= dr; |
if(fl != 10){ |
lrc = 189; |
if(prlc) printf(f,lrc); |
} |
dl = 5; cr = 2; |
dl *= cr; |
if(dl != 10){ |
lrc = 190; |
if(prlc) printf(f,lrc); |
} |
dl = 5; sr = 2; |
dl *= sr; |
if(dl != 10){ |
lrc = 191; |
if(prlc) printf(f,lrc); |
} |
dl = 5; ir = 2; |
dl *= ir; |
if(dl != 10){ |
lrc = 192; |
if(prlc) printf(f,lrc); |
} |
dl = 5; lr = 2; |
dl *= lr; |
if(dl != 10){ |
lrc = 193; |
if(prlc) printf(f,lrc); |
} |
dl = 5; ur = 2; |
dl *= ur; |
if(dl != 10){ |
lrc = 194; |
if(prlc) printf(f,lrc); |
} |
dl = 5; fr = 2; |
dl *= fr; |
if(dl != 10){ |
lrc = 195; |
if(prlc) printf(f,lrc); |
} |
dl = 5; dr = 2; |
dl *= dr; |
if(dl != 10){ |
lrc = 196; |
if(prlc) printf(f,lrc); |
} |
cl = 5; cr = 2; |
cl /= cr; |
if(cl != 2){ |
lrc = 197; |
if(prlc) printf(f,lrc); |
} |
cl = 5; sr = 2; |
cl /= sr; |
if(cl != 2){ |
lrc = 198; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ir = 2; |
cl /= ir; |
if(cl != 2){ |
lrc = 199; |
if(prlc) printf(f,lrc); |
} |
cl = 5; lr = 2; |
cl /= lr; |
if(cl != 2){ |
lrc = 200; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ur = 2; |
cl /= ur; |
if(cl != 2){ |
lrc = 201; |
if(prlc) printf(f,lrc); |
} |
cl = 5; fr = 2; |
cl /= fr; |
if(cl != 2){ |
lrc = 202; |
if(prlc) printf(f,lrc); |
} |
cl = 5; dr = 2; |
cl /= dr; |
if(cl != 2){ |
lrc = 203; |
if(prlc) printf(f,lrc); |
} |
sl = 5; cr = 2; |
sl /= cr; |
if(sl != 2){ |
lrc = 204; |
if(prlc) printf(f,lrc); |
} |
sl = 5; sr = 2; |
sl /= sr; |
if(sl != 2){ |
lrc = 205; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ir = 2; |
sl /= ir; |
if(sl != 2){ |
lrc = 206; |
if(prlc) printf(f,lrc); |
} |
sl = 5; lr = 2; |
sl /= lr; |
if(sl != 2){ |
lrc = 207; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ur = 2; |
sl /= ur; |
if(sl != 2){ |
lrc = 208; |
if(prlc) printf(f,lrc); |
} |
sl = 5; fr = 2; |
sl /= fr; |
if(sl != 2){ |
lrc = 209; |
if(prlc) printf(f,lrc); |
} |
sl = 5; dr = 2; |
sl /= dr; |
if(sl != 2){ |
lrc = 210; |
if(prlc) printf(f,lrc); |
} |
il = 5; cr = 2; |
il /= cr; |
if(il != 2){ |
lrc = 211; |
if(prlc) printf(f,lrc); |
} |
il = 5; sr = 2; |
il /= sr; |
if(il != 2){ |
lrc = 212; |
if(prlc) printf(f,lrc); |
} |
il = 5; ir = 2; |
il /= ir; |
if(il != 2){ |
lrc = 213; |
if(prlc) printf(f,lrc); |
} |
il = 5; lr = 2; |
il /= lr; |
if(il != 2){ |
lrc = 214; |
if(prlc) printf(f,lrc); |
} |
il = 5; ur = 2; |
il /= ur; |
if(il != 2){ |
lrc = 215; |
if(prlc) printf(f,lrc); |
} |
il = 5; fr = 2; |
il /= fr; |
if(il != 2){ |
lrc = 216; |
if(prlc) printf(f,lrc); |
} |
il = 5; dr = 2; |
il /= dr; |
if(il != 2){ |
lrc = 217; |
if(prlc) printf(f,lrc); |
} |
ll = 5; cr = 2; |
ll /= cr; |
if(ll != 2){ |
lrc = 218; |
if(prlc) printf(f,lrc); |
} |
ll = 5; sr = 2; |
ll /= sr; |
if(ll != 2){ |
lrc = 219; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ir = 2; |
ll /= ir; |
if(ll != 2){ |
lrc = 220; |
if(prlc) printf(f,lrc); |
} |
ll = 5; lr = 2; |
ll /= lr; |
if(ll != 2){ |
lrc = 221; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ur = 2; |
ll /= ur; |
if(ll != 2){ |
lrc = 222; |
if(prlc) printf(f,lrc); |
} |
ll = 5; fr = 2; |
ll /= fr; |
if(ll != 2){ |
lrc = 223; |
if(prlc) printf(f,lrc); |
} |
ll = 5; dr = 2; |
ll /= dr; |
if(ll != 2){ |
lrc = 224; |
if(prlc) printf(f,lrc); |
} |
ul = 5; cr = 2; |
ul /= cr; |
if(ul != 2){ |
lrc = 225; |
if(prlc) printf(f,lrc); |
} |
ul = 5; sr = 2; |
ul /= sr; |
if(ul != 2){ |
lrc = 226; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ir = 2; |
ul /= ir; |
if(ul != 2){ |
lrc = 227; |
if(prlc) printf(f,lrc); |
} |
ul = 5; lr = 2; |
ul /= lr; |
if(ul != 2){ |
lrc = 228; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ur = 2; |
ul /= ur; |
if(ul != 2){ |
lrc = 229; |
if(prlc) printf(f,lrc); |
} |
ul = 5; fr = 2; |
ul /= fr; |
if(ul != 2){ |
lrc = 230; |
if(prlc) printf(f,lrc); |
} |
ul = 5; dr = 2; |
ul /= dr; |
if(ul != 2){ |
lrc = 231; |
if(prlc) printf(f,lrc); |
} |
fl = 5; cr = 2; |
fl /= cr; |
if(fl != 2.5){ |
lrc = 232; |
if(prlc) printf(f,lrc); |
} |
fl = 5; sr = 2; |
fl /= sr; |
if(fl != 2.5){ |
lrc = 233; |
if(prlc) printf(f,lrc); |
} |
fl = 5; ir = 2; |
fl /= ir; |
if(fl != 2.5){ |
lrc = 234; |
if(prlc) printf(f,lrc); |
} |
fl = 5; lr = 2; |
fl /= lr; |
if(fl != 2.5){ |
lrc = 235; |
if(prlc) printf(f,lrc); |
} |
fl = 5; ur = 2; |
fl /= ur; |
if(fl != 2.5){ |
lrc = 236; |
if(prlc) printf(f,lrc); |
} |
fl = 5; fr = 2; |
fl /= fr; |
if(fl != 2.5){ |
lrc = 237; |
if(prlc) printf(f,lrc); |
} |
fl = 5; dr = 2; |
fl /= dr; |
if(fl != 2.5){ |
lrc = 238; |
if(prlc) printf(f,lrc); |
} |
dl = 5; cr = 2; |
dl /= cr; |
if(dl != 2.5){ |
lrc = 239; |
if(prlc) printf(f,lrc); |
} |
dl = 5; sr = 2; |
dl /= sr; |
if(dl != 2.5){ |
lrc = 240; |
if(prlc) printf(f,lrc); |
} |
dl = 5; ir = 2; |
dl /= ir; |
if(dl != 2.5){ |
lrc = 241; |
if(prlc) printf(f,lrc); |
} |
dl = 5; lr = 2; |
dl /= lr; |
if(dl != 2.5){ |
lrc = 242; |
if(prlc) printf(f,lrc); |
} |
dl = 5; ur = 2; |
dl /= ur; |
if(dl != 2.5){ |
lrc = 243; |
if(prlc) printf(f,lrc); |
} |
dl = 5; fr = 2; |
dl /= fr; |
if(dl != 2.5){ |
lrc = 244; |
if(prlc) printf(f,lrc); |
} |
dl = 5; dr = 2; |
dl /= dr; |
if(dl != 2.5){ |
lrc = 245; |
if(prlc) printf(f,lrc); |
} |
cl = 5; cr = 2; |
cl %= cr; |
if(cl != 1){ |
lrc = 246; |
if(prlc) printf(f,lrc); |
} |
cl = 5; sr = 2; |
cl %= sr; |
if(cl != 1){ |
lrc = 247; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ir = 2; |
cl %= ir; |
if(cl != 1){ |
lrc = 248; |
if(prlc) printf(f,lrc); |
} |
cl = 5; lr = 2; |
cl %= lr; |
if(cl != 1){ |
lrc = 249; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ur = 2; |
cl %= ur; |
if(cl != 1){ |
lrc = 250; |
if(prlc) printf(f,lrc); |
} |
sl = 5; cr = 2; |
sl %= cr; |
if(sl != 1){ |
lrc = 251; |
if(prlc) printf(f,lrc); |
} |
sl = 5; sr = 2; |
sl %= sr; |
if(sl != 1){ |
lrc = 252; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ir = 2; |
sl %= ir; |
if(sl != 1){ |
lrc = 253; |
if(prlc) printf(f,lrc); |
} |
sl = 5; lr = 2; |
sl %= lr; |
if(sl != 1){ |
lrc = 254; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ur = 2; |
sl %= ur; |
if(sl != 1){ |
lrc = 255; |
if(prlc) printf(f,lrc); |
} |
il = 5; cr = 2; |
il %= cr; |
if(il != 1){ |
lrc = 256; |
if(prlc) printf(f,lrc); |
} |
il = 5; sr = 2; |
il %= sr; |
if(il != 1){ |
lrc = 257; |
if(prlc) printf(f,lrc); |
} |
il = 5; ir = 2; |
il %= ir; |
if(il != 1){ |
lrc = 258; |
if(prlc) printf(f,lrc); |
} |
il = 5; lr = 2; |
il %= lr; |
if(il != 1){ |
lrc = 259; |
if(prlc) printf(f,lrc); |
} |
il = 5; ur = 2; |
il %= ur; |
if(il != 1){ |
lrc = 260; |
if(prlc) printf(f,lrc); |
} |
ll = 5; cr = 2; |
ll %= cr; |
if(ll != 1){ |
lrc = 261; |
if(prlc) printf(f,lrc); |
} |
ll = 5; sr = 2; |
ll %= sr; |
if(ll != 1){ |
lrc = 262; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ir = 2; |
ll %= ir; |
if(ll != 1){ |
lrc = 263; |
if(prlc) printf(f,lrc); |
} |
ll = 5; lr = 2; |
ll %= lr; |
if(ll != 1){ |
lrc = 264; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ur = 2; |
ll %= ur; |
if(ll != 1){ |
lrc = 265; |
if(prlc) printf(f,lrc); |
} |
ul = 5; cr = 2; |
ul %= cr; |
if(ul != 1){ |
lrc = 266; |
if(prlc) printf(f,lrc); |
} |
ul = 5; sr = 2; |
ul %= sr; |
if(ul != 1){ |
lrc = 267; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ir = 2; |
ul %= ir; |
if(ul != 1){ |
lrc = 268; |
if(prlc) printf(f,lrc); |
} |
ul = 5; lr = 2; |
ul %= lr; |
if(ul != 1){ |
lrc = 269; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ur = 2; |
ul %= ur; |
if(ul != 1){ |
lrc = 270; |
if(prlc) printf(f,lrc); |
} |
cl = 5; cr = 2; |
cl >>= cr; |
if(cl != 1){ |
lrc = 271; |
if(prlc) printf(f,lrc); |
} |
cl = 5; sr = 2; |
cl >>= sr; |
if(cl != 1){ |
lrc = 272; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ir = 2; |
cl >>= ir; |
if(cl != 1){ |
lrc = 273; |
if(prlc) printf(f,lrc); |
} |
cl = 5; lr = 2; |
cl >>= lr; |
if(cl != 1){ |
lrc = 274; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ur = 2; |
cl >>= ur; |
if(cl != 1){ |
lrc = 275; |
if(prlc) printf(f,lrc); |
} |
sl = 5; cr = 2; |
sl >>= cr; |
if(sl != 1){ |
lrc = 276; |
if(prlc) printf(f,lrc); |
} |
sl = 5; sr = 2; |
sl >>= sr; |
if(sl != 1){ |
lrc = 277; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ir = 2; |
sl >>= ir; |
if(sl != 1){ |
lrc = 278; |
if(prlc) printf(f,lrc); |
} |
sl = 5; lr = 2; |
sl >>= lr; |
if(sl != 1){ |
lrc = 279; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ur = 2; |
sl >>= ur; |
if(sl != 1){ |
lrc = 280; |
if(prlc) printf(f,lrc); |
} |
il = 5; cr = 2; |
il >>= cr; |
if(il != 1){ |
lrc = 281; |
if(prlc) printf(f,lrc); |
} |
il = 5; sr = 2; |
il >>= sr; |
if(il != 1){ |
lrc = 282; |
if(prlc) printf(f,lrc); |
} |
il = 5; ir = 2; |
il >>= ir; |
if(il != 1){ |
lrc = 283; |
if(prlc) printf(f,lrc); |
} |
il = 5; lr = 2; |
il >>= lr; |
if(il != 1){ |
lrc = 284; |
if(prlc) printf(f,lrc); |
} |
il = 5; ur = 2; |
il >>= ur; |
if(il != 1){ |
lrc = 285; |
if(prlc) printf(f,lrc); |
} |
ll = 5; cr = 2; |
ll >>= cr; |
if(ll != 1){ |
lrc = 286; |
if(prlc) printf(f,lrc); |
} |
ll = 5; sr = 2; |
ll >>= sr; |
if(ll != 1){ |
lrc = 287; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ir = 2; |
ll >>= ir; |
if(ll != 1){ |
lrc = 288; |
if(prlc) printf(f,lrc); |
} |
ll = 5; lr = 2; |
ll >>= lr; |
if(ll != 1){ |
lrc = 289; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ur = 2; |
ll >>= ur; |
if(ll != 1){ |
lrc = 290; |
if(prlc) printf(f,lrc); |
} |
ul = 5; cr = 2; |
ul >>= cr; |
if(ul != 1){ |
lrc = 291; |
if(prlc) printf(f,lrc); |
} |
ul = 5; sr = 2; |
ul >>= sr; |
if(ul != 1){ |
lrc = 292; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ir = 2; |
ul >>= ir; |
if(ul != 1){ |
lrc = 293; |
if(prlc) printf(f,lrc); |
} |
ul = 5; lr = 2; |
ul >>= lr; |
if(ul != 1){ |
lrc = 294; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ur = 2; |
ul >>= ur; |
if(ul != 1){ |
lrc = 295; |
if(prlc) printf(f,lrc); |
} |
cl = 5; cr = 2; |
cl <<= cr; |
if(cl != 20){ |
lrc = 296; |
if(prlc) printf(f,lrc); |
} |
cl = 5; sr = 2; |
cl <<= sr; |
if(cl != 20){ |
lrc = 297; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ir = 2; |
cl <<= ir; |
if(cl != 20){ |
lrc = 298; |
if(prlc) printf(f,lrc); |
} |
cl = 5; lr = 2; |
cl <<= lr; |
if(cl != 20){ |
lrc = 299; |
if(prlc) printf(f,lrc); |
} |
cl = 5; ur = 2; |
cl <<= ur; |
if(cl != 20){ |
lrc = 300; |
if(prlc) printf(f,lrc); |
} |
sl = 5; cr = 2; |
sl <<= cr; |
if(sl != 20){ |
lrc = 301; |
if(prlc) printf(f,lrc); |
} |
sl = 5; sr = 2; |
sl <<= sr; |
if(sl != 20){ |
lrc = 302; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ir = 2; |
sl <<= ir; |
if(sl != 20){ |
lrc = 303; |
if(prlc) printf(f,lrc); |
} |
sl = 5; lr = 2; |
sl <<= lr; |
if(sl != 20){ |
lrc = 304; |
if(prlc) printf(f,lrc); |
} |
sl = 5; ur = 2; |
sl <<= ur; |
if(sl != 20){ |
lrc = 305; |
if(prlc) printf(f,lrc); |
} |
il = 5; cr = 2; |
il <<= cr; |
if(il != 20){ |
lrc = 306; |
if(prlc) printf(f,lrc); |
} |
il = 5; sr = 2; |
il <<= sr; |
if(il != 20){ |
lrc = 307; |
if(prlc) printf(f,lrc); |
} |
il = 5; ir = 2; |
il <<= ir; |
if(il != 20){ |
lrc = 308; |
if(prlc) printf(f,lrc); |
} |
il = 5; lr = 2; |
il <<= lr; |
if(il != 20){ |
lrc = 309; |
if(prlc) printf(f,lrc); |
} |
il = 5; ur = 2; |
il <<= ur; |
if(il != 20){ |
lrc = 310; |
if(prlc) printf(f,lrc); |
} |
ll = 5; cr = 2; |
ll <<= cr; |
if(ll != 20){ |
lrc = 311; |
if(prlc) printf(f,lrc); |
} |
ll = 5; sr = 2; |
ll <<= sr; |
if(ll != 20){ |
lrc = 312; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ir = 2; |
ll <<= ir; |
if(ll != 20){ |
lrc = 313; |
if(prlc) printf(f,lrc); |
} |
ll = 5; lr = 2; |
ll <<= lr; |
if(ll != 20){ |
lrc = 314; |
if(prlc) printf(f,lrc); |
} |
ll = 5; ur = 2; |
ll <<= ur; |
if(ll != 20){ |
lrc = 315; |
if(prlc) printf(f,lrc); |
} |
ul = 5; cr = 2; |
ul <<= cr; |
if(ul != 20){ |
lrc = 316; |
if(prlc) printf(f,lrc); |
} |
ul = 5; sr = 2; |
ul <<= sr; |
if(ul != 20){ |
lrc = 317; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ir = 2; |
ul <<= ir; |
if(ul != 20){ |
lrc = 318; |
if(prlc) printf(f,lrc); |
} |
ul = 5; lr = 2; |
ul <<= lr; |
if(ul != 20){ |
lrc = 319; |
if(prlc) printf(f,lrc); |
} |
ul = 5; ur = 2; |
ul <<= ur; |
if(ul != 20){ |
lrc = 320; |
if(prlc) printf(f,lrc); |
} |
cl = 12; cr = 10; |
cl &= cr; |
if(cl != 8){ |
lrc = 321; |
if(prlc) printf(f,lrc); |
} |
cl = 12; sr = 10; |
cl &= sr; |
if(cl != 8){ |
lrc = 322; |
if(prlc) printf(f,lrc); |
} |
cl = 12; ir = 10; |
cl &= ir; |
if(cl != 8){ |
lrc = 323; |
if(prlc) printf(f,lrc); |
} |
cl = 12; lr = 10; |
cl &= lr; |
if(cl != 8){ |
lrc = 324; |
if(prlc) printf(f,lrc); |
} |
cl = 12; ur = 10; |
cl &= ur; |
if(cl != 8){ |
lrc = 325; |
if(prlc) printf(f,lrc); |
} |
sl = 12; cr = 10; |
sl &= cr; |
if(sl != 8){ |
lrc = 326; |
if(prlc) printf(f,lrc); |
} |
sl = 12; sr = 10; |
sl &= sr; |
if(sl != 8){ |
lrc = 327; |
if(prlc) printf(f,lrc); |
} |
sl = 12; ir = 10; |
sl &= ir; |
if(sl != 8){ |
lrc = 328; |
if(prlc) printf(f,lrc); |
} |
sl = 12; lr = 10; |
sl &= lr; |
if(sl != 8){ |
lrc = 329; |
if(prlc) printf(f,lrc); |
} |
sl = 12; ur = 10; |
sl &= ur; |
if(sl != 8){ |
lrc = 330; |
if(prlc) printf(f,lrc); |
} |
il = 12; cr = 10; |
il &= cr; |
if(il != 8){ |
lrc = 331; |
if(prlc) printf(f,lrc); |
} |
il = 12; sr = 10; |
il &= sr; |
if(il != 8){ |
lrc = 332; |
if(prlc) printf(f,lrc); |
} |
il = 12; ir = 10; |
il &= ir; |
if(il != 8){ |
lrc = 333; |
if(prlc) printf(f,lrc); |
} |
il = 12; lr = 10; |
il &= lr; |
if(il != 8){ |
lrc = 334; |
if(prlc) printf(f,lrc); |
} |
il = 12; ur = 10; |
il &= ur; |
if(il != 8){ |
lrc = 335; |
if(prlc) printf(f,lrc); |
} |
ll = 12; cr = 10; |
ll &= cr; |
if(ll != 8){ |
lrc = 336; |
if(prlc) printf(f,lrc); |
} |
ll = 12; sr = 10; |
ll &= sr; |
if(ll != 8){ |
lrc = 337; |
if(prlc) printf(f,lrc); |
} |
ll = 12; ir = 10; |
ll &= ir; |
if(ll != 8){ |
lrc = 338; |
if(prlc) printf(f,lrc); |
} |
ll = 12; lr = 10; |
ll &= lr; |
if(ll != 8){ |
lrc = 339; |
if(prlc) printf(f,lrc); |
} |
ll = 12; ur = 10; |
ll &= ur; |
if(ll != 8){ |
lrc = 340; |
if(prlc) printf(f,lrc); |
} |
ul = 12; cr = 10; |
ul &= cr; |
if(ul != 8){ |
lrc = 341; |
if(prlc) printf(f,lrc); |
} |
ul = 12; sr = 10; |
ul &= sr; |
if(ul != 8){ |
lrc = 342; |
if(prlc) printf(f,lrc); |
} |
ul = 12; ir = 10; |
ul &= ir; |
if(ul != 8){ |
lrc = 343; |
if(prlc) printf(f,lrc); |
} |
ul = 12; lr = 10; |
ul &= lr; |
if(ul != 8){ |
lrc = 344; |
if(prlc) printf(f,lrc); |
} |
ul = 12; ur = 10; |
ul &= ur; |
if(ul != 8){ |
lrc = 345; |
if(prlc) printf(f,lrc); |
} |
cl = 12; cr = 10; |
cl ^= cr; |
if(cl != 6){ |
lrc = 346; |
if(prlc) printf(f,lrc); |
} |
cl = 12; sr = 10; |
cl ^= sr; |
if(cl != 6){ |
lrc = 347; |
if(prlc) printf(f,lrc); |
} |
cl = 12; ir = 10; |
cl ^= ir; |
if(cl != 6){ |
lrc = 348; |
if(prlc) printf(f,lrc); |
} |
cl = 12; lr = 10; |
cl ^= lr; |
if(cl != 6){ |
lrc = 349; |
if(prlc) printf(f,lrc); |
} |
cl = 12; ur = 10; |
cl ^= ur; |
if(cl != 6){ |
lrc = 350; |
if(prlc) printf(f,lrc); |
} |
sl = 12; cr = 10; |
sl ^= cr; |
if(sl != 6){ |
lrc = 351; |
if(prlc) printf(f,lrc); |
} |
sl = 12; sr = 10; |
sl ^= sr; |
if(sl != 6){ |
lrc = 352; |
if(prlc) printf(f,lrc); |
} |
sl = 12; ir = 10; |
sl ^= ir; |
if(sl != 6){ |
lrc = 353; |
if(prlc) printf(f,lrc); |
} |
sl = 12; lr = 10; |
sl ^= lr; |
if(sl != 6){ |
lrc = 354; |
if(prlc) printf(f,lrc); |
} |
sl = 12; ur = 10; |
sl ^= ur; |
if(sl != 6){ |
lrc = 355; |
if(prlc) printf(f,lrc); |
} |
il = 12; cr = 10; |
il ^= cr; |
if(il != 6){ |
lrc = 356; |
if(prlc) printf(f,lrc); |
} |
il = 12; sr = 10; |
il ^= sr; |
if(il != 6){ |
lrc = 357; |
if(prlc) printf(f,lrc); |
} |
il = 12; ir = 10; |
il ^= ir; |
if(il != 6){ |
lrc = 358; |
if(prlc) printf(f,lrc); |
} |
il = 12; lr = 10; |
il ^= lr; |
if(il != 6){ |
lrc = 359; |
if(prlc) printf(f,lrc); |
} |
il = 12; ur = 10; |
il ^= ur; |
if(il != 6){ |
lrc = 360; |
if(prlc) printf(f,lrc); |
} |
ll = 12; cr = 10; |
ll ^= cr; |
if(ll != 6){ |
lrc = 361; |
if(prlc) printf(f,lrc); |
} |
ll = 12; sr = 10; |
ll ^= sr; |
if(ll != 6){ |
lrc = 362; |
if(prlc) printf(f,lrc); |
} |
ll = 12; ir = 10; |
ll ^= ir; |
if(ll != 6){ |
lrc = 363; |
if(prlc) printf(f,lrc); |
} |
ll = 12; lr = 10; |
ll ^= lr; |
if(ll != 6){ |
lrc = 364; |
if(prlc) printf(f,lrc); |
} |
ll = 12; ur = 10; |
ll ^= ur; |
if(ll != 6){ |
lrc = 365; |
if(prlc) printf(f,lrc); |
} |
ul = 12; cr = 10; |
ul ^= cr; |
if(ul != 6){ |
lrc = 366; |
if(prlc) printf(f,lrc); |
} |
ul = 12; sr = 10; |
ul ^= sr; |
if(ul != 6){ |
lrc = 367; |
if(prlc) printf(f,lrc); |
} |
ul = 12; ir = 10; |
ul ^= ir; |
if(ul != 6){ |
lrc = 368; |
if(prlc) printf(f,lrc); |
} |
ul = 12; lr = 10; |
ul ^= lr; |
if(ul != 6){ |
lrc = 369; |
if(prlc) printf(f,lrc); |
} |
ul = 12; ur = 10; |
ul ^= ur; |
if(ul != 6){ |
lrc = 370; |
if(prlc) printf(f,lrc); |
} |
cl = 12; cr = 10; |
cl |= cr; |
if(cl != 14){ |
lrc = 371; |
if(prlc) printf(f,lrc); |
} |
cl = 12; sr = 10; |
cl |= sr; |
if(cl != 14){ |
lrc = 372; |
if(prlc) printf(f,lrc); |
} |
cl = 12; ir = 10; |
cl |= ir; |
if(cl != 14){ |
lrc = 373; |
if(prlc) printf(f,lrc); |
} |
cl = 12; lr = 10; |
cl |= lr; |
if(cl != 14){ |
lrc = 374; |
if(prlc) printf(f,lrc); |
} |
cl = 12; ur = 10; |
cl |= ur; |
if(cl != 14){ |
lrc = 375; |
if(prlc) printf(f,lrc); |
} |
sl = 12; cr = 10; |
sl |= cr; |
if(sl != 14){ |
lrc = 376; |
if(prlc) printf(f,lrc); |
} |
sl = 12; sr = 10; |
sl |= sr; |
if(sl != 14){ |
lrc = 377; |
if(prlc) printf(f,lrc); |
} |
sl = 12; ir = 10; |
sl |= ir; |
if(sl != 14){ |
lrc = 378; |
if(prlc) printf(f,lrc); |
} |
sl = 12; lr = 10; |
sl |= lr; |
if(sl != 14){ |
lrc = 379; |
if(prlc) printf(f,lrc); |
} |
sl = 12; ur = 10; |
sl |= ur; |
if(sl != 14){ |
lrc = 380; |
if(prlc) printf(f,lrc); |
} |
il = 12; cr = 10; |
il |= cr; |
if(il != 14){ |
lrc = 381; |
if(prlc) printf(f,lrc); |
} |
il = 12; sr = 10; |
il |= sr; |
if(il != 14){ |
lrc = 382; |
if(prlc) printf(f,lrc); |
} |
il = 12; ir = 10; |
il |= ir; |
if(il != 14){ |
lrc = 383; |
if(prlc) printf(f,lrc); |
} |
il = 12; lr = 10; |
il |= lr; |
if(il != 14){ |
lrc = 384; |
if(prlc) printf(f,lrc); |
} |
il = 12; ur = 10; |
il |= ur; |
if(il != 14){ |
lrc = 385; |
if(prlc) printf(f,lrc); |
} |
ll = 12; cr = 10; |
ll |= cr; |
if(ll != 14){ |
lrc = 386; |
if(prlc) printf(f,lrc); |
} |
ll = 12; sr = 10; |
ll |= sr; |
if(ll != 14){ |
lrc = 387; |
if(prlc) printf(f,lrc); |
} |
ll = 12; ir = 10; |
ll |= ir; |
if(ll != 14){ |
lrc = 388; |
if(prlc) printf(f,lrc); |
} |
ll = 12; lr = 10; |
ll |= lr; |
if(ll != 14){ |
lrc = 389; |
if(prlc) printf(f,lrc); |
} |
ll = 12; ur = 10; |
ll |= ur; |
if(ll != 14){ |
lrc = 390; |
if(prlc) printf(f,lrc); |
} |
ul = 12; cr = 10; |
ul |= cr; |
if(ul != 14){ |
lrc = 391; |
if(prlc) printf(f,lrc); |
} |
ul = 12; sr = 10; |
ul |= sr; |
if(ul != 14){ |
lrc = 392; |
if(prlc) printf(f,lrc); |
} |
ul = 12; ir = 10; |
ul |= ir; |
if(ul != 14){ |
lrc = 393; |
if(prlc) printf(f,lrc); |
} |
ul = 12; lr = 10; |
ul |= lr; |
if(ul != 14){ |
lrc = 394; |
if(prlc) printf(f,lrc); |
} |
ul = 12; ur = 10; |
ul |= ur; |
if(ul != 14){ |
lrc = 395; |
if(prlc) printf(f,lrc); |
} |
if(lrc != 0) { |
rc = 1; |
if(pd0->flgd != 0) printf(s714er,1); |
} |
return rc; |
} |
s715(pd0) /* 7.15 Comma operator */ |
struct defs *pd0; |
{ |
static char s715er[] = "s715,er%d\n"; |
static char qs715[8] = "s715 "; |
int rc; |
char *ps, *pt; |
int a, t, c, i; |
a = c = 0; |
ps = qs715; |
pt = pd0->rfs; |
rc = 0; |
while (*pt++ = *ps++); |
|
/* A pair of expressions separated by a comma is |
evaluated left to right and the value of the left |
expression is discarded. |
*/ |
i = 1; |
if( i++,i++,i++,i++,++i != 6 ){ |
if(pd0->flgd != 0) printf(s715er,1); |
rc = rc+1; |
} |
|
/* In contexts where the comma is given a special mean- |
ing, for example in a list of actual arguments to |
functions (sic) and lists of initializers, the comma |
operator as described in this section can only appear |
in parentheses; for example |
|
f( a, (t=3, t+2), c) |
|
has three arguments, the second of which has the |
value 5. |
*/ |
|
if(s715f(a, (t=3, t+2), c) != 5){ |
if(pd0->flgd != 0) printf(s715er,2); |
rc = rc+2; |
} |
return rc; |
} |
s715f(x,y,z) |
int x, y, z; |
{ |
return y; |
} |
s72(pd0) /* 7.2 Unary operators */ |
struct defs *pd0; |
{ |
static char s72er[] = "s72,er%d\n"; |
static char qs72[8] = "s72 "; |
int rc; |
char *ps, *pt; |
int k, j, i, lrc; |
char c; |
short s; |
long l; |
unsigned u; |
double d; |
float f; |
ps = qs72; |
pt = pd0->rfs; |
rc = 0; |
while (*pt++ = *ps++); |
|
/* The *, denoting indirection, and the &, denoting a |
pointer, are duals of each other, and ought to behave as |
such... */ |
|
k = 2; |
if(*&*&k != 2){ |
rc = rc+1; |
printf(s72er,1); |
} |
|
/* The unary minus has the conventional meaning. */ |
|
if(k+(-k) != 0){ |
rc = rc+2; |
printf(s72er,2); |
} |
|
/* The negation operator (!) has been thoroughly checked out, |
perhaps more thoroughly than any of the others. The ~ oper- |
ator gets us a ones complement. */ |
|
k = 0; |
for(j=0;j<pd0->ibits;j++) k = (k<<1)|1; |
if(~k != 0){ |
rc = rc+4; |
printf(s72er,4); |
} |
|
/* Now we look at the ++ and -- operators, which can be |
used in either prefix or suffix form. With side |
effects they're loaded. */ |
|
k = 5; |
|
if( ++k != 6 || --k != 5 |
|| k++ != 5 || k-- != 6 |
|| k != 5 ){ |
rc = rc+8; |
printf(s72er,8); |
} |
|
/* An expression preceded by the parenthesised name of a |
data type causes conversion of the value of the expression |
to the named type. This construction is called a cast. |
Here, we check to see that all of the possible casts and |
their simple combinations are accepted by the compiler, |
and that they all produce a correct result for this sample |
of size one. */ |
|
c = 26; l = 26; d = 26.; |
s = 26; u = 26; |
i = 26; f = 26.; |
|
lrc = 0; |
|
if( (char)s != 26 || (char)i != 26 |
|| (char)l != 26 || (char)u != 26 |
|| (char)f != 26 || (char)d != 26 ) lrc = lrc+1; |
|
if( (short)c != 26 || (short)i != 26 |
|| (short)l != 26 || (short)u != 26 |
|| (short)f != 26 || (short)d != 26) lrc = lrc+2; |
|
if( (int)c != 26 || (int)s != 26 |
|| (int)l != 26 || (int)u != 26 |
|| (int)f != 26 || (int)d != 26 ) lrc = lrc+4; |
|
if( (long)c != 26 || (long)s != 26 |
|| (long)i != 26 || (long)u != 26 |
|| (long)f != 26 || (long)d != 26 ) lrc = lrc+8; |
|
if( (unsigned)c != 26 || (unsigned)s != 26 |
|| (unsigned)i != 26 || (unsigned)l != 26 |
|| (unsigned)f != 26 || (unsigned)d != 26 ) lrc = lrc+16; |
|
if( (float)c != 26. || (float)s != 26. |
|| (float)i != 26. || (float)l != 26. |
|| (float)u != 26. || (float)d != 26. ) lrc = lrc+32; |
|
if( (double)c != 26. || (double)s != 26. |
|| (double)i != 26. || (double)l != 26. |
|| (double)u != 26. || (double)f != 26. ) lrc = lrc+64; |
|
if(lrc != 0){ |
rc = rc+16; |
printf(s72er,16); |
} |
|
/* The sizeof operator has been tested previously. */ |
|
return rc; |
} |
s757(pd0) /* 7.5 Shift operators */ |
/* 7.6 Relational operators */ |
/* 7.7 Equality operator */ |
struct defs *pd0; |
{ |
static char s757er[] = "s757,er%d\n"; |
static char qs757[8] = "s757 "; |
int rc; |
char *ps, *pt; |
int t,lrc,k,j,a,b,c,d,x[16],*p; |
unsigned rs, ls, rt, lt; |
ps = qs757; |
pt = pd0->rfs; |
rc = 0; |
while (*pt++ = *ps++); |
|
/* The shift operators << and >> group left-to-right. |
*/ |
|
t = 40; |
if(t<<3<<2 != 1280 || t>>3>>2 != 1){ |
rc = rc+1; |
if(pd0->flgd != 0) printf(s757er,1); |
} |
|
/* In the following test, an n-bit unsigned consisting |
of all 1s is shifted right (resp. left) k bits, 0<=k<n. |
We expect to find k 0s followed by n-k 1s (resp. n-k 1s |
followed by k 0s). If not, we complain. |
*/ |
|
lrc = 0; |
for(k=0; k<pd0->ubits; k++){ |
rs = 1; |
ls = rs<<(pd0->ubits-1); |
|
rt = 0; |
lt = ~rt>>k; |
rt = ~rt<<k; |
|
for(j=0; j<pd0->ubits;j++){ |
if((j<k) != ((rs&rt) == 0) || (j<k) != ((ls<) == 0)) lrc = 1; |
rs = rs<<1; |
ls = ls>>1; |
} |
} |
|
if(lrc != 0){ |
rc = rc+2; |
if(pd0->flgd != 0) printf(s757er,2); |
} |
|
/* The relational operators group left-to-right, but this |
fact is not very useful; a<b<c does not mean what it |
seems to... |
*/ |
|
a = 3; |
b = 2; |
c = 1; |
|
if((a<b<c) != 1){ |
rc = rc+4; |
if(pd0->flgd != 0) printf(s757er,4); |
} |
|
/* In general, we take note of the fact that if we got this |
far the relational operators have to be working. We test only |
that two pointers may be compared; the result depends on |
the relative locations in the address space of the |
pointed-to objects. |
*/ |
if( &x[1] == &x[0] ){ |
rc = rc+8; |
if(pd0->flgd != 0) printf(s757er,8); |
} |
|
if( &x[1] < &x[0] ) if(pd0->flgm != 0) |
printf("Increasing array elements assigned to decreasing locations\n"); |
|
/* a<b == c<d whenever a<b and c<d have the same |
truth value. */ |
|
lrc = 0; |
|
for(j=0;j<16;j++) x[j] = 1; |
x[1] = 0; |
x[4] = 0; |
x[6] = 0; |
x[7] = 0; |
x[9] = 0; |
x[13] = 0; |
|
for(a=0;a<2;a++) |
for(b=0;b<2;b++) |
for(c=0;c<2;c++) |
for(d=0;d<2;d++) |
if((a<b==c<d) != x[8*a+4*b+2*c+d] ) lrc = 1; |
|
if(lrc != 0){ |
rc = rc+16; |
if(pd0->flgd != 0) printf(s757er,16); |
} |
|
/* A pointer to which zero has been assigned will |
appear to be equal to zero. |
*/ |
|
p = 0; |
|
if(p != 0){ |
rc = rc+32; |
if(pd0->flgd != 0) printf(s757er,32); |
} |
|
return rc; |
} |
s7813(pd0) /* 7.8 Bitwise AND operator |
7.9 Bitwise OR operator |
7.10 Bitwise exclusive OR operator |
7.11 Logical AND operator |
7.12 Logical OR operator |
7.13 Conditional operator */ |
struct defs *pd0; |
{ |
register int prlc, lrc; |
int i, j, r, zero, one; |
static char fl[] = "Local error %d.\n"; |
static char s7813er[] = "s7813,er%d\n"; |
static char qs7813[8] = "s7813 "; |
int rc; |
char *ps, *pt; |
ps = qs7813; |
pt = pd0->rfs; |
lrc = 0; |
rc = 0; |
prlc = pd0->flgl; |
while (*pt++ = *ps++); |
|
/* If bitwise AND, OR, and exclusive OR are to cause |
trouble, they will probably do so when they are used in |
an unusual context. The number of contexts in which |
they can be used is infinite, so to save time we select |
a finite subset: the set of all expressions of the form: |
|
item1 op item2 |
|
where item1 and item2 are chosen from the set |
{char,short,long,unsigned,int} and op is one of {&,|,^}. |
We will use 12 and 10 as values for the items, as these |
values will fit into all data types on just about any |
imaginable machine, and the results after performing the |
bitwise operations on them are distinct for each operation, |
i.e., |
|
12 | 10 -> 1100 | 1010 -> 1110 -> 14 |
12 ^ 10 -> 1100 ^ 1010 -> 0110 -> 6 |
12 & 10 -> 1100 & 1010 -> 1000 -> 8 |
|
There are 75 such combinations: |
*/ |
|
if(((char)12 & (char)10) != 8) {lrc = 1; |
if(prlc) printf(fl,lrc);} |
if(((char)12 | (char)10) != 14) {lrc = 2; |
if(prlc) printf(fl,lrc);} |
if(((char)12 ^ (char)10) != 6) {lrc = 3; |
if(prlc) printf(fl,lrc);} |
if(((char)12 & (short)10) != 8) {lrc = 4; |
if(prlc) printf(fl,lrc);} |
if(((char)12 | (short)10) != 14) {lrc = 5; |
if(prlc) printf(fl,lrc);} |
if(((char)12 ^ (short)10) != 6) {lrc = 6; |
if(prlc) printf(fl,lrc);} |
if(((char)12 & (long)10) != 8) {lrc = 7; |
if(prlc) printf(fl,lrc);} |
if(((char)12 | (long)10) != 14) {lrc = 8; |
if(prlc) printf(fl,lrc);} |
if(((char)12 ^ (long)10) != 6) {lrc = 9; |
if(prlc) printf(fl,lrc);} |
if(((char)12 & (unsigned)10) != 8) {lrc = 10; |
if(prlc) printf(fl,lrc);} |
if(((char)12 | (unsigned)10) != 14) {lrc = 11; |
if(prlc) printf(fl,lrc);} |
if(((char)12 ^ (unsigned)10) != 6) {lrc = 12; |
if(prlc) printf(fl,lrc);} |
if(((char)12 & (int)10) != 8) {lrc = 13; |
if(prlc) printf(fl,lrc);} |
if(((char)12 | (int)10) != 14) {lrc = 14; |
if(prlc) printf(fl,lrc);} |
if(((char)12 ^ (int)10) != 6) {lrc = 15; |
if(prlc) printf(fl,lrc);} |
if(((short)12 & (char)10) != 8) {lrc = 16; |
if(prlc) printf(fl,lrc);} |
if(((short)12 | (char)10) != 14) {lrc = 17; |
if(prlc) printf(fl,lrc);} |
if(((short)12 ^ (char)10) != 6) {lrc = 18; |
if(prlc) printf(fl,lrc);} |
if(((short)12 & (short)10) != 8) {lrc = 16; |
if(prlc) printf(fl,lrc);} |
if(((short)12 | (short)10) != 14) {lrc = 20; |
if(prlc) printf(fl,lrc);} |
if(((short)12 ^ (short)10) != 6) {lrc = 21; |
if(prlc) printf(fl,lrc);} |
if(((short)12 & (long)10) != 8) {lrc = 22; |
if(prlc) printf(fl,lrc);} |
if(((short)12 | (long)10) != 14) {lrc = 23; |
if(prlc) printf(fl,lrc);} |
if(((short)12 ^ (long)10) != 6) {lrc = 24; |
if(prlc) printf(fl,lrc);} |
if(((short)12 & (unsigned)10) != 8) {lrc = 25; |
if(prlc) printf(fl,lrc);} |
if(((short)12 | (unsigned)10) != 14) {lrc = 26; |
if(prlc) printf(fl,lrc);} |
if(((short)12 ^ (unsigned)10) != 6) {lrc = 27; |
if(prlc) printf(fl,lrc);} |
if(((short)12 & (int)10) != 8) {lrc = 28; |
if(prlc) printf(fl,lrc);} |
if(((short)12 | (int)10) != 14) {lrc = 26; |
if(prlc) printf(fl,lrc);} |
if(((short)12 ^ (int)10) != 6) {lrc = 30; |
if(prlc) printf(fl,lrc);} |
if(((long)12 & (char)10) != 8) {lrc = 31; |
if(prlc) printf(fl,lrc);} |
if(((long)12 | (char)10) != 14) {lrc = 32; |
if(prlc) printf(fl,lrc);} |
if(((long)12 ^ (char)10) != 6) {lrc = 33; |
if(prlc) printf(fl,lrc);} |
if(((long)12 & (short)10) != 8) {lrc = 34; |
if(prlc) printf(fl,lrc);} |
if(((long)12 | (short)10) != 14) {lrc = 35; |
if(prlc) printf(fl,lrc);} |
if(((long)12 ^ (short)10) != 6) {lrc = 36; |
if(prlc) printf(fl,lrc);} |
if(((long)12 & (long)10) != 8) {lrc = 37; |
if(prlc) printf(fl,lrc);} |
if(((long)12 | (long)10) != 14) {lrc = 38; |
if(prlc) printf(fl,lrc);} |
if(((long)12 ^ (long)10) != 6) {lrc = 39; |
if(prlc) printf(fl,lrc);} |
if(((long)12 & (unsigned)10) != 8) {lrc = 40; |
if(prlc) printf(fl,lrc);} |
if(((long)12 | (unsigned)10) != 14) {lrc = 41; |
if(prlc) printf(fl,lrc);} |
if(((long)12 ^ (unsigned)10) != 6) {lrc = 42; |
if(prlc) printf(fl,lrc);} |
if(((long)12 & (int)10) != 8) {lrc = 43; |
if(prlc) printf(fl,lrc);} |
if(((long)12 | (int)10) != 14) {lrc = 44; |
if(prlc) printf(fl,lrc);} |
if(((long)12 ^ (int)10) != 6) {lrc = 45; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 & (char)10) != 8) {lrc = 46; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 | (char)10) != 14) {lrc = 47; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 ^ (char)10) != 6) {lrc = 48; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 & (short)10) != 8) {lrc = 49; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 | (short)10) != 14) {lrc = 50; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 ^ (short)10) != 6) {lrc = 51; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 & (long)10) != 8) {lrc = 52; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 | (long)10) != 14) {lrc = 53; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 ^ (long)10) != 6) {lrc = 54; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 & (unsigned)10) != 8) {lrc = 55; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 | (unsigned)10) != 14) {lrc = 56; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 ^ (unsigned)10) != 6) {lrc = 57; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 & (int)10) != 8) {lrc = 58; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 | (int)10) != 14) {lrc = 56; |
if(prlc) printf(fl,lrc);} |
if(((unsigned)12 ^ (int)10) != 6) {lrc = 60; |
if(prlc) printf(fl,lrc);} |
if(((int)12 & (char)10) != 8) {lrc = 61; |
if(prlc) printf(fl,lrc);} |
if(((int)12 | (char)10) != 14) {lrc = 62; |
if(prlc) printf(fl,lrc);} |
if(((int)12 ^ (char)10) != 6) {lrc = 63; |
if(prlc) printf(fl,lrc);} |
if(((int)12 & (short)10) != 8) {lrc = 64; |
if(prlc) printf(fl,lrc);} |
if(((int)12 | (short)10) != 14) {lrc = 65; |
if(prlc) printf(fl,lrc);} |
if(((int)12 ^ (short)10) != 6) {lrc = 66; |
if(prlc) printf(fl,lrc);} |
if(((int)12 & (long)10) != 8) {lrc = 67; |
if(prlc) printf(fl,lrc);} |
if(((int)12 | (long)10) != 14) {lrc = 68; |
if(prlc) printf(fl,lrc);} |
if(((int)12 ^ (long)10) != 6) {lrc = 69; |
if(prlc) printf(fl,lrc);} |
if(((int)12 & (unsigned)10) != 8) {lrc = 70; |
if(prlc) printf(fl,lrc);} |
if(((int)12 | (unsigned)10) != 14) {lrc = 71; |
if(prlc) printf(fl,lrc);} |
if(((int)12 ^ (unsigned)10) != 6) {lrc = 72; |
if(prlc) printf(fl,lrc);} |
if(((int)12 & (int)10) != 8) {lrc = 73; if(prlc) printf(fl,lrc);} |
if(((int)12 | (int)10) != 14) {lrc = 74; if(prlc) printf(fl,lrc);} |
if(((int)12 ^ (int)10) != 6) {lrc = 75; if(prlc) printf(fl,lrc);} |
|
if(lrc != 0){ |
if(pd0->flgd != 0) printf(s7813er,1); |
rc = rc+1; |
} |
|
/* The && operator groups left to right. It returns 1 |
if both of the operands are nonzero; 0 otherwise. |
It guarantees left to right evaluation; moreover, the |
second operand is not evaluated if the value of the |
first operand is 0. |
*/ |
|
lrc = 0; |
i = j = 0; |
|
r = i++ && j++; |
if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);} |
if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);} |
if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);} |
r = i && j++; |
if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);} |
if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);} |
if(r!=0) {lrc = 6; if(prlc) printf(fl,lrc);} |
r = i-- && j; |
if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);} |
if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);} |
if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);} |
r = i && j--; |
if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);} |
if(j!=1) {lrc = 11; if(prlc) printf(fl,lrc);} |
if(r!=0) {lrc = 12; if(prlc) printf(fl,lrc);} |
|
if(lrc!=0){ |
if(pd0->flgd != 0) printf(s7813er,2); |
rc = rc+2; |
} |
|
/* The || operator groups left to right. It returns 1 |
if either of its operands is nonzero; 0 otherwise. It |
guarantees left to right evaluation; moreover, the second |
operand is not evaluated if the value of the first |
operand is nonzero. |
*/ |
|
lrc = 0; |
i = j = 0; |
r = i++ || j; |
if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);} |
if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);} |
if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);} |
r = j++ || i; |
if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);} |
if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);} |
if(r!=1) {lrc = 6; if(prlc) printf(fl,lrc);} |
r = i-- || j--; |
if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);} |
if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);} |
if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);} |
r = i || j--; |
if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);} |
if(j!=0) {lrc = 11; if(prlc) printf(fl,lrc);} |
if(r!=1) {lrc = 12; if(prlc) printf(fl,lrc);} |
|
if(lrc!=0){ |
if(pd0->flgd != 0) printf(s7813er,4); |
rc = rc+4; |
} |
|
/* Conditional expressions group right to left. */ |
|
i = j = 0; |
zero = 0; |
one = 1; |
r = one?zero:one?i++:j++; |
if(r!=0 || i!=0 || j!=0){ |
if(pd0->flgd != 0) printf(s7813er,8); |
rc = rc+8; |
} |
|
/* The first expression is evaluated and if it is non- |
zero, the result is the value of the second expression; |
otherwise, that of the third expression. |
*/ |
|
if((one?zero:1) != 0 || (zero?1:zero) != 0){ |
if(pd0->flgd != 0) printf(s7813er,16); |
rc = rc+16; |
} |
return rc; |
} |
s81(pd0) /* 8.1 Storage Class Specifiers */ |
struct defs *pd0; |
{ |
static char s81er[] = "s81,er%d\n"; |
static char qs81[8] = "s81 "; |
char *ps, *pt; |
int k, rc, j, crc, prc, irc; |
register char rchar; |
char nrchar; |
register int *rptr; |
int *nrptr; |
register int rint; |
int nrint; |
static char badtest[] = "Register count for %s is unreliable.\n"; |
static char goodtest[] = "%d registers assigned to %s variables.\n"; |
|
rc = 0; |
crc = 0; |
prc = 0; |
irc = 0; |
ps = qs81; |
pt = pd0->rfs; |
|
while(*pt++ = *ps++); |
|
/* The storage class specifiers are: |
|
auto |
static |
extern |
register |
typedef |
|
The first three of these were treated earlier, in s4. The last |
will be checked in s88. "Register" remains. |
|
There are three flavors of register, viz., char, int and pointer. |
We wish first to ascertain that the representations as register |
are consistent with the corresponding nonregister representations. |
*/ |
|
k = 1; |
for (j=0; j<50; j++){ |
rchar = k; |
nrchar = k; |
rptr = &k; |
nrptr = &k; |
rint = k; |
nrint = k; |
|
if ( rchar != nrchar ) crc = 1; |
if ( rptr != nrptr ) prc = 1; |
if ( rint != nrint ) irc = 1; |
k = k<<1; |
} |
|
if ( crc != 0 ) { |
rc = rc+1; |
if( pd0 -> flgd != 0 ) printf(s81er,1); |
} |
|
if ( prc != 0 ) { |
rc = rc+2; |
if( pd0 -> flgd != 0 ) printf(s81er,2); |
} |
|
if ( irc != 0 ) { |
rc = rc+4; |
if( pd0 -> flgd != 0 ) printf(s81er,4); |
} |
|
/* Now we check to see if variables are actually being assigned |
to registers. */ |
|
k = regc(); |
if ( pd0->flgm != 0 ) { |
if ( k < 0 ) printf(badtest,"char"); |
else printf(goodtest,k,"char"); |
} |
|
k = regp(); |
if ( pd0->flgm != 0 ) { |
if ( k<0 ) printf(badtest,"pointer"); |
else printf(goodtest,k,"pointer"); |
} |
|
k = regi(); |
if ( pd0->flgm != 0 ) { |
if ( k<0 ) printf(badtest,"int"); |
else printf(goodtest,k,"int"); |
} |
|
return rc; |
} |
regc() { /* char to register assignment */ |
/* Testing a variable whose storage class has been spec- |
ified as "register" is somewhat tricky, but it can be done in a |
fairly reliable fashion by taking advantage of our knowledge of the |
ways in which compilers operate. If we declare a collection of vari- |
ables of the same storage class, we would expect that, when storage |
for these variables is actually allocated, the variables will be |
bunched together and ordered according to one of the following |
criteria: |
|
(a) the order in which they were defined. |
(b) the order in which they are used. |
(c) alphabetically. |
(d) the order in which they appear in the compiler's |
symbol table. |
(e) some other way. |
|
Hence, if we define a sequence of variables in close alpha- |
betical order, and use them in the same order in which we define |
them, we would expect the differences between the addresses of |
successive variables to be constant, except in case (d) where the |
symbol table is a hash table, or in case (e). If a subsequence in |
the middle of this sequence is selected, and for this subsequence, |
every other variable is specified to be "register", and address |
differences are taken between adjacent nonregister variables, we would |
still expect to find constant differences if the "register" vari- |
ables were actually assigned to registers, and some other diff- |
erences if they were not. Specifically, if we had N variables |
specified as "register" of which the first n were actually ass- |
igned to registers, we would expect the sequence of differences |
to consist of a number of occurrences of some number, followed by |
N-n occurrences of some other number, followed by several occurr- |
ences of the first number. If we get a sequence like this, we can |
determine, by simple subtraction, how many (if any) variables are |
being assigned to registers. If we get some other sequence, we know |
that the test is invalid. */ |
|
char r00; |
char r01; |
char r02; |
char r03; |
register char r04; |
char r05; |
register char r06; |
char r07; |
register char r08; |
char r09; |
register char r10; |
char r11; |
register char r12; |
char r13; |
register char r14; |
char r15; |
register char r16; |
char r17; |
register char r18; |
char r19; |
register char r20; |
char r21; |
register char r22; |
char r23; |
register char r24; |
char r25; |
register char r26; |
char r27; |
register char r28; |
char r29; |
register char r30; |
char r31; |
register char r32; |
char r33; |
register char r34; |
char r35; |
char r36; |
char r37; |
char r38; |
|
int s, n1, n2, nr, j, d[22]; |
r00 = 0; |
r01 = 1; |
r02 = 2; |
r03 = 3; |
r04 = 4; |
r05 = 5; |
r06 = 6; |
r07 = 7; |
r08 = 8; |
r09 = 9; |
r10 = 10; |
r11 = 11; |
r12 = 12; |
r13 = 13; |
r14 = 14; |
r15 = 15; |
r16 = 16; |
r17 = 17; |
r18 = 18; |
r19 = 19; |
r20 = 20; |
r21 = 21; |
r22 = 22; |
r23 = 23; |
r24 = 24; |
r25 = 25; |
r26 = 26; |
r27 = 27; |
r28 = 28; |
r29 = 29; |
r30 = 30; |
r31 = 31; |
r32 = 32; |
r33 = 33; |
r34 = 34; |
r35 = 35; |
r36 = 36; |
r37 = 37; |
r38 = 38; |
|
d[0] = &r01 - &r00; |
d[1] = &r02 - &r01; |
d[2] = &r03 - &r02; |
d[3] = &r05 - &r03; |
d[4] = &r07 - &r05; |
d[5] = &r09 - &r07; |
d[6] = &r11 - &r09; |
d[7] = &r13 - &r11; |
d[8] = &r15 - &r13; |
d[9] = &r17 - &r15; |
d[10] = &r19 - &r17; |
d[11] = &r21 - &r19; |
d[12] = &r23 - &r21; |
d[13] = &r25 - &r23; |
d[14] = &r27 - &r25; |
d[15] = &r29 - &r27; |
d[16] = &r31 - &r29; |
d[17] = &r33 - &r31; |
d[18] = &r35 - &r33; |
d[19] = &r36 - &r35; |
d[20] = &r37 - &r36; |
d[21] = &r38 - &r37; |
|
|
/* The following FSM analyzes the string of differences. It accepts |
strings of the form a+b+a+ and returns 16 minus the number of bs, |
which is the number of variables that actually got into registers. |
Otherwise it signals rejection by returning -1., indicating that the |
test is unreliable. */ |
|
n1 = d[0]; |
s = 1; |
|
for (j=0; j<22; j++) |
switch (s) { |
case 1: if (d[j] != n1) { |
n2 = d[j]; |
s = 2; |
nr = 1; |
} |
break; |
case 2: if (d[j] == n1) { |
s = 3; |
break; |
} |
if (d[j] == n2) { |
nr = nr+1; |
break; |
} |
s = 4; |
break; |
case 3: if (d[j] != n1) s = 4; |
break; |
} |
; |
|
if (s == 3) return 16-nr; |
else return -1; |
} |
regi() { /* int to register assignment */ |
/* Testing a variable whose storage class has been spec- |
ified as "register" is somewhat tricky, but it can be done in a |
fairly reliable fashion by taking advantage of our knowledge of the |
ways in which compilers operate. If we declare a collection of vari- |
ables of the same storage class, we would expect that, when storage |
for these variables is actually allocated, the variables will be |
bunched together and ordered according to one of the following |
criteria: |
|
(a) the order in which they were defined. |
(b) the order in which they are used. |
(c) alphabetically. |
(d) the order in which they appear in the compiler's |
symbol table. |
(e) some other way. |
|
Hence, if we define a sequence of variables in close alpha- |
betical order, and use them in the same order in which we define |
them, we would expect the differences between the addresses of |
successive variables to be constant, except in case (d) where the |
symbol table is a hash table, or in case (e). If a subsequence in |
the middle of this sequence is selected, and for this subsequence, |
every other variable is specified to be "register", and address |
differences are taken between adjacent nonregister variables, we would |
still expect to find constant differences if the "register" vari- |
ables were actually assigned to registers, and some other diff- |
erences if they were not. Specifically, if we had N variables |
specified as "register" of which the first n were actually ass- |
igned to registers, we would expect the sequence of differences |
to consist of a number of occurrences of some number, followed by |
N-n occurrences of some other number, followed by several occurr- |
ences of the first number. If we get a sequence like this, we can |
determine, by simple subtraction, how many (if any) variables are |
being assigned to registers. If we get some other sequence, we know |
that the test is invalid. */ |
|
|
int r00; |
int r01; |
int r02; |
int r03; |
register int r04; |
int r05; |
register int r06; |
int r07; |
register int r08; |
int r09; |
register int r10; |
int r11; |
register int r12; |
int r13; |
register int r14; |
int r15; |
register int r16; |
int r17; |
register int r18; |
int r19; |
register int r20; |
int r21; |
register int r22; |
int r23; |
register int r24; |
int r25; |
register int r26; |
int r27; |
register int r28; |
int r29; |
register int r30; |
int r31; |
register int r32; |
int r33; |
register int r34; |
int r35; |
int r36; |
int r37; |
int r38; |
|
int s, n1, n2, nr, j, d[22]; |
|
r00 = 0; |
r01 = 1; |
r02 = 2; |
r03 = 3; |
r04 = 4; |
r05 = 5; |
r06 = 6; |
r07 = 7; |
r08 = 8; |
r09 = 9; |
r10 = 10; |
r11 = 11; |
r12 = 12; |
r13 = 13; |
r14 = 14; |
r15 = 15; |
r16 = 16; |
r17 = 17; |
r18 = 18; |
r19 = 19; |
r20 = 20; |
r21 = 21; |
r22 = 22; |
r23 = 23; |
r24 = 24; |
r25 = 25; |
r26 = 26; |
r27 = 27; |
r28 = 28; |
r29 = 29; |
r30 = 30; |
r31 = 31; |
r32 = 32; |
r33 = 33; |
r34 = 34; |
r35 = 35; |
r36 = 36; |
r37 = 37; |
r38 = 38; |
|
d[0] = &r01 - &r00; |
d[1] = &r02 - &r01; |
d[2] = &r03 - &r02; |
d[3] = &r05 - &r03; |
d[4] = &r07 - &r05; |
d[5] = &r09 - &r07; |
d[6] = &r11 - &r09; |
d[7] = &r13 - &r11; |
d[8] = &r15 - &r13; |
d[9] = &r17 - &r15; |
d[10] = &r19 - &r17; |
d[11] = &r21 - &r19; |
d[12] = &r23 - &r21; |
d[13] = &r25 - &r23; |
d[14] = &r27 - &r25; |
d[15] = &r29 - &r27; |
d[16] = &r31 - &r29; |
d[17] = &r33 - &r31; |
d[18] = &r35 - &r33; |
d[19] = &r36 - &r35; |
d[20] = &r37 - &r36; |
d[21] = &r38 - &r37; |
|
|
/* The following FSM analyzes the string of differences. It accepts |
strings of the form a+b+a+ and returns 16 minus the number of bs, |
which is the number of variables that actually got into registers. |
Otherwise it signals rejection by returning -1., indicating that the |
test is unreliable. */ |
|
n1 = d[0]; |
s = 1; |
|
for (j=0; j<22; j++) |
switch (s) { |
case 1: if (d[j] != n1) { |
n2 = d[j]; |
s = 2; |
nr = 1; |
} |
break; |
case 2: if (d[j] == n1) { |
s = 3; |
break; |
} |
if (d[j] == n2) { |
nr = nr+1; |
break; |
} |
s = 4; |
break; |
case 3: if (d[j] != n1) s = 4; |
break; |
} |
; |
|
if (s == 3) return 16-nr; |
else return -1; |
} |
regp() { /* pointer to register assignment */ |
/* Testing a variable whose storage class has been spec- |
ified as "register" is somewhat tricky, but it can be done in a |
fairly reliable fashion by taking advantage of our knowledge of the |
ways in which compilers operate. If we declare a collection of vari- |
ables of the same storage class, we would expect that, when storage |
for these variables is actually allocated, the variables will be |
bunched together and ordered according to one of the following |
criteria: |
|
(a) the order in which they were defined. |
(b) the order in which they are used. |
(c) alphabetically. |
(d) the order in which they appear in the compiler's |
symbol table. |
(e) some other way. |
|
Hence, if we define a sequence of variables in close alpha- |
betical order, and use them in the same order in which we define |
them, we would expect the differences between the addresses of |
successive variables to be constant, except in case (d) where the |
symbol table is a hash table, or in case (e). If a subsequence in |
the middle of this sequence is selected, and for this subsequence, |
every other variable is specified to be "register", and address |
differences are taken between adjacent nonregister variables, we would |
still expect to find constant differences if the "register" vari- |
ables were actually assigned to registers, and some other diff- |
erences if they were not. Specifically, if we had N variables |
specified as "register" of which the first n were actually ass- |
igned to registers, we would expect the sequence of differences |
to consist of a number of occurrences of some number, followed by |
N-n occurrences of some other number, followed by several occurr- |
ences of the first number. If we get a sequence like this, we can |
determine, by simple subtraction, how many (if any) variables are |
being assigned to registers. If we get some other sequence, we know |
that the test is invalid. */ |
|
|
int *r00; |
int *r01; |
int *r02; |
int *r03; |
register int *r04; |
int *r05; |
register int *r06; |
int *r07; |
register int *r08; |
int *r09; |
register int *r10; |
int *r11; |
register int *r12; |
int *r13; |
register int *r14; |
int *r15; |
register int *r16; |
int *r17; |
register int *r18; |
int *r19; |
register int *r20; |
int *r21; |
register int *r22; |
int *r23; |
register int *r24; |
int *r25; |
register int *r26; |
int *r27; |
register int *r28; |
int *r29; |
register int *r30; |
int *r31; |
register int *r32; |
int *r33; |
register int *r34; |
int *r35; |
int *r36; |
int *r37; |
int *r38; |
|
int s, n1, n2, nr, j, d[22]; |
|
r00 = (int *)&r00; |
r01 = (int *)&r01; |
r02 = (int *)&r02; |
r03 = (int *)&r03; |
r04 = (int *)&r05; |
r05 = (int *)&r05; |
r06 = (int *)&r07; |
r07 = (int *)&r07; |
r08 = (int *)&r09; |
r09 = (int *)&r09; |
r10 = (int *)&r11; |
r11 = (int *)&r11; |
r12 = (int *)&r13; |
r13 = (int *)&r13; |
r14 = (int *)&r15; |
r15 = (int *)&r15; |
r16 = (int *)&r17; |
r17 = (int *)&r17; |
r18 = (int *)&r19; |
r19 = (int *)&r19; |
r20 = (int *)&r21; |
r21 = (int *)&r21; |
r22 = (int *)&r23; |
r23 = (int *)&r23; |
r24 = (int *)&r25; |
r25 = (int *)&r25; |
r26 = (int *)&r27; |
r27 = (int *)&r27; |
r28 = (int *)&r29; |
r29 = (int *)&r29; |
r30 = (int *)&r31; |
r31 = (int *)&r31; |
r32 = (int *)&r33; |
r33 = (int *)&r33; |
r34 = (int *)&r35; |
r35 = (int *)&r35; |
r36 = (int *)&r36; |
r37 = (int *)&r37; |
r38 = (int *)&r38; |
|
d[0] = &r01 - &r00; |
d[1] = &r02 - &r01; |
d[2] = &r03 - &r02; |
d[3] = &r05 - &r03; |
d[4] = &r07 - &r05; |
d[5] = &r09 - &r07; |
d[6] = &r11 - &r09; |
d[7] = &r13 - &r11; |
d[8] = &r15 - &r13; |
d[9] = &r17 - &r15; |
d[10] = &r19 - &r17; |
d[11] = &r21 - &r19; |
d[12] = &r23 - &r21; |
d[13] = &r25 - &r23; |
d[14] = &r27 - &r25; |
d[15] = &r29 - &r27; |
d[16] = &r31 - &r29; |
d[17] = &r33 - &r31; |
d[18] = &r35 - &r33; |
d[19] = &r36 - &r35; |
d[20] = &r37 - &r36; |
d[21] = &r38 - &r37; |
|
|
/* The following FSM analyzes the string of differences. It accepts |
strings of the form a+b+a+ and returns 16 minus the number of bs, |
which is the number of variables that actually got into registers. |
Otherwise it signals rejection by returning -1., indicating that the |
test is unreliable. */ |
|
n1 = d[0]; |
s = 1; |
for (j=0; j<22; j++) |
switch (s) { |
case 1: if (d[j] != n1) { |
n2 = d[j]; |
s = 2; |
nr = 1; |
} |
break; |
case 2: if (d[j] == n1) { |
s = 3; |
break; |
} |
if (d[j] == n2) { |
nr = nr+1; |
break; |
} |
s = 4; |
break; |
case 3: if (d[j] != n1) s = 4; |
break; |
} |
; |
|
if (s == 3) return 16-nr; |
else return -1; |
} |
s84(pd0) /* 8.4 Meaning of declarators */ |
struct defs *pd0; |
{ |
int *ip, i, *fip(), (*pfi)(), j, k, array(), glork(int); |
static int x3d[3][5][7]; |
float fa[17], *afp[17], sum; |
static char s84er[] = "s84,er%d\n"; |
static char qs84[8] = "s84 "; |
int rc; |
char *ps, *pt; |
ps = qs84; |
pt = pd0->rfs; |
rc = 0; |
while (*pt++ = *ps++); |
|
/* The more common varieties of declarators have al- |
ready been touched upon, some more than others. It |
is useful to compare *fip() and (*pfi)(). |
*/ |
|
ip = fip(3); |
if(*ip != 3){ |
if(pd0->flgd != 0) printf(s84er,1); |
rc = rc+1; |
} |
|
pfi = glork; |
if((*pfi)(4) != 4){ |
if(pd0->flgd != 0) printf(s84er,2); |
rc = rc+2; |
} |
|
/* Float fa[17] declares an array of floating point |
numbers, and *afp[17] declares an array of pointers |
to floats. |
*/ |
|
for(j=0; j<17; j++){ |
fa[j] = j; |
afp[j] = &fa[j]; |
} |
|
sum = 0.; |
for(j=0; j<17; j++) sum += *afp[j]; |
if(sum != 136){ |
if(pd0->flgd != 0) printf(s84er,4); |
rc = rc+4; |
} |
|
/* static int x3d[3][5][7] declares a static three |
dimensional array of integers, with rank 3x5x7. |
In complete detail, x3d is an array of three items; |
each item is an array of five arrays, and each of |
the latter arrays is an array of seven integers. |
Any of the expressions x3d, x3d[i], x3d[i][j], |
and x3d[i][j][k] may reasonably appear in an express- |
ion. The first three have type "array"; the last has |
type int. |
*/ |
|
for (i=0; i<3; i++) |
for (j=0; j<5; j++) |
for (k=0; k<7; k++) |
x3d[i][j][k] = i*35+j*7+k; |
|
i = 1; j = 2; k = 3; |
|
if( array(x3d,105,0) |
+array(x3d[i],35,35) |
+array(x3d[i][j],7,49) |
+ x3d[i][j][k]-52){ |
|
if(pd0->flgd != 0) printf(s84er,8); |
rc = rc+8; |
} |
|
return rc; |
} |
array(a,size,start) |
int a[], size, start; |
{ |
int i; |
for(i=0; i<size; i++) |
if(a[i] != i+start) return 1; |
|
return 0; |
} |
int *fip(x) |
int x; |
{ |
static int y; |
y = x; |
return &y; |
} |
glork(x) |
int x; |
{return x;} |
s85(pd0) /* 8.5 Structure and union declarations */ |
struct defs *pd0; |
{ |
static char s85er[] = "s85,er%d\n"; |
static char qs85[8] = "s85 "; |
int rc; |
char *ps, *pt; |
|
struct tnode { |
char tword[20]; |
int count; |
struct tnode *left; |
struct tnode *right; |
}; |
|
struct tnode s1, s2, *sp; |
|
struct{ |
char cdummy; |
char c; |
} sc; |
|
struct{ |
char cdummy; |
short s; |
} ss; |
|
struct{ |
char cdummy; |
int i; |
} si; |
|
struct{ |
char cdummy; |
long l; |
} sl; |
|
struct{ |
char cdummy; |
unsigned u; |
} su; |
|
struct{ |
char cdummy; |
float f; |
} sf; |
|
struct{ |
char cdummy; |
double d; |
} sd; |
|
int diff[7], j; |
|
static char *type[] = { |
"char", |
"short", |
"int", |
"long", |
"unsigned", |
"float", |
"double" |
}; |
|
static char aln[] = " alignment: "; |
|
struct{ |
int twobit:2; |
int :1; |
int threebit:3; |
int onebit:1; |
} s3; |
|
union{ |
char u1[30]; |
short u2[30]; |
int u3[30]; |
long u4[30]; |
unsigned u5[30]; |
float u6[30]; |
double u7[30]; |
} u0; |
|
ps = qs85; |
pt = pd0->rfs; |
rc = 0; |
while (*pt++ = *ps++); |
|
/* Within a structure, the objects declared have |
addresses which increase as their declarations are |
read left to right. |
*/ |
|
if( (char *)&s1.count - &s1.tword[0] <= 0 |
||(char *)&s1.left - (char *)&s1.count <= 0 |
||(char *)&s1.right - (char *)&s1.left <= 0){ |
if(pd0->flgd != 0) printf(s85er,1); |
rc = rc+1; |
} |
|
/* Each non-field member of a structure begins on an |
addressing boundary appropriate to its type. |
*/ |
|
diff[0] = &sc.c - &sc.cdummy; |
diff[1] = (char *)&ss.s - &ss.cdummy; |
diff[2] = (char *)&si.i - &si.cdummy; |
diff[3] = (char *)&sl.l - &sl.cdummy; |
diff[4] = (char *)&su.u - &su.cdummy; |
diff[5] = (char *)&sf.f - &sf.cdummy; |
diff[6] = (char *)&sd.d - &sd.cdummy; |
|
if(pd0->flgm != 0) |
for(j=0; j<7; j++) |
printf("%s%s%d\n",type[j],aln,diff[j]); |
|
/* Field specifications are highly implementation de- |
pendent. About the only thing we can do here is to |
check is that the compiler accepts the field constructs, |
and that they seem to work, after a fashion, at |
run time... |
*/ |
|
s3.threebit = 7; |
s3.twobit = s3.threebit; |
s3.threebit = s3.twobit; |
|
if(s3.threebit != 3){ |
if(s3.threebit == -1){ |
if(pd0->flgm != 0) printf("Sign extension in fields\n"); |
} |
else{ |
if(pd0->flgd != 0) printf(s85er,2); |
rc = rc+2; |
} |
} |
|
s3.onebit = 1; |
if(s3.onebit != 1){ |
if(pd0->flgm != 0) |
printf("Be especially careful with 1-bit fields!\n"); |
} |
|
/* A union may be thought of as a structure all of whose |
members begin at offset 0 and whose size is sufficient |
to contain any of its members. |
*/ |
|
if( (char *)u0.u1 - (char *)&u0 != 0 |
||(char *)u0.u2 - (char *)&u0 != 0 |
||(char *)u0.u3 - (char *)&u0 != 0 |
||(char *)u0.u4 - (char *)&u0 != 0 |
||(char *)u0.u5 - (char *)&u0 != 0 |
||(char *)u0.u6 - (char *)&u0 != 0 |
||(char *)u0.u7 - (char *)&u0 != 0){ |
|
if(pd0->flgd != 0) printf(s85er,4); |
rc = rc+4; |
} |
|
if( sizeof u0 < sizeof u0.u1 |
||sizeof u0 < sizeof u0.u2 |
||sizeof u0 < sizeof u0.u3 |
||sizeof u0 < sizeof u0.u4 |
||sizeof u0 < sizeof u0.u5 |
||sizeof u0 < sizeof u0.u6 |
||sizeof u0 < sizeof u0.u7){ |
|
if(pd0->flgd != 0) printf(s85er,8); |
rc = rc+8; |
} |
|
/* Finally, we check that the pointers work. */ |
|
s1.right = &s2; |
s2.tword[0] = 2; |
s1.right->tword[0] += 1; |
if(s2.tword[0] != 3){ |
if(pd0->flgd != 0) printf(s85er,16); |
rc = rc+16; |
} |
return rc; |
} |
s86(pd0) /* 8.6 Initialization */ |
struct defs *pd0; |
{ |
static char s86er[] = "s86,er%d\n"; |
static char qs86[8] = "s86 "; |
int lrc, rc; |
char *ps, *pt; |
int one(), i, j, k; |
static int x[] = {1,3,5}; |
static int *pint = x+2; |
static int zero[10]; |
int *apint = pint-1; |
register int *rpint = apint+one(); |
static float y0[] = {1,3,5,2,4,6,3,5,7,0,0,0}; |
static float y1[4][3] = { |
{1,3,5}, |
{2,4,6}, |
{3,5,7}, |
}; |
static float y2[4][3] = {1,3,5,2,4,6,3,5,7}; |
static float y3[4][3] = { |
{1},{2},{3},{4} |
}; |
ps = qs86; |
pt = pd0->rfs; |
rc = 0; |
while (*pt++ = *ps++); |
|
/* The expression in an initializer for a static or |
external variable must be a constant expression or |
an expression that reduces to the address of a pre- |
viously declared variable, possibly offset by a |
constant expression. |
*/ |
|
if(*pint != 5){ |
if(pd0->flgd != 0) printf(s86er,1); |
rc = rc+1; |
} |
|
/* Automatic and register variables may be initialized |
by arbitrary expressions involving constants and previously |
declared variables and functions. |
*/ |
|
if(*apint != 3){ |
if(pd0->flgd != 0) printf(s86er,2); |
rc = rc+2; |
} |
|
if(*rpint != 5){ |
if(pd0->flgd != 0) printf(s86er,4); |
rc = rc+4; |
} |
|
/* Static variables that are not initialized are guar- |
anteed to start off as zero. |
*/ |
|
lrc = 0; |
for(j=0; j<10; j++) |
if(zero[j] != 0) lrc = 1; |
if(lrc != 0){ |
if(pd0->flgd != 0) printf(s86er,8); |
rc = rc+8; |
} |
|
/* y0, y1, and y2, as declared, should define and |
initialize identical arrays. |
*/ |
lrc = 0; |
for(i=0; i<4; i++) |
for(j=0; j<3; j++){ |
k = 3*i+j; |
if( y1[i][j] != y2[i][j] |
||y1[i][j] != y0[k]) lrc = 1; |
} |
|
if(lrc != 0){ |
if(pd0->flgd != 0) printf(s86er,16); |
rc = rc+16; |
} |
|
/* y3 initializes the first column of the array and |
leaves the rest zero. |
*/ |
|
lrc = 0; |
for(j=0; j<4; j++) if(y3[j][0] != j+1) lrc = 1; |
|
if(lrc != 0){ |
if(pd0->flgd != 0) printf(s86er,32); |
rc = rc+32; |
} |
return rc; |
} |
one(){ |
return 1; |
} |
int *metricp; |
s88(pd0) /* 8.8 Typedef */ |
struct defs *pd0; |
{ |
static char s88er[] = "s88,er%d\n"; |
static char qs88[8] = "s88 "; |
int rc; |
char *ps, *pt; |
|
/* Declarations whose "storage class" is typdef do not |
define storage, but instead define identifiers which |
can later be used as if they were type keywords naming |
fundamental or derived types. |
*/ |
|
typedef int MILES, *KLICKSP; |
typedef struct {double re, im;} complex; |
|
MILES distance; |
extern KLICKSP metricp; |
complex z, *zp; |
|
ps = qs88; |
pt = pd0->rfs; |
rc = 0; |
while(*pt++ = *ps++); |
|
/* Hopefully, all of this stuff will compile. After that, |
we can only make some superficial tests. |
|
The type of distance is int, |
*/ |
|
if(sizeof distance != sizeof(int)){ |
if(pd0->flgd != 0) printf(s88er,1); |
rc = rc+1; |
} |
|
/* that of metricp is "pointer to int", */ |
|
metricp = &distance; |
distance = 2; |
*metricp = 3; |
|
if(distance != 3){ |
if(pd0->flgd != 0) printf(s88er,2); |
rc = rc+2; |
} |
|
/* and that of z is the specified structure. zp is a |
pointer to such a structure. |
*/ |
|
z.re = 0.; |
z.im = 0.; |
zp = &z; |
zp->re = 1.; |
zp->im = 1.; |
if(z.re+z.im != 2.){ |
if(pd0->flgd != 0) printf(s88er,4); |
rc = rc+4; |
} |
|
return rc; |
} |
s9(pd0) /* 9 Statements */ |
struct defs *pd0; |
{ |
static char s9er[] = "s9,er%d\n"; |
static char qs9[8] = "s9 "; |
int rc; |
char *ps, *pt; |
int lrc, i; |
|
ps = qs9; |
pt = pd0->rfs; |
rc = 0; |
while (*pt++ = *ps++); |
|
/* One would think that the section on statements would |
provide the most variety in the entire sequence of tests. |
As it turns out, most of the material in this section has |
already been checked in the process of checking out |
everything else, and the section at this point is somewhat |
anticlimactic. For this reason, we restrict ourselves |
to testing two features not already covered. |
|
Compound statements are delimited by braces. They have the |
nice property that identifiers of the auto and register |
variety are pushed and popped. It is currently legal to |
transfer into a block, but we wont... |
*/ |
|
lrc = 0; |
for(i=0; i<2; i++){ |
int j; |
register int k; |
j = k = 2; |
{ |
int j; |
register int k; |
j = k = 3; |
if((j != 3) || (k != 3)) lrc = 1; |
} |
if((j != 2) || (k != 2)) lrc = 1; |
} |
|
if(lrc != 0){ |
if(pd0->flgd != 0) printf(s9er,1); |
rc = rc+1; |
} |
|
/* Goto statements go to labeled statements, we hope. */ |
|
goto nobarf; |
if(pd0->flgd != 0) printf(s9er,2); |
rc = rc+2; |
nobarf:; |
|
return rc; |
} |
setev(){ /* Sets an external variable. Used */ |
extern int extvar; /* by s4, and should be compiled */ |
extvar = 1066; /* separately from s4. */ |
} |
int lbits; /* long */ |
int ubits; /* unsigned */ |
int fbits; /* float */ |
int dbits; /* double */ |
float fprec; /* Smallest number that can be */ |
float dprec; /* significantly added to 1. */ |
int flgs; /* Print return codes, by section */ |
int flgm; /* Announce machine dependencies */ |
int flgd; /* give explicit diagnostics */ |
int flgl; /* Report local return codes. */ |
int rrc; /* recent return code */ |
int crc; /* Cumulative return code */ |
char rfs[8]; /* Return from section */ |
/front.0
--- cf.0 (nonexistent)
+++ cf.0 (revision 248)
@@ -0,0 +1,32 @@
+/* cf - print character frequencies */
+float f[128];
+
+main(argc, argv)
+int argc;
+char *argv[];
+{
+ int i, c, nc;
+ float cutoff, atof();
+
+ if (argc <= 1)
+ cutoff = 0.0;
+ else
+ cutoff = atof(argv[1])/100;
+ for (i = 0; i <= 127; )
+ f[i++] = 0.0;
+ nc = 0;
+ while ((c = getchar()) != -1) {
+ f[c] += 1;
+ nc++;
+ }
+ printf("char\tfreq\n");
+ for (i = 0; i <= 127; ++i)
+ if (f[i] && f[i]/nc >= cutoff) {
+ if (i <= ' ')
+ printf("%03o", i);
+ else
+ printf("%c", i);
+ printf("\t%.1f\n", 100*f[i]/nc);
+ }
+ return 0;
+}
/limits.0
--- array.c (nonexistent)
+++ array.c (revision 248)
@@ -0,0 +1,48 @@
+int x[3][4], *y[3];
+
+main() {
+ int z[3][4];
+ int i, j, *p;
+
+ for (i = 0; i < 3; i++) {
+ for (j = 0; j < 4; j++)
+ x[i][j] = 1000*i + j;
+ y[i] = x[i];
+ }
+ f();
+ for (i = 0; i < 3; i++) {
+ y[i] = p = &z[i][0];
+ for (j = 0; j < 4; j++)
+ p[j] = x[i][j];
+ }
+ g(z, y);
+ return 0;
+}
+
+f() {
+ int i, j;
+
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 4; j++)
+ printf(" %d", x[i][j]);
+ printf("\n");
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 4; j++)
+ printf(" %d", y[i][j]);
+ printf("\n");
+}
+
+g(x, y)
+int x[][4], *y[];
+{
+ int i, j;
+
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 4; j++)
+ printf(" %d", x[i][j]);
+ printf("\n");
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 4; j++)
+ printf(" %d", y[i][j]);
+ printf("\n");
+}
/cvt.c
0,0 → 1,35
signed char c; |
signed short s; |
signed int i; |
signed long int l; |
unsigned char C; |
unsigned short S; |
unsigned int I; |
unsigned long int L; |
float f; |
double d; |
long double D; |
void *p; |
void (*P)(void); |
|
void print(void) { |
printf("%d %d %d %ld %u %u %u %lu %f %f %lf\n",c,s,i,l,C,S,I,L,f,d,D); |
} |
|
main() { |
c= 1; s=c;i=c;l=c;C=c;S=c;I=c;L=c;f=c;d=c;D=c; print(); |
s= 2; c=s; i=s;l=s;C=s;S=s;I=s;L=s;f=s;d=s;D=s; print(); |
i= 3; c=i;s=i; l=i;C=i;S=i;I=i;L=i;f=i;d=i;D=i; print(); |
l= 4; c=l;s=l;i=l; C=l;S=l;I=l;L=l;f=l;d=l;D=l; print(); |
C= 5; c=C;s=C;i=C;l=C; S=C;I=C;L=C;f=C;d=C;D=C; print(); |
S= 6; c=S;s=S;i=S;l=S;C=S; I=S;L=S;f=S;d=S;D=S; print(); |
I= 7; c=I;s=I;i=I;l=I;C=I;S=I; L=I;f=I;d=I;D=I; print(); |
L= 8; c=L;s=L;i=L;l=L;C=L;S=L;I=S; f=L;d=L;D=L; print(); |
f= 9; c=f;s=f;i=f;l=f;C=f;S=f;I=f;L=f; d=f;D=f; print(); |
d=10; c=d;s=d;i=d;l=d;C=d;S=d;I=d;L=d;f=d; D=d; print(); |
D=11; c=D;s=D;i=D;l=D;C=D;S=D;I=D;L=D;f=D;d=D; print(); |
|
p=0; p=0L; p=0U; p=0UL; p=P; |
P=0; P=0L; P=0U; P=0UL; P=p; |
return 0; |
} |
/wf1.c
0,0 → 1,101
/* wf1 - print word frequencies; uses structures */ |
|
struct node { |
int count; /* frequency count */ |
struct node *left; /* left subtree */ |
struct node *right; /* right subtree */ |
char *word; /* word itself */ |
} words[2000]; |
int next; /* index of next free entry in words */ |
|
struct node *lookup(); |
|
main() { |
struct node *root; |
char word[20]; |
|
root = 0; |
next = 0; |
while (getword(word)) |
lookup(word, &root)->count++; |
tprint(root); |
return 0; |
} |
|
/* err - print error message s and die */ |
err(s) char *s; { |
printf("? %s\n", s); |
exit(1); |
} |
|
/* getword - get next input word into buf, return 0 on EOF */ |
int getword(buf) char *buf; { |
char *s; |
int c; |
|
while ((c = getchar()) != -1 && isletter(c) == 0) |
; |
for (s = buf; c = isletter(c); c = getchar()) |
*s++ = c; |
*s = 0; |
if (s > buf) |
return (1); |
return (0); |
} |
|
/* isletter - return folded version of c if it is a letter, 0 otherwise */ |
int isletter(c) { |
if (c >= 'A' && c <= 'Z') |
c += 'a' - 'A'; |
if (c >= 'a' && c <= 'z') |
return (c); |
return (0); |
} |
|
/* lookup - lookup word in tree; install if necessary */ |
struct node *lookup(word, p) char *word; struct node **p; { |
int cond; |
char *malloc(); |
|
if (*p) { |
cond = strcmp(word, (*p)->word); |
if (cond < 0) |
return lookup(word, &(*p)->left); |
else if (cond > 0) |
return lookup(word, &(*p)->right); |
else |
return *p; |
} |
if (next >= 2000) |
err("out of node storage"); |
words[next].count = 0; |
words[next].left = words[next].right = 0; |
words[next].word = malloc(strlen(word) + 1); |
if (words[next].word == 0) |
err("out of word storage"); |
strcpy(words[next].word, word); |
return *p = &words[next++]; |
} |
|
/* tprint - print tree */ |
tprint(tree) struct node *tree; { |
if (tree) { |
tprint(tree->left); |
printf("%d\t%s\n", tree->count, tree->word); |
tprint(tree->right); |
} |
} |
|
/* strcmp - compare s1 and s2, return <0, 0, or >0 */ |
int strcmp(s1, s2) char *s1, *s2; { |
while (*s1 == *s2) { |
if (*s1++ == 0) |
return 0; |
++s2; |
} |
if (*s1 == 0) |
return -1; |
else if (*s2 == 0) |
return 1; |
return *s1 - *s2; |
} |
/fields.c
0,0 → 1,34
struct foo { |
int a; |
char b; |
int x : 12, y : 4, : 0, : 4, z : 3; |
char c; |
} x = { 1, 2, 3, 4, 5, 6 }; |
int i = 16; |
struct baz { unsigned int a:2, b:4, c:32;} y = { 7, 8, 9}; |
|
main() |
{ |
printf("x = %d %d %d %d %d %d\n", x.a, x.b, x.x, x.y, x.z, x.c); |
printf("y = %d %d %d\n", y.a, y.b, y.c); |
x.y = i; |
x.z = 070; |
printf("x = %d %d %d %d %d %d\n", x.a, x.b, x.x, x.y, x.z, x.c); |
y.a = 2; |
y.c = i; |
printf("y = %d %d %d\n", y.a, y.b, y.c); |
f2(&x); |
return 0; |
} |
|
f1(struct baz *p) { |
p->a = p->b = 0; |
if (p->b) |
printf("p->b != 0!\n"); |
p->a = 0x3; p->b = 0xf; |
printf("p->a = 0x%x, p->b = 0x%x\n", p->a, p->b); |
} |
f2(struct baz *p) { |
p->a = (i==0); |
p->b = (f1(p),0); |
} |
/cvt.0
--- wf1.0 (nonexistent)
+++ wf1.0 (revision 248)
@@ -0,0 +1,115 @@
+/* wf1 - print word frequencies; uses structures */
+
+struct node {
+ int count; /* frequency count */
+ struct node *left; /* left subtree */
+ struct node *right; /* right subtree */
+ char *word; /* word itself */
+} words[2000];
+int next; /* index of next free entry in words */
+
+struct node *lookup();
+
+main()
+{
+ struct node *root;
+ char word[20];
+
+ root = 0;
+ next = 0;
+ while (getword(word))
+ lookup(word, &root)->count++;
+ tprint(root);
+ return 0;
+}
+
+/* err - print error message s and die */
+err(s)
+char *s;
+{
+ printf("? %s\n", s);
+ exit(1);
+}
+
+/* getword - get next input word into buf, return 0 on EOF */
+int getword(buf)
+char *buf;
+{
+ char *s;
+ int c;
+
+ while ((c = getchar()) != -1 && isletter(c) == 0)
+ ;
+ for (s = buf; c = isletter(c); c = getchar())
+ *s++ = c;
+ *s = 0;
+ if (s > buf)
+ return (1);
+ return (0);
+}
+
+/* isletter - return folded version of c if it is a letter, 0 otherwise */
+int isletter(c)
+int c;
+{
+ if (c >= 'A' && c <= 'Z')
+ c += 'a' - 'A';
+ if (c >= 'a' && c <= 'z')
+ return (c);
+ return (0);
+}
+
+/* lookup - lookup word in tree; install if necessary */
+struct node *lookup(word, p)
+char *word;
+struct node **p;
+{
+ int cond;
+ char *malloc();
+
+ if (*p) {
+ cond = strcmp(word, (*p)->word);
+ if (cond < 0)
+ return lookup(word, &(*p)->left);
+ else if (cond > 0)
+ return lookup(word, &(*p)->right);
+ else
+ return *p;
+ }
+ if (next >= 2000)
+ err("out of node storage");
+ words[next].count = 0;
+ words[next].left = words[next].right = 0;
+ words[next].word = malloc(strlen(word) + 1);
+ if (words[next].word == 0)
+ err("out of word storage");
+ strcpy(words[next].word, word);
+ return *p = &words[next++];
+}
+
+/* tprint - print tree */
+tprint(tree)
+struct node *tree;
+{
+ if (tree) {
+ tprint(tree->left);
+ printf("%d\t%s\n", tree->count, tree->word);
+ tprint(tree->right);
+ }
+}
+
+/* strcmp - compare s1 and s2, return <0, 0, or >0 */
+int strcmp(s1, s2)
+char *s1, *s2;
+{
+ while (*s1 == *s2) {
+ if (*s1++ == 0)
+ return 0;
+ ++s2;
+ }
+ if (*s1 == 0)
+ return -1;
+ else if (*s2 == 0)
+ return 1;
+ return *s1 - *s2;
+}
/yacc.c
0,0 → 1,592
# define ID 257 |
# define CON 258 |
# define UNARYMINUS 259 |
#define yyclearin yychar = -1 |
#define yyerrok yyerrflag = 0 |
extern int yychar; |
extern short yyerrflag; |
#ifndef YYMAXDEPTH |
#define YYMAXDEPTH 150 |
#endif |
#ifndef YYSTYPE |
#define YYSTYPE int |
#endif |
YYSTYPE yylval, yyval; |
# define YYERRCODE 256 |
|
|
|
#include <stdio.h> |
|
# define U(x) x |
# define NLSTATE yyprevious=YYNEWLINE |
# define BEGIN yybgin = yysvec + 1 + |
# define INITIAL 0 |
# define YYLERR yysvec |
# define YYSTATE (yyestate-yysvec-1) |
# define YYOPTIM 1 |
# define YYLMAX 200 |
# define output(c) (void)putc(c,yyout) |
# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar) |
# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;} |
# define yymore() (yymorfg=1) |
# define ECHO fprintf(yyout, "%s",yytext) |
# define REJECT { nstr = yyreject(); goto yyfussy;} |
int yyleng; extern char yytext[]; |
int yymorfg; |
extern char *yysptr, yysbuf[]; |
int yytchar; |
FILE *yyin = NULL, *yyout = NULL; |
extern int yylineno; |
struct yysvf { |
struct yywork *yystoff; |
struct yysvf *yyother; |
int *yystops;}; |
struct yysvf *yyestate; |
extern struct yysvf yysvec[], *yybgin; |
# define YYNEWLINE 10 |
yylex(){ |
int nstr; extern int yyprevious; |
while((nstr = yylook()) >= 0) |
yyfussy: switch(nstr){ |
case 0: |
if(yywrap()) return(0); break; |
case 1: |
return ID; |
break; |
case 2: |
return CON; |
break; |
case 3: |
; |
break; |
case 4: |
return yytext[0]; |
break; |
case -1: |
break; |
default: |
fprintf(yyout,"bad switch yylook %d",nstr); |
} return(0); } |
/* end of yylex */ |
int yyvstop[] ={ |
0, |
|
4, |
0, |
|
3, |
4, |
0, |
|
2, |
4, |
0, |
|
1, |
4, |
0, |
|
2, |
0, |
|
1, |
0, |
0}; |
# define YYTYPE char |
struct yywork { YYTYPE verify, advance; } yycrank[] ={ |
0,0, 0,0, 1,3, 0,0, |
0,0, 0,0, 0,0, 0,0, |
0,0, 0,0, 1,4, 1,3, |
0,0, 0,0, 0,0, 0,0, |
0,0, 0,0, 0,0, 0,0, |
0,0, 0,0, 0,0, 0,0, |
0,0, 0,0, 0,0, 0,0, |
0,0, 0,0, 0,0, 0,0, |
0,0, 0,0, 0,0, 0,0, |
0,0, 0,0, 0,0, 0,0, |
0,0, 0,0, 0,0, 0,0, |
0,0, 0,0, 0,0, 0,0, |
0,0, 1,5, 5,7, 5,7, |
5,7, 5,7, 5,7, 5,7, |
5,7, 5,7, 5,7, 5,7, |
0,0, 0,0, 0,0, 0,0, |
0,0, 0,0, 1,6, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 0,0, 0,0, 0,0, |
0,0, 0,0, 0,0, 0,0, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 0,0, 0,0, |
0,0, 0,0, 6,8, 0,0, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 6,8, 6,8, |
6,8, 6,8, 0,0, 0,0, |
0,0}; |
struct yysvf yysvec[] ={ |
0, 0, 0, |
yycrank+-1, 0, 0, |
yycrank+0, yysvec+1, 0, |
yycrank+0, 0, yyvstop+1, |
yycrank+0, 0, yyvstop+3, |
yycrank+2, 0, yyvstop+6, |
yycrank+19, 0, yyvstop+9, |
yycrank+0, yysvec+5, yyvstop+12, |
yycrank+0, yysvec+6, yyvstop+14, |
0, 0, 0}; |
struct yywork *yytop = yycrank+141; |
struct yysvf *yybgin = yysvec+1; |
char yymatch[] ={ |
00 ,01 ,01 ,01 ,01 ,01 ,01 ,01 , |
01 ,011 ,012 ,01 ,01 ,01 ,01 ,01 , |
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 , |
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 , |
011 ,01 ,01 ,01 ,01 ,01 ,01 ,01 , |
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 , |
'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' , |
'0' ,'0' ,01 ,01 ,01 ,01 ,01 ,01 , |
01 ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
'A' ,'A' ,'A' ,01 ,01 ,01 ,01 ,'A' , |
01 ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
'A' ,'A' ,'A' ,01 ,01 ,01 ,01 ,01 , |
0}; |
char yyextra[] ={ |
0,0,0,0,0,0,0,0, |
0}; |
/* ncform 4.1 83/08/11 */ |
|
int yylineno =1; |
# define YYU(x) x |
# define NLSTATE yyprevious=YYNEWLINE |
char yytext[YYLMAX]; |
struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp; |
char yysbuf[YYLMAX]; |
char *yysptr = yysbuf; |
int *yyfnd; |
extern struct yysvf *yyestate; |
int yyprevious = YYNEWLINE; |
yylook(){ |
register struct yysvf *yystate, **lsp; |
register struct yywork *yyt; |
struct yysvf *yyz; |
int yych; |
struct yywork *yyr; |
# ifdef LEXDEBUG |
int debug; |
# endif |
char *yylastch; |
/* start off machines */ |
# ifdef LEXDEBUG |
debug = 0; |
# endif |
if (!yymorfg) |
yylastch = yytext; |
else { |
yymorfg=0; |
yylastch = yytext+yyleng; |
} |
for(;;){ |
lsp = yylstate; |
yyestate = yystate = yybgin; |
if (yyprevious==YYNEWLINE) yystate++; |
for (;;){ |
# ifdef LEXDEBUG |
if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1); |
# endif |
yyt = yystate->yystoff; |
if(yyt == yycrank){ /* may not be any transitions */ |
yyz = yystate->yyother; |
if(yyz == 0)break; |
if(yyz->yystoff == yycrank)break; |
} |
*yylastch++ = yych = input(); |
tryagain: |
# ifdef LEXDEBUG |
if(debug){ |
fprintf(yyout,"char "); |
allprint(yych); |
putchar('\n'); |
} |
# endif |
yyr = yyt; |
if ( yyt > yycrank){ |
yyt = yyr + yych; |
if (yyt <= yytop && yyt->verify+yysvec == yystate){ |
if(yyt->advance+yysvec == YYLERR) /* error transitions */ |
{unput(*--yylastch);break;} |
*lsp++ = yystate = yyt->advance+yysvec; |
goto contin; |
} |
} |
# ifdef YYOPTIM |
else if(yyt < yycrank) { /* r < yycrank */ |
yyt = yyr = yycrank+(yycrank-yyt); |
# ifdef LEXDEBUG |
if(debug)fprintf(yyout,"compressed state\n"); |
# endif |
yyt = yyt + yych; |
if(yyt <= yytop && yyt->verify+yysvec == yystate){ |
if(yyt->advance+yysvec == YYLERR) /* error transitions */ |
{unput(*--yylastch);break;} |
*lsp++ = yystate = yyt->advance+yysvec; |
goto contin; |
} |
yyt = yyr + YYU(yymatch[yych]); |
# ifdef LEXDEBUG |
if(debug){ |
fprintf(yyout,"try fall back character "); |
allprint(YYU(yymatch[yych])); |
putchar('\n'); |
} |
# endif |
if(yyt <= yytop && yyt->verify+yysvec == yystate){ |
if(yyt->advance+yysvec == YYLERR) /* error transition */ |
{unput(*--yylastch);break;} |
*lsp++ = yystate = yyt->advance+yysvec; |
goto contin; |
} |
} |
if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){ |
# ifdef LEXDEBUG |
if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1); |
# endif |
goto tryagain; |
} |
# endif |
else |
{unput(*--yylastch);break;} |
contin: |
# ifdef LEXDEBUG |
if(debug){ |
fprintf(yyout,"state %d char ",yystate-yysvec-1); |
allprint(yych); |
putchar('\n'); |
} |
# endif |
; |
} |
# ifdef LEXDEBUG |
if(debug){ |
fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1); |
allprint(yych); |
putchar('\n'); |
} |
# endif |
while (lsp-- > yylstate){ |
*yylastch-- = 0; |
if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){ |
yyolsp = lsp; |
if(yyextra[*yyfnd]){ /* must backup */ |
while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){ |
lsp--; |
unput(*yylastch--); |
} |
} |
yyprevious = YYU(*yylastch); |
yylsp = lsp; |
yyleng = yylastch-yytext+1; |
yytext[yyleng] = 0; |
# ifdef LEXDEBUG |
if(debug){ |
fprintf(yyout,"\nmatch "); |
sprint(yytext); |
fprintf(yyout," action %d\n",*yyfnd); |
} |
# endif |
return(*yyfnd++); |
} |
unput(*yylastch); |
} |
if (yytext[0] == 0 /* && feof(yyin) */) |
{ |
yysptr=yysbuf; |
return(0); |
} |
yyprevious = yytext[0] = input(); |
if (yyprevious>0) |
output(yyprevious); |
yylastch=yytext; |
# ifdef LEXDEBUG |
if(debug)putchar('\n'); |
# endif |
} |
} |
yyback(p, m) |
int *p; |
{ |
if (p==0) return(0); |
while (*p) |
{ |
if (*p++ == m) |
return(1); |
} |
return(0); |
} |
/* the following are only used in the lex library */ |
yyinput(){ |
return(input()); |
} |
yyoutput(c) |
int c; { |
output(c); |
} |
yyunput(c) |
int c; { |
unput(c); |
} |
|
main() { |
yyin = stdin; yyout = stdout; |
yyparse(); |
return 0; |
} |
|
/* yyerror - issue error message */ |
yyerror(s) char *s; { |
printf("%s\n", s); |
} |
short yyexca[] ={ |
-1, 1, |
0, -1, |
-2, 0, |
}; |
# define YYNPROD 15 |
# define YYLAST 249 |
short yyact[]={ |
|
12, 2, 9, 8, 17, 11, 25, 17, 15, 18, |
16, 10, 18, 17, 15, 7, 16, 13, 18, 5, |
3, 1, 0, 19, 20, 0, 0, 21, 22, 23, |
24, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 6, 14, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 4, 6 }; |
short yypact[]={ |
|
-1000, -9,-1000, 5, -7, -59,-1000,-1000,-1000, -40, |
-29, -40, -40,-1000,-1000, -40, -40, -40, -40, -38, |
-35, -38, -38,-1000,-1000,-1000 }; |
short yypgo[]={ |
|
0, 21, 20, 17, 11 }; |
short yyr1[]={ |
|
0, 1, 1, 1, 1, 2, 4, 4, 4, 4, |
4, 4, 4, 4, 3 }; |
short yyr2[]={ |
|
0, 0, 2, 3, 3, 3, 3, 3, 3, 3, |
2, 3, 1, 1, 1 }; |
short yychk[]={ |
|
-1000, -1, 10, -2, 256, -3, 257, 10, 10, 61, |
-4, 45, 40, -3, 258, 43, 45, 42, 47, -4, |
-4, -4, -4, -4, -4, 41 }; |
short yydef[]={ |
|
1, -2, 2, 0, 0, 0, 14, 3, 4, 0, |
5, 0, 0, 12, 13, 0, 0, 0, 0, 10, |
0, 6, 7, 8, 9, 11 }; |
#ifndef lint |
#endif |
|
# define YYFLAG -1000 |
# define YYERROR goto yyerrlab |
# define YYACCEPT return(0) |
# define YYABORT return(1) |
|
/* parser for yacc output */ |
|
#ifdef YYDEBUG |
int yydebug = 0; /* 1 for debugging */ |
#endif |
YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */ |
int yychar = -1; /* current input token number */ |
int yynerrs = 0; /* number of errors */ |
short yyerrflag = 0; /* error recovery flag */ |
|
yyparse() { |
|
short yys[YYMAXDEPTH]; |
short yyj, yym; |
register YYSTYPE *yypvt; |
register short yystate, *yyps, yyn; |
register YYSTYPE *yypv; |
register short *yyxi; |
|
yystate = 0; |
yychar = -1; |
yynerrs = 0; |
yyerrflag = 0; |
yyps= &yys[-1]; |
yypv= &yyv[-1]; |
|
yystack: /* put a state and value onto the stack */ |
|
#ifdef YYDEBUG |
if( yydebug ) printf( "state %d, char 0%o\n", yystate, yychar ); |
#endif |
if( ++yyps> &yys[YYMAXDEPTH-1] ) { yyerror( "yacc stack overflow" ); return(1); } |
*yyps = yystate; |
++yypv; |
*yypv = yyval; |
|
yynewstate: |
|
yyn = yypact[yystate]; |
|
if( yyn<= YYFLAG ) goto yydefault; /* simple state */ |
|
if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0; |
if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault; |
|
if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */ |
yychar = -1; |
yyval = yylval; |
yystate = yyn; |
if( yyerrflag > 0 ) --yyerrflag; |
goto yystack; |
} |
|
yydefault: |
/* default state action */ |
|
if( (yyn=yydef[yystate]) == -2 ) { |
if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0; |
/* look through exception table */ |
|
for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */ |
|
while( *(yyxi+=2) >= 0 ){ |
if( *yyxi == yychar ) break; |
} |
if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */ |
} |
|
if( yyn == 0 ){ /* error */ |
/* error ... attempt to resume parsing */ |
|
switch( yyerrflag ){ |
|
case 0: /* brand new error */ |
|
yyerror( "syntax error" ); |
yyerrlab: |
++yynerrs; |
|
case 1: |
case 2: /* incompletely recovered error ... try again */ |
|
yyerrflag = 3; |
|
/* find a state where "error" is a legal shift action */ |
|
while ( yyps >= yys ) { |
yyn = yypact[*yyps] + YYERRCODE; |
if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){ |
yystate = yyact[yyn]; /* simulate a shift of "error" */ |
goto yystack; |
} |
yyn = yypact[*yyps]; |
|
/* the current yyps has no shift onn "error", pop stack */ |
|
#ifdef YYDEBUG |
if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] ); |
#endif |
--yyps; |
--yypv; |
} |
|
/* there is no state on the stack with an error shift ... abort */ |
|
yyabort: |
return(1); |
|
|
case 3: /* no shift yet; clobber input char */ |
|
#ifdef YYDEBUG |
if( yydebug ) printf( "error recovery discards char %d\n", yychar ); |
#endif |
|
if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */ |
yychar = -1; |
goto yynewstate; /* try again in the same state */ |
|
} |
|
} |
|
/* reduction by production yyn */ |
|
#ifdef YYDEBUG |
if( yydebug ) printf("reduce %d\n",yyn); |
#endif |
yyps -= yyr2[yyn]; |
yypvt = yypv; |
yypv -= yyr2[yyn]; |
yyval = yypv[1]; |
yym=yyn; |
/* consult goto table to find next state */ |
yyn = yyr1[yyn]; |
yyj = yypgo[yyn] + *yyps + 1; |
if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]]; |
switch(yym){ |
|
case 4: |
{ yyerrok; } break; |
case 5: |
{ printf("store\n"); } break; |
case 6: |
{ printf("add\n"); } break; |
case 7: |
{ printf("negate\nadd\n"); } break; |
case 8: |
{ printf("multiply\n"); } break; |
case 9: |
{ printf("divide\n"); } break; |
case 10: |
{ printf("negate\n"); } break; |
case 12: |
{ printf("load\n"); } break; |
case 13: |
{ printf("push %s\n", yytext); } break; |
case 14: |
{ printf("%s\n", yytext); } break; |
} |
goto yystack; /* stack new state and value */ |
|
} |
int yywrap() { return 1; } |
/fields.0
--- spill.c (nonexistent)
+++ spill.c (revision 248)
@@ -0,0 +1,17 @@
+main(){}
+
+f(i){i=f()+f();}
+
+f2(i){i=f()+(i?f():1);}
+
+f3(int i,int *p){register r1=0,r2=0,r3=0,r4=0,r5=0,r6=0,r7=0,r8=0,r9=0,r10=0;*p++=i?f():0;}
+
+double a[10],b[10];int i;f4(){register r6=0,r7=0,r8=0,r9=0,r10=0,r11=0;i=a[i]+b[i] && i && a[i]-b[i];}
+/* f4 causes parent to spill child on vax when odd double regs are enabled */
+
+int j, k, m, n;
+double *A, *B, x;
+f5(){
+ x=A[k*m]*A[j*m]+B[k*n]*B[j*n];
+ x=A[k*m]*B[j*n]-B[k*n]*A[j*m];
+}
/stdarg.c
0,0 → 1,51
#include <stdarg.h> |
|
struct node { int a[4]; } x = {1,2,3,4}; |
|
print(char *fmt, ...); |
|
main() { |
print("test 1\n"); |
print("test %s\n", "2"); |
print("test %d%c", 3, '\n'); |
print("%s%s %w%c", "te", "st", 4, '\n'); |
print("%s%s %f%c", "te", "st", 5.0, '\n'); |
print("%b %b %b %b %b %b\n", x, x, x, x, x, x); |
return 0; |
} |
|
print(char *fmt, ...) { |
va_list ap; |
|
va_start(ap, fmt); |
for (; *fmt; fmt++) |
if (*fmt == '%') |
switch (*++fmt) { |
case 'b': { |
struct node x = va_arg(ap, struct node); |
printf("{%d %d %d %d}", x.a[0], x.a[1], x.a[2], x.a[3]); |
break; |
} |
case 'c': |
printf("%c", va_arg(ap, char)); |
break; |
case 'd': |
printf("%d", va_arg(ap, int)); |
break; |
case 'w': |
printf("%x", va_arg(ap, short)); |
break; |
case 's': |
printf("%s", va_arg(ap, char *)); |
break; |
case 'f': |
printf("%f", va_arg(ap, double)); |
break; |
default: |
printf("%c", *fmt); |
break; |
} |
else |
printf("%c", *fmt); |
va_end(ap); |
} |
/struct.c
0,0 → 1,69
typedef struct point { int x,y; } point; |
typedef struct rect { point pt1, pt2; } rect; |
|
point addpoint(point p1, point p2) { /* add two points */ |
p1.x += p2.x; |
p1.y += p2.y; |
return p1; |
} |
|
#define min(a, b) ((a) < (b) ? (a) : (b)) |
#define max(a, b) ((a) > (b) ? (a) : (b)) |
|
rect canonrect(rect r) { /* canonicalize rectangle coordinates */ |
rect temp; |
|
temp.pt1.x = min(r.pt1.x, r.pt2.x); |
temp.pt1.y = min(r.pt1.y, r.pt2.y); |
temp.pt2.x = max(r.pt1.x, r.pt2.x); |
temp.pt2.y = max(r.pt1.y, r.pt2.y); |
return temp; |
} |
|
point makepoint(int x, int y) { /* make a point from x and y components */ |
point p; |
|
p.x = x; |
p.y = y; |
return p; |
} |
|
rect makerect(point p1, point p2) { /* make a rectangle from two points */ |
rect r; |
|
r.pt1 = p1; |
r.pt2 = p2; |
return canonrect(r); |
} |
|
int ptinrect(point p, rect r) { /* is p in r? */ |
return p.x >= r.pt1.x && p.x < r.pt2.x |
&& p.y >= r.pt1.y && p.y < r.pt2.y; |
} |
|
struct odd {char a[3]; } y = {'a', 'b', 0}; |
|
odd(struct odd y) { |
struct odd x = y; |
printf("%s\n", x.a); |
} |
|
main() { |
int i; |
point x, origin = { 0, 0 }, maxpt = { 320, 320 }; |
point pts[] = { -1, -1, 1, 1, 20, 300, 500, 400 }; |
rect screen = makerect(addpoint(maxpt, makepoint(-10, -10)), |
addpoint(origin, makepoint(10, 10))); |
|
for (i = 0; i < sizeof pts/sizeof pts[0]; i++) { |
printf("(%d,%d) is ", pts[i].x, |
(x = makepoint(pts[i].x, pts[i].y)).y); |
if (ptinrect(x, screen) == 0) |
printf("not "); |
printf("within [%d,%d; %d,%d]\n", screen.pt1.x, screen.pt1.y, |
screen.pt2.x, screen.pt2.y); |
} |
odd(y); |
exit(0); |
} |
|
/sort.c
0,0 → 1,65
int in[] = {10, 32, -1, 567, 3, 18, 1, -51, 789, 0}; |
|
main() { |
int i; |
|
sort(in, (sizeof in)/(sizeof in[0])); |
for (i = 0; i < (sizeof in)/(sizeof in[0]); i++) { |
putd(in[i]); |
putchar('\n'); |
} |
return 0; |
} |
|
/* putd - output decimal number */ |
putd(n) { |
if (n < 0) { |
putchar('-'); |
n = -n; |
} |
if (n/10) |
putd(n/10); |
putchar(n%10 + '0'); |
} |
|
int *xx; |
|
/* sort - sort a[0..n-1] into increasing order */ |
sort(a, n) int a[]; { |
quick(xx = a, 0, --n); |
} |
|
/* quick - quicksort a[lb..ub] */ |
quick(a, lb, ub) int a[]; { |
int k, partition(); |
|
if (lb >= ub) |
return; |
k = partition(a, lb, ub); |
quick(a, lb, k - 1); |
quick(a, k + 1, ub); |
} |
|
/* partition - partition a[i..j] */ |
int partition(a, i, j) int a[]; { |
int v, k; |
|
j++; |
k = i; |
v = a[k]; |
while (i < j) { |
i++; while (a[i] < v) i++; |
j--; while (a[j] > v) j--; |
if (i < j) exchange(&a[i], &a[j]); |
} |
exchange(&a[k], &a[j]); |
return j; |
} |
|
/* exchange - exchange *x and *y */ |
exchange(x, y) int *x, *y; { |
int t; |
|
printf("exchange(%d,%d)\n", x - xx, y - xx); |
t = *x; *x = *y; *y = t; |
} |
/front.c
0,0 → 1,120
main() { |
exit(0); |
} |
|
nested(a,b) { |
if ((a<4 && b == 'r') |
|| (a == 1 && (b == 'h' || b == 'i')) |
|| (a == 2 && (b == 'o' || b == 'y')) |
) a=b; |
} |
|
/* type name scope */ |
|
void s(struct D *d) {} /* this struct D differs from the one below */ |
typedef struct D D; |
struct D {int x, y;} Dy={0}; |
D Dz={1}; |
Dfunc(){ |
D a; a.y=1; |
s(&Dy); /* error */ |
} |
|
/* qualifiers */ |
|
const a; int b; |
const int a, *x; int b, *y; |
volatile unsigned z; |
|
f() { |
x = y; |
z = z + z; /* should be 2 references to z's r-value */ |
} |
f1() { |
x = &a; |
x = &b; |
y = &a; /* error */ |
y = &b; |
} |
f2(int **a, int **b) { |
f(&x, &y); |
**a = 0; |
return **b; |
} |
g(const int *p) { |
g(&a); |
g(&b); |
return *p; |
} |
h(int *p) { |
f(&a); |
f(&b); |
return *p; |
} |
h1(const int x, int y) { |
h1(a,b); |
h1(b,a); |
return x + y; |
} |
h2() { |
char *b; const void *p; |
p = b; |
b = p; /* error */ |
} |
|
|
/* static naming */ |
|
extern int yy; set1() { { static yy=1; yy=2;} yy=4;} |
static int yy; set2() { yy=5; {static yy=2; yy=3; }} |
static void goo() {} |
sss() { int goo; { static int goo();} goo=1;} |
rrr(p) float *p; { extern int xr; |
{ static float xr; |
{ extern int *xr; } p=&xr; }} |
|
/* local extern */ |
|
static int ss1; |
int ss3; |
extern int ss5; |
setstatic() { extern int ss1,ss2,ss3,ss4; ss1 = ss2; ss3 = ss4; ss5 = 0;} |
static int ss2; |
int ss4; |
static int ss5; |
|
/* function prototypes */ |
|
int fx1(void); |
int fx1(); |
|
int gx1(double x); |
int gx1(x) double x; { gx1(&x); } /* error */ |
|
int hx1(); |
int hx1(double x,...); /* error */ |
|
int ff1(double x, int *y); |
int ff1(x,y) float x; int y[]; {x=y[0];} |
|
int gg1(int a); |
int gg1(a,b){a=b;} |
|
int hh1(const int x); |
hh1(a) {return a;} |
|
extern int strcmp(const char*, const char*); |
extern void qsort(void*, int, int, int (*)(const void*, const void*)); |
extern int cmp(char**a, char**b) { return strcmp(*a,*b); } |
sort() { |
int n; char *a[100]; |
qsort(a, n, sizeof(char*), (int (*)(const void*, const void*))cmp); |
qsort(a, n, sizeof(char*), cmp); /* error */ |
} |
|
/* nasty calls */ |
|
onearg(){ |
int a,b,c,d; |
f( ( (a? (b = 1): (c = 2)), (d ? 3 : 4) ) ); /* 1 argument */ |
} |
/8q.c
0,0 → 1,39
int up[15], down[15], rows[8], x[8]; |
int queens(), print(); |
|
main() |
{ |
int i; |
|
for (i = 0; i < 15; i++) |
up[i] = down[i] = 1; |
for (i = 0; i < 8; i++) |
rows[i] = 1; |
queens(0); |
return 0; |
} |
|
queens(c) |
{ |
int r; |
|
for (r = 0; r < 8; r++) |
if (rows[r] && up[r-c+7] && down[r+c]) { |
rows[r] = up[r-c+7] = down[r+c] = 0; |
x[c] = r; |
if (c == 7) |
print(); |
else |
queens(c + 1); |
rows[r] = up[r-c+7] = down[r+c] = 1; |
} |
} |
|
print() |
{ |
int k; |
|
for (k = 0; k < 8; k++) |
printf("%c ", x[k]+'1'); |
printf("\n"); |
} |
/cf.c
0,0 → 1,32
/* cf - print character frequencies */ |
float f[128]; |
|
main(argc, argv) |
int argc; |
char *argv[]; |
{ |
int i, c, nc; |
float cutoff, atof(); |
|
if (argc <= 1) |
cutoff = 0.0; |
else |
cutoff = atof(argv[1])/100; |
for (i = 0; i <= 127; ) |
f[i++] = 0.0; |
nc = 0; |
while ((c = getchar()) != -1) { |
f[c] += 1; |
nc++; |
} |
printf("char\tfreq\n"); |
for (i = 0; i <= 127; ++i) |
if (f[i] && f[i]/nc >= cutoff) { |
if (i <= ' ') |
printf("%03o", i); |
else |
printf("%c", i); |
printf("\t%.1f\n", 100*f[i]/nc); |
} |
return 0; |
} |
/paranoia.c
0,0 → 1,2203
#undef V9 |
#define NOPAUSE |
/* A C version of Kahan's Floating Point Test "Paranoia" |
|
Thos Sumner, UCSF, Feb. 1985 |
David Gay, BTL, Jan. 1986 |
|
This is a rewrite from the Pascal version by |
|
B. A. Wichmann, 18 Jan. 1985 |
|
(and does NOT exhibit good C programming style). |
|
(C) Apr 19 1983 in BASIC version by: |
Professor W. M. Kahan, |
567 Evans Hall |
Electrical Engineering & Computer Science Dept. |
University of California |
Berkeley, California 94720 |
USA |
|
converted to Pascal by: |
B. A. Wichmann |
National Physical Laboratory |
Teddington Middx |
TW11 OLW |
UK |
|
converted to C by: |
|
David M. Gay and Thos Sumner |
AT&T Bell Labs Computer Center, Rm. U-76 |
600 Mountain Avenue University of California |
Murray Hill, NJ 07974 San Francisco, CA 94143 |
USA USA |
|
with simultaneous corrections to the Pascal source (reflected |
in the Pascal source available over netlib). |
[A couple of bug fixes from dgh = sun!dhough incorporated 31 July 1986.] |
|
Reports of results on various systems from all the versions |
of Paranoia are being collected by Richard Karpinski at the |
same address as Thos Sumner. This includes sample outputs, |
bug reports, and criticisms. |
|
You may copy this program freely if you acknowledge its source. |
Comments on the Pascal version to NPL, please. |
|
|
The C version catches signals from floating-point exceptions. |
If signal(SIGFPE,...) is unavailable in your environment, you may |
#define NOSIGNAL to comment out the invocations of signal. |
|
This source file is too big for some C compilers, but may be split |
into pieces. Comments containing "SPLIT" suggest convenient places |
for this splitting. At the end of these comments is an "ed script" |
(for the UNIX(tm) editor ed) that will do this splitting. |
|
By #defining Single when you compile this source, you may obtain |
a single-precision C version of Paranoia. |
|
|
The following is from the introductory commentary from Wichmann's work: |
|
The BASIC program of Kahan is written in Microsoft BASIC using many |
facilities which have no exact analogy in Pascal. The Pascal |
version below cannot therefore be exactly the same. Rather than be |
a minimal transcription of the BASIC program, the Pascal coding |
follows the conventional style of block-structured languages. Hence |
the Pascal version could be useful in producing versions in other |
structured languages. |
|
Rather than use identifiers of minimal length (which therefore have |
little mnemonic significance), the Pascal version uses meaningful |
identifiers as follows [Note: A few changes have been made for C]: |
|
|
BASIC C BASIC C BASIC C |
|
A J S StickyBit |
A1 AInverse J0 NoErrors T |
B Radix [Failure] T0 Underflow |
B1 BInverse J1 NoErrors T2 ThirtyTwo |
B2 RadixD2 [SeriousDefect] T5 OneAndHalf |
B9 BMinusU2 J2 NoErrors T7 TwentySeven |
C [Defect] T8 TwoForty |
C1 CInverse J3 NoErrors U OneUlp |
D [Flaw] U0 UnderflowThreshold |
D4 FourD K PageNo U1 |
E0 L Milestone U2 |
E1 M V |
E2 Exp2 N V0 |
E3 N1 V8 |
E5 MinSqEr O Zero V9 |
E6 SqEr O1 One W |
E7 MaxSqEr O2 Two X |
E8 O3 Three X1 |
E9 O4 Four X8 |
F1 MinusOne O5 Five X9 Random1 |
F2 Half O8 Eight Y |
F3 Third O9 Nine Y1 |
F6 P Precision Y2 |
F9 Q Y9 Random2 |
G1 GMult Q8 Z |
G2 GDiv Q9 Z0 PseudoZero |
G3 GAddSub R Z1 |
H R1 RMult Z2 |
H1 HInverse R2 RDiv Z9 |
I R3 RAddSub |
IO NoTrials R4 RSqrt |
I3 IEEE R9 Random9 |
|
SqRWrng |
|
All the variables in BASIC are true variables and in consequence, |
the program is more difficult to follow since the "constants" must |
be determined (the glossary is very helpful). The Pascal version |
uses Real constants, but checks are added to ensure that the values |
are correctly converted by the compiler. |
|
The major textual change to the Pascal version apart from the |
identifiersis that named procedures are used, inserting parameters |
wherehelpful. New procedures are also introduced. The |
correspondence is as follows: |
|
|
BASIC Pascal |
lines |
|
90- 140 Pause |
170- 250 Instructions |
380- 460 Heading |
480- 670 Characteristics |
690- 870 History |
2940-2950 Random |
3710-3740 NewD |
4040-4080 DoesYequalX |
4090-4110 PrintIfNPositive |
4640-4850 TestPartialUnderflow |
|
=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*= |
|
Below is an "ed script" that splits para.c into 10 files |
of the form part[1-8].c, subs.c, and msgs.c, plus a header |
file, paranoia.h, that these files require. |
|
r paranoia.c |
$ |
?SPLIT |
+,$w msgs.c |
.,$d |
?SPLIT |
.d |
+d |
-,$w subs.c |
-,$d |
?part8 |
+d |
?include |
.,$w part8.c |
.,$d |
-d |
?part7 |
+d |
?include |
.,$w part7.c |
.,$d |
-d |
?part6 |
+d |
?include |
.,$w part6.c |
.,$d |
-d |
?part5 |
+d |
?include |
.,$w part5.c |
.,$d |
-d |
?part4 |
+d |
?include |
.,$w part4.c |
.,$d |
-d |
?part3 |
+d |
?include |
.,$w part3.c |
.,$d |
-d |
?part2 |
+d |
?include |
.,$w part2.c |
.,$d |
?SPLIT |
.d |
1,/^#include/-1d |
1,$w part1.c |
/Computed constants/,$d |
1,$s/^int/extern &/ |
1,$s/^FLOAT/extern &/ |
1,$s/^char/extern &/ |
1,$s! = .*!;! |
/^Guard/,/^Round/s/^/extern / |
/^jmp_buf/s/^/extern / |
/^Sig_type/s/^/extern / |
s/$/\ |
extern void sigfpe();/ |
w paranoia.h |
q |
|
*/ |
|
#include <stdio.h> |
#ifndef NOSIGNAL |
#include <signal.h> |
#endif |
#include <setjmp.h> |
|
extern double fabs(), floor(), log(), pow(), sqrt(); |
|
#ifdef Single |
#define FLOAT float |
#define FABS(x) (float)fabs((double)(x)) |
#define FLOOR(x) (float)floor((double)(x)) |
#define LOG(x) (float)log((double)(x)) |
#define POW(x,y) (float)pow((double)(x),(double)(y)) |
#define SQRT(x) (float)sqrt((double)(x)) |
#else |
#define FLOAT double |
#define FABS(x) fabs(x) |
#define FLOOR(x) floor(x) |
#define LOG(x) log(x) |
#define POW(x,y) pow(x,y) |
#define SQRT(x) sqrt(x) |
#endif |
|
jmp_buf ovfl_buf; |
typedef void (*Sig_type)(); |
Sig_type sigsave; |
|
#define KEYBOARD 0 |
|
FLOAT Radix, BInvrse, RadixD2, BMinusU2; |
FLOAT Sign(), Random(); |
|
/*Small floating point constants.*/ |
FLOAT Zero = 0.0; |
FLOAT Half = 0.5; |
FLOAT One = 1.0; |
FLOAT Two = 2.0; |
FLOAT Three = 3.0; |
FLOAT Four = 4.0; |
FLOAT Five = 5.0; |
FLOAT Eight = 8.0; |
FLOAT Nine = 9.0; |
FLOAT TwentySeven = 27.0; |
FLOAT ThirtyTwo = 32.0; |
FLOAT TwoForty = 240.0; |
FLOAT MinusOne = -1.0; |
FLOAT OneAndHalf = 1.5; |
/*Integer constants*/ |
int NoTrials = 20; /*Number of tests for commutativity. */ |
#define False 0 |
#define True 1 |
|
/* Definitions for declared types |
Guard == (Yes, No); |
Rounding == (Chopped, Rounded, Other); |
Message == packed array [1..40] of char; |
Class == (Flaw, Defect, Serious, Failure); |
*/ |
#define Yes 1 |
#define No 0 |
#define Chopped 2 |
#define Rounded 1 |
#define Other 0 |
#define Flaw 3 |
#define Defect 2 |
#define Serious 1 |
#define Failure 0 |
typedef int Guard, Rounding, Class; |
typedef char Message; |
|
/* Declarations of Variables */ |
int Indx; |
char ch[8]; |
FLOAT AInvrse, A1; |
FLOAT C, CInvrse; |
FLOAT D, FourD; |
FLOAT E0, E1, Exp2, E3, MinSqEr; |
FLOAT SqEr, MaxSqEr, E9; |
FLOAT Third; |
FLOAT F6, F9; |
FLOAT H, HInvrse; |
int I; |
FLOAT StickyBit, J; |
FLOAT MyZero; |
FLOAT Precision; |
FLOAT Q, Q9; |
FLOAT R, Random9; |
FLOAT T, Underflow, S; |
FLOAT OneUlp, UfThold, U1, U2; |
FLOAT V, V0, V9; |
FLOAT W; |
FLOAT X, X1, X2, X8, Random1; |
FLOAT Y, Y1, Y2, Random2; |
FLOAT Z, PseudoZero, Z1, Z2, Z9; |
int ErrCnt[4]; |
int fpecount; |
int Milestone; |
int PageNo; |
int M, N, N1; |
Guard GMult, GDiv, GAddSub; |
Rounding RMult, RDiv, RAddSub, RSqrt; |
int Break, Done, NotMonot, Monot, Anomaly, IEEE, |
SqRWrng, UfNGrad; |
/* Computed constants. */ |
/*U1 gap below 1.0, i.e, 1.0-U1 is next number below 1.0 */ |
/*U2 gap above 1.0, i.e, 1.0+U2 is next number above 1.0 */ |
|
/* floating point exception receiver */ |
void |
sigfpe(i) |
{ |
fpecount++; |
printf("\n* * * FLOATING-POINT ERROR * * *\n"); |
fflush(stdout); |
if (sigsave) { |
#ifndef NOSIGNAL |
signal(SIGFPE, sigsave); |
#endif |
sigsave = 0; |
longjmp(ovfl_buf, 1); |
} |
abort(); |
} |
|
main() |
{ |
#ifdef mc |
char *out; |
ieee_flags("set", "precision", "double", &out); |
#endif |
/* First two assignments use integer right-hand sides. */ |
Zero = 0; |
One = 1; |
Two = One + One; |
Three = Two + One; |
Four = Three + One; |
Five = Four + One; |
Eight = Four + Four; |
Nine = Three * Three; |
TwentySeven = Nine * Three; |
ThirtyTwo = Four * Eight; |
TwoForty = Four * Five * Three * Four; |
MinusOne = -One; |
Half = One / Two; |
OneAndHalf = One + Half; |
ErrCnt[Failure] = 0; |
ErrCnt[Serious] = 0; |
ErrCnt[Defect] = 0; |
ErrCnt[Flaw] = 0; |
PageNo = 1; |
/*=============================================*/ |
Milestone = 0; |
/*=============================================*/ |
#ifndef NOSIGNAL |
signal(SIGFPE, sigfpe); |
#endif |
Instructions(); |
Pause(); |
Heading(); |
Pause(); |
Characteristics(); |
Pause(); |
History(); |
Pause(); |
/*=============================================*/ |
Milestone = 7; |
/*=============================================*/ |
printf("Program is now RUNNING tests on small integers:\n"); |
|
TstCond (Failure, (Zero + Zero == Zero) && (One - One == Zero) |
&& (One > Zero) && (One + One == Two), |
"0+0 != 0, 1-1 != 0, 1 <= 0, or 1+1 != 2"); |
Z = - Zero; |
if (Z != 0.0) { |
ErrCnt[Failure] = ErrCnt[Failure] + 1; |
printf("Comparison alleges that -0.0 is Non-zero!\n"); |
U1 = 0.001; |
Radix = 1; |
TstPtUf(); |
} |
TstCond (Failure, (Three == Two + One) && (Four == Three + One) |
&& (Four + Two * (- Two) == Zero) |
&& (Four - Three - One == Zero), |
"3 != 2+1, 4 != 3+1, 4+2*(-2) != 0, or 4-3-1 != 0"); |
TstCond (Failure, (MinusOne == (0 - One)) |
&& (MinusOne + One == Zero ) && (One + MinusOne == Zero) |
&& (MinusOne + FABS(One) == Zero) |
&& (MinusOne + MinusOne * MinusOne == Zero), |
"-1+1 != 0, (-1)+abs(1) != 0, or -1+(-1)*(-1) != 0"); |
TstCond (Failure, Half + MinusOne + Half == Zero, |
"1/2 + (-1) + 1/2 != 0"); |
/*=============================================*/ |
/*SPLIT |
part2(); |
part3(); |
part4(); |
part5(); |
part6(); |
part7(); |
part8(); |
} |
#include "paranoia.h" |
part2(){ |
*/ |
Milestone = 10; |
/*=============================================*/ |
TstCond (Failure, (Nine == Three * Three) |
&& (TwentySeven == Nine * Three) && (Eight == Four + Four) |
&& (ThirtyTwo == Eight * Four) |
&& (ThirtyTwo - TwentySeven - Four - One == Zero), |
"9 != 3*3, 27 != 9*3, 32 != 8*4, or 32-27-4-1 != 0"); |
TstCond (Failure, (Five == Four + One) && |
(TwoForty == Four * Five * Three * Four) |
&& (TwoForty / Three - Four * Four * Five == Zero) |
&& ( TwoForty / Four - Five * Three * Four == Zero) |
&& ( TwoForty / Five - Four * Three * Four == Zero), |
"5 != 4+1, 240/3 != 80, 240/4 != 60, or 240/5 != 48"); |
if (ErrCnt[Failure] == 0) { |
printf("-1, 0, 1/2, 1, 2, 3, 4, 5, 9, 27, 32 & 240 are O.K.\n"); |
printf("\n"); |
} |
printf("Searching for Radix and Precision.\n"); |
W = One; |
do { |
W = W + W; |
Y = W + One; |
Z = Y - W; |
Y = Z - One; |
} while (MinusOne + FABS(Y) < Zero); |
/*.. now W is just big enough that |((W+1)-W)-1| >= 1 ...*/ |
Precision = Zero; |
Y = One; |
do { |
Radix = W + Y; |
Y = Y + Y; |
Radix = Radix - W; |
} while ( Radix == Zero); |
if (Radix < Two) Radix = One; |
printf("Radix = %f .\n", Radix); |
if (Radix != 1) { |
W = One; |
do { |
Precision = Precision + One; |
W = W * Radix; |
Y = W + One; |
} while ((Y - W) == One); |
} |
/*... now W == Radix^Precision is barely too big to satisfy (W+1)-W == 1 |
...*/ |
U1 = One / W; |
U2 = Radix * U1; |
printf("Closest relative separation found is U1 = %.7e .\n\n", U1); |
printf("Recalculating radix and precision\n "); |
|
/*save old values*/ |
E0 = Radix; |
E1 = U1; |
E9 = U2; |
E3 = Precision; |
|
X = Four / Three; |
Third = X - One; |
F6 = Half - Third; |
X = F6 + F6; |
X = FABS(X - Third); |
if (X < U2) X = U2; |
|
/*... now X = (unknown no.) ulps of 1+...*/ |
do { |
U2 = X; |
Y = Half * U2 + ThirtyTwo * U2 * U2; |
Y = One + Y; |
X = Y - One; |
} while ( ! ((U2 <= X) || (X <= Zero))); |
|
/*... now U2 == 1 ulp of 1 + ... */ |
X = Two / Three; |
F6 = X - Half; |
Third = F6 + F6; |
X = Third - Half; |
X = FABS(X + F6); |
if (X < U1) X = U1; |
|
/*... now X == (unknown no.) ulps of 1 -... */ |
do { |
U1 = X; |
Y = Half * U1 + ThirtyTwo * U1 * U1; |
Y = Half - Y; |
X = Half + Y; |
Y = Half - X; |
X = Half + Y; |
} while ( ! ((U1 <= X) || (X <= Zero))); |
/*... now U1 == 1 ulp of 1 - ... */ |
if (U1 == E1) printf("confirms closest relative separation U1 .\n"); |
else printf("gets better closest relative separation U1 = %.7e .\n", U1); |
W = One / U1; |
F9 = (Half - U1) + Half; |
Radix = FLOOR(0.01 + U2 / U1); |
if (Radix == E0) printf("Radix confirmed.\n"); |
else printf("MYSTERY: recalculated Radix = %.7e .\n", Radix); |
TstCond (Defect, Radix <= Eight + Eight, |
"Radix is too big: roundoff problems"); |
TstCond (Flaw, (Radix == Two) || (Radix == 10) |
|| (Radix == One), "Radix is not as good as 2 or 10"); |
/*=============================================*/ |
Milestone = 20; |
/*=============================================*/ |
TstCond (Failure, F9 - Half < Half, |
"(1-U1)-1/2 < 1/2 is FALSE, prog. fails?"); |
X = F9; |
I = 1; |
Y = X - Half; |
Z = Y - Half; |
TstCond (Failure, (X != One) |
|| (Z == Zero), "Comparison is fuzzy,X=1 but X-1/2-1/2 != 0"); |
X = One + U2; |
I = 0; |
/*=============================================*/ |
Milestone = 25; |
/*=============================================*/ |
/*... BMinusU2 = nextafter(Radix, 0) */ |
BMinusU2 = Radix - One; |
BMinusU2 = (BMinusU2 - U2) + One; |
/* Purify Integers */ |
if (Radix != One) { |
X = - TwoForty * LOG(U1) / LOG(Radix); |
Y = FLOOR(Half + X); |
if (FABS(X - Y) * Four < One) X = Y; |
Precision = X / TwoForty; |
Y = FLOOR(Half + Precision); |
if (FABS(Precision - Y) * TwoForty < Half) Precision = Y; |
} |
if ((Precision != FLOOR(Precision)) || (Radix == One)) { |
printf("Precision cannot be characterized by an Integer number\n"); |
printf("of significant digits but, by itself, this is a minor flaw.\n"); |
} |
if (Radix == One) |
printf("logarithmic encoding has precision characterized solely by U1.\n"); |
else printf("The number of significant digits of the Radix is %f .\n", |
Precision); |
TstCond (Serious, U2 * Nine * Nine * TwoForty < One, |
"Precision worse than 5 decimal figures "); |
/*=============================================*/ |
Milestone = 30; |
/*=============================================*/ |
/* Test for extra-precise subepressions */ |
X = FABS(((Four / Three - One) - One / Four) * Three - One / Four); |
do { |
Z2 = X; |
X = (One + (Half * Z2 + ThirtyTwo * Z2 * Z2)) - One; |
} while ( ! ((Z2 <= X) || (X <= Zero))); |
X = Y = Z = FABS((Three / Four - Two / Three) * Three - One / Four); |
do { |
Z1 = Z; |
Z = (One / Two - ((One / Two - (Half * Z1 + ThirtyTwo * Z1 * Z1)) |
+ One / Two)) + One / Two; |
} while ( ! ((Z1 <= Z) || (Z <= Zero))); |
do { |
do { |
Y1 = Y; |
Y = (Half - ((Half - (Half * Y1 + ThirtyTwo * Y1 * Y1)) + Half |
)) + Half; |
} while ( ! ((Y1 <= Y) || (Y <= Zero))); |
X1 = X; |
X = ((Half * X1 + ThirtyTwo * X1 * X1) - F9) + F9; |
} while ( ! ((X1 <= X) || (X <= Zero))); |
if ((X1 != Y1) || (X1 != Z1)) { |
BadCond(Serious, "Disagreements among the values X1, Y1, Z1,\n"); |
printf("respectively %.7e, %.7e, %.7e,\n", X1, Y1, Z1); |
printf("are symptoms of inconsistencies introduced\n"); |
printf("by extra-precise evaluation of arithmetic subexpressions.\n"); |
notify("Possibly some part of this"); |
if ((X1 == U1) || (Y1 == U1) || (Z1 == U1)) printf( |
"That feature is not tested further by this program.\n") ; |
} |
else { |
if ((Z1 != U1) || (Z2 != U2)) { |
if ((Z1 >= U1) || (Z2 >= U2)) { |
BadCond(Failure, ""); |
notify("Precision"); |
printf("\tU1 = %.7e, Z1 - U1 = %.7e\n",U1,Z1-U1); |
printf("\tU2 = %.7e, Z2 - U2 = %.7e\n",U2,Z2-U2); |
} |
else { |
if ((Z1 <= Zero) || (Z2 <= Zero)) { |
printf("Because of unusual Radix = %f", Radix); |
printf(", or exact rational arithmetic a result\n"); |
printf("Z1 = %.7e, or Z2 = %.7e ", Z1, Z2); |
notify("of an\nextra-precision"); |
} |
if (Z1 != Z2 || Z1 > Zero) { |
X = Z1 / U1; |
Y = Z2 / U2; |
if (Y > X) X = Y; |
Q = - LOG(X); |
printf("Some subexpressions appear to be calculated extra\n"); |
printf("precisely with about %g extra B-digits, i.e.\n", |
(Q / LOG(Radix))); |
printf("roughly %g extra significant decimals.\n", |
Q / LOG(10.)); |
} |
printf("That feature is not tested further by this program.\n"); |
} |
} |
} |
Pause(); |
/*=============================================*/ |
/*SPLIT |
} |
#include "paranoia.h" |
part3(){ |
*/ |
Milestone = 35; |
/*=============================================*/ |
if (Radix >= Two) { |
X = W / (Radix * Radix); |
Y = X + One; |
Z = Y - X; |
T = Z + U2; |
X = T - Z; |
TstCond (Failure, X == U2, |
"Subtraction is not normalized X=Y,X+Z != Y+Z!"); |
if (X == U2) printf( |
"Subtraction appears to be normalized, as it should be."); |
} |
printf("\nChecking for guard digit in *, /, and -.\n"); |
Y = F9 * One; |
Z = One * F9; |
X = F9 - Half; |
Y = (Y - Half) - X; |
Z = (Z - Half) - X; |
X = One + U2; |
T = X * Radix; |
R = Radix * X; |
X = T - Radix; |
X = X - Radix * U2; |
T = R - Radix; |
T = T - Radix * U2; |
X = X * (Radix - One); |
T = T * (Radix - One); |
if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)) GMult = Yes; |
else { |
GMult = No; |
TstCond (Serious, False, |
"* lacks a Guard Digit, so 1*X != X"); |
} |
Z = Radix * U2; |
X = One + Z; |
Y = FABS((X + Z) - X * X) - U2; |
X = One - U2; |
Z = FABS((X - U2) - X * X) - U1; |
TstCond (Failure, (Y <= Zero) |
&& (Z <= Zero), "* gets too many final digits wrong.\n"); |
Y = One - U2; |
X = One + U2; |
Z = One / Y; |
Y = Z - X; |
X = One / Three; |
Z = Three / Nine; |
X = X - Z; |
T = Nine / TwentySeven; |
Z = Z - T; |
TstCond(Defect, X == Zero && Y == Zero && Z == Zero, |
"Division lacks a Guard Digit, so error can exceed 1 ulp\nor 1/3 and 3/9 and 9/27 may disagree"); |
Y = F9 / One; |
X = F9 - Half; |
Y = (Y - Half) - X; |
X = One + U2; |
T = X / One; |
X = T - X; |
if ((X == Zero) && (Y == Zero) && (Z == Zero)) GDiv = Yes; |
else { |
GDiv = No; |
TstCond (Serious, False, |
"Division lacks a Guard Digit, so X/1 != X"); |
} |
X = One / (One + U2); |
Y = X - Half - Half; |
TstCond (Serious, Y < Zero, |
"Computed value of 1/1.000..1 >= 1"); |
X = One - U2; |
Y = One + Radix * U2; |
Z = X * Radix; |
T = Y * Radix; |
R = Z / Radix; |
StickyBit = T / Radix; |
X = R - X; |
Y = StickyBit - Y; |
TstCond (Failure, X == Zero && Y == Zero, |
"* and/or / gets too many last digits wrong"); |
Y = One - U1; |
X = One - F9; |
Y = One - Y; |
T = Radix - U2; |
Z = Radix - BMinusU2; |
T = Radix - T; |
if ((X == U1) && (Y == U1) && (Z == U2) && (T == U2)) GAddSub = Yes; |
else { |
GAddSub = No; |
TstCond (Serious, False, |
"- lacks Guard Digit, so cancellation is obscured"); |
} |
if (F9 != One && F9 - One >= Zero) { |
BadCond(Serious, "comparison alleges (1-U1) < 1 although\n"); |
printf(" subtraction yields (1-U1) - 1 = 0 , thereby vitiating\n"); |
printf(" such precautions against division by zero as\n"); |
printf(" ... if (X == 1.0) {.....} else {.../(X-1.0)...}\n"); |
} |
if (GMult == Yes && GDiv == Yes && GAddSub == Yes) printf( |
" *, /, and - appear to have guard digits, as they should.\n"); |
/*=============================================*/ |
Milestone = 40; |
/*=============================================*/ |
Pause(); |
printf("Checking rounding on multiply, divide and add/subtract.\n"); |
RMult = Other; |
RDiv = Other; |
RAddSub = Other; |
RadixD2 = Radix / Two; |
A1 = Two; |
Done = False; |
do { |
AInvrse = Radix; |
do { |
X = AInvrse; |
AInvrse = AInvrse / A1; |
} while ( ! (FLOOR(AInvrse) != AInvrse)); |
Done = (X == One) || (A1 > Three); |
if (! Done) A1 = Nine + One; |
} while ( ! (Done)); |
if (X == One) A1 = Radix; |
AInvrse = One / A1; |
X = A1; |
Y = AInvrse; |
Done = False; |
do { |
Z = X * Y - Half; |
TstCond (Failure, Z == Half, |
"X * (1/X) differs from 1"); |
Done = X == Radix; |
X = Radix; |
Y = One / X; |
} while ( ! (Done)); |
Y2 = One + U2; |
Y1 = One - U2; |
X = OneAndHalf - U2; |
Y = OneAndHalf + U2; |
Z = (X - U2) * Y2; |
T = Y * Y1; |
Z = Z - X; |
T = T - X; |
X = X * Y2; |
Y = (Y + U2) * Y1; |
X = X - OneAndHalf; |
Y = Y - OneAndHalf; |
if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T <= Zero)) { |
X = (OneAndHalf + U2) * Y2; |
Y = OneAndHalf - U2 - U2; |
Z = OneAndHalf + U2 + U2; |
T = (OneAndHalf - U2) * Y1; |
X = X - (Z + U2); |
StickyBit = Y * Y1; |
S = Z * Y2; |
T = T - Y; |
Y = (U2 - Y) + StickyBit; |
Z = S - (Z + U2 + U2); |
StickyBit = (Y2 + U2) * Y1; |
Y1 = Y2 * Y1; |
StickyBit = StickyBit - Y2; |
Y1 = Y1 - Half; |
if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero) |
&& ( StickyBit == Zero) && (Y1 == Half)) { |
RMult = Rounded; |
printf("Multiplication appears to round correctly.\n"); |
} |
else if ((X + U2 == Zero) && (Y < Zero) && (Z + U2 == Zero) |
&& (T < Zero) && (StickyBit + U2 == Zero) |
&& (Y1 < Half)) { |
RMult = Chopped; |
printf("Multiplication appears to chop.\n"); |
} |
else printf("* is neither chopped nor correctly rounded.\n"); |
if ((RMult == Rounded) && (GMult == No)) notify("Multiplication"); |
} |
else printf("* is neither chopped nor correctly rounded.\n"); |
/*=============================================*/ |
Milestone = 45; |
/*=============================================*/ |
Y2 = One + U2; |
Y1 = One - U2; |
Z = OneAndHalf + U2 + U2; |
X = Z / Y2; |
T = OneAndHalf - U2 - U2; |
Y = (T - U2) / Y1; |
Z = (Z + U2) / Y2; |
X = X - OneAndHalf; |
Y = Y - T; |
T = T / Y1; |
Z = Z - (OneAndHalf + U2); |
T = (U2 - OneAndHalf) + T; |
if (! ((X > Zero) || (Y > Zero) || (Z > Zero) || (T > Zero))) { |
X = OneAndHalf / Y2; |
Y = OneAndHalf - U2; |
Z = OneAndHalf + U2; |
X = X - Y; |
T = OneAndHalf / Y1; |
Y = Y / Y1; |
T = T - (Z + U2); |
Y = Y - Z; |
Z = Z / Y2; |
Y1 = (Y2 + U2) / Y2; |
Z = Z - OneAndHalf; |
Y2 = Y1 - Y2; |
Y1 = (F9 - U1) / F9; |
if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero) |
&& (Y2 == Zero) && (Y2 == Zero) |
&& (Y1 - Half == F9 - Half )) { |
RDiv = Rounded; |
printf("Division appears to round correctly.\n"); |
if (GDiv == No) notify("Division"); |
} |
else if ((X < Zero) && (Y < Zero) && (Z < Zero) && (T < Zero) |
&& (Y2 < Zero) && (Y1 - Half < F9 - Half)) { |
RDiv = Chopped; |
printf("Division appears to chop.\n"); |
} |
} |
if (RDiv == Other) printf("/ is neither chopped nor correctly rounded.\n"); |
BInvrse = One / Radix; |
TstCond (Failure, (BInvrse * Radix - Half == Half), |
"Radix * ( 1 / Radix ) differs from 1"); |
/*=============================================*/ |
/*SPLIT |
} |
#include "paranoia.h" |
part4(){ |
*/ |
Milestone = 50; |
/*=============================================*/ |
TstCond (Failure, ((F9 + U1) - Half == Half) |
&& ((BMinusU2 + U2 ) - One == Radix - One), |
"Incomplete carry-propagation in Addition"); |
X = One - U1 * U1; |
Y = One + U2 * (One - U2); |
Z = F9 - Half; |
X = (X - Half) - Z; |
Y = Y - One; |
if ((X == Zero) && (Y == Zero)) { |
RAddSub = Chopped; |
printf("Add/Subtract appears to be chopped.\n"); |
} |
if (GAddSub == Yes) { |
X = (Half + U2) * U2; |
Y = (Half - U2) * U2; |
X = One + X; |
Y = One + Y; |
X = (One + U2) - X; |
Y = One - Y; |
if ((X == Zero) && (Y == Zero)) { |
X = (Half + U2) * U1; |
Y = (Half - U2) * U1; |
X = One - X; |
Y = One - Y; |
X = F9 - X; |
Y = One - Y; |
if ((X == Zero) && (Y == Zero)) { |
RAddSub = Rounded; |
printf("Addition/Subtraction appears to round correctly.\n"); |
if (GAddSub == No) notify("Add/Subtract"); |
} |
else printf("Addition/Subtraction neither rounds nor chops.\n"); |
} |
else printf("Addition/Subtraction neither rounds nor chops.\n"); |
} |
else printf("Addition/Subtraction neither rounds nor chops.\n"); |
S = One; |
X = One + Half * (One + Half); |
Y = (One + U2) * Half; |
Z = X - Y; |
T = Y - X; |
StickyBit = Z + T; |
if (StickyBit != Zero) { |
S = Zero; |
BadCond(Flaw, "(X - Y) + (Y - X) is non zero!\n"); |
} |
StickyBit = Zero; |
if ((GMult == Yes) && (GDiv == Yes) && (GAddSub == Yes) |
&& (RMult == Rounded) && (RDiv == Rounded) |
&& (RAddSub == Rounded) && (FLOOR(RadixD2) == RadixD2)) { |
printf("Checking for sticky bit.\n"); |
X = (Half + U1) * U2; |
Y = Half * U2; |
Z = One + Y; |
T = One + X; |
if ((Z - One <= Zero) && (T - One >= U2)) { |
Z = T + Y; |
Y = Z - X; |
if ((Z - T >= U2) && (Y - T == Zero)) { |
X = (Half + U1) * U1; |
Y = Half * U1; |
Z = One - Y; |
T = One - X; |
if ((Z - One == Zero) && (T - F9 == Zero)) { |
Z = (Half - U1) * U1; |
T = F9 - Z; |
Q = F9 - Y; |
if ((T - F9 == Zero) && (F9 - U1 - Q == Zero)) { |
Z = (One + U2) * OneAndHalf; |
T = (OneAndHalf + U2) - Z + U2; |
X = One + Half / Radix; |
Y = One + Radix * U2; |
Z = X * Y; |
if (T == Zero && X + Radix * U2 - Z == Zero) { |
if (Radix != Two) { |
X = Two + U2; |
Y = X / Two; |
if ((Y - One == Zero)) StickyBit = S; |
} |
else StickyBit = S; |
} |
} |
} |
} |
} |
} |
if (StickyBit == One) printf("Sticky bit apparently used correctly.\n"); |
else printf("Sticky bit used incorrectly or not at all.\n"); |
TstCond (Flaw, !(GMult == No || GDiv == No || GAddSub == No || |
RMult == Other || RDiv == Other || RAddSub == Other), |
"lack(s) of guard digits or failure(s) to correctly round or chop\n(noted above) count as one flaw in the final tally below"); |
/*=============================================*/ |
Milestone = 60; |
/*=============================================*/ |
printf("\n"); |
printf("Does Multiplication commute? "); |
printf("Testing on %d random pairs.\n", NoTrials); |
Random9 = SQRT(3.0); |
Random1 = Third; |
I = 1; |
do { |
X = Random(); |
Y = Random(); |
Z9 = Y * X; |
Z = X * Y; |
Z9 = Z - Z9; |
I = I + 1; |
} while ( ! ((I > NoTrials) || (Z9 != Zero))); |
if (I == NoTrials) { |
Random1 = One + Half / Three; |
Random2 = (U2 + U1) + One; |
Z = Random1 * Random2; |
Y = Random2 * Random1; |
Z9 = (One + Half / Three) * ((U2 + U1) + One) - (One + Half / |
Three) * ((U2 + U1) + One); |
} |
if (! ((I == NoTrials) || (Z9 == Zero))) |
BadCond(Defect, "X * Y == Y * X trial fails.\n"); |
else printf(" No failures found in %d integer pairs.\n", NoTrials); |
/*=============================================*/ |
Milestone = 70; |
/*=============================================*/ |
printf("\nRunning test of square root(x).\n"); |
TstCond (Failure, (Zero == SQRT(Zero)) |
&& (- Zero == SQRT(- Zero)) |
&& (One == SQRT(One)), "Square root of 0.0, -0.0 or 1.0 wrong"); |
MinSqEr = Zero; |
MaxSqEr = Zero; |
J = Zero; |
X = Radix; |
OneUlp = U2; |
SqXMinX (Serious); |
X = BInvrse; |
OneUlp = BInvrse * U1; |
SqXMinX (Serious); |
X = U1; |
OneUlp = U1 * U1; |
SqXMinX (Serious); |
if (J != Zero) Pause(); |
printf("Testing if sqrt(X * X) == X for %d Integers X.\n", NoTrials); |
J = Zero; |
X = Two; |
Y = Radix; |
if ((Radix != One)) do { |
X = Y; |
Y = Radix * Y; |
} while ( ! ((Y - X >= NoTrials))); |
OneUlp = X * U2; |
I = 1; |
while (I <= NoTrials) { |
X = X + One; |
SqXMinX (Defect); |
if (J > Zero) break; |
I = I + 1; |
} |
printf("Test for sqrt monotonicity.\n"); |
I = - 1; |
X = BMinusU2; |
Y = Radix; |
Z = Radix + Radix * U2; |
NotMonot = False; |
Monot = False; |
while ( ! (NotMonot || Monot)) { |
I = I + 1; |
X = SQRT(X); |
Q = SQRT(Y); |
Z = SQRT(Z); |
if ((X > Q) || (Q > Z)) NotMonot = True; |
else { |
Q = FLOOR(Q + Half); |
if ((I > 0) || (Radix == Q * Q)) Monot = True; |
else if (I > 0) { |
if (I > 1) Monot = True; |
else { |
Y = Y * BInvrse; |
X = Y - U1; |
Z = Y + U1; |
} |
} |
else { |
Y = Q; |
X = Y - U2; |
Z = Y + U2; |
} |
} |
} |
if (Monot) printf("sqrt has passed a test for Monotonicity.\n"); |
else { |
BadCond(Defect, ""); |
printf("sqrt(X) is non-monotonic for X near %.7e .\n", Y); |
} |
/*=============================================*/ |
/*SPLIT |
} |
#include "paranoia.h" |
part5(){ |
*/ |
Milestone = 80; |
/*=============================================*/ |
MinSqEr = MinSqEr + Half; |
MaxSqEr = MaxSqEr - Half; |
Y = (SQRT(One + U2) - One) / U2; |
SqEr = (Y - One) + U2 / Eight; |
if (SqEr > MaxSqEr) MaxSqEr = SqEr; |
SqEr = Y + U2 / Eight; |
if (SqEr < MinSqEr) MinSqEr = SqEr; |
Y = ((SQRT(F9) - U2) - (One - U2)) / U1; |
SqEr = Y + U1 / Eight; |
if (SqEr > MaxSqEr) MaxSqEr = SqEr; |
SqEr = (Y + One) + U1 / Eight; |
if (SqEr < MinSqEr) MinSqEr = SqEr; |
OneUlp = U2; |
X = OneUlp; |
for( Indx = 1; Indx <= 3; ++Indx) { |
Y = SQRT((X + U1 + X) + F9); |
Y = ((Y - U2) - ((One - U2) + X)) / OneUlp; |
Z = ((U1 - X) + F9) * Half * X * X / OneUlp; |
SqEr = (Y + Half) + Z; |
if (SqEr < MinSqEr) MinSqEr = SqEr; |
SqEr = (Y - Half) + Z; |
if (SqEr > MaxSqEr) MaxSqEr = SqEr; |
if (((Indx == 1) || (Indx == 3))) |
X = OneUlp * Sign (X) * FLOOR(Eight / (Nine * SQRT(OneUlp))); |
else { |
OneUlp = U1; |
X = - OneUlp; |
} |
} |
/*=============================================*/ |
Milestone = 85; |
/*=============================================*/ |
SqRWrng = False; |
Anomaly = False; |
RSqrt = Other; /* ~dgh */ |
if (Radix != One) { |
printf("Testing whether sqrt is rounded or chopped.\n"); |
D = FLOOR(Half + POW(Radix, One + Precision - FLOOR(Precision))); |
/* ... == Radix^(1 + fract) if (Precision == Integer + fract. */ |
X = D / Radix; |
Y = D / A1; |
if ((X != FLOOR(X)) || (Y != FLOOR(Y))) { |
Anomaly = True; |
} |
else { |
X = Zero; |
Z2 = X; |
Y = One; |
Y2 = Y; |
Z1 = Radix - One; |
FourD = Four * D; |
do { |
if (Y2 > Z2) { |
Q = Radix; |
Y1 = Y; |
do { |
X1 = FABS(Q + FLOOR(Half - Q / Y1) * Y1); |
Q = Y1; |
Y1 = X1; |
} while ( ! (X1 <= Zero)); |
if (Q <= One) { |
Z2 = Y2; |
Z = Y; |
} |
} |
Y = Y + Two; |
X = X + Eight; |
Y2 = Y2 + X; |
if (Y2 >= FourD) Y2 = Y2 - FourD; |
} while ( ! (Y >= D)); |
X8 = FourD - Z2; |
Q = (X8 + Z * Z) / FourD; |
X8 = X8 / Eight; |
if (Q != FLOOR(Q)) Anomaly = True; |
else { |
Break = False; |
do { |
X = Z1 * Z; |
X = X - FLOOR(X / Radix) * Radix; |
if (X == One) |
Break = True; |
else |
Z1 = Z1 - One; |
} while ( ! (Break || (Z1 <= Zero))); |
if ((Z1 <= Zero) && (! Break)) Anomaly = True; |
else { |
if (Z1 > RadixD2) Z1 = Z1 - Radix; |
do { |
NewD(); |
} while ( ! (U2 * D >= F9)); |
if (D * Radix - D != W - D) Anomaly = True; |
else { |
Z2 = D; |
I = 0; |
Y = D + (One + Z) * Half; |
X = D + Z + Q; |
SR3750(); |
Y = D + (One - Z) * Half + D; |
X = D - Z + D; |
X = X + Q + X; |
SR3750(); |
NewD(); |
if (D - Z2 != W - Z2) Anomaly = True; |
else { |
Y = (D - Z2) + (Z2 + (One - Z) * Half); |
X = (D - Z2) + (Z2 - Z + Q); |
SR3750(); |
Y = (One + Z) * Half; |
X = Q; |
SR3750(); |
if (I == 0) Anomaly = True; |
} |
} |
} |
} |
} |
if ((I == 0) || Anomaly) { |
BadCond(Failure, "Anomalous arithmetic with Integer < "); |
printf("Radix^Precision = %.7e\n", W); |
printf(" fails test whether sqrt rounds or chops.\n"); |
SqRWrng = True; |
} |
} |
if (! Anomaly) { |
if (! ((MinSqEr < Zero) || (MaxSqEr > Zero))) { |
RSqrt = Rounded; |
printf("Square root appears to be correctly rounded.\n"); |
} |
else { |
if ((MaxSqEr + U2 > U2 - Half) || (MinSqEr > Half) |
|| (MinSqEr + Radix < Half)) SqRWrng = True; |
else { |
RSqrt = Chopped; |
printf("Square root appears to be chopped.\n"); |
} |
} |
} |
if (SqRWrng) { |
printf("Square root is neither chopped nor correctly rounded.\n"); |
printf("Observed errors run from %.7e ", MinSqEr - Half); |
printf("to %.7e ulps.\n", Half + MaxSqEr); |
TstCond (Serious, MaxSqEr - MinSqEr < Radix * Radix, |
"sqrt gets too many last digits wrong"); |
} |
/*=============================================*/ |
Milestone = 90; |
/*=============================================*/ |
Pause(); |
printf("Testing powers Z^i for small Integers Z and i.\n"); |
N = 0; |
/* ... test powers of zero. */ |
I = 0; |
Z = -Zero; |
M = 3.0; |
Break = False; |
do { |
X = One; |
SR3980(); |
if (I <= 10) { |
I = 1023; |
SR3980(); |
} |
if (Z == MinusOne) Break = True; |
else { |
Z = MinusOne; |
PrintIfNPositive(); |
N = 0; |
/* .. if(-1)^N is invalid, replace MinusOne by One. */ |
I = - 4; |
} |
} while ( ! Break); |
PrintIfNPositive(); |
N1 = N; |
N = 0; |
Z = A1; |
M = FLOOR(Two * LOG(W) / LOG(A1)); |
Break = False; |
do { |
X = Z; |
I = 1; |
SR3980(); |
if (Z == AInvrse) Break = True; |
else Z = AInvrse; |
} while ( ! (Break)); |
/*=============================================*/ |
Milestone = 100; |
/*=============================================*/ |
/* Powers of Radix have been tested, */ |
/* next try a few primes */ |
M = NoTrials; |
Z = Three; |
do { |
X = Z; |
I = 1; |
SR3980(); |
do { |
Z = Z + Two; |
} while ( Three * FLOOR(Z / Three) == Z ); |
} while ( Z < Eight * Three ); |
if (N > 0) { |
printf("Errors like this may invalidate financial calculations\n"); |
printf("\tinvolving interest rates.\n"); |
} |
PrintIfNPositive(); |
N += N1; |
if (N == 0) printf("... no discrepancis found.\n"); |
if (N > 0) Pause(); |
else printf("\n"); |
/*=============================================*/ |
/*SPLIT |
} |
#include "paranoia.h" |
part6(){ |
*/ |
Milestone = 110; |
/*=============================================*/ |
printf("Seeking Underflow thresholds UfThold and E0.\n"); |
D = U1; |
if (Precision != FLOOR(Precision)) { |
D = BInvrse; |
X = Precision; |
do { |
D = D * BInvrse; |
X = X - One; |
} while ( X > Zero); |
} |
Y = One; |
Z = D; |
/* ... D is power of 1/Radix < 1. */ |
do { |
C = Y; |
Y = Z; |
Z = Y * Y; |
} while ((Y > Z) && (Z + Z > Z)); |
Y = C; |
Z = Y * D; |
do { |
C = Y; |
Y = Z; |
Z = Y * D; |
} while ((Y > Z) && (Z + Z > Z)); |
if (Radix < Two) HInvrse = Two; |
else HInvrse = Radix; |
H = One / HInvrse; |
/* ... 1/HInvrse == H == Min(1/Radix, 1/2) */ |
CInvrse = One / C; |
E0 = C; |
Z = E0 * H; |
/* ...1/Radix^(BIG Integer) << 1 << CInvrse == 1/C */ |
do { |
Y = E0; |
E0 = Z; |
Z = E0 * H; |
} while ((E0 > Z) && (Z + Z > Z)); |
UfThold = E0; |
E1 = Zero; |
Q = Zero; |
E9 = U2; |
S = One + E9; |
D = C * S; |
if (D <= C) { |
E9 = Radix * U2; |
S = One + E9; |
D = C * S; |
if (D <= C) { |
BadCond(Failure, "multiplication gets too many last digits wrong.\n"); |
Underflow = E0; |
Y1 = Zero; |
PseudoZero = Z; |
Pause(); |
} |
} |
else { |
Underflow = D; |
PseudoZero = Underflow * H; |
UfThold = Zero; |
do { |
Y1 = Underflow; |
Underflow = PseudoZero; |
if (E1 + E1 <= E1) { |
Y2 = Underflow * HInvrse; |
E1 = FABS(Y1 - Y2); |
Q = Y1; |
if ((UfThold == Zero) && (Y1 != Y2)) UfThold = Y1; |
} |
PseudoZero = PseudoZero * H; |
} while ((Underflow > PseudoZero) |
&& (PseudoZero + PseudoZero > PseudoZero)); |
} |
/* Comment line 4530 .. 4560 */ |
if (PseudoZero != Zero) { |
printf("\n"); |
Z = PseudoZero; |
/* ... Test PseudoZero for "phoney- zero" violates */ |
/* ... PseudoZero < Underflow or PseudoZero < PseudoZero + PseudoZero |
... */ |
if (PseudoZero <= Zero) { |
BadCond(Failure, "Positive expressions can underflow to an\n"); |
printf("allegedly negative value\n"); |
printf("PseudoZero that prints out as: %g .\n", PseudoZero); |
X = - PseudoZero; |
if (X <= Zero) { |
printf("But -PseudoZero, which should be\n"); |
printf("positive, isn't; it prints out as %g .\n", X); |
} |
} |
else { |
BadCond(Flaw, "Underflow can stick at an allegedly positive\n"); |
printf("value PseudoZero that prints out as %g .\n", PseudoZero); |
} |
TstPtUf(); |
} |
/*=============================================*/ |
Milestone = 120; |
/*=============================================*/ |
if (CInvrse * Y > CInvrse * Y1) { |
S = H * S; |
E0 = Underflow; |
} |
if (! ((E1 == Zero) || (E1 == E0))) { |
BadCond(Defect, ""); |
if (E1 < E0) { |
printf("Products underflow at a higher"); |
printf(" threshold than differences.\n"); |
if (PseudoZero == Zero) |
E0 = E1; |
} |
else { |
printf("Difference underflows at a higher"); |
printf(" threshold than products.\n"); |
} |
} |
printf("Smallest strictly positive number found is E0 = %g .\n", E0); |
Z = E0; |
TstPtUf(); |
Underflow = E0; |
if (N == 1) Underflow = Y; |
I = 4; |
if (E1 == Zero) I = 3; |
if (UfThold == Zero) I = I - 2; |
UfNGrad = True; |
switch (I) { |
case 1: |
UfThold = Underflow; |
if ((CInvrse * Q) != ((CInvrse * Y) * S)) { |
UfThold = Y; |
BadCond(Failure, "Either accuracy deteriorates as numbers\n"); |
printf("approach a threshold = %.17e\n", UfThold);; |
printf(" coming down from %.17e\n", C); |
printf(" or else multiplication gets too many last digits wrong.\n"); |
} |
Pause(); |
break; |
|
case 2: |
BadCond(Failure, "Underflow confuses Comparison, which alleges that\n"); |
printf("Q == Y while denying that |Q - Y| == 0; these values\n"); |
printf("print out as Q = %.17e, Y = %.17e .\n", Q, Y2); |
printf ("|Q - Y| = %.17e .\n" , FABS(Q - Y2)); |
UfThold = Q; |
break; |
|
case 3: |
X = X; |
break; |
|
case 4: |
if ((Q == UfThold) && (E1 == E0) |
&& (FABS( UfThold - E1 / E9) <= E1)) { |
UfNGrad = False; |
printf("Underflow is gradual; it incurs Absolute Error =\n"); |
printf("(roundoff in UfThold) < E0.\n"); |
Y = E0 * CInvrse; |
Y = Y * (OneAndHalf + U2); |
X = CInvrse * (One + U2); |
Y = Y / X; |
IEEE = (Y == E0); |
} |
} |
if (UfNGrad) { |
printf("\n"); |
sigsave = sigfpe; |
if (setjmp(ovfl_buf)) { |
printf("Underflow / UfThold failed!\n"); |
R = H + H; |
} |
else R = SQRT(Underflow / UfThold); |
sigsave = 0; |
if (R <= H) { |
Z = R * UfThold; |
X = Z * (One + R * H * (One + H)); |
} |
else { |
Z = UfThold; |
X = Z * (One + H * H * (One + H)); |
} |
if (! ((X == Z) || (X - Z != Zero))) { |
BadCond(Flaw, ""); |
printf("X = %.17e\n\tis not equal to Z = %.17e .\n", X, Z); |
Z9 = X - Z; |
printf("yet X - Z yields %.17e .\n", Z9); |
printf(" Should this NOT signal Underflow, "); |
printf("this is a SERIOUS DEFECT\nthat causes "); |
printf("confusion when innocent statements like\n");; |
printf(" if (X == Z) ... else"); |
printf(" ... (f(X) - f(Z)) / (X - Z) ...\n"); |
printf("encounter Division by Zero although actually\n"); |
sigsave = sigfpe; |
if (setjmp(ovfl_buf)) printf("X / Z fails!\n"); |
else printf("X / Z = 1 + %g .\n", (X / Z - Half) - Half); |
sigsave = 0; |
} |
} |
printf("The Underflow threshold is %.17e, %s\n", UfThold, |
" below which"); |
printf("calculation may suffer larger Relative error than "); |
printf("merely roundoff.\n"); |
Y2 = U1 * U1; |
Y = Y2 * Y2; |
Y2 = Y * U1; |
if (Y2 <= UfThold) { |
if (Y > E0) { |
BadCond(Defect, ""); |
I = 5; |
} |
else { |
BadCond(Serious, ""); |
I = 4; |
} |
printf("Range is too narrow; U1^%d Underflows.\n", I); |
} |
/*=============================================*/ |
/*SPLIT |
} |
#include "paranoia.h" |
part7(){ |
*/ |
Milestone = 130; |
/*=============================================*/ |
Y = - FLOOR(Half - TwoForty * LOG(UfThold) / LOG(HInvrse)) / TwoForty; |
Y2 = Y + Y; |
printf("Since underflow occurs below the threshold\n"); |
printf("UfThold = (%.17e) ^ (%.17e)\nonly underflow ", HInvrse, Y); |
printf("should afflict the expression\n\t(%.17e) ^ (%.17e);\n", HInvrse, Y); |
V9 = POW(HInvrse, Y2); |
printf("actually calculating yields: %.17e .\n", V9); |
if (! ((V9 >= Zero) && (V9 <= (Radix + Radix + E9) * UfThold))) { |
BadCond(Serious, "this is not between 0 and underflow\n"); |
printf(" threshold = %.17e .\n", UfThold); |
} |
else if (! (V9 > UfThold * (One + E9))) |
printf("This computed value is O.K.\n"); |
else { |
BadCond(Defect, "this is not between 0 and underflow\n"); |
printf(" threshold = %.17e .\n", UfThold); |
} |
/*=============================================*/ |
Milestone = 140; |
/*=============================================*/ |
printf("\n"); |
/* ...calculate Exp2 == exp(2) == 7.389056099... */ |
X = Zero; |
I = 2; |
Y = Two * Three; |
Q = Zero; |
N = 0; |
do { |
Z = X; |
I = I + 1; |
Y = Y / (I + I); |
R = Y + Q; |
X = Z + R; |
Q = (Z - X) + R; |
} while(X > Z); |
Z = (OneAndHalf + One / Eight) + X / (OneAndHalf * ThirtyTwo); |
X = Z * Z; |
Exp2 = X * X; |
X = F9; |
Y = X - U1; |
printf("Testing X^((X + 1) / (X - 1)) vs. exp(2) = %.17e as X -> 1.\n", |
Exp2); |
for(I = 1;;) { |
Z = X - BInvrse; |
Z = (X + One) / (Z - (One - BInvrse)); |
Q = POW(X, Z) - Exp2; |
if (FABS(Q) > TwoForty * U2) { |
N = 1; |
V9 = (X - BInvrse) - (One - BInvrse); |
BadCond(Defect, "Calculated"); |
printf(" %.17e for\n", POW(X,Z)); |
printf("\t(1 + (%.17e) ^ (%.17e);\n", V9, Z); |
printf("\tdiffers from correct value by %.17e .\n", Q); |
printf("\tThis much error may spoil financial\n"); |
printf("\tcalculations involving tiny interest rates.\n"); |
break; |
} |
else { |
Z = (Y - X) * Two + Y; |
X = Y; |
Y = Z; |
Z = One + (X - F9)*(X - F9); |
if (Z > One && I < NoTrials) I++; |
else { |
if (X > One) { |
if (N == 0) |
printf("Accuracy seems adequate.\n"); |
break; |
} |
else { |
X = One + U2; |
Y = U2 + U2; |
Y += X; |
I = 1; |
} |
} |
} |
} |
/*=============================================*/ |
Milestone = 150; |
/*=============================================*/ |
printf("Testing powers Z^Q at four nearly extreme values.\n"); |
N = 0; |
Z = A1; |
Q = FLOOR(Half - LOG(C) / LOG(A1)); |
Break = False; |
do { |
X = CInvrse; |
Y = POW(Z, Q); |
IsYeqX(); |
Q = - Q; |
X = C; |
Y = POW(Z, Q); |
IsYeqX(); |
if (Z < One) Break = True; |
else Z = AInvrse; |
} while ( ! (Break)); |
PrintIfNPositive(); |
if (N == 0) printf(" ... no discrepancies found.\n"); |
printf("\n"); |
|
/*=============================================*/ |
Milestone = 160; |
/*=============================================*/ |
Pause(); |
printf("Searching for Overflow threshold:\n"); |
printf("This may generate an error.\n"); |
Y = - CInvrse; |
V9 = HInvrse * Y; |
sigsave = sigfpe; |
if (setjmp(ovfl_buf)) { I = 0; V9 = Y; goto overflow; } |
do { |
V = Y; |
Y = V9; |
V9 = HInvrse * Y; |
} while(V9 < Y); |
I = 1; |
overflow: |
sigsave = 0; |
Z = V9; |
printf("Can `Z = -Y' overflow?\n"); |
printf("Trying it on Y = %.17e .\n", Y); |
V9 = - Y; |
V0 = V9; |
if (V - Y == V + V0) printf("Seems O.K.\n"); |
else { |
printf("finds a "); |
BadCond(Flaw, "-(-Y) differs from Y.\n"); |
} |
if (Z != Y) { |
BadCond(Serious, ""); |
printf("overflow past %.17e\n\tshrinks to %.17e .\n", Y, Z); |
} |
if (I) { |
Y = V * (HInvrse * U2 - HInvrse); |
Z = Y + ((One - HInvrse) * U2) * V; |
if (Z < V0) Y = Z; |
if (Y < V0) V = Y; |
if (V0 - V < V0) V = V0; |
} |
else { |
V = Y * (HInvrse * U2 - HInvrse); |
V = V + ((One - HInvrse) * U2) * Y; |
} |
printf("Overflow threshold is V = %.17e .\n", V); |
if (I) printf("Overflow saturates at V0 = %.17e .\n", V0); |
else printf("There is no saturation value because the system traps on overflow.\n"); |
V9 = V * One; |
printf("No Overflow should be signaled for V * 1 = %.17e\n", V9); |
V9 = V / One; |
printf(" nor for V / 1 = %.17e .\n", V9); |
printf("Any overflow signal separating this * from the one\n"); |
printf("above is a DEFECT.\n"); |
/*=============================================*/ |
Milestone = 170; |
/*=============================================*/ |
if (!(-V < V && -V0 < V0 && -UfThold < V && UfThold < V)) { |
BadCond(Failure, "Comparisons involving "); |
printf("+-%g, +-%g\nand +-%g are confused by Overflow.", |
V, V0, UfThold); |
} |
/*=============================================*/ |
Milestone = 175; |
/*=============================================*/ |
printf("\n"); |
for(Indx = 1; Indx <= 3; ++Indx) { |
switch (Indx) { |
case 1: Z = UfThold; break; |
case 2: Z = E0; break; |
case 3: Z = PseudoZero; break; |
} |
if (Z != Zero) { |
V9 = SQRT(Z); |
Y = V9 * V9; |
if (Y / (One - Radix * E9) < Z |
|| Y > (One + Radix * E9) * Z) { /* dgh: + E9 --> * E9 */ |
if (V9 > U1) BadCond(Serious, ""); |
else BadCond(Defect, ""); |
printf("Comparison alleges that what prints as Z = %.17e\n", Z); |
printf(" is too far from sqrt(Z) ^ 2 = %.17e .\n", Y); |
} |
} |
} |
/*=============================================*/ |
Milestone = 180; |
/*=============================================*/ |
for(Indx = 1; Indx <= 2; ++Indx) { |
if (Indx == 1) Z = V; |
else Z = V0; |
V9 = SQRT(Z); |
X = (One - Radix * E9) * V9; |
V9 = V9 * X; |
if (((V9 < (One - Two * Radix * E9) * Z) || (V9 > Z))) { |
Y = V9; |
if (X < W) BadCond(Serious, ""); |
else BadCond(Defect, ""); |
printf("Comparison alleges that Z = %17e\n", Z); |
printf(" is too far from sqrt(Z) ^ 2 (%.17e) .\n", Y); |
} |
} |
/*=============================================*/ |
/*SPLIT |
} |
#include "paranoia.h" |
part8(){ |
*/ |
Milestone = 190; |
/*=============================================*/ |
Pause(); |
X = UfThold * V; |
Y = Radix * Radix; |
if (X*Y < One || X > Y) { |
if (X * Y < U1 || X > Y/U1) BadCond(Defect, "Badly"); |
else BadCond(Flaw, ""); |
|
printf(" unbalanced range; UfThold * V = %.17e\n\t%s\n", |
X, "is too far from 1.\n"); |
} |
/*=============================================*/ |
Milestone = 200; |
/*=============================================*/ |
for (Indx = 1; Indx <= 5; ++Indx) { |
X = F9; |
switch (Indx) { |
case 2: X = One + U2; break; |
case 3: X = V; break; |
case 4: X = UfThold; break; |
case 5: X = Radix; |
} |
Y = X; |
sigsave = sigfpe; |
if (setjmp(ovfl_buf)) |
printf(" X / X traps when X = %g\n", X); |
else { |
V9 = (Y / X - Half) - Half; |
if (V9 == Zero) continue; |
if (V9 == - U1 && Indx < 5) BadCond(Flaw, ""); |
else BadCond(Serious, ""); |
printf(" X / X differs from 1 when X = %.17e\n", X); |
printf(" instead, X / X - 1/2 - 1/2 = %.17e .\n", V9); |
} |
sigsave = 0; |
} |
/*=============================================*/ |
Milestone = 210; |
/*=============================================*/ |
MyZero = Zero; |
printf("\n"); |
printf("What message and/or values does Division by Zero produce?\n") ; |
#ifndef NOPAUSE |
printf("This can interupt your program. You can "); |
printf("skip this part if you wish.\n"); |
printf("Do you wish to compute 1 / 0? "); |
fflush(stdout); |
read (KEYBOARD, ch, 8); |
if ((ch[0] == 'Y') || (ch[0] == 'y')) { |
#endif |
sigsave = sigfpe; |
printf(" Trying to compute 1 / 0 produces ..."); |
if (!setjmp(ovfl_buf)) printf(" %.7e .\n", One / MyZero); |
sigsave = 0; |
#ifndef NOPAUSE |
} |
else printf("O.K.\n"); |
printf("\nDo you wish to compute 0 / 0? "); |
fflush(stdout); |
read (KEYBOARD, ch, 80); |
if ((ch[0] == 'Y') || (ch[0] == 'y')) { |
#endif |
sigsave = sigfpe; |
printf("\n Trying to compute 0 / 0 produces ..."); |
if (!setjmp(ovfl_buf)) printf(" %.7e .\n", Zero / MyZero); |
sigsave = 0; |
#ifndef NOPAUSE |
} |
else printf("O.K.\n"); |
#endif |
/*=============================================*/ |
Milestone = 220; |
/*=============================================*/ |
Pause(); |
printf("\n"); |
{ |
static char *msg[] = { |
"FAILUREs encountered =", |
"SERIOUS DEFECTs discovered =", |
"DEFECTs discovered =", |
"FLAWs discovered =" }; |
int i; |
for(i = 0; i < 4; i++) if (ErrCnt[i]) |
printf("The number of %-29s %d.\n", |
msg[i], ErrCnt[i]); |
} |
printf("\n"); |
if ((ErrCnt[Failure] + ErrCnt[Serious] + ErrCnt[Defect] |
+ ErrCnt[Flaw]) > 0) { |
if ((ErrCnt[Failure] + ErrCnt[Serious] + ErrCnt[ |
Defect] == 0) && (ErrCnt[Flaw] > 0)) { |
printf("The arithmetic diagnosed seems "); |
printf("Satisfactory though flawed.\n"); |
} |
if ((ErrCnt[Failure] + ErrCnt[Serious] == 0) |
&& ( ErrCnt[Defect] > 0)) { |
printf("The arithmetic diagnosed may be Acceptable\n"); |
printf("despite inconvenient Defects.\n"); |
} |
if ((ErrCnt[Failure] + ErrCnt[Serious]) > 0) { |
printf("The arithmetic diagnosed has "); |
printf("unacceptable Serious Defects.\n"); |
} |
if (ErrCnt[Failure] > 0) { |
printf("Potentially fatal FAILURE may have spoiled this"); |
printf(" program's subsequent diagnoses.\n"); |
} |
} |
else { |
printf("No failures, defects nor flaws have been discovered.\n"); |
if (! ((RMult == Rounded) && (RDiv == Rounded) |
&& (RAddSub == Rounded) && (RSqrt == Rounded))) |
printf("The arithmetic diagnosed seems Satisfactory.\n"); |
else { |
if (StickyBit >= One && |
(Radix - Two) * (Radix - Nine - One) == Zero) { |
printf("Rounding appears to conform to "); |
printf("the proposed IEEE standard P"); |
if ((Radix == Two) && |
((Precision - Four * Three * Two) * |
( Precision - TwentySeven - |
TwentySeven + One) == Zero)) |
printf("754"); |
else printf("854"); |
if (IEEE) printf(".\n"); |
else { |
printf(",\nexcept for possibly Double Rounding"); |
printf(" during Gradual Underflow.\n"); |
} |
} |
printf("The arithmetic diagnosed appears to be Excellent!\n"); |
} |
} |
if (fpecount) |
printf("\nA total of %d floating point exceptions were registered.\n", |
fpecount); |
printf("END OF TEST.\n"); |
return 0; |
} |
|
/*SPLIT subs.c |
#include "paranoia.h" |
*/ |
|
/* Sign */ |
|
FLOAT Sign (X) |
FLOAT X; |
{ return X >= 0. ? 1.0 : -1.0; } |
|
/* Pause */ |
|
Pause() |
{ |
#ifndef NOPAUSE |
char ch[8]; |
|
printf("\nTo continue, press RETURN"); |
fflush(stdout); |
read(KEYBOARD, ch, 8); |
#endif |
printf("\nDiagnosis resumes after milestone Number %d", Milestone); |
printf(" Page: %d\n\n", PageNo); |
++Milestone; |
++PageNo; |
} |
|
/* TstCond */ |
|
TstCond (K, Valid, T) |
int K, Valid; |
char *T; |
{ if (! Valid) { BadCond(K,T); printf(".\n"); } } |
|
BadCond(K, T) |
int K; |
char *T; |
{ |
static char *msg[] = { "FAILURE", "SERIOUS DEFECT", "DEFECT", "FLAW" }; |
|
ErrCnt [K] = ErrCnt [K] + 1; |
printf("%s: %s", msg[K], T); |
} |
|
/* Random */ |
/* Random computes |
X = (Random1 + Random9)^5 |
Random1 = X - FLOOR(X) + 0.000005 * X; |
and returns the new value of Random1 |
*/ |
|
FLOAT Random() |
{ |
FLOAT X, Y; |
|
X = Random1 + Random9; |
Y = X * X; |
Y = Y * Y; |
X = X * Y; |
Y = X - FLOOR(X); |
Random1 = Y + X * 0.000005; |
return(Random1); |
} |
|
/* SqXMinX */ |
|
SqXMinX (ErrKind) |
int ErrKind; |
{ |
FLOAT XA, XB; |
|
XB = X * BInvrse; |
XA = X - XB; |
SqEr = ((SQRT(X * X) - XB) - XA) / OneUlp; |
if (SqEr != Zero) { |
if (SqEr < MinSqEr) MinSqEr = SqEr; |
if (SqEr > MaxSqEr) MaxSqEr = SqEr; |
J = J + 1.0; |
BadCond(ErrKind, "\n"); |
printf("sqrt( %.17e) - %.17e = %.17e\n", X * X, X, OneUlp * SqEr); |
printf("\tinstead of correct value 0 .\n"); |
} |
} |
|
/* NewD */ |
|
NewD() |
{ |
X = Z1 * Q; |
X = FLOOR(Half - X / Radix) * Radix + X; |
Q = (Q - X * Z) / Radix + X * X * (D / Radix); |
Z = Z - Two * X * D; |
if (Z <= Zero) { |
Z = - Z; |
Z1 = - Z1; |
} |
D = Radix * D; |
} |
|
/* SR3750 */ |
|
SR3750() |
{ |
if (! ((X - Radix < Z2 - Radix) || (X - Z2 > W - Z2))) { |
I = I + 1; |
X2 = SQRT(X * D); |
Y2 = (X2 - Z2) - (Y - Z2); |
X2 = X8 / (Y - Half); |
X2 = X2 - Half * X2 * X2; |
SqEr = (Y2 + Half) + (Half - X2); |
if (SqEr < MinSqEr) MinSqEr = SqEr; |
SqEr = Y2 - X2; |
if (SqEr > MaxSqEr) MaxSqEr = SqEr; |
} |
} |
|
/* IsYeqX */ |
|
IsYeqX() |
{ |
if (Y != X) { |
if (N <= 0) { |
if (Z == Zero && Q <= Zero) |
printf("WARNING: computing\n"); |
else BadCond(Defect, "computing\n"); |
printf("\t(%.17e) ^ (%.17e)\n", Z, Q); |
printf("\tyielded %.17e;\n", Y); |
printf("\twhich compared unequal to correct %.17e ;\n", |
X); |
printf("\t\tthey differ by %.17e .\n", Y - X); |
} |
N = N + 1; /* ... count discrepancies. */ |
} |
} |
|
/* SR3980 */ |
|
SR3980() |
{ |
do { |
Q = (FLOAT) I; |
Y = POW(Z, Q); |
IsYeqX(); |
if (++I > M) break; |
X = Z * X; |
} while ( X < W ); |
} |
|
/* PrintIfNPositive */ |
|
PrintIfNPositive() |
{ |
if (N > 0) printf("Similar discrepancies have occurred %d times.\n", N); |
} |
|
/* TstPtUf */ |
|
TstPtUf() |
{ |
N = 0; |
if (Z != Zero) { |
printf("Since comparison denies Z = 0, evaluating "); |
printf("(Z + Z) / Z should be safe.\n"); |
sigsave = sigfpe; |
if (setjmp(ovfl_buf)) goto very_serious; |
Q9 = (Z + Z) / Z; |
printf("What the machine gets for (Z + Z) / Z is %.17e .\n", |
Q9); |
if (FABS(Q9 - Two) < Radix * U2) { |
printf("This is O.K., provided Over/Underflow"); |
printf(" has NOT just been signaled.\n"); |
} |
else { |
if ((Q9 < One) || (Q9 > Two)) { |
very_serious: |
N = 1; |
ErrCnt [Serious] = ErrCnt [Serious] + 1; |
printf("This is a VERY SERIOUS DEFECT!\n"); |
} |
else { |
N = 1; |
ErrCnt [Defect] = ErrCnt [Defect] + 1; |
printf("This is a DEFECT!\n"); |
} |
} |
sigsave = 0; |
V9 = Z * One; |
Random1 = V9; |
V9 = One * Z; |
Random2 = V9; |
V9 = Z / One; |
if ((Z == Random1) && (Z == Random2) && (Z == V9)) { |
if (N > 0) Pause(); |
} |
else { |
N = 1; |
BadCond(Defect, "What prints as Z = "); |
printf("%.17e\n\tcompares different from ", Z); |
if (Z != Random1) printf("Z * 1 = %.17e ", Random1); |
if (! ((Z == Random2) |
|| (Random2 == Random1))) |
printf("1 * Z == %g\n", Random2); |
if (! (Z == V9)) printf("Z / 1 = %.17e\n", V9); |
if (Random2 != Random1) { |
ErrCnt [Defect] = ErrCnt [Defect] + 1; |
BadCond(Defect, "Multiplication does not commute!\n"); |
printf("\tComparison alleges that 1 * Z = %.17e\n", |
Random2); |
printf("\tdiffers from Z * 1 = %.17e\n", Random1); |
} |
Pause(); |
} |
} |
} |
|
notify(s) |
char *s; |
{ |
printf("%s test appears to be inconsistent...\n", s); |
printf(" PLEASE NOTIFY KARPINKSI!\n"); |
} |
|
/*SPLIT msgs.c */ |
|
/* Instructions */ |
|
msglist(s) |
char **s; |
{ while(*s) printf("%s\n", *s++); } |
|
Instructions() |
{ |
static char *instr[] = { |
"Lest this program stop prematurely, i.e. before displaying\n", |
" `END OF TEST',\n", |
"try to persuade the computer NOT to terminate execution when an", |
"error like Over/Underflow or Division by Zero occurs, but rather", |
"to persevere with a surrogate value after, perhaps, displaying some", |
"warning. If persuasion avails naught, don't despair but run this", |
"program anyway to see how many milestones it passes, and then", |
"amend it to make further progress.\n", |
"Answer questions with Y, y, N or n (unless otherwise indicated).\n", |
0}; |
|
msglist(instr); |
} |
|
/* Heading */ |
|
Heading() |
{ |
static char *head[] = { |
"Users are invited to help debug and augment this program so it will", |
"cope with unanticipated and newly uncovered arithmetic pathologies.\n", |
"Please send suggestions and interesting results to", |
"\tRichard Karpinski", |
"\tComputer Center U-76", |
"\tUniversity of California", |
"\tSan Francisco, CA 94143-0704, USA\n", |
"In doing so, please include the following information:", |
#ifdef Single |
"\tPrecision:\tsingle;", |
#else |
"\tPrecision:\tdouble;", |
#endif |
"\tVersion:\t10 February 1989;", |
"\tComputer:\n", |
"\tCompiler:\n", |
"\tOptimization level:\n", |
"\tOther relevant compiler options:", |
0}; |
|
msglist(head); |
} |
|
/* Characteristics */ |
|
Characteristics() |
{ |
static char *chars[] = { |
"Running this program should reveal these characteristics:", |
" Radix = 1, 2, 4, 8, 10, 16, 100, 256 ...", |
" Precision = number of significant digits carried.", |
" U2 = Radix/Radix^Precision = One Ulp", |
"\t(OneUlpnit in the Last Place) of 1.000xxx .", |
" U1 = 1/Radix^Precision = One Ulp of numbers a little less than 1.0 .", |
" Adequacy of guard digits for Mult., Div. and Subt.", |
" Whether arithmetic is chopped, correctly rounded, or something else", |
"\tfor Mult., Div., Add/Subt. and Sqrt.", |
" Whether a Sticky Bit used correctly for rounding.", |
" UnderflowThreshold = an underflow threshold.", |
" E0 and PseudoZero tell whether underflow is abrupt, gradual, or fuzzy.", |
" V = an overflow threshold, roughly.", |
" V0 tells, roughly, whether Infinity is represented.", |
" Comparisions are checked for consistency with subtraction", |
"\tand for contamination with pseudo-zeros.", |
" Sqrt is tested. Y^X is not tested.", |
" Extra-precise subexpressions are revealed but NOT YET tested.", |
" Decimal-Binary conversion is NOT YET tested for accuracy.", |
0}; |
|
msglist(chars); |
} |
|
History() |
|
{ /* History */ |
/* Converted from Brian Wichmann's Pascal version to C by Thos Sumner, |
with further massaging by David M. Gay. */ |
|
static char *hist[] = { |
"The program attempts to discriminate among", |
" FLAWs, like lack of a sticky bit,", |
" Serious DEFECTs, like lack of a guard digit, and", |
" FAILUREs, like 2+2 == 5 .", |
"Failures may confound subsequent diagnoses.\n", |
"The diagnostic capabilities of this program go beyond an earlier", |
"program called `MACHAR', which can be found at the end of the", |
"book `Software Manual for the Elementary Functions' (1980) by", |
"W. J. Cody and W. Waite. Although both programs try to discover", |
"the Radix, Precision and range (over/underflow thresholds)", |
"of the arithmetic, this program tries to cope with a wider variety", |
"of pathologies, and to say how well the arithmetic is implemented.", |
"\nThe program is based upon a conventional radix representation for", |
"floating-point numbers, but also allows logarithmic encoding", |
"as used by certain early WANG machines.\n", |
"BASIC version of this program (C) 1983 by Prof. W. M. Kahan;", |
"see source comments for more history.", |
0}; |
|
msglist(hist); |
} |
|
double |
pow(x, y) /* return x ^ y (exponentiation) */ |
double x, y; |
{ |
extern double exp(), frexp(), ldexp(), log(), modf(); |
double xy, ye; |
long i; |
int ex, ey = 0, flip = 0; |
|
if (!y) return 1.0; |
|
if ((y < -1100. || y > 1100.) && x != -1.) return exp(y * log(x)); |
|
if (y < 0.) { y = -y; flip = 1; } |
y = modf(y, &ye); |
if (y) xy = exp(y * log(x)); |
else xy = 1.0; |
/* next several lines assume >= 32 bit integers */ |
x = frexp(x, &ex); |
if (i = ye) for(;;) { |
if (i & 1) { xy *= x; ey += ex; } |
if (!(i >>= 1)) break; |
x *= x; |
ex *= 2; |
if (x < .5) { x *= 2.; ex -= 1; } |
} |
if (flip) { xy = 1. / xy; ey = -ey; } |
return ldexp(xy, ey); |
} |
/incr.c
0,0 → 1,39
main() {} |
|
memchar() { |
char x, *p; |
|
&x, &p; |
x = *p++; |
x = *++p; |
x = *p--; |
x = *--p; |
} |
|
memint() { |
int x, *p; |
|
&x, &p; |
x = *p++; |
x = *++p; |
x = *p--; |
x = *--p; |
} |
|
regchar() { |
register char x, *p; |
|
x = *p++; |
x = *++p; |
x = *p--; |
x = *--p; |
} |
|
regint() { |
register int x, *p; |
|
x = *p++; |
x = *++p; |
x = *p--; |
x = *--p; |
} |
/yacc.0
0,0 → 1,39
a=-b+5*c |