diff --git a/test/err/cc65091001.c b/test/err/cc65091001.c new file mode 100644 index 000000000..265df0aac --- /dev/null +++ b/test/err/cc65091001.c @@ -0,0 +1,29 @@ +/* + !!DESCRIPTION!! invalid binary operation on pointer, should not compile + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! +*/ + +/* > Gets stuck in an endless loop with -O. */ + +#include +#include +typedef unsigned char U8; +char var = 0xf0; +char fn(char bar) +{ + char* ptr = (char*)0xf; + var |= ptr; /* should throw an error here */ + while (var > bar) + var <<= 1; + return 0; +} +int main() { + fn(0x7f); + assert(0); + + printf("it works :)\n"); + + return 0; +} \ No newline at end of file diff --git a/test/err/front.c b/test/err/front.c new file mode 100644 index 000000000..dde8d47ec --- /dev/null +++ b/test/err/front.c @@ -0,0 +1,133 @@ +/* + !!DESCRIPTION!! this code is not supposed to compile + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +main() { + return 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 (incompatible pointer type) */ +} + +/* 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 (incompatible pointer type) */ +} + +/* nasty calls */ + +onearg(){ + int a,b,c,d; + f( ( (a? (b = 1): (c = 2)), (d ? 3 : 4) ) ); /* 1 argument */ +} diff --git a/test/ref/8q.c b/test/ref/8q.c new file mode 100644 index 000000000..afbe41c64 --- /dev/null +++ b/test/ref/8q.c @@ -0,0 +1,47 @@ +/* + !!DESCRIPTION!! solves the "8 queens" chess problem + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +int up[15], down[15], rows[8], x[8]; +void queens(int c); +void print(void); + +int main(void) +{ + 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; +} + +void queens(int 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; + } +} + +void print(void) +{ + int k; + + for (k = 0; k < 8; k++) { + printf("%c", x[k]+'1'); + if(k<7) printf(" "); + } + printf("\n"); +} diff --git a/test/ref/array.c b/test/ref/array.c new file mode 100644 index 000000000..9d170aaa9 --- /dev/null +++ b/test/ref/array.c @@ -0,0 +1,62 @@ +/* + !!DESCRIPTION!! basic array properties + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +#include + +#ifndef NO_NEW_PROTOTYPES_FOR_OLD_FUNC_DECL +int f(void); +int g(int x[][4],int *y[]); +#endif + +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"); +} diff --git a/test/ref/cc65070303.c b/test/ref/cc65070303.c new file mode 100644 index 000000000..c0404dab8 --- /dev/null +++ b/test/ref/cc65070303.c @@ -0,0 +1,38 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! +*/ + +#include + +typedef signed int TypA[3]; +typedef struct TypB { + TypA Data[2]; +} sTypB; +sTypB Bs[10]; +TypA * APtr; + +int main(int argc, char* argv[]) +{ + Bs[7].Data[1][2]=11; + APtr=&(Bs[7].Data[1]); + printf("Hallo Welt! %i = %i \n",Bs[7].Data[1][2], (*APtr)[2] ); + return 0; +} + +/* +....gives +test.c(20): Error: Incompatible pointer types +for   APtr=&(Bs[7].Data[1]); + +My experience in C is very limited, but as this works both in MSVC and +the 8 bit Z80 compiler i originally used, i guess its an bug in CC65. + +As a workaround, an typecast via  APtr=(TypA*)&(Bs[7].Data[1]); +seems to work. + +greetings, +   Andreas +*/ \ No newline at end of file diff --git a/test/ref/cc65080227.c b/test/ref/cc65080227.c new file mode 100644 index 000000000..4dd454b98 --- /dev/null +++ b/test/ref/cc65080227.c @@ -0,0 +1,37 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! +*/ + +long a; /* must be static life */ +long b; /* must be static life */ + +int main(void) +{ + a = 0x00112200; /* must be immediate pattern is (1stBYTE == 4thBYTE) */ + b = a; + /* b is 0x11112200 ! */ + + printf("b (should be 0x00112200): %08lx\n",b); + + return 0; +} + +/* +[ command line ] + cl65 -c -T -l -O test.c + +[ part of test.lst ] + 000012r 1 ; b = a; + 000012r 1 AD rr rr lda _a+2 + 000015r 1 85 rr sta sreg + 000017r 1 AE rr rr ldx _a+1 + 00001Ar 1 AD rr rr lda _a + 00001Dr 1 8D rr rr sta _b + 000020r 1 8E rr rr stx _b+1 + 000023r 1 A4 rr ldy sreg + 000025r 1 8C rr rr sty _b+2 + 000028r 1 8C rr rr sty _b+3 ; lost 4th BYTE ! +*/ \ No newline at end of file diff --git a/test/ref/cc65080328.c b/test/ref/cc65080328.c new file mode 100644 index 000000000..11ef73514 --- /dev/null +++ b/test/ref/cc65080328.c @@ -0,0 +1,24 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! +*/ + +/* +The following code produces an 'Error: Incompatible pointer types' at +the last line when compiling with snapshot-2.11.9.20080316 without +optimizations. If I remove the struct inside f() it compiles fine ?!? + +Best, Oliver +*/ + +void f(void){struct{int i;}d;} +struct{void(*p)(void);}s={f}; + +int main(void) +{ + printf("it works :)\n"); + + return 0; +} diff --git a/test/ref/cc65090111.c b/test/ref/cc65090111.c new file mode 100644 index 000000000..f515716f7 --- /dev/null +++ b/test/ref/cc65090111.c @@ -0,0 +1,49 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! +*/ + +/* +cc65 doesn't compile this, if i use the "-O"-option. +but it works with "while(!0)"; instead of "for(;;);" + +i'm using cl65 V2.12.9 win + +---- +#include + +int main(void) +{ + static uint8_t x = 0; + static uint8_t y = 0; + + for (x = 0; x < 16; ++x) + { + y = y + 1; + } + for(;;); +} +*/ + +#include + +int test(void) +{ + static uint8_t x = 0; + static uint8_t y = 0; + + for (x = 0; x < 16; ++x) + { + y = y + 1; + } + for(;;); +} + +int main(void) +{ + printf("it works :)\n"); + + return 0; +} diff --git a/test/ref/cc65090124.c b/test/ref/cc65090124.c new file mode 100644 index 000000000..fef22268f --- /dev/null +++ b/test/ref/cc65090124.c @@ -0,0 +1,61 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! +*/ + +/* +there is a bug in the preprocessor (i think) ... the following works +(compiles) correctly: + +unsigned long fs,fd,a; + +unsigned long _func(unsigned long x,unsigned long y) +{ + return 0; +} + +int main(void) +{ + fs=(_func((fd/a),(_func(2,0x0082c90f)))); +} + +now if i wrap _func into a macro like this: + +#define func(x,y) _func(x,y) + +int main(void) +{ + fs=(func((fd/a),(func(2,0x0082c90f)))); +} + +i get "Error: `)' expected" on that line. (this is with the snapshot, freshly +compiled 5 minutes ago) +*/ + +unsigned long fs,fd,a; + +unsigned long _func1(unsigned long x,unsigned long y) +{ + return 0; +} + +int test1(void) +{ + fs=(_func1((fd/a),(_func1(2,0x0082c90f)))); +} + +#define func(x,y) _func1(x,y) + +int test2(void) +{ + fs=(func((fd/a),(func(2,0x0082c90f)))); +} + +int main(void) +{ + printf("it works :)\n"); + + return 0; +} diff --git a/test/ref/cc65090726.c b/test/ref/cc65090726.c new file mode 100644 index 000000000..fb4773afb --- /dev/null +++ b/test/ref/cc65090726.c @@ -0,0 +1,46 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! +*/ + +struct Record { + struct Record *PtrComp; + int x; +}; + +typedef struct Record RecordType; +typedef RecordType *RecordPtr; + +void Proc3(RecordPtr *PtrParOut) +{ + /* whatever */ +} + +void Proc1(RecordPtr PtrParIn) +{ +#define NextRecord (*(PtrParIn->PtrComp)) + Proc3((RecordPtr *)NextRecord.PtrComp); + Proc3(&NextRecord.PtrComp); + Proc3(&PtrParIn->PtrComp->PtrComp); + +#ifdef CAST_STRUCT_PTR + Proc3((RecordPtr *) PtrParIn->PtrComp->PtrComp); + Proc3((RecordPtr *) (*(PtrParIn->PtrComp)).PtrComp); + Proc3((RecordPtr *) NextRecord.PtrComp); +#else + Proc3(PtrParIn->PtrComp->PtrComp); + Proc3((*(PtrParIn->PtrComp)).PtrComp); + Proc3(NextRecord.PtrComp); +#endif + +#undef NextRecord +} + +int main(void) +{ + printf("it works :)\n"); + + return 0; +} diff --git a/test/ref/cc65090910.c b/test/ref/cc65090910.c new file mode 100644 index 000000000..c8e5ce934 --- /dev/null +++ b/test/ref/cc65090910.c @@ -0,0 +1,26 @@ +/* + !!DESCRIPTION!! optimizer bug + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Oliver Schmidt +*/ + +/* +After spending a "little" time I finally succeeded in isolating an +(maybe THE) optimizer bug causing Contiki to fail. + +From my user perspective it is very interesting that the bug shows up +with compiler option -O but does _not_ show up with -Oi. +*/ + +unsigned htons(unsigned val) +{ + return (((unsigned) (val)) << 8) | (((unsigned) (val)) >> 8); +} + +int main(void) +{ + printf("%x -> %x\n", 0x1234, htons(0x1234) & 0xffff); + + return 0; +} diff --git a/test/ref/cc65090913.c b/test/ref/cc65090913.c new file mode 100644 index 000000000..a319fec50 --- /dev/null +++ b/test/ref/cc65090913.c @@ -0,0 +1,31 @@ +/* + !!DESCRIPTION!! optimizer bug + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Oliver Schmidt +*/ + +/* +> I found the problem and fixed it. cc65 treated a label as a statement, but +> the standard says, that a label is part of a statement. In a loop without +> curly braces like +> +> while (foo < bar) +> label: ++foo; +> +> the following statement is the one that is looped over - and because cc65 +> treated just the label as a statement, it created code that looped forever. + +*/ + +int foo=0,bar=2; + +int main(void) +{ + while(foofoo = 1; + + printf("it works :)\n"); + + return 0; +} + diff --git a/test/ref/cc65091022.c b/test/ref/cc65091022.c new file mode 100644 index 000000000..222253992 --- /dev/null +++ b/test/ref/cc65091022.c @@ -0,0 +1,20 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Johan Kotlinski +*/ + +/* +...gives "test.c(2): Error: Variable `foo' has unknown size" using -Cl. +Is it really unknown? + +cc65 V2.13.0, SVN version: 4384 +*/ + +int main() { + char foo[] = { 0 }; + printf("it works :)\n"); + + return 0; +} diff --git a/test/ref/cc65101102.c b/test/ref/cc65101102.c new file mode 100644 index 000000000..4faa7c12b --- /dev/null +++ b/test/ref/cc65101102.c @@ -0,0 +1,56 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Marc 'BlackJack' Rintsch +*/ + +/* +Compiler is build from cc65-snapshot-2.13.9.20101031 sources. + +Expected results and also what I get from this without any optimisations +are: 48663 and 49218 + +When I turn on ``-O``: 58096 and 58096. After swapping the two variable +declaration lines in `calculate_checksum()` the results are correct +with ``-O``. + +But with ``--O --static-locals`` the results are incorrect again (31757 +and 15408). ``--static-locals`` alone works though. +*/ + +#include +#include + +// uint16_t __fastcall__ calculate_checksum(uint8_t *block); +uint8_t block[256]; + +uint16_t calculate_checksum(uint8_t *block) +{ + uint16_t i, result = 0xffff; + uint8_t j; + + for (i = 0; i < 256; ++i) { + result ^= block[i] << 8; + for (j = 0; j < 8; ++j) { + if (result & (1 << 15)) { + result = (result << 1) ^ 0x1021; + } else { + result <<= 1; + } + } + } + return ~result; +} + +int main(void) +{ + uint16_t i; + + printf("zeroes: %u\n", calculate_checksum(block)); + for (i = 0; i < 256; ++i) block[i] = i; + printf("0..255: %u\n", calculate_checksum(block)); + + return 0; +} + diff --git a/test/ref/cc65101209.c b/test/ref/cc65101209.c new file mode 100644 index 000000000..c14543640 --- /dev/null +++ b/test/ref/cc65101209.c @@ -0,0 +1,38 @@ +/* + !!DESCRIPTION!! mod operator bug + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! marcas +*/ + +#include +#include + +int main(void) { + int tmp; + + for (tmp = 0; tmp<=12345; tmp++) + if (!(tmp%1000)) printf("%d mod 1000 is %d\n", tmp, tmp%1000); + + return 0; +} + +/* +results in (vice x64) +0 mod 1000 is 0 +232 mod 1000 is 0 +1000 mod 1000 is 0 + +Interesting: + + 1000 = $3E8 + 232 = $E8 + +So testing with 999 gives: + +0 mod 999 is 0 +231 mod 999 is 0 +999 mod 999 is 0 + +This seems to be systematic. +*/ \ No newline at end of file diff --git a/test/ref/cc65101216.c b/test/ref/cc65101216.c new file mode 100644 index 000000000..eaaf0b3e4 --- /dev/null +++ b/test/ref/cc65101216.c @@ -0,0 +1,27 @@ +/* + !!DESCRIPTION!! division bug + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Stefan Wessels +*/ + +/* +The output from the code below is: +a / b = 6 + +Shouldn't that be 0? +*/ + +#include +#define b 10000 +char a; +int main() +{ + char c; + + a = 100; + c = a / b; + printf("a / b = %d", c); + + return 0; +} \ No newline at end of file diff --git a/test/ref/cc65110210.c b/test/ref/cc65110210.c new file mode 100644 index 000000000..2c7853556 --- /dev/null +++ b/test/ref/cc65110210.c @@ -0,0 +1,55 @@ +/* + !!DESCRIPTION!! linker bug + !!ORIGIN!! testsuite + !!LICENCE!! public domain +*/ + +/* +with SVN version: 4973M + +$ cl65 -v -o test.prg tests/cc65110210.c +Opened include file `/usr/local/lib/cc65/include/stdio.h' +Opened include file `/usr/local/lib/cc65/include/stddef.h' +Opened include file `/usr/local/lib/cc65/include/stdarg.h' +Opened include file `/usr/local/lib/cc65/include/limits.h' +0 errors, 0 warnings +Opened output file `tests/cc65110210.s' +Wrote output to `tests/cc65110210.s' +Closed output file `tests/cc65110210.s' +cl65: Subprocess `ld65' aborted by signal 11 + +*/ + +/* #define STANDALONE */ + +#include +#include + +#ifdef STANDALONE + +#define NO_IMPLICIT_FUNCPTR_CONV + +#define OPENTEST() +#define CLOSETEST() + +#else + +#endif + +#ifdef NO_IMPLICIT_FUNCPTR_CONV +void (*p1func)(void); +#else +void (*p1func)(); +#endif + +void func(void) +{ + (*p1func)(); +} + +int main(void) +{ + printf("it works :)\n"); + + return (0); +} diff --git a/test/ref/cc65110211.c b/test/ref/cc65110211.c new file mode 100644 index 000000000..76b3f4a70 --- /dev/null +++ b/test/ref/cc65110211.c @@ -0,0 +1,80 @@ +/* + !!DESCRIPTION!! unreachable code related bug + !!ORIGIN!! Testsuite + !!LICENCE!! Public Domain +*/ + +/* + test2 and test3 will result in an endless loop (SVN version: 4974M) +*/ + +#define OPENTEST() +#define CLOSETEST() + +static char upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + +int test1(void) +{ + int res; + unsigned char *p; + + p = upper; + res = 0; + + while(*p) { + if(*p < 0) { + res = 1; + } + p++; + } + + printf("test1:ok\n"); + return res; +} + +int test2(void) +{ + int res; + unsigned char *p; + + p = upper; + res = 0; + + while(*p) { + if(*p++ < 0) { + res = 1; + } + } + + printf("test2:ok\n"); + return res; +} + +int test3(void) +{ + int res; + unsigned char *p; + + p = upper; + res = 0; + + while(*p) { + if(*++p < 0) { + res = 1; + } + } + + printf("test3:ok\n"); + return res; +} + +int main(int n,char **args) +{ + test1(); + test2(); + test3(); + + printf("it works :)\n"); + + return 0; +} diff --git a/test/ref/cf.c b/test/ref/cf.c new file mode 100644 index 000000000..951f31295 --- /dev/null +++ b/test/ref/cf.c @@ -0,0 +1,181 @@ +/* + !!DESCRIPTION!! print character frequencies + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +/* + cf - print character frequencies +*/ + +#include +#include +#include + +#define INFILE "cf.in" + +#ifndef NO_FLOATS +float f[0x100]; +#else +signed f[0x100]; +#endif + +#ifdef NO_OLD_FUNC_DECL +int main(int argc,char **argv) +#else +main(argc, argv) +int argc; +char *argv[]; +#endif +{ + int i, c, nc; +#ifndef NO_FLOATS + float cutoff, atof(); +#else + signed cutoff; +#endif + + if (argc <= 1) +#ifndef NO_FLOATS + cutoff = 0.0; +#else + cutoff = 0; +#endif + else +#ifndef NO_FLOATS + cutoff = atof(argv[1])/100; +#else + cutoff = atoi(argv[1])/100; +#endif + for (i = 0; i < 0x100; ) + { +#ifndef NO_FLOATS + f[i++] = 0.0; +#else + f[i++] = 0; +#endif + } + + printf("input:\n\n"); + + nc = 0; + while ((c = GETCHAR()) != -1) + { +/* printf("[%02x]",c); */ + printf("%c",c); + f[c] += 1; + nc++; + } + printf("\n\ncount: %d\n\n",nc); + + /* + now try to print a report in a way so that + the order is somewhat independent from the + target character set + */ + + printf("a-z char:freq\n\n"); + + /* first round ... lowercase characters */ + for (i = 0; i < 0x100; ++i) + { + if ((f[i]) && ((f[i]/nc) >= cutoff)) + { + if ((i >= 'a') && (i <= 'z')) + { + printf("%c", i); +#ifndef NO_FLOATS + printf(":%.1f\n", 100*f[i]/nc); +#else + printf(":%d\n", 100*f[i]/nc); +#endif + f[i]=0; + } + } + } + + printf("A-Z char:freq\n\n"); + + /* second round ... uppercase characters */ + for (i = 0; i < 0x100; ++i) + { + if ((f[i]) && ((f[i]/nc) >= cutoff)) + { + if ((i >= 'A') && (i <= 'Z')) + { + printf("%c", i); +#ifndef NO_FLOATS + printf(":%.1f\n", 100*f[i]/nc); +#else + printf(":%d\n", 100*f[i]/nc); +#endif + f[i]=0; + } + } + } + + printf("0-9 char:freq\n\n"); + + /* third round ... numbers */ + for (i = 0; i < 0x100; ++i) + { + if ((f[i]) && ((f[i]/nc) >= cutoff)) + { + if ((i >= '0') && (i <= '9')) + { + printf("%c", i); +#ifndef NO_FLOATS + printf(":%.1f\n", 100*f[i]/nc); +#else + printf(":%d\n", 100*f[i]/nc); +#endif + f[i]=0; + } + } + } + + printf("isprint char:freq\n\n"); + + /* second last round ... remaining printable characters */ + for (i = 0; i < 0x100; ++i) + { + if ((f[i]) && ((f[i]/nc) >= cutoff)) + { + if(isprint(i)) + { + printf("%c", i); +#ifndef NO_FLOATS + printf(":%.1f\n", 100*f[i]/nc); +#else + printf(":%d\n", 100*f[i]/nc); +#endif + f[i]=0; + } + } + } + + printf("rest char:freq\n\n"); + + /* last round ... remaining non printable characters */ + for (i = 0; i < 0x100; ++i) + { + if ((f[i]) && ((f[i]/nc) >= cutoff)) + { + if(i=='\n') + { + printf("newline"); + } + else + { + printf("%03o", i); + } +#ifndef NO_FLOATS + printf(":%.1f\n", 100*f[i]/nc); +#else + printf(":%d\n", 100*f[i]/nc); +#endif + } + } + + return 0; +} diff --git a/test/ref/charconst.c b/test/ref/charconst.c new file mode 100644 index 000000000..1aa9f8e3f --- /dev/null +++ b/test/ref/charconst.c @@ -0,0 +1,59 @@ +/* + !!DESCRIPTION!! check if character constants are translated correctly + !!ORIGIN!! cc65 bug report + !!LICENCE!! Public Domain +*/ + +#include +#include + +void backslash(unsigned char c) +{ + printf("%c : ",c); + + switch (c) + { + case 'b': + c = '\b'; + case 'f': + c = '\f'; + case 'n': + c = '\n'; + case 'r': + c = '\r'; + case 't': + c = '\t'; + case 'v': + #ifndef NO_BACKSLASH_V + c = '\v'; + #else + c = 0x0b; + #endif + } + + if(!isprint(c)) + { + printf("ok.\n"); + } + else + { + printf("failed.\n"); + } +} + +void testbackslash(void) +{ + backslash('b'); + backslash('f'); + backslash('n'); + backslash('r'); + backslash('t'); + backslash('v'); +} + +int main(void) +{ + testbackslash(); + + return 0; +} diff --git a/test/ref/charset.c b/test/ref/charset.c new file mode 100644 index 000000000..59b7c4c54 --- /dev/null +++ b/test/ref/charset.c @@ -0,0 +1,93 @@ +/* + !!DESCRIPTION!! basic ASCII character test + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Groepaz/Hitmen +*/ + +#include + +#if 0 + +/* this kind of line-continuation for strings doesnt work properly for cc65 */ + +const unsigned char characters[]={ + /*0123456789abcdef0123456789abcdef*/ + /* iso646-us control-characters */ + " " /* 00-1f */ + /* iso646-us printable characters */ + " !\"#$%&'()*+,-./" /* 20-2f !"#$%&'()*+,-./ */ + "0123456789" /* 30-39 0123456789 */ + ":;<=>?@" /* 3a-40 :;<=>?@ */ + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" /* 41-5a A-Z */ + "[\\]^_`" /* 5b-60 [\]^_` */ + "abcdefghijklmnopqrstuvwxyz" /* 61-7a a-z */ + "{|}~ " /* 7b-7f {|}~ */ + /* iso8859-15 extended characters */ +}; + +#endif + +const unsigned char characters[]={ + /*0123456789abcdef0123456789abcdef*/ + /* iso646-us control-characters */ + /* 00-1f */ + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + /* iso646-us printable characters */ + /* 20-2f !"#$%&'()*+,-./ */ + ' ','!','"','#','$','%','&','\'','(',')','*','+',',','-','.','/', + /* 30-39 0123456789 */ + '0','1','2','3','4','5','6','7','8','9', + /* 3a-40 :;<=>?@ */ + ':',';','<','=','>','?','@', + /* 41-5a A-Z */ + 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z', + /* 5b-60 [\]^_` */ + '[','\\',']','^','_','`', + /* 61-7a a-z */ + 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z', + /* 7b-7f {|}~ */ + '{','|','}','~',' ' + /* iso8859-15 extended characters */ +}; + +void printchars(unsigned char a,unsigned char b){ + for(b++;a!=b;a++) +/* printf("%02x ",a); */ +/* printf("%02x ",characters[a]); */ + printf("%c",characters[a]); + printf("\n"); +} + +int main(void) { + printf("characters:\n\n"); + printchars(0x61,0x7a); + printchars(0x41,0x5a); + printf("numbers:\n\n"); + printchars(0x30,0x39); + printf("other:\n\n"); + printchars(0x20,0x2f); + /*printchars(0x3a,0x40);*/ + printchars(0x3a,0x3f); + /*printchars(0x5b,0x60);*/ + /*printchars(0x7b,0x7f);*/ + printf("\n\n"); + printf("slash: '%c'\n",'/'); + printf("backslash: '%c'\n",'\\'); + printf("curly braces open: '%c'\n",'{'); + printf("curly braces close: '%c'\n",'}'); + printf("square braces open: '%c'\n",'['); + printf("square braces close: '%c'\n",']'); + printf("underscore: '%c'\n",'_'); + printf("tilde: '%c'\n",'~'); + printf("pipe: '%c'\n",'|'); + printf("apostroph: '%c'\n",'\''); + printf("single quote '%c'\n",'`'); + printf("xor '%c'\n",'^'); + printf("at '%c'\n",'@'); + + return 0; +} diff --git a/test/ref/cvt.c b/test/ref/cvt.c new file mode 100644 index 000000000..ed7b6084e --- /dev/null +++ b/test/ref/cvt.c @@ -0,0 +1,53 @@ +/* + !!DESCRIPTION!! type conversion + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +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; + +#ifdef NO_FLOATS +signed long f; +signed long d; +signed long D; +#else +float f; +double d; +long double D; +#endif + +void *p; +void (*P)(void); + +void print(void) { + #ifdef NO_FLOATS + printf("%d %d %d %ld %u %u %u %lu %ld.000000 %ld.000000 %ld.000000\n",c,s,i,l,C,S,I,L,f,d,D); + #else + printf("%d %d %d %ld %u %u %u %lu %f %f %lf \n",c,s,i,l,C,S,I,L,f,d,D ); + #endif +} + +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; +} diff --git a/test/ref/dijkstra.c b/test/ref/dijkstra.c new file mode 100644 index 000000000..168324f68 --- /dev/null +++ b/test/ref/dijkstra.c @@ -0,0 +1,369 @@ +/* + !!DESCRIPTION!! Dijkstras Algorithm + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Groepaz/Hitmen +*/ + +#include +#include + +#ifndef NULL +#define NULL ((void*)0) +#endif + +#define DIJKSTRA_INFINITY (0xffff) + +#define DIJKSTRA_FLAG_UNVISITED (0x0) +/* +#define DIJKSTRA_FLAG_OPEN (0x1) +*/ +#define DIJKSTRA_FLAG_CLOSED (0x2) + +typedef struct _DIJKSTRA_EDGE { + struct _DIJKSTRA_NODE *NEXTNODE; + unsigned short DISTANCE; +} DIJKSTRA_EDGE; + +typedef struct _DIJKSTRA_NODE { + DIJKSTRA_EDGE *EDGES; + unsigned char TAG; + unsigned char FLAG; + unsigned short MINDIST; + struct _DIJKSTRA_NODE *PREVIOUS; +} DIJKSTRA_NODE; + +/* init with graph, startnode, working-array */ +void Dijkstra_Init(const DIJKSTRA_NODE *graph,DIJKSTRA_NODE *start,DIJKSTRA_NODE *nodes); + +/* call main algo with working-array */ +void Dijkstra_Search(DIJKSTRA_NODE *nodes); + +/* print path, call with working-array, endnode */ +void Dijkstra_Path(DIJKSTRA_NODE *nodes,DIJKSTRA_NODE *end); + +/* print table, call with working-array, current node */ +void Dijkstra_Table(DIJKSTRA_NODE *nodes,DIJKSTRA_NODE *current); + +/* internally used routines */ + +unsigned short Dijkstra_Distance(DIJKSTRA_NODE *currnode,DIJKSTRA_NODE *nextnode); +void Dijkstra_Relax(DIJKSTRA_NODE *currnode,DIJKSTRA_NODE *nextnode); +DIJKSTRA_NODE *Dijkstra_NextCheapest(DIJKSTRA_NODE *graph); +unsigned short Dijkstra_CountUnvisited(DIJKSTRA_NODE *graph); + +/* define to get printed info as the algorithm proceeds */ +#define DIJKSTRA_PRINTDEBUG + +/* the working array */ +DIJKSTRA_NODE mynodes[0x10]; + +/* test-network data (mypoints and myedges) */ + +const DIJKSTRA_EDGE myedges_A[]={ + {&mynodes[1],1}, + {NULL} +}; +const DIJKSTRA_EDGE myedges_B[]={ + {&mynodes[0],1}, + {&mynodes[2],2}, + {&mynodes[3],1}, + {NULL} +}; +const DIJKSTRA_EDGE myedges_C[]={ + {&mynodes[1],2}, + {&mynodes[5],1}, + {NULL} +}; +const DIJKSTRA_EDGE myedges_D[]={ + {&mynodes[1],1}, + {&mynodes[4],1}, + {NULL} +}; +const DIJKSTRA_EDGE myedges_E[]={ + {&mynodes[6],1}, + {NULL} +}; +const DIJKSTRA_EDGE myedges_F[]={ + {&mynodes[7],1}, + {NULL} +}; +const DIJKSTRA_EDGE myedges_G[]={ + {&mynodes[8],1}, + {&mynodes[7],4}, + {NULL} +}; +const DIJKSTRA_EDGE myedges_H[]={ + {&mynodes[9],1}, + {&mynodes[6],4}, + {NULL} +}; +const DIJKSTRA_EDGE myedges_I[]={ + {&mynodes[10],5}, + {NULL} +}; +const DIJKSTRA_EDGE myedges_J[]={ + {&mynodes[10],1}, + {NULL} +}; +const DIJKSTRA_EDGE myedges_K[]={ + {&mynodes[11],1}, + {NULL} +}; +const DIJKSTRA_EDGE myedges_L[]={ + {&mynodes[10],1}, + {NULL} +}; + +const DIJKSTRA_NODE mypoints[]={ + {(DIJKSTRA_EDGE *)&myedges_A[0],'A'}, + {(DIJKSTRA_EDGE *)&myedges_B[0],'B'}, + {(DIJKSTRA_EDGE *)&myedges_C[0],'C'}, + {(DIJKSTRA_EDGE *)&myedges_D[0],'D'}, + {(DIJKSTRA_EDGE *)&myedges_E[0],'E'}, + {(DIJKSTRA_EDGE *)&myedges_F[0],'F'}, + {(DIJKSTRA_EDGE *)&myedges_G[0],'G'}, + {(DIJKSTRA_EDGE *)&myedges_H[0],'H'}, + {(DIJKSTRA_EDGE *)&myedges_I[0],'I'}, + {(DIJKSTRA_EDGE *)&myedges_J[0],'J'}, + {(DIJKSTRA_EDGE *)&myedges_K[0],'K'}, + {(DIJKSTRA_EDGE *)&myedges_L[0],'L'}, + {NULL} +}; + +/* + * initialize working-array + */ + +void Dijkstra_Init(const DIJKSTRA_NODE *graph,DIJKSTRA_NODE *start,DIJKSTRA_NODE *nodes) { + while(graph->EDGES!=NULL) { + nodes->EDGES=graph->EDGES; + nodes->TAG=graph->TAG; + nodes->FLAG=DIJKSTRA_FLAG_UNVISITED; + nodes->MINDIST=DIJKSTRA_INFINITY; + nodes->PREVIOUS=NULL; + + graph++;nodes++; + + } +/* + start->FLAG=DIJKSTRA_FLAG_OPEN; + start->PREVIOUS=NULL; + */ + start->MINDIST=0; +} + +/* + * compute the distance between two Nodes in the Graph + */ + +unsigned short Dijkstra_Distance(DIJKSTRA_NODE *currnode,DIJKSTRA_NODE *nextnode){ +DIJKSTRA_EDGE *edge; + + edge=currnode->EDGES; + + while(edge!=NULL) { + if(edge->NEXTNODE == nextnode){ + return(edge->DISTANCE); + } + + edge++; + + } + + return(DIJKSTRA_INFINITY); +} + +/* + * 'relax' one node against another + */ + +void Dijkstra_Relax(DIJKSTRA_NODE *currnode,DIJKSTRA_NODE *nextnode){ +unsigned short newdist; + +#ifdef DIJKSTRA_PRINTDEBUG + printf("relax >%c< to >%c<\n",currnode->TAG,nextnode->TAG); +#endif + + newdist=currnode->MINDIST+Dijkstra_Distance(currnode,nextnode); + + if((nextnode->MINDIST)>(newdist)){ + nextnode->MINDIST=newdist; + nextnode->PREVIOUS=currnode; + + } +} + +/* + * find the yet unprocessed Node with the currently + * smallest estimated MINDIST + */ + +DIJKSTRA_NODE *Dijkstra_NextCheapest(DIJKSTRA_NODE *graph){ +unsigned short mindist; +DIJKSTRA_NODE *node; + + node=NULL; + mindist=DIJKSTRA_INFINITY; + + while(graph->EDGES!=NULL) { + if(graph->FLAG!=DIJKSTRA_FLAG_CLOSED){ + if(!(mindistMINDIST)){ + mindist=graph->MINDIST; + node=graph; + } + } + + graph++; + + } + +#ifdef DIJKSTRA_PRINTDEBUG + if(node!=NULL) printf("next cheapest Node: >%c<\n",node->TAG); +#endif + + return(node); +} + +/* + * count number of Nodes that are left for processing + */ + +unsigned short Dijkstra_CountUnvisited(DIJKSTRA_NODE *graph){ +unsigned short num; + + num=0; + + while(graph->EDGES!=NULL) { + if(graph->FLAG!=DIJKSTRA_FLAG_CLOSED){ + num++; + } + + graph++; + + } + + return(num); +} + +/* + * Dijkstra-Algorithmus main processing + */ + +void Dijkstra_Search(DIJKSTRA_NODE *graph){ +DIJKSTRA_NODE *currnode,*nextnode; +DIJKSTRA_EDGE *edge; + + currnode=graph; + + while(Dijkstra_CountUnvisited(graph)>0){ + edge=currnode->EDGES; + while(edge->NEXTNODE!=NULL){ + nextnode=edge->NEXTNODE; + if(nextnode->FLAG!=DIJKSTRA_FLAG_CLOSED){ +/* + nextnode->FLAG=DIJKSTRA_FLAG_OPEN; + */ + Dijkstra_Relax(currnode,nextnode); +#ifdef DIJKSTRA_PRINTDEBUG + Dijkstra_Table(graph,currnode); +#endif + } + edge++; + } + currnode=Dijkstra_NextCheapest(graph); + currnode->FLAG=DIJKSTRA_FLAG_CLOSED; + } +} + +/* + * print the Path from start Node to one other Node + */ + +void Dijkstra_Path(DIJKSTRA_NODE *graph,DIJKSTRA_NODE *end){ +DIJKSTRA_NODE *currnode,*nextnode; + + printf("Path from >%c< to >%c< : ",end->TAG,graph->TAG); + + currnode=end; + + while(currnode->PREVIOUS!=NULL){ + printf(">%c< ",currnode->TAG); + currnode=currnode->PREVIOUS; + } + + printf(">%c<\n",currnode->TAG); +} + +/* + * print working-array as a table + */ + +void Dijkstra_Table(DIJKSTRA_NODE *graph,DIJKSTRA_NODE *current){ +DIJKSTRA_NODE *g; + + printf("----------------------\n"); + + printf("Node |"); + g=graph;while(g->EDGES!=NULL) { + printf("-->%c<-|",g->TAG); + g++; + } + printf("\n"); + + printf("MinDist |"); + g=graph;while(g->EDGES!=NULL) { + printf(" %5u|",g->MINDIST); + g++; + } + printf("\n"); + + printf("Flag |"); + g=graph;while(g->EDGES!=NULL) { + switch(g->FLAG){ +/* + case DIJKSTRA_FLAG_OPEN: + printf("opened|"); + break; + */ + case DIJKSTRA_FLAG_CLOSED: + printf("closed|"); + break; + default: + if(g->MINDIST!=DIJKSTRA_INFINITY){ + printf("opened|"); + } else { + printf("------|"); + } + break; + } + g++; + } + printf("\n"); + + printf("Previous|"); + g=graph;while(g->EDGES!=NULL) { + if(g->PREVIOUS==NULL) + printf("------|"); + else + printf(" (%c) |",g->PREVIOUS->TAG); + g++; + } + printf("\n"); + + printf("----------------------\n"); +} + +int main(void) +{ + /* init with graph, startnode, working-array */ + Dijkstra_Init(&mypoints[0],&mynodes[0],&mynodes[0]); + /* call main algo with working-array */ + Dijkstra_Search(&mynodes[0]); + /* print table, call with working-array, endnode */ + Dijkstra_Table(&mynodes[0],&mynodes[11]); + /* print path, call with working-array, endnode */ + Dijkstra_Path(&mynodes[0],&mynodes[11]); + + return 0; +} diff --git a/test/ref/divmod.c b/test/ref/divmod.c new file mode 100644 index 000000000..68a0198e1 --- /dev/null +++ b/test/ref/divmod.c @@ -0,0 +1,38 @@ +/* + !!DESCRIPTION!! div/mod test + !!ORIGIN!! + !!LICENCE!! public domain +*/ + +#include + +void printc(signed char a,signed char b){ +signed char x=a/b,y=a%b,z=a*b; + printf("%3d,%3d is %3d,%3d,%3d\n",a,b,x,y,z); +} +void prints(short a,short b){ +short x=a/b,y=a%b,z=a*b; + printf("%3d,%3d is %3d,%3d,%3d\n",a,b,x,y,z); +} +void printl(long a,long b){ +long x=a/b,y=a%b,z=a*b; + printf("%3ld,%3ld is %3ld,%3ld,%3ld\n",a,b,x,y,z); +} + +int main(void) { + printl( 3,-2); + printl(-3,-2); + printl(-3, 2); + printl( 3, 2); + printf("-\n"); + prints( 3,-2); + prints(-3,-2); + prints(-3, 2); + prints( 3, 2); + printf("-\n"); + printc( 3,-2); + printc(-3,-2); + printc(-3, 2); + printc( 3, 2); + return 0; +} diff --git a/test/ref/fields.c b/test/ref/fields.c new file mode 100644 index 000000000..794a81924 --- /dev/null +++ b/test/ref/fields.c @@ -0,0 +1,92 @@ +/* + !!DESCRIPTION!! bitfield test + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +#ifdef NO_BITFIELDS + +main() +{ + printf("NO_BITFIELDS\n\r"); +} + +#else + +#ifdef SIZEOF_INT_16BIT + +#ifdef REFCC +#include +struct foo { + int16_t a; + char b; + int16_t x : 12, y : 4; + int16_t zz : 1, : 0, : 4, z : 3; + char c; +} x = { 1, 2, 3, 4, 5, 6 }; + +struct baz { uint16_t a:2, b:4, c:16;} y = { 7, 8, 9}; +int16_t i = 8; + +#else + +struct foo { + int a; + char b; + int x : 12, y : 4; + int zz : 1, : 0, : 4, z : 3; + char c; +} x = { 1, 2, 3, 4, 5, 6 }; + +struct baz { unsigned int a:2, b:4, c:16;} y = { 7, 8, 9}; +int i = 8; +#endif + +#else +struct foo { + int a; + char b; + int x : 12, y : 4, : 0, : 4, z : 3; + char c; +} x = { 1, 2, 3, 4, 5, 6 }; + +struct baz { unsigned int a:2, b:4, c:32;} y = { 7, 8, 9}; +int i = 16; +#endif + +#ifdef NO_IMPLICIT_FUNC_PROTOTYPES +f1(struct baz *p); +f2(struct baz *p); +#endif + +main() +{ + printf("x = %d b:%d %d %d %d c:%d\n", x.a, x.b, x.x, x.y, x.z, x.c); + printf("y = %d b:%d c:%d\n", y.a, y.b, y.c); + x.y = i; + x.z = 070; + printf("x = %d b:%d %d %d %d c:%d\n", x.a, x.b, x.x, x.y, x.z, x.c); + y.a = 2; + y.c = i; + printf("y = %d b:%d c:%d\n", y.a, y.b, y.c); +#ifdef CAST_STRUCT_PTR + f2((struct baz *)&x); +#else + f2(&x); +#endif + 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); +} + +#endif diff --git a/test/ref/hanoi.c b/test/ref/hanoi.c new file mode 100644 index 000000000..234ac41e4 --- /dev/null +++ b/test/ref/hanoi.c @@ -0,0 +1,90 @@ +/* + !!DESCRIPTION!! solves the "towers of hanoi" problem + !!ORIGIN!! BYTE UNIX Benchmarks + !!LICENCE!! Public Domain +*/ + +/******************************************************************************* + * The BYTE UNIX Benchmarks - Release 3 + * Module: hanoi.c SID: 3.3 5/15/91 19:30:20 + * + ******************************************************************************* + * Bug reports, patches, comments, suggestions should be sent to: + * + * Ben Smith, Rick Grehan or Tom Yager + * ben@bytepb.byte.com rick_g@bytepb.byte.com tyager@bytepb.byte.com + * + ******************************************************************************* + * Modification Log: + * $Header: hanoi.c,v 3.5 87/08/06 08:11:14 kenj Exp $ + * August 28, 1990 - Modified timing routines (ty) + * + ******************************************************************************/ + +#define VERBOSE +/*#define USECMDLINE*/ + +#include +#include + +unsigned short iter = 0; /* number of iterations */ +char num[4]; +long cnt; + +int disk=5, /* default number of disks */ + duration=10; /* default time to run test */ + +void mov(unsigned char n,unsigned char f,unsigned char t) +{ +char o; + + if(n == 1) + { + num[f]--; + num[t]++; + } + else + { + o = (6-(f+t)); + mov(n-1,f,o); + mov(1,f,t); + mov(n-1,o,t); + } + + #ifdef VERBOSE + printf("%2d: %2d %2d %2d %2d\n", + (int)iter,(int)num[0],(int)num[1],(int)num[2],(int)num[3]); + #endif +} + +int main(int argc,char **argv) +{ + #ifdef USECMDLINE + if (argc < 2) { + printf("Usage: %s [duration] [disks]\n", argv[0]); + exit(1); + } + else + { + if(argc > 1) duration = atoi(argv[1]); + if(argc > 2) disk = atoi(argv[2]); + } + #endif + + printf("towers of hanoi\ndisks: %d\n\n",disk); + + num[1] = disk; + + #ifdef VERBOSE + printf("%2d: %2d %2d %2d %2d\n", + (int)iter,(int)num[0],(int)num[1],(int)num[2],(int)num[3]); + #endif + + while(num[3] +#include + +void t1a(void) +{ + int a = -0x5000; + + printf(a < 0x5000 ? "ok\n" : "error\n"); +} + +void t1b(void) +{ + int a = -0x5000; + + if(a<0x5000) + { + printf("ok\n"); + } + else + { + printf("error\n"); + } +} + +int main(void) +{ + t1a();t1b(); + + return 0; +} diff --git a/test/ref/incr.c b/test/ref/incr.c new file mode 100644 index 000000000..adce0e1c0 --- /dev/null +++ b/test/ref/incr.c @@ -0,0 +1,51 @@ +/* + !!DESCRIPTION!! increment/decrement + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +#include + +int main(void) +{ + printf("disassemble this program to check the generated code.\n"); + return 0; +} + +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; +} diff --git a/test/ref/init.c b/test/ref/init.c new file mode 100644 index 000000000..dc3f28a81 --- /dev/null +++ b/test/ref/init.c @@ -0,0 +1,94 @@ +/* + !!DESCRIPTION!! variable initialization + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +/* todo: add back conditional stuff here ! */ + +typedef struct { int codes[3]; char name[6]; } Word; + +#ifdef NO_IMPLICIT_FUNC_PROTOTYPES + +#ifdef NO_OLD_FUNC_DECL +f(); +void g(Word *p); +h(); +#else +f(); +g(); +h(); +#endif + +#endif + +/* +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; +*/ + +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 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); +} + +#ifdef NO_OLD_FUNC_DECL +void g(Word *p) +#else +g(p) +Word *p; +#endif +{ + 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]); +} diff --git a/test/ref/limits.c b/test/ref/limits.c new file mode 100644 index 000000000..613d6bd09 --- /dev/null +++ b/test/ref/limits.c @@ -0,0 +1,56 @@ +/* + !!DESCRIPTION!! display type limits + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +#include +#include + +#define SSHRT_MAX SHRT_MAX +#define SINT_MAX INT_MAX +#define SLONG_MAX LONG_MAX + +#define UCHAR_MIN 0 +#define USHRT_MIN 0 +#define SSHRT_MIN SHRT_MIN +#define UINT_MIN 0 +#define SINT_MIN INT_MIN +#define ULONG_MIN 0l +#define SLONG_MIN LONG_MIN + +int main(void) { + printf("CHAR_MAX: 0x%08x=%d\n", CHAR_MAX, CHAR_MAX); + printf("UCHAR_MAX: 0x%08x=%d\n", UCHAR_MAX, UCHAR_MAX); + printf("SCHAR_MAX: 0x%08x=%d\n", SCHAR_MAX, SCHAR_MAX); + + printf("SHRT_MAX: 0x%08x=%d\n", SHRT_MAX, SHRT_MAX); + printf("USHRT_MAX: 0x%08x=%d\n", USHRT_MAX, USHRT_MAX); + printf("SSHRT_MAX: 0x%08x=%d\n", SSHRT_MAX, SSHRT_MAX); + + printf("INT_MAX: 0x%08x=%d\n", INT_MAX, INT_MAX); + printf("UINT_MAX: 0x%08x=%d\n", UINT_MAX, UINT_MAX); + printf("SINT_MAX: 0x%08x=%d\n", SINT_MAX, SINT_MAX); + + printf("LONG_MAX: 0x%08lx=%ld\n", LONG_MAX, LONG_MAX); + printf("ULONG_MAX: 0x%08lx=%ld\n", ULONG_MAX, ULONG_MAX); + printf("SLONG_MAX: 0x%08lx=%ld\n", SLONG_MAX, SLONG_MAX); + + printf("CHAR_MIN: 0x%08x=%d\n", CHAR_MIN, CHAR_MIN); + printf("UCHAR_MIN: 0x%08x=%d\n", UCHAR_MIN, UCHAR_MIN); + printf("SCHAR_MIN: 0x%08x=%d\n", SCHAR_MIN, SCHAR_MIN); + + printf("SHRT_MIN: 0x%08x=%d\n", SHRT_MIN, SHRT_MIN); + printf("USHRT_MIN: 0x%08x=%d\n", USHRT_MIN, USHRT_MIN); + printf("SSHRT_MIN: 0x%08x=%d\n", SSHRT_MIN, SSHRT_MIN); + + printf("INT_MIN: 0x%08x=%d\n", INT_MIN, INT_MIN); + printf("UINT_MIN: 0x%08x=%d\n", UINT_MIN, UINT_MIN); + printf("SINT_MIN: 0x%08x=%d\n", SINT_MIN, SINT_MIN); + + printf("LONG_MIN: 0x%08lx=%ld\n", LONG_MIN, LONG_MIN); + printf("ULONG_MIN: 0x%08lx=%ld\n", ULONG_MIN, ULONG_MIN); + printf("SLONG_MIN: 0x%08lx=%ld\n", SLONG_MIN, SLONG_MIN); + + return 0; +} diff --git a/test/ref/macro.c b/test/ref/macro.c new file mode 100644 index 000000000..1650b98db --- /dev/null +++ b/test/ref/macro.c @@ -0,0 +1,30 @@ +/* + !!DESCRIPTION!! macro bug test program + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Groepaz/Hitmen +*/ + +#include +#include + +unsigned long fs=7; +unsigned long fd=5; +unsigned long a=3; + +unsigned long _func(unsigned long x,unsigned long y) +{ + printf("x:%ld y:%ld\n",x,y); + return 0; +} + +#define func(x,y) _func(x,y) + +int main(void) +{ + fs= func( (fd/a) , func(2,0x0082c90f) ); + printf("fs:%ld\n",fs); + fs=_func( (fd/a) , _func(2,0x0082c90f) ); + printf("fs:%ld\n",fs); + return 0; +} diff --git a/test/ref/mandel.c b/test/ref/mandel.c new file mode 100644 index 000000000..6c21151f9 --- /dev/null +++ b/test/ref/mandel.c @@ -0,0 +1,84 @@ +/* + !!DESCRIPTION!! mandelbrot test program + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Groepaz/Hitmen +*/ + +#include +#include + +static unsigned short SCREEN_X; +static unsigned char SCREEN_Y; + +#define MAXCOL 8 + +#define maxiterations 16 + +#define fpshift (12) + +#define tofp(_x) ((_x)<>fpshift) +#define fpabs(_x) (abs(_x)) + +#define mulfp(_a,_b) ((((signed long)_a)*(_b))>>fpshift) +#define divfp(_a,_b) ((((signed long)_a)<>(fpshift-1))+yy; + r=r1; + } + if(count==maxiterations) + { + printf(" "); + } + else + { + printf("%c",dither[(count%MAXCOL)]); + } + } + printf("\n"); + } +} + +int main (void) +{ + SCREEN_X = 80; + SCREEN_Y = 40; + + /* calc mandelbrot set */ + mandelbrot(tofp(-2),tofp(-2),tofp(2),tofp(2)); + + /* Done */ + return 0; +} + diff --git a/test/ref/minimal.c b/test/ref/minimal.c new file mode 100644 index 000000000..5aa3c5f4f --- /dev/null +++ b/test/ref/minimal.c @@ -0,0 +1,14 @@ +/* + !!DESCRIPTION!! minimal Program, checks if the Compiler and testsuite framework works + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Groepaz/Hitmen +*/ + +int main(void) +{ +#if 1 + printf("it works :)\n"); +#endif + return 0; +} diff --git a/test/ref/otccex.c b/test/ref/otccex.c new file mode 100644 index 000000000..a967e4805 --- /dev/null +++ b/test/ref/otccex.c @@ -0,0 +1,148 @@ +/* + !!DESCRIPTION!! OTCC Example (simple K&R Style) + !!ORIGIN!! OTCC + !!LICENCE!! GPL (?), read COPYING.GPL +*/ + +/* + * Sample OTCC C example. You can uncomment the first line and install + * otcc in /usr/local/bin to make otcc scripts ! + */ + +/* Any preprocessor directive except #define are ignored. We put this + include so that a standard C compiler can compile this code too. */ +#include +#include + +/* defines are handled, but macro arguments cannot be given. No + recursive defines are tolerated */ +#define DEFAULT_BASE 10 + +#ifdef NO_IMPLICIT_FUNC_PROTOTYPES +help(char *name); +#endif + +/* + * Only old style K&R prototypes are parsed. Only int arguments are + * allowed (implicit types). + * + * By benchmarking the execution time of this function (for example + * for fib(35)), you'll notice that OTCC is quite fast because it + * generates native i386 machine code. + */ +fib(n) +{ + printf("[fib(%d)]", n); + if (n <= 2) + return 1; + else + return fib(n-1) + fib(n-2); +} + +/* Identifiers are parsed the same way as C: begins with letter or + '_', and then letters, '_' or digits */ +long fact(n) +{ + /* local variables can be declared. Only 'int' type is supported */ + int i; + long r; + r = 1; + /* 'while' and 'for' loops are supported */ + for(i=2;i<=n;i++) + r = r * i; + return r; +} + +/* Well, we could use printf, but it would be too easy */ +print_num(long n,int b) +{ + int tab, p, c; + /* Numbers can be entered in decimal, hexadecimal ('0x' prefix) and + octal ('0' prefix) */ + /* more complex programs use malloc */ + tab = malloc(0x100); + p = tab; + while (1) { + c = n % b; + /* Character constants can be used */ + if (c >= 10) + c = c + 'a' - 10; + else + c = c + '0'; + *(char *)p = c; + p++; + n = n / b; + /* 'break' is supported */ + if (n == 0) + break; + } + while (p != tab) { + p--; + printf("%c", *(char *)p); + } + free(tab); +} + +/* 'main' takes standard 'argc' and 'argv' parameters */ +mymain(int argc,char **argv) +{ + /* no local name space is supported, but local variables ARE + supported. As long as you do not use a globally defined + variable name as local variable (which is a bad habbit), you + won't have any problem */ + int s, n, f, base; + + + /* && and || operator have the same semantics as C (left to right + evaluation and early exit) */ + if (argc != 2 && argc != 3) { + /* '*' operator is supported with explicit casting to 'int *', + 'char *' or 'int (*)()' (function pointer). Of course, 'int' + are supposed to be used as pointers too. */ + s = *(int *)argv; + help(s); + return 1; + } + /* Any libc function can be used because OTCC uses dynamic linking */ + n = atoi(argv[1]); + base = DEFAULT_BASE; + if (argc >= 3) { + base = atoi(argv[2]); + if (base < 2 || base > 36) { + /* external variables can be used too (here: 'stderr') */ + fprintf(stdout, "Invalid base\n"); + return 1; + } + } + printf("fib(%d) =\n", n); + print_num(fib(n), base); + printf("\n"); + + printf("fact(%d) = ", n); + if (n > 12) { + printf("Overflow"); + } else { + /* why not using a function pointer ? */ + f = &fact; + print_num((*(long (*)())f)(n), base); + } + printf("\n"); + return 0; +} + +/* functions can be used before being defined */ +help(char *name) +{ + printf("usage: %s n [base]\n", name); + printf("Compute fib(n) and fact(n) and output the result in base 'base'\n"); +} + +int main(void) +{ + char *argv[3]; + argv[0]=""; + argv[1]="10"; /* n */ + argv[2]="8"; /* base */ + mymain(3, argv); + return 0; +} \ No newline at end of file diff --git a/test/ref/paranoia.c b/test/ref/paranoia.c new file mode 100644 index 000000000..3616c9391 --- /dev/null +++ b/test/ref/paranoia.c @@ -0,0 +1,2216 @@ +/* + !!DESCRIPTION!! a wellknown floating point test + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +#ifdef NO_FLOATS + +main() +{ + printf("NO_FLOATS\n\r"); +} + +#else + +#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 +#ifndef NOSIGNAL +#include +#endif +#include + +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); +} + +#endif /* NO_FLOATS */ diff --git a/test/ref/pointer2.c b/test/ref/pointer2.c new file mode 100644 index 000000000..69d04a989 --- /dev/null +++ b/test/ref/pointer2.c @@ -0,0 +1,111 @@ +/* + !!DESCRIPTION!! pointer test + !!ORIGIN!! + !!LICENCE!! public domain +*/ + +#include + +/* + check behaviour on incompletely declared arrays +*/ + +char i1[]; + +void test1(void) { +int a; + + a=sizeof(i1[0]); + printf("%04x - ",a); + if(sizeof(i1[0])==sizeof(char)) { + /* gcc gives size of element */ + printf("sizeof(i1[0]) gives size of element\n"); + } + if(sizeof(i1[0])==sizeof(char*)) { + printf("sizeof(i1[0]) gives size of pointer to element\n"); + } +} + +/* + check behaviour on string init +*/ + +char t1[]="abcde"; +char t2[]={"abcde"}; + +char *t3="abcde"; +char *t4={"abcde"}; + +void test2(void) { +char c1,c2,c3,c4; +int i,e=0; + for(i=0;i<5;i++){ + c1=t1[i];c2=t2[i];c3=t3[i];c4=t4[i]; +/* printf("%02x %02x %02x %02x\n",c1,c2,c3,c4); */ + printf("%c %c %c %c\n",c1,c2,c3,c4); + if(!((c1==c2)&(c1==c3)&(c1==c4))) e=1; + } + if(e) printf("test2 failed.\n"); + else printf("test2 ok.\n"); +} + +/* + check behaviour on extern-declarations inside functions +*/ + +typedef struct { + char *name; + void *func; +} A3; + +#ifdef NO_SLOPPY_STRUCT_INIT +A3 a3[] = { + { "test3", (void*) NULL }, + { "test3", (void*) NULL }, +}; +#else +/*gcc warning: missing braces around initializer (near initialization for `a3[0]') + this type of struct-initialization seems to be kinda common */ +A3 a3[] = { + "test3", (void*) NULL , + "test3", (void*) NULL , +}; +#endif + +void test3a(A3 *list, int number){ + printf("%s %d\n",list->name,number); +} + +static void test31(void) +{ + extern A3 a3[]; + test3a(a3, -1); +} + +#if 0 +/* this variation compiles and works with cc65, but gives an error with gcc :=P */ +static void test32(void) +{ + extern A3 *a3; + test3a(a3, -1); +} +#endif + +static void test30(void) +{ + test3a(a3, -1); +} + +/* + todo: add test on function pointers in the form of (*func)(arg) ... + cc65 seems to have problems here aswell ;/ +*/ + +int main(void) { + test1(); + test2(); + test30(); + test31(); +/* test32(); */ + return 0; +} diff --git a/test/ref/return.c b/test/ref/return.c new file mode 100644 index 000000000..0ea12d509 --- /dev/null +++ b/test/ref/return.c @@ -0,0 +1,96 @@ +/* + !!DESCRIPTION!! return values, implicit type conversion on return + !!ORIGIN!! cc65 devel list + !!LICENCE!! Public Domain +*/ + +#include +#include + +unsigned char val_char=0x76; +unsigned int val_int=0x5678; +unsigned long val_long=0x12345678; + +int test1_int_char(void) +{ + return val_char; +} +int test1_int_int(void) +{ + return val_int; +} + +int test2_int_char(void) +{ + return (int)val_char; +} +int test2_int_int(void) +{ + return (int)val_int; +} + +long test1_long_char(void) +{ + return val_char; +} +long test1_long_int(void) +{ + return val_int; +} +long test1_long_long(void) +{ + return val_long; +} + +long test2_long_char(void) +{ + return (long)val_char; +} +long test2_long_int(void) +{ + return (long)val_int; +} +long test2_long_long(void) +{ + return (long)val_long; +} + +#define dotest(_n,_a,_v) \ + _n=_a; \ + printf("%04lx %04lx,",(unsigned long)_n,(unsigned long)_v); \ + if(_n!=_v) printf("failed\n"); \ + else printf("ok\n") + +int main(void) +{ +int i; +unsigned long l; + + printf("\nwithout cast:\n"); + + printf("return int\n"); + + dotest(i,test1_int_char(),0x76); + dotest(i,test1_int_int(),0x5678); + + printf("return long\n"); + + dotest(l,test1_long_char(),0x76); + dotest(l,test1_long_int(),0x5678); + dotest(l,test1_long_long(),0x12345678); + + printf("\nwith cast:\n"); + + printf("return int\n"); + + dotest(i,test2_int_char(),0x76); + dotest(i,test2_int_int(),0x5678); + + printf("return long\n"); + + dotest(l,test2_long_char(),0x76); + dotest(l,test2_long_int(),0x5678); + dotest(l,test2_long_long(),0x12345678); + + return 0; +} diff --git a/test/ref/sort.c b/test/ref/sort.c new file mode 100644 index 000000000..5db5cf01b --- /dev/null +++ b/test/ref/sort.c @@ -0,0 +1,75 @@ +/* + !!DESCRIPTION!! simple quicksort, tests recursion + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +#include +#include + +int in[] = {10, 32, -1, 567, 3, 18, 1, -51, 789, 0}; +int *xx; + +/* exchange - exchange *x and *y */ +exchange(int *x,int *y) { +int t; + + printf("exchange(%d,%d)\n", x - xx, y - xx); + t = *x; *x = *y; *y = t; +} + +/* partition - partition a[i..j] */ +int partition(int a[], int i, int j) { +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; +} + +/* quick - quicksort a[lb..ub] */ +void quick(int a[], int lb, int ub) { + int k; + + if (lb >= ub) + return; + k = partition(a, lb, ub); + quick(a, lb, k - 1); + quick(a, k + 1, ub); +} + +/* sort - sort a[0..n-1] into increasing order */ +sort(int a[], int n) { + quick(xx = a, 0, --n); +} + +/* putd - output decimal number */ +void putd(int n) { + if (n < 0) { + putchar('-'); + n = -n; + } + if (n/10) + putd(n/10); + putchar(n%10 + '0'); +} + +int main(void) { + 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; +} + diff --git a/test/ref/spill.c b/test/ref/spill.c new file mode 100644 index 000000000..2aedf0c8c --- /dev/null +++ b/test/ref/spill.c @@ -0,0 +1,55 @@ +/* + !!DESCRIPTION!! register spilling + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +#include + +int main(void) +{ + printf("disassemble this program to check the generated code.\n"); + return 0; +} + +#ifdef NO_EMPTY_FUNC_ARGS + f(i){return i+i;} + f2(i){return f(i)+(i?f(i):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(i):0; + } +#else + 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; + } +#endif + +#ifdef NO_FLOATS + signed a[10],b[10]; +#else + double a[10],b[10]; +#endif + +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; +#ifdef NO_FLOATS + signed *A, *B, x; +#else + double *A, *B, x; +#endif + +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]; +} diff --git a/test/ref/stdarg.c b/test/ref/stdarg.c new file mode 100644 index 000000000..b476cf338 --- /dev/null +++ b/test/ref/stdarg.c @@ -0,0 +1,93 @@ +/* + !!DESCRIPTION!! variable argument lists + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +#include + +#ifndef NO_FUNCS_TAKE_STRUCTS +struct node +{ + int a[4]; +} x = +{ +#ifdef NO_SLOPPY_STRUCT_INIT + { +#endif + 1,2,3,4 +#ifdef NO_SLOPPY_STRUCT_INIT + } +#endif +}; +#endif + +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'); + #ifdef NO_FLOATS + print("%s%s %f%c", "te", "st", (signed long) 5, '\n'); + #else + print("%s%s %f%c", "te", "st", 5.0, '\n'); + #endif + #ifndef NO_FUNCS_TAKE_STRUCTS + print("%b %b %b %b %b %b\n", x, x, x, x, x, x); + #endif + return 0; +} + +print(char *fmt, ...) { + va_list ap; + va_start(ap, fmt); + for (; *fmt; fmt++) + { + if (*fmt == '%') + switch (*++fmt) { + case 'b': { + #ifdef NO_FUNCS_TAKE_STRUCTS + printf("(1 2 3 4)"); + #else + 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]); + #endif + break; + } + case 'c': + /* printf("%c", va_arg(ap, char)); */ + printf("%c", va_arg(ap, int)); + break; + case 'd': + printf("%d", va_arg(ap, int)); + break; + case 'w': + /* printf("%x", va_arg(ap, short)); */ + printf("%x", va_arg(ap, int)); + break; + case 's': + printf("%s", va_arg(ap, char *)); + break; + case 'f': + #ifdef NO_FLOATS + printf("%ld.000000", va_arg(ap, signed long)); + #else + printf("%f", va_arg(ap, double)); + #endif + break; + default: + printf("%c", *fmt); + break; + } + else + printf("%c", *fmt); + } + va_end(ap); +} diff --git a/test/ref/strptr.c b/test/ref/strptr.c new file mode 100644 index 000000000..8bfa983a8 --- /dev/null +++ b/test/ref/strptr.c @@ -0,0 +1,130 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Groepaz/Hitmen +*/ + +/* + this test reproduces a bug that prevented the testsuites directory + reading stuff for the c64 from working before. the bug appears to + only occur when optimizations are enabled. it also disappears if + the buffers inside the readdir function are declared static or + made global. +*/ + +/*#define STANDALONE*/ + +#ifdef STANDALONE + +FILE *outfile=NULL; +#define OPENTEST() outfile=stdout; +#define CLOSETEST() + +#else + +#endif + +#include +#include +#include +#include + +#define XNAME_MAX 16 + +struct Xdirent +{ + char d_name[XNAME_MAX+1]; + unsigned short d_off; + unsigned short d_reclen; + unsigned char d_type; + unsigned char d_namlen; +}; + +typedef struct +{ + unsigned char fd; + unsigned short off; + char name[XNAME_MAX+1]; +} XDIR; + +unsigned char b1[4]; +unsigned char b2[0x10]={" \"test\" "}; + +struct Xdirent *Xreaddir(XDIR *dir) +{ +unsigned char buffer[0x40]; +unsigned char temp; +unsigned char i,ii; + +static struct Xdirent entry; +unsigned char fd; +static unsigned char ch; + + entry.d_off=dir->off; + + /* basic line-link / file-length */ + memcpy(buffer,b1,4); + + dir->off=dir->off+4; + entry.d_reclen=254*(buffer[2]+(buffer[3]<<8)); + + /* read file entry */ + memcpy(buffer,b2,0x10); + + dir->off=dir->off+i; + + printf("Xreaddir: '%s'\n",buffer); + + /* skip until either quote (file) or b (blocks free => end) */ + i=0;ii=0; + while(i==0){ + temp=buffer[ii];ii++; + if(ii>16){ + /* something went wrong...this shouldnt happen! */ + return(NULL); + } + else if(temp=='\"') i++; + else if(temp=='b') { + /* "blocks free" */ + return(NULL); + } + } + printf("Xreaddir: '%s'\n",buffer); + + /* process file entry */ + + i=0; temp=buffer[ii];ii++; + while(temp!='\"'){ + entry.d_name[i]=temp; + i++; + temp=buffer[ii];ii++; + } + entry.d_name[i]=0; + entry.d_namlen=i; + + /* set type flag */ + + return(&entry); +} + +int main(void) +{ +char mydirname[XNAME_MAX+1]="."; +XDIR mydir; +struct Xdirent *mydirent; + + printf("start\n"); + + if((mydirent=Xreaddir(&mydir))==NULL) + { + printf("NULL\n"); + } + else + { + printf("=%s\n",mydirent->d_name); + } + printf("done\n"); + + return 0; +} diff --git a/test/ref/struct.c b/test/ref/struct.c new file mode 100644 index 000000000..ccd74953f --- /dev/null +++ b/test/ref/struct.c @@ -0,0 +1,261 @@ +/* + !!DESCRIPTION!! structs + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +typedef struct point { int x,y; } point; +typedef struct rect { point pt1, pt2; } rect; + +#define min(a, b) ((a) < (b) ? (a) : (b)) +#define max(a, b) ((a) > (b) ? (a) : (b)) + +#ifdef NO_FUNCS_RETURN_STRUCTS +# ifdef NO_FUNCS_TAKE_STRUCTS +/* canonicalize rectangle coordinates */ +void canonrect(rect *d,rect *r) { + d->pt1.x = min(r->pt1.x, r->pt2.x); + d->pt1.y = min(r->pt1.y, r->pt2.y); + d->pt2.x = max(r->pt1.x, r->pt2.x); + d->pt2.y = max(r->pt1.y, r->pt2.y); +} +/* add two points */ +void addpoint(point *p, point *p1, point *p2) { + p->x= p1->x + p2->x; + p->y= p1->y + p2->y; +} +/* make a point from x and y components */ +void makepoint(point *p,int x, int y) { + p->x = x; + p->y = y; +} +/* make a rectangle from two points */ +void makerect(rect *d,point *p1, point *p2) { +rect r; + r.pt1.x = p1->x; + r.pt1.y = p1->y; + r.pt2.x = p2->x; + r.pt2.y = p2->y; + + canonrect(d,&r); +} + +#ifdef NO_SLOPPY_STRUCT_INIT +struct odd {char a[3]; } y = {{'a', 'b', 0 }}; +#else +struct odd {char a[3]; } y = {'a', 'b', 0}; +#endif + +odd(struct odd *y) { + struct odd *x = y; + printf("%s\n\r", x->a); +} + +# else /* FUNCS_TAKE_STRUCTS */ +/* canonicalize rectangle coordinates */ +void canonrect(rect *d,rect r) { + d->pt1.x = min(r.pt1.x, r.pt2.x); + d->pt1.y = min(r.pt1.y, r.pt2.y); + d->pt2.x = max(r.pt1.x, r.pt2.x); + d->pt2.y = max(r.pt1.y, r.pt2.y); +} +/* add two points */ +void addpoint(point *p, point p1, point p2) { + p->x= p1.x + p2.x; + p->y= p1.y + p2.y; +} +/* make a point from x and y components */ +void makepoint(point *p,int x, int y) { + p->x = x; + p->y = y; +} +/* make a rectangle from two points */ +void makerect(rect *d,point p1, point p2) { +rect r; + r.pt1 = p1; + r.pt2 = p2; + + canonrect(d,r); +} + +#ifdef NO_SLOPPY_STRUCT_INIT +struct odd {char a[3]; } y = {{'a', 'b', 0}}; +#else +struct odd {char a[3]; } y = {'a', 'b', 0}; +#endif + +odd(struct odd y) { + struct odd x = y; + printf("%s\n\r", x.a); +} + +# endif /* FUNCS_TAKE_STRUCTS */ + +#else /* FUNCS_RETURN_STRUCTS */ + +/* add two points */ +point addpoint(point p1, point p2) { + p1.x += p2.x; + p1.y += p2.y; + return p1; +} +/* canonicalize rectangle coordinates */ +rect canonrect(rect r) { + 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; +} +/* make a point from x and y components */ +point makepoint(int x, int y) { + point p; + + p.x = x; + p.y = y; + return p; +} + +/* make a rectangle from two points */ +rect makerect(point p1, point p2) { + rect r; + + r.pt1 = p1; + r.pt2 = p2; + return canonrect(r); +} + +struct odd {char a[3]; } y = +{ +#ifdef NO_SLOPPY_STRUCT_INIT + { +#endif + 'a', 'b', 0 +#ifdef NO_SLOPPY_STRUCT_INIT + } +#endif +}; + +odd(struct odd y) +{ + struct odd x + = y; + printf("%s\n\r", x.a); +} + +#endif + +/* is p in r? */ +# ifdef NO_FUNCS_TAKE_STRUCTS +int ptinrect(point *p, rect *r) { + return p->x >= r->pt1.x && p->x < r->pt2.x + && p->y >= r->pt1.y && p->y < r->pt2.y; +} +#else +int ptinrect(point p, rect r) { + return p.x >= r.pt1.x && p.x < r.pt2.x + && p.y >= r.pt1.y && p.y < r.pt2.y; +} +#endif + +#ifdef NO_FUNCS_RETURN_STRUCTS + +#ifdef NO_LOCAL_STRUCT_INIT +#ifdef NO_SLOPPY_STRUCT_INIT +point pts[] = { {-1, -1},{ 1, 1},{ 20, 300},{ 500, 400 } }; +#else +point pts[] = { -1, -1, 1, 1, 20, 300, 500, 400 }; +#endif +point origin = { 0, 0 }; +point maxpt = { 320, 320 }; +#endif + +main() { +int i; +point x; +rect screen; +#ifndef NO_LOCAL_STRUCT_INIT +point origin = { 0, 0 }; +point maxpt = { 320, 320 }; +#ifdef NO_SLOPPY_STRUCT_INIT +point pts[] = { {-1, -1},{ 1, 1},{ 20, 300},{ 500, 400 } }; +#else +point pts[] = { -1, -1, 1, 1, 20, 300, 500, 400 }; +#endif +#endif + + makepoint ( &x, -10, -10); +#ifdef NO_FUNCS_TAKE_STRUCTS + addpoint ( &maxpt, &maxpt, &x); +#else + addpoint ( &maxpt, maxpt, x); +#endif + makepoint ( &x, 10, 10); + +#ifdef NO_FUNCS_TAKE_STRUCTS + addpoint (&origin,&origin, &x); + makerect (&screen, &maxpt,&origin); +#else + addpoint (&origin,origin, x); + makerect (&screen, maxpt,origin); +#endif + + for (i = 0; i < sizeof pts/sizeof pts[0]; i++) { + makepoint(&x,pts[i].x, pts[i].y); + printf("(%d,%d) is ", pts[i].x, x.y); +#ifdef NO_FUNCS_TAKE_STRUCTS + if (ptinrect(&x, &screen) == 0) +#else + if (ptinrect(x, screen) == 0) +#endif + { + printf("not "); + } + printf("within (%d,%d; %d,%d)\n\r", screen.pt1.x, screen.pt1.y, + screen.pt2.x, screen.pt2.y); + } +#ifdef NO_FUNCS_TAKE_STRUCTS + odd(&y); +#else + odd(y); +#endif + + return 0; +} + +#else /* FUNCS_RETURN_STRUCTS */ + +main() { +int i; +point x, origin = { 0, 0 }, maxpt = { 320, 320 }; + +#ifdef NO_SLOPPY_STRUCT_INIT +point pts[] = { {-1, -1}, {1, 1}, {20, 300}, {500, 400} }; +#else +point pts[] = { -1, -1, 1, 1, 20, 300, 500, 400 }; +#endif + +rect screen = + makerect( + addpoint(maxpt, makepoint(-10, -10)), + addpoint(origin, makepoint(10, 10)) + ); + + test1(); + + 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\r", screen.pt1.x, screen.pt1.y, + screen.pt2.x, screen.pt2.y); + } + odd(y); + + return 0; +} + +#endif /* FUNCS_RETURN_STRUCTS */ diff --git a/test/ref/switch.c b/test/ref/switch.c new file mode 100644 index 000000000..1fc315d90 --- /dev/null +++ b/test/ref/switch.c @@ -0,0 +1,216 @@ +/* + !!DESCRIPTION!! switch statement + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +#include + +#ifdef NO_IMPLICIT_FUNC_PROTOTYPES +testbig(); +testbackslash(); +backslash(int c); +f(); +g(); +h(); +limit(); + +big( +# ifdef ASSUME_32BIT_UNSIGNED + unsigned +# else + unsigned long +# endif +x); + +#endif + +main() +{ + testbackslash(); + f(); + g(); + h(); + testbig(); /* ! broken long int compare (?) */ + limit(); /* ! broken long int compare (?) */ + + return 0; +} + +testbig() +{ + #ifdef ASSUME_32BIT_INT + int i; + #else + signed long i; + #endif + /* 2341234 2341234 2341234 */ + for (i = 0x1000000; i&0x7000000; i += 0x1000000) { +/* printf("i = 0x%lx\n", i); */ + big(i); + } +} + +#ifdef NO_LOCAL_STRING_INIT +/* static char _s[8]={"bfnrtvx"}; */ + static char _s[8]="bfnrtvx"; +#endif + +testbackslash() +{ + char *s; + +#ifdef NO_STRINGS_IN_FOR +# ifndef NO_LOCAL_STRING_INIT + char _s[8]={"bfnrtvx"}; +# endif + for (s=_s; *s; s++) { +#else + for (s = "bfnrtvx"; *s; s++) { +#endif + printf("%c = %c\n", *s, backslash(*s)); + } +} + +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 'x'; +} + +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); +} + +#ifdef NO_OLD_FUNC_DECL + big( +#else + big(x) +#endif + +# ifdef ASSUME_32BIT_UNSIGNED + unsigned +# else + unsigned long +# endif + +#ifdef NO_OLD_FUNC_DECL + x) { +#else + x; { +#endif + +/* printf("x = 0x%x\n", x); */ + + switch(x&0x6000000){ + case -1: + case -2: + case 0x0000000: + printf("x = 0x%lx\n", x); break; + case 0x2000000: + printf("x = 0x%lx\n", x); break; + case 0x4000000: + printf("x = 0x%lx\n", x); break; + default: + printf("x = 0x%lx (default)\n", x); break; + } +} + +limit() { + int i; + + for (i = INT_MIN; i <= INT_MIN+5; i++) +/* for (i = INT_MIN; i < INT_MIN+6; 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; + } +} diff --git a/test/ref/switch2.c b/test/ref/switch2.c new file mode 100644 index 000000000..e75cfe71e --- /dev/null +++ b/test/ref/switch2.c @@ -0,0 +1,262 @@ +/* + !!DESCRIPTION!! switch test + !!ORIGIN!! + !!LICENCE!! public domain +*/ + +/*#define STANDALONE*/ + +#include + +void testlimits(int i) { + printf("%d:",i); + + switch(i) { + case -1: /* works */ + /* case 0xffff: */ /* 'range error' (-1) */ + + printf("-1\n"); + break; + /* max int */ + +/* case 0x7fff: */ /* works */ + case 32767: /* works */ + /* case 32768: */ /* 'range error' (correct for that one!) */ + + printf("max\n"); + break; + /* min int */ + + case -32768: /* 'warning. constant is long' */ + /* case 0x8000: */ /* 'range error' */ + /* case -32769: */ /* 'range error' (correct for that one!) */ + printf("min\n"); + break; + } + printf("\n"); +} + +void testdefault1(unsigned char i) { +/* we want a signed char */ +#ifdef REFCC + +#ifdef REFCC_UNSIGNED_CHARS +signed char k; +#else +char k; +#endif + +#else + +#ifdef UNSIGNED_CHARS +signed char k; +#else +char k; +#endif + +#endif + + for(;i<254;) { + k = i; + printf(">%d\n",i);i++; + switch(k) { + case 1: + break; + case 2: + break; + case 3: + break; + case 4: + break; + case 5: + break; + case 6: + break; + case 7: + break; + case 8: + break; + case 9: + break; + case 10: + break; + case 11: + break; + case 12: + break; + case 13: + break; + case 14: + break; + case 15: + break; + case 17: + break; + /* triggers bug ? */ + /* gcc warning: case label value exceeds maximum value for type */ + /* cc65 error: range error */ + + /* + case 170: + break; + */ + case 18: + break; + case 19: + break; + case 20: + break; + case 21: + break; + case 22: + break; + case 23: + break; + case 24: + switch(k) { + case 1: + break; + case 2: + break; + case 3: + break; + case 4: + case 5: + break; + case 6: + case 7: + break; + case 8: + case 9: + break; + } + break; + case 100: + break; + default: + printf(">>>default\n"); + /* triggers bug if this break; is missing? */ + /* break; */ + } + } +} + +void testdefault2(unsigned char i) { +/* we want a unsigned char */ +#ifdef REFCC + +#ifdef REFCC_UNSIGNED_CHARS +char k; +#else +unsigned char k; +#endif + +#else + +#ifdef UNSIGNED_CHARS +char k; +#else +unsigned char k; +#endif + +#endif + + for(;i<254;) { + k = i; + printf(">%d\n",i);i++; + switch(k) { + case 1: + break; + case 2: + break; + case 3: + break; + case 4: + break; + case 5: + break; + case 6: + break; + case 7: + break; + case 8: + break; + case 9: + break; + case 10: + break; + case 11: + break; + case 12: + break; + case 13: + break; + case 14: + break; + case 15: + break; + case 17: + break; + /* triggers bug ? */ + + case 170: + break; + + case 18: + break; + case 19: + break; + case 20: + break; + case 21: + break; + case 22: + break; + case 23: + break; + case 24: + switch(k) { + case 1: + break; + case 2: + break; + case 3: + break; + case 4: + case 5: + break; + case 6: + case 7: + break; + case 8: + case 9: + break; + } + break; + case 100: + break; + default: + printf(">>>default\n"); + /* triggers bug if this break; is missing? */ + /* break; */ + } + } +} + +int main(void) { + testlimits(32767); + testlimits(-32768); + testlimits(-1); + + testdefault1(1); + testdefault1(2); + testdefault1(3); + testdefault1(4); + + testdefault2(1); + testdefault2(2); + testdefault2(3); + testdefault2(4); + + return 0; +} diff --git a/test/ref/varargs.c b/test/ref/varargs.c new file mode 100644 index 000000000..11fd33b38 --- /dev/null +++ b/test/ref/varargs.c @@ -0,0 +1,105 @@ +/* + !!DESCRIPTION!! varargs test + !!ORIGIN!! + !!LICENCE!! public domain +*/ + +#include +#include +#include + +void chk0(char *format,...); +void chk1(int fd,char *format,...); + +#if 0 +// old workaround for broken varargs + +void chk0(char *format,...){ + __asm__ ("pha"); // save argument size + { +//va_list ap; +char *ap; +char *_format; +static char string[0x100]; + +// va_start(ap,format); + __asm__ ("pla"); // restore argument size + __asm__ ("ldx #$00"); // clear hibyte of AX + ap=__AX__; + ap+=(char*)&format; + // get value of format + ap-=2; + _format=*((char**)ap); + +// vsprintf(string,format,ap); + vsprintf(&string[0],_format,ap); + printf("format:%s,string:%s\n",_format,string); +// va_end(ap); + + } +} + +void chk1(int fd,char *format,...){ + __asm__ ("pha"); // save argument size + { +//va_list ap; +char *ap; +char *_format; +int _fd; +static char string[0x100]; + +// va_start(ap,format); + __asm__ ("pla"); // restore argument size + __asm__ ("ldx #$00"); // clear hibyte of AX + ap=__AX__; + ap+=(char*)&format; + // get value of fd + ap-=2; + _fd=*((int*)ap); + // get value of format + ap-=2; + _format=*((char**)ap); + +// vsprintf(string,format,ap); + vsprintf(&string[0],_format,ap); + printf("fd:%d,format:%s,string:%s\n",_fd,_format,string); +// va_end(ap); + + } +} + +#endif + +void chk0(char *format,...){ +va_list ap; +static char string[0x100]; + va_start(ap,format); + vsprintf(string,format,ap); + printf("format:%s,string:%s\n",format,string); + va_end(ap); +} + +void chk1(int fd,char *format,...){ +va_list ap; +static char string[0x100]; + + va_start(ap,format); + + vsprintf(string,format,ap); + printf("fd:%d,format:%s,string:%s\n",fd,format,string); + va_end(ap); +} + +int main(int argc,char **argv) { + printf("varargs test\n"); + + printf("\nchk0/0:\n");chk0("chk0 %s","arg0"); + printf("\nchk0/1:\n");chk0("chk0 %s %s","arg0","arg1"); + printf("\nchk0/2:\n");chk0("chk0 %s %s %s","arg0","arg1","arg2"); + + printf("\nchk1/0:\n");chk1(0xfd,"chk1 %s","arg0"); + printf("\nchk1/1:\n");chk1(0xfd,"chk1 %s %s","arg0","arg1"); + printf("\nchk1/2:\n");chk1(0xfd,"chk1 %s %s %s","arg0","arg1","arg2"); + + return 0; +} diff --git a/test/ref/wf1.c b/test/ref/wf1.c new file mode 100644 index 000000000..3e9c80fb2 --- /dev/null +++ b/test/ref/wf1.c @@ -0,0 +1,132 @@ +/* + !!DESCRIPTION!! print word frequencies; uses structures + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +#include +#include +#include +#include + +#define MAXWORDS 250 + +struct node +{ + int count; /* frequency count */ + struct node *left; /* left subtree */ + struct node *right; /* right subtree */ + char *word; /* word itself */ +} words[MAXWORDS]; +int next; /* index of next free entry in words */ + +/*struct node *lookup();*/ + +#if defined(NO_NEW_PROTOTYPES_FOR_OLD_FUNC_DECL) && !defined(NO_OLD_FUNC_DECL) + +#else + +int err(char *s); +int getword(char *buf); +void tprint(struct node *tree); +struct node *lookup(char *word, struct node **p); + +#endif + +int isletter(char c); + +/* err - print error message s and die */ +#ifndef NO_OLD_FUNC_DECL +err(s) char *s; { +#else +int err(char *s) { +#endif + printf("? %s\n", s); + exit(1); +} + +/* getword - get next input word into buf, return 0 on EOF */ +#ifndef NO_OLD_FUNC_DECL +int getword(buf) char *buf; +#else +int getword(char *buf) +#endif +{ + 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(char 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 */ +#ifndef NO_OLD_FUNC_DECL +struct node *lookup(word, p) +char *word; struct node **p; +#else +struct node *lookup(char *word, struct node **p) +#endif +{ + 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 >= MAXWORDS) + 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 */ +#ifndef NO_OLD_FUNC_DECL +void tprint(tree) struct node *tree; { +#else +void tprint(struct node *tree) { +#endif + if (tree) { + tprint(tree->left); + printf("%d:%s\n", tree->count, tree->word); + tprint(tree->right); + } +} + +int main(void) +{ + struct node *root; + char word[20]; + + root = 0; + next = 0; + while (getword(word)) + lookup(word, &root)->count++; + tprint(root); + + return 0; +} diff --git a/test/ref/yacc.c b/test/ref/yacc.c new file mode 100644 index 000000000..3baefd348 --- /dev/null +++ b/test/ref/yacc.c @@ -0,0 +1,996 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +/*#define STANDALONE*/ + +#ifndef YACCDBG + +#include +#include +#include + +/* +#define LEXDEBUG +#define YYDEBUG +*/ + +#endif + +/* hack the original tables to work with both petscii and ascii */ +#define CHARSETHACK + +# 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*/ +#define YYMAXDEPTH 50 +#endif +#ifndef YYSTYPE +#define YYSTYPE int +#endif +YYSTYPE yylval, yyval; +# define YYERRCODE 256 + +# 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 input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getchar())==('\n')?(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 ={stdin}, *yyout ={stdout};*/ +#define yyin infile +#define yyout outfile + +extern int yylineno; +struct yysvf +{ + struct yywork *yystoff; + struct yysvf *yyother; + int *yystops; +}; +struct yysvf *yyestate; +extern struct yysvf yysvec[], *yybgin; + +/*# define YYNEWLINE 10 */ +# define YYNEWLINE ('\n') + +#ifdef NO_IMPLICIT_FUNC_PROTOTYPES +yylook(); +int yywrap(); +yyparse(); +yyerror(char *s); +yyunput(int c); +yyoutput(int c); +yyinput(); +yyback(int *p,int m); +#endif + +#ifdef YYDEBUG +void printchar(char *name,int ch) +{ + if((ch==YYNEWLINE)) + { + fprintf(yyout," %s=YYNEWLINE\n",name); + } + else if((ch<0)||(ch>0xf0)||(!isprint(ch))) + { + fprintf(yyout," %s=%04x\n",name,ch &0xffff); + } + else + { + fprintf(yyout," %s='%c'\n",name,ch); + } +} +#endif + +yylex() +{ +int nstr; +extern int yyprevious; + +#ifdef YYDEBUG + fprintf(yyout,"yylex()\n"); +#endif + + while((nstr = yylook()) >= 0) + { +#ifdef YYDEBUG + fprintf(yyout,"yylex: nstr=%d\n",nstr); +#endif +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,"yylex: bad switch yylook %d\n",nstr); + } + + } + +#ifdef YYDEBUG + fprintf(yyout,"yylex: return 0\n"); +#endif + 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}, +/* 0x40 */ + {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}, +/* 0x80 */ + {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}, + +#ifdef CHARSETHACK + {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}, + +/* 0xc0 */ + {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}, +#endif + {0,0} +}; + +/* +struct yysvf +{ + struct yywork *yystoff; + struct yysvf *yyother; + int *yystops; +}; +*/ +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} +}; + /* 0x8d */ +/* struct yywork *yytop = yycrank+141; */ + /* 0xff */ +struct yywork *yytop = yycrank+255; + +struct yysvf *yybgin = yysvec+1; + +/* + WARNING: this table contains one entry per character + in the execution character set and must match it. +*/ +char yymatch[] = +{ + 00 ,01 ,01 ,01 ,01 ,01 ,01 ,01 , +#ifdef CHARSETHACK + 01 ,011 ,012 ,01 ,01 ,012 ,01 ,01 , +#else + 01 ,011 ,012 ,01 ,01 ,01 ,01 ,01 , +#endif + 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 , + +/* 0x40 (ascii) @A... (petscii) @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 ,'A' , + +/* 0x60 (ascii) @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 , + +#ifdef CHARSETHACK +/* 0x80 */ + 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, + +/* 0xc0 (petcii) @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,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, +#endif + 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; + +unsigned char testbreak=0; + +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 = 1; +# else + debug = 0; +# endif +*/ + +# ifdef LEXDEBUG +#define debug 1 +# else +#define debug 0 +#endif + +#ifdef YYDEBUG + fprintf(yyout,"yylook()\n"); +# endif + + if (!yymorfg) + yylastch = yytext; + else + { + yymorfg=0; + yylastch = yytext+yyleng; + } + +#ifdef YYDEBUG + fprintf(yyout,"yylook: yymorfg=%d\n",yymorfg); +# endif + + for(;;) + { +#ifdef YYDEBUG + fprintf(yyout,"yylook: (outer loop)"); + printchar("yyprevious",yyprevious); +# endif + lsp = yylstate; + yyestate = yystate = yybgin; + if (yyprevious==YYNEWLINE) yystate++; + + testbreak=0; + + for (;;) + { +# ifdef LEXDEBUG + fprintf(yyout,"yylook: (inner loop) state %d\n",yystate-yysvec-1); +# endif + if(testbreak==5) + { + fprintf(yyout,"yylook: error, aborted after 5 loops\n"); + exit(0); + } + testbreak++; + + yyt = yystate->yystoff; + +/* fprintf(yyout,"yylook: yyt offs: %02x\n",yyt-yycrank); */ + + + if(yyt == yycrank) + { /* may not be any transitions */ + yyz = yystate->yyother; + if(yyz == 0)break; + if(yyz->yystoff == yycrank)break; + } + *yylastch++ = yych = input(); + +# ifdef LEXDEBUG + fprintf(yyout,"yylook: input "); + printchar("yych",yych); +# endif + + tryagain: + +# ifdef LEXDEBUG +/* fprintf(yyout,"yylook: yych=%02x yymatch[yych]=%02x\n",yych,yymatch[yych]); */ + fprintf(yyout,"yylook: tryagain\n"); +# endif + yyr = yyt; + +/* fprintf(yyout,"yylook: yyr offs: %02x\n",yyr-yycrank); */ + + if ( yyt > yycrank) + { + yyt = yyr + yych; + if (yyt <= yytop && yyt->verify+yysvec == yystate) + { + if(yyt->advance+yysvec == YYLERR) /* error transitions */ + { +# ifdef LEXDEBUG + fprintf(yyout,"yylook: unput (1) "); + printchar("*yylastch",*yylastch); +# endif + unput(*--yylastch); + break; + } + *lsp++ = yystate = yyt->advance+yysvec; +# ifdef LEXDEBUG + fprintf(yyout,"yylook: continue (1)\n"); +# endif + goto contin; + } +# ifdef LEXDEBUG + fprintf(yyout,"yylook: ( yyt > yycrank)\n"); +# endif + } +# ifdef YYOPTIM + else if(yyt < yycrank) /* r < yycrank */ + { + yyt = yyr = yycrank+(yycrank-yyt); +# ifdef LEXDEBUG + fprintf(yyout,"yylook: compressed state\n"); +# endif + yyt = yyt + yych; + if(yyt <= yytop && yyt->verify+yysvec == yystate) + { +# ifdef LEXDEBUG + fprintf(yyout,"yylook: (1)\n"); +# endif + if(yyt->advance+yysvec == YYLERR) /* error transitions */ + { +# ifdef LEXDEBUG + fprintf(yyout,"yylook: unput (2) "); + printchar("*yylastch",*yylastch); +# endif + unput(*--yylastch); + break; + } + *lsp++ = yystate = yyt->advance+yysvec; +# ifdef LEXDEBUG + fprintf(yyout,"yylook: continue (2)\n"); +# endif + goto contin; + + } +# ifdef LEXDEBUG +/* + fprintf(yyout,"yylook: yych=%02x yymatch[yych]=%02x\n",yych,yymatch[yych]); + fprintf(yyout,"yylook: yyt offs: %02x\n",yyt-yycrank); + fprintf(yyout,"yylook: yyr offs: %02x\n",yyr-yycrank); +*/ +# endif + yyt = yyr + YYU(yymatch[yych]); +# ifdef LEXDEBUG +/* + fprintf(yyout,"yylook: yyt offs: %02x <= yytop offs: %02x\n",yyt-yycrank,yytop-yycrank); + fprintf(yyout,"yylook: yyt->verify=%04x yysvec=%04x (yyt->verify+yysvec)=%04x == yystate=%04x\n",yyt->verify,yysvec,(yyt->verify+yysvec),yystate); +*/ + fprintf(yyout,"yylook: try fall back character\n"); +# endif + if(yyt <= yytop && yyt->verify+yysvec == yystate) + { +# ifdef LEXDEBUG + fprintf(yyout,"yylook: (2a)\n"); +# endif + + if(yyt->advance+yysvec == YYLERR) /* error transition */ + { +# ifdef LEXDEBUG +/* cc65 compiles this ?! fprintf(yyout,"yylook: unput (3) ",); */ + fprintf(yyout,"yylook: unput (3) "); + printchar("*yylastch",*yylastch); +# endif + unput(*--yylastch); + break; + } + *lsp++ = yystate = yyt->advance+yysvec; +# ifdef LEXDEBUG +/* fprintf(yyout,"yylook: yyt offs: %02x yyt->advance=%d\n",yyt-yycrank,yyt->advance); */ + fprintf(yyout,"yylook: continue (3)\n"); +# endif + goto contin; + + } +# ifdef LEXDEBUG + fprintf(yyout,"yylook: (2)\n"); +# endif + } + if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank) + { +# ifdef LEXDEBUG + fprintf(yyout,"yylook: fall back to state %d\n",yystate-yysvec-1); +# endif + goto tryagain; + } +# endif + else + { +# ifdef LEXDEBUG + fprintf(yyout,"yylook: unput (4) "); + printchar("*yylastch",*yylastch); +# endif + unput(*--yylastch); + break; + } + contin: +# ifdef LEXDEBUG + fprintf(yyout,"yylook: contin state=%d\n",yystate-yysvec-1); +# endif + ; + } + +# ifdef LEXDEBUG + if((*(lsp-1)-yysvec-1)<0) + { + fprintf(yyout,"yylook: stopped (end)\n"); + } + else + { + fprintf(yyout,"yylook: stopped at %d with\n",*(lsp-1)-yysvec-1); + } +# 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--; +# ifdef LEXDEBUG + fprintf(yyout,"yylook: unput (5) "); + printchar("*yylastch",*yylastch); +# endif + unput(*yylastch--); + } + } + yyprevious = YYU(*yylastch); + yylsp = lsp; + yyleng = yylastch-yytext+1; + yytext[yyleng] = 0; +# ifdef LEXDEBUG + fprintf(yyout,"\nyylook: match action %d\n",*yyfnd); + fprintf(yyout,"yylook: done loops: %d\n",testbreak); +# endif + return(*yyfnd++); + } + unput(*yylastch); + } + if (yytext[0] == 0 /* && feof(yyin) */) + { + yysptr=yysbuf; +# ifdef LEXDEBUG + fprintf(yyout,"yylook: done loops: %d\n",testbreak); +# endif + return(0); + } + yyprevious = yytext[0] = input(); + +# ifdef LEXDEBUG + fprintf(yyout,"yylook: input "); + printchar("yyprevious",yyprevious); +# endif + + if (yyprevious>0) + output(yyprevious); + yylastch=yytext; +# ifdef LEXDEBUG +/* if(debug)putchar('\n'); */ +# endif + } + +# ifdef LEXDEBUG + fprintf(yyout,"yylook: done loops: %d\n",testbreak); + fprintf(yyout,"yylook: return \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() +{ + int out=input(); + +#ifdef YYDEBUG + fprintf(yyout,"yylook: input "); + printchar("out",out); +#endif + return(out); +} +yyoutput(c) + int c; +{ + output(c); +} +yyunput(c) + int c; +{ + unput(c); +} + +main() +{ + printf("main start\n"); + yyparse(); + printf("main end\n"); + 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 +}; + +# define YYFLAG -1000 +# define YYERROR goto yyerrlab +# define YYACCEPT return(0) +# define YYABORT return(1) + +/* parser for yacc output */ + +#ifdef YYDEBUG +int yydebug = 1; /* 1 for debugging */ +#else +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 + printf("yyparse: yystack\n"); +#endif + +#ifdef YYDEBUG + printf("yyparse: yystate=%d, ", yystate); + printchar("yychar",yychar); +#endif + if( ++yyps> &yys[YYMAXDEPTH] ) + { + yyerror( "yyparse: yacc stack overflow" ); + return(1); + } + *yyps = yystate; + ++yypv; + *yypv = yyval; + + yynewstate: +#ifdef YYDEBUG + printf("yyparse: yynewstate\n"); +#endif + + yyn = yypact[yystate]; + + if( yyn<= YYFLAG ) goto yydefault; /* simple state */ + +#ifdef YYDEBUG + printf("yyparse: yynewstate (1)\n"); +#endif + + if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0; + +#ifdef YYDEBUG + + printf("yyparse: yynewstate yyn=%d ",yyn); + printchar("yychar",yychar); +#endif + + if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault; + +#ifdef YYDEBUG + printf("yyparse: yynewstate (2)\n"); +#endif + + if( yychk[ yyn=yyact[ yyn ] ] == yychar ) /* valid shift */ + { + yychar = -1; + yyval = yylval; + yystate = yyn; + +#ifdef YYDEBUG + printf("yyparse: yynewstate (3)\n"); +#endif + + if( yyerrflag > 0 ) --yyerrflag; + goto yystack; + } + + yydefault: +#ifdef YYDEBUG + printf("yyparse: yydefault yystate=%d\n",yystate); +#endif + /* 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 */ + } + +#ifdef YYDEBUG + printf("yyparse: yyn=%d yyerrflag=%d\n",yyn,yyerrflag); +#endif + + if( yyn == 0 ) /* error */ + { + /* error ... attempt to resume parsing */ + + switch( yyerrflag ){ + case 0: /* brand new error */ + + yyerror( "yyparse: 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 + printf("yyparse: 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 + printf("yyparse: error recovery discards char "); + printchar("yychar",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 + printf("yyparse: 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("[NEG]\n[ADD]\n"); + } + break; + case 8: + { + printf("[MUL]\n"); + } + break; + case 9: + { + printf("[DIV]\n"); + } + break; + case 10: + { + printf("[NEG]\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; +} diff --git a/test/ref/yacc2.c b/test/ref/yacc2.c new file mode 100644 index 000000000..c62fca34a --- /dev/null +++ b/test/ref/yacc2.c @@ -0,0 +1,227 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Groepaz/Hitmen +*/ + +# 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}, +/* 0x40 */ + {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}, +/* 0x80 */ + {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}, + +#ifdef CHARSETHACK + {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}, + +/* 0xc0 */ + {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}, +#endif + {0,0} +}; + +struct yywork *yytop = yycrank+255; + +int yyvstop[] = +{ + 0,4,0,3,4,0,2,4,0,1,4,0,2,0,1,0,0 +}; + +struct yysvf +{ + struct yywork *yystoff; + struct yysvf *yyother; + int *yystops; +}; + +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} +}; + +#if 0 +# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):GETCHAR())==('\n')?(yylineno++,yytchar):yytchar)==EOF?0:yytchar) +// *yylastch++ = yych = input(); +void subtest1(void) +{ + *yylastch++ = yych = input(); +} +#endif + +// do some bogus operation to destroy all registers etc +static int bog=1234; +#if 0 +void bogus(void) +{ + bog*=0x1234; +} +#else +#define bogus() bog+=0x1234 +#endif + +#if 1 +// yyt = yyt + yych; +void subtest2(void) +{ + register struct yywork *yyt; + int yych; + + yyt=yycrank; + yych=10; + + bogus(); + yyt = yyt + yych; + + printf("yyt: %d %d\n",yyt->verify,yyt->advance); +} +#endif + +#if 1 +// if(yyt <= yytop && yyt->verify+yysvec == yystate) +void subtest3(void) +{ + register struct yywork *yyt; + register struct yysvf *yystate; + + yyt=yycrank; + yystate=yysvec; + + bogus(); + if(yyt <= yytop && yyt->verify+yysvec == yystate) + { + printf("if ok %d %d\n",yyt->verify,yyt->advance); + } + else + { + printf("if not ok %d %d\n",yyt->verify,yyt->advance); + } +} +#endif + +short yyr2[]= +{ + 0, 0, 2, 3, 3, 3, 3, 3, 3, 3, + 2, 3, 1, 1, 1 +}; + +// yyps -= yyr2[yyn]; +void subtest4(void) +{ + register short *yyps, yyn; + + yyps=0x8004; + yyn=0; + + while(yyn<14) + { + bogus(); + yyps -= yyr2[yyn]; + + yyn++; + } + printf("yyps: %04x\n",yyps); +} + +#if 1 + +int yylookret=10; +yylook() +{ + yylookret--; + return yylookret; +} + +// while((nstr = yylook()) >= 0) +void subtest5(void) +{ + int nstr; + + bogus(); + while((nstr = yylook()) >= 0) + { + printf("nstr: %04x\n",nstr); + bogus(); + } +} +#endif + +int main(void) +{ +// subtest1(); + subtest2(); + subtest3(); + subtest4(); + subtest5(); + + return 0; +} diff --git a/test/ref/yaccdbg.c b/test/ref/yaccdbg.c new file mode 100644 index 000000000..41e1afcdd --- /dev/null +++ b/test/ref/yaccdbg.c @@ -0,0 +1,19 @@ +/* + !!DESCRIPTION!! verbose/debug version of yacc.c (if one fails and the other does not you most likely have a stack related problem) + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +/*#define STANDALONE*/ + +#include +#include +#include + +#define INFILE "yaccdbg.in" + +#define LEXDEBUG +#define YYDEBUG + +#define YACCDBG +#include "yacc.c" diff --git a/test/val/add1.c b/test/val/add1.c new file mode 100644 index 000000000..381d12e26 --- /dev/null +++ b/test/val/add1.c @@ -0,0 +1,181 @@ +/* + !!DESCRIPTION!! Addition tests + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES + +bit bit0 = 0; +bit bit1 = 0; +bit bit2 = 0; +bit bit3 = 0; +bit bit4 = 0; +bit bit5 = 0; +bit bit6 = 0; +bit bit7 = 0; +bit bit8 = 0; +bit bit9 = 0; +bit bit10 = 0; +bit bit11 = 0; + +#endif + +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned char achar0 = 0; +unsigned char achar1 = 0; +unsigned char achar2 = 0; +unsigned char achar3 = 0; +unsigned char *acharP = 0; + +void done() +{ + dummy++; +} + +void add_lit2uchar(void) +{ + achar0 = achar0 + 5; + + if(achar0 != 5) + failures++; + + achar0 += 10; + + if(achar0 != 15) + failures++; + + achar0 = achar0 +1; /*Should be an increment */ + if(achar0 != 16) + failures++; + + for(achar1 = 0; achar1 < 100; achar1++) + achar0 += 2; + + if(achar0 != 216) + failures++; +} + +void add_uchar2uchar(void) +{ + achar1 = achar1 + achar0; + + if(achar1 != 16) + failures++; + + for(achar2 = 0; achar2<7; achar2++) + achar1 += achar0; + + if(achar1 != 128) + failures++; +} + +/* assumes + achar0 = 0 + achar1 = 32 + achar2, achar3 can be anything. +*/ +void add_uchar2uchar2(void) +{ + achar0++; + achar0 = achar0 + 1; + achar0 = achar0 + 2; + achar0 = achar0 + 3; + if(achar0 != 7) + failures++; + + achar1 += achar0; + if(achar1 != 39) + failures++; + + achar2 = achar1 + achar0; + if(achar2 != 46) + failures++; + + achar3 = achar2 + achar1 + achar0; + if(achar3 != 92) + failures++; +} + +#ifdef SUPPORT_BIT_TYPES +void add_bits(void) +{ + bit1 = bit0; + + bit0 = 1; + + if(bit1 != 0) + failures++; + + bit1 = bit1+bit0; + if(bit1 != 1) + failures++; + +#ifdef SUPPORT_BIT_ARITHMETIC + bit2 = bit1+bit3; + if(!bit2) + failures++; + + bit3 = bit4+bit5+bit6+bit7+bit0; + if(!bit3) + failures++; +#endif +} + +/* add_bit2uchar(void) - assumes bit0 = 1, achar0 = 7 */ + +void add_bit2uchar(void) +{ + achar0 += bit0; + + if(achar0 != 8) + failures++; + + if(achar0 == bit0) + failures++; +} + +void add_bit2uint(void) +{ + if(aint0 != bit11) + failures++; + + aint0 += bit0; + if(aint0!=1) + failures++; +} +#endif + +int main(void) +{ + add_lit2uchar(); + + achar0=16; + achar1=0; + add_uchar2uchar(); + + achar0 = 0; + achar1 = 32; + add_uchar2uchar2(); + +#ifdef SUPPORT_BIT_TYPES + add_bits(); + + add_bit2uchar(); + add_bit2uint(); +#endif + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/add1.o b/test/val/add1.o new file mode 100644 index 000000000..bc6b2f505 Binary files /dev/null and b/test/val/add1.o differ diff --git a/test/val/add1.prg b/test/val/add1.prg new file mode 100644 index 000000000..c0bdb01a2 Binary files /dev/null and b/test/val/add1.prg differ diff --git a/test/val/add2.c b/test/val/add2.c new file mode 100644 index 000000000..90f0f4175 --- /dev/null +++ b/test/val/add2.c @@ -0,0 +1,328 @@ +/* + !!DESCRIPTION!! Addition tests - mostly int's + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SIZEOF_INT_16BIT +#if defined(__LINUX__) || defined(LINUX) +unsigned short aint0 = 0; +unsigned short aint1 = 0; +unsigned short aint2 = 0; +unsigned short aint3 = 0; + +#else +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned int aint2 = 0; +unsigned int aint3 = 0; + +#endif + +#else +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned int aint2 = 0; +unsigned int aint3 = 0; + +#endif + +unsigned char achar0 = 0; +unsigned char achar1 = 0; +unsigned char achar2 = 0; +unsigned char achar3 = 0; +unsigned char *acharP = 0; + +#ifdef SUPPORT_BIT_TYPES + +bit bit0 = 0; +bit bit1 = 0; +bit bit2 = 0; +bit bit3 = 0; +bit bit4 = 0; +bit bit5 = 0; +bit bit6 = 0; +bit bit7 = 0; +bit bit8 = 0; +bit bit9 = 0; +bit bit10 = 0; +bit bit11 = 0; + +#endif + +void done() +{ + dummy++; +} + +void add_lit2uint(void) +{ + aint0 = aint0 + 5; + + if(aint0 != 5) + failures++; + + aint0 += 10; + + if(aint0 != 15) + failures++; + + aint0 = aint0 +1; /* Should be an increment */ + if(aint0 != 16) + failures++; + + for(aint1 = 0; aint1 < 100; aint1++) + aint0 += 2; + + if(aint0 != 216) + failures++; +} + +void add_uint2uint (void) +{ + aint1 = aint1 + aint0; + + if(aint1 != 16) + failures++; + + for(aint2 = 0; aint2<7; aint2++) + aint1 += aint0; + + if(aint1 != 128) + failures++; +} + +/* assumes + aint0 = 0 + aint1 = 32 + aint2, aint3 can be anything. +*/ +void add_uint2uint2(void) +{ + aint0++; + aint0 = aint0 + 1; + aint0 = aint0 + 2; + aint0 = aint0 + 3; + if(aint0 != 7) + failures++; + + aint1 += aint0; + if(aint1 != 0x27) + failures++; + + aint2 = aint1 + aint0; + if(aint2 != 0x2e) + failures++; + + aint3 = aint2 + aint1 + aint0; + if(aint3 != 0x5c) + failures++; + + aint3 += 0xa0; + if(aint3 != 0xfc) + failures++; + + aint3 += aint0; + if(aint3 != 0x103) + failures++; + + aint1 += 0xffc0; + if(aint1 != 0xffe7) + failures++; + + aint3 = aint2 + aint1 + aint0; + if(aint3 != 0x1c) + failures++; +} + +#ifdef SUPPORT_BIT_TYPES +void add_bits(void) +{ + bit1 = bit0; + + bit0 = 1; + + if(bit1 != 0) + failures++; + + bit1 = bit1+bit0; + if(bit1 != 1) + failures++; + + bit2 = bit1+bit3; + if(!bit2) + failures++; + + bit3 = bit4+bit5+bit6+bit7+bit0; + if(!bit3) + failures++; +} + +/* add_bit2uchar(void) - assumes bit0 = 1, aint0 = 7 */ + +void add_bit2uchar(void) +{ + achar0 += bit0; + + if(achar0 != 8) + failures++; + + if(achar0 == bit0) + failures++; +} + +void add_bit2uint(void) +{ + if(aint0 != bit11) + failures++; + + aint0 += bit0; + if(aint0!=1) + failures++; +} +#endif + +/***********************************/ + +void addlits(void) +{ + aint0 += 0x0001; + + if(aint0 != 1) + failures++; + + aint0 += 0x00; + + if(aint0 != 1) + failures++; + + aint0 += 0x00fe; + if(aint0 != 0x00ff) + failures++; + + aint0 += 0x0001; + + if(aint0 != 0x0100) + failures++; + + aint0++; + if(aint0 != 0x0101) + failures++; + + aint0 += 0x00ff; + if(aint0 != 0x0200) + failures++; + + aint0 += 0x00a0; + if(aint0 != 0x02a0) + failures++; + + aint0 += 0x0061; + if(aint0 != 0x0301) + failures++; + + aint0 += 0x0100; + if(aint0 != 0x0401) + failures++; + + aint0 += 0x0101; + if(aint0 != 0x0502) + failures++; + + aint0 += 0x00fd; + if(aint0 != 0x05ff) + failures++; + + aint0 += 0x0101; + if(aint0 != 0x0700) + failures++; + + aint0 += 0x01ff; + if(aint0 != 0x08ff) + failures++; + + aint0 += 0x01ff; + if(aint0 != 0x0afe) + failures++; + + aint0 += 0xff02; + if(aint0 != 0x0a00) + failures++; + + aint0 += 0xffff; + if(aint0 != 0x09ff) + failures++; + + aint0 += 0xff01; + if(aint0 != 0x0900) + failures++; + + aint0 += 0xff00; + if(aint0 != 0x0800) + failures++; + + aint0 += 0xff01; + if(aint0 != 0x0701) + failures++; + + aint0 += 0x0300; + if(aint0 != 0x0a01) + failures++; + + aint0 += 0x03ff; + if(aint0 != 0x0e00) + failures++; + + aint0 += 0x0301; + if(aint0 != 0x1101) + failures++; + + aint0 += 0x03fe; + if(aint0 != 0x14ff) + failures++; + + aint0 += 0x0301; + if(aint0 != 0x1800) + failures++; +} + +int main(void) +{ + add_lit2uint(); + + aint0=16; + aint1=0; + add_uint2uint(); + + aint0 = 0; + aint1 = 32; + aint2 = 0; + add_uint2uint2(); + +#ifdef SUPPORT_BIT_TYPES + add_bits(); + + achar0 = 7; + add_bit2uchar(); + + aint0 = 0; + bit0 = 1; + add_bit2uint(); +#endif + + aint0 = 0; + addlits(); + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/add3.c b/test/val/add3.c new file mode 100644 index 000000000..abbc93b47 --- /dev/null +++ b/test/val/add3.c @@ -0,0 +1,263 @@ +/* + !!DESCRIPTION!! Addition tests - mostly int's + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include +#include + +unsigned char failures=0; + +char char0 = 0; +char char1 = 0; +char char2 = 0; + +/* + this test assumes: + sizeof(char) == 1 + sizeof(int) == 2 + sizeof(long) == 4 +*/ + +#ifdef REFERENCE + +/* + make sure the reference output uses types with + proper size +*/ + +#include + +#ifdef SIZEOF_INT_16BIT +int16_t int0 = 0; +int16_t int1 = 0; +#else +int32_t int0 = 0; +int32_t int1 = 0; +#endif +int32_t long0 = 0; +int32_t long1 = 0; +uint32_t ulong0 = 0; +uint32_t ulong1 = 0; + +#else + +int int0 = 0; +int int1 = 0; +long long0 = 0; +long long1 = 0; +unsigned long ulong0 = 0; +unsigned long ulong1 = 0; + +#endif + +#ifdef SUPPORT_BIT_TYPES + +bit bit0 = 0; +bit bit1 = 0; +bit bit2 = 0; +bit bit3 = 0; +bit bit4 = 0; +bit bit5 = 0; +bit bit6 = 0; +bit bit7 = 0; +bit bit8 = 0; +bit bit9 = 0; +bit bit10 = 0; +bit bit11 = 0; + +#endif + +void done(char *name) +{ + printf("%s done - failures: %d\n", name, failures); + + if(failures) + exit(failures); +} + +void add_char2char(void) +{ + if(char0 != 4) + failures++; + if(char1 != 5) + failures++; + + char0 = char0 + char1; + + if(char0 != 9) + failures++; + + char0 += 127; + +#if (!defined(REFCC) && defined(UNSIGNED_CHARS)) || (defined(REFCC) && defined(REFCC_UNSIGNED_CHARS)) + if(char0 < 0) + failures++; + + if(char0 != (127+9)) + failures++; +#else + if(char0 > 0) + failures++; + + if(char0 != -0x78) + failures++; +#endif + + done("add_char2char"); +} + +void add_compound_char(void) +{ + char0 = char1+5; + + if(char0 != 9) + failures++; + + if((char0+char1) != 13) + failures++; + + done("add_compound_char"); +} + +void add_int2int(void) +{ + if(int0 != 4) + failures++; + if(int1 != 5) + failures++; + + int0 += int1; + if(int0 != 9) + failures++; + + int0 += 0x7fff; + if(int0 != -0x7ff8) + failures++; + + done("add_int2int"); +} + +void add_compound_int(void) +{ + int0 = int1+5; + + if(int0 != 9) + failures++; + + if((int0+int1) != 13) + failures++; + + done("add_compound_int"); +} + +void add_lit2long(void) +{ + if(long0 != 0) + failures++; + + long0++; + + if(long0 != 1) + failures++; + + long0 = long0 + 0xff; + + if(long0 != 0x100) + failures++; + + long0 = long0 + 0x100; + if(long0 != 0x200) + failures++; + + long0 = long0 + 0xfe00; + if(long0 != 0x10000) + failures++; + + long0 = long0 + 0xff0000; + if(long0 != 0x1000000) + failures++; + + long0 = long0 + 0x7e000000; + if(long0 != 0x7f000000) + failures++; + + /* wrap around zero */ + long0 = long0 + 0x2000000; + if(long0 != -0x7f000000) + failures++; + + long0 = long0 + 0x7f000000; + if(long0 != 0) + failures++; + + done("add_lit2long"); +} + +void add_lit2ulong(void) +{ + if(ulong0 != 0) + failures++; + + ulong0++; + + if(ulong0 != 1) + failures++; + + ulong0 = ulong0 + 0xff; + + if(ulong0 != 0x100) + failures++; + + ulong0 = ulong0 + 0x100; + if(ulong0 != 0x200) + failures++; + + ulong0 = ulong0 + 0xfe00; + if(ulong0 != 0x10000) + failures++; + + ulong0 = ulong0 + 0xff0000; + if(ulong0 != 0x1000000) + failures++; + + ulong0 = ulong0 + 0x7e000000; + if(ulong0 != 0x7f000000) + failures++; + + ulong0 = ulong0 + 0x2000000; + if(ulong0 != 0x81000000) + failures++; + + /* wrap around zero */ + ulong0 = ulong0 + 0x7f000000; + if(ulong0) + failures++; + + done("add_lit2ulong"); +} + +int main(void) +{ + char0=4; + char1 = char0 + 1; + add_char2char(); + + char1=4; + add_compound_char(); + + int0 = 4; + int1 = int0 + 1; + add_int2int(); + + int1=4; + add_compound_int(); + + add_lit2long(); + add_lit2ulong(); + + /* if not exit() */ + return 0; +} diff --git a/test/val/add3.o b/test/val/add3.o new file mode 100644 index 000000000..53a40880f Binary files /dev/null and b/test/val/add3.o differ diff --git a/test/val/add3.prg b/test/val/add3.prg new file mode 100644 index 000000000..9ababe609 Binary files /dev/null and b/test/val/add3.prg differ diff --git a/test/val/add4.c b/test/val/add4.c new file mode 100644 index 000000000..f02a7fb9c --- /dev/null +++ b/test/val/add4.c @@ -0,0 +1,94 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +int int0 = 0; +int int1 = 0; +char char0 = 0; +char char1 = 0; +long long0 = 0; +long long1 = 0; +unsigned long ulong0 = 0; +unsigned long ulong1 = 0; +#define NULL 0 +char *cP0=NULL; +char *cP1=NULL; +int *iP0=NULL; +int *iP1=NULL; + +void +done () +{ + dummy++; +} + +/* pointer to char arithmetic */ + +void pc_add(void) +{ + if(*cP1) + failures++; + + *cP1 += 1; + if(*cP1 != 1) + failures++; + + if(char0 != 1) + failures++; + + char0++; + + if(*cP1 != 2) + failures++; + + char1 = char0 + *cP1; + + if(char1 != 4) + failures++; +} + +/* pointer to integer arithmetic */ +void pi_add(void) +{ + if(*iP0) + failures++; + + *iP0 += 1; + + if(*iP0 != 1) + failures++; + + if(int0 != 1) + failures++; + + int1 = int0 + *iP0; + if(int1 != 2) + failures++; +} + +int main(void) +{ + cP1 = &char0; + pc_add(); + + iP0 = &int0; + pi_add(); + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/add4.o b/test/val/add4.o new file mode 100644 index 000000000..cc6c6aa52 Binary files /dev/null and b/test/val/add4.o differ diff --git a/test/val/add4.prg b/test/val/add4.prg new file mode 100644 index 000000000..b00f31329 Binary files /dev/null and b/test/val/add4.prg differ diff --git a/test/val/and1.c b/test/val/and1.c new file mode 100644 index 000000000..2409fe63e --- /dev/null +++ b/test/val/and1.c @@ -0,0 +1,145 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +unsigned int uint0 = 0; +unsigned int uint1 = 0; +unsigned char uchar0 = 0; +unsigned char uchar1 = 0; +unsigned long ulong0 = 0; + +void done() +{ + dummy++; +} + +/* uchar0 = 0xff; */ +void and_lit2uchar(void) +{ + if(uchar0 != 0xff) + failures++; + + uchar0 &= 0x7f; + + if(uchar0 != 0x7f) + failures++; + + uchar0 &= 0x3f; + + if(uchar0 != 0x3f) + failures++; + + uchar0 &= 0xdf; + + if(uchar0 != 0x1f) + failures++; +} + +void and_lit2uint(void) +{ + if(uint0 != 0xffff) + failures++; + + uint0 &= 0x7fff; + + if(uint0 != 0x7fff) + failures++; + + uint0 &= 0x3fff; + + if(uint0 != 0x3fff) + failures++; + + uint0 &= 0xdfff; + + if(uint0 != 0x1fff) + failures++; + + uint0 &= 0xff7f; + + if(uint0 != 0x1f7f) + failures++; + + uint0 &= 0x0f0f; + + if(uint0 != 0x0f0f) + failures++; + + uint0 &= 0xfefe; + + if(uint0 != 0x0e0e) + failures++; + + uint0 &= 0xf0f0; + + if(uint0 != 0) + failures++; +} + +void and_lit2ulong(void) +{ + if(ulong0 != 0xffffffff) + failures++; + + ulong0 &= 0x7fffffff; + + if(ulong0 != 0x7fffffff) + failures++; + + ulong0 &= 0xff00ffff; + + if(ulong0 != 0x7f00ffff) + failures++; + + ulong0 &= 0xfeff00ff; + + if(ulong0 != 0x7e0000ff) + failures++; +} + +/*-----------*/ +void and_uchar2uchar(void) +{ + uchar0 &= uchar1; + + if(uchar0 != 0x0f) + failures++; + + uchar1 &= 0xf7; + + uchar0 = uchar1 & 0xfe; + + if(uchar0 != 0x06) + failures++; +} + +int main(void) +{ + uchar0 = 0xff; + and_lit2uchar(); + + uint0 = 0xffff; + and_lit2uint(); + + ulong0 = 0xffffffff; + and_lit2ulong(); + + uchar0 = 0xff; + uchar1 = 0x0f; + and_uchar2uchar(); + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/and2.c b/test/val/and2.c new file mode 100644 index 000000000..672bd6019 --- /dev/null +++ b/test/val/and2.c @@ -0,0 +1,118 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +unsigned int uint0 = 0; +unsigned int uint1 = 0; +unsigned char uchar0 = 0; +unsigned char uchar1 = 0; +unsigned long ulong0 = 0; + +void done() +{ + dummy++; +} + +/* uchar0 = 0x13; */ +void and_compound1(void) +{ + uchar0 = (uchar0 + 1) & 0x0f; + if(uchar0 != 4) + failures++; +} + +/* uchar1 = 0x42; */ +void and_compound2(void) +{ + uchar0 = (uchar1 + 1) & 0x0f; + if(uchar0 != 3) + failures++; + + if(uchar1 != 0x42) + failures++; +} + +/* uchar0 = 0x13; */ +void or_compound1(void) +{ + uchar0 = (uchar0 + 0xe) | 0x0f; + if(uchar0 != 0x2f) + failures++; +} + +/* uchar1 = 0x47; */ +void or_compound2(void) +{ + uchar0 = (uchar1 + 0xf) | 0x0f; + if(uchar0 != 0x5f) + failures++; + + if(uchar1 != 0x47) + failures++; +} + +/* uchar0 = 0x13; */ +void xor_compound1(void) +{ + uchar0 = (uchar0 + 1) ^ 0x0f; + if(uchar0 != 0x1b) + failures++; +} + +/* uchar1 = 0x47; */ +void xor_compound2(void) +{ + uchar0 = (uchar1 + 0xf) ^ 0x0f; + if(uchar0 != 0x59) + failures++; + + if(uchar1 != 0x47) + failures++; +} + +/* uchar0 = 0x13; */ +void neg_compound1(void) +{ + uchar0 = ~(uchar0 + 1); + if(uchar0 != 0xeb) + failures++; +} + +int main(void) +{ + uchar0 = 0x13; + and_compound1(); + + uchar1 = 0x42; + and_compound2(); + + uchar0 = 0x13; + or_compound1(); + + uchar1 = 0x47; + or_compound2(); + + uchar0 = 0x13; + xor_compound1(); + + uchar1 = 0x47; + xor_compound2(); + + uchar0 = 0x13; + neg_compound1(); + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/atoi-test.c b/test/val/atoi-test.c new file mode 100644 index 000000000..5f5fa65e7 --- /dev/null +++ b/test/val/atoi-test.c @@ -0,0 +1,42 @@ +/* + !!DESCRIPTION!! A small test for atoi. Assumes twos complement + !!ORIGIN!! + !!LICENCE!! + !!AUTHOR!! +*/ + +#include +#include +#include +#include +#include + +static unsigned int Failures = 0; + +static void CheckAtoi (const char* Str, int Val) +{ + int Res = atoi (Str); + if (Res != Val) { + printf ("atoi error in \"%s\":\n" + " result = %d, should be %d\n", Str, Res, Val); + ++Failures; + } +} + +int main (void) +{ + CheckAtoi ("\t +0A", 0); + CheckAtoi ("\t -0.123", 0); + CheckAtoi (" -32 ", -32); + CheckAtoi (" +32 ", 32); + CheckAtoi ("0377", 377); + CheckAtoi (" 0377 ", 377); + CheckAtoi (" +0377 ", 377); + CheckAtoi (" -0377 ", -377); + CheckAtoi ("0x7FFF", 0); + CheckAtoi (" +0x7FFF", 0); + CheckAtoi (" -0x7FFF", 0); + printf ("Failures: %u\n", Failures); + + return Failures; +} diff --git a/test/val/bool1.c b/test/val/bool1.c new file mode 100644 index 000000000..2bdccd436 --- /dev/null +++ b/test/val/bool1.c @@ -0,0 +1,130 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned char achar0 = 0; +unsigned char achar1 = 0; + +void done() +{ + dummy++; +} + +void bool_or1(void) +{ + if( (achar0 >0) || (achar1 >0 )) + failures++; +} + +void bool_or2(void) +{ + if( achar0 || achar1) + failures++; +} + +void bool_test1(void) +{ + if( (achar0==0) || achar1) + failures++; +} + +void bool_test2(void) +{ + if( (achar0==0) || aint0) + failures++; +} + +void bool_and1(void) +{ + if( achar0 && achar1) + failures++; +} + +void bin_or1(void) +{ + char t; + + t = achar0 | achar1; + if(t) + failures++; +} + +void bin_xor1(void) +{ + if(achar0 ^ achar1) + failures++; +} + +void bool_test3(void) +{ + if((achar0 == 0x42) || (achar1 == 42)) + failures++; +} + +void bool_or_lit1(void) +{ + achar0 |= 0x0f; + + if(achar0 > 0x10) + failures++; + + if( (achar0 | 0x10) > 0xf0) + failures++; +} + +void bool_and_lit1(void) +{ + achar0 &= 0xf0; + + if(achar0 > 0x10) + failures++; + + if( (achar0 & 0x10) > 0xf0) + failures++; + + achar0 &= 0xef; +} + +int main(void) +{ + bool_or1(); + bool_or2(); + bool_and1(); + bin_or1(); + bin_xor1(); + + achar0++; + bool_and1(); + bool_test1(); + bool_test2(); + bool_test3(); + + achar0--; achar1++; + bool_and1(); + + achar0=0; + achar1=0; + + bool_or_lit1(); + bool_and_lit1(); + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/bool3.c b/test/val/bool3.c new file mode 100644 index 000000000..73c03a3e2 --- /dev/null +++ b/test/val/bool3.c @@ -0,0 +1,66 @@ +/* + !!DESCRIPTION!! Compound comparisons + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +bit bit1 = 0; +#endif +unsigned int ui0 = 0; +unsigned int ui1 = 0; +unsigned char uc0 = 0; +unsigned char uc1 = 0; +unsigned long uL0 = 0; +unsigned long uL1 = 0; + +void done() +{ + dummy++; +} + +void compound_compare_uc(void) +{ + failures += (uc0 != uc1); +} + +void compound_compare_ui(void) +{ + failures += (ui0 != ui1); +} + +void compound_compare_ul(void) +{ + failures += (uL0 != uL1); +} + +void compound_compare_uc_lit(void) +{ + failures += (uc0 != 0xff); + failures += (uc0 != 0xff); + failures += (uc0 == 0); +} + +int main(void) +{ + compound_compare_uc(); + compound_compare_ui(); + compound_compare_ul(); + + uc0 = 0xff; + compound_compare_uc_lit(); + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/call1.c b/test/val/call1.c new file mode 100644 index 000000000..c7ac920b3 --- /dev/null +++ b/test/val/call1.c @@ -0,0 +1,157 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int uint0 = 0; +unsigned int uint1 = 0; +unsigned char uchar0 = 0; +unsigned char uchar1 = 0; + +unsigned char call3 (void); + +void +done () +{ + dummy++; +} + +void +call1 (unsigned char uc0) +{ + if (uc0) + failures++; +} + +void +call2 (unsigned int ui0) +{ + if (ui0) + failures++; +} + +unsigned char +call3 (void) +{ + if (uchar0) + failures++; + + return (failures); +} + +unsigned int +call4 (void) +{ + unsigned int i = 0; + + if (uint0) + i++; + + return (i); +} + +unsigned int +call5 (unsigned int k) +{ + if (k) + failures++; + + return (k); +} + +unsigned char +call6a(unsigned char uc) +{ + if(uc>uchar1) + return 1; + else + return 0; +} + +unsigned char +call6(unsigned char uc) +{ + return(call6a(uc)); +} + +unsigned int +call7a(unsigned int ui) +{ + if(ui) + return 1; + else + return 0; +} + +unsigned int +call7(unsigned int ui) +{ + return(call7a(ui)); +} + +unsigned char +call8(unsigned char uc1,unsigned char uc2) +{ + return uc1+uc2; +} + +void call9(unsigned int ui1, unsigned int ui2) +{ + if(ui1 != 0x1234) + failures++; + if(ui2 != 0x5678) + failures++; +} + +int +main (void) +{ + call1 (uchar0); + call2 (uint0); + uchar1 = call3 (); + uint1 = call4 (); + if (uint1) + failures++; + + uint1 = call5 (uint0); + if (uint1) + failures++; + + if(call6(uchar0)) + failures++; + + if(call7(0)) + failures++; + + if(!call7(1)) + failures++; + + if(!call7(0xff00)) + failures++; + + uchar0=4; + uchar1=3; + uchar0 = call8(uchar0,uchar1); + + if(uchar0 != 7) + failures++; + + call9(0x1234,0x5678); + + success = failures; + done (); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/cc65091020.c b/test/val/cc65091020.c new file mode 100644 index 000000000..8ec11ef8d --- /dev/null +++ b/test/val/cc65091020.c @@ -0,0 +1,26 @@ +/* + !!DESCRIPTION!! bit field bug + !!ORIGIN!! testsuite + !!LICENCE!! Public Domain + !!AUTHOR!! Johan Kotlinski +*/ + +#include + +struct { + int foo : 7; + int bar : 4; +} baz = { 0, 2 }; + +int main() { + char bar = baz.bar; + + assert(2 == bar); + + printf("it works :)\n"); + + /* if not assert() */ + return 0; +} + +/* Assert fails. (SVN rev 4381) */ \ No newline at end of file diff --git a/test/val/compare1.c b/test/val/compare1.c new file mode 100644 index 000000000..0127e3b1b --- /dev/null +++ b/test/val/compare1.c @@ -0,0 +1,183 @@ +/* + !!DESCRIPTION!! test compare + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +/* + compare.c +*/ + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +bit bit1 = 0; +#endif + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +unsigned char achar0 = 0; +unsigned char achar1 = 0; +unsigned int aint0 = 0; +unsigned int aint1 = 0; + +char schar0 = 0; +char schar1 = 0; + +void +done () +{ + dummy++; +} + +/* achar0 should be zero */ + +void +compare_char_to_lits1 (void) +{ + if (achar0) + failures++; + + if (achar0 == 1) + failures++; + + if (achar0 == 7) + failures++; + + if (achar0 != 0) + failures++; +} + +/* achar0 should be `5' */ +void +compare_char_to_lits2 (void) +{ + if (!achar0) + failures++; + + if (achar0 == 1) + failures++; + + if (achar0 == 7) + failures++; + + if (achar0 != 5) + failures++; +} + +/* achar0 should equal achar1 */ +void +compare_char_to_char1 (void) +{ + if (achar0 != achar1) + failures++; + + if (schar0 != schar1) + failures++; +} + +/* achar0 should be different than achar1 */ +void +compare_char_to_char2 (void) +{ + if (achar0 == achar1) + failures++; +} + +/* aint0 should be zero */ + +void +compare_int_to_lits1 (void) +{ + if (aint0) + failures++; + + if (aint0 == 1) + failures++; + + if (aint0 == 7) + failures++; + + if (aint0 != 0) + failures++; +} + +/* aint0 should be `5' */ +void +compare_int_to_lits2 (void) +{ + if (!aint0) + failures++; + + if (aint0 == 1) + failures++; + + if (aint0 == 7) + failures++; + + if (aint0 != 5) + failures++; +} + +/* aint0 should be `0x1234' */ +void +compare_int_to_lits3 (void) +{ + if (!aint0) + failures++; + + if (aint0 == 1) + failures++; + + if (aint0 == 7) + failures++; + + if (aint0 != 0x1234) + failures++; +} + +/* aint0 should equal aint1 */ +void +compare_int_to_int1 (void) +{ + if (aint0 != aint1) + failures++; +} + +/* aint0 should be different than aint1 */ +void +compare_int_to_int2 (void) +{ + if (aint0 == aint1) + failures++; +} + +int +main (void) +{ + compare_char_to_lits1 (); + compare_char_to_char1 (); + achar0 = 5; + compare_char_to_lits2 (); + compare_char_to_char2 (); + + compare_int_to_lits1 (); + aint0 = 5; + compare_int_to_lits2 (); + aint0 = 0x1234; + compare_int_to_lits3 (); + compare_int_to_int2 (); + aint0 = 0; + compare_int_to_int1 (); + + success = failures; + done (); + + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/compare10.c b/test/val/compare10.c new file mode 100644 index 000000000..861a02d64 --- /dev/null +++ b/test/val/compare10.c @@ -0,0 +1,319 @@ +/* + !!DESCRIPTION!! Signed comparisons of the form: (variable>=LIT) + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +/* This regression test exercises all of the boundary + conditions in literal less than comparisons. There + are numerous opportunities to optimize these comparison + and each one has an astonishing capability of failing + a boundary condition. +*/ +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; +unsigned char result = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +int int0 = 0; +int int1 = 0; +unsigned char uchar0 = 0; +unsigned char uchar1 = 0; +signed char char0 = 0; +signed char char1 = 0; +char long0 = 0; +char long1 = 0; + +/* *** NOTE *** This particular test takes quite a while to run + * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC). + * The WDT will reset the CPU if it's enabled. So disable it... +*/ + +void +done () +{ + dummy++; +} + +void c_char_gte_lit1(unsigned char expected_result) +{ + result = 0; + + if(char0 >= -0x7f) + result |= 1; + + if(char0 >= -1) + result |= 2; + + if(char0 >= 0) + result |= 4; + + if(char0 >= 1) + result |= 8; + + if(char0 >= 0x7e) + result |= 0x10; + + if(char0 >= 0x7f) + result |= 0x20; + + if(result != expected_result) + { +/* LOG_ERROR(1); */ + printf("c_char_gte_lit1: char %02x - result %02x expected: %02x\n",char0,result,expected_result); + failures++; + } + +/* printf("char %02x - %02x failures: %d\n",char0,expected_result,failures); */ +} + +void char_compare(void) +{ + char0 = 0x7f; + c_char_gte_lit1(0x3f); + + char0 = 0x7e; + c_char_gte_lit1(0x1f); + + char0 = 0x40; + c_char_gte_lit1(0x0f); + + char0 = 0x2; + c_char_gte_lit1(0x0f); + + char0 = 0x1; + c_char_gte_lit1(0x0f); + + char0 = 0; + c_char_gte_lit1(0x07); + + char0 = -1; + c_char_gte_lit1(0x03); + + char0 = -2; + c_char_gte_lit1(0x01); + + char0 = -0x40; + c_char_gte_lit1(0x01); + + char0 = -0x7e; + c_char_gte_lit1(0x01); + + char0 = -0x7f; + c_char_gte_lit1(0x01); + + char0 = 0x80; + c_char_gte_lit1(0x00); + + /* Now test entire range */ + + for(char0=1; char0 != 0x7e; char0++) + c_char_gte_lit1(0x0f); + + for(char0=-0x7f; char0 != -1; char0++) + c_char_gte_lit1(0x01); +} + +void c_int_gte_lit1(unsigned char expected_result) +{ + result = 0; + + if(int0 >= 0) + result |= 1; + + if(int0 >= 1) + result |= 2; + + if(int0 >= 0xff) + result |= 4; + + if(int0 >= 0x100) + result |= 8; + + if(int0 >= 0x0101) + result |= 0x10; + + if(int0 >= 0x01ff) + result |= 0x20; + + if(int0 >= 0x0200) + result |= 0x40; + + if(int0 >= 0x0201) + result |= 0x80; + + if(result != expected_result) + failures=1; +} + +void int_compare1(void) +{ + int0 = -1; + c_int_gte_lit1(0x00); + + int0 = 0; + c_int_gte_lit1(0x01); + + int0 = 1; + c_int_gte_lit1(0x03); + + int0 = 2; + c_int_gte_lit1(0x03); + + int0 = 0xfe; + c_int_gte_lit1(0x03); + + int0 = 0xff; + c_int_gte_lit1(0x07); + + int0 = 0x100; + c_int_gte_lit1(0x0f); + + int0 = 0x101; + c_int_gte_lit1(0x1f); + + int0 = 0x102; + c_int_gte_lit1(0x1f); + + int0 = 0x1fe; + c_int_gte_lit1(0x1f); + + int0 = 0x1ff; + c_int_gte_lit1(0x3f); + + int0 = 0x200; + c_int_gte_lit1(0x7f); + + int0 = 0x201; + c_int_gte_lit1(0xff); + + int0 = 0x7f00; + c_int_gte_lit1(0xff); + + /* now check contiguous ranges */ + + for(int0 = -0x7fff; int0 != -1; int0++) + c_int_gte_lit1(0x00); + + for(int0 = 1; int0 != 0xff; int0++) + c_int_gte_lit1(0x03); + + for(int0 = 0x201; int0 != 0x7fff; int0++) + c_int_gte_lit1(0xff); +} + +void c_int_gte_lit2(unsigned char expected_result) +{ + result = 0; + + if(int0 >= -0x7fff) + result |= 1; + + if(int0 >= -0x7f00) + result |= 2; + + if(int0 >= -0x7eff) + result |= 4; + + if(int0 >= -0x7e00) + result |= 8; + + if(int0 >= -0x0101) + result |= 0x10; + + if(int0 >= -0x0100) + result |= 0x20; + + if(int0 >= -0xff) + result |= 0x40; + + if(int0 >= -1) + result |= 0x80; + + if(result != expected_result) + failures=1; +} + +void int_compare2(void) +{ + int0 = -0x7fff; + c_int_gte_lit2(0x01); + + int0 = -0x7f00; + c_int_gte_lit2(0x03); + + int0 = -0x7eff; + c_int_gte_lit2(0x07); + + int0 = -0x7e00; + c_int_gte_lit2(0x0f); + + int0 = -0x7dff; + c_int_gte_lit2(0x0f); + + int0 = -0x4567; + c_int_gte_lit2(0x0f); + + int0 = -0x200; + c_int_gte_lit2(0x0f); + + int0 = -0x102; + c_int_gte_lit2(0x0f); + + int0 = -0x101; + c_int_gte_lit2(0x1f); + + int0 = -0x100; + c_int_gte_lit2(0x3f); + + int0 = -0xff; + c_int_gte_lit2(0x7f); + + int0 = -0x02; + c_int_gte_lit2(0x7f); + + int0 = -0x01; + c_int_gte_lit2(0xff); + + int0 = 0; + c_int_gte_lit2(0xff); + + int0 = 1; + c_int_gte_lit2(0xff); + + int0 = 0x7fff; + c_int_gte_lit2(0xff); + + /* now check contiguous ranges */ + + for(int0 = -0x7fff; int0 != -0x7f00; int0++) + c_int_gte_lit2(0x01); + + for(int0 = -0x7e00; int0 != -0x101; int0++) + c_int_gte_lit2(0x0f); + + for(int0 = -1; int0 != 0x7fff; int0++) + c_int_gte_lit2(0xff); +} + +int +main (void) +{ + char_compare(); + printf("failures: %d\n",failures); + int_compare1(); + printf("failures: %d\n",failures); + int_compare2(); + + success = failures; + done (); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/compare2.c b/test/val/compare2.c new file mode 100644 index 000000000..afc2db8fc --- /dev/null +++ b/test/val/compare2.c @@ -0,0 +1,362 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned char achar0 = 0; +unsigned char achar1 = 0; + +void +done () +{ + dummy++; +} + +void +char_lt_char (void) +{ + if (achar0 < achar1) + failures++; +} + +void +char_gt_char (void) +{ + if (achar1 > achar0) + failures++; +} + +void +char_lte_char (void) +{ + if (achar0 <= achar1) + failures++; +} + +void +char_gte_char (void) +{ + if (achar1 >= achar0) + failures++; +} + +void +char_lt_lit (void) +{ + if (achar1 < 0x10) + failures++; +} + +void +char_gt_lit (void) +{ + if (achar1 > 0x10) + failures++; +} + +void +char_lte_lit (void) +{ + if (achar1 <= 0x0f) + failures++; +} + +void +char_gte_lit (void) +{ + if (achar1 >= 0x11) + failures++; +} + +/* now repeat test using negative logic */ +void +char_lt_char_else (void) +{ + if (achar0 >= achar1) + dummy++; + else + failures++; +} + +void +char_gt_char_else (void) +{ + if (achar1 <= achar0) + dummy++; + else + failures++; +} + +void +char_lte_char_else (void) +{ + if (achar0 > achar1) + dummy++; + else + failures++; +} + +void +char_gte_char_else (void) +{ + if (achar1 < achar0) + dummy++; + else + failures++; +} + +void +char_lt_lit_else (void) +{ + if (achar1 >= 0x10) + dummy++; + else + failures++; +} + +void +char_gt_lit_else (void) +{ + if (achar1 <= 0x10) + dummy++; + else + failures++; +} + +void +char_lte_lit_else (void) +{ + if (achar1 > 0x0f) + dummy++; + else + failures++; +} + +void +char_gte_lit_else (void) +{ + if (achar1 < 0x11) + dummy++; + else + failures++; +} + +/* ints */ + +void +int_lt_int (void) +{ + if (aint0 < aint1) + failures++; +} + +void +int_gt_int (void) +{ + if (aint1 > aint0) + failures++; +} + +void +int_lte_int (void) +{ + if (aint0 <= aint1) + failures++; +} + +void +int_gte_int (void) +{ + if (aint1 >= aint0) + failures++; +} + +void +int_lt_lit (void) +{ + if (aint1 < 0x10) + failures++; +} + +void +int_gt_lit (void) +{ + if (aint1 > 0x10) + failures++; +} + +void +int_lte_lit (void) +{ + if (aint1 <= 0x0f) + failures++; +} + +void +int_gte_lit (void) +{ + if (aint1 >= 0x11) + failures++; +} + +/* now repeat int comparisons using negative logic */ + +void +int_lt_int_else (void) +{ + if (aint0 >= aint1) + dummy++; + else + failures++; +} + +void +int_gt_int_else (void) +{ + if (aint1 <= aint0) + dummy++; + else + failures++; +} + +void +int_lte_int_else (void) +{ + if (aint0 > aint1) + dummy++; + else + failures++; +} + +void +int_gte_int_else (void) +{ + if (aint1 < aint0) + dummy++; + else + failures++; +} + +void +int_lt_lit_else (void) +{ + if (aint1 >= 0x10) + dummy++; + else + failures++; +} + +void +int_gt_lit_else (void) +{ + if (aint1 <= 0x10) + dummy++; + else + failures++; +} + +void +int_lte_lit_else (void) +{ + if (aint1 > 0x0f) + dummy++; + else + failures++; +} + +void +int_gte_lit_else (void) +{ + if (aint1 < 0x11) + dummy++; + else + failures++; +} + +int +main (void) +{ + char_lt_char (); + char_gt_char (); + + achar0++; + char_lt_char (); + char_gt_char (); + char_gte_char (); + char_lte_char (); + + achar1 = 0x10; + char_lt_lit (); + char_gt_lit (); + char_lte_lit (); + char_gte_lit (); + + achar0 = 0; + achar1 = 0; + + char_lt_char_else (); + char_gt_char_else (); + + achar0++; + char_lt_char_else (); + char_gt_char_else (); + char_gte_char_else (); + char_lte_char_else (); + + achar1 = 0x10; + char_lt_lit_else (); + char_gt_lit_else (); + char_lte_lit_else (); + char_gte_lit_else (); + + int_lt_int (); + int_gt_int (); + + aint0++; + int_lt_int (); + int_gt_int (); + int_gte_int (); + int_lte_int (); + + aint1 = 0x10; + int_lt_lit (); + int_gt_lit (); + int_lte_lit (); + int_gte_lit (); + + aint0=0; + aint1=0; + int_lt_int_else (); + int_gt_int_else (); + + aint0++; + int_lt_int_else (); + int_gt_int_else (); + int_gte_int_else (); + int_lte_int_else (); + + aint1 = 0x10; + int_lt_lit_else (); + int_gt_lit_else (); + int_lte_lit_else (); + int_gte_lit_else (); + + success = failures; + done (); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/compare3.c b/test/val/compare3.c new file mode 100644 index 000000000..614efd5e9 --- /dev/null +++ b/test/val/compare3.c @@ -0,0 +1,246 @@ +/* + !!DESCRIPTION!! regression testing program for comparing literals to variables + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +/* + compare3.c +*/ + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned char achar0 = 0; +unsigned char achar1 = 0; + +void +done () +{ + dummy++; +} + +/* compare to 0 + assumes + achar0 == 0 + achar1 != 0 + aint0 == 0 + aint1 != 0 +*/ +void c_0(void) +{ + if(achar0 != 0) + failures++; + + if(achar0) + failures++; + + if(achar1 == 0) + failures++; + + if(!achar1) + failures++; + + if(aint0 != 0) + failures++; + + if(aint0) + failures++; + + if(aint1 == 0) + failures++; + + if(!aint1) + failures++; +} + +/* compare to 1 + assumes + achar0 != 1 + achar1 == 1 + aint0 != 1 + aint1 == 1 +*/ +void c_1(void) +{ + if(achar0 == 1) + failures++; + + if(achar1 != 1) + failures++; + + if(aint0 == 1) + failures++; + + if(aint1 != 1) + failures++; +} + +/* compare to 2 + assumes + achar0 == 2 + aint0 == 2 +*/ +void c_2(void) +{ + if(achar0 != 2) + failures++; + + if(aint0 != 2) + failures++; +} + +/* compare to 0xff + assumes + achar0 == 0xff + aint0 == 0xff +*/ +void c_ff(void) +{ + if(achar0 != 0xff) + failures++; + + if(aint0 != 0xff) + failures++; + + if(aint0 == 0xfe) + failures++; + + if(aint0 == 0xff00) + failures++; +} + +/* compare to 0x00a5 + assumes + achar0 == 0xa5 + aint0 == 0x00a5 +*/ +void c_a5(void) +{ + if(achar0 != 0xa5) + failures++; + + if(aint0 != 0xa5) + failures++; + + if(aint0 == 0xa4) + failures++; + + if(aint0 == 0xa500) + failures++; +} + +/* compare to 0xa500 + assumes + achar0 == 0xa5 + aint0 == 0xa500 +*/ +void c_a500(void) +{ + if(achar0 == 0xa500) + failures++; + + if(aint0 != 0xa500) + failures++; + + if(aint0 == 0xa400) + failures++; + + if(aint0 == 0x00a5) + failures++; +} + +/* compare to 0xabcd + assumes + achar0 == 0xa5 + aint0 == 0xabcd +*/ +void c_abcd(void) +{ + if(achar0 == 0xabcd) + failures++; + + if(aint0 != 0xabcd) + failures++; + + if(aint0 == 0xab00) + failures++; + + if(aint0 == 0x00cd) + failures++; + + if(aint0 == 0x05cd) + failures++; + + if(aint0 == 0xab05) + failures++; + + if(aint0 == 0xab01) + failures++; + + if(aint0 == 0x01cd) + failures++; + + /* + if(aint0 == 0x1234abcd) + failures++; + */ +} + +/* assumes achar1 == 0 */ +void c_ifelse1(void) +{ + if(achar0) + achar0 = achar1; + else + achar0 = 0; + + if(achar0) + failures++; +} + +int +main (void) +{ + aint1 = 1; + achar1 = 1; + c_0(); + c_1(); + + aint0 = 2; + achar0 = 2; + c_2(); + + aint0 = 0xff; + achar0 = 0xff; + c_ff(); + + aint0 = 0xa5; + achar0 = 0xa5; + c_a5(); + + aint0 = 0xabcd; + c_abcd(); + + achar0 = 0; + achar1 = 0; + c_ifelse1(); + + achar0 = 1; + c_ifelse1(); + + success = failures; + done (); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/compare4.c b/test/val/compare4.c new file mode 100644 index 000000000..47948c3a3 --- /dev/null +++ b/test/val/compare4.c @@ -0,0 +1,349 @@ +/* + !!DESCRIPTION!! regression testing program for comparing signed chars and ints + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +/* + compare4.c +*/ + +/*#define COMPARE_OUT_OF_RANGE 1*/ + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +#ifdef SIZEOF_INT_16BIT +#if defined(__LINUX__) || defined(LINUX) +short int0 = 0; +short int1 = 0; + +#else +int int0 = 0; +int int1 = 0; + +#endif + +#else +int int0 = 0; +int int1 = 0; + +#endif + +signed char char0 = 0; +signed char char1 = 0; + +void +done () +{ + dummy++; +} + +/* compare to 0 + assumes + char0 == 0 + char1 != 0 + int0 == 0 + int1 != 0 +*/ +void c_0(void) +{ + if(char0 != 0) + failures++; + + if(char0) + failures++; + + if(char1 == 0) + failures++; + + if(!char1) + failures++; + + if(int0 != 0) + failures++; + + if(int0) + failures++; + + if(int1 == 0) + failures++; + + if(!int1) + failures++; + + if(char0>0) + failures++; + + if(int0>0) + failures++; + + if(char0<0) + failures++; + + if(int0<0) + failures++; +} + +/* compare to 1 + assumes + char0 != 1 + char1 == 1 + int0 != 1 + int1 == 1 +*/ +void c_1(void) +{ + if(char0 == 1) + failures++; + + if(char1 != 1) + failures++; + + if(int0 == 1) + failures++; + + if(int1 != 1) + failures++; + + if(char0 < 0) + failures++; + + if(int0 < 0) + failures++; +} + +/* compare to 2 + assumes + achar0 == 2 + aint0 == 2 +*/ +void c_2(void) +{ + if(char0 != 2) + failures++; + + if(int0 != 2) + failures++; +} + +/* compare to 0xff + assumes + achar0 == 0xff + aint0 == 0xff +*/ +void c_ff(void) +{ + if((unsigned char)char0 != 0xff) + failures++; + + if((unsigned short)int0 != 0xff) + failures++; + + if((unsigned short)int0 == 0xfe) + failures++; + + if((unsigned short)int0 == 0xff00) + failures++; +} + +/* compare to 0x00a5 + assumes + char0 == 0xa5 + int0 == 0x00a5 +*/ +void c_a5(void) +{ + if((unsigned char)char0 != 0xa5) + failures++; + + if((unsigned short)int0 != 0xa5) + failures++; + + if((unsigned short)int0 == 0xa4) + failures++; + + if((unsigned short)int0 == 0xa500) + failures++; +} + +/* compare to 0xa500 + assumes + char0 == 0xa5 + int0 == 0xa500 +*/ +void c_a500(void) +{ +#ifdef COMPARE_OUT_OF_RANGE + if(char0 == 0xa500) + failures++; +#endif + + if((unsigned short)int0 != 0xa500) + failures++; + + if(int0 != 0x44) + int0 = 0x28; + + if((unsigned short)int0 == 0xa400) + failures++; + + if(int0 == 0x00a5) + failures++; +} + +/* compare to 0xabcd + assumes + char0 == 0xa5 + int0 == 0xabcd +*/ +void c_abcd(void) +{ +#ifdef COMPARE_OUT_OF_RANGE + if(char0 == 0xabcd) + failures++; +#endif +/* + if(int0 != 0xabcd) + failures++; +*/ + if((unsigned short)int0 == 0xab00) + failures++; + + if(int0 == 0x00cd) + failures++; + + if(int0 == 0x05cd) + failures++; + + if((unsigned short)int0 == 0xab05) + failures++; + + if((unsigned short)int0 == 0xab01) + failures++; + + if(int0 == 0x01cd) + failures++; + + if(int0 > 0) + failures++; + +#ifdef COMPARE_OUT_OF_RANGE + if(int0 == 0x1234abcd) + failures++; +#endif +} + +/* assumes char1 == 0 */ +void c_ifelse1(void) +{ + if(char0) + char0 = char1; + else + char0 = 0; + + if(char0) + failures++; +} + +/* assumes char0 = -1 + assumes int0 = -1 +*/ +void c_minus1(void) +{ + if(char0 != -1) + failures++; + + printf("%d\n",failures); + + if(int0 != -1) + failures++; + + printf("%d\n",failures); + + if(char0 != int0) + failures++; + + printf("%d\n",failures); + + if(char0>0) + failures++; + + printf("%d\n",failures); + + if(int0>0) + failures++; + + printf("%d\n",failures); +} + +void c_c0gtc1(void) +{ + if(char0 < char1) + failures++; + + printf("%d\n",failures); +} + +int main(void) +{ + int1 = 1; + char1 = 1; + c_0(); + printf("failures: %d\n",failures); + c_1(); + printf("failures: %d\n",failures); + + int0 = 2; + char0 = 2; + c_2(); + printf("failures: %d\n",failures); + + int0 = 0xff; + char0 = 0xff; + c_ff(); + printf("failures: %d\n",failures); + + int0 = 0xa5; + char0 = 0xa5; + c_a5(); + printf("failures: %d\n",failures); + + int0 = 0xabcd; + /*c_abcd();*/ + + char0 = 0; + char1 = 0; + c_ifelse1(); + printf("failures: %d\n",failures); + + char0 = 1; + c_ifelse1(); + printf("failures: %d\n",failures); + + char0 = -1; + int0 = -1; + c_minus1(); + printf("failures: %d\n",failures); + + char0 = 5; + char1 = 3; + c_c0gtc1(); + printf("failures: %d\n",failures); + + char1 = -3; + c_c0gtc1(); + + success = failures; + done (); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/compare5.c b/test/val/compare5.c new file mode 100644 index 000000000..b5dd93f01 --- /dev/null +++ b/test/val/compare5.c @@ -0,0 +1,445 @@ +/* + !!DESCRIPTION!! regression testing program for comparing longs + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +/* + compare5.c +*/ + +#define COMPARE_OUT_OF_RANGE 1 + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +int int0 = 0; +int int1 = 0; +char char0 = 0; +char char1 = 0; +long long0 = 0; +long long1 = 0; +unsigned long ulong0 = 0; +unsigned long ulong1 = 0; + +void +done () +{ + dummy++; +} + +/* compare to 0 + assumes + long0 == 0 + ulong0 == 0 +*/ +void c_0(void) +{ + if(long0 != 0) + failures++; + + if(long0 > 0) + failures++; + + if(ulong0 != 0) + failures++; + + if(ulong0 > 0) + failures++; +} + +/* compare to 1 + assumes + long1 == 1 + ulong1 == 1 +*/ +void c_1(void) +{ + if(long0 == 1) + failures++; + + if(long1 != 1) + failures++; + + if(ulong0 == 1) + failures++; + + if(ulong1 != 1) + failures++; + + if(long1 < 0) + failures++; + + if(long1 < 1) + failures++; + + if(ulong1 < 1) + failures++; + + if(long1 > 1) + failures++; + + if(ulong1 > 1) + failures++; +} + +/* compare to 2 + assumes + long0 == 2 + ulong0 == 2 +*/ +void c_2(void) +{ + if(long0 != 2) + failures++; + + if(ulong0 != 2) + failures++; + + if(long1 == 2) + failures++; + + if(ulong1 == 2) + failures++; +} + +/* compare to 0xff + assumes + achar0 == 0xff + aint0 == 0xff +*/ +void c_ff(void) +{ + if(long0 != 0xff) + failures++; + + if(ulong0 != 0xff) + failures++; + + if(long1 == 0xff) + failures++; + + if(ulong1 == 0xff) + failures++; +} + +/* compare to 0x200 + assumes + achar0 == 0x200 + aint0 == 0x200 +*/ +void c_200(void) +{ + if(long0 != 0x200) + failures++; + + if(ulong0 != 0x200) + failures++; + + if(long1 == 0x200) + failures++; + + if(ulong1 == 0x200) + failures++; +} + +/* compare to 0x20000 + assumes + long0 == 0x20000 + ulong0 == 0x20000 + long1 != 0x20000 + ulong1 != 0x20000 +*/ +void c_20000(void) +{ + if(long0 != 0x20000) + failures++; + + if(ulong0 != 0x20000) + failures++; + + if(long1 == 0x20000) + failures++; + + if(ulong1 == 0x20000) + failures++; + + if(long0 <= 0x10000) + failures++; + + if(long0 < 0x10000) + failures++; + +/* if(long0 < 0x12345) + failures++; +*/ + if(long0 == 0) + failures++; +} + +/* compare to 0x00a5 + assumes + char0 == 0xa5 + int0 == 0x00a5 +*/ +void c_a5(void) +{ + if(char0 != 0xa5) + failures++; + + if(int0 != 0xa5) + failures++; + + if(int0 == 0xa4) + failures++; + + if(int0 == 0xa500) + failures++; +} + +/* compare to 0xa500 + assumes + char0 == 0xa5 + int0 == 0xa500 +*/ +void c_a500(void) +{ +#ifdef COMPARE_OUT_OF_RANGE + if(char0 == 0xa500) + failures++; +#endif + + if(int0 != 0xa500) + failures++; + + if(int0 == 0xa400) + failures++; + + if(int0 == 0x00a5) + failures++; +} + +/* compare to 0xabcd + assumes + char0 == 0xa5 + int0 == 0xabcd +*/ +void c_abcd(void) +{ +#ifdef COMPARE_OUT_OF_RANGE + if(char0 == 0xabcd) + failures++; +#endif + + if(int0 != 0xabcd) + failures++; + + if(int0 == 0xab00) + failures++; + + if(int0 == 0x00cd) + failures++; + + if(int0 == 0x05cd) + failures++; + + if(int0 == 0xab05) + failures++; + + if(int0 == 0xab01) + failures++; + + if(int0 == 0x01cd) + failures++; + + if(int0 > 0) + failures++; + +#ifdef COMPARE_OUT_OF_RANGE + if(int0 == 0x1234abcd) + failures++; +#endif +} + +/* assumes char1 == 0 */ +void c_ifelse1(void) +{ + if(char0) + char0 = char1; + else + char0 = 0; + + if(char0) + failures++; +} + +/* + assumes long0 = -1 + assumes long1 = 1 +*/ +void c_minus1(void) +{ + printf("long0:%ld long1:%ld\n",long0,long1); + + printf("(long0 != -1)\n"); + if(long0 != -1) + { + LOG_ERROR(1); + failures++; + } + printf("(long0 > 0)\n"); + if(long0 > 0) + { + LOG_ERROR(1); + failures++; + } + printf("(long1 < 0)\n"); + if(long1 < 0) + { + LOG_ERROR(1); + failures++; + } +/* + if(long1 < 2) + failures++; +*/ +} + +/* assumes + long0 = long1 = ulong0 = ulong1 == 0 +*/ +void c_long2long_eq(void) +{ + if(long0 != long1) + failures++; + + if(ulong0 != ulong1) + failures++; + + if(long0 != ulong1) + failures++; + + if(long0 > long1) + failures++; + + if(long0 < long1) + failures++; + + if(long0 > ulong0) + failures++; + + if(long0 < ulong0) + failures++; +} + +/* assumes + long0 = ulong0 == 0 + long1 = ulong1 == 1 +*/ +void c_long2long_neq(void) +{ + if(long0 == long1) + failures++; + + if(ulong0 == ulong1) + failures++; + + if(long1 != ulong1) + failures++; + + if(long1 < long0) + failures++; + + if(long1 <= long0) + failures++; + + if(ulong1 < ulong0) + failures++; + + if(ulong1 <= ulong0) + failures++; +} + +/* long0=-100; + long1=-1000; +*/ +void +c_long2neglit(void) +{ + if(long0>0) + failures++; + if(long1>0) + failures++; + + if(long1 > long0) + failures++; + + if(long1 > 100) + failures++; + + if(long0 > -50) + failures++; + + if(long1 < -5000) + failures++; +} + +int +main (void) +{ + c_0(); + printf("c_0: %d\n",failures); + + c_long2long_eq(); + printf("c_long2long_eq: %d\n",failures); + + long1 = 1; + ulong1 = 1; + c_1(); + printf("c_1: %d\n",failures); + c_long2long_neq(); + printf("c_long2long_neq: %d\n",failures); + + long0 = 2; + ulong0 = 2; + c_2(); + printf("c_2: %d\n",failures); + + long0 = 0xff; + ulong0 = 0xff; + c_ff(); + printf("c_ff: %d\n",failures); + + long0 = 0x200; + ulong0 = 0x200; + c_200(); + printf("c_200: %d\n",failures); + + long0 = 0x20000; + ulong0 = 0x20000; + c_20000(); + printf("c_20000: %d\n",failures); + + long0 = -1; + c_minus1(); + printf("c_minus1: %d\n",failures); + + long0=-100; + long1=-1000; + c_long2neglit(); + printf("c_long2neglit: %d\n",failures); + + success = failures; + done (); + + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/compare6.c b/test/val/compare6.c new file mode 100644 index 000000000..85f16a1c4 --- /dev/null +++ b/test/val/compare6.c @@ -0,0 +1,176 @@ +/* + !!DESCRIPTION!! Compound comparisons + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +int int0 = 0; +int int1 = 0; +unsigned char uchar0 = 0; +unsigned char uchar1 = 0; +char char0 = 0; +char char1 = 0; +char long0 = 0; +char long1 = 0; + +void +done () +{ + dummy++; +} + +void c_char(void) +{ + if(char0 || char1) + failures++; + + if(char0 && char1) + failures++; + + if(char0 > char1) + failures++; + + if((char0+1) < char1) + failures++; + + if((char0+5) >= (char1+9)) + failures++; + + char0++; + + if(char0 && char1) + failures++; + + if(char0 != (char1+1) ) + failures++; + + if(!char0) + failures++; + + if(char1 || !char0) + failures++; + + if((char0 >5 ) && (char0 < 10)) + failures++; + + char0 +=5; /* char0 = 6 now */ + + if(!((char0 >5 ) && (char0 < 10))) + failures++; +} + +void c_int(void) +{ + if(int0 || int1) + failures++; + + if(int0 && int1) + failures++; + + if(int0 > int1) + failures++; + + if((int0+1) < int1) + failures++; + + if((int0+5) >= (int1+9)) + failures++; + + int0++; + + if(int0 && int1) + failures++; + + if(int0 != (int1+1) ) + failures++; + + if(!int0) + failures++; + + if(int1 || !int0) + failures++; + + if((int0 >5 ) && (int0 < 10)) + failures++; + + int0 +=5; /* int0 = 6 now */ + + if(!((int0 >5 ) && (int0 < 10))) + failures++; +} + +void c_long(void) +{ + if(long0 || long1) + failures++; + + if(long0 && long1) + failures++; + + if(long0 > long1) + failures++; + + if((long0+1) < long1) + failures++; + + if((long0+5) >= (long1+9)) + failures++; + + long0++; + + if(long0 && long1) + failures++; + + if(long0 != (long1+1) ) + failures++; + + if(!long0) + failures++; + + if(long1 || !long0) + failures++; + + if((long0 >5 ) && (long0 < 10)) + failures++; + + long0 +=5; /* long0 = 6 now */ + + if(!((long0 >5 ) && (long0 < 10))) + failures++; +} + +void c_uminus(void) +{ + int1 = -int0; + if(int1 < 0) + failures++; +} + +int +main (void) +{ + c_char(); + c_int(); + c_long(); + + int0 = -1; + c_uminus(); + if(int1 != 1) + failures++; + + success = failures; + done (); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/compare7.c b/test/val/compare7.c new file mode 100644 index 000000000..6c9636dec --- /dev/null +++ b/test/val/compare7.c @@ -0,0 +1,307 @@ +/* + !!DESCRIPTION!! Signed comparisons of the form: (variable +#include + +/* This regression test exercises all of the boundary + conditions in literal less than comparisons. There + are numerous opportunities to optimize these comparison + and each one has an astonishing capability of failing + a boundary condition. +*/ +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; +unsigned char result = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +int int0 = 0; +int int1 = 0; +signed char char0 = 0; +signed char char1 = 0; +char long0 = 0; +char long1 = 0; + +/* *** NOTE *** This particular test takes quite a while to run + * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC). + * The WDT will reset the CPU if it's enabled. So disable it... +*/ + +void +done () +{ + dummy++; +} + +void c_char_lt_lit1(unsigned char expected_result) +{ + result = 0; + + if(char0 < -0x7f) + result |= 1; + + if(char0 < -1) + result |= 2; + + if(char0 < 0) + result |= 4; + + if(char0 < 1) + result |= 8; + + if(char0 < 0x7f) + result |= 0x10; + + if(result != expected_result) + failures++; +} + +void char_compare(void) +{ + char0 = 0x7f; + c_char_lt_lit1(0); + +/* return; */ + + char0 = 0x7e; + c_char_lt_lit1(0x10); + + char0 = 0x40; + c_char_lt_lit1(0x10); + + char0 = 0x2; + c_char_lt_lit1(0x10); + + char0 = 0x1; + c_char_lt_lit1(0x10); + + char0 = 0; + c_char_lt_lit1(0x18); + + char0 = -1; + c_char_lt_lit1(0x1c); + + char0 = -2; + c_char_lt_lit1(0x1e); + + char0 = -0x40; + c_char_lt_lit1(0x1e); + + char0 = -0x7e; + c_char_lt_lit1(0x1e); + + char0 = -0x7f; + c_char_lt_lit1(0x1e); + + char0 = 0x80; + c_char_lt_lit1(0x1f); + + /* Now test entire range */ + + for(char0=1; char0 != 0x7f; char0++) + c_char_lt_lit1(0x10); + + for(char0=-0x7f; char0 != -1; char0++) + c_char_lt_lit1(0x1e); +} + +void c_int_lt_lit1(unsigned char expected_result) +{ + result = 0; + + if(int0 < 0) + result |= 1; + + if(int0 < 1) + result |= 2; + + if(int0 < 0xff) + result |= 4; + + if(int0 < 0x100) + result |= 8; + + if(int0 < 0x0101) + result |= 0x10; + + if(int0 < 0x01ff) + result |= 0x20; + + if(int0 < 0x0200) + result |= 0x40; + + if(int0 < 0x0201) + result |= 0x80; + + if(result != expected_result) + failures=1; +} + +void int_compare1(void) +{ + int0 = -1; + c_int_lt_lit1(0xff); + + int0 = 0; + c_int_lt_lit1(0xfe); + + int0 = 1; + c_int_lt_lit1(0xfc); + + int0 = 2; + c_int_lt_lit1(0xfc); + + int0 = 0xfe; + c_int_lt_lit1(0xfc); + + int0 = 0xff; + c_int_lt_lit1(0xf8); + + int0 = 0x100; + c_int_lt_lit1(0xf0); + + int0 = 0x101; + c_int_lt_lit1(0xe0); + + int0 = 0x1fe; + c_int_lt_lit1(0xe0); + + int0 = 0x1ff; + c_int_lt_lit1(0xc0); + + int0 = 0x200; + c_int_lt_lit1(0x80); + + int0 = 0x201; + c_int_lt_lit1(0x0); + + int0 = 0x7f00; + c_int_lt_lit1(0x0); + + /* now check contiguous ranges */ + + for(int0 = -0x7fff; int0 != -1; int0++) + c_int_lt_lit1(0xff); + + for(int0 = 1; int0 != 0xff; int0++) + c_int_lt_lit1(0xfc); + + for(int0 = 0x201; int0 != 0x7fff; int0++) + c_int_lt_lit1(0); +} + +void c_int_lt_lit2(unsigned char expected_result) +{ + result = 0; + + if(int0 < -0x7fff) + result |= 1; + + if(int0 < -0x7f00) + result |= 2; + + if(int0 < -0x7eff) + result |= 4; + + if(int0 < -0x7e00) + result |= 8; + + if(int0 < -0x0101) + result |= 0x10; + + if(int0 < -0x0100) + result |= 0x20; + + if(int0 < -0xff) + result |= 0x40; + + if(int0 < -1) + result |= 0x80; + + if(result != expected_result) + failures=1; +} + +void int_compare2(void) +{ + int0 = -0x7fff; + c_int_lt_lit2(0xfe); + + int0 = -0x7f00; + c_int_lt_lit2(0xfc); + + int0 = -0x7eff; + c_int_lt_lit2(0xf8); + + int0 = -0x7e00; + c_int_lt_lit2(0xf0); + + int0 = -0x4567; + c_int_lt_lit2(0xf0); + + int0 = -0x200; + c_int_lt_lit2(0xf0); + + int0 = -0x102; + c_int_lt_lit2(0xf0); + + int0 = -0x101; + c_int_lt_lit2(0xe0); + + int0 = -0x100; + c_int_lt_lit2(0xc0); + + int0 = -0xff; + c_int_lt_lit2(0x80); + + int0 = -0x02; + c_int_lt_lit2(0x80); + + int0 = -0x01; + c_int_lt_lit2(0x00); + + int0 = 0; + c_int_lt_lit2(0x00); + + int0 = 1; + c_int_lt_lit2(0x00); + + int0 = 0x7fff; + c_int_lt_lit2(0x00); + + /* now check contiguous ranges */ + int0 = -0x7f01; + c_int_lt_lit2(0xfe); + + for(int0 = -0x7ffe; int0 != -0x7f01; int0++) + c_int_lt_lit2(0xfe); + + for(int0 = -0x7e00; int0 != -0x101; int0++) + c_int_lt_lit2(0xf0); + + for(int0 = -1; int0 != 0x7fff; int0++) + c_int_lt_lit2(0); +} + +int +main (void) +{ + char_compare(); + printf("failures: %d\n",failures); + + int_compare1(); + printf("failures: %d\n",failures); + int_compare2(); + + success = failures; + done (); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/compare8.c b/test/val/compare8.c new file mode 100644 index 000000000..0abff8c69 --- /dev/null +++ b/test/val/compare8.c @@ -0,0 +1,311 @@ +/* + !!DESCRIPTION!! Signed comparisons of the form: (variable>LIT) + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +/* This regression test exercises all of the boundary + conditions in literal less than comparisons. There + are numerous opportunities to optimize these comparison + and each one has an astonishing capability of failing + a boundary condition. +*/ +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; +unsigned char result = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +int int0 = 0; +int int1 = 0; +unsigned char uchar0 = 0; +unsigned char uchar1 = 0; +signed char char0 = 0; +signed char char1 = 0; +char long0 = 0; +char long1 = 0; + +/* *** NOTE *** This particular test takes quite a while to run + * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC). + * The WDT will reset the CPU if it's enabled. So disable it... +*/ + +void +done () +{ + dummy++; +} + +void c_char_gt_lit1(unsigned char expected_result) +{ + result = 0; + + if(char0 > -0x7f) + result |= 1; + + if(char0 > -1) + result |= 2; + + if(char0 > 0) + result |= 4; + + if(char0 > 1) + result |= 8; + + if(char0 > 0x7e) + result |= 0x10; + + if(char0 > 0x7f) + result |= 0x20; + + if(result != expected_result) + failures++; +} + +void char_compare(void) +{ + char0 = 0x7f; + c_char_gt_lit1(0x1f); + + char0 = 0x7e; + c_char_gt_lit1(0x0f); + + char0 = 0x40; + c_char_gt_lit1(0x0f); + + char0 = 0x2; + c_char_gt_lit1(0x0f); + + char0 = 0x1; + c_char_gt_lit1(0x07); + + char0 = 0; + c_char_gt_lit1(0x03); + + char0 = -1; + c_char_gt_lit1(0x01); + + char0 = -2; + c_char_gt_lit1(0x01); + + char0 = -0x40; + c_char_gt_lit1(0x01); + + char0 = -0x7e; + c_char_gt_lit1(0x01); + + char0 = -0x7f; + c_char_gt_lit1(0x00); + + char0 = 0x80; + c_char_gt_lit1(0x00); + + /* Now test entire range */ + + for(char0=2; char0 != 0x7f; char0++) + c_char_gt_lit1(0x0f); + + for(char0=-0x7e; char0 != -1; char0++) + c_char_gt_lit1(0x01); +} + +void c_int_gt_lit1(unsigned char expected_result) +{ + result = 0; + + if(int0 > 0) + result |= 1; + + if(int0 > 1) + result |= 2; + + if(int0 > 0xff) + result |= 4; + + if(int0 > 0x100) + result |= 8; + + if(int0 > 0x0101) + result |= 0x10; + + if(int0 > 0x01ff) + result |= 0x20; + + if(int0 > 0x0200) + result |= 0x40; + + if(int0 > 0x0201) + result |= 0x80; + + if(result != expected_result) + failures=1; +} + +void int_compare1(void) +{ + int0 = -1; + c_int_gt_lit1(0x00); + + int0 = 0; + c_int_gt_lit1(0x00); + + int0 = 1; + c_int_gt_lit1(0x01); + + int0 = 2; + c_int_gt_lit1(0x03); + + int0 = 0xfe; + c_int_gt_lit1(0x03); + + int0 = 0xff; + c_int_gt_lit1(0x03); + + int0 = 0x100; + c_int_gt_lit1(0x07); + + int0 = 0x101; + c_int_gt_lit1(0x0f); + + int0 = 0x102; + c_int_gt_lit1(0x1f); + + int0 = 0x1fe; + c_int_gt_lit1(0x1f); + + int0 = 0x1ff; + c_int_gt_lit1(0x1f); + + int0 = 0x200; + c_int_gt_lit1(0x3f); + + int0 = 0x201; + c_int_gt_lit1(0x7f); + + int0 = 0x7f00; + c_int_gt_lit1(0xff); + + /* now check contiguous ranges */ + + for(int0 = -0x7fff; int0 != -1; int0++) + c_int_gt_lit1(0x00); + + for(int0 = 2; int0 != 0xff; int0++) + c_int_gt_lit1(0x03); + + for(int0 = 0x202; int0 != 0x7fff; int0++) + c_int_gt_lit1(0xff); +} + +void c_int_gt_lit2(unsigned char expected_result) +{ + result = 0; + + if(int0 > -0x7fff) + result |= 1; + + if(int0 > -0x7f00) + result |= 2; + + if(int0 > -0x7eff) + result |= 4; + + if(int0 > -0x7e00) + result |= 8; + + if(int0 > -0x0101) + result |= 0x10; + + if(int0 > -0x0100) + result |= 0x20; + + if(int0 > -0xff) + result |= 0x40; + + if(int0 > -1) + result |= 0x80; + + if(result != expected_result) + failures=1; +} + +void int_compare2(void) +{ + int0 = -0x7fff; + c_int_gt_lit2(0x00); + + int0 = -0x7f00; + c_int_gt_lit2(0x01); + + int0 = -0x7eff; + c_int_gt_lit2(0x03); + + int0 = -0x7e00; + c_int_gt_lit2(0x07); + + int0 = -0x7dff; + c_int_gt_lit2(0x0f); + + int0 = -0x4567; + c_int_gt_lit2(0x0f); + + int0 = -0x200; + c_int_gt_lit2(0x0f); + + int0 = -0x102; + c_int_gt_lit2(0x0f); + + int0 = -0x101; + c_int_gt_lit2(0x0f); + + int0 = -0x100; + c_int_gt_lit2(0x1f); + + int0 = -0xff; + c_int_gt_lit2(0x3f); + + int0 = -0x02; + c_int_gt_lit2(0x7f); + + int0 = -0x01; + c_int_gt_lit2(0x7f); + + int0 = 0; + c_int_gt_lit2(0xff); + + int0 = 1; + c_int_gt_lit2(0xff); + + int0 = 0x7fff; + c_int_gt_lit2(0xff); + + /* now check contiguous ranges */ + + for(int0 = -0x7ffe; int0 != -0x7f01; int0++) + c_int_gt_lit2(0x01); + + for(int0 = -0x7dff; int0 != -0x101; int0++) + c_int_gt_lit2(0x0f); + + for(int0 = 0; int0 != 0x7fff; int0++) + c_int_gt_lit2(0xff); +} + +int +main (void) +{ + char_compare(); + int_compare1(); + int_compare2(); + + success = failures; + done (); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/compare9.c b/test/val/compare9.c new file mode 100644 index 000000000..4a3714199 --- /dev/null +++ b/test/val/compare9.c @@ -0,0 +1,297 @@ +/* + !!DESCRIPTION!! Signed comparisons of the form: (variable<=LIT) + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +/* + This regression test exercises all of the boundary + conditions in literal less than or equal comparisons. There + are numerous opportunities to optimize these comparison + and each one has an astonishing capability of failing + a boundary condition. +*/ + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; +unsigned char result = 0; + +int int0 = 0; +int int1 = 0; +signed char char0 = 0; +signed char char1 = 0; + +/* *** NOTE *** This particular test takes quite a while to run + * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC). + * The WDT will reset the CPU if it's enabled. So disable it... +*/ + +void +done () +{ + dummy++; +} + +void c_char_lte_lit1(unsigned char expected_result) +{ + result = 0; + + if(char0 <= -0x7f) + result |= 1; + + if(char0 <= -1) + result |= 2; + + if(char0 <= 0) + result |= 4; + + if(char0 <= 1) + result |= 8; + + if(char0 <= 0x7f) + result |= 0x10; + + if(result != expected_result) + failures++; +} + +void char_compare(void) +{ + char0 = 0x7f; + c_char_lte_lit1(0x10); + + char0 = 0x7e; + c_char_lte_lit1(0x10); + + char0 = 0x40; + c_char_lte_lit1(0x10); + + char0 = 0x2; + c_char_lte_lit1(0x10); + + char0 = 0x1; + c_char_lte_lit1(0x18); + + char0 = 0; + c_char_lte_lit1(0x1c); + + char0 = -1; + c_char_lte_lit1(0x1e); + + char0 = -2; + c_char_lte_lit1(0x1e); + + char0 = -0x40; + c_char_lte_lit1(0x1e); + + char0 = -0x7e; + c_char_lte_lit1(0x1e); + + char0 = -0x7f; + c_char_lte_lit1(0x1f); + + char0 = 0x80; + /* c_char_lte_lit1(0x1f); */ + + /* Now test entire range */ + + for(char0=2; char0 != 0x7f; char0++) + c_char_lte_lit1(0x10); + + for(char0=-0x7e; char0 != 0; char0++) + c_char_lte_lit1(0x1e); +} + +void c_int_lte_lit1(unsigned char expected_result) +{ + result = 0; + + if(int0 <= 0) + result |= 1; + + if(int0 <= 1) + result |= 2; + + if(int0 <= 0xff) + result |= 4; + + if(int0 <= 0x100) + result |= 8; + + if(int0 <= 0x0101) + result |= 0x10; + + if(int0 <= 0x01ff) + result |= 0x20; + + if(int0 <= 0x0200) + result |= 0x40; + + if(int0 <= 0x0201) + result |= 0x80; + + if(result != expected_result) + failures=1; +} + +void int_compare1(void) +{ + int0 = -1; + c_int_lte_lit1(0xff); + + int0 = 0; + c_int_lte_lit1(0xff); + + int0 = 1; + c_int_lte_lit1(0xfe); + + int0 = 2; + c_int_lte_lit1(0xfc); + + int0 = 0xfe; + c_int_lte_lit1(0xfc); + + int0 = 0xff; + c_int_lte_lit1(0xfc); + + int0 = 0x100; + c_int_lte_lit1(0xf8); + + int0 = 0x101; + c_int_lte_lit1(0xf0); + + int0 = 0x1fe; + c_int_lte_lit1(0xe0); + + int0 = 0x1ff; + c_int_lte_lit1(0xe0); + + int0 = 0x200; + c_int_lte_lit1(0xc0); + + int0 = 0x201; + c_int_lte_lit1(0x80); + + int0 = 0x7f00; + c_int_lte_lit1(0x0); + + /* now check contiguous ranges */ + + for(int0 = -0x7fff; int0 != 1; int0++) + c_int_lte_lit1(0xff); + + for(int0 = 2; int0 != 0xff; int0++) + c_int_lte_lit1(0xfc); + + for(int0 = 0x202; int0 != 0x7fff; int0++) + c_int_lte_lit1(0); +} + +void c_int_lte_lit2(unsigned char expected_result) +{ + result = 0; + + if(int0 <= -0x7fff) + result |= 1; + + if(int0 <= -0x7f00) + result |= 2; + + if(int0 <= -0x7eff) + result |= 4; + + if(int0 <= -0x7e00) + result |= 8; + + if(int0 <= -0x0101) + result |= 0x10; + + if(int0 <= -0x0100) + result |= 0x20; + + if(int0 <= -0xff) + result |= 0x40; + + if(int0 <= -1) + result |= 0x80; + + if(result != expected_result) + failures=1; +} + +void int_compare2(void) +{ + int0 = -0x7fff; + c_int_lte_lit2(0xff); + + int0 = -0x7f00; + c_int_lte_lit2(0xfe); + + int0 = -0x7eff; + c_int_lte_lit2(0xfc); + + int0 = -0x7e00; + c_int_lte_lit2(0xf8); + + int0 = -0x4567; + c_int_lte_lit2(0xf0); + + int0 = -0x200; + c_int_lte_lit2(0xf0); + + int0 = -0x102; + c_int_lte_lit2(0xf0); + + int0 = -0x101; + c_int_lte_lit2(0xf0); + + int0 = -0x100; + c_int_lte_lit2(0xe0); + + int0 = -0xff; + c_int_lte_lit2(0xc0); + + int0 = -0x02; + c_int_lte_lit2(0x80); + + int0 = -0x01; + c_int_lte_lit2(0x80); + + int0 = 0; + c_int_lte_lit2(0x00); + + int0 = 1; + c_int_lte_lit2(0x00); + + int0 = 0x7fff; + c_int_lte_lit2(0x00); + + /* now check contiguous ranges */ + + for(int0 = -0x7ffe; int0 != -0x7f00; int0++) + c_int_lte_lit2(0xfe); + + for(int0 = -0x7dff; int0 != -0x101; int0++) + c_int_lte_lit2(0xf0); + + for(int0 = 0; int0 != 0x7fff; int0++) + c_int_lte_lit2(0); +} + +int +main (void) +{ + char_compare(); + int_compare1(); + int_compare2(); + + success = failures; + done (); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/cq22.c b/test/val/cq22.c new file mode 100644 index 000000000..4ce40ecc0 --- /dev/null +++ b/test/val/cq22.c @@ -0,0 +1,144 @@ +/* + !!DESCRIPTION!! C-Manual Chapter 2.2: identifiers (names) + !!ORIGIN!! LCC 4.1 Testsuite + !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC +*/ + +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 */ + #ifndef NO_FLOATS + float fprec; /* Smallest number that can be */ + float dprec; /* significantly added to 1. */ + #endif + 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 */ +}; + + int lbits; /* long */ + int ubits; /* unsigned */ + int fbits; /* float */ + int dbits; /* double */ + #ifndef NO_FLOATS + float fprec; /* Smallest number that can be */ + float dprec; /* significantly added to 1. */ + #endif + 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 */ + +/* + 2.2 Identifiers (Names) +*/ + +#ifndef NO_OLD_FUNC_DECL +s22(pd0) +struct defs *pd0; +{ +#else +int s22(struct defs *pd0) +{ +#endif + + 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); +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#define cq_sections 1 + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s22(pd0); + } +} + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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 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 defined(REFERENCE) && defined(REFCC_SIZEOF_LONG_64BIT) +/*#warning "sizeof(long)!=4, skipping test"*/ +#else + 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); + } +#endif + /* 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; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#define cq_sections 1 + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s241(pd0); + } +} + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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); + } + + #ifndef NO_BACKSLASH_CHARCODE + + /* Finally, the escape \ddd consists of the backslash followed + by 1, 2, or 3 octal digits which are taken to specify the + desired character. */ + +/* + this test is non portable and inaccurate, we replace it + by a more failproof version + + 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 + ) +*/ + if( + ('0' != '\60') || + ('9' != '\71') || + ('A' != '\101') || + ('Z' != '\132') || + ('a' != '\141') || + ('z' != '\172') + ) + + { + rc = rc+8; + if(pd0->flgd != 0) + { + printf(s243er,8); + } + } + + #endif + + return rc; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#define cq_sections 1 + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s243(pd0); + } +} + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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; + + #else + + return 0; + + #endif +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#define cq_sections 1 + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s244(pd0); + } +} + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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; jflgd != 0) printf(s25er,32); + } + return rc; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#define cq_sections 1 + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s25(pd0); + } +} + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + + 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); + #ifndef NO_FLOATS + pd0->fbits = pd0->cbits * sizeof(float); + pd0->dbits = pd0->cbits * sizeof(double); + #endif + + /* 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. */ + +#ifndef NO_FLOATS + 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.; +#endif + + /* Now, if anyone's interested, we publish the results. */ + +#ifndef CQ26_INCLUDED + 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"); + #ifndef NO_FLOATS + printf(s2,pd0->fprec,"float"); + printf(s2,pd0->dprec,"double"); + #else + printf("NO_FLOATS\n"); + #endif + } +#endif + /* Since we are only exploring and perhaps reporting, but not + testing any features, we cannot return an error code. */ + + return 0; +} + +#ifndef CQ26_INCLUDED + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s26(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + + 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; +} + +#ifndef NO_OLD_FUNC_DECL +svtest(n) +int n; +{ +#else +int svtest(int n) { +#endif + + 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; +} + +/* Sets an external variable. Used */ +/* by s4, and should be compiled */ +/* separately from s4. */ + +setev(){ +#ifndef NO_SLOPPY_EXTERN + extern int extvar; +#endif + extvar = 1066; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s4(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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,.?/"; + 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; + + printf(s61ok,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); + } + else if(pd0->flgd != 0) printf(s61ok,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); + } + else if(pd0->flgd != 0) printf(s61ok,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); + } + else if(pd0->flgd != 0) printf(s61ok,8); + + return rc; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + /*case 0: return s26(pd0);*/ + case 0: return s61(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + + 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); + #ifndef NO_FLOATS + pd0->fbits = pd0->cbits * sizeof(float); + pd0->dbits = pd0->cbits * sizeof(double); + #endif + + /* 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. */ + +#ifndef NO_FLOATS + 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.; +#endif + + /* Now, if anyone's interested, we publish the results. */ + +#ifndef CQ26_INCLUDED + 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"); + #ifndef NO_FLOATS + printf(s2,pd0->fprec,"float"); + printf(s2,pd0->dprec,"double"); + #else + printf("NO_FLOATS\n"); + #endif + } +#endif + /* Since we are only exploring and perhaps reporting, but not + testing any features, we cannot return an error code. */ + + return 0; +} + +int extvar; + +#ifndef NO_OLD_FUNC_DECL +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; +{ +#else +int s626(struct defs *pd0){ +#endif + static char s626er[] = "s626,er%d\n"; + static char qs626[8] = "s626 "; + int rc; + char *ps, *pt; + #ifndef NO_FLOATS + float eps, f1, f2, f3, f4, f; + #endif + long lint1, lint2, l, ls; + char c, t[28], t0; + short s; + int is, i, j; + unsigned u, us; + #ifndef NO_FLOATS + double d, ds; + #endif + ps = qs626; + pt = pd0->rfs; + rc = 0; + while (*pt++ = *ps++); + + #ifndef NO_FLOATS + + /* Conversions of integral values to floating type are + well-behaved. */ + + f1 = 1.; + lint1 = 1.; + lint2 = 1.; + + for(j=0;jlbits-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"); + } + } + + #endif + + /* 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; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s26(pd0); + case 1: return s626(pd0); + } +} + +#define cq_sections 2 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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: */ + + #ifndef NO_FLOATS + + if(pd0->dprec != (*pd0).dprec){ + rc = rc+32; + if(pd0->flgd != 0) printf(s71er,32); + } + + #endif + + return rc; +} +#ifndef NO_OLD_FUNC_DECL +McCarthy(x) +int x; +{ +#else +int McCarthy(int x){ +#endif + if(x>100) return x-10; + else return McCarthy( McCarthy(x+11)); +} + +#ifndef NO_OLD_FUNC_DECL +clobber(x,y) +int x,*y; +#else +int clobber(int x,int *y) +#endif + +/* +#ifndef NO_OLD_FUNC_DECL +clobber(x,y) +int x, +#ifdef NO_TYPELESS_INT_PTR +int +#endif +*y; +{ +#else +int clobber(int x, +#ifdef NO_TYPELESS_INT_PTR +int +#endif +*y +){ +#endif +*/ + +{ + x = 3; + *y = 2; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + /*case 0: return s26(pd0);*/ + case 0: return s71(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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); + } + + #ifdef NO_FLOATS + fl = 5; cr = 2; + fl /= cr; + if(fl != 2){ + lrc = 232; + if(prlc) printf(f,lrc); + } + fl = 5; sr = 2; + fl /= sr; + if(fl != 2){ + lrc = 233; + if(prlc) printf(f,lrc); + } + fl = 5; ir = 2; + fl /= ir; + if(fl != 2){ + lrc = 234; + if(prlc) printf(f,lrc); + } + fl = 5; lr = 2; + fl /= lr; + if(fl != 2){ + lrc = 235; + if(prlc) printf(f,lrc); + } + fl = 5; ur = 2; + fl /= ur; + if(fl != 2){ + lrc = 236; + if(prlc) printf(f,lrc); + } + fl = 5; fr = 2; + fl /= fr; + if(fl != 2){ + lrc = 237; + if(prlc) printf(f,lrc); + } + fl = 5; dr = 2; + fl /= dr; + if(fl != 2){ + lrc = 238; + if(prlc) printf(f,lrc); + } + dl = 5; cr = 2; + dl /= cr; + if(dl != 2){ + lrc = 239; + if(prlc) printf(f,lrc); + } + dl = 5; sr = 2; + dl /= sr; + if(dl != 2){ + lrc = 240; + if(prlc) printf(f,lrc); + } + dl = 5; ir = 2; + dl /= ir; + if(dl != 2){ + lrc = 241; + if(prlc) printf(f,lrc); + } + dl = 5; lr = 2; + dl /= lr; + if(dl != 2){ + lrc = 242; + if(prlc) printf(f,lrc); + } + dl = 5; ur = 2; + dl /= ur; + if(dl != 2){ + lrc = 243; + if(prlc) printf(f,lrc); + } + dl = 5; fr = 2; + dl /= fr; + if(dl != 2){ + lrc = 244; + if(prlc) printf(f,lrc); + } + dl = 5; dr = 2; + dl /= dr; + if(dl != 2){ + lrc = 245; + if(prlc) printf(f,lrc); + } + #else + 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); + } + #endif + 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); + } + + if(lrc != 0) { + rc = 1; + if(pd0->flgd != 0) printf(s714er,1); + } + return rc; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s714(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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. + */ + + 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; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s714(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + /*case 0: return s26(pd0);*/ + case 0: return s715(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + + 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); + #ifndef NO_FLOATS + pd0->fbits = pd0->cbits * sizeof(float); + pd0->dbits = pd0->cbits * sizeof(double); + #endif + + /* 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. */ + +#ifndef NO_FLOATS + 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.; +#endif + + /* Now, if anyone's interested, we publish the results. */ + +#ifndef CQ26_INCLUDED + 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"); + #ifndef NO_FLOATS + printf(s2,pd0->fprec,"float"); + printf(s2,pd0->dprec,"double"); + #else + printf("NO_FLOATS\n"); + #endif + } +#endif + /* Since we are only exploring and perhaps reporting, but not + testing any features, we cannot return an error code. */ + + return 0; +} + +#ifndef NO_OLD_FUNC_DECL +s72(pd0) /* 7.2 Unary operators */ +struct defs *pd0; +{ +#else +int s72(struct defs *pd0){ +#endif + 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; + + #ifndef NO_FLOATS + double d; + float f; + #else + signed d; + signed f; + #endif + + 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;jibits;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; + s = 26; u = 26; + i = 26; + #ifndef NO_FLOATS + f = 26.; + d = 26.; + #else + f = 26; + d = 26; + #endif + + 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; + + #ifndef NO_FLOATS + 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; + #endif + + if(lrc != 0){ + rc = rc+16; + printf(s72er,16); + } + + /* The sizeof operator has been tested previously. */ + + return rc; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s26(pd0); + case 1: return s72(pd0); + } +} + +#define cq_sections 2 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + + 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); + #ifndef NO_FLOATS + pd0->fbits = pd0->cbits * sizeof(float); + pd0->dbits = pd0->cbits * sizeof(double); + #endif + + /* 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. */ + +#ifndef NO_FLOATS + 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.; +#endif + + /* Now, if anyone's interested, we publish the results. */ + +#ifndef CQ26_INCLUDED + 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"); + #ifndef NO_FLOATS + printf(s2,pd0->fprec,"float"); + printf(s2,pd0->dprec,"double"); + #else + printf("NO_FLOATS\n"); + #endif + } +#endif + /* Since we are only exploring and perhaps reporting, but not + testing any features, we cannot return an error code. */ + + return 0; +} + +#ifndef NO_OLD_FUNC_DECL +s757(pd0) /* 7.5 Shift operators */ + /* 7.6 Relational operators */ + /* 7.7 Equality operator */ +struct defs *pd0; +{ +#else +int s757(struct defs *pd0){ +#endif + 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<=kubits; k++){ + rs = 1; + ls = rs<<(pd0->ubits-1); + + rt = 0; + lt = ~rt>>k; + rt = ~rt<ubits;j++){ + if((j>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; aflgd != 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"); + + /* aflgd != 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; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s26(pd0); + case 1: return s757(pd0); + } +} + +#define cq_sections 2 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s7813(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + + 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; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s81(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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; + } + + /* kludges */ + #if defined(FORCE_POINTERS) | defined(NO_OLD_FUNC_DECL) + if(glork(4) != 4){ + if(pd0->flgd != 0) printf(s84er,2); + rc = rc+2; + } + #else + pfi = glork; + if((*pfi)(4) != 4){ + if(pd0->flgd != 0) printf(s84er,2); + rc = rc+2; + } + #endif + + /* 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]; + } + + #ifndef NO_FLOATS + sum = 0.; + #else + sum = 0; + #endif + 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; + + /* kludges */ + #if defined(FORCE_POINTERS) | defined(NO_OLD_FUNC_DECL) + if( array((int*)x3d,105,0) + +array((int*)x3d[i],35,35) + #else + if( array(x3d,105,0) + +array(x3d[i],35,35) + #endif + +array(x3d[i][j],7,49) + + x3d[i][j][k]-52){ + if(pd0->flgd != 0) printf(s84er,8); + rc = rc+8; + } + + return rc; +} + +#ifndef NO_OLD_FUNC_DECL +array(a,size,start) +int a[],size,start; +#else +int array(int a[],int size,int start) +#endif +{ +/* +#ifndef NO_OLD_FUNC_DECL +array(a,size,start) +int a[], +#else +int array(int a[], +#endif +#ifdef NO_TYPELESS_INT +int +#endif +#ifdef NO_TYPELESS_INT +int +#endif + +#ifndef NO_OLD_FUNC_DECL +start; { +#else +start){ +#endif +*/ + int i; + for(i=0; irfs; + 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{ + #ifdef NO_BITFIELDS + if(pd0->flgd != 0) printf("NO_BITFIELDS\n"); + #else + if(pd0->flgd != 0) printf(s85er,2); + rc = rc+2; + #endif + } + } + + 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; +} + +#ifdef NO_LOCAL_PROTOTYPES +int one(); +#endif + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s85(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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; +} +#ifndef NO_OLD_FUNC_DECL +one(){ +#else +int one(){ +#endif + return 1; +} +int *metricp; + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s86(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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. + */ + + #ifndef NO_FLOATS + z.re = 0.; + z.im = 0.; + zp = &z; + zp->re = 1.; + zp->im = 1.; + if(z.re+z.im != 2.){ + #else + z.re = 0; + z.im = 0; + zp = &z; + zp->re = 1; + zp->im = 1; + if(z.re+z.im != 2){ + #endif + if(pd0->flgd != 0) printf(s88er,4); + rc = rc+4; + } + + return rc; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s88(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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; jrfs; + 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; +} + +/********************************************************************************************* + the main loop that launches the sections +*********************************************************************************************/ + +#ifndef NO_TYPELESS_STRUCT_PTR + int section(int j,struct* pd0){ +#else + int section(int j,void* pd0){ +#endif + switch(j){ + case 0: return s9(pd0); + } +} + +#define cq_sections 1 + +/* + C REFERENCE MANUAL (main) +*/ + +#ifndef NO_OLD_FUNC_DECL +main(n,args) +int n; +char **args; +{ +#else +int main(int n,char **args) { +#endif + +int j; +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 +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int uint0 = 0; +unsigned int uint1 = 0; +unsigned char uchar0 = 0; +unsigned char uchar1 = 0; + +void done() +{ + dummy++; +} + +void for1(void) +{ + unsigned char i=0; + + for(i=0; i<10; i++) + uchar0++; + + if(uchar0 != 10) + failures++; +} + +void for2(void) +{ + unsigned char i=0; + + for(i=0; i<10; i++) + uchar0++; + + if(i < 10) + failures++; +} + +void for3(void) +{ + unsigned int i=0; + + for(i=0; i<10; i++) + uint0++; + + if(i < 10) + failures++; +} + +void for4(void) +{ + for(uint0=1; uint0<10; uint0++) + uchar0++; + + if(uchar0 != 9) + failures++; +} + +void for5(void) +{ + for(uint0=1; uint0<=10; uint0++) + uchar0++; + + if(uchar0 != 10) + failures++; +} + +void inc_uchar0(void) +{ + uchar0++; +} + +void for6(void) +{ + uchar0 = 0; + for(uint0=1; uint0<=10; uint0++) + inc_uchar0(); +} + +int main(void) +{ + for1(); + for2(); + for3(); + uchar0 = 0; + for4(); + uchar0 = 0; + for5(); + + for6(); + if(uchar0 != 10) + failures++; + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/mult1.c b/test/val/mult1.c new file mode 100644 index 000000000..831bde7ec --- /dev/null +++ b/test/val/mult1.c @@ -0,0 +1,117 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +#define TESTLIT 0x05 + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +signed char c1,c2,c3; +unsigned char uc1,uc2,uc3; + +unsigned int ui1,ui2,ui3; +signed int i1,i2; + +void done() +{ + dummy++; +} + +void m1(void) +{ + c1 = c1*5; /* char = char * lit */ + + c2 = c1 *c3; /* char = char * char */ + + uc1= uc1*5; /* uchar = uchar * lit * + uc2=uc1*uc3; /* uchar = uchar * uchar */ + + if(c2 != 25) + failures++; +} + +void m2(unsigned char uc) +{ + uc2 = uc1 * uc; + + if(uc2 != 0x20) + failures++; +} + +void m3(unsigned char uc) +{ + volatile unsigned char vuc; + + /* uchar = uchar * lit */ + /* testing literal multiply with same source and destination */ + vuc = uc; + uc2 = 0; + uc1 = vuc; uc1 = uc1*1; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*2; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*3; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*4; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*5; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*6; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*7; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*8; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*9; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*10; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*11; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*12; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*13; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*14; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*15; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*16; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*17; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*18; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*19; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*20; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*21; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*22; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*23; if( uc1 != (uc2+=TESTLIT) ) failures++; + uc1 = vuc; uc1 = uc1*24; if( uc1 != (uc2+=TESTLIT) ) failures++; + + uc1 = vuc; uc1 = uc1*31; if( uc1 != ((31*TESTLIT) & 0xff) ) failures++; + uc1 = vuc; uc1 = uc1*32; if( uc1 != ((32*TESTLIT) & 0xff) ) failures++; + uc1 = vuc; uc1 = uc1*64; if( uc1 != ((64*TESTLIT) & 0xff) ) failures++; + uc1 = vuc; uc1 = uc1*128;if( uc1 != ((128*TESTLIT)& 0xff) ) failures++; + + /* testing literal multiply with different source and destination */ + uc1 = vuc*1; if( uc1 != ((1*TESTLIT) & 0xff) ) failures++; + uc1 = vuc*2; if( uc1 != ((2*TESTLIT) & 0xff) ) failures++; + uc1 = vuc*4; if( uc1 != ((4*TESTLIT) & 0xff) ) failures++; +} + +int main(void) +{ + dummy = 0; + + c1 = 1; + c3 = 5; + + m1(); + + uc1 = 0x10; + m2(2); + + ui1 = uc1*uc2; /* uint = uchar * uchar */ + + i1 = c1*c2; /* int = char * char */ + + ui3 = ui1*ui2; /* uint = uint * unit */ + + /*m3(TESTLIT);*/ + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/nestfor.c b/test/val/nestfor.c new file mode 100644 index 000000000..735da21de --- /dev/null +++ b/test/val/nestfor.c @@ -0,0 +1,151 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int uint0 = 0; +unsigned int uint1 = 0; +unsigned char uchar0 = 0; +unsigned char uchar1 = 0; + +void dput(unsigned char val) +{ + /*PORTB = val; + PORTA = 0x01; + PORTA = 0x00; + */ +} + +void done() +{ + dummy++; +} + +/* both loops use the loop variable inside the inner loop */ +void for1(void) +{ + unsigned char i, j; + + uchar0 = 0; + uchar1 = 0; + for(i = 0; i < 3; i++) { + uchar0++; + for(j = 0; j < 4; j++) { + uchar1++; + dput(i); + dput(j); + } + } + if(uchar0 != 3) + failures++; + if(uchar1 != 12) + failures++; +} + +/* only the outer loop's variable is used inside, inner can be optimized into a repeat-loop */ +void for2(void) +{ + unsigned char i, j; + + uchar0 = 0; + uchar1 = 0; + for(i = 0; i < 3; i++) { + uchar0++; + for(j = 0; j < 4; j++) { + uchar1++; + dput(i); + } + } + if(uchar0 != 3) + failures++; + if(uchar1 != 12) + failures++; +} + +/* only the inner loop's variable is used inside */ +void for3(void) +{ + unsigned char i, j; + + uchar0 = 0; + uchar1 = 0; + for(i = 0; i < 3; i++) { + uchar0++; + for(j = 0; j < 4; j++) { + uchar1++; + dput(j); + } + } + if(uchar0 != 3) + failures++; + if(uchar1 != 12) + failures++; +} + +/* neither loop variable used inside the loops */ +void for4(void) +{ + unsigned char i, j; + + uchar0 = 0; + uchar1 = 0; + for(i = 0; i < 3; i++) { + uchar0++; + for(j = 0; j < 4; j++) { + uchar1++; + dput(uchar0); + dput(uchar1); + } + } + if(uchar0 != 3) + failures++; + if(uchar1 != 12) + failures++; +} + +/* like for1 but different condition in inner loop */ +void for5(void) +{ + unsigned char i, j; + + uchar0 = 0; + uchar1 = 0; + for(i = 0; i < 3; i++) { + uchar0++; + for(j = 10; j >= 5; j--) { + uchar1++; + dput(i); + dput(j); + } + } + if(uchar0 != 3) + failures++; + if(uchar1 != 18) + failures++; +} + +int main(void) +{ + for1(); + for2(); + for3(); + for4(); + for5(); + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/or1.c b/test/val/or1.c new file mode 100644 index 000000000..9e41d7a39 --- /dev/null +++ b/test/val/or1.c @@ -0,0 +1,192 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#if SUPPORT_BIT_TYPES +bit bit0 = 0; +bit bit1 = 0; +bit bit2 = 0; +#endif + +unsigned int uint0 = 0; +unsigned int uint1 = 0; +unsigned char uchar0 = 0; +unsigned char uchar1 = 0; +unsigned long ulong0 = 0; +unsigned long ulong1 = 0; + +void done() +{ + dummy++; +} + +/* uchar0 = 0; */ +void or_lit2uchar(void) +{ + if(uchar0) + failures++; + + uchar0 |= 1; + + if(uchar0 != 1) + failures++; + + uchar0 |= 2; + + if(uchar0 != 3) + failures++; + + uchar0 |= 0x0e; + + if(uchar0 != 0x0f) + failures++; +} + +void or_lit2uint(void) +{ + if(uint0) + failures++; + + uint0 |= 1; + if(uint0 != 1) + failures++; + + uint0 |= 2; + if(uint0 != 3) + failures++; + + uint0 |= 0x100; + if(uint0 != 0x103) + failures++; + + uint0 |= 0x102; + if(uint0 != 0x103) + failures++; + + uint0 |= 0x303; + if(uint0 != 0x303) + failures++; +} + +void or_lit2ulong(void) +{ + if(ulong0) + failures++; + + ulong0 |= 1; + if(ulong0 != 1) + failures++; + + ulong0 |= 2; + if(ulong0 != 3) + failures++; + + ulong0 |= 0x100; + if(ulong0 != 0x103) + failures++; + + ulong0 |= 0x102; + if(ulong0 != 0x103) + failures++; + + ulong0 |= 0x303; + if(ulong0 != 0x303) + failures++; + + ulong0 |= 0x80000000; + if(ulong0 != 0x80000303) + failures++; +} + +/*-----------*/ +void or_uchar2uchar(void) +{ + uchar0 |= uchar1; + + if(uchar0 != 1) + failures++; + + uchar1 |= 0x0f; + + uchar0 = uchar1 | 0x10; + + if(uchar0 != 0x1f) + failures++; +} + +void or_uint2uint(void) +{ + uint0 |= uint1; + + if(uint0 != 1) + failures++; + + uint1 |= 0x0f; + + uint0 = uint1 | 0x10; + + if(uint0 != 0x1f) + failures++; +} + +#if SUPPORT_BIT_TYPES + +void or_bits1(void) +{ + bit0 = bit0 | bit1 | bit2; +} + +void or_bits2(void) +{ + bit0 = bit1 | bit2; +} +#endif + +int main(void) +{ + or_lit2uchar(); + or_lit2uint(); + or_lit2ulong(); + + uchar0=0; + uchar1=1; + or_uchar2uchar(); + + uint0=0; + uint1=1; + or_uint2uint(); + +#if SUPPORT_BIT_TYPES + or_bits1(); + if(bit0) + failures++; + + or_bits2(); + if(bit0) + failures++; + + bit1=1; + or_bits1(); + if(!bit0) + failures++; + + or_bits2(); + if(!bit0) + failures++; +#endif + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/pointer1.c b/test/val/pointer1.c new file mode 100644 index 000000000..b108bfeb9 --- /dev/null +++ b/test/val/pointer1.c @@ -0,0 +1,134 @@ +/* + !!DESCRIPTION!! Pointer tests + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned char achar0 = 0; +unsigned char achar1 = 0; +unsigned char *acharP = 0; + +char buff[10]; + +void +done () +{ + dummy++; +} + +void +f1 (unsigned char *ucP) +{ + if (ucP == 0) + { + failures++; + return; + } + + if (*ucP) + failures++; +} + +void +f2 (unsigned int *uiP) +{ + if (uiP == 0) + { + failures++; + return; + } + + if (*uiP) + failures++; +} + +unsigned char * +f3 (void) +{ + return &achar0; +} + +void f4(unsigned char *ucP, unsigned char uc) +{ + if(!ucP) { + failures++; + return; + } + + if(*ucP != uc) + failures++; +} + +void init_array(char start_value) +{ + unsigned char c; + + for(c=0; c +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int uint0 = 0; +unsigned int uint1 = 0; + +/* + * BUG: if these aren't volatile, an overzealous optimizer or somthing + * wreaks havoc with the simple tests like "if(uchar != 3)failures++" + */ + +#if 0 +unsigned char uchar0 = 0; +unsigned char uchar1 = 0; +unsigned char uchar2 = 0; +#else +volatile unsigned char uchar0 = 0; +volatile unsigned char uchar1 = 0; +volatile unsigned char uchar2 = 0; +#endif + +#ifdef NO_IMPLICIT_FUNCPTR_CONV +void (*pfunc)(void); +void (*p1func)(void); +unsigned char (*pcfunc)(void); +#else +void (*pfunc)(); +void (*p1func)(); +unsigned char (*pcfunc)(); +#endif + +void done() +{ + dummy++; +} + +void call0(void) +{ + uchar0++; +} + +void call1(void) +{ + uchar1++; +} + +unsigned char call2(void) +{ + return uchar0 + 9; +} + +void docall0(void) +{ + pfunc = call0; + (pfunc)(); + if(uchar0 != 1) + failures++; +} + +void docall1() +{ + unsigned char i; + for(i = 0; i < 3; i++) { + (*p1func)(); + } +} + +#ifdef NO_IMPLICIT_FUNCPTR_CONV +void docall2( void(*pf)(void) ) +#else +void docall2( void(*pf)() ) +#endif +{ + unsigned char i; + for(i = 0; i < 2; i++) { + pf(); + } +} + +int main(void) +{ + docall0(); + + p1func = call1; + docall1(); + if(uchar1 != 3) + failures++; + if(uchar0 != 1) + failures++; + + p1func = call0; + docall1(); + if(uchar1 != 3) + failures++; + if(uchar0 != 4) + failures++; + + docall2(call0); + if(uchar1 != 3) + failures++; + if(uchar0 != 6) + failures++; + + docall2(call1); + if(uchar1 != 5) + failures++; + if(uchar0 != 6) + failures++; + + pcfunc = call2; + uchar2 = (*pcfunc)(); + if(uchar2 != 15) + failures++; + + uchar2 += (pcfunc)(); + uchar2 += pcfunc(); + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/rotate1.c b/test/val/rotate1.c new file mode 100644 index 000000000..b7d6e6484 --- /dev/null +++ b/test/val/rotate1.c @@ -0,0 +1,201 @@ +/* + !!DESCRIPTION!! Shift bytes left and right by a constant. + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned char achar0 = 0; +unsigned char achar1 = 0; +unsigned char achar2 = 0; + +void done() +{ + dummy++; +} + +void check(void) +{ + if(achar0 != achar1) + failures++; +} + +void shift_left_1(void) +{ + achar0 <<= 1; + + check(); +} + +void shift_left_2(void) +{ + achar0 <<= 2; + + if(achar0 != achar1) + failures++; +} + +void shift_left_3(void) +{ + achar0 <<= 3; + + if(achar0 != achar1) + failures++; +} + +void shift_left_4(void) +{ + achar0 <<= 4; + + if(achar0 != achar1) + failures++; +} + +void shift_left_5(void) +{ + achar0 <<= 5; + + if(achar0 != achar1) + failures++; +} + +void shift_left_6(void) +{ + achar0 <<= 6; + + if(achar0 != achar1) + failures++; +} + +void shift_left_7(void) +{ + achar0 <<= 7; + + if(achar0 != achar1) + failures++; +} + +void shift_right_1(void) +{ + achar0 >>= 1; + + check(); +} + +void shift_right_2(void) +{ + achar0 >>= 2; + + check(); +} + +void shift_right_3(void) +{ + achar0 >>= 3; + + check(); +} + +void shift_right_4(void) +{ + achar0 >>= 4; + + check(); +} + +void shift_right_5(void) +{ + achar0 >>= 5; + + check(); +} + +void shift_right_6(void) +{ + achar0 >>= 6; + + check(); +} + +void shift_right_7(void) +{ + achar0 >>= 7; + + check(); +} + +int main(void) +{ + /* call with both values zero */ + shift_left_1(); + + achar0 = 1; + achar1 = 2; + for(achar2=0; achar2<6; achar2++) { + shift_left_1(); + achar1 <<=1; + } + + achar0 = 1; + achar1 = 4; + shift_left_2(); + + achar0 = 1; + achar1 = 8; + shift_left_3(); + + achar0 = 1; + achar1 = 0x10; + shift_left_4(); + + achar0 = 1; + achar1 = 0x20; + shift_left_5(); + + achar0 = 1; + achar1 = 0x40; + shift_left_6(); + + achar0 = 1; + achar1 = 0x80; + shift_left_7(); + + achar0 = 2; + achar1 = 1; + shift_right_1(); + + achar0 = 4; + shift_right_2(); + + achar0 = 8; + shift_right_3(); + + achar0 = 0x10; + shift_right_4(); + + achar0 = 0x20; + shift_right_5(); + + achar0 = 0x40; + shift_right_6(); + + achar0 = 0x80; + shift_right_7(); + + success=failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/rotate2.c b/test/val/rotate2.c new file mode 100644 index 000000000..7622736aa --- /dev/null +++ b/test/val/rotate2.c @@ -0,0 +1,71 @@ +/* + !!DESCRIPTION!! Shift bytes left and right by a variable. + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned char achar0 = 0; +unsigned char achar1 = 0; +unsigned char achar2 = 0; +unsigned char achar3 = 0; + +void done() +{ + dummy++; +} + +void shift_right_var(void) +{ + achar0 >>= achar1; +} + +void shift_left_var(void) +{ + achar0 <<= achar1; +} + +void shift_int_left_1(void) +{ + aint0 <<= 1; +} + +int main(void) +{ + char i; + + achar0 = 1; + achar1 = 1; + shift_left_var(); + + if(achar0 !=2) + failures++; + + achar0 = 1; + achar1 = 1; + achar2 = 1; + for(i=0; i<7; i++) { + shift_left_var(); + achar2 <<= 1; + + if(achar2 != achar0) + failures++; + } + + success=failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/rotate3.c b/test/val/rotate3.c new file mode 100644 index 000000000..21b2dc370 --- /dev/null +++ b/test/val/rotate3.c @@ -0,0 +1,384 @@ +/* + !!DESCRIPTION!! Shift ints left and right + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +#ifdef SIZEOF_INT_16BIT +#if defined(__LINUX__) || defined(LINUX) +unsigned short aint0 = 0; +unsigned short aint1 = 0; + +#else +unsigned int aint0 = 0; +unsigned int aint1 = 0; + +#endif + +#else +unsigned int aint0 = 0; +unsigned int aint1 = 0; + +#endif +unsigned char achar0 = 0; +unsigned char achar1 = 0; +unsigned char achar2 = 0; +unsigned char achar3 = 0; + +void done() +{ + dummy++; +} + +void shift_int_left_1(void) +{ + aint0 <<= 1; +} + +void shift_int_left_2(void) +{ + aint0 <<= 2; +} + +void shift_int_left_3(void) +{ + aint0 <<= 3; +} + +void shift_int_left_4(void) +{ + aint0 <<= 4; +} + +void shift_int_left_5(void) +{ + aint0 <<= 5; +} + +void shift_int_left_6(void) +{ + aint0 <<= 6; +} + +void shift_int_left_7(void) +{ + aint0 <<= 7; +} + +void shift_int_left_8(void) +{ + aint0 <<= 8; +} + +void shift_int_left_9(void) +{ + aint0 <<= 9; +} + +void shift_int_left_10(void) +{ + aint0 <<= 10; +} + +void shift_int_left_11(void) +{ + aint0 <<= 11; +} + +void shift_int_left_12(void) +{ + aint0 <<= 12; +} + +void shift_int_left_13(void) +{ + aint0 <<= 13; +} + +void shift_int_left_14(void) +{ + aint0 <<= 14; +} + +void shift_int_left_15(void) +{ + aint0 <<= 15; +} + +/*****************************************************/ +void shift_int_right_1(void) +{ + aint0 >>= 1; +} + +void shift_int_right_2(void) +{ + aint0 >>= 2; +} + +void shift_int_right_3(void) +{ + aint0 >>= 3; +} + +void shift_int_right_4(void) +{ + aint0 >>= 4; +} + +void shift_int_right_5(void) +{ + aint0 >>= 5; +} + +void shift_int_right_6(void) +{ + aint0 >>= 6; +} + +void shift_int_right_7(void) +{ + aint0 >>= 7; +} + +void shift_int_right_8(void) +{ + aint0 >>= 8; +} + +void shift_int_right_9(void) +{ + aint0 >>= 9; +} + +void shift_int_right_10(void) +{ + aint0 >>= 10; +} + +void shift_int_right_11(void) +{ + aint0 >>= 11; +} + +void shift_int_right_12(void) +{ + aint0 >>= 12; +} + +void shift_int_right_13(void) +{ + aint0 >>= 13; +} + +void shift_int_right_14(void) +{ + aint0 >>= 14; +} + +void shift_int_right_15(void) +{ + aint0 >>= 15; +} + +/*****************************************************/ +int main(void) +{ + /*char i;*/ + aint0 = 0xabcd; + + shift_int_left_1(); + if(aint0 != 0x579a) + failures++; + + aint0 = 0xabcd; + + shift_int_left_2(); + if(aint0 != 0xaf34) + failures++; + + aint0 = 0xabcd; + + shift_int_left_3(); + if(aint0 != 0x5e68) + failures++; + + aint0 = 0xabcd; + + shift_int_left_4(); + if(aint0 != 0xbcd0) + failures++; + + aint0 = 0xabcd; + + shift_int_left_5(); + if(aint0 != 0x79a0) + failures++; + + aint0 = 0xabcd; + + shift_int_left_6(); + if(aint0 != 0xf340) + failures++; + + aint0 = 0xabcd; + + shift_int_left_7(); + if(aint0 != 0xe680) + failures++; + + aint0 = 0xabcd; + + shift_int_left_8(); + if(aint0 != 0xcd00) + failures++; + + aint0 = 0xabcd; + + shift_int_left_9(); + if(aint0 != 0x9a00) + failures++; + + aint0 = 0xabcd; + + shift_int_left_10(); + if(aint0 != 0x3400) + failures++; + + aint0 = 0xabcd; + + shift_int_left_11(); + if(aint0 != 0x6800) + failures++; + + aint0 = 0xabcd; + + shift_int_left_12(); + if(aint0 != 0xd000) + failures++; + + aint0 = 0xabcd; + + shift_int_left_13(); + if(aint0 != 0xa000) + failures++; + + aint0 = 0xabcd; + + shift_int_left_14(); + if(aint0 != 0x4000) + failures++; + + aint0 = 0xabcd; + + shift_int_left_15(); + if(aint0 != 0x8000) + failures++; + + /***********************/ + aint0 = 0xabcd; + + shift_int_right_1(); + if(aint0 != 0x55e6) + failures++; + + aint0 = 0xabcd; + + shift_int_right_2(); + if(aint0 != 0x2af3) + failures++; + + aint0 = 0xabcd; + + shift_int_right_3(); + if(aint0 != 0x1579) + failures++; + + aint0 = 0xabcd; + + shift_int_right_4(); + if(aint0 != 0x0abc) + failures++; + + aint0 = 0xabcd; + + shift_int_right_5(); + if(aint0 != 0x055e) + failures++; + + aint0 = 0xabcd; + + shift_int_right_6(); + if(aint0 != 0x02af) + failures++; + + aint0 = 0xabcd; + + shift_int_right_7(); + if(aint0 != 0x0157) + failures++; + + aint0 = 0xabcd; + + shift_int_right_8(); + if(aint0 != 0x00ab) + failures++; + + aint0 = 0xabcd; + + shift_int_right_9(); + if(aint0 != 0x0055) + failures++; + + aint0 = 0xabcd; + + shift_int_right_10(); + if(aint0 != 0x002a) + failures++; + + aint0 = 0xabcd; + + shift_int_right_11(); + if(aint0 != 0x0015) + failures++; + + aint0 = 0xabcd; + + shift_int_right_12(); + if(aint0 != 0x000a) + failures++; + + aint0 = 0xabcd; + + shift_int_right_13(); + if(aint0 != 0x0005) + failures++; + + aint0 = 0xabcd; + + shift_int_right_14(); + if(aint0 != 0x0002) + failures++; + + aint0 = 0xabcd; + + shift_int_right_15(); + if(aint0 != 0x0001) + failures++; + + success=failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/rotate4.c b/test/val/rotate4.c new file mode 100644 index 000000000..09b1ebf4c --- /dev/null +++ b/test/val/rotate4.c @@ -0,0 +1,228 @@ +/* + !!DESCRIPTION!! rotate bytes left and right by a constant. + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +#ifdef SIZEOF_INT_16BIT +#if defined(__LINUX__) || defined(LINUX) +unsigned short aint0 = 0; +unsigned short aint1 = 0; + +#else +unsigned int aint0 = 0; +unsigned int aint1 = 0; + +#endif + +#else +unsigned int aint0 = 0; +unsigned int aint1 = 0; + +#endif +unsigned char uchar0 = 0; +unsigned char uchar1 = 0; +unsigned char uchar2 = 0; + +void done() +{ + dummy++; +} + +void check(void) +{ + if(uchar0 != uchar1) + failures++; +} + +void rotate_left_1(void) +{ + uchar0 = (uchar0<<1) | (uchar0>>7); + + check(); +} + +void rotate_left_2(void) +{ + uchar0 = (uchar0<<2) | (uchar0>>6); + + check(); +} + +void rotate_left_3(void) +{ + uchar0 <<= 3; + + if(uchar0 != uchar1) + failures++; +} + +void rotate_left_4(void) +{ + uchar0 <<= 4; + + if(uchar0 != uchar1) + failures++; +} + +void rotate_left_5(void) +{ + uchar0 <<= 5; + + if(uchar0 != uchar1) + failures++; +} + +void rotate_left_6(void) +{ + uchar0 <<= 6; + + if(uchar0 != uchar1) + failures++; +} + +void rotate_left_7(void) +{ + uchar0 <<= 7; + + if(uchar0 != uchar1) + failures++; +} + +void rotate_right_1(void) +{ + uchar0 = (uchar0>>1) | (uchar0<<7); + + check(); +} + +void rotate_right_2(void) +{ + uchar0 = (uchar0>>2) | (uchar0<<6); + + check(); +} + +void rotate_right_3(void) +{ + uchar0 >>= 3; + + check(); +} + +void rotate_right_4(void) +{ + uchar0 >>= 4; + + check(); +} + +void rotate_right_5(void) +{ + uchar0 >>= 5; + + check(); +} + +void rotate_right_6(void) +{ + uchar0 >>= 6; + + check(); +} + +void rotate_right_7(void) +{ + uchar0 >>= 7; + + check(); +} + +int main(void) +{ + /* call with both values zero */ + rotate_left_1(); + + uchar0 = 1; + uchar1 = 2; + + rotate_left_1(); + + uchar0 = 0x80; + uchar1 = 1; + + rotate_left_1(); + + uchar1 = 2; + for(uchar2=0; uchar2<6; uchar2++) { + rotate_left_1(); + uchar1 <<=1; + } + + uchar0 = 1; + uchar1 = 4; + rotate_left_2(); + + uchar0 = 1; + uchar1 = 8; + rotate_left_3(); + + uchar0 = 1; + uchar1 = 0x10; + rotate_left_4(); + + uchar0 = 1; + uchar1 = 0x20; + rotate_left_5(); + + uchar0 = 1; + uchar1 = 0x40; + rotate_left_6(); + + uchar0 = 1; + uchar1 = 0x80; + rotate_left_7(); + + uchar0 = 2; + uchar1 = 1; + rotate_right_1(); + + uchar0 = 1; + uchar1 = 0x80; + rotate_right_1(); + + uchar0 = 4; + uchar1 = 1; + rotate_right_2(); + + uchar0 = 8; + rotate_right_3(); + + uchar0 = 0x10; + rotate_right_4(); + + uchar0 = 0x20; + rotate_right_5(); + + uchar0 = 0x40; + rotate_right_6(); + + uchar0 = 0x80; + rotate_right_7(); + + success=failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/rotate5.c b/test/val/rotate5.c new file mode 100644 index 000000000..501e2e567 --- /dev/null +++ b/test/val/rotate5.c @@ -0,0 +1,260 @@ +/* + !!DESCRIPTION!! Shift bytes left and right by a constant. + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +#ifdef SIZEOF_INT_16BIT +#if defined(__LINUX__) || defined(LINUX) +signed short aint0 = 0; +signed short aint1 = 0; + +#else +signed int aint0 = 0; +signed int aint1 = 0; + +#endif + +#else +signed int aint0 = 0; +signed int aint1 = 0; + +#endif +signed char achar0 = 0; +signed char achar1 = 0; +signed char achar2 = 0; + +void done() +{ + dummy++; +} + +void check(void) +{ + if(achar0 != achar1) + failures++; +} + +void shift_left_1(void) +{ + achar0 <<= 1; + + check(); +} + +void shift_left_2(void) +{ + achar0 <<= 2; + + if(achar0 != achar1) + failures++; +} + +void shift_left_3(void) +{ + achar0 <<= 3; + + if(achar0 != achar1) + failures++; +} + +void shift_left_4(void) +{ + achar0 <<= 4; + + if(achar0 != achar1) + failures++; +} + +void shift_left_5(void) +{ + achar0 <<= 5; + + if(achar0 != achar1) + failures++; +} + +void shift_left_6(void) +{ + achar0 <<= 6; + + if(achar0 != achar1) + failures++; +} + +void shift_left_7(void) +{ + achar0 <<= 7; + + if(achar0 != achar1) + failures++; +} + +void shift_right_1(void) +{ + achar0 >>= 1; + + check(); +} + +void shift_right_2(void) +{ + achar0 >>= 2; + + check(); +} + +void shift_right_3(void) +{ + achar0 >>= 3; + + check(); +} + +void shift_right_4(void) +{ + achar0 >>= 4; + + check(); +} + +void shift_right_5(void) +{ + achar0 >>= 5; + + check(); +} + +void shift_right_6(void) +{ + achar0 >>= 6; + + check(); +} + +void shift_right_7(void) +{ + achar0 >>= 7; + + check(); +} + +int main(void) +{ + /* call with both values zero */ + shift_left_1(); + printf("failures: %d\n",failures); + + achar0 = 1; + achar1 = 2; + for(achar2=0; achar2<6; achar2++) { + shift_left_1(); + achar1 <<=1; + } + printf("failures: %d\n",failures); + + achar0 = 1; + achar1 = 4; + shift_left_2(); + printf("failures: %d\n",failures); + + achar0 = 1; + achar1 = 8; + shift_left_3(); + printf("failures: %d\n",failures); + + achar0 = 1; + achar1 = 0x10; + shift_left_4(); + printf("failures: %d\n",failures); + + achar0 = 1; + achar1 = 0x20; + shift_left_5(); + printf("failures: %d\n",failures); + + achar0 = 1; + achar1 = 0x40; + shift_left_6(); + printf("failures: %d\n",failures); + + achar0 = 1; + achar1 = 0x80; + shift_left_7(); + printf("failures: %d\n",failures); + + achar0 = 2; + achar1 = 1; + shift_right_1(); + printf("failures: %d\n",failures); + + achar0 = 4; + shift_right_2(); + printf("failures: %d\n",failures); + + achar0 = 8; + shift_right_3(); + printf("failures: %d\n",failures); + + achar0 = 0x10; + shift_right_4(); + printf("failures: %d\n",failures); + + achar0 = 0x20; + shift_right_5(); + printf("failures: %d\n",failures); + + achar0 = 0x40; + shift_right_6(); + printf("failures: %d\n",failures); + + achar0 = 0xff; + achar1 = 0xff; + shift_right_1(); + printf("failures: %d\n",failures); + + achar0 = 0xfe; + achar1 = 0xff; + shift_right_1(); + printf("failures: %d\n",failures); + + achar0 = 0xfc; + shift_right_2(); + printf("failures: %d\n",failures); + + achar0 = 0xf8; + shift_right_3(); + printf("failures: %d\n",failures); + + achar0 = 0xf0; + shift_right_4(); + printf("failures: %d\n",failures); + + achar0 = 0xe0; + shift_right_5(); + printf("failures: %d\n",failures); + + achar0 = 0xc0; + shift_right_6(); + printf("failures: %d\n",failures); + + achar0 = 0x80; + achar1 = 0xff; + shift_right_7(); + + success=failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/rotate6.c b/test/val/rotate6.c new file mode 100644 index 000000000..9109e124e --- /dev/null +++ b/test/val/rotate6.c @@ -0,0 +1,158 @@ +/* + !!DESCRIPTION!! Shift bytes left and right by a variable. + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +#ifdef SIZEOF_INT_16BIT +#if defined(__LINUX__) || defined(LINUX) +signed short aint0 = 0; +signed short aint1 = 0; + +#else +signed int aint0 = 0; +signed int aint1 = 0; + +#endif + +#else +signed int aint0 = 0; +signed int aint1 = 0; + +#endif +signed char achar0 = 0; +signed char achar1 = 0; +signed char achar2 = 0; +signed char achar3 = 0; + +void done() +{ + dummy++; +} + +void shift_right_var(void) +{ + achar0 >>= achar1; +} + +void shift_left_var(void) +{ + achar0 <<= achar1; +} + +void shift_int_left_var(void) +{ + aint0 <<= achar1; +} + +void shift_int_right_var(void) +{ + aint0 >>= achar1; +} + +void shift_int_right_var2(void) +{ + aint0 = aint1 >> achar1; +} + +void shift_int_left_var2(void) +{ + aint0 = aint1 << achar1; +} + +int +main (void) +{ + char i; + + achar0 = 1; + achar1 = 1; + shift_left_var(); + + if(achar0 !=2) + failures++; + printf("failures: %d\n",failures); + + achar0 = 1; + achar1 = 1; + achar2 = 1; + for(i=0; i<7; i++) { + shift_left_var(); + achar2 <<= 1; + + if(achar2 != achar0) + failures++; + } + printf("failures: %d\n",failures); + + achar1 = 4; + achar0 = 0xf0; + shift_right_var(); + if(((unsigned char)achar0) != 0xff) + failures++; + printf("failures: %d\n",failures); + + aint0 = 1; + aint1 = 1; + achar1 = 1; + + for(i=0; i<15; i++) { + shift_int_left_var(); + aint1 <<= 1; + if(aint0 != aint1) + failures++; + } + printf("failures: %d\n",failures); + + aint0 = 0x4000; + aint1 = 0x4000; + + for(i=0; i<15; i++) { + shift_int_right_var(); + aint1 >>= 1; + if(aint0 != aint1) + failures++; + } + printf("failures: %d\n",failures); + + aint0 = -0x4000; + aint1 = -0x4000; + + for(i=0; i<15; i++) { + shift_int_right_var(); + aint1 >>= 1; + if(aint0 != aint1) + failures++; + } + printf("failures: %d\n",failures); + + aint1 = 0xf000; + achar1 = 10; + shift_int_right_var2(); + + if(((unsigned short)aint0) != 0xfffc) + failures++; + printf("failures: %d\n",failures); + + aint1 = aint0; + shift_int_left_var2(); + + if(((unsigned short)aint0) != 0xf000) + failures++; + + success=failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/rotate7.c b/test/val/rotate7.c new file mode 100644 index 000000000..2b30b86dd --- /dev/null +++ b/test/val/rotate7.c @@ -0,0 +1,413 @@ +/* + !!DESCRIPTION!! Shift ints left and right + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SIZEOF_INT_16BIT +#if defined(__LINUX__) || defined(LINUX) +signed short aint0 = 0; +signed short aint1 = 0; + +#else +signed int aint0 = 0; +signed int aint1 = 0; + +#endif + +#else +signed int aint0 = 0; +signed int aint1 = 0; + +#endif + +/* +signed char achar0 = 0; +signed char achar1 = 0; +signed char achar2 = 0; +signed char achar3 = 0; +*/ + +void done() +{ + dummy++; +} + +void shift_int_left_1(void) +{ + aint0 <<= 1; +} + +void shift_int_left_2(void) +{ + aint0 <<= 2; +} + +void shift_int_left_3(void) +{ + aint0 <<= 3; +} + +void shift_int_left_4(void) +{ + aint0 <<= 4; +} + +void shift_int_left_5(void) +{ + aint0 <<= 5; +} + +void shift_int_left_6(void) +{ + aint0 <<= 6; +} + +void shift_int_left_7(void) +{ + aint0 <<= 7; +} + +void shift_int_left_8(void) +{ + aint0 <<= 8; +} + +void shift_int_left_9(void) +{ + aint0 <<= 9; +} + +void shift_int_left_10(void) +{ + aint0 <<= 10; +} + +void shift_int_left_11(void) +{ + aint0 <<= 11; +} + +void shift_int_left_12(void) +{ + aint0 <<= 12; +} + +void shift_int_left_13(void) +{ + aint0 <<= 13; +} + +void shift_int_left_14(void) +{ + aint0 <<= 14; +} + +void shift_int_left_15(void) +{ + aint0 <<= 15; +} + +/*****************************************************/ +void shift_int_right_1(void) +{ + aint0 >>= 1; +} + +void shift_int_right_2(void) +{ + aint0 >>= 2; +} + +void shift_int_right_3(void) +{ + aint0 >>= 3; +} + +void shift_int_right_4(void) +{ + aint0 >>= 4; +} + +void shift_int_right_5(void) +{ + aint0 >>= 5; +} + +void shift_int_right_6(void) +{ + aint0 >>= 6; +} + +void shift_int_right_7(void) +{ + aint0 >>= 7; +} + +void shift_int_right_8(void) +{ + aint0 >>= 8; +} + +void shift_int_right_9(void) +{ + aint0 >>= 9; +} + +void shift_int_right_10(void) +{ + aint0 >>= 10; +} + +void shift_int_right_11(void) +{ + aint0 >>= 11; +} + +void shift_int_right_12(void) +{ + aint0 >>= 12; +} + +void shift_int_right_13(void) +{ + aint0 >>= 13; +} + +void shift_int_right_14(void) +{ + aint0 >>= 14; +} + +void shift_int_right_15(void) +{ + aint0 >>= 15; +} + +/*****************************************************/ +int +main (void) +{ + aint0 = 0xabcd; + + shift_int_left_1(); + if(aint0 != 0x579a) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_2(); + if((unsigned short)aint0 != 0xaf34) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_3(); + if(aint0 != 0x5e68) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_4(); + if((unsigned short)aint0 != 0xbcd0) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_5(); + if(aint0 != 0x79a0) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_6(); + if((unsigned short)aint0 != 0xf340) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_7(); + if((unsigned short)aint0 != 0xe680) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_8(); + if((unsigned short)aint0 != 0xcd00) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_9(); + if((unsigned short)aint0 != 0x9a00) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_10(); + if(aint0 != 0x3400) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_11(); + if(aint0 != 0x6800) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_12(); + if((unsigned short)aint0 != 0xd000) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_13(); + if((unsigned short)aint0 != 0xa000) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_14(); + if(aint0 != 0x4000) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_left_15(); + if((unsigned short)aint0 != 0x8000) + failures++; + printf("failures: %d\n",failures); + + /***********************/ + aint0 = 0xabcd; + + shift_int_right_1(); + if((unsigned short)aint0 != 0xd5e6) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_2(); + if((unsigned short)aint0 != 0xeaf3) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_3(); + if((unsigned short)aint0 != 0xf579) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_4(); + if((unsigned short)aint0 != 0xfabc) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_5(); + if((unsigned short)aint0 != 0xfd5e) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_6(); + if((unsigned short)aint0 != 0xfeaf) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_7(); + if((unsigned short)aint0 != 0xff57) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_8(); + if((unsigned short)aint0 != 0xffab) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_9(); + if((unsigned short)aint0 != 0xffd5) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_10(); + if((unsigned short)aint0 != 0xffea) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_11(); + if((unsigned short)aint0 != 0xfff5) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_12(); + if((unsigned short)aint0 != 0xfffa) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_13(); + if((unsigned short)aint0 != 0xfffd) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_14(); + if((unsigned short)aint0 != 0xfffe) + failures++; + printf("failures: %d\n",failures); + + aint0 = 0xabcd; + + shift_int_right_15(); + if(aint0 != -1) + failures++; + + success=failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/sitest.c b/test/val/sitest.c new file mode 100644 index 000000000..9570f4989 --- /dev/null +++ b/test/val/sitest.c @@ -0,0 +1,1591 @@ +/* + !!DESCRIPTION!! C99 WCHAR test + !!ORIGIN!! + !!LICENCE!! public domain +*/ + +/* + sitest -- exercise features of C99 and + + This source code has been placed into the PUBLIC DOMAIN by its author. + + last edit: 1999/11/05 gwyn@arl.mil + + Tries to accommodate pre-C99 versions of . + + Takes advantage of __Q8_* symbols defined by a particular + implementation of , but doesn't require them. + + NOTE: This is not a thorough validation test of the facilities. +*/ + +#define NO_INTERNAL_WCHAR +/*#define STANDALONE*/ + +#include +#include /* for CHAR_BIT */ +#include +#include /* for ptrdiff_t */ +#include +#include + +#if !defined(STANDARD_C99) && !defined(STANDARD_CC65) + +#error "this test checks C99 features, which are not available in the selected standard." + +#else + +#ifdef NO_WCHAR + +#warn "this test checks C99 features, but NO_WCHAR is defined so the test will most definetly fails." + +#endif + +#include /* embeds */ + +#include /* for sig_atomic_t */ + +#if defined(INTMAX_MAX) /* has C99 features */ +#include +#endif + +#include /* test idempotency */ + +#ifdef STANDALONE + +FILE *outfile=NULL; +#define opentest(x) outfile=stdout; +#define closetest(x) + +#else + +#endif + +#if __STDC_VERSION__ >= 199901 +#ifndef __Q8_QT +#define __Q8_QT long long +#endif +#endif + +#ifdef PRIdMAX +#define HAVE_PRIdMAX +#ifndef __Q8_MT +#define __Q8_MT intmax_t +#endif +#else +#ifdef PRIdLEAST64 +#ifndef __Q8_MT +#define __Q8_MT int_least64_t +#endif +#define PRIdMAX PRIdLEAST64 +#else +#ifndef __Q8_MT +#define __Q8_MT long +#endif +#define PRIdMAX "ld" +#endif +#endif + +#ifdef PRIuMAX +#define HAVE_PRIuMAX +#define U__Q8_MT uintmax_t +#else +#ifdef PRIuLEAST64 +#define U__Q8_MT uint_least64_t +#define PRIuMAX PRIuLEAST64 +#else +#define U__Q8_MT unsigned long +#define PRIuMAX "lu" +#endif +#endif + +#define STR_SUB(s) # s +#define STRINGIZE(s) STR_SUB(s) /* extra level to expand argument */ + +#if defined(SCNo32) || defined(PRIo32) +static int32_t int32; +#endif +static int_least16_t intl16; +static uint_least16_t uintl16; +static uint_fast16_t uintf16; +static intmax_t intmax; +static uintmax_t uintmax; + +int +main() { + int status = 0; /* exit status to be returned */ + + + /* features: */ + + printf("CHAR_BIT=%u\n", (unsigned)CHAR_BIT ); + printf("sizeof(char)=%u\n", (unsigned)sizeof(char)); /* s.b. 1 */ + printf("sizeof(short)=%u\n", (unsigned)sizeof(short)); + printf("sizeof(int)=%u\n", (unsigned)sizeof(int)); + printf("sizeof(long)=%u\n", (unsigned)sizeof(long)); +#ifdef __Q8_QT + printf("sizeof(long long)=%u\n", (unsigned)sizeof(__Q8_QT)); +#else + printf("*** long long isn't defined ***\n"); +#endif + printf("sizeof(intmax_t)=%u\n", (unsigned)sizeof(intmax_t)); + printf("sizeof(ptrdiff_t)=%u\n", (unsigned)sizeof(ptrdiff_t)); + printf("sizeof(size_t)=%u\n", (unsigned)sizeof(size_t)); + printf("sizeof(sig_atomic_t)=%u\n", (unsigned)sizeof(sig_atomic_t)); + printf("sizeof(wchar_t)=%u\n", (unsigned)sizeof(wchar_t)); +#if defined(WINT_MAX) || __STDC_VERSION__ >= 199901 + printf("sizeof(wint_t)=%u\n", (unsigned)sizeof(wint_t)); +#else + printf("*** wint_t isn't defined ***\n"); + status = EXIT_FAILURE; +#endif +#ifdef INT8_MAX + printf("sizeof(int8_t)=%u\n", (unsigned)sizeof(int8_t)); + printf("sizeof(uint8_t)=%u\n", (unsigned)sizeof(uint8_t)); +#endif +#ifdef INT9_MAX + printf("sizeof(int9_t)=%u\n", (unsigned)sizeof(int9_t)); + printf("sizeof(uint9_t)=%u\n", (unsigned)sizeof(uint9_t)); +#endif +#ifdef INT12_MAX + printf("sizeof(int12_t)=%u\n", (unsigned)sizeof(int12_t)); + printf("sizeof(uint12_t)=%u\n", (unsigned)sizeof(uint12_t)); +#endif +#ifdef INT16_MAX + printf("sizeof(int16_t)=%u\n", (unsigned)sizeof(int16_t)); + printf("sizeof(uint16_t)=%u\n", (unsigned)sizeof(uint16_t)); +#endif +#ifdef INT18_MAX + printf("sizeof(int18_t)=%u\n", (unsigned)sizeof(int18_t)); + printf("sizeof(uint18_t)=%u\n", (unsigned)sizeof(uint18_t)); +#endif +#ifdef INT24_MAX + printf("sizeof(int24_t)=%u\n", (unsigned)sizeof(int24_t)); + printf("sizeof(uint24_t)=%u\n", (unsigned)sizeof(uint24_t)); +#endif +#ifdef INT32_MAX + printf("sizeof(int32_t)=%u\n", (unsigned)sizeof(int32_t)); + printf("sizeof(uint32_t)=%u\n", (unsigned)sizeof(uint32_t)); +#endif +#ifdef INT36_MAX + printf("sizeof(int36_t)=%u\n", (unsigned)sizeof(int36_t)); + printf("sizeof(uint36_t)=%u\n", (unsigned)sizeof(uint36_t)); +#endif +#ifdef INT40_MAX + printf("sizeof(int40_t)=%u\n", (unsigned)sizeof(int40_t)); + printf("sizeof(uint40_t)=%u\n", (unsigned)sizeof(uint40_t)); +#endif +#ifdef INT48_MAX + printf("sizeof(int48_t)=%u\n", (unsigned)sizeof(int48_t)); + printf("sizeof(uint48_t)=%u\n", (unsigned)sizeof(uint48_t)); +#endif +#ifdef INT60_MAX + printf("sizeof(int60_t)=%u\n", (unsigned)sizeof(int60_t)); + printf("sizeof(uint60_t)=%u\n", (unsigned)sizeof(uint60_t)); +#endif +#ifdef INT64_MAX + printf("sizeof(int64_t)=%u\n", (unsigned)sizeof(int64_t)); + printf("sizeof(uint64_t)=%u\n", (unsigned)sizeof(uint64_t)); +#endif +#ifdef INT72_MAX + printf("sizeof(int72_t)=%u\n", (unsigned)sizeof(int72_t)); + printf("sizeof(uint72_t)=%u\n", (unsigned)sizeof(uint72_t)); +#endif +#ifdef INT128_MAX + printf("sizeof(int128_t)=%u\n", (unsigned)sizeof(int128_t)); + printf("sizeof(uint128_t)=%u\n", (unsigned)sizeof(uint128_t)); +#endif + printf("sizeof(int_least8_t)=%u\n", (unsigned)sizeof(int_least8_t)); + printf("sizeof(uint_least8_t)=%u\n", (unsigned)sizeof(uint_least8_t)); + printf("sizeof(int_least16_t)=%u\n", (unsigned)sizeof(int_least16_t)); + printf("sizeof(uint_least16_t)=%u\n", (unsigned)sizeof(uint_least16_t)); + printf("sizeof(int_least32_t)=%u\n", (unsigned)sizeof(int_least32_t)); + printf("sizeof(uint_least32_t)=%u\n", (unsigned)sizeof(uint_least32_t)); +#ifdef INT_LEAST64_MAX + printf("sizeof(int_least64_t)=%u\n", (unsigned)sizeof(int_least64_t)); + printf("sizeof(uint_least64_t)=%u\n", (unsigned)sizeof(uint_least64_t)); +#else + printf("*** uint_least64_t isn't defined ***\n"); + status = EXIT_FAILURE; +#endif +#ifdef INT_LEAST128_MAX + printf("sizeof(int_least128_t)=%u\n", (unsigned)sizeof(int_least128_t)); + printf("sizeof(uint_least128_t)=%u\n", + (unsigned)sizeof(uint_least128_t)); +#endif + printf("sizeof(int_fast8_t)=%u\n", (unsigned)sizeof(int_fast8_t)); + printf("sizeof(uint_fast8_t)=%u\n", (unsigned)sizeof(uint_fast8_t)); + printf("sizeof(int_fast16_t)=%u\n", (unsigned)sizeof(int_fast16_t)); + printf("sizeof(uint_fast16_t)=%u\n", (unsigned)sizeof(uint_fast16_t)); + printf("sizeof(int_fast32_t)=%u\n", (unsigned)sizeof(int_fast32_t)); + printf("sizeof(uint_fast32_t)=%u\n", (unsigned)sizeof(uint_fast32_t)); +#ifdef INT_FAST64_MAX + printf("sizeof(int_fast64_t)=%u\n", (unsigned)sizeof(int_fast64_t)); + printf("sizeof(uint_fast64_t)=%u\n", (unsigned)sizeof(uint_fast64_t)); +#else + printf("*** int_fast64_t isn't defined ***\n"); + status = EXIT_FAILURE; +#endif +#ifdef INT_FAST128_MAX + printf("sizeof(int_fast128_t)=%u\n", (unsigned)sizeof(int_fast128_t)); + printf("sizeof(uint_fast128_t)=%u\n", (unsigned)sizeof(uint_fast128_t)); +#endif +#if defined(INTPTR_MAX) + printf("sizeof(intptr_t)=%u\n", (unsigned)sizeof(intptr_t)); +#if defined(UINTPTR_MAX) + printf("sizeof(uintptr_t)=%u\n", (unsigned)sizeof(uintptr_t)); +#else + printf("*** intptr_t is defined but uintptr_t isn't ***\n"); + status = EXIT_FAILURE; +#endif +#elif defined(UINTPTR_MAX) + printf("sizeof(uintptr_t)=%u\n", (unsigned)sizeof(uintptr_t)); + printf("*** uintptr_t is defined but intptr_t isn't ***\n"); + status = EXIT_FAILURE; +#else + printf("*** neither intptr_t nor uintptr_t is defined ***\n"); + status = EXIT_FAILURE; +#endif +#ifdef INTMAX_MAX + printf("sizeof(intmax_t)=%u\n", (unsigned)sizeof(intmax_t)); + printf("sizeof(uintmax_t)=%u\n", (unsigned)sizeof(uintmax_t)); +#else + printf("*** intmax_t isn't defined ***\n"); + status = EXIT_FAILURE; +#endif + +#ifdef INT8_MAX + printf("INT8_MIN=%"PRIdMAX"\n", (__Q8_MT)INT8_MIN); + printf("INT8_MAX=%"PRIdMAX"\n", (__Q8_MT)INT8_MAX); + printf("UINT8_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT8_MAX); +#endif +#ifdef INT9_MAX + printf("INT9_MIN=%"PRIdMAX"\n", (__Q8_MT)INT9_MIN); + printf("INT9_MAX=%"PRIdMAX"\n", (__Q8_MT)INT9_MAX); + printf("UINT9_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT9_MAX); +#endif +#ifdef INT12_MAX + printf("INT12_MIN=%"PRIdMAX"\n", (__Q8_MT)INT12_MIN); + printf("INT12_MAX=%"PRIdMAX"\n", (__Q8_MT)INT12_MAX); + printf("UINT12_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT12_MAX); +#endif +#ifdef INT16_MAX + printf("INT16_MIN=%"PRIdMAX"\n", (__Q8_MT)INT16_MIN); + printf("INT16_MAX=%"PRIdMAX"\n", (__Q8_MT)INT16_MAX); + printf("UINT16_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT16_MAX); +#endif +#ifdef INT18_MAX + printf("INT18_MIN=%"PRIdMAX"\n", (__Q8_MT)INT18_MIN); + printf("INT18_MAX=%"PRIdMAX"\n", (__Q8_MT)INT18_MAX); + printf("UINT18_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT18_MAX); +#endif +#ifdef INT24_MAX + printf("INT24_MIN=%"PRIdMAX"\n", (__Q8_MT)INT24_MIN); + printf("INT24_MAX=%"PRIdMAX"\n", (__Q8_MT)INT24_MAX); + printf("UINT24_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT24_MAX); +#endif +#ifdef INT32_MAX + printf("INT32_MIN=%"PRIdMAX"\n", (__Q8_MT)INT32_MIN); + printf("INT32_MAX=%"PRIdMAX"\n", (__Q8_MT)INT32_MAX); + printf("UINT32_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT32_MAX); +#endif +#ifdef INT36_MAX + printf("INT36_MIN=%"PRIdMAX"\n", (__Q8_MT)INT36_MIN); + printf("INT36_MAX=%"PRIdMAX"\n", (__Q8_MT)INT36_MAX); + printf("UINT36_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT36_MAX); +#endif +#ifdef INT40_MAX + printf("INT40_MIN=%"PRIdMAX"\n", (__Q8_MT)INT40_MIN); + printf("INT40_MAX=%"PRIdMAX"\n", (__Q8_MT)INT40_MAX); + printf("UINT40_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT40_MAX); +#endif +#ifdef INT48_MAX + printf("INT48_MIN=%"PRIdMAX"\n", (__Q8_MT)INT48_MIN); + printf("INT48_MAX=%"PRIdMAX"\n", (__Q8_MT)INT48_MAX); + printf("UINT48_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT48_MAX); +#endif +#ifdef INT60_MAX + printf("INT60_MIN=%"PRIdMAX"\n", (__Q8_MT)INT60_MIN); + printf("INT60_MAX=%"PRIdMAX"\n", (__Q8_MT)INT60_MAX); + printf("UINT60_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT60_MAX); +#endif +#ifdef INT64_MAX + printf("INT64_MIN=%"PRIdMAX"\n", (__Q8_MT)INT64_MIN); + printf("INT64_MAX=%"PRIdMAX"\n", (__Q8_MT)INT64_MAX); + printf("UINT64_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT64_MAX); +#endif +#ifdef INT72_MAX + printf("INT72_MIN=%"PRIdMAX"\n", (__Q8_MT)INT72_MIN); + printf("INT72_MAX=%"PRIdMAX"\n", (__Q8_MT)INT72_MAX); + printf("UINT72_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT72_MAX); +#endif +#ifdef INT128_MAX + printf("INT128_MIN=%"PRIdMAX"\n", (__Q8_MT)INT128_MIN); + printf("INT128_MAX=%"PRIdMAX"\n", (__Q8_MT)INT128_MAX); + printf("UINT128_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT128_MAX); +#endif + printf("INT_LEAST8_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST8_MIN); + printf("INT_LEAST8_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST8_MAX); + printf("UINT_LEAST8_MAX=%"PRIuMAX"\n", + (U__Q8_MT)UINT_LEAST8_MAX); + printf("INT_LEAST16_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST16_MIN); + printf("INT_LEAST16_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST16_MAX); + printf("UINT_LEAST16_MAX=%"PRIuMAX"\n", + (U__Q8_MT)UINT_LEAST16_MAX); + printf("INT_LEAST32_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST32_MIN); + printf("INT_LEAST32_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST32_MAX); + printf("UINT_LEAST32_MAX=%"PRIuMAX"\n", + (U__Q8_MT)UINT_LEAST32_MAX); +#ifdef INT_LEAST64_MAX + printf("INT_LEAST64_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST64_MIN); + printf("INT_LEAST64_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST64_MAX); + printf("UINT_LEAST64_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT_LEAST64_MAX); +#endif +#ifdef INT_LEAST128_MAX + printf("INT_LEAST128_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST128_MIN); + printf("INT_LEAST128_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST128_MAX); + printf("UINT_LEAST128_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT_LEAST128_MAX); +#endif + printf("INT_FAST8_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_FAST8_MIN); + printf("INT_FAST8_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_FAST8_MAX); + printf("UINT_FAST8_MAX=%"PRIuMAX"\n", + (U__Q8_MT)UINT_FAST8_MAX); + printf("INT_FAST16_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_FAST16_MIN); + printf("INT_FAST16_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_FAST16_MAX); + printf("UINT_FAST16_MAX=%"PRIuMAX"\n", + (U__Q8_MT)UINT_FAST16_MAX); + printf("INT_FAST32_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_FAST32_MIN); + printf("INT_FAST32_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_FAST32_MAX); + printf("UINT_FAST32_MAX=%"PRIuMAX"\n", + (U__Q8_MT)UINT_FAST32_MAX); +#ifdef INT_FAST64_MAX + printf("INT_FAST64_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_FAST64_MIN); + printf("INT_FAST64_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_FAST64_MAX); + printf("UINT_FAST64_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT_FAST64_MAX); +#endif +#ifdef INT_FAST128_MAX + printf("INT_FAST128_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_FAST128_MIN); + printf("INT_FAST128_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_FAST128_MAX); + printf("UINT_FAST128_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT_FAST128_MAX); +#endif +#ifdef INTPTR_MAX + printf("INTPTR_MIN=%"PRIdMAX"\n", (__Q8_MT)INTPTR_MIN); + printf("INTPTR_MAX=%"PRIdMAX"\n", (__Q8_MT)INTPTR_MAX); +#endif +#ifdef UINTPTR_MAX + printf("UINTPTR_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINTPTR_MAX); +#endif +#ifdef INTMAX_MAX + printf("INTMAX_MIN=%"PRIdMAX"\n", (__Q8_MT)INTMAX_MIN); + printf("INTMAX_MAX=%"PRIdMAX"\n", (__Q8_MT)INTMAX_MAX); + printf("UINTMAX_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINTMAX_MAX); +#endif +#ifdef PTRDIFF_MAX + printf("PTRDIFF_MIN=%"PRIdMAX"\n", (__Q8_MT)PTRDIFF_MIN); + printf("PTRDIFF_MAX=%"PRIdMAX"\n", (__Q8_MT)PTRDIFF_MAX); +#endif +#ifdef SIG_ATOMIC_MAX +#if SIG_ATOMIC_MIN < 0 + printf("SIG_ATOMIC_MIN=%"PRIdMAX"\n", (__Q8_MT)SIG_ATOMIC_MIN); + printf("SIG_ATOMIC_MAX=%"PRIdMAX"\n", (__Q8_MT)SIG_ATOMIC_MAX); +#else + printf("SIG_ATOMIC_MIN=%"PRIuMAX"\n", (U__Q8_MT)SIG_ATOMIC_MIN); + printf("SIG_ATOMIC_MAX=%"PRIuMAX"\n", (U__Q8_MT)SIG_ATOMIC_MAX); +#endif +#endif +#ifdef SIZE_MAX + printf("SIZE_MAX=%"PRIuMAX"\n", (U__Q8_MT)SIZE_MAX); +#endif + +#ifdef WCHAR_MAX +#if WCHAR_MIN < 0 + printf("WCHAR_MIN=%"PRIdMAX"\n", (__Q8_MT)WCHAR_MIN); + printf("WCHAR_MAX=%"PRIdMAX"\n", (__Q8_MT)WCHAR_MAX); +#else + printf("WCHAR_MIN=%"PRIuMAX"\n", (U__Q8_MT)WCHAR_MIN); + printf("WCHAR_MAX=%"PRIuMAX"\n", (U__Q8_MT)WCHAR_MAX); +#endif +#endif +#ifdef WINT_MAX +#if WINT_MIN < 0 + printf("WINT_MIN=%"PRIdMAX"\n", (__Q8_MT)WINT_MIN); + printf("WINT_MAX=%"PRIdMAX"\n", (__Q8_MT)WINT_MAX); +#else + printf("WINT_MIN=%"PRIuMAX"\n", (U__Q8_MT)WINT_MIN); + printf("WINT_MAX=%"PRIuMAX"\n", (U__Q8_MT)WINT_MAX); +#endif +#endif + + /* + 7.18.4 Macros for integer constants + */ + + /* INTn_C for n=8 and 16 were at one point unimplementable + on most platforms, so they're treated as "optional": */ +#ifdef INT8_C + if ( INT8_C(-123) != -123 ) + printf("*** INT8_C(-123) produced %"PRIdMAX" ***\n", + (__Q8_MT)INT8_C(-123) + ); + if ( UINT8_C(123) != 123 ) + printf("*** UINT8_C(123) produced %"PRIuMAX" ***\n", + (U__Q8_MT)UINT8_C(123) + ); +#endif +#ifdef INT16_C + if ( INT16_C(-12345) != -12345 ) + printf("*** INT16_C(-12345) produced %"PRIdMAX" ***\n", + (__Q8_MT)INT16_C(-12345) + ); + if ( UINT16_C(12345) != 12345 ) + printf("*** UINT16_C(12345) produced %"PRIuMAX" ***\n", + (U__Q8_MT)UINT16_C(12345) + ); +#endif + if ( INT32_C(-123456789) != -123456789 ) + printf("*** INT32_C(-123456789) produced %"PRIdMAX" ***\n", + (__Q8_MT)INT32_C(-123456789) + ); + if ( UINT32_C(123456789) != 123456789 ) + printf("*** UINT32_C(123456789) produced %"PRIuMAX" ***\n", + (U__Q8_MT)UINT32_C(123456789) + ); +#ifdef INT_LEAST64_MAX + if ( INT64_C(-1234567890123456789) != -1234567890123456789 ) + printf("*** INT64_C(-1234567890123456789) produced %"PRIdMAX + " ***\n", + (__Q8_MT)INT64_C(-1234567890123456789) + ); + if ( UINT64_C(1234567890123456789) != 1234567890123456789 ) + printf("*** UINT64_C(1234567890123456789) produced %"PRIuMAX + " ***\n", + (U__Q8_MT)UINT64_C(1234567890123456789) + ); +#endif +#ifdef INTMAX_MAX + if ( INTMAX_C(-1234567890123456789) != -1234567890123456789 ) + printf("*** INTMAX_C(-1234567890123456789) produced %"PRIdMAX + " ***\n", + (__Q8_MT)INTMAX_C(-1234567890123456789) + ); + if ( UINTMAX_C(1234567890123456789) != 1234567890123456789 ) + printf("*** UINTMAX_C(1234567890123456789) produced %"PRIuMAX + " ***\n", + (U__Q8_MT)UINTMAX_C(1234567890123456789) + ); +#endif + + /* features: */ + +#if __STDC_VERSION__ >= 199901 + printf("sizeof(imaxdiv_t)=%u\n", (unsigned)sizeof(imaxdiv_t)); +#endif + + /* + 7.8.1 Macros for format specifiers + */ + + { + /* scanf these strings */ + static const char in_dn[] = "Z119bZ"; + static const char in_dmo[] = "Z-0119bZ"; + static const char in_dspx[] = "Z \t\n +0X119bZ"; + static const char in_dsmx[] = "Z \t\n -0x119bZ"; + static const char in_dsn[] = "Z \t\n 119bZ"; + static const char in_dp[] = "Z+119bZ"; + static const char in_dpx[] = "Z+0X119bz"; + + /* sprintf into this */ + static char buffer[1024]; + +#if 1 + +#define SCAN(buf,fs,var,exp) if ( sscanf(buf, "Z%" fs, &var) != 1 ) \ + { \ + printf("***%s=",fs, STR_SUB(fs) \ + " failed ***\n" \ + ); \ + status = EXIT_FAILURE; \ + } \ + else if ( var != (exp) ) \ + { \ + printf("***%s=",fs, STR_SUB(fs) \ + " should be: " STR_SUB(exp) \ + ", was: %" fs " ***\n", var \ + ); \ + status = EXIT_FAILURE; \ + } \ + else /* for trailing semicolon */ + +#define PRINT(fs,var,exp) if ( sprintf(buffer, "%" fs, var ) <= 0 ) \ + { \ + printf("***%s=",fs, STR_SUB(fs) \ + " failed ***\n" \ + ); \ + status = EXIT_FAILURE; \ + } \ + else if ( strcmp(buffer, STR_SUB(exp)) != 0 ) \ + { \ + printf("***%s=",fs, STR_SUB(fs) \ + " should be: " STR_SUB(exp) \ + ", was: %s ***\n", buffer \ + ); \ + status = EXIT_FAILURE; \ + } \ + else /* for trailing semicolon */ + +#else + +#define SCAN(buf,fs,var,exp) +#define PRINT(fs,var,exp) + +#endif + +#ifdef SCNo32 + + SCAN(in_dn, SCNo32, int32, 9); + +#endif +#ifdef PRIo32 + PRINT(PRIo32, int32, 11); +#endif + SCAN(in_dmo, SCNiLEAST16, intl16, -9); + SCAN(in_dspx, SCNdLEAST16, intl16, 0); + SCAN(in_dsmx, SCNiLEAST16, intl16, -4507); + PRINT(PRIdLEAST16, intl16, -4507); + PRINT(PRIiLEAST16, intl16, -4507); + SCAN(in_dsn, SCNxLEAST16, uintl16, 4507); + PRINT(PRIoLEAST16, uintl16, 10633); + PRINT(PRIuLEAST16, uintl16, 4507); + PRINT(PRIxLEAST16, uintl16, 119b); + PRINT(PRIXLEAST16, uintl16, 119B); + SCAN(in_dp, SCNxFAST16, uintf16, 4507); + PRINT(PRIxFAST16, uintf16, 119b); +#ifdef SCNdMAX + SCAN(in_dp, SCNdMAX, intmax, 119); +#endif +#ifdef PRIiMAX + PRINT(PRIiMAX, intmax, 119); +#endif +#ifdef SCNoMAX + SCAN(in_dpx, SCNoMAX, uintmax, 0); +#endif +#ifdef PRIxMAX + PRINT(PRIxMAX, uintmax, 0); +#endif + /* Obviously there should be a much larger battery of such tests. */ + } + +#if defined(INTMAX_MAX) /* has C99 features */ + /* + 7.8.2 Functions for greatest-width integer types + */ + + { + static struct + { + intmax_t input; + intmax_t expect; + } abs_data[] = + { +#ifdef INT8_MAX + { INT8_MAX, INT8_MAX, }, + { -INT8_MAX, INT8_MAX, }, + { UINT8_MAX, UINT8_MAX, }, +#endif + +#if 0 + +#ifdef INT16_MAX + { INT16_MAX, INT16_MAX, }, + { -INT16_MAX, INT16_MAX, }, + { UINT16_MAX, UINT16_MAX, }, +#endif +#ifdef INT32_MAX + { INT32_MAX, INT32_MAX, }, + { -INT32_MAX, INT32_MAX, }, +#ifdef INT_LEAST64_MAX /* else might support only 32 bits */ + { UINT32_MAX, UINT32_MAX, }, +#endif +#endif +#ifdef INT64_MAX + { INT64_MAX, INT64_MAX, }, + { -INT64_MAX, INT64_MAX, }, +#endif + { INT_LEAST8_MAX, INT_LEAST8_MAX, }, + { -INT_LEAST8_MAX, INT_LEAST8_MAX, }, + { UINT_LEAST8_MAX, UINT_LEAST8_MAX, }, + { INT_LEAST16_MAX, INT_LEAST16_MAX, }, + { -INT_LEAST16_MAX, INT_LEAST16_MAX, }, + { UINT_LEAST16_MAX, UINT_LEAST16_MAX, }, + { INT_LEAST32_MAX, INT_LEAST32_MAX, }, + { -INT_LEAST32_MAX, INT_LEAST32_MAX, }, +#ifdef INT_LEAST64_MAX + { UINT_LEAST32_MAX, UINT_LEAST32_MAX, }, + { INT_LEAST64_MAX, INT_LEAST64_MAX, }, + { -INT_LEAST64_MAX, INT_LEAST64_MAX, }, +#endif + { INT_FAST8_MAX, INT_FAST8_MAX, }, + { -INT_FAST8_MAX, INT_FAST8_MAX, }, + { UINT_FAST8_MAX, UINT_FAST8_MAX, }, + { INT_FAST16_MAX, INT_FAST16_MAX, }, + { -INT_FAST16_MAX, INT_FAST16_MAX, }, + { UINT_FAST16_MAX, UINT_FAST16_MAX, }, + { INT_FAST32_MAX, INT_FAST32_MAX, }, + { -INT_FAST32_MAX, INT_FAST32_MAX, }, +#ifdef INT_FAST64_MAX + { UINT_FAST32_MAX, UINT_FAST32_MAX, }, + { INT_FAST64_MAX, INT_FAST64_MAX, }, + { -INT_FAST64_MAX, INT_FAST64_MAX, }, +#endif +#ifdef INTPTR_MAX + { INTPTR_MAX, INTPTR_MAX, }, + { -INTPTR_MAX, INTPTR_MAX, }, +#endif +#ifdef UINTPTR_MAX + { UINTPTR_MAX, UINTPTR_MAX, }, +#endif + { INTMAX_MAX, INTMAX_MAX, }, +#ifdef PTRDIFF_MAX + { PTRDIFF_MAX, PTRDIFF_MAX, }, +#endif +#ifdef SIG_ATOMIC_MAX + { SIG_ATOMIC_MAX, SIG_ATOMIC_MAX, }, +#if SIG_ATOMIC_MIN < 0 + { -SIG_ATOMIC_MAX, SIG_ATOMIC_MAX, }, +#endif +#endif +#ifdef SIZE_MAX + { SIZE_MAX, SIZE_MAX, }, +#endif +#ifdef WCHAR_MAX + { WCHAR_MAX, WCHAR_MAX, }, +#if WCHAR_MIN < 0 + { -WCHAR_MAX, WCHAR_MAX, }, +#endif +#endif +#ifdef WINT_MAX + { WINT_MAX, WINT_MAX, }, +#if WINT_MIN < 0 + { -WINT_MAX, WINT_MAX, }, +#endif +#endif + { 127, 127, }, + { -127, 127, }, + { 128, 128, }, + { -127-1, 128, }, + { 255, 255, }, + { -256+1, 255, }, + { 256, 256, }, + { -256, 256, }, + { 32767, 32767, }, + { -32767, 32767, }, + { 32768, 32768, }, + { -32767-1, 32768, }, + { 65535, 65535, }, + { -65536+1, 65535, }, + { 65536, 65536, }, + { -65536, 65536, }, + { 2147483647, 2147483647, }, + { -2147483647, 2147483647, }, + { 2147483648, 2147483648, }, + { -2147483647-1, 2147483648, }, +#ifdef INT_LEAST64_MAX /* else might support only 32 bits */ + { 4294967295, 4294967295, }, + { -4294967296+1, 4294967295, }, + { 4294967296, 4294967296, }, + { -4294967296, 4294967296, }, + { 9223372036854775807, 9223372036854775807, }, + { -9223372036854775807, 9223372036854775807, }, + { 1234567890123456789, 1234567890123456789, }, + { -1234567890123456789, 1234567890123456789, }, +#endif + { 1, 1, }, + { -1, 1, }, + { 2, 2, }, + { -2, 2, }, + { 10, 10, }, + { -10, 10, }, + { 16, 16, }, + { -16, 16, }, +#endif + /* Other test cases can be added here. */ + { 0, 0 /* terminates the list */ }, + }, *adp = abs_data; + + do { + if ( (intmax = imaxabs(adp->input)) != adp->expect ) + { + printf("*** imaxabs(%"PRIdMAX") failed; should be: %" + PRIdMAX", was: %"PRIdMAX" ***\n", + adp->input, adp->expect, intmax + ); + status = EXIT_FAILURE; + } +// } while ( adp++->input != 0 ); + } while ( (adp++)->input != 0 ); + } + + { + imaxdiv_t result; + static struct + { + intmax_t numer; + intmax_t denom; + intmax_t exp_quot; + intmax_t exp_rem; + } div_data[] = + { + { 0, 1, 0, 0, }, +#if 0 + { 0, -1, 0, 0, }, + { 0, 2, 0, 0, }, + { 0, -2, 0, 0, }, + { 0, 5, 0, 0, }, + { 0, -5, 0, 0, }, + { 1, 1, 1, 0, }, + { 1, -1, -1, 0, }, + { 1, 2, 0, 1, }, + { 1, -2, 0, 1, }, + { 1, 5, 0, 1, }, + { 1, -5, 0, 1, }, + { -1, 1, -1, 0, }, + { -1, -1, 1, 0, }, + { -1, 2, 0, -1, }, + { -1, -2, 0, -1, }, + { -1, 5, 0, -1, }, + { -1, -5, 0, -1, }, + { 2, 1, 2, 0, }, + { 2, -1, -2, 0, }, + { 2, 2, 1, 0, }, + { 2, -2, -1, 0, }, + { 2, 5, 0, 2, }, + { 2, -5, 0, 2, }, + { -2, 1, -2, 0, }, + { -2, -1, 2, 0, }, + { -2, 2, -1, 0, }, + { -2, -2, 1, 0, }, + { -2, 5, 0, -2, }, + { -2, -5, 0, -2, }, + { 17, 5, 3, 2, }, + { -17, -5, 3, -2, }, + { 17, -5, -3, 2, }, + { -17, 5, -3, -2, }, + { 2147483647, 1, 2147483647, 0, }, + { -2147483647, 1, -2147483647, 0, }, + { 2147483648, 1, 2147483648, 0, }, + { -2147483647-1, 1, -2147483647-1, 0, }, + { 2147483647, 2, 1073741823, 1, }, + { -2147483647, 2, -1073741823, -1, }, + { 2147483648, 2, 1073741824, 0, }, + { -2147483647-1, 2, -1073741824, 0, }, +#ifdef INT_LEAST64_MAX /* else might support only 32 bits */ + { 4294967295, 1, 4294967295, 0, }, + { -4294967296+1, 1, -4294967296+1, 0, }, + { 4294967296, 1, 4294967296, 0, }, + { -4294967296, 1, -4294967296, 0, }, + { 4294967295, -1, -4294967296+1, 0, }, + { -4294967296+1, -1, 4294967295, 0, }, + { 4294967296, -1, -4294967296, 0, }, + { -4294967296, -1, 4294967296, 0, }, + { 4294967295, 2, 2147483647, 1, }, + { -4294967296+1, 2, -2147483647, -1, }, + { 4294967296, 2, 2147483648, 0, }, + { -4294967296, 2, -2147483647-1, 0, }, + { 4294967295, 2147483647, 2, 1, }, + { -4294967296+1, 2147483647, -2, -1, }, + { 4294967296, 2147483647, 2, 2, }, + { -4294967296, 2147483647, -2, -2, }, + { 4294967295, -2147483647, -2, 1, }, + { -4294967296+1, -2147483647, 2, -1, }, + { 4294967296, -2147483647, -2, 2, }, + { -4294967296, -2147483647, 2, -2, }, + { 4294967295, 2147483648, 1, 2147483647, }, + { -4294967296+1, 2147483648, -1, -2147483647, }, + { 4294967296, 2147483648, 2, 0, }, + { -4294967296, 2147483648, -2, 0, }, + { 4294967295, -2147483647-1, -1, 2147483647, }, + { -4294967296+1, -2147483647-1, 1, -2147483647,}, + { 4294967296, -2147483647-1, -2, 0, }, + { -4294967296, -2147483647-1, 2, 0, }, + { 9223372036854775807, 1, 9223372036854775807, 0, }, + { -9223372036854775807, 1, -9223372036854775807, 0, }, + { 9223372036854775807, 2, 4611686018427387903, 1, }, + { -9223372036854775807, 2, -4611686018427387903, -1, }, +#endif +#endif + /* There should be a much larger battery of such tests. */ + { 0, 0, 0, 0 }, /* 0 denom terminates the list */ + }, *ddp; + +#if 0 + for ( ddp = div_data; ddp->denom != 0; ++ddp ) + if ( (result = imaxdiv(ddp->numer, ddp->denom)).quot + != ddp->exp_quot || result.rem != ddp->exp_rem + ) { +// printf("*** imaxdiv(%"PRIdMAX",%"PRIdMAX +// ") failed; should be: (%"PRIdMAX",%"PRIdMAX +// "), was: (%"PRIdMAX",%"PRIdMAX") ***\n", +// ddp->numer, ddp->denom, ddp->exp_quot, +// ddp->exp_rem, result.quot, result.rem +// ); + printf("err:imaxdiv(%"PRIdMAX",%"PRIdMAX + ") = (%"PRIdMAX",%"PRIdMAX + "), is: (%"PRIdMAX",%"PRIdMAX")\n", + ddp->numer, ddp->denom, ddp->exp_quot, + ddp->exp_rem, result.quot, result.rem + ); + status = EXIT_FAILURE; + } +#endif + } + + { + char *endptr; + wchar_t *wendptr; + static char saved[64]; /* holds copy of input string */ + static wchar_t wnptr[64]; /* holds wide copy of test string */ + static int warned; /* "warned for null endptr" flag */ + register int i; + static struct + { + char * nptr; + int base; + intmax_t exp_val; + int exp_len; + } str_data[] = + { + { "", 0, 0, 0, }, + { "", 2, 0, 0, }, + { "", 8, 0, 0, }, + { "", 9, 0, 0, }, + { "", 10, 0, 0, }, + { "", 16, 0, 0, }, + { "", 36, 0, 0, }, + { "0", 0, 0, 1, }, + { "0", 2, 0, 1, }, + { "0", 8, 0, 1, }, + { "0", 9, 0, 1, }, + { "0", 10, 0, 1, }, + { "0", 16, 0, 1, }, + { "0", 36, 0, 1, }, + { "+0", 0, 0, 2, }, + { "+0", 2, 0, 2, }, + { "+0", 8, 0, 2, }, + { "+0", 9, 0, 2, }, + { "+0", 10, 0, 2, }, + { "+0", 16, 0, 2, }, + { "+0", 36, 0, 2, }, + { "-0", 0, 0, 2, }, + { "-0", 2, 0, 2, }, + { "-0", 8, 0, 2, }, + { "-0", 9, 0, 2, }, + { "-0", 10, 0, 2, }, + { "-0", 16, 0, 2, }, + { "-0", 36, 0, 2, }, + { "Inf", 0, 0, 0, }, + { "Inf", 2, 0, 0, }, + { "Inf", 8, 0, 0, }, + { "Inf", 9, 0, 0, }, + { "Inf", 10, 0, 0, }, + { "Inf", 16, 0, 0, }, + { "Inf", 36, 24171, 3, }, + { "+Inf", 0, 0, 0, }, + { "+Inf", 2, 0, 0, }, + { "+Inf", 8, 0, 0, }, + { "+Inf", 9, 0, 0, }, + { "+Inf", 10, 0, 0, }, + { "+Inf", 16, 0, 0, }, + { "+Inf", 36, 24171, 4, }, + { "-Inf", 0, 0, 0, }, + { "-Inf", 2, 0, 0, }, + { "-Inf", 8, 0, 0, }, + { "-Inf", 9, 0, 0, }, + { "-Inf", 10, 0, 0, }, + { "-Inf", 16, 0, 0, }, + { "-Inf", 36, -24171, 4, }, + { "inf", 0, 0, 0, }, + { "inf", 2, 0, 0, }, + { "inf", 8, 0, 0, }, + { "inf", 9, 0, 0, }, + { "inf", 10, 0, 0, }, + { "inf", 16, 0, 0, }, + { "inf", 36, 24171, 3, }, + { "+inf", 0, 0, 0, }, + { "+inf", 2, 0, 0, }, + { "+inf", 8, 0, 0, }, + { "+inf", 9, 0, 0, }, + { "+inf", 10, 0, 0, }, + { "+inf", 16, 0, 0, }, + { "+inf", 36, 24171, 4, }, + { "-inf", 0, 0, 0, }, + { "-inf", 2, 0, 0, }, + { "-inf", 8, 0, 0, }, + { "-inf", 9, 0, 0, }, + { "-inf", 10, 0, 0, }, + { "-inf", 16, 0, 0, }, + { "-inf", 36, -24171, 4, }, + { "119b8Z", 0, 119, 3, }, + { "119bZ", 0, 119, 3, }, + { "-0119bZ", 0, -9, 4, }, + { " \t\n 0X119bZ", 0, 4507, 10, }, + { " \t\n +0X119bZ", 0, 4507, 11, }, + { " \t\n -0x119bZ", 0, -4507, 11, }, + { " \t\n 119bZ", 0, 119, 7, }, + { "+119bZ", 0, 119, 4, }, + { "+0X119bz", 0, 4507, 7, }, + { "119b8Z", 2, 3, 2, }, + { "119bZ", 2, 3, 2, }, + { "-0119bZ", 2, -3, 4, }, + { " \t\n 0X119bZ", 2, 0, 5, }, + { " \t\n +0X119bZ", 2, 0, 6, }, + { " \t\n -0x119bZ", 2, 0, 6, }, + { " \t\n 119bZ", 2, 3, 6, }, + { "+119bZ", 2, 3, 3, }, + { "+0X119bz", 2, 0, 2, }, + { "119b8Z", 8, 9, 2, }, + { "119bZ", 8, 9, 2, }, + { "-0119bZ", 8, -9, 4, }, + { " \t\n 0X119bZ", 8, 0, 5, }, + { " \t\n +0X119bZ", 8, 0, 6, }, + { " \t\n -0x119bZ", 8, 0, 6, }, + { " \t\n 119bZ", 8, 9, 6, }, + { "+119bZ", 8, 9, 3, }, + { "+0X119bz", 8, 0, 2, }, + { "119b8Z", 9, 10, 2, }, + { "119bZ", 9, 10, 2, }, + { "-0119bZ", 9, -10, 4, }, + { " \t\n 0X119bZ", 9, 0, 5, }, + { " \t\n +0X119bZ", 9, 0, 6, }, + { " \t\n -0x119bZ", 9, 0, 6, }, + { " \t\n 119bZ", 9, 10, 6, }, + { "+119bZ", 9, 10, 3, }, + { "+0X119bz", 9, 0, 2, }, + { "119b8Z", 10, 119, 3, }, + { "119bZ", 10, 119, 3, }, + { "-0119bZ", 10, -119, 5, }, + { " \t\n 0X119bZ", 10, 0, 5, }, + { " \t\n +0X119bZ", 10, 0, 6, }, + { " \t\n -0x119bZ", 10, 0, 6, }, + { " \t\n 119bZ", 10, 119, 7, }, + { "+119bZ", 10, 119, 4, }, + { "+0X119bz", 10, 0, 2, }, + { "119b8Z", 16, 72120, 5, }, + { "119bZ", 16, 4507, 4, }, + { "-0119bZ", 16, -4507, 6, }, + { " \t\n 0X119bZ", 16, 4507, 10, }, + { " \t\n +0X119bZ", 16, 4507, 11, }, + { " \t\n -0x119bZ", 16, -4507, 11, }, + { " \t\n 119bZ", 16, 4507,8, }, + { "+119bZ", 16, 4507, 5, }, + { "+0X119bz", 16, 4507, 7, }, + { "119b8Z", 36, 62580275, 6, }, + { "119bZ", 36, 1738367, 5, }, + { "-0119bZ", 36, -1738367, 7, }, + { " \t\n 0X119bZ", 36, 1997122175, 11, }, + { " \t\n +0X119bZ", 36, 1997122175, 12, }, + { " \t\n -0x119bZ", 36, -1997122175, 12, }, + { " \t\n 119bZ", 36, 1738367, 9, }, + { "+119bZ", 36, 1738367, 6, }, + { "+0X119bz", 36, 1997122175, 8, }, + /* There should be a much larger battery of such tests. */ + { "127", 0, 127, 3, }, + { "-127", 0, -127, 4, }, + { "128", 0, 128, 3, }, + { "-128", 0, -127-1, 4, }, + { "255", 0, 255, 3, }, + { "-255", 0, -255, 4, }, + { "256", 0, 256, 3, }, + { "-256", 0, -255-1, 4, }, + { "32767", 0, 32767, 5, }, + { "-32767", 0, -32767, 6, }, + { "32768", 0, 32768, 5, }, + { "-32768", 0, -32767-1, 6, }, + { "65535", 0, 65535, 5, }, + { "-65535", 0, -65536+1, 6, }, + { "65536", 0, 65536, 5, }, + { "-65536", 0, -65536, 6, }, + { "2147483647", 0, 2147483647, 10, }, + { "-2147483647", 0, -2147483647, 11, }, + { "2147483648", 0, 2147483648, 10, }, + { "-2147483648", 0, -2147483647-1, 11, }, + { "4294967295", 0, 4294967295, 10, }, + { "-4294967295", 0, -4294967296+1, 11, }, + { "4294967296", 0, 4294967296, 10, }, + { "-4294967296", 0, -4294967296, 11, }, + { "9223372036854775807", 0, 9223372036854775807, 19, }, + { "-9223372036854775807", 0, -9223372036854775807, 20, }, + { "1234567890123456789", 0, 1234567890123456789, 19, }, + { "-1234567890123456789", 0, -1234567890123456789, 20, }, + { "1", 0, 1, 1, }, + { "-1", 0, -1, 2, }, + { "2", 0, 2, 1, }, + { "-2", 0, -2, 2, }, + { "10", 0, 10, 2, }, + { "-10", 0, -10, 3, }, + { "16", 0, 16, 2, }, + { "-16", 0, -16, 3, }, + /* Other test cases can be added here. */ + { NULL, 0, 0, 0 }, /* terminates the list */ + }, *sdp; + + for ( sdp = str_data; sdp->nptr != NULL ; ++sdp ) + { + /* + 7.8.2.3 The strtoimax and strtoumax functions + */ + + strcpy(saved, sdp->nptr); + + errno = 0; /* shouldn't be changed */ + + if ( (intmax = strtoimax(sdp->nptr, &endptr, sdp->base)) + != sdp->exp_val + ) { + int save = errno; + + printf("*** strtoimax(%s,,%d) failed; should be: %" + PRIdMAX", was: %"PRIdMAX" ***\n", sdp->nptr, + sdp->base, sdp->exp_val, intmax + ); + status = EXIT_FAILURE; + errno = save; + } + else if ( endptr != sdp->nptr + sdp->exp_len ) + { + int save = errno; + + printf("*** strtoimax(%s,,%d) returned wrong endptr" + " ***\n", sdp->nptr, sdp->base + ); + status = EXIT_FAILURE; + errno = save; + } + + if ( errno != 0 ) + { + printf("*** strtoimax modified errno ***\n"); + status = EXIT_FAILURE; + } + + if ( strcmp(sdp->nptr, saved) != 0 ) + { + printf("*** strtoimax modified its input ***\n"); + status = EXIT_FAILURE; + strcpy(saved, sdp->nptr); + } + + if ( sdp->exp_val >= 0 ) /* else some sign extension */ + { + errno = 0; /* shouldn't be changed */ + + if ( (uintmax = strtoumax(sdp->nptr, &endptr, sdp->base + ) + ) != sdp->exp_val + ) { + int save = errno; + + printf("*** strtoumax(%s,,%d) failed; " + "should be: %"PRIuMAX", was: %"PRIuMAX + " ***\n", sdp->nptr, sdp->base, + sdp->exp_val, uintmax + ); + status = EXIT_FAILURE; + errno = save; + } + else if ( endptr != sdp->nptr + sdp->exp_len ) + { + int save = errno; + + printf("*** strtoumax(%s,,%d) returned wrong " + "endptr ***\n", sdp->nptr, sdp->base + ); + status = EXIT_FAILURE; + errno = save; + } + + if ( errno != 0 ) + { + printf("*** strtoumax modified errno ***\n"); + status = EXIT_FAILURE; + } + + if ( strcmp(sdp->nptr, saved) != 0 ) + { + printf("*** strtoumax" + " modified its input ***\n" + ); + status = EXIT_FAILURE; + strcpy(saved, sdp->nptr); + } + } + + /* tests for null endptr */ + +#define WARN() if (!warned) warned = 1, printf("*** Using null endptr: ***\n") + + warned = 0; + errno = 0; /* shouldn't be changed */ + + if ( (intmax = strtoimax(sdp->nptr, (char **)NULL, sdp->base)) + != sdp->exp_val + ) { + int save = errno; + + WARN(); + printf("*** strtoimax(%s,NULL,%d) failed; " + "should be: %"PRIdMAX", was: %"PRIdMAX" ***\n", + sdp->nptr, sdp->base, sdp->exp_val, intmax + ); + status = EXIT_FAILURE; + errno = save; + } + + if ( errno != 0 ) + { + WARN(); + printf("*** strtoimax modified errno ***\n"); + status = EXIT_FAILURE; + } + + if ( strcmp(sdp->nptr, saved) != 0 ) + { + WARN(); + printf("*** strtoimax modified its input ***\n"); + status = EXIT_FAILURE; + strcpy(saved, sdp->nptr); + } + + if ( sdp->exp_val >= 0 ) /* else some sign extension */ + { + errno = 0; /* shouldn't be changed */ + + if ( (uintmax = strtoumax(sdp->nptr, (char **)NULL, + sdp->base + ) + ) != sdp->exp_val + ) { + int save = errno; + + WARN(); + printf("*** strtoumax(%s,NULL,%d) failed; " + "should be: %"PRIuMAX", was: %"PRIuMAX + " ***\n", sdp->nptr, sdp->base, + sdp->exp_val, uintmax + ); + status = EXIT_FAILURE; + errno = save; + } + + if ( errno != 0 ) + { + WARN(); + printf("*** strtoumax modified errno ***\n"); + status = EXIT_FAILURE; + } + + if ( strcmp(sdp->nptr, saved) != 0 ) + { + WARN(); + printf("*** strtoumax" + " modified its input ***\n" + ); + status = EXIT_FAILURE; + strcpy(saved, sdp->nptr); + } + } + + /* + 7.8.2.4 The wcstoimax and wcstoumax functions + */ + + for ( i = 0; i < 64; ++i ) + if ( (wnptr[i] = sdp->nptr[i]) == '\0' ) + break; + + errno = 0; /* shouldn't be changed */ + + if ( (intmax = wcstoimax(wnptr, &wendptr, sdp->base)) + != sdp->exp_val + ) { + int save = errno; + + printf("*** wcstoimax(%s,,%d) failed; should be: %" + PRIdMAX", was: %"PRIdMAX" ***\n", sdp->nptr, + sdp->base, sdp->exp_val, intmax + ); + status = EXIT_FAILURE; + errno = save; + } + else if ( wendptr != wnptr + sdp->exp_len ) + { + int save = errno; + + printf("*** wcstoimax(%s,,%d) returned wrong endptr" + " ***\n", sdp->nptr, sdp->base + ); + status = EXIT_FAILURE; + errno = save; + } + + if ( errno != 0 ) + { + printf("*** wcstoimax modified errno ***\n"); + status = EXIT_FAILURE; + } + + for ( i = 0; i < 64; ++i ) + if ( wnptr[i] != sdp->nptr[i] ) + { + printf("*** wcstoimax modified its input ***\n" + ); + status = EXIT_FAILURE; + + for ( ; i < 64; ++i ) + if ( (wnptr[i] = sdp->nptr[i]) == '\0' ) + break; + + break; + } + else if ( wnptr[i] == '\0' ) + break; + + if ( sdp->exp_val >= 0 ) /* else some sign extension */ + { + errno = 0; /* shouldn't be changed */ + + if ( (uintmax = wcstoumax(wnptr, &wendptr, sdp->base) + ) != sdp->exp_val + ) { + int save = errno; + + printf("*** wcstoumax(%s,,%d) failed; " + "should be: %"PRIuMAX", was: %"PRIuMAX + " ***\n", sdp->nptr, sdp->base, + sdp->exp_val, uintmax + ); + status = EXIT_FAILURE; + errno = save; + } + else if ( wendptr != wnptr + sdp->exp_len ) + { + int save = errno; + + printf("*** wcstoumax(%s,,%d) returned wrong " + "endptr ***\n", sdp->nptr, sdp->base + ); + status = EXIT_FAILURE; + errno = save; + } + + if ( errno != 0 ) + { + printf("*** wcstoumax modified errno ***\n"); + status = EXIT_FAILURE; + } + + for ( i = 0; i < 64; ++i ) + if ( wnptr[i] != sdp->nptr[i] ) + { + printf("*** wcstoumax" + " modified its input ***\n" + ); + status = EXIT_FAILURE; + + for ( ; i < 64; ++i ) + if ( (wnptr[i] = sdp->nptr[i]) + == '\0' + ) + break; + + break; + } + else if ( wnptr[i] == '\0' ) + break; + } + + /* tests for null endptr */ + + warned = 0; + errno = 0; /* shouldn't be changed */ + + if ( (intmax = wcstoimax(wnptr, (wchar_t **)NULL, sdp->base)) + != sdp->exp_val + ) { + int save = errno; + + WARN(); + printf("*** wcstoimax(%s,NULL,%d) failed; should be: %" + PRIdMAX", was: %"PRIdMAX" ***\n", sdp->nptr, + sdp->base, sdp->exp_val, intmax + ); + status = EXIT_FAILURE; + errno = save; + } + + if ( errno != 0 ) + { + WARN(); + printf("*** wcstoimax modified errno ***\n"); + status = EXIT_FAILURE; + } + + for ( i = 0; i < 64; ++i ) + if ( wnptr[i] != sdp->nptr[i] ) + { + WARN(); + printf("*** wcstoimax modified its input ***\n" + ); + status = EXIT_FAILURE; + + for ( ; i < 64; ++i ) + if ( (wnptr[i] = sdp->nptr[i]) + == '\0' + ) + break; + + break; + } + else if ( wnptr[i] == '\0' ) + break; + + if ( sdp->exp_val >= 0 ) /* else some sign extension */ + { + errno = 0; /* shouldn't be changed */ + + if ( (uintmax = wcstoumax(wnptr, (wchar_t **)NULL, + sdp->base + ) + ) != sdp->exp_val + ) { + int save = errno; + + WARN(); + printf("*** wcstoumax(%s,NULL,%d) failed; " + "should be: %"PRIuMAX", was: %"PRIuMAX + " ***\n", sdp->nptr, sdp->base, + sdp->exp_val, uintmax + ); + status = EXIT_FAILURE; + errno = save; + } + + if ( errno != 0 ) + { + WARN(); + printf("*** wcstoumax modified errno ***\n"); + status = EXIT_FAILURE; + } + + for ( i = 0; i < 64; ++i ) + if ( wnptr[i] != sdp->nptr[i] ) + { + WARN(); + printf("*** wcstoumax" + " modified its input ***\n" + ); + status = EXIT_FAILURE; + + for ( ; i < 64; ++i ) + if ( (wnptr[i] = sdp->nptr[i]) + == '\0' + ) + break; + + break; + } + else if ( wnptr[i] == '\0' ) + break; + } + } + + /* + 7.8.2.3 The strtoimax and strtoumax functions (continued) + */ + + if ( (intmax = strtoimax("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", + &endptr, 0 + ) + ) != INTMAX_MAX || errno != ERANGE + ) { + printf("*** strtoimax failed overflow test ***\n"); + status = EXIT_FAILURE; + } + + if ( (intmax = strtoimax("+1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", + &endptr, 0 + ) + ) != INTMAX_MAX || errno != ERANGE + ) { + printf("*** strtoimax failed +overflow test ***\n"); + status = EXIT_FAILURE; + } + + if ( (intmax = strtoimax("-1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", + &endptr, 0 + ) + ) != INTMAX_MIN || errno != ERANGE + ) { + printf("*** strtoimax failed -overflow test ***\n"); + status = EXIT_FAILURE; + } + + if ( (uintmax = strtoumax("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", + &endptr, 0 + ) + ) != UINTMAX_MAX || errno != ERANGE + ) { + printf("*** strtoumax failed overflow test ***\n"); + status = EXIT_FAILURE; + } + + if ( (uintmax = strtoumax("+1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", + &endptr, 0 + ) + ) != UINTMAX_MAX || errno != ERANGE + ) { + printf("*** strtoumax failed +overflow test ***\n"); + status = EXIT_FAILURE; + } + + if ( (uintmax = strtoumax("-1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", + &endptr, 0 + ) + ) != UINTMAX_MAX || errno != ERANGE + ) { + printf("*** strtoumax failed -overflow test ***\n"); + status = EXIT_FAILURE; + } + + /* + 7.8.2.4 The wcstoimax and wcstoumax functions (continued) + */ + +#ifdef NO_INTERNAL_WCHAR + printf("NO_INTERNAL_WCHAR\n"); +#else + + if ( (intmax = wcstoimax(L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890", + &wendptr, 0 + ) + ) != INTMAX_MAX || errno != ERANGE + ) { + printf("*** wcstoimax failed overflow test ***\n"); + status = EXIT_FAILURE; + } + + if ( (intmax = wcstoimax(L"+1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890", + &wendptr, 0 + ) + ) != INTMAX_MAX || errno != ERANGE + ) { + printf("*** wcstoimax failed +overflow test ***\n"); + status = EXIT_FAILURE; + } + + if ( (intmax = wcstoimax(L"-1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890", + &wendptr, 0 + ) + ) != INTMAX_MIN || errno != ERANGE + ) { + printf("*** wcstoimax failed -overflow test ***\n"); + status = EXIT_FAILURE; + } + + if ( (uintmax = wcstoumax(L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890", + &wendptr, 0 + ) + ) != UINTMAX_MAX || errno != ERANGE + ) { + printf("*** wcstoumax failed overflow test ***\n"); + status = EXIT_FAILURE; + } + + if ( (uintmax = wcstoumax(L"+1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890", + &wendptr, 0 + ) + ) != UINTMAX_MAX || errno != ERANGE + ) { + printf("*** wcstoumax failed +overflow test ***\n"); + status = EXIT_FAILURE; + } + + if ( (uintmax = wcstoumax(L"-1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890" + L"1234567890123456789012345678901234567890", + &wendptr, 0 + ) + ) != UINTMAX_MAX || errno != ERANGE + ) { + printf("*** wcstoumax failed -overflow test ***\n"); + status = EXIT_FAILURE; + } +#endif // NO_INTERNAL_WCHAR + } +#endif /* defined(INTMAX_MAX) */ + + if ( status != 0 ) + printf("sitest failed.\n"); + + return status; +} + +#endif \ No newline at end of file diff --git a/test/val/strtol-test.c b/test/val/strtol-test.c new file mode 100644 index 000000000..76daef791 --- /dev/null +++ b/test/val/strtol-test.c @@ -0,0 +1,135 @@ +/* + !!DESCRIPTION!! A small test for atoi/strtol. Assumes twos complement + !!ORIGIN!! + !!LICENCE!! + !!AUTHOR!! +*/ + +#include +#include +#include +#include +#include + +#define ERROR 0 +#define OK 1 + +static unsigned int Failures = 0; + +static void IncStr (char* Buf) +/* Increment a number represented as a string by one. The string MUST not + * start with a '9', we cannot handle overflow in this case. + */ +{ + int Len = strlen (Buf); + + while (--Len >= 0) { + switch (Buf[Len]) { + case '9': + Buf[Len] = '0'; + break; + + default: + ++(Buf[Len]); + return; + } + } +} + +static void CheckStrToL (const char* Str, int Base, long Val, unsigned char Ok) +{ + char* EndPtr; + long Res = strtol (Str, &EndPtr, Base); + if (Ok) { + if (Res != Val) { + printf ("strtol error in \"%s\":\n" + " result = %ld, should be %ld, chars = %d\n", + Str, Res, Val, EndPtr - Str); + ++Failures; + } + } else { + if (errno != ERANGE) { + printf ("strtol error in \"%s\":\n" + " should not convert, but errno = %d\n", + Str, errno); + ++Failures; + } + if (Res != Val) { + printf ("strtol error in \"%s\":\n" + " result = %ld, should be %ld, chars = %d\n", + Str, Res, Val, EndPtr - Str); + ++Failures; + } + } +} + +int main (void) +{ + char Buf[80]; + + /* Prefixed allowed if base = 0 */ + CheckStrToL ("\t 0x10G ", 0, 16L, OK); + CheckStrToL ("\t 0X10G ", 0, 16L, OK); + CheckStrToL (" \t0377\t", 0, 255L, OK); + CheckStrToL (" 377", 0, 377L, OK); + + CheckStrToL ("\t -0x10G ", 0, -16L, OK); + CheckStrToL ("\t -0X10G ", 0, -16L, OK); + CheckStrToL (" \t-0377\t", 0, -255L, OK); + CheckStrToL (" -377", 0, -377L, OK); + + /* No prefixes if base = 10 */ + CheckStrToL ("\t 1234 ", 10, 1234L, OK); + CheckStrToL ("\t -1234 ", 10, -1234L, OK); + CheckStrToL ("\t -0x10G ", 10, 0L, OK); + CheckStrToL ("\t -0X10G ", 10, 0L, OK); + CheckStrToL (" \t-0377\t", 10, -377L, OK); + CheckStrToL (" 0377", 10, 377L, OK); + + /* 0x prefix is allowed if base = 16 */ + CheckStrToL ("\t 0x1234 ", 16, 0x1234L, OK); + CheckStrToL ("\t -0x1234 ", 16, -0x1234L, OK); + CheckStrToL ("\t -010G ", 16, -16L, OK); + CheckStrToL ("\t 10G ", 16, 16L, OK); + + /* Check LONG_MIN and LONG_MAX */ + sprintf (Buf, "%ld", LONG_MIN); + CheckStrToL (Buf, 0, LONG_MIN, OK); + sprintf (Buf, "%ld", LONG_MAX); + CheckStrToL (Buf, 0, LONG_MAX, OK); + + /* Check value one smaller */ + sprintf (Buf+1, "%ld", LONG_MIN); + Buf[1] = '0'; /* Overwrite '-' */ + IncStr (Buf+1); + if (Buf[1] == '0') { + Buf[1] = '-'; + Buf[0] = ' '; + } else { + Buf[0] = '-'; + } + CheckStrToL (Buf, 0, LONG_MIN, ERROR); + + /* Check value one larger */ + sprintf (Buf+1, "%ld", LONG_MAX); + Buf[0] = '0'; + IncStr (Buf); + if (Buf[0] == '0') { + Buf[0] = ' '; + } + CheckStrToL (Buf, 0, LONG_MAX, ERROR); + + /* Check numbers that are much too large or small */ + CheckStrToL ("-999999999999999999999999999999999999999999999999999999999", 0, LONG_MIN, ERROR); + CheckStrToL ("+999999999999999999999999999999999999999999999999999999999", 0, LONG_MAX, ERROR); + CheckStrToL (" 999999999999999999999999999999999999999999999999999999999", 0, LONG_MAX, ERROR); + + /* Check a few other bases */ + CheckStrToL ("aBcD", 36, 481261L, OK); + CheckStrToL ("zyaB", 35, 0L, ERROR); + CheckStrToL ("zyaB", 36, 1677395L, ERROR); + + printf ("Failures: %u\n", Failures); + + return Failures; +} diff --git a/test/val/strtoul-test.c b/test/val/strtoul-test.c new file mode 100644 index 000000000..803fd452c --- /dev/null +++ b/test/val/strtoul-test.c @@ -0,0 +1,121 @@ +/* + !!DESCRIPTION!! A small test for strtuol. Assumes twos complement + !!ORIGIN!! + !!LICENCE!! + !!AUTHOR!! +*/ + +#include +#include +#include +#include +#include + +#define ERROR 0 +#define OK 1 + +static unsigned int Failures = 0; + +static void IncStr (char* Buf) +/* Increment a number represented as a string by one. The string MUST not + * start with a '9', we cannot handle overflow in this case. + */ +{ + int Len = strlen (Buf); + + while (--Len >= 0) { + switch (Buf[Len]) { + case '9': + Buf[Len] = '0'; + break; + + default: + ++(Buf[Len]); + return; + } + } +} + +static void CheckStrToUL (const char* Str, int Base, unsigned long Val, unsigned char Ok) +{ + char* EndPtr; + unsigned long Res = strtoul (Str, &EndPtr, Base); + if (Ok) { + if (Res != Val) { + printf ("strtol error in \"%s\":\n" + " result = %lu, should be %lu, chars = %d\n", + Str, Res, Val, EndPtr - Str); + ++Failures; + } + } else { + if (errno != ERANGE) { + printf ("strtol error in \"%s\":\n" + " should not convert, but errno = %d\n", + Str, errno); + ++Failures; + } + if (Res != Val) { + printf ("strtol error in \"%s\":\n" + " result = %lu, should be %lu, chars = %d\n", + Str, Res, Val, EndPtr - Str); + ++Failures; + } + } +} + +int main (void) +{ + char Buf[80]; + + /* Prefixed allowed if base = 0 */ + CheckStrToUL ("\t 0x10G ", 0, 16UL, OK); + CheckStrToUL ("\t 0X10G ", 0, 16UL, OK); + CheckStrToUL (" \t0377\t", 0, 255UL, OK); + CheckStrToUL (" 377", 0, 377UL, OK); + + CheckStrToUL ("\t -0x10G ", 0, (unsigned long) -16L, OK); + CheckStrToUL ("\t -0X10G ", 0, (unsigned long) -16L, OK); + CheckStrToUL (" \t-0377\t", 0, (unsigned long) -255L, OK); + CheckStrToUL (" -377", 0, (unsigned long) -377L, OK); + + /* No prefixes if base = 10 */ + CheckStrToUL ("\t 1234 ", 10, 1234UL, OK); + CheckStrToUL ("\t -1234 ", 10, (unsigned long) -1234L, OK); + CheckStrToUL ("\t -0x10G ", 10, 0UL, OK); + CheckStrToUL ("\t -0X10G ", 10, 0UL, OK); + CheckStrToUL (" \t-0377\t", 10, (unsigned long) -377L, OK); + CheckStrToUL (" 0377", 10, 377UL, OK); + + /* 0x prefix is allowed if base = 16 */ + CheckStrToUL ("\t 0x1234 ", 16, 0x1234UL, OK); + CheckStrToUL ("\t -0x1234 ", 16, (unsigned long) -0x1234L, OK); + CheckStrToUL ("\t -010G ", 16, (unsigned long) -16L, OK); + CheckStrToUL ("\t 10G ", 16, 16UL, OK); + + /* Check ULONG_MAX */ + sprintf (Buf, "%lu", ULONG_MAX); + CheckStrToUL (Buf, 0, ULONG_MAX, OK); + + /* Check value one larger */ + sprintf (Buf+1, "%lu", ULONG_MAX); + Buf[0] = '0'; + IncStr (Buf); + if (Buf[0] == '0') { + Buf[0] = ' '; + } + CheckStrToUL (Buf, 0, ULONG_MAX, ERROR); + + /* Check numbers that are much too large or small */ + CheckStrToUL ("-999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR); + CheckStrToUL ("+999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR); + CheckStrToUL (" 999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR); + + /* Check a few other bases */ + CheckStrToUL ("aBcD", 36, 481261UL, OK); + CheckStrToUL ("zyaB", 35, 0UL, ERROR); + CheckStrToUL ("zyaB", 36, 1677395UL, ERROR); + + printf ("Failures: %u\n", Failures); + + return Failures; +} diff --git a/test/val/struct1.c b/test/val/struct1.c new file mode 100644 index 000000000..71dbf7946 --- /dev/null +++ b/test/val/struct1.c @@ -0,0 +1,100 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +#if SUPPORT_BIT_TYPES + +bit bit0 = 0; +bit bit1 = 0; +bit bit2 = 0; +bit bit3 = 0; +bit bit4 = 0; +bit bit5 = 0; +bit bit6 = 0; +bit bit7 = 0; +bit bit8 = 0; +bit bit9 = 0; +bit bit10 = 0; +bit bit11 = 0; + +#endif + +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned char achar0 = 0; +unsigned char achar1 = 0; +unsigned char *acharP = 0; + +struct chars + { + unsigned char c0, c1; + unsigned int i0, i1; + }; + +struct chars struct1; + +void +done () +{ + dummy++; +} + +void +struct_test (void) +{ + if (struct1.c0 || struct1.c1) + failures++; + + struct1.c0++; + + if (struct1.c0 != 1) + failures++; +} + +void +ptr_to_struct (struct chars *p) +{ + if (p->c1) + failures++; + + p->c1++; + + if (p->c1 != 1) + failures++; +} + +void add_chars(void) +{ + achar0 = struct1.c0 + struct1.c1; + + if(achar0 != 1) + failures++; +} + +int +main (void) +{ + struct1.c0 = 0; + struct1.c1 = 0; + struct_test (); + ptr_to_struct (&struct1); + + struct1.c0 = 0; + struct1.c1 = 1; + add_chars(); + + success = failures; + done (); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/sub1.c b/test/val/sub1.c new file mode 100644 index 000000000..f1ae9394f --- /dev/null +++ b/test/val/sub1.c @@ -0,0 +1,272 @@ +/* + !!DESCRIPTION!! Substraction Test + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#if SUPPORT_BIT_TYPES + +bit bit0 = 0; +bit bit1 = 0; +bit bit2 = 0; +bit bit3 = 0; +bit bit4 = 0; +bit bit5 = 0; +bit bit6 = 0; +bit bit7 = 0; +bit bit8 = 0; +bit bit9 = 0; +bit bit10 = 0; +bit bit11 = 0; + +#endif + +#ifdef SIZEOF_INT_16BIT +#if defined(__LINUX__) || defined(LINUX) +unsigned short aint0 = 0; +unsigned short aint1 = 0; +#else +unsigned int aint0 = 0; +unsigned int aint1 = 0; +#endif + +#else +unsigned int aint0 = 0; +unsigned int aint1 = 0; +#endif +unsigned char achar0 = 0; +unsigned char achar1 = 0; +unsigned char achar2 = 0; +unsigned char achar3 = 0; +unsigned char *acharP = 0; + +void done() +{ + dummy++; +} + +void sub_lit_from_uchar(void) +{ + achar0 = achar0 - 5; + + if(achar0 != 0xfb) + failures++; + + achar0 -= 10; + + if(achar0 != 0xf1) + failures++; + + achar0 = achar0 -1; /* Should be a decrement */ + if(achar0 != 0xf0) + failures++; + + for(achar1 = 0; achar1 < 100; achar1++) + achar0 -= 2; + + if(achar0 != 40) + failures++; +} + +/* achar0 = 1 + achar1 = 100 +*/ + +void sub_uchar2uchar(void) +{ + achar1 = achar1 - achar0; + + if(achar1 != 99) + failures++; + + for(achar2 = 0; achar2<7; achar2++) + achar1 -= achar0; + + if(achar1 != 92) + failures++; +} + +/* assumes + achar0 = 10 + achar1 = 32 + achar2, achar3 can be anything. +*/ +void sub_uchar2uchar2(void) +{ + achar0--; + achar0 = achar0 - 1; + achar0 = achar0 - 2; + achar0 = achar0 - 3; + if(achar0 != 3) + failures++; + + achar1 -= achar0; + if(achar1 != 29) + failures++; + + achar2 = achar1 - achar0; + if(achar2 != 26) + failures++; + + achar3 = achar2 - achar1 - achar0; + if(achar3 != 0xfa) + failures++; +} + +/* sub_bits + all bit variables are 0 upon entry. +*/ +#if SUPPORT_BIT_TYPES +void sub_bits(void) +{ + bit1 = bit0; + + bit0 = 1; + + if(bit1 != 0) + failures++; + + bit1 = bit0-bit1; /* 1 - 0 => 1 */ + if(bit1 != 1) + failures++; + +#if SUPPORT_BIT_ARITHMETIC + bit2 = bit1-bit0; /* 1 - 1 => 0 */ + if(bit2) + failures++; + + bit7 = bit4-bit5; + bit6 = bit4+bit5; + bit3 = bit4-bit5-bit6-bit7-bit0; /* 0-0-0-0-1 => 1 */ + if(!bit3) + failures++; +#endif +} + +/* sub_bit2uchar(void) - assumes bit0 = 1, achar0 = 7 */ + +void sub_bit2uchar(void) +{ + achar0 -= bit0; + + if(achar0 != 6) + failures++; + + if(achar0 == bit0) + failures++; +} + +void sub_bit2uint(void) +{ + if(aint0 != bit11) + failures++; + + aint0 -= bit0; + if(aint0!=0xffff) + failures++; +} +#endif + +void sub_ucharFromLit(void) +{ + achar0 = 2 - achar0; + + if(achar0 != 2) + { + printf("%x != %x\n",0x02,achar0); + failures++; + } + + aint0 = 2 - aint0; + + if(aint0 != 2) + { + printf("%x != %x\n",0x02,aint0); + failures++; + } + + aint0--; + + if(aint0 != 1) + { + printf("%x != %x\n",0x01,aint0); + failures++; + } + + aint0 = 0x100 - aint0; + + if(aint0 != 0xff) + { + printf("%x != %x\n",0xff,aint0); + failures++; + } + + aint0 = 0xff00 - aint0; + + if(aint0 != 0xfe01) + { + printf("%x != %x\n",0xfe01,aint0); + failures++; + } + + aint0 = 0x0e01 - aint0; + + if(aint0 != 0x1000) + { + printf("%x != %x\n",0x1000,aint0); + failures++; + } + + aint0 = 0x10ff - aint0; + + if(aint0 != 0xff) + { + printf("%x != %x\n",0xff,aint0); + failures++; + } +} + +int main(void) +{ + sub_lit_from_uchar(); + printf("failures: %d\n",failures); + + achar0=1; + achar1=100; + sub_uchar2uchar(); + printf("failures: %d\n",failures); + + achar0 = 10; + achar1 = 32; + sub_uchar2uchar2(); + printf("failures: %d\n",failures); + +#if SUPPORT_BIT_TYPES + sub_bits(); + + achar0 = 7; + bit0 = 1; + sub_bit2uchar(); + printf("failures: %d\n",failures); + sub_bit2uint(); + printf("failures: %d\n",failures); +#endif + + aint0 = 0; + achar0 = 0; + sub_ucharFromLit(); + + success = failures; + done(); + + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/sub2.c b/test/val/sub2.c new file mode 100644 index 000000000..835e65733 --- /dev/null +++ b/test/val/sub2.c @@ -0,0 +1,169 @@ +/* + !!DESCRIPTION!! Substraction Test + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#if SUPPORT_BIT_TYPES + +bit bit0 = 0; +bit bit1 = 0; +bit bit2 = 0; +bit bit3 = 0; +bit bit4 = 0; +bit bit5 = 0; +bit bit6 = 0; +bit bit7 = 0; +bit bit8 = 0; +bit bit9 = 0; +bit bit10 = 0; +bit bit11 = 0; + +#endif + +int int0 = 0; +int int1 = 0; + +signed char char0 = 0; +signed char char1 = 0; +signed char char2 = 0; + +void done() +{ + dummy++; +} + +void sub_int1(void) +{ + if(int0 != 5) + failures++; + + if(int1 != 4) + failures++; + + int0 = int0 - int1; + + if(int0 != 1) + failures++; + + int0 = 4 - int0; + if(int0 != 3) + failures++; + + int0 = int0 - int1; + + if(int0 != -1) + failures++; + + int0 = int0 - 0xff; + + if(int0 != -0x100) + failures++; + + int0 = 0xff - int0; + + if(int0 != 0x1ff) + failures++; +} + +void sub_char_int(void) +{ + int0 = int0 - char0; + + if(int0 != 3) + failures++; + + if(int0 < char0) + failures++; + + int0 = int0 - char0; + + if(int0 != 1) + failures++; + + if(int0 > char0) + failures++; + + int0 = int0 - char0; + if(int0 != -1) + failures++; + + if(int0>0) + failures++; +} + +void assign_char2int(void) +{ + int0 = char0; + if(int0 != 0x7f) + failures++; + + /* printf("%2x %2x %2x %d\n",0x7f,int0,char0,failures); */ + + int1 = char1; + if(int1 != -5) + failures++; + + /* printf("%2x,%d %2x,%d %2x,%d %d\n",-5,-5,(int)int1,(int)int1,(int)char1,(int)char1,failures); */ +} + +void sub_compound_char(void) +{ + char0 = char1 - 5; + if(char0 != 4) + failures++; + + if((char1 - char0 - 5) != 0) + failures++; +} + +void sub_compound_int(void) +{ + int0 = int1 - 5; + if(int0 != 4) + failures++; + + if((int1 - int0 - 5) != 0) + failures++; +} + +int main(void) +{ + int0 = 5; + int1 = 4; + + sub_int1(); + printf("failures: %d\n",failures); + + int0 = 5; + int1 = 4; + char0 = 2; + + sub_char_int(); + printf("failures: %d\n",failures); + + char0 = 0x7f; + char1 = -5; + assign_char2int(); + printf("failures: %d\n",failures); + + char1 = 9; + sub_compound_char(); + printf("failures: %d\n",failures); + + int1 = 9; + sub_compound_int(); + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/switch1.c b/test/val/switch1.c new file mode 100644 index 000000000..8d31b4ecf --- /dev/null +++ b/test/val/switch1.c @@ -0,0 +1,91 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned char achar0 = 0; +unsigned char achar1 = 0; + +void done() +{ + dummy++; +} + +void switch1(void) +{ + switch(achar0) { + case 0: + achar0 = 9; + break; + case 1: + achar0 = 18; + break; + + default: + achar0 = 0; + } +} + +void switch2(void) +{ + switch(achar1) { + case 0: achar0 = 9; break; + case 1: achar0 = 8; break; + case 2: achar0 = 7; break; + case 3: achar0 = 6; break; + case 4: achar0 = 5; break; + case 5: achar0 = 4; break; + case 6: achar0 = 3; break; + case 7: achar0 = 2; break; + case 8: achar0 = 1; break; + case 9: achar0 = 0; break; + case 10: achar0 = 9; break; + case 11: achar0 = 8; break; + case 12: achar0 = 7; break; + default: achar0 = 0xff; break; + } +} + +int main(void) +{ + achar0 = 0; + switch1(); + if(achar0 != 9) + failures++; + + switch1(); + if(achar0 != 0) + failures++; + + achar0++; + + switch1(); + if(achar0 != 18) + failures++; + + for(achar1=0; achar1<10;achar1++){ + switch2(); + if(achar0 != (9-achar1)) + failures++; + + } + + success=failures; + done(); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/while.c b/test/val/while.c new file mode 100644 index 000000000..cf2147052 --- /dev/null +++ b/test/val/while.c @@ -0,0 +1,53 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +#ifdef SUPPORT_BIT_TYPES +bit bit0 = 0; +#endif +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned char achar0 = 0; +unsigned char achar1 = 0; + +void +done () +{ + dummy++; +} + +void +while1 (void) +{ + unsigned char i = 10; + + do + { + achar0++; + } + while (--i); + + if (achar0 != 10) + failures++; +} + +int +main (void) +{ + while1 (); + + success = failures; + done (); + printf("failures: %d\n",failures); + + return failures; +} diff --git a/test/val/xor.c b/test/val/xor.c new file mode 100644 index 000000000..2a346023e --- /dev/null +++ b/test/val/xor.c @@ -0,0 +1,64 @@ +/* + !!DESCRIPTION!! + !!ORIGIN!! SDCC regression tests + !!LICENCE!! GPL, read COPYING.GPL +*/ + +#include +#include + +unsigned char success=0; +unsigned char failures=0; +unsigned char dummy=0; + +unsigned char achar0 = 0; +unsigned char achar1 = 0; +unsigned char achar2 = 0; + +void done() +{ + dummy++; +} + +void xor_chars_0_1(void) +{ + achar2 = achar0 ^ achar1; + + achar0 = achar0 ^ 0x1; + + achar1 = achar0 ^ achar1 ^ 4; +} + +void xor_if(void) +{ + if(achar0 ^ achar1) + failures++; + + achar0 ^= 0xff; + + if( !(achar0 ^ achar1) ) + failures++; +} + +int main(void) +{ + xor_chars_0_1(); + + if(achar2) + failures++; + + if(achar0 != 1) + failures++; + + if(achar1 != 5) + failures++; + + achar0 = achar1; + xor_if(); + + success = failures; + done(); + printf("failures: %d\n",failures); + + return failures; +}