From 9b82eaadd06351ac1965636c878049befe5f0633 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Wed, 24 Sep 2014 16:45:10 +0200
Subject: [PATCH 01/40] added tests as prepared by oliver
---
test/err/cc65091001.c | 29 +
test/err/front.c | 133 +++
test/ref/8q.c | 47 +
test/ref/array.c | 62 ++
test/ref/cc65070303.c | 38 +
test/ref/cc65080227.c | 37 +
test/ref/cc65080328.c | 24 +
test/ref/cc65090111.c | 49 +
test/ref/cc65090124.c | 61 ++
test/ref/cc65090726.c | 46 +
test/ref/cc65090910.c | 26 +
test/ref/cc65090913.c | 31 +
test/ref/cc65091007.c | 27 +
test/ref/cc65091022.c | 20 +
test/ref/cc65101102.c | 56 +
test/ref/cc65101209.c | 38 +
test/ref/cc65101216.c | 27 +
test/ref/cc65110210.c | 55 +
test/ref/cc65110211.c | 80 ++
test/ref/cf.c | 181 ++++
test/ref/charconst.c | 59 ++
test/ref/charset.c | 93 ++
test/ref/cvt.c | 53 +
test/ref/dijkstra.c | 369 +++++++
test/ref/divmod.c | 38 +
test/ref/fields.c | 92 ++
test/ref/hanoi.c | 90 ++
test/ref/ifexpr.c | 36 +
test/ref/incr.c | 51 +
test/ref/init.c | 94 ++
test/ref/limits.c | 56 +
test/ref/macro.c | 30 +
test/ref/mandel.c | 84 ++
test/ref/minimal.c | 14 +
test/ref/otccex.c | 148 +++
test/ref/paranoia.c | 2216 +++++++++++++++++++++++++++++++++++++++
test/ref/pointer2.c | 111 ++
test/ref/return.c | 96 ++
test/ref/sort.c | 75 ++
test/ref/spill.c | 55 +
test/ref/stdarg.c | 93 ++
test/ref/strptr.c | 130 +++
test/ref/struct.c | 261 +++++
test/ref/switch.c | 216 ++++
test/ref/switch2.c | 262 +++++
test/ref/varargs.c | 105 ++
test/ref/wf1.c | 132 +++
test/ref/yacc.c | 996 ++++++++++++++++++
test/ref/yacc2.c | 227 ++++
test/ref/yaccdbg.c | 19 +
test/val/add1.c | 181 ++++
test/val/add1.o | Bin 0 -> 6483 bytes
test/val/add1.prg | Bin 0 -> 3113 bytes
test/val/add2.c | 328 ++++++
test/val/add3.c | 263 +++++
test/val/add3.o | Bin 0 -> 22855 bytes
test/val/add3.prg | Bin 0 -> 5022 bytes
test/val/add4.c | 94 ++
test/val/add4.o | Bin 0 -> 5552 bytes
test/val/add4.prg | Bin 0 -> 3019 bytes
test/val/and1.c | 145 +++
test/val/and2.c | 118 +++
test/val/atoi-test.c | 42 +
test/val/bool1.c | 130 +++
test/val/bool3.c | 66 ++
test/val/call1.c | 157 +++
test/val/cc65091020.c | 26 +
test/val/compare1.c | 183 ++++
test/val/compare10.c | 319 ++++++
test/val/compare2.c | 362 +++++++
test/val/compare3.c | 246 +++++
test/val/compare4.c | 349 ++++++
test/val/compare5.c | 445 ++++++++
test/val/compare6.c | 176 ++++
test/val/compare7.c | 307 ++++++
test/val/compare8.c | 311 ++++++
test/val/compare9.c | 297 ++++++
test/val/cq22.c | 144 +++
test/val/cq241.c | 286 +++++
test/val/cq243.c | 264 +++++
test/val/cq244.c | 159 +++
test/val/cq25.c | 171 +++
test/val/cq26.c | 217 ++++
test/val/cq4.c | 242 +++++
test/val/cq61.c | 186 ++++
test/val/cq626.c | 337 ++++++
test/val/cq71.c | 240 +++++
test/val/cq714.c | 1795 +++++++++++++++++++++++++++++++
test/val/cq714b.c | 1016 ++++++++++++++++++
test/val/cq715.c | 151 +++
test/val/cq72.c | 345 ++++++
test/val/cq757.c | 335 ++++++
test/val/cq7813.c | 381 +++++++
test/val/cq81.c | 727 +++++++++++++
test/val/cq84.c | 268 +++++
test/val/cq85.c | 313 ++++++
test/val/cq86.c | 228 ++++
test/val/cq88.c | 184 ++++
test/val/cq9.c | 154 +++
test/val/for.c | 109 ++
test/val/mult1.c | 117 +++
test/val/nestfor.c | 151 +++
test/val/or1.c | 192 ++++
test/val/pointer1.c | 134 +++
test/val/ptrfunc.c | 136 +++
test/val/rotate1.c | 201 ++++
test/val/rotate2.c | 71 ++
test/val/rotate3.c | 384 +++++++
test/val/rotate4.c | 228 ++++
test/val/rotate5.c | 260 +++++
test/val/rotate6.c | 158 +++
test/val/rotate7.c | 413 ++++++++
test/val/sitest.c | 1591 ++++++++++++++++++++++++++++
test/val/strtol-test.c | 135 +++
test/val/strtoul-test.c | 121 +++
test/val/struct1.c | 100 ++
test/val/sub1.c | 272 +++++
test/val/sub2.c | 169 +++
test/val/switch1.c | 91 ++
test/val/while.c | 53 +
test/val/xor.c | 64 ++
121 files changed, 25206 insertions(+)
create mode 100644 test/err/cc65091001.c
create mode 100644 test/err/front.c
create mode 100644 test/ref/8q.c
create mode 100644 test/ref/array.c
create mode 100644 test/ref/cc65070303.c
create mode 100644 test/ref/cc65080227.c
create mode 100644 test/ref/cc65080328.c
create mode 100644 test/ref/cc65090111.c
create mode 100644 test/ref/cc65090124.c
create mode 100644 test/ref/cc65090726.c
create mode 100644 test/ref/cc65090910.c
create mode 100644 test/ref/cc65090913.c
create mode 100644 test/ref/cc65091007.c
create mode 100644 test/ref/cc65091022.c
create mode 100644 test/ref/cc65101102.c
create mode 100644 test/ref/cc65101209.c
create mode 100644 test/ref/cc65101216.c
create mode 100644 test/ref/cc65110210.c
create mode 100644 test/ref/cc65110211.c
create mode 100644 test/ref/cf.c
create mode 100644 test/ref/charconst.c
create mode 100644 test/ref/charset.c
create mode 100644 test/ref/cvt.c
create mode 100644 test/ref/dijkstra.c
create mode 100644 test/ref/divmod.c
create mode 100644 test/ref/fields.c
create mode 100644 test/ref/hanoi.c
create mode 100644 test/ref/ifexpr.c
create mode 100644 test/ref/incr.c
create mode 100644 test/ref/init.c
create mode 100644 test/ref/limits.c
create mode 100644 test/ref/macro.c
create mode 100644 test/ref/mandel.c
create mode 100644 test/ref/minimal.c
create mode 100644 test/ref/otccex.c
create mode 100644 test/ref/paranoia.c
create mode 100644 test/ref/pointer2.c
create mode 100644 test/ref/return.c
create mode 100644 test/ref/sort.c
create mode 100644 test/ref/spill.c
create mode 100644 test/ref/stdarg.c
create mode 100644 test/ref/strptr.c
create mode 100644 test/ref/struct.c
create mode 100644 test/ref/switch.c
create mode 100644 test/ref/switch2.c
create mode 100644 test/ref/varargs.c
create mode 100644 test/ref/wf1.c
create mode 100644 test/ref/yacc.c
create mode 100644 test/ref/yacc2.c
create mode 100644 test/ref/yaccdbg.c
create mode 100644 test/val/add1.c
create mode 100644 test/val/add1.o
create mode 100644 test/val/add1.prg
create mode 100644 test/val/add2.c
create mode 100644 test/val/add3.c
create mode 100644 test/val/add3.o
create mode 100644 test/val/add3.prg
create mode 100644 test/val/add4.c
create mode 100644 test/val/add4.o
create mode 100644 test/val/add4.prg
create mode 100644 test/val/and1.c
create mode 100644 test/val/and2.c
create mode 100644 test/val/atoi-test.c
create mode 100644 test/val/bool1.c
create mode 100644 test/val/bool3.c
create mode 100644 test/val/call1.c
create mode 100644 test/val/cc65091020.c
create mode 100644 test/val/compare1.c
create mode 100644 test/val/compare10.c
create mode 100644 test/val/compare2.c
create mode 100644 test/val/compare3.c
create mode 100644 test/val/compare4.c
create mode 100644 test/val/compare5.c
create mode 100644 test/val/compare6.c
create mode 100644 test/val/compare7.c
create mode 100644 test/val/compare8.c
create mode 100644 test/val/compare9.c
create mode 100644 test/val/cq22.c
create mode 100644 test/val/cq241.c
create mode 100644 test/val/cq243.c
create mode 100644 test/val/cq244.c
create mode 100644 test/val/cq25.c
create mode 100644 test/val/cq26.c
create mode 100644 test/val/cq4.c
create mode 100644 test/val/cq61.c
create mode 100644 test/val/cq626.c
create mode 100644 test/val/cq71.c
create mode 100644 test/val/cq714.c
create mode 100644 test/val/cq714b.c
create mode 100644 test/val/cq715.c
create mode 100644 test/val/cq72.c
create mode 100644 test/val/cq757.c
create mode 100644 test/val/cq7813.c
create mode 100644 test/val/cq81.c
create mode 100644 test/val/cq84.c
create mode 100644 test/val/cq85.c
create mode 100644 test/val/cq86.c
create mode 100644 test/val/cq88.c
create mode 100644 test/val/cq9.c
create mode 100644 test/val/for.c
create mode 100644 test/val/mult1.c
create mode 100644 test/val/nestfor.c
create mode 100644 test/val/or1.c
create mode 100644 test/val/pointer1.c
create mode 100644 test/val/ptrfunc.c
create mode 100644 test/val/rotate1.c
create mode 100644 test/val/rotate2.c
create mode 100644 test/val/rotate3.c
create mode 100644 test/val/rotate4.c
create mode 100644 test/val/rotate5.c
create mode 100644 test/val/rotate6.c
create mode 100644 test/val/rotate7.c
create mode 100644 test/val/sitest.c
create mode 100644 test/val/strtol-test.c
create mode 100644 test/val/strtoul-test.c
create mode 100644 test/val/struct1.c
create mode 100644 test/val/sub1.c
create mode 100644 test/val/sub2.c
create mode 100644 test/val/switch1.c
create mode 100644 test/val/while.c
create mode 100644 test/val/xor.c
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 <assert.h>
+#include <string.h>
+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 <stdio.h>
+
+#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 <stdio.h>
+
+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 <stdint.h>
+
+int main(void)
+{
+ static uint8_t x = 0;
+ static uint8_t y = 0;
+
+ for (x = 0; x < 16; ++x)
+ {
+ y = y + 1;
+ }
+ for(;;);
+}
+*/
+
+#include <stdint.h>
+
+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(foo<bar)
+ label: ++foo;
+
+ printf("foo: %d bar: %d\n",foo,bar);
+
+ return 0;
+}
diff --git a/test/ref/cc65091007.c b/test/ref/cc65091007.c
new file mode 100644
index 000000000..1c69e02f9
--- /dev/null
+++ b/test/ref/cc65091007.c
@@ -0,0 +1,27 @@
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Johan Kotlinski
+*/
+
+/*
+This produces the compiler error "test.c(9): Error: Assignment to const"
+Shouldn't be an error, should it? baz is const, bar isn't.
+*/
+
+typedef struct {
+ char foo;
+} Bar;
+
+int main() {
+ Bar bar;
+ Bar* const baz = &bar;
+
+ baz->foo = 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 <stdio.h>
+#include <stdint.h>
+
+// 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 <stdlib.h>
+#include <stdio.h>
+
+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 <stdio.h>
+#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 <stdio.h>
+#include <limits.h>
+
+#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 <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#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 <limits.h>
+#include <ctype.h>
+
+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 <stdio.h>
+
+#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 <stdio.h>
+#include <stdlib.h>
+
+#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(!(mindist<graph->MINDIST)){
+ 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 <stdio.h>
+
+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 <stdint.h>
+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 <stdio.h>
+#include <stdlib.h>
+
+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]<disk)
+ {
+ mov(disk,1,3);
+ ++iter;
+ }
+
+ return 0;
+}
diff --git a/test/ref/ifexpr.c b/test/ref/ifexpr.c
new file mode 100644
index 000000000..a60203917
--- /dev/null
+++ b/test/ref/ifexpr.c
@@ -0,0 +1,36 @@
+/*
+ !!DESCRIPTION!! if/then, ? operator, compares
+ !!ORIGIN!! cc65 devel list
+ !!LICENCE!! Public Domain
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+#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 <stdio.h>
+#include <stdlib.h>
+
+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 <stdio.h>
+#include <stdlib.h>
+
+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 fromfp(_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)/(_b))
+
+unsigned char dither[MAXCOL]={" .*o+0%#"};
+
+void mandelbrot(signed short x1,signed short y1,signed short x2,signed short y2)
+{
+register signed short r,r1,i;
+register unsigned char count;
+register signed short xs,ys,xx,yy;
+register signed short x;
+register unsigned char y;
+
+ /* calc stepwidth */
+ xs=((x2-x1)/(SCREEN_X));
+ ys=((y2-y1)/(SCREEN_Y));
+
+ yy=y1;
+ for(y = 0; y < (SCREEN_Y); ++y)
+ {
+ yy+=ys; xx=x1;
+ for(x = 0; x < (SCREEN_X); ++x)
+ {
+ xx+=xs;
+ /* do iterations */
+ r=0;i=0;
+ for(count=0;(count<maxiterations)&&
+ (fpabs(r)<tofp(2))&&
+ (fpabs(i)<tofp(2))
+ ;++count)
+ {
+ r1 = (mulfp(r,r)-mulfp(i,i))+xx;
+ /* i = (mulfp(mulfp(r,i),tofp(2)))+yy; */
+ i = (((signed long)r*i)>>(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 <stdio.h>
+#include <limits.h>
+
+/* 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 <stdio.h>
+#ifndef NOSIGNAL
+#include <signal.h>
+#endif
+#include <setjmp.h>
+
+extern double fabs(), floor(), log(), pow(), sqrt();
+
+#ifdef Single
+#define FLOAT float
+#define FABS(x) (float)fabs((double)(x))
+#define FLOOR(x) (float)floor((double)(x))
+#define LOG(x) (float)log((double)(x))
+#define POW(x,y) (float)pow((double)(x),(double)(y))
+#define SQRT(x) (float)sqrt((double)(x))
+#else
+#define FLOAT double
+#define FABS(x) fabs(x)
+#define FLOOR(x) floor(x)
+#define LOG(x) log(x)
+#define POW(x,y) pow(x,y)
+#define SQRT(x) sqrt(x)
+#endif
+
+jmp_buf ovfl_buf;
+typedef void (*Sig_type)();
+Sig_type sigsave;
+
+#define KEYBOARD 0
+
+FLOAT Radix, BInvrse, RadixD2, BMinusU2;
+FLOAT Sign(), Random();
+
+/*Small floating point constants.*/
+FLOAT Zero = 0.0;
+FLOAT Half = 0.5;
+FLOAT One = 1.0;
+FLOAT Two = 2.0;
+FLOAT Three = 3.0;
+FLOAT Four = 4.0;
+FLOAT Five = 5.0;
+FLOAT Eight = 8.0;
+FLOAT Nine = 9.0;
+FLOAT TwentySeven = 27.0;
+FLOAT ThirtyTwo = 32.0;
+FLOAT TwoForty = 240.0;
+FLOAT MinusOne = -1.0;
+FLOAT OneAndHalf = 1.5;
+/*Integer constants*/
+int NoTrials = 20; /*Number of tests for commutativity. */
+#define False 0
+#define True 1
+
+/* Definitions for declared types
+ Guard == (Yes, No);
+ Rounding == (Chopped, Rounded, Other);
+ Message == packed array [1..40] of char;
+ Class == (Flaw, Defect, Serious, Failure);
+ */
+#define Yes 1
+#define No 0
+#define Chopped 2
+#define Rounded 1
+#define Other 0
+#define Flaw 3
+#define Defect 2
+#define Serious 1
+#define Failure 0
+typedef int Guard, Rounding, Class;
+typedef char Message;
+
+/* Declarations of Variables */
+int Indx;
+char ch[8];
+FLOAT AInvrse, A1;
+FLOAT C, CInvrse;
+FLOAT D, FourD;
+FLOAT E0, E1, Exp2, E3, MinSqEr;
+FLOAT SqEr, MaxSqEr, E9;
+FLOAT Third;
+FLOAT F6, F9;
+FLOAT H, HInvrse;
+int I;
+FLOAT StickyBit, J;
+FLOAT MyZero;
+FLOAT Precision;
+FLOAT Q, Q9;
+FLOAT R, Random9;
+FLOAT T, Underflow, S;
+FLOAT OneUlp, UfThold, U1, U2;
+FLOAT V, V0, V9;
+FLOAT W;
+FLOAT X, X1, X2, X8, Random1;
+FLOAT Y, Y1, Y2, Random2;
+FLOAT Z, PseudoZero, Z1, Z2, Z9;
+int ErrCnt[4];
+int fpecount;
+int Milestone;
+int PageNo;
+int M, N, N1;
+Guard GMult, GDiv, GAddSub;
+Rounding RMult, RDiv, RAddSub, RSqrt;
+int Break, Done, NotMonot, Monot, Anomaly, IEEE,
+ SqRWrng, UfNGrad;
+/* Computed constants. */
+/*U1 gap below 1.0, i.e, 1.0-U1 is next number below 1.0 */
+/*U2 gap above 1.0, i.e, 1.0+U2 is next number above 1.0 */
+
+/* floating point exception receiver */
+ void
+sigfpe(i)
+{
+ fpecount++;
+ printf("\n* * * FLOATING-POINT ERROR * * *\n");
+ fflush(stdout);
+ if (sigsave) {
+#ifndef NOSIGNAL
+ signal(SIGFPE, sigsave);
+#endif
+ sigsave = 0;
+ longjmp(ovfl_buf, 1);
+ }
+ abort();
+}
+
+main()
+{
+#ifdef mc
+ char *out;
+ ieee_flags("set", "precision", "double", &out);
+#endif
+ /* First two assignments use integer right-hand sides. */
+ Zero = 0;
+ One = 1;
+ Two = One + One;
+ Three = Two + One;
+ Four = Three + One;
+ Five = Four + One;
+ Eight = Four + Four;
+ Nine = Three * Three;
+ TwentySeven = Nine * Three;
+ ThirtyTwo = Four * Eight;
+ TwoForty = Four * Five * Three * Four;
+ MinusOne = -One;
+ Half = One / Two;
+ OneAndHalf = One + Half;
+ ErrCnt[Failure] = 0;
+ ErrCnt[Serious] = 0;
+ ErrCnt[Defect] = 0;
+ ErrCnt[Flaw] = 0;
+ PageNo = 1;
+ /*=============================================*/
+ Milestone = 0;
+ /*=============================================*/
+#ifndef NOSIGNAL
+ signal(SIGFPE, sigfpe);
+#endif
+ Instructions();
+ Pause();
+ Heading();
+ Pause();
+ Characteristics();
+ Pause();
+ History();
+ Pause();
+ /*=============================================*/
+ Milestone = 7;
+ /*=============================================*/
+ printf("Program is now RUNNING tests on small integers:\n");
+
+ TstCond (Failure, (Zero + Zero == Zero) && (One - One == Zero)
+ && (One > Zero) && (One + One == Two),
+ "0+0 != 0, 1-1 != 0, 1 <= 0, or 1+1 != 2");
+ Z = - Zero;
+ if (Z != 0.0) {
+ ErrCnt[Failure] = ErrCnt[Failure] + 1;
+ printf("Comparison alleges that -0.0 is Non-zero!\n");
+ U1 = 0.001;
+ Radix = 1;
+ TstPtUf();
+ }
+ TstCond (Failure, (Three == Two + One) && (Four == Three + One)
+ && (Four + Two * (- Two) == Zero)
+ && (Four - Three - One == Zero),
+ "3 != 2+1, 4 != 3+1, 4+2*(-2) != 0, or 4-3-1 != 0");
+ TstCond (Failure, (MinusOne == (0 - One))
+ && (MinusOne + One == Zero ) && (One + MinusOne == Zero)
+ && (MinusOne + FABS(One) == Zero)
+ && (MinusOne + MinusOne * MinusOne == Zero),
+ "-1+1 != 0, (-1)+abs(1) != 0, or -1+(-1)*(-1) != 0");
+ TstCond (Failure, Half + MinusOne + Half == Zero,
+ "1/2 + (-1) + 1/2 != 0");
+ /*=============================================*/
+ /*SPLIT
+ part2();
+ part3();
+ part4();
+ part5();
+ part6();
+ part7();
+ part8();
+ }
+#include "paranoia.h"
+part2(){
+*/
+ Milestone = 10;
+ /*=============================================*/
+ TstCond (Failure, (Nine == Three * Three)
+ && (TwentySeven == Nine * Three) && (Eight == Four + Four)
+ && (ThirtyTwo == Eight * Four)
+ && (ThirtyTwo - TwentySeven - Four - One == Zero),
+ "9 != 3*3, 27 != 9*3, 32 != 8*4, or 32-27-4-1 != 0");
+ TstCond (Failure, (Five == Four + One) &&
+ (TwoForty == Four * Five * Three * Four)
+ && (TwoForty / Three - Four * Four * Five == Zero)
+ && ( TwoForty / Four - Five * Three * Four == Zero)
+ && ( TwoForty / Five - Four * Three * Four == Zero),
+ "5 != 4+1, 240/3 != 80, 240/4 != 60, or 240/5 != 48");
+ if (ErrCnt[Failure] == 0) {
+ printf("-1, 0, 1/2, 1, 2, 3, 4, 5, 9, 27, 32 & 240 are O.K.\n");
+ printf("\n");
+ }
+ printf("Searching for Radix and Precision.\n");
+ W = One;
+ do {
+ W = W + W;
+ Y = W + One;
+ Z = Y - W;
+ Y = Z - One;
+ } while (MinusOne + FABS(Y) < Zero);
+ /*.. now W is just big enough that |((W+1)-W)-1| >= 1 ...*/
+ Precision = Zero;
+ Y = One;
+ do {
+ Radix = W + Y;
+ Y = Y + Y;
+ Radix = Radix - W;
+ } while ( Radix == Zero);
+ if (Radix < Two) Radix = One;
+ printf("Radix = %f .\n", Radix);
+ if (Radix != 1) {
+ W = One;
+ do {
+ Precision = Precision + One;
+ W = W * Radix;
+ Y = W + One;
+ } while ((Y - W) == One);
+ }
+ /*... now W == Radix^Precision is barely too big to satisfy (W+1)-W == 1
+ ...*/
+ U1 = One / W;
+ U2 = Radix * U1;
+ printf("Closest relative separation found is U1 = %.7e .\n\n", U1);
+ printf("Recalculating radix and precision\n ");
+
+ /*save old values*/
+ E0 = Radix;
+ E1 = U1;
+ E9 = U2;
+ E3 = Precision;
+
+ X = Four / Three;
+ Third = X - One;
+ F6 = Half - Third;
+ X = F6 + F6;
+ X = FABS(X - Third);
+ if (X < U2) X = U2;
+
+ /*... now X = (unknown no.) ulps of 1+...*/
+ do {
+ U2 = X;
+ Y = Half * U2 + ThirtyTwo * U2 * U2;
+ Y = One + Y;
+ X = Y - One;
+ } while ( ! ((U2 <= X) || (X <= Zero)));
+
+ /*... now U2 == 1 ulp of 1 + ... */
+ X = Two / Three;
+ F6 = X - Half;
+ Third = F6 + F6;
+ X = Third - Half;
+ X = FABS(X + F6);
+ if (X < U1) X = U1;
+
+ /*... now X == (unknown no.) ulps of 1 -... */
+ do {
+ U1 = X;
+ Y = Half * U1 + ThirtyTwo * U1 * U1;
+ Y = Half - Y;
+ X = Half + Y;
+ Y = Half - X;
+ X = Half + Y;
+ } while ( ! ((U1 <= X) || (X <= Zero)));
+ /*... now U1 == 1 ulp of 1 - ... */
+ if (U1 == E1) printf("confirms closest relative separation U1 .\n");
+ else printf("gets better closest relative separation U1 = %.7e .\n", U1);
+ W = One / U1;
+ F9 = (Half - U1) + Half;
+ Radix = FLOOR(0.01 + U2 / U1);
+ if (Radix == E0) printf("Radix confirmed.\n");
+ else printf("MYSTERY: recalculated Radix = %.7e .\n", Radix);
+ TstCond (Defect, Radix <= Eight + Eight,
+ "Radix is too big: roundoff problems");
+ TstCond (Flaw, (Radix == Two) || (Radix == 10)
+ || (Radix == One), "Radix is not as good as 2 or 10");
+ /*=============================================*/
+ Milestone = 20;
+ /*=============================================*/
+ TstCond (Failure, F9 - Half < Half,
+ "(1-U1)-1/2 < 1/2 is FALSE, prog. fails?");
+ X = F9;
+ I = 1;
+ Y = X - Half;
+ Z = Y - Half;
+ TstCond (Failure, (X != One)
+ || (Z == Zero), "Comparison is fuzzy,X=1 but X-1/2-1/2 != 0");
+ X = One + U2;
+ I = 0;
+ /*=============================================*/
+ Milestone = 25;
+ /*=============================================*/
+ /*... BMinusU2 = nextafter(Radix, 0) */
+ BMinusU2 = Radix - One;
+ BMinusU2 = (BMinusU2 - U2) + One;
+ /* Purify Integers */
+ if (Radix != One) {
+ X = - TwoForty * LOG(U1) / LOG(Radix);
+ Y = FLOOR(Half + X);
+ if (FABS(X - Y) * Four < One) X = Y;
+ Precision = X / TwoForty;
+ Y = FLOOR(Half + Precision);
+ if (FABS(Precision - Y) * TwoForty < Half) Precision = Y;
+ }
+ if ((Precision != FLOOR(Precision)) || (Radix == One)) {
+ printf("Precision cannot be characterized by an Integer number\n");
+ printf("of significant digits but, by itself, this is a minor flaw.\n");
+ }
+ if (Radix == One)
+ printf("logarithmic encoding has precision characterized solely by U1.\n");
+ else printf("The number of significant digits of the Radix is %f .\n",
+ Precision);
+ TstCond (Serious, U2 * Nine * Nine * TwoForty < One,
+ "Precision worse than 5 decimal figures ");
+ /*=============================================*/
+ Milestone = 30;
+ /*=============================================*/
+ /* Test for extra-precise subepressions */
+ X = FABS(((Four / Three - One) - One / Four) * Three - One / Four);
+ do {
+ Z2 = X;
+ X = (One + (Half * Z2 + ThirtyTwo * Z2 * Z2)) - One;
+ } while ( ! ((Z2 <= X) || (X <= Zero)));
+ X = Y = Z = FABS((Three / Four - Two / Three) * Three - One / Four);
+ do {
+ Z1 = Z;
+ Z = (One / Two - ((One / Two - (Half * Z1 + ThirtyTwo * Z1 * Z1))
+ + One / Two)) + One / Two;
+ } while ( ! ((Z1 <= Z) || (Z <= Zero)));
+ do {
+ do {
+ Y1 = Y;
+ Y = (Half - ((Half - (Half * Y1 + ThirtyTwo * Y1 * Y1)) + Half
+ )) + Half;
+ } while ( ! ((Y1 <= Y) || (Y <= Zero)));
+ X1 = X;
+ X = ((Half * X1 + ThirtyTwo * X1 * X1) - F9) + F9;
+ } while ( ! ((X1 <= X) || (X <= Zero)));
+ if ((X1 != Y1) || (X1 != Z1)) {
+ BadCond(Serious, "Disagreements among the values X1, Y1, Z1,\n");
+ printf("respectively %.7e, %.7e, %.7e,\n", X1, Y1, Z1);
+ printf("are symptoms of inconsistencies introduced\n");
+ printf("by extra-precise evaluation of arithmetic subexpressions.\n");
+ notify("Possibly some part of this");
+ if ((X1 == U1) || (Y1 == U1) || (Z1 == U1)) printf(
+ "That feature is not tested further by this program.\n") ;
+ }
+ else {
+ if ((Z1 != U1) || (Z2 != U2)) {
+ if ((Z1 >= U1) || (Z2 >= U2)) {
+ BadCond(Failure, "");
+ notify("Precision");
+ printf("\tU1 = %.7e, Z1 - U1 = %.7e\n",U1,Z1-U1);
+ printf("\tU2 = %.7e, Z2 - U2 = %.7e\n",U2,Z2-U2);
+ }
+ else {
+ if ((Z1 <= Zero) || (Z2 <= Zero)) {
+ printf("Because of unusual Radix = %f", Radix);
+ printf(", or exact rational arithmetic a result\n");
+ printf("Z1 = %.7e, or Z2 = %.7e ", Z1, Z2);
+ notify("of an\nextra-precision");
+ }
+ if (Z1 != Z2 || Z1 > Zero) {
+ X = Z1 / U1;
+ Y = Z2 / U2;
+ if (Y > X) X = Y;
+ Q = - LOG(X);
+ printf("Some subexpressions appear to be calculated extra\n");
+ printf("precisely with about %g extra B-digits, i.e.\n",
+ (Q / LOG(Radix)));
+ printf("roughly %g extra significant decimals.\n",
+ Q / LOG(10.));
+ }
+ printf("That feature is not tested further by this program.\n");
+ }
+ }
+ }
+ Pause();
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part3(){
+*/
+ Milestone = 35;
+ /*=============================================*/
+ if (Radix >= Two) {
+ X = W / (Radix * Radix);
+ Y = X + One;
+ Z = Y - X;
+ T = Z + U2;
+ X = T - Z;
+ TstCond (Failure, X == U2,
+ "Subtraction is not normalized X=Y,X+Z != Y+Z!");
+ if (X == U2) printf(
+ "Subtraction appears to be normalized, as it should be.");
+ }
+ printf("\nChecking for guard digit in *, /, and -.\n");
+ Y = F9 * One;
+ Z = One * F9;
+ X = F9 - Half;
+ Y = (Y - Half) - X;
+ Z = (Z - Half) - X;
+ X = One + U2;
+ T = X * Radix;
+ R = Radix * X;
+ X = T - Radix;
+ X = X - Radix * U2;
+ T = R - Radix;
+ T = T - Radix * U2;
+ X = X * (Radix - One);
+ T = T * (Radix - One);
+ if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)) GMult = Yes;
+ else {
+ GMult = No;
+ TstCond (Serious, False,
+ "* lacks a Guard Digit, so 1*X != X");
+ }
+ Z = Radix * U2;
+ X = One + Z;
+ Y = FABS((X + Z) - X * X) - U2;
+ X = One - U2;
+ Z = FABS((X - U2) - X * X) - U1;
+ TstCond (Failure, (Y <= Zero)
+ && (Z <= Zero), "* gets too many final digits wrong.\n");
+ Y = One - U2;
+ X = One + U2;
+ Z = One / Y;
+ Y = Z - X;
+ X = One / Three;
+ Z = Three / Nine;
+ X = X - Z;
+ T = Nine / TwentySeven;
+ Z = Z - T;
+ TstCond(Defect, X == Zero && Y == Zero && Z == Zero,
+ "Division lacks a Guard Digit, so error can exceed 1 ulp\nor 1/3 and 3/9 and 9/27 may disagree");
+ Y = F9 / One;
+ X = F9 - Half;
+ Y = (Y - Half) - X;
+ X = One + U2;
+ T = X / One;
+ X = T - X;
+ if ((X == Zero) && (Y == Zero) && (Z == Zero)) GDiv = Yes;
+ else {
+ GDiv = No;
+ TstCond (Serious, False,
+ "Division lacks a Guard Digit, so X/1 != X");
+ }
+ X = One / (One + U2);
+ Y = X - Half - Half;
+ TstCond (Serious, Y < Zero,
+ "Computed value of 1/1.000..1 >= 1");
+ X = One - U2;
+ Y = One + Radix * U2;
+ Z = X * Radix;
+ T = Y * Radix;
+ R = Z / Radix;
+ StickyBit = T / Radix;
+ X = R - X;
+ Y = StickyBit - Y;
+ TstCond (Failure, X == Zero && Y == Zero,
+ "* and/or / gets too many last digits wrong");
+ Y = One - U1;
+ X = One - F9;
+ Y = One - Y;
+ T = Radix - U2;
+ Z = Radix - BMinusU2;
+ T = Radix - T;
+ if ((X == U1) && (Y == U1) && (Z == U2) && (T == U2)) GAddSub = Yes;
+ else {
+ GAddSub = No;
+ TstCond (Serious, False,
+ "- lacks Guard Digit, so cancellation is obscured");
+ }
+ if (F9 != One && F9 - One >= Zero) {
+ BadCond(Serious, "comparison alleges (1-U1) < 1 although\n");
+ printf(" subtraction yields (1-U1) - 1 = 0 , thereby vitiating\n");
+ printf(" such precautions against division by zero as\n");
+ printf(" ... if (X == 1.0) {.....} else {.../(X-1.0)...}\n");
+ }
+ if (GMult == Yes && GDiv == Yes && GAddSub == Yes) printf(
+ " *, /, and - appear to have guard digits, as they should.\n");
+ /*=============================================*/
+ Milestone = 40;
+ /*=============================================*/
+ Pause();
+ printf("Checking rounding on multiply, divide and add/subtract.\n");
+ RMult = Other;
+ RDiv = Other;
+ RAddSub = Other;
+ RadixD2 = Radix / Two;
+ A1 = Two;
+ Done = False;
+ do {
+ AInvrse = Radix;
+ do {
+ X = AInvrse;
+ AInvrse = AInvrse / A1;
+ } while ( ! (FLOOR(AInvrse) != AInvrse));
+ Done = (X == One) || (A1 > Three);
+ if (! Done) A1 = Nine + One;
+ } while ( ! (Done));
+ if (X == One) A1 = Radix;
+ AInvrse = One / A1;
+ X = A1;
+ Y = AInvrse;
+ Done = False;
+ do {
+ Z = X * Y - Half;
+ TstCond (Failure, Z == Half,
+ "X * (1/X) differs from 1");
+ Done = X == Radix;
+ X = Radix;
+ Y = One / X;
+ } while ( ! (Done));
+ Y2 = One + U2;
+ Y1 = One - U2;
+ X = OneAndHalf - U2;
+ Y = OneAndHalf + U2;
+ Z = (X - U2) * Y2;
+ T = Y * Y1;
+ Z = Z - X;
+ T = T - X;
+ X = X * Y2;
+ Y = (Y + U2) * Y1;
+ X = X - OneAndHalf;
+ Y = Y - OneAndHalf;
+ if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T <= Zero)) {
+ X = (OneAndHalf + U2) * Y2;
+ Y = OneAndHalf - U2 - U2;
+ Z = OneAndHalf + U2 + U2;
+ T = (OneAndHalf - U2) * Y1;
+ X = X - (Z + U2);
+ StickyBit = Y * Y1;
+ S = Z * Y2;
+ T = T - Y;
+ Y = (U2 - Y) + StickyBit;
+ Z = S - (Z + U2 + U2);
+ StickyBit = (Y2 + U2) * Y1;
+ Y1 = Y2 * Y1;
+ StickyBit = StickyBit - Y2;
+ Y1 = Y1 - Half;
+ if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)
+ && ( StickyBit == Zero) && (Y1 == Half)) {
+ RMult = Rounded;
+ printf("Multiplication appears to round correctly.\n");
+ }
+ else if ((X + U2 == Zero) && (Y < Zero) && (Z + U2 == Zero)
+ && (T < Zero) && (StickyBit + U2 == Zero)
+ && (Y1 < Half)) {
+ RMult = Chopped;
+ printf("Multiplication appears to chop.\n");
+ }
+ else printf("* is neither chopped nor correctly rounded.\n");
+ if ((RMult == Rounded) && (GMult == No)) notify("Multiplication");
+ }
+ else printf("* is neither chopped nor correctly rounded.\n");
+ /*=============================================*/
+ Milestone = 45;
+ /*=============================================*/
+ Y2 = One + U2;
+ Y1 = One - U2;
+ Z = OneAndHalf + U2 + U2;
+ X = Z / Y2;
+ T = OneAndHalf - U2 - U2;
+ Y = (T - U2) / Y1;
+ Z = (Z + U2) / Y2;
+ X = X - OneAndHalf;
+ Y = Y - T;
+ T = T / Y1;
+ Z = Z - (OneAndHalf + U2);
+ T = (U2 - OneAndHalf) + T;
+ if (! ((X > Zero) || (Y > Zero) || (Z > Zero) || (T > Zero))) {
+ X = OneAndHalf / Y2;
+ Y = OneAndHalf - U2;
+ Z = OneAndHalf + U2;
+ X = X - Y;
+ T = OneAndHalf / Y1;
+ Y = Y / Y1;
+ T = T - (Z + U2);
+ Y = Y - Z;
+ Z = Z / Y2;
+ Y1 = (Y2 + U2) / Y2;
+ Z = Z - OneAndHalf;
+ Y2 = Y1 - Y2;
+ Y1 = (F9 - U1) / F9;
+ if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)
+ && (Y2 == Zero) && (Y2 == Zero)
+ && (Y1 - Half == F9 - Half )) {
+ RDiv = Rounded;
+ printf("Division appears to round correctly.\n");
+ if (GDiv == No) notify("Division");
+ }
+ else if ((X < Zero) && (Y < Zero) && (Z < Zero) && (T < Zero)
+ && (Y2 < Zero) && (Y1 - Half < F9 - Half)) {
+ RDiv = Chopped;
+ printf("Division appears to chop.\n");
+ }
+ }
+ if (RDiv == Other) printf("/ is neither chopped nor correctly rounded.\n");
+ BInvrse = One / Radix;
+ TstCond (Failure, (BInvrse * Radix - Half == Half),
+ "Radix * ( 1 / Radix ) differs from 1");
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part4(){
+*/
+ Milestone = 50;
+ /*=============================================*/
+ TstCond (Failure, ((F9 + U1) - Half == Half)
+ && ((BMinusU2 + U2 ) - One == Radix - One),
+ "Incomplete carry-propagation in Addition");
+ X = One - U1 * U1;
+ Y = One + U2 * (One - U2);
+ Z = F9 - Half;
+ X = (X - Half) - Z;
+ Y = Y - One;
+ if ((X == Zero) && (Y == Zero)) {
+ RAddSub = Chopped;
+ printf("Add/Subtract appears to be chopped.\n");
+ }
+ if (GAddSub == Yes) {
+ X = (Half + U2) * U2;
+ Y = (Half - U2) * U2;
+ X = One + X;
+ Y = One + Y;
+ X = (One + U2) - X;
+ Y = One - Y;
+ if ((X == Zero) && (Y == Zero)) {
+ X = (Half + U2) * U1;
+ Y = (Half - U2) * U1;
+ X = One - X;
+ Y = One - Y;
+ X = F9 - X;
+ Y = One - Y;
+ if ((X == Zero) && (Y == Zero)) {
+ RAddSub = Rounded;
+ printf("Addition/Subtraction appears to round correctly.\n");
+ if (GAddSub == No) notify("Add/Subtract");
+ }
+ else printf("Addition/Subtraction neither rounds nor chops.\n");
+ }
+ else printf("Addition/Subtraction neither rounds nor chops.\n");
+ }
+ else printf("Addition/Subtraction neither rounds nor chops.\n");
+ S = One;
+ X = One + Half * (One + Half);
+ Y = (One + U2) * Half;
+ Z = X - Y;
+ T = Y - X;
+ StickyBit = Z + T;
+ if (StickyBit != Zero) {
+ S = Zero;
+ BadCond(Flaw, "(X - Y) + (Y - X) is non zero!\n");
+ }
+ StickyBit = Zero;
+ if ((GMult == Yes) && (GDiv == Yes) && (GAddSub == Yes)
+ && (RMult == Rounded) && (RDiv == Rounded)
+ && (RAddSub == Rounded) && (FLOOR(RadixD2) == RadixD2)) {
+ printf("Checking for sticky bit.\n");
+ X = (Half + U1) * U2;
+ Y = Half * U2;
+ Z = One + Y;
+ T = One + X;
+ if ((Z - One <= Zero) && (T - One >= U2)) {
+ Z = T + Y;
+ Y = Z - X;
+ if ((Z - T >= U2) && (Y - T == Zero)) {
+ X = (Half + U1) * U1;
+ Y = Half * U1;
+ Z = One - Y;
+ T = One - X;
+ if ((Z - One == Zero) && (T - F9 == Zero)) {
+ Z = (Half - U1) * U1;
+ T = F9 - Z;
+ Q = F9 - Y;
+ if ((T - F9 == Zero) && (F9 - U1 - Q == Zero)) {
+ Z = (One + U2) * OneAndHalf;
+ T = (OneAndHalf + U2) - Z + U2;
+ X = One + Half / Radix;
+ Y = One + Radix * U2;
+ Z = X * Y;
+ if (T == Zero && X + Radix * U2 - Z == Zero) {
+ if (Radix != Two) {
+ X = Two + U2;
+ Y = X / Two;
+ if ((Y - One == Zero)) StickyBit = S;
+ }
+ else StickyBit = S;
+ }
+ }
+ }
+ }
+ }
+ }
+ if (StickyBit == One) printf("Sticky bit apparently used correctly.\n");
+ else printf("Sticky bit used incorrectly or not at all.\n");
+ TstCond (Flaw, !(GMult == No || GDiv == No || GAddSub == No ||
+ RMult == Other || RDiv == Other || RAddSub == Other),
+ "lack(s) of guard digits or failure(s) to correctly round or chop\n(noted above) count as one flaw in the final tally below");
+ /*=============================================*/
+ Milestone = 60;
+ /*=============================================*/
+ printf("\n");
+ printf("Does Multiplication commute? ");
+ printf("Testing on %d random pairs.\n", NoTrials);
+ Random9 = SQRT(3.0);
+ Random1 = Third;
+ I = 1;
+ do {
+ X = Random();
+ Y = Random();
+ Z9 = Y * X;
+ Z = X * Y;
+ Z9 = Z - Z9;
+ I = I + 1;
+ } while ( ! ((I > NoTrials) || (Z9 != Zero)));
+ if (I == NoTrials) {
+ Random1 = One + Half / Three;
+ Random2 = (U2 + U1) + One;
+ Z = Random1 * Random2;
+ Y = Random2 * Random1;
+ Z9 = (One + Half / Three) * ((U2 + U1) + One) - (One + Half /
+ Three) * ((U2 + U1) + One);
+ }
+ if (! ((I == NoTrials) || (Z9 == Zero)))
+ BadCond(Defect, "X * Y == Y * X trial fails.\n");
+ else printf(" No failures found in %d integer pairs.\n", NoTrials);
+ /*=============================================*/
+ Milestone = 70;
+ /*=============================================*/
+ printf("\nRunning test of square root(x).\n");
+ TstCond (Failure, (Zero == SQRT(Zero))
+ && (- Zero == SQRT(- Zero))
+ && (One == SQRT(One)), "Square root of 0.0, -0.0 or 1.0 wrong");
+ MinSqEr = Zero;
+ MaxSqEr = Zero;
+ J = Zero;
+ X = Radix;
+ OneUlp = U2;
+ SqXMinX (Serious);
+ X = BInvrse;
+ OneUlp = BInvrse * U1;
+ SqXMinX (Serious);
+ X = U1;
+ OneUlp = U1 * U1;
+ SqXMinX (Serious);
+ if (J != Zero) Pause();
+ printf("Testing if sqrt(X * X) == X for %d Integers X.\n", NoTrials);
+ J = Zero;
+ X = Two;
+ Y = Radix;
+ if ((Radix != One)) do {
+ X = Y;
+ Y = Radix * Y;
+ } while ( ! ((Y - X >= NoTrials)));
+ OneUlp = X * U2;
+ I = 1;
+ while (I <= NoTrials) {
+ X = X + One;
+ SqXMinX (Defect);
+ if (J > Zero) break;
+ I = I + 1;
+ }
+ printf("Test for sqrt monotonicity.\n");
+ I = - 1;
+ X = BMinusU2;
+ Y = Radix;
+ Z = Radix + Radix * U2;
+ NotMonot = False;
+ Monot = False;
+ while ( ! (NotMonot || Monot)) {
+ I = I + 1;
+ X = SQRT(X);
+ Q = SQRT(Y);
+ Z = SQRT(Z);
+ if ((X > Q) || (Q > Z)) NotMonot = True;
+ else {
+ Q = FLOOR(Q + Half);
+ if ((I > 0) || (Radix == Q * Q)) Monot = True;
+ else if (I > 0) {
+ if (I > 1) Monot = True;
+ else {
+ Y = Y * BInvrse;
+ X = Y - U1;
+ Z = Y + U1;
+ }
+ }
+ else {
+ Y = Q;
+ X = Y - U2;
+ Z = Y + U2;
+ }
+ }
+ }
+ if (Monot) printf("sqrt has passed a test for Monotonicity.\n");
+ else {
+ BadCond(Defect, "");
+ printf("sqrt(X) is non-monotonic for X near %.7e .\n", Y);
+ }
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part5(){
+*/
+ Milestone = 80;
+ /*=============================================*/
+ MinSqEr = MinSqEr + Half;
+ MaxSqEr = MaxSqEr - Half;
+ Y = (SQRT(One + U2) - One) / U2;
+ SqEr = (Y - One) + U2 / Eight;
+ if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+ SqEr = Y + U2 / Eight;
+ if (SqEr < MinSqEr) MinSqEr = SqEr;
+ Y = ((SQRT(F9) - U2) - (One - U2)) / U1;
+ SqEr = Y + U1 / Eight;
+ if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+ SqEr = (Y + One) + U1 / Eight;
+ if (SqEr < MinSqEr) MinSqEr = SqEr;
+ OneUlp = U2;
+ X = OneUlp;
+ for( Indx = 1; Indx <= 3; ++Indx) {
+ Y = SQRT((X + U1 + X) + F9);
+ Y = ((Y - U2) - ((One - U2) + X)) / OneUlp;
+ Z = ((U1 - X) + F9) * Half * X * X / OneUlp;
+ SqEr = (Y + Half) + Z;
+ if (SqEr < MinSqEr) MinSqEr = SqEr;
+ SqEr = (Y - Half) + Z;
+ if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+ if (((Indx == 1) || (Indx == 3)))
+ X = OneUlp * Sign (X) * FLOOR(Eight / (Nine * SQRT(OneUlp)));
+ else {
+ OneUlp = U1;
+ X = - OneUlp;
+ }
+ }
+ /*=============================================*/
+ Milestone = 85;
+ /*=============================================*/
+ SqRWrng = False;
+ Anomaly = False;
+ RSqrt = Other; /* ~dgh */
+ if (Radix != One) {
+ printf("Testing whether sqrt is rounded or chopped.\n");
+ D = FLOOR(Half + POW(Radix, One + Precision - FLOOR(Precision)));
+ /* ... == Radix^(1 + fract) if (Precision == Integer + fract. */
+ X = D / Radix;
+ Y = D / A1;
+ if ((X != FLOOR(X)) || (Y != FLOOR(Y))) {
+ Anomaly = True;
+ }
+ else {
+ X = Zero;
+ Z2 = X;
+ Y = One;
+ Y2 = Y;
+ Z1 = Radix - One;
+ FourD = Four * D;
+ do {
+ if (Y2 > Z2) {
+ Q = Radix;
+ Y1 = Y;
+ do {
+ X1 = FABS(Q + FLOOR(Half - Q / Y1) * Y1);
+ Q = Y1;
+ Y1 = X1;
+ } while ( ! (X1 <= Zero));
+ if (Q <= One) {
+ Z2 = Y2;
+ Z = Y;
+ }
+ }
+ Y = Y + Two;
+ X = X + Eight;
+ Y2 = Y2 + X;
+ if (Y2 >= FourD) Y2 = Y2 - FourD;
+ } while ( ! (Y >= D));
+ X8 = FourD - Z2;
+ Q = (X8 + Z * Z) / FourD;
+ X8 = X8 / Eight;
+ if (Q != FLOOR(Q)) Anomaly = True;
+ else {
+ Break = False;
+ do {
+ X = Z1 * Z;
+ X = X - FLOOR(X / Radix) * Radix;
+ if (X == One)
+ Break = True;
+ else
+ Z1 = Z1 - One;
+ } while ( ! (Break || (Z1 <= Zero)));
+ if ((Z1 <= Zero) && (! Break)) Anomaly = True;
+ else {
+ if (Z1 > RadixD2) Z1 = Z1 - Radix;
+ do {
+ NewD();
+ } while ( ! (U2 * D >= F9));
+ if (D * Radix - D != W - D) Anomaly = True;
+ else {
+ Z2 = D;
+ I = 0;
+ Y = D + (One + Z) * Half;
+ X = D + Z + Q;
+ SR3750();
+ Y = D + (One - Z) * Half + D;
+ X = D - Z + D;
+ X = X + Q + X;
+ SR3750();
+ NewD();
+ if (D - Z2 != W - Z2) Anomaly = True;
+ else {
+ Y = (D - Z2) + (Z2 + (One - Z) * Half);
+ X = (D - Z2) + (Z2 - Z + Q);
+ SR3750();
+ Y = (One + Z) * Half;
+ X = Q;
+ SR3750();
+ if (I == 0) Anomaly = True;
+ }
+ }
+ }
+ }
+ }
+ if ((I == 0) || Anomaly) {
+ BadCond(Failure, "Anomalous arithmetic with Integer < ");
+ printf("Radix^Precision = %.7e\n", W);
+ printf(" fails test whether sqrt rounds or chops.\n");
+ SqRWrng = True;
+ }
+ }
+ if (! Anomaly) {
+ if (! ((MinSqEr < Zero) || (MaxSqEr > Zero))) {
+ RSqrt = Rounded;
+ printf("Square root appears to be correctly rounded.\n");
+ }
+ else {
+ if ((MaxSqEr + U2 > U2 - Half) || (MinSqEr > Half)
+ || (MinSqEr + Radix < Half)) SqRWrng = True;
+ else {
+ RSqrt = Chopped;
+ printf("Square root appears to be chopped.\n");
+ }
+ }
+ }
+ if (SqRWrng) {
+ printf("Square root is neither chopped nor correctly rounded.\n");
+ printf("Observed errors run from %.7e ", MinSqEr - Half);
+ printf("to %.7e ulps.\n", Half + MaxSqEr);
+ TstCond (Serious, MaxSqEr - MinSqEr < Radix * Radix,
+ "sqrt gets too many last digits wrong");
+ }
+ /*=============================================*/
+ Milestone = 90;
+ /*=============================================*/
+ Pause();
+ printf("Testing powers Z^i for small Integers Z and i.\n");
+ N = 0;
+ /* ... test powers of zero. */
+ I = 0;
+ Z = -Zero;
+ M = 3.0;
+ Break = False;
+ do {
+ X = One;
+ SR3980();
+ if (I <= 10) {
+ I = 1023;
+ SR3980();
+ }
+ if (Z == MinusOne) Break = True;
+ else {
+ Z = MinusOne;
+ PrintIfNPositive();
+ N = 0;
+ /* .. if(-1)^N is invalid, replace MinusOne by One. */
+ I = - 4;
+ }
+ } while ( ! Break);
+ PrintIfNPositive();
+ N1 = N;
+ N = 0;
+ Z = A1;
+ M = FLOOR(Two * LOG(W) / LOG(A1));
+ Break = False;
+ do {
+ X = Z;
+ I = 1;
+ SR3980();
+ if (Z == AInvrse) Break = True;
+ else Z = AInvrse;
+ } while ( ! (Break));
+ /*=============================================*/
+ Milestone = 100;
+ /*=============================================*/
+ /* Powers of Radix have been tested, */
+ /* next try a few primes */
+ M = NoTrials;
+ Z = Three;
+ do {
+ X = Z;
+ I = 1;
+ SR3980();
+ do {
+ Z = Z + Two;
+ } while ( Three * FLOOR(Z / Three) == Z );
+ } while ( Z < Eight * Three );
+ if (N > 0) {
+ printf("Errors like this may invalidate financial calculations\n");
+ printf("\tinvolving interest rates.\n");
+ }
+ PrintIfNPositive();
+ N += N1;
+ if (N == 0) printf("... no discrepancis found.\n");
+ if (N > 0) Pause();
+ else printf("\n");
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part6(){
+*/
+ Milestone = 110;
+ /*=============================================*/
+ printf("Seeking Underflow thresholds UfThold and E0.\n");
+ D = U1;
+ if (Precision != FLOOR(Precision)) {
+ D = BInvrse;
+ X = Precision;
+ do {
+ D = D * BInvrse;
+ X = X - One;
+ } while ( X > Zero);
+ }
+ Y = One;
+ Z = D;
+ /* ... D is power of 1/Radix < 1. */
+ do {
+ C = Y;
+ Y = Z;
+ Z = Y * Y;
+ } while ((Y > Z) && (Z + Z > Z));
+ Y = C;
+ Z = Y * D;
+ do {
+ C = Y;
+ Y = Z;
+ Z = Y * D;
+ } while ((Y > Z) && (Z + Z > Z));
+ if (Radix < Two) HInvrse = Two;
+ else HInvrse = Radix;
+ H = One / HInvrse;
+ /* ... 1/HInvrse == H == Min(1/Radix, 1/2) */
+ CInvrse = One / C;
+ E0 = C;
+ Z = E0 * H;
+ /* ...1/Radix^(BIG Integer) << 1 << CInvrse == 1/C */
+ do {
+ Y = E0;
+ E0 = Z;
+ Z = E0 * H;
+ } while ((E0 > Z) && (Z + Z > Z));
+ UfThold = E0;
+ E1 = Zero;
+ Q = Zero;
+ E9 = U2;
+ S = One + E9;
+ D = C * S;
+ if (D <= C) {
+ E9 = Radix * U2;
+ S = One + E9;
+ D = C * S;
+ if (D <= C) {
+ BadCond(Failure, "multiplication gets too many last digits wrong.\n");
+ Underflow = E0;
+ Y1 = Zero;
+ PseudoZero = Z;
+ Pause();
+ }
+ }
+ else {
+ Underflow = D;
+ PseudoZero = Underflow * H;
+ UfThold = Zero;
+ do {
+ Y1 = Underflow;
+ Underflow = PseudoZero;
+ if (E1 + E1 <= E1) {
+ Y2 = Underflow * HInvrse;
+ E1 = FABS(Y1 - Y2);
+ Q = Y1;
+ if ((UfThold == Zero) && (Y1 != Y2)) UfThold = Y1;
+ }
+ PseudoZero = PseudoZero * H;
+ } while ((Underflow > PseudoZero)
+ && (PseudoZero + PseudoZero > PseudoZero));
+ }
+ /* Comment line 4530 .. 4560 */
+ if (PseudoZero != Zero) {
+ printf("\n");
+ Z = PseudoZero;
+ /* ... Test PseudoZero for "phoney- zero" violates */
+ /* ... PseudoZero < Underflow or PseudoZero < PseudoZero + PseudoZero
+ ... */
+ if (PseudoZero <= Zero) {
+ BadCond(Failure, "Positive expressions can underflow to an\n");
+ printf("allegedly negative value\n");
+ printf("PseudoZero that prints out as: %g .\n", PseudoZero);
+ X = - PseudoZero;
+ if (X <= Zero) {
+ printf("But -PseudoZero, which should be\n");
+ printf("positive, isn't; it prints out as %g .\n", X);
+ }
+ }
+ else {
+ BadCond(Flaw, "Underflow can stick at an allegedly positive\n");
+ printf("value PseudoZero that prints out as %g .\n", PseudoZero);
+ }
+ TstPtUf();
+ }
+ /*=============================================*/
+ Milestone = 120;
+ /*=============================================*/
+ if (CInvrse * Y > CInvrse * Y1) {
+ S = H * S;
+ E0 = Underflow;
+ }
+ if (! ((E1 == Zero) || (E1 == E0))) {
+ BadCond(Defect, "");
+ if (E1 < E0) {
+ printf("Products underflow at a higher");
+ printf(" threshold than differences.\n");
+ if (PseudoZero == Zero)
+ E0 = E1;
+ }
+ else {
+ printf("Difference underflows at a higher");
+ printf(" threshold than products.\n");
+ }
+ }
+ printf("Smallest strictly positive number found is E0 = %g .\n", E0);
+ Z = E0;
+ TstPtUf();
+ Underflow = E0;
+ if (N == 1) Underflow = Y;
+ I = 4;
+ if (E1 == Zero) I = 3;
+ if (UfThold == Zero) I = I - 2;
+ UfNGrad = True;
+ switch (I) {
+ case 1:
+ UfThold = Underflow;
+ if ((CInvrse * Q) != ((CInvrse * Y) * S)) {
+ UfThold = Y;
+ BadCond(Failure, "Either accuracy deteriorates as numbers\n");
+ printf("approach a threshold = %.17e\n", UfThold);;
+ printf(" coming down from %.17e\n", C);
+ printf(" or else multiplication gets too many last digits wrong.\n");
+ }
+ Pause();
+ break;
+
+ case 2:
+ BadCond(Failure, "Underflow confuses Comparison, which alleges that\n");
+ printf("Q == Y while denying that |Q - Y| == 0; these values\n");
+ printf("print out as Q = %.17e, Y = %.17e .\n", Q, Y2);
+ printf ("|Q - Y| = %.17e .\n" , FABS(Q - Y2));
+ UfThold = Q;
+ break;
+
+ case 3:
+ X = X;
+ break;
+
+ case 4:
+ if ((Q == UfThold) && (E1 == E0)
+ && (FABS( UfThold - E1 / E9) <= E1)) {
+ UfNGrad = False;
+ printf("Underflow is gradual; it incurs Absolute Error =\n");
+ printf("(roundoff in UfThold) < E0.\n");
+ Y = E0 * CInvrse;
+ Y = Y * (OneAndHalf + U2);
+ X = CInvrse * (One + U2);
+ Y = Y / X;
+ IEEE = (Y == E0);
+ }
+ }
+ if (UfNGrad) {
+ printf("\n");
+ sigsave = sigfpe;
+ if (setjmp(ovfl_buf)) {
+ printf("Underflow / UfThold failed!\n");
+ R = H + H;
+ }
+ else R = SQRT(Underflow / UfThold);
+ sigsave = 0;
+ if (R <= H) {
+ Z = R * UfThold;
+ X = Z * (One + R * H * (One + H));
+ }
+ else {
+ Z = UfThold;
+ X = Z * (One + H * H * (One + H));
+ }
+ if (! ((X == Z) || (X - Z != Zero))) {
+ BadCond(Flaw, "");
+ printf("X = %.17e\n\tis not equal to Z = %.17e .\n", X, Z);
+ Z9 = X - Z;
+ printf("yet X - Z yields %.17e .\n", Z9);
+ printf(" Should this NOT signal Underflow, ");
+ printf("this is a SERIOUS DEFECT\nthat causes ");
+ printf("confusion when innocent statements like\n");;
+ printf(" if (X == Z) ... else");
+ printf(" ... (f(X) - f(Z)) / (X - Z) ...\n");
+ printf("encounter Division by Zero although actually\n");
+ sigsave = sigfpe;
+ if (setjmp(ovfl_buf)) printf("X / Z fails!\n");
+ else printf("X / Z = 1 + %g .\n", (X / Z - Half) - Half);
+ sigsave = 0;
+ }
+ }
+ printf("The Underflow threshold is %.17e, %s\n", UfThold,
+ " below which");
+ printf("calculation may suffer larger Relative error than ");
+ printf("merely roundoff.\n");
+ Y2 = U1 * U1;
+ Y = Y2 * Y2;
+ Y2 = Y * U1;
+ if (Y2 <= UfThold) {
+ if (Y > E0) {
+ BadCond(Defect, "");
+ I = 5;
+ }
+ else {
+ BadCond(Serious, "");
+ I = 4;
+ }
+ printf("Range is too narrow; U1^%d Underflows.\n", I);
+ }
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part7(){
+*/
+ Milestone = 130;
+ /*=============================================*/
+ Y = - FLOOR(Half - TwoForty * LOG(UfThold) / LOG(HInvrse)) / TwoForty;
+ Y2 = Y + Y;
+ printf("Since underflow occurs below the threshold\n");
+ printf("UfThold = (%.17e) ^ (%.17e)\nonly underflow ", HInvrse, Y);
+ printf("should afflict the expression\n\t(%.17e) ^ (%.17e);\n", HInvrse, Y);
+ V9 = POW(HInvrse, Y2);
+ printf("actually calculating yields: %.17e .\n", V9);
+ if (! ((V9 >= Zero) && (V9 <= (Radix + Radix + E9) * UfThold))) {
+ BadCond(Serious, "this is not between 0 and underflow\n");
+ printf(" threshold = %.17e .\n", UfThold);
+ }
+ else if (! (V9 > UfThold * (One + E9)))
+ printf("This computed value is O.K.\n");
+ else {
+ BadCond(Defect, "this is not between 0 and underflow\n");
+ printf(" threshold = %.17e .\n", UfThold);
+ }
+ /*=============================================*/
+ Milestone = 140;
+ /*=============================================*/
+ printf("\n");
+ /* ...calculate Exp2 == exp(2) == 7.389056099... */
+ X = Zero;
+ I = 2;
+ Y = Two * Three;
+ Q = Zero;
+ N = 0;
+ do {
+ Z = X;
+ I = I + 1;
+ Y = Y / (I + I);
+ R = Y + Q;
+ X = Z + R;
+ Q = (Z - X) + R;
+ } while(X > Z);
+ Z = (OneAndHalf + One / Eight) + X / (OneAndHalf * ThirtyTwo);
+ X = Z * Z;
+ Exp2 = X * X;
+ X = F9;
+ Y = X - U1;
+ printf("Testing X^((X + 1) / (X - 1)) vs. exp(2) = %.17e as X -> 1.\n",
+ Exp2);
+ for(I = 1;;) {
+ Z = X - BInvrse;
+ Z = (X + One) / (Z - (One - BInvrse));
+ Q = POW(X, Z) - Exp2;
+ if (FABS(Q) > TwoForty * U2) {
+ N = 1;
+ V9 = (X - BInvrse) - (One - BInvrse);
+ BadCond(Defect, "Calculated");
+ printf(" %.17e for\n", POW(X,Z));
+ printf("\t(1 + (%.17e) ^ (%.17e);\n", V9, Z);
+ printf("\tdiffers from correct value by %.17e .\n", Q);
+ printf("\tThis much error may spoil financial\n");
+ printf("\tcalculations involving tiny interest rates.\n");
+ break;
+ }
+ else {
+ Z = (Y - X) * Two + Y;
+ X = Y;
+ Y = Z;
+ Z = One + (X - F9)*(X - F9);
+ if (Z > One && I < NoTrials) I++;
+ else {
+ if (X > One) {
+ if (N == 0)
+ printf("Accuracy seems adequate.\n");
+ break;
+ }
+ else {
+ X = One + U2;
+ Y = U2 + U2;
+ Y += X;
+ I = 1;
+ }
+ }
+ }
+ }
+ /*=============================================*/
+ Milestone = 150;
+ /*=============================================*/
+ printf("Testing powers Z^Q at four nearly extreme values.\n");
+ N = 0;
+ Z = A1;
+ Q = FLOOR(Half - LOG(C) / LOG(A1));
+ Break = False;
+ do {
+ X = CInvrse;
+ Y = POW(Z, Q);
+ IsYeqX();
+ Q = - Q;
+ X = C;
+ Y = POW(Z, Q);
+ IsYeqX();
+ if (Z < One) Break = True;
+ else Z = AInvrse;
+ } while ( ! (Break));
+ PrintIfNPositive();
+ if (N == 0) printf(" ... no discrepancies found.\n");
+ printf("\n");
+
+ /*=============================================*/
+ Milestone = 160;
+ /*=============================================*/
+ Pause();
+ printf("Searching for Overflow threshold:\n");
+ printf("This may generate an error.\n");
+ Y = - CInvrse;
+ V9 = HInvrse * Y;
+ sigsave = sigfpe;
+ if (setjmp(ovfl_buf)) { I = 0; V9 = Y; goto overflow; }
+ do {
+ V = Y;
+ Y = V9;
+ V9 = HInvrse * Y;
+ } while(V9 < Y);
+ I = 1;
+overflow:
+ sigsave = 0;
+ Z = V9;
+ printf("Can `Z = -Y' overflow?\n");
+ printf("Trying it on Y = %.17e .\n", Y);
+ V9 = - Y;
+ V0 = V9;
+ if (V - Y == V + V0) printf("Seems O.K.\n");
+ else {
+ printf("finds a ");
+ BadCond(Flaw, "-(-Y) differs from Y.\n");
+ }
+ if (Z != Y) {
+ BadCond(Serious, "");
+ printf("overflow past %.17e\n\tshrinks to %.17e .\n", Y, Z);
+ }
+ if (I) {
+ Y = V * (HInvrse * U2 - HInvrse);
+ Z = Y + ((One - HInvrse) * U2) * V;
+ if (Z < V0) Y = Z;
+ if (Y < V0) V = Y;
+ if (V0 - V < V0) V = V0;
+ }
+ else {
+ V = Y * (HInvrse * U2 - HInvrse);
+ V = V + ((One - HInvrse) * U2) * Y;
+ }
+ printf("Overflow threshold is V = %.17e .\n", V);
+ if (I) printf("Overflow saturates at V0 = %.17e .\n", V0);
+ else printf("There is no saturation value because the system traps on overflow.\n");
+ V9 = V * One;
+ printf("No Overflow should be signaled for V * 1 = %.17e\n", V9);
+ V9 = V / One;
+ printf(" nor for V / 1 = %.17e .\n", V9);
+ printf("Any overflow signal separating this * from the one\n");
+ printf("above is a DEFECT.\n");
+ /*=============================================*/
+ Milestone = 170;
+ /*=============================================*/
+ if (!(-V < V && -V0 < V0 && -UfThold < V && UfThold < V)) {
+ BadCond(Failure, "Comparisons involving ");
+ printf("+-%g, +-%g\nand +-%g are confused by Overflow.",
+ V, V0, UfThold);
+ }
+ /*=============================================*/
+ Milestone = 175;
+ /*=============================================*/
+ printf("\n");
+ for(Indx = 1; Indx <= 3; ++Indx) {
+ switch (Indx) {
+ case 1: Z = UfThold; break;
+ case 2: Z = E0; break;
+ case 3: Z = PseudoZero; break;
+ }
+ if (Z != Zero) {
+ V9 = SQRT(Z);
+ Y = V9 * V9;
+ if (Y / (One - Radix * E9) < Z
+ || Y > (One + Radix * E9) * Z) { /* dgh: + E9 --> * E9 */
+ if (V9 > U1) BadCond(Serious, "");
+ else BadCond(Defect, "");
+ printf("Comparison alleges that what prints as Z = %.17e\n", Z);
+ printf(" is too far from sqrt(Z) ^ 2 = %.17e .\n", Y);
+ }
+ }
+ }
+ /*=============================================*/
+ Milestone = 180;
+ /*=============================================*/
+ for(Indx = 1; Indx <= 2; ++Indx) {
+ if (Indx == 1) Z = V;
+ else Z = V0;
+ V9 = SQRT(Z);
+ X = (One - Radix * E9) * V9;
+ V9 = V9 * X;
+ if (((V9 < (One - Two * Radix * E9) * Z) || (V9 > Z))) {
+ Y = V9;
+ if (X < W) BadCond(Serious, "");
+ else BadCond(Defect, "");
+ printf("Comparison alleges that Z = %17e\n", Z);
+ printf(" is too far from sqrt(Z) ^ 2 (%.17e) .\n", Y);
+ }
+ }
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part8(){
+*/
+ Milestone = 190;
+ /*=============================================*/
+ Pause();
+ X = UfThold * V;
+ Y = Radix * Radix;
+ if (X*Y < One || X > Y) {
+ if (X * Y < U1 || X > Y/U1) BadCond(Defect, "Badly");
+ else BadCond(Flaw, "");
+
+ printf(" unbalanced range; UfThold * V = %.17e\n\t%s\n",
+ X, "is too far from 1.\n");
+ }
+ /*=============================================*/
+ Milestone = 200;
+ /*=============================================*/
+ for (Indx = 1; Indx <= 5; ++Indx) {
+ X = F9;
+ switch (Indx) {
+ case 2: X = One + U2; break;
+ case 3: X = V; break;
+ case 4: X = UfThold; break;
+ case 5: X = Radix;
+ }
+ Y = X;
+ sigsave = sigfpe;
+ if (setjmp(ovfl_buf))
+ printf(" X / X traps when X = %g\n", X);
+ else {
+ V9 = (Y / X - Half) - Half;
+ if (V9 == Zero) continue;
+ if (V9 == - U1 && Indx < 5) BadCond(Flaw, "");
+ else BadCond(Serious, "");
+ printf(" X / X differs from 1 when X = %.17e\n", X);
+ printf(" instead, X / X - 1/2 - 1/2 = %.17e .\n", V9);
+ }
+ sigsave = 0;
+ }
+ /*=============================================*/
+ Milestone = 210;
+ /*=============================================*/
+ MyZero = Zero;
+ printf("\n");
+ printf("What message and/or values does Division by Zero produce?\n") ;
+#ifndef NOPAUSE
+ printf("This can interupt your program. You can ");
+ printf("skip this part if you wish.\n");
+ printf("Do you wish to compute 1 / 0? ");
+ fflush(stdout);
+ read (KEYBOARD, ch, 8);
+ if ((ch[0] == 'Y') || (ch[0] == 'y')) {
+#endif
+ sigsave = sigfpe;
+ printf(" Trying to compute 1 / 0 produces ...");
+ if (!setjmp(ovfl_buf)) printf(" %.7e .\n", One / MyZero);
+ sigsave = 0;
+#ifndef NOPAUSE
+ }
+ else printf("O.K.\n");
+ printf("\nDo you wish to compute 0 / 0? ");
+ fflush(stdout);
+ read (KEYBOARD, ch, 80);
+ if ((ch[0] == 'Y') || (ch[0] == 'y')) {
+#endif
+ sigsave = sigfpe;
+ printf("\n Trying to compute 0 / 0 produces ...");
+ if (!setjmp(ovfl_buf)) printf(" %.7e .\n", Zero / MyZero);
+ sigsave = 0;
+#ifndef NOPAUSE
+ }
+ else printf("O.K.\n");
+#endif
+ /*=============================================*/
+ Milestone = 220;
+ /*=============================================*/
+ Pause();
+ printf("\n");
+ {
+ static char *msg[] = {
+ "FAILUREs encountered =",
+ "SERIOUS DEFECTs discovered =",
+ "DEFECTs discovered =",
+ "FLAWs discovered =" };
+ int i;
+ for(i = 0; i < 4; i++) if (ErrCnt[i])
+ printf("The number of %-29s %d.\n",
+ msg[i], ErrCnt[i]);
+ }
+ printf("\n");
+ if ((ErrCnt[Failure] + ErrCnt[Serious] + ErrCnt[Defect]
+ + ErrCnt[Flaw]) > 0) {
+ if ((ErrCnt[Failure] + ErrCnt[Serious] + ErrCnt[
+ Defect] == 0) && (ErrCnt[Flaw] > 0)) {
+ printf("The arithmetic diagnosed seems ");
+ printf("Satisfactory though flawed.\n");
+ }
+ if ((ErrCnt[Failure] + ErrCnt[Serious] == 0)
+ && ( ErrCnt[Defect] > 0)) {
+ printf("The arithmetic diagnosed may be Acceptable\n");
+ printf("despite inconvenient Defects.\n");
+ }
+ if ((ErrCnt[Failure] + ErrCnt[Serious]) > 0) {
+ printf("The arithmetic diagnosed has ");
+ printf("unacceptable Serious Defects.\n");
+ }
+ if (ErrCnt[Failure] > 0) {
+ printf("Potentially fatal FAILURE may have spoiled this");
+ printf(" program's subsequent diagnoses.\n");
+ }
+ }
+ else {
+ printf("No failures, defects nor flaws have been discovered.\n");
+ if (! ((RMult == Rounded) && (RDiv == Rounded)
+ && (RAddSub == Rounded) && (RSqrt == Rounded)))
+ printf("The arithmetic diagnosed seems Satisfactory.\n");
+ else {
+ if (StickyBit >= One &&
+ (Radix - Two) * (Radix - Nine - One) == Zero) {
+ printf("Rounding appears to conform to ");
+ printf("the proposed IEEE standard P");
+ if ((Radix == Two) &&
+ ((Precision - Four * Three * Two) *
+ ( Precision - TwentySeven -
+ TwentySeven + One) == Zero))
+ printf("754");
+ else printf("854");
+ if (IEEE) printf(".\n");
+ else {
+ printf(",\nexcept for possibly Double Rounding");
+ printf(" during Gradual Underflow.\n");
+ }
+ }
+ printf("The arithmetic diagnosed appears to be Excellent!\n");
+ }
+ }
+ if (fpecount)
+ printf("\nA total of %d floating point exceptions were registered.\n",
+ fpecount);
+ printf("END OF TEST.\n");
+ return 0;
+ }
+
+/*SPLIT subs.c
+#include "paranoia.h"
+*/
+
+/* Sign */
+
+FLOAT Sign (X)
+FLOAT X;
+{ return X >= 0. ? 1.0 : -1.0; }
+
+/* Pause */
+
+Pause()
+{
+#ifndef NOPAUSE
+ char ch[8];
+
+ printf("\nTo continue, press RETURN");
+ fflush(stdout);
+ read(KEYBOARD, ch, 8);
+#endif
+ printf("\nDiagnosis resumes after milestone Number %d", Milestone);
+ printf(" Page: %d\n\n", PageNo);
+ ++Milestone;
+ ++PageNo;
+ }
+
+ /* TstCond */
+
+TstCond (K, Valid, T)
+int K, Valid;
+char *T;
+{ if (! Valid) { BadCond(K,T); printf(".\n"); } }
+
+BadCond(K, T)
+int K;
+char *T;
+{
+ static char *msg[] = { "FAILURE", "SERIOUS DEFECT", "DEFECT", "FLAW" };
+
+ ErrCnt [K] = ErrCnt [K] + 1;
+ printf("%s: %s", msg[K], T);
+ }
+
+/* Random */
+/* Random computes
+ X = (Random1 + Random9)^5
+ Random1 = X - FLOOR(X) + 0.000005 * X;
+ and returns the new value of Random1
+*/
+
+FLOAT Random()
+{
+ FLOAT X, Y;
+
+ X = Random1 + Random9;
+ Y = X * X;
+ Y = Y * Y;
+ X = X * Y;
+ Y = X - FLOOR(X);
+ Random1 = Y + X * 0.000005;
+ return(Random1);
+ }
+
+/* SqXMinX */
+
+SqXMinX (ErrKind)
+int ErrKind;
+{
+ FLOAT XA, XB;
+
+ XB = X * BInvrse;
+ XA = X - XB;
+ SqEr = ((SQRT(X * X) - XB) - XA) / OneUlp;
+ if (SqEr != Zero) {
+ if (SqEr < MinSqEr) MinSqEr = SqEr;
+ if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+ J = J + 1.0;
+ BadCond(ErrKind, "\n");
+ printf("sqrt( %.17e) - %.17e = %.17e\n", X * X, X, OneUlp * SqEr);
+ printf("\tinstead of correct value 0 .\n");
+ }
+ }
+
+/* NewD */
+
+NewD()
+{
+ X = Z1 * Q;
+ X = FLOOR(Half - X / Radix) * Radix + X;
+ Q = (Q - X * Z) / Radix + X * X * (D / Radix);
+ Z = Z - Two * X * D;
+ if (Z <= Zero) {
+ Z = - Z;
+ Z1 = - Z1;
+ }
+ D = Radix * D;
+ }
+
+/* SR3750 */
+
+SR3750()
+{
+ if (! ((X - Radix < Z2 - Radix) || (X - Z2 > W - Z2))) {
+ I = I + 1;
+ X2 = SQRT(X * D);
+ Y2 = (X2 - Z2) - (Y - Z2);
+ X2 = X8 / (Y - Half);
+ X2 = X2 - Half * X2 * X2;
+ SqEr = (Y2 + Half) + (Half - X2);
+ if (SqEr < MinSqEr) MinSqEr = SqEr;
+ SqEr = Y2 - X2;
+ if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+ }
+ }
+
+/* IsYeqX */
+
+IsYeqX()
+{
+ if (Y != X) {
+ if (N <= 0) {
+ if (Z == Zero && Q <= Zero)
+ printf("WARNING: computing\n");
+ else BadCond(Defect, "computing\n");
+ printf("\t(%.17e) ^ (%.17e)\n", Z, Q);
+ printf("\tyielded %.17e;\n", Y);
+ printf("\twhich compared unequal to correct %.17e ;\n",
+ X);
+ printf("\t\tthey differ by %.17e .\n", Y - X);
+ }
+ N = N + 1; /* ... count discrepancies. */
+ }
+ }
+
+/* SR3980 */
+
+SR3980()
+{
+ do {
+ Q = (FLOAT) I;
+ Y = POW(Z, Q);
+ IsYeqX();
+ if (++I > M) break;
+ X = Z * X;
+ } while ( X < W );
+ }
+
+/* PrintIfNPositive */
+
+PrintIfNPositive()
+{
+ if (N > 0) printf("Similar discrepancies have occurred %d times.\n", N);
+ }
+
+/* TstPtUf */
+
+TstPtUf()
+{
+ N = 0;
+ if (Z != Zero) {
+ printf("Since comparison denies Z = 0, evaluating ");
+ printf("(Z + Z) / Z should be safe.\n");
+ sigsave = sigfpe;
+ if (setjmp(ovfl_buf)) goto very_serious;
+ Q9 = (Z + Z) / Z;
+ printf("What the machine gets for (Z + Z) / Z is %.17e .\n",
+ Q9);
+ if (FABS(Q9 - Two) < Radix * U2) {
+ printf("This is O.K., provided Over/Underflow");
+ printf(" has NOT just been signaled.\n");
+ }
+ else {
+ if ((Q9 < One) || (Q9 > Two)) {
+very_serious:
+ N = 1;
+ ErrCnt [Serious] = ErrCnt [Serious] + 1;
+ printf("This is a VERY SERIOUS DEFECT!\n");
+ }
+ else {
+ N = 1;
+ ErrCnt [Defect] = ErrCnt [Defect] + 1;
+ printf("This is a DEFECT!\n");
+ }
+ }
+ sigsave = 0;
+ V9 = Z * One;
+ Random1 = V9;
+ V9 = One * Z;
+ Random2 = V9;
+ V9 = Z / One;
+ if ((Z == Random1) && (Z == Random2) && (Z == V9)) {
+ if (N > 0) Pause();
+ }
+ else {
+ N = 1;
+ BadCond(Defect, "What prints as Z = ");
+ printf("%.17e\n\tcompares different from ", Z);
+ if (Z != Random1) printf("Z * 1 = %.17e ", Random1);
+ if (! ((Z == Random2)
+ || (Random2 == Random1)))
+ printf("1 * Z == %g\n", Random2);
+ if (! (Z == V9)) printf("Z / 1 = %.17e\n", V9);
+ if (Random2 != Random1) {
+ ErrCnt [Defect] = ErrCnt [Defect] + 1;
+ BadCond(Defect, "Multiplication does not commute!\n");
+ printf("\tComparison alleges that 1 * Z = %.17e\n",
+ Random2);
+ printf("\tdiffers from Z * 1 = %.17e\n", Random1);
+ }
+ Pause();
+ }
+ }
+ }
+
+notify(s)
+char *s;
+{
+ printf("%s test appears to be inconsistent...\n", s);
+ printf(" PLEASE NOTIFY KARPINKSI!\n");
+ }
+
+/*SPLIT msgs.c */
+
+/* Instructions */
+
+msglist(s)
+char **s;
+{ while(*s) printf("%s\n", *s++); }
+
+Instructions()
+{
+ static char *instr[] = {
+ "Lest this program stop prematurely, i.e. before displaying\n",
+ " `END OF TEST',\n",
+ "try to persuade the computer NOT to terminate execution when an",
+ "error like Over/Underflow or Division by Zero occurs, but rather",
+ "to persevere with a surrogate value after, perhaps, displaying some",
+ "warning. If persuasion avails naught, don't despair but run this",
+ "program anyway to see how many milestones it passes, and then",
+ "amend it to make further progress.\n",
+ "Answer questions with Y, y, N or n (unless otherwise indicated).\n",
+ 0};
+
+ msglist(instr);
+ }
+
+/* Heading */
+
+Heading()
+{
+ static char *head[] = {
+ "Users are invited to help debug and augment this program so it will",
+ "cope with unanticipated and newly uncovered arithmetic pathologies.\n",
+ "Please send suggestions and interesting results to",
+ "\tRichard Karpinski",
+ "\tComputer Center U-76",
+ "\tUniversity of California",
+ "\tSan Francisco, CA 94143-0704, USA\n",
+ "In doing so, please include the following information:",
+#ifdef Single
+ "\tPrecision:\tsingle;",
+#else
+ "\tPrecision:\tdouble;",
+#endif
+ "\tVersion:\t10 February 1989;",
+ "\tComputer:\n",
+ "\tCompiler:\n",
+ "\tOptimization level:\n",
+ "\tOther relevant compiler options:",
+ 0};
+
+ msglist(head);
+ }
+
+/* Characteristics */
+
+Characteristics()
+{
+ static char *chars[] = {
+ "Running this program should reveal these characteristics:",
+ " Radix = 1, 2, 4, 8, 10, 16, 100, 256 ...",
+ " Precision = number of significant digits carried.",
+ " U2 = Radix/Radix^Precision = One Ulp",
+ "\t(OneUlpnit in the Last Place) of 1.000xxx .",
+ " U1 = 1/Radix^Precision = One Ulp of numbers a little less than 1.0 .",
+ " Adequacy of guard digits for Mult., Div. and Subt.",
+ " Whether arithmetic is chopped, correctly rounded, or something else",
+ "\tfor Mult., Div., Add/Subt. and Sqrt.",
+ " Whether a Sticky Bit used correctly for rounding.",
+ " UnderflowThreshold = an underflow threshold.",
+ " E0 and PseudoZero tell whether underflow is abrupt, gradual, or fuzzy.",
+ " V = an overflow threshold, roughly.",
+ " V0 tells, roughly, whether Infinity is represented.",
+ " Comparisions are checked for consistency with subtraction",
+ "\tand for contamination with pseudo-zeros.",
+ " Sqrt is tested. Y^X is not tested.",
+ " Extra-precise subexpressions are revealed but NOT YET tested.",
+ " Decimal-Binary conversion is NOT YET tested for accuracy.",
+ 0};
+
+ msglist(chars);
+ }
+
+History()
+
+{ /* History */
+ /* Converted from Brian Wichmann's Pascal version to C by Thos Sumner,
+ with further massaging by David M. Gay. */
+
+ static char *hist[] = {
+ "The program attempts to discriminate among",
+ " FLAWs, like lack of a sticky bit,",
+ " Serious DEFECTs, like lack of a guard digit, and",
+ " FAILUREs, like 2+2 == 5 .",
+ "Failures may confound subsequent diagnoses.\n",
+ "The diagnostic capabilities of this program go beyond an earlier",
+ "program called `MACHAR', which can be found at the end of the",
+ "book `Software Manual for the Elementary Functions' (1980) by",
+ "W. J. Cody and W. Waite. Although both programs try to discover",
+ "the Radix, Precision and range (over/underflow thresholds)",
+ "of the arithmetic, this program tries to cope with a wider variety",
+ "of pathologies, and to say how well the arithmetic is implemented.",
+ "\nThe program is based upon a conventional radix representation for",
+ "floating-point numbers, but also allows logarithmic encoding",
+ "as used by certain early WANG machines.\n",
+ "BASIC version of this program (C) 1983 by Prof. W. M. Kahan;",
+ "see source comments for more history.",
+ 0};
+
+ msglist(hist);
+ }
+
+double
+pow(x, y) /* return x ^ y (exponentiation) */
+double x, y;
+{
+ extern double exp(), frexp(), ldexp(), log(), modf();
+ double xy, ye;
+ long i;
+ int ex, ey = 0, flip = 0;
+
+ if (!y) return 1.0;
+
+ if ((y < -1100. || y > 1100.) && x != -1.) return exp(y * log(x));
+
+ if (y < 0.) { y = -y; flip = 1; }
+ y = modf(y, &ye);
+ if (y) xy = exp(y * log(x));
+ else xy = 1.0;
+ /* next several lines assume >= 32 bit integers */
+ x = frexp(x, &ex);
+ if (i = ye) for(;;) {
+ if (i & 1) { xy *= x; ey += ex; }
+ if (!(i >>= 1)) break;
+ x *= x;
+ ex *= 2;
+ if (x < .5) { x *= 2.; ex -= 1; }
+ }
+ if (flip) { xy = 1. / xy; ey = -ey; }
+ return ldexp(xy, ey);
+}
+
+#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 <stdio.h>
+
+/*
+ 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 <stdio.h>
+#include <stdlib.h>
+
+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 <stdlib.h>
+#include <stdio.h>
+
+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 <stdio.h>
+
+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 <stdarg.h>
+
+#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 <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+
+#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 <limits.h>
+
+#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 <stdio.h>
+
+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 <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+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 <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#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 <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+/*
+#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 <void>\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 <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#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 <stdio.h>
+#include <limits.h>
+
+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 0000000000000000000000000000000000000000..bc6b2f50511213499261fc384d39aeb940fc73b6
GIT binary patch
literal 6483
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
U@IHeE49x1=C+gOrUc7+(2Rm>XtN;K2
literal 0
HcmV?d00001
diff --git a/test/val/add1.prg b/test/val/add1.prg
new file mode 100644
index 0000000000000000000000000000000000000000..c0bdb01a211531e1ab95a8bb62320f5c6600ee25
GIT binary patch
literal 3113
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
literal 0
HcmV?d00001
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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+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 <stdint.h>
+
+#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 0000000000000000000000000000000000000000..53a40880f534f9a6ae7b9f30a714459ca72b527d
GIT binary patch
literal 22855
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
literal 0
HcmV?d00001
diff --git a/test/val/add3.prg b/test/val/add3.prg
new file mode 100644
index 0000000000000000000000000000000000000000..9ababe609fca2db3e52db3be1ae1696931b5b6a8
GIT binary patch
literal 5022
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
KAY|tnj_^N^XFyv3
literal 0
HcmV?d00001
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 <stdio.h>
+#include <limits.h>
+
+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 0000000000000000000000000000000000000000..cc6c6aa521e07b617db2c4b9f4bb55426254cc2a
GIT binary patch
literal 5552
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
literal 0
HcmV?d00001
diff --git a/test/val/add4.prg b/test/val/add4.prg
new file mode 100644
index 0000000000000000000000000000000000000000..b00f313293bf5322b34fa6052ab7098fb35db783
GIT binary patch
literal 3019
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
literal 0
HcmV?d00001
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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <assert.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+/*
+ 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 <stdio.h>
+#include <limits.h>
+
+/* 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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+/*
+ 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 <stdio.h>
+#include <limits.h>
+
+/*
+ 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 <stdio.h>
+#include <limits.h>
+
+/*
+ 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 <stdio.h>
+#include <limits.h>
+
+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<LIT)
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/* 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 <stdio.h>
+#include <limits.h>
+
+/* 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 <stdio.h>
+#include <limits.h>
+
+/*
+ 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<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq241.c b/test/val/cq241.c
new file mode 100644
index 000000000..d7d8ed952
--- /dev/null
+++ b/test/val/cq241.c
@@ -0,0 +1,286 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 2.41: integer constants, 2.42: explizit long constants
+ !!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.4.1 Integer constants
+ 2.4.2 Explicit long constants
+*/
+
+/* Calculate 2**n by multiplying, not shifting */
+#ifndef NO_OLD_FUNC_DECL
+long pow2(n)
+long n;
+{
+#else
+long pow2(long n) {
+#endif
+ long s;
+ s = 1;
+ while(n--) s = s*2;
+ return s;
+}
+
+ long d[39], o[39], x[39];
+
+#ifndef NO_OLD_FUNC_DECL
+s241(pd0)
+struct defs *pd0;
+{
+#else
+int s241(struct defs *pd0) {
+#endif
+
+/* long pow2(); */
+ static char s241er[] = "s241,er%d\n";
+ static char qs241[8] = "s241 ";
+ char *ps, *pt;
+ int rc, j, lrc;
+ static long g[39] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,6,0,8,0,12,0,16,0,18,0,20,0,24,
+ 0,28,0,30,0,32,0,36};
+/* long d[39], o[39], x[39]; */
+
+ rc = 0;
+ lrc = 0;
+ ps = qs241;
+ pt = pd0 -> rfs;
+ while (*pt++ = *ps++);
+
+ /* An integer constant consisting of a sequence of digits is
+ taken to be octal if it begins with 0 (digit zero), decimal
+ otherwise. */
+
+ if ( 8 != 010
+ || 16 != 020
+ || 24 != 030
+ || 32 != 040
+ || 40 != 050
+ || 48 != 060
+ || 56 != 070
+ || 64 != 0100
+ || 72 != 0110
+ || 80 != 0120
+ || 9 != 0011
+ || 17 != 0021
+ || 25 != 0031
+ || 33 != 0041
+ || 41 != 0051
+ || 49 != 0061
+ || 57 != 0071
+ || 65 != 0101
+ || 73 != 0111
+ || 81 != 0121 ){
+ rc = rc+1;
+ if( pd0->flgd != 0 ) printf(s241er,1);
+ }
+
+ /* A sequence of digits preceded by 0x or 0X (digit zero)
+ is taken to be a hexadecimal integer. The hexadecimal
+ digits include a or A through f or F with values 10
+ through 15. */
+
+ if ( 0x00abcdef != 0xabcdef
+ || 0xabcdef != 0Xabcdef || 0Xabcdef != 0XAbcdef
+ || 0XAbcdef != 0XABcdef || 0XABcdef != 0XABCdef
+ || 0XABCdef != 0XABCDef || 0XABCDef != 0XABCDEf
+ || 0XABCDEf != 0XABCDEF || 0xABCDEF != 11259375 ){
+ rc = rc+2;
+ if( pd0->flgd != 0 ) printf(s241er,2);
+ }
+
+ /* A decimal constant whose value exceeds the largest signed
+ machine integer is taken to be long; an octal or hex con-
+ stant which exceeds the largest unsigned machine integer
+ is likewise taken to be long. */
+#if 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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq243.c b/test/val/cq243.c
new file mode 100644
index 000000000..03b08b4d2
--- /dev/null
+++ b/test/val/cq243.c
@@ -0,0 +1,264 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 2.43: character constants
+ !!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.4.3 Character constants
+**********************************************************************************************/
+
+#ifndef NO_OLD_FUNC_DECL
+zerofill(x)
+char *x;
+{
+#else
+void zerofill(char *x) {
+#endif
+ int j;
+
+ for (j=0; j<256; j++) *x++ = 0;
+}
+
+#ifndef NO_OLD_FUNC_DECL
+sumof(x)
+char *x;
+{
+#else
+int sumof(char *x) {
+#endif
+ char *p;
+ int total, j;
+
+ p = x;
+ total = 0;
+
+ for(j=0; j<256; j++) total = total+ *p++;
+ return total;
+}
+
+char chars[256];
+
+#ifndef NO_OLD_FUNC_DECL
+s243(pd0)
+struct defs *pd0;
+{
+#else
+int s243(struct defs *pd0) {
+#endif
+ static char s243er[] = "s243,er%d\n";
+ static char qs243[8] = "s243 ";
+ char *ps, *pt;
+ int rc;
+/* char chars[256]; */
+
+ rc = 0;
+ ps = qs243;
+ pt = pd0->rfs;
+ while(*pt++ = *ps++);
+
+ /* One of the problems that arises when testing character constants
+ is that of definition: What, exactly, is the character set?
+ In order to guarantee a certain amount of machine independence,
+ the character set we will use here is the set of characters writ-
+ able as escape sequences in C, plus those characters used in writ-
+ ing C programs, i.e.,
+
+ letters:
+ ABCDEFGHIJKLMNOPQRSTUVWXYZ 26
+ abcdefghijklmnopqrstuvwxyz 26
+ numbers:
+ 0123456789 10
+ special characters:
+ ~!"#%&()_=-^|{}[]+;*:<>,.?/ 27
+ extra special characters:
+ newline \n
+ horizontal tab \t
+ backspace \b
+ carriage return \r
+ form feed \f
+ backslash \\
+ single quote \' 7
+ blank & NUL 2
+ ---
+ 98
+
+ Any specific implementation of C may of course support additional
+ characters. */
+
+ /* Since the value of a character constant is the numerical value
+ of the character in the machine's character set, there should
+ be a one-to-one correspondence between characters and values. */
+
+ zerofill(chars);
+
+ chars['a'] = 1; chars['A'] = 1; chars['~'] = 1; chars['0'] = 1;
+ chars['b'] = 1; chars['B'] = 1; chars['!'] = 1; chars['1'] = 1;
+ chars['c'] = 1; chars['C'] = 1; chars['"'] = 1; chars['2'] = 1;
+ chars['d'] = 1; chars['D'] = 1; chars['#'] = 1; chars['3'] = 1;
+ chars['e'] = 1; chars['E'] = 1; chars['%'] = 1; chars['4'] = 1;
+ chars['f'] = 1; chars['F'] = 1; chars['&'] = 1; chars['5'] = 1;
+ chars['g'] = 1; chars['G'] = 1; chars['('] = 1; chars['6'] = 1;
+ chars['h'] = 1; chars['H'] = 1; chars[')'] = 1; chars['7'] = 1;
+ chars['i'] = 1; chars['I'] = 1; chars['_'] = 1; chars['8'] = 1;
+ chars['j'] = 1; chars['J'] = 1; chars['='] = 1; chars['9'] = 1;
+ chars['k'] = 1; chars['K'] = 1; chars['-'] = 1;
+ chars['l'] = 1; chars['L'] = 1; chars['^'] = 1;
+ chars['m'] = 1; chars['M'] = 1; chars['|'] = 1; chars['\n'] = 1;
+ chars['n'] = 1; chars['N'] = 1; chars['\t'] = 1;
+ chars['o'] = 1; chars['O'] = 1; chars['{'] = 1; chars['\b'] = 1;
+ chars['p'] = 1; chars['P'] = 1; chars['}'] = 1; chars['\r'] = 1;
+ chars['q'] = 1; chars['Q'] = 1; chars['['] = 1; chars['\f'] = 1;
+ chars['r'] = 1; chars['R'] = 1; chars[']'] = 1;
+ chars['s'] = 1; chars['S'] = 1; chars['+'] = 1; chars['\\'] = 1;
+ chars['t'] = 1; chars['T'] = 1; chars[';'] = 1; chars['\''] = 1;
+ chars['u'] = 1; chars['U'] = 1; chars['*'] = 1;
+ chars['v'] = 1; chars['V'] = 1; chars[':'] = 1; chars['\0'] = 1;
+ chars['w'] = 1; chars['W'] = 1; chars['<'] = 1; chars[' '] = 1;
+ chars['x'] = 1; chars['X'] = 1; chars['>'] = 1;
+ chars['y'] = 1; chars['Y'] = 1; chars[','] = 1;
+ chars['z'] = 1; chars['Z'] = 1; chars['.'] = 1;
+ chars['?'] = 1;
+ chars['/'] = 1;
+
+ if(sumof(chars) != 98){
+ rc = rc+1;
+ if(pd0->flgd != 0) printf(s243er,1);
+ }
+
+ #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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq244.c b/test/val/cq244.c
new file mode 100644
index 000000000..52695bfb6
--- /dev/null
+++ b/test/val/cq244.c
@@ -0,0 +1,159 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 2.44: floating point constants
+ !!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 */
+
+#ifndef NO_OLD_FUNC_DECL
+s244(pd0)
+struct defs *pd0;
+{
+#else
+s244(struct defs *pd0) {
+#endif
+
+ #ifndef NO_FLOATS
+ double a[8];
+
+ int rc, lrc, j;
+ static char s244er[] = "s244,er%d\n";
+ static char qs244[8] = "s244 ";
+ char *ps, *pt;
+
+ ps = qs244;
+ pt = pd0->rfs;
+ while(*pt++ = *ps++);
+ rc = 0;
+ lrc = 0;
+
+ /* Unfortunately, there's not a lot we can do with floating constants.
+ We can check to see that the various representations can be com-
+ piled, that the conversion is such that they yield the same hard-
+ ware representations in all cases, and that all representations
+ thus checked are double precision. */
+
+ a[0] = .1250E+04;
+ a[1] = 1.250E3;
+ a[2] = 12.50E02;
+ a[3] = 125.0e+1;
+ a[4] = 1250e00;
+ a[5] = 12500.e-01;
+ a[6] = 125000e-2;
+ a[7] = 1250.;
+
+ lrc = 0;
+ for (j=0; j<7; j++) if(a[j] != a[j+1]) lrc = 1;
+
+ if(lrc != 0) {
+ if(pd0->flgd != 0) printf(s244er,1);
+ rc = rc+1;
+ }
+
+ if ( (sizeof .1250E+04 ) != sizeof(double)
+ || (sizeof 1.250E3 ) != sizeof(double)
+ || (sizeof 12.50E02 ) != sizeof(double)
+ || (sizeof 1.250e+1 ) != sizeof(double)
+ || (sizeof 1250e00 ) != sizeof(double)
+ || (sizeof 12500.e-01) != sizeof(double)
+ || (sizeof 125000e-2 ) != sizeof(double)
+ || (sizeof 1250. ) != sizeof(double)){
+ if(pd0->flgd != 0) printf(s244er,2);
+ rc = rc+2;
+ }
+
+ return rc;
+
+ #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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq25.c b/test/val/cq25.c
new file mode 100644
index 000000000..d4a0c4a90
--- /dev/null
+++ b/test/val/cq25.c
@@ -0,0 +1,171 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 2.5: strings
+ !!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 */
+
+#ifndef NO_OLD_FUNC_DECL
+s25(pd0)
+struct defs *pd0;
+{
+#else
+int s25(struct defs *pd0) {
+#endif
+ char *s, *s2;
+ int rc, lrc, j;
+ static char s25er[] = "s25,er%d\n";
+ static char qs25[8] = "s25 ";
+ char *ps, *pt;
+
+ ps = qs25;
+ pt = pd0->rfs;
+ while(*pt++ = *ps++);
+ rc = 0;
+
+ /* A string is a sequence of characters surrounded by double
+ quotes, as in "...". */
+
+ s = "...";
+
+ /* A string has type "array of characters" and storage class
+ static and is initialized with the given characters. */
+
+ if ( s[0] != s[1] || s[1] != s[2]
+ || s[2] != '.' ) {
+ rc = rc+1;
+ if(pd0->flgd != 0) printf(s25er,1);
+ }
+
+ /* The compiler places a null byte \0 at the end of each string
+ so the program which scans the string can find its end. */
+
+ if( s[3] != '\0' ){
+ rc = rc+4;
+ if(pd0->flgd != 0) printf(s25er,4);
+ }
+
+ /* In a string, the double quote character " must be preceded
+ by a \. */
+
+ if( ".\"."[1] != '"' ){
+ rc = rc+8;
+ if(pd0->flgd != 0) printf(s25er,8);
+ }
+
+ /* In addition, the same escapes described for character constants
+ may be used. */
+
+ s = "\n\t\b\r\f\\\'";
+
+ if( s[0] != '\n'
+ || s[1] != '\t'
+ || s[2] != '\b'
+ || s[3] != '\r'
+ || s[4] != '\f'
+ || s[5] != '\\'
+ || s[6] != '\'' ){
+ rc = rc+16;
+ if( pd0->flgd != 0) printf(s25er,16);
+ }
+
+ /* Finally, a \ and an immediately following newline are ignored */
+
+ s2 = "queep!";
+ s = "queep!";
+
+ lrc = 0;
+ for (j=0; j<sizeof "queep!"; j++) if(s[j] != s2[j]) lrc = 1;
+ if (lrc != 0){
+ rc = rc+32;
+ if(pd0->flgd != 0) printf(s25er,32);
+ }
+ return rc;
+}
+
+/*********************************************************************************************
+ 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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq26.c b/test/val/cq26.c
new file mode 100644
index 000000000..42527e80f
--- /dev/null
+++ b/test/val/cq26.c
@@ -0,0 +1,217 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 2.6: Hardware Characteristics
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#ifndef CQ26_INCLUDED
+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 */
+
+#endif
+
+/*
+ section s26, which pokes around at the hardware
+ trying to figure out the characteristics of the machine that
+ it is running on, saves information that is subsequently
+ used by sections s626, s72, and s757. If this program is
+ to be broken up into smallish pieces, say for running on
+ a microcomputer, take care to see that s26 is called before
+ calling any of the latter three sections.
+*/
+
+/*
+ 2.6 Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+ static char qs26[8] = "s26 ";
+ char *ps, *pt;
+ char c0, c1;
+ #ifndef NO_FLOATS
+ float temp, one, delta;
+ double tempd, oned;
+ #endif
+ static char s[] = "%3d bits in %ss.\n";
+ static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+ ps = qs26;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+ /* Here, we shake the machinery a little to see what falls
+ out. First, we find out how many bits are in a char. */
+
+ pd0->cbits = 0;
+ c0 = 0;
+ c1 = 1;
+
+ while(c0 != c1) {
+ c1 = c1<<1;
+ pd0->cbits = pd0->cbits+1;
+ }
+ /* That information lets us determine the size of everything else. */
+
+ pd0->ibits = pd0->cbits * sizeof(int);
+ pd0->sbits = pd0->cbits * sizeof(short);
+ pd0->lbits = pd0->cbits * sizeof(long);
+ pd0->ubits = pd0->cbits * sizeof(unsigned);
+ #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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
+#endif
diff --git a/test/val/cq4.c b/test/val/cq4.c
new file mode 100644
index 000000000..94f4d5fb7
--- /dev/null
+++ b/test/val/cq4.c
@@ -0,0 +1,242 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 4: what's in a name?
+ !!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 */
+
+/*#include "cq26.c"*/ /* hardware check */
+
+int extvar;
+
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+int s4(struct defs *pd0);
+int svtest(int n);
+zero();
+testev();
+setev();
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s4(pd0) /* 4. What's in a name? */
+struct defs *pd0;
+{
+#else
+int s4(struct defs *pd0) {
+#endif
+ static char s4er[] = "s4,er%d\n";
+ static char qs4[8] = "s4 ";
+ char *ps, *pt;
+ int j, rc;
+
+ short sint; /* short integer, for size test */
+ int pint; /* plain */
+ long lint; /* long */
+ unsigned target;
+ unsigned int mask;
+
+ rc = 0;
+ ps = qs4;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+/* There are four declarable storage classes: automatic,
+static, external, and register. Automatic variables have
+been dealt with extensively thus far, and will not be specif-
+ically treated in this section. Register variables are treated
+in section s81.
+
+ Static variables are local to a block, but retain their
+values upon reentry to a block, even after control has left
+the block. */
+
+ for (j=0; j<3; j++)
+ if(svtest(j) != zero()){
+ rc = 1;
+ if(pd0->flgd != 0) printf(s4er,1);
+ }
+ ;
+
+/* External variables exist and retain their values throughout
+the execution of the entire program, and may be used for comm-
+unication between functions, even separately compiled functions.
+ */
+
+ setev();
+ if(testev() != 0){
+ rc=rc+2;
+ if(pd0->flgd != 0) printf(s4er,2);
+ }
+/*
+ Characters have been tested elsewhere (in s243).
+
+ Up to three sizes of integer, declared short int, int, and
+long int, are available. Longer integers provide no less storage
+than shorter ones, but implementation may make either short
+integers, or long integers, or both, equivalent to plain
+integers.
+ */
+
+ if(sizeof lint < sizeof pint || sizeof pint < sizeof sint){
+ rc = rc+4;
+ if(pd0->flgd != 0) printf(s4er,4);
+ }
+
+/* Unsigned integers, declared unsigned, obey the laws of
+arithmetic modulo 2**n, where n is the number of bits in the
+implementation */
+
+ target = ~0U;
+ mask = 1;
+
+ for(j=0; j<(sizeof target)*pd0->cbits; j++){
+ mask = mask⌖
+ target = target>>1;
+ }
+
+ if(mask != 1 || target != 0){
+ rc = rc+8;
+ if(pd0->flgd != 0) printf(s4er,8);
+ }
+
+ return rc;
+}
+
+#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<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq61.c b/test/val/cq61.c
new file mode 100644
index 000000000..f40b21d61
--- /dev/null
+++ b/test/val/cq61.c
@@ -0,0 +1,186 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 6.1: characters and integers
+ !!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 */
+
+/*#include "cq26.c"*/ /* hardware check */
+
+int extvar;
+
+#ifndef NO_OLD_FUNC_DECL
+s61(pd0) /* Characters and integers */
+struct defs *pd0;
+{
+#else
+int s61(struct defs *pd0){
+#endif
+ static char s61er[] = "s61,er%d\n";
+ static char s61ok[] = "s61,ok%d\n";
+ static char qs61[8] = "s61 ";
+ short from, shortint;
+ long int to, longint;
+ int rc, lrc;
+ int j;
+ char fromc, charint;
+ char *wd, *pc[6];
+
+ static char upper_alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ static char lower_alpha[] = "abcdefghijklmnopqrstuvwxyz";
+ static char numbers[] = "0123456789";
+ static char special_characters[] = "~!\"#%&()_=-^|{}[]+;*:<>,.?/";
+ static char extra_special_characters[] = "\n\t\b\r\f\\\'";
+ static char blank_and_NUL[] = " \0";
+
+ char *ps, *pt;
+ ps = qs61;
+ pt = pd0->rfs;
+ rc = 0;
+
+ 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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq626.c b/test/val/cq626.c
new file mode 100644
index 000000000..7fab43f53
--- /dev/null
+++ b/test/val/cq626.c
@@ -0,0 +1,337 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 6.2: Float and double, 6.3 Floating and integral, 6.4 Pointers and integers, 6.5 Unsigned, 6.6 Arithmetic conversions
+ !!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 */
+
+#define CQ26_INCLUDED
+/*
+ section s26, which pokes around at the hardware
+ trying to figure out the characteristics of the machine that
+ it is running on, saves information that is subsequently
+ used by sections s626, s72, and s757. If this program is
+ to be broken up into smallish pieces, say for running on
+ a microcomputer, take care to see that s26 is called before
+ calling any of the latter three sections.
+*/
+
+/*
+ 2.6 Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+ static char qs26[8] = "s26 ";
+ char *ps, *pt;
+ char c0, c1;
+ #ifndef NO_FLOATS
+ float temp, one, delta;
+ double tempd, oned;
+ #endif
+ static char s[] = "%3d bits in %ss.\n";
+ static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+ ps = qs26;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+ /* Here, we shake the machinery a little to see what falls
+ out. First, we find out how many bits are in a char. */
+
+ pd0->cbits = 0;
+ c0 = 0;
+ c1 = 1;
+
+ while(c0 != c1) {
+ c1 = c1<<1;
+ pd0->cbits = pd0->cbits+1;
+ }
+ /* That information lets us determine the size of everything else. */
+
+ pd0->ibits = pd0->cbits * sizeof(int);
+ pd0->sbits = pd0->cbits * sizeof(short);
+ pd0->lbits = pd0->cbits * sizeof(long);
+ pd0->ubits = pd0->cbits * sizeof(unsigned);
+ #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;j<pd0->lbits-2;j++){
+ f1 = f1*2;
+ lint2 = (lint2<<1)|lint1;
+ }
+ f2 = lint2;
+ f1 = (f1-f2)/f1;
+ if(f1>2.*pd0->fprec){
+ rc = rc+2;
+ if(pd0->flgd != 0) printf(s626er,2);
+ }
+
+ /* Pointer-integer combinations are discussed in s74,
+ "Additive operators". The unsigned-int combination
+ appears below. */
+
+ c = 125;
+ s = 125;
+ i = 125; is = 15625;
+ u = 125; us = 15625;
+ l = 125; ls = 15625;
+ f = 125.;
+ d = 125.; ds = 15625.;
+
+ for(j=0;j<28;j++) t[j] = 0;
+
+ if(c*c != is) t[ 0] = 1;
+ if(s*c != is) t[ 1] = 1;
+ if(s*s != is) t[ 2] = 1;
+ if(i*c != is) t[ 3] = 1;
+ if(i*s != is) t[ 4] = 1;
+ if(i*i != is) t[ 5] = 1;
+ if(u*c != us) t[ 6] = 1;
+ if(u*s != us) t[ 7] = 1;
+ if(u*i != us) t[ 8] = 1;
+ if(u*u != us) t[ 9] = 1;
+ if(l*c != ls) t[10] = 1;
+ if(l*s != ls) t[11] = 1;
+ if(l*i != ls) t[12] = 1;
+ if(l*u != us) t[13] = 1;
+ if(l*l != ls) t[14] = 1;
+ if(f*c != ds) t[15] = 1;
+ if(f*s != ds) t[16] = 1;
+ if(f*i != ds) t[17] = 1;
+ if(f*u != ds) t[18] = 1;
+ if(f*l != ds) t[19] = 1;
+ if(f*f != ds) t[20] = 1;
+ if(d*c != ds) t[21] = 1;
+ if(d*s != ds) t[22] = 1;
+ if(d*i != ds) t[23] = 1;
+ if(d*u != ds) t[24] = 1;
+ if(d*l != ds) t[25] = 1;
+ if(d*f != ds) t[26] = 1;
+ if(d*d != ds) t[27] = 1;
+
+ t0 = 0;
+ for(j=0; j<28; j++) t0 = t0+t[j];
+
+ if(t0 != 0){
+ rc = rc+4;
+ if(pd0->flgd != 0){
+ printf(s626er,4);
+ printf(" key=");
+ for(j=0;j<28;j++) printf("%d",t[j]);
+ printf("\n");
+ }
+ }
+
+ #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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq71.c b/test/val/cq71.c
new file mode 100644
index 000000000..342b9809a
--- /dev/null
+++ b/test/val/cq71.c
@@ -0,0 +1,240 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.1: primary expressions
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+/*include "cq26.c"*/ /* hardware check */
+
+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 */
+
+int extvar;
+
+#ifndef NO_OLD_FUNC_DECL
+s71(pd0) /* 7.1 Primary expressions */
+struct defs *pd0;
+{
+#else
+int s71(struct defs *pd0){
+#endif
+ static char s71er[] = "s71,er%d\n";
+ static char qs71[8] = "s71 ";
+ int rc;
+ char *ps, *pt;
+ static char q = 'q';
+#ifndef NO_SLOPPY_EXTERN
+ int x[10], McCarthy(), clobber(), a, b, *p;
+#else
+ int x[10], a, b, *p;
+#endif
+ ps = qs71;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+/* Testing of expressions and operators is quite complicated,
+ because (a) problems are apt to surface in queer combinations
+ of operators and operands, rather than in isolation,
+ and (b) the number of expressions needed to provoke a case
+ of improper behaviour may be quite large. Hence, we take the
+ following approach: for this section, and for subsequent
+ sections through 7.15, we will check the primitive operations
+ in isolation, thus verifying that the primitives work,
+ after a fashion. The job of testing combinations, we will
+ leave to a separate, machine-generated program, to be included
+ in the C test package at some later date.
+ */
+
+/* A string is a primary expression. The identifier points to
+ the first character of a string.
+ */
+
+ if(*"queep" != q){
+ rc = rc+1;
+ if(pd0->flgd != 0) printf(s71er,1);
+ }
+/* A parenthesized expression is a primary expression whose
+ type and value are the same as those of the unadorned
+ expression.
+ */
+ if((2+3) != 2+3) {
+ rc = rc+2;
+ if(pd0->flgd != 0) printf(s71er,2);
+ }
+
+/* A primary expression followed by an expression in square
+ brackets is a primary expression. The intuitive meaning is
+ that of a subscript. The expression E1[E2] is identical
+ (by definition) to *((E1)+(E2)).
+ */
+
+ x[5] = 1942;
+ if(x[5] != 1942 || x[5] != *((x)+(5))){
+ rc = rc+4;
+ if(pd0->flgd != 0) printf(s71er,4);
+ }
+
+/* If the various flavors of function calls didn't work, we
+ would never have gotten this far; however, we do need to
+ show that functions can be recursive...
+ */
+
+ if ( McCarthy(-5) != 91){
+ rc = rc+8;
+ if(pd0->flgd != 0) printf(s71er,8);
+ }
+
+/* and that argument passing is strictly by value. */
+
+ a = 2;
+ b = 3;
+ p = &b;
+
+ clobber(a,p);
+
+ if(a != 2 || b != 2){
+ rc = rc+16;
+ if(pd0->flgd != 0) printf(s71er,16);
+ }
+
+/* Finally, structures and unions are addressed thusly: */
+
+ #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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq714.c b/test/val/cq714.c
new file mode 100644
index 000000000..1d36b18ab
--- /dev/null
+++ b/test/val/cq714.c
@@ -0,0 +1,1795 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.14: assignment operators
+ !!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 */
+
+#ifndef NO_OLD_FUNC_DECL
+s714(pd0) /* 7.14 Assignment operators */
+struct defs *pd0;
+{
+#else
+int s714(struct defs *pd0){
+#endif
+ static char f[] = "Local error %d.\n";
+ static char s714er[] = "s714,er%d\n";
+ static char qs714[8] = "s714 ";
+ register int prlc, lrc;
+ int rc;
+ char cl, cr;
+ short sl, sr;
+ int il, ir;
+ long ll, lr;
+ unsigned ul, ur;
+ #ifndef NO_FLOATS
+ float fl, fr;
+ double dl, dr;
+ #else
+ signed fl, fr;
+ signed dl, dr;
+ #endif
+ char *ps, *pt;
+ ps = qs714;
+ pt = pd0->rfs;
+ rc = 0;
+ lrc = 0;
+ prlc = pd0->flgl;
+ while (*pt++ = *ps++);
+
+ /* This section tests the assignment operators.
+
+ It is an exhaustive test of all assignment statements
+ of the form:
+
+ vl op vr
+
+ where vl and vr are variables from the set
+ {char,short,int,long,unsigned,float,double} and op is
+ one of the assignment operators. There are 395 such
+ statements.
+
+ The initial values for the variables have been chosen
+ so that both the initial values and the results will
+ "fit" in just about any implementation, and that the re-
+ sults will be such that they test for the proper form-
+ ation of composite operators, rather than checking for
+ the valid operation of those operators' components.
+ For example, in checking >>=, we want to verify that
+ a right shift and a move take place, rather than
+ whether or not there may be some peculiarities about
+ the right shift. Such tests have been made previously,
+ and to repeat them here would be to throw out a red
+ herring.
+
+ The table below lists the operators, assignment targets,
+ initial values for left and right operands, and the
+ expected values of the results.
+
+ = += -= *= /= %= >>= <<= &= ^= |=
+char 2 7 3 10 2 1 1 20 8 6 14
+short 2 7 3 10 2 1 1 20 8 6 14
+int 2 7 3 10 2 1 1 20 8 6 14
+long 2 7 3 10 2 1 1 20 8 6 14
+unsigned 2 7 3 10 2 1 1 20 8 6 14
+float 2 7 3 10 2.5 | |
+double 2 7 3 10 2.5 | |
+ | |
+initial (5,2) | (5,2) | (12,10)
+
+ The following machine-generated program reflects the
+ tests described in the table.
+ */
+
+ cl = 5; cr = 2;
+ cl = cr;
+ if(cl != 2){
+ lrc = 1;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl = sr;
+ if(cl != 2){
+ lrc = 2;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl = ir;
+ if(cl != 2){
+ lrc = 3;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl = lr;
+ if(cl != 2){
+ lrc = 4;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl = ur;
+ if(cl != 2){
+ lrc = 5;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; fr = 2;
+ cl = fr;
+ if(cl != 2){
+ lrc = 6;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; dr = 2;
+ cl = dr;
+ if(cl != 2){
+ lrc = 7;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl = cr;
+ if(sl != 2){
+ lrc = 8;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl = sr;
+ if(sl != 2){
+ lrc = 9;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl = ir;
+ if(sl != 2){
+ lrc = 10;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl = lr;
+ if(sl != 2){
+ lrc = 11;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl = ur;
+ if(sl != 2){
+ lrc = 12;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; fr = 2;
+ sl = fr;
+ if(sl != 2){
+ lrc = 13;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; dr = 2;
+ sl = dr;
+ if(sl != 2){
+ lrc = 14;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il = cr;
+ if(il != 2){
+ lrc = 15;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il = sr;
+ if(il != 2){
+ lrc = 16;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il = ir;
+ if(il != 2){
+ lrc = 17;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il = lr;
+ if(il != 2){
+ lrc = 18;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il = ur;
+ if(il != 2){
+ lrc = 19;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; fr = 2;
+ il = fr;
+ if(il != 2){
+ lrc = 20;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; dr = 2;
+ il = dr;
+ if(il != 2){
+ lrc = 21;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll = cr;
+ if(ll != 2){
+ lrc = 22;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll = sr;
+ if(ll != 2){
+ lrc = 23;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll = ir;
+ if(ll != 2){
+ lrc = 24;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll = lr;
+ if(ll != 2){
+ lrc = 25;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll = ur;
+ if(ll != 2){
+ lrc = 26;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; fr = 2;
+ ll = fr;
+ if(ll != 2){
+ lrc = 27;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; dr = 2;
+ ll = dr;
+ if(ll != 2){
+ lrc = 28;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul = cr;
+ if(ul != 2){
+ lrc = 29;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul = sr;
+ if(ul != 2){
+ lrc = 30;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul = ir;
+ if(ul != 2){
+ lrc = 31;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul = lr;
+ if(ul != 2){
+ lrc = 32;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul = ur;
+ if(ul != 2){
+ lrc = 33;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; fr = 2;
+ ul = fr;
+ if(ul != 2){
+ lrc = 34;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; dr = 2;
+ ul = dr;
+ if(ul != 2){
+ lrc = 35;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; cr = 2;
+ fl = cr;
+ if(fl != 2){
+ lrc = 36;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; sr = 2;
+ fl = sr;
+ if(fl != 2){
+ lrc = 37;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ir = 2;
+ fl = ir;
+ if(fl != 2){
+ lrc = 38;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; lr = 2;
+ fl = lr;
+ if(fl != 2){
+ lrc = 39;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ur = 2;
+ fl = ur;
+ if(fl != 2){
+ lrc = 40;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; fr = 2;
+ fl = fr;
+ if(fl != 2){
+ lrc = 41;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; dr = 2;
+ fl = dr;
+ if(fl != 2){
+ lrc = 42;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; cr = 2;
+ dl = cr;
+ if(dl != 2){
+ lrc = 43;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; sr = 2;
+ dl = sr;
+ if(dl != 2){
+ lrc = 44;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ir = 2;
+ dl = ir;
+ if(dl != 2){
+ lrc = 45;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; lr = 2;
+ dl = lr;
+ if(dl != 2){
+ lrc = 46;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ur = 2;
+ dl = ur;
+ if(dl != 2){
+ lrc = 47;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; fr = 2;
+ dl = fr;
+ if(dl != 2){
+ lrc = 48;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; dr = 2;
+ dl = dr;
+ if(dl != 2){
+ lrc = 49;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; cr = 2;
+ cl += cr;
+ if(cl != 7){
+ lrc = 50;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl += sr;
+ if(cl != 7){
+ lrc = 51;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl += ir;
+ if(cl != 7){
+ lrc = 52;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl += lr;
+ if(cl != 7){
+ lrc = 53;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl += ur;
+ if(cl != 7){
+ lrc = 54;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; fr = 2;
+ cl += fr;
+ if(cl != 7){
+ lrc = 55;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; dr = 2;
+ cl += dr;
+ if(cl != 7){
+ lrc = 56;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl += cr;
+ if(sl != 7){
+ lrc = 57;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl += sr;
+ if(sl != 7){
+ lrc = 58;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl += ir;
+ if(sl != 7){
+ lrc = 59;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl += lr;
+ if(sl != 7){
+ lrc = 60;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl += ur;
+ if(sl != 7){
+ lrc = 61;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; fr = 2;
+ sl += fr;
+ if(sl != 7){
+ lrc = 62;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; dr = 2;
+ sl += dr;
+ if(sl != 7){
+ lrc = 63;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il += cr;
+ if(il != 7){
+ lrc = 64;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il += sr;
+ if(il != 7){
+ lrc = 65;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il += ir;
+ if(il != 7){
+ lrc = 66;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il += lr;
+ if(il != 7){
+ lrc = 67;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il += ur;
+ if(il != 7){
+ lrc = 68;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; fr = 2;
+ il += fr;
+ if(il != 7){
+ lrc = 69;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; dr = 2;
+ il += dr;
+ if(il != 7){
+ lrc = 70;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll += cr;
+ if(ll != 7){
+ lrc = 71;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll += sr;
+ if(ll != 7){
+ lrc = 72;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll += ir;
+ if(ll != 7){
+ lrc = 73;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll += lr;
+ if(ll != 7){
+ lrc = 74;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll += ur;
+ if(ll != 7){
+ lrc = 75;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; fr = 2;
+ ll += fr;
+ if(ll != 7){
+ lrc = 76;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; dr = 2;
+ ll += dr;
+ if(ll != 7){
+ lrc = 77;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul += cr;
+ if(ul != 7){
+ lrc = 78;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul += sr;
+ if(ul != 7){
+ lrc = 79;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul += ir;
+ if(ul != 7){
+ lrc = 80;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul += lr;
+ if(ul != 7){
+ lrc = 81;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul += ur;
+ if(ul != 7){
+ lrc = 82;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; fr = 2;
+ ul += fr;
+ if(ul != 7){
+ lrc = 83;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; dr = 2;
+ ul += dr;
+ if(ul != 7){
+ lrc = 84;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; cr = 2;
+ fl += cr;
+ if(fl != 7){
+ lrc = 85;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; sr = 2;
+ fl += sr;
+ if(fl != 7){
+ lrc = 86;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ir = 2;
+ fl += ir;
+ if(fl != 7){
+ lrc = 87;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; lr = 2;
+ fl += lr;
+ if(fl != 7){
+ lrc = 88;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ur = 2;
+ fl += ur;
+ if(fl != 7){
+ lrc = 89;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; fr = 2;
+ fl += fr;
+ if(fl != 7){
+ lrc = 90;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; dr = 2;
+ fl += dr;
+ if(fl != 7){
+ lrc = 91;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; cr = 2;
+ dl += cr;
+ if(dl != 7){
+ lrc = 92;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; sr = 2;
+ dl += sr;
+ if(dl != 7){
+ lrc = 93;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ir = 2;
+ dl += ir;
+ if(dl != 7){
+ lrc = 94;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; lr = 2;
+ dl += lr;
+ if(dl != 7){
+ lrc = 95;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ur = 2;
+ dl += ur;
+ if(dl != 7){
+ lrc = 96;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; fr = 2;
+ dl += fr;
+ if(dl != 7){
+ lrc = 97;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; dr = 2;
+ dl += dr;
+ if(dl != 7){
+ lrc = 98;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; cr = 2;
+ cl -= cr;
+ if(cl != 3){
+ lrc = 99;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl -= sr;
+ if(cl != 3){
+ lrc = 100;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl -= ir;
+ if(cl != 3){
+ lrc = 101;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl -= lr;
+ if(cl != 3){
+ lrc = 102;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl -= ur;
+ if(cl != 3){
+ lrc = 103;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; fr = 2;
+ cl -= fr;
+ if(cl != 3){
+ lrc = 104;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; dr = 2;
+ cl -= dr;
+ if(cl != 3){
+ lrc = 105;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl -= cr;
+ if(sl != 3){
+ lrc = 106;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl -= sr;
+ if(sl != 3){
+ lrc = 107;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl -= ir;
+ if(sl != 3){
+ lrc = 108;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl -= lr;
+ if(sl != 3){
+ lrc = 109;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl -= ur;
+ if(sl != 3){
+ lrc = 110;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; fr = 2;
+ sl -= fr;
+ if(sl != 3){
+ lrc = 111;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; dr = 2;
+ sl -= dr;
+ if(sl != 3){
+ lrc = 112;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il -= cr;
+ if(il != 3){
+ lrc = 113;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il -= sr;
+ if(il != 3){
+ lrc = 114;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il -= ir;
+ if(il != 3){
+ lrc = 115;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il -= lr;
+ if(il != 3){
+ lrc = 116;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il -= ur;
+ if(il != 3){
+ lrc = 117;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; fr = 2;
+ il -= fr;
+ if(il != 3){
+ lrc = 118;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; dr = 2;
+ il -= dr;
+ if(il != 3){
+ lrc = 119;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll -= cr;
+ if(ll != 3){
+ lrc = 120;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll -= sr;
+ if(ll != 3){
+ lrc = 121;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll -= ir;
+ if(ll != 3){
+ lrc = 122;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll -= lr;
+ if(ll != 3){
+ lrc = 123;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll -= ur;
+ if(ll != 3){
+ lrc = 124;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; fr = 2;
+ ll -= fr;
+ if(ll != 3){
+ lrc = 125;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; dr = 2;
+ ll -= dr;
+ if(ll != 3){
+ lrc = 126;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul -= cr;
+ if(ul != 3){
+ lrc = 127;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul -= sr;
+ if(ul != 3){
+ lrc = 128;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul -= ir;
+ if(ul != 3){
+ lrc = 129;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul -= lr;
+ if(ul != 3){
+ lrc = 130;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul -= ur;
+ if(ul != 3){
+ lrc = 131;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; fr = 2;
+ ul -= fr;
+ if(ul != 3){
+ lrc = 132;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; dr = 2;
+ ul -= dr;
+ if(ul != 3){
+ lrc = 133;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; cr = 2;
+ fl -= cr;
+ if(fl != 3){
+ lrc = 134;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; sr = 2;
+ fl -= sr;
+ if(fl != 3){
+ lrc = 135;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ir = 2;
+ fl -= ir;
+ if(fl != 3){
+ lrc = 136;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; lr = 2;
+ fl -= lr;
+ if(fl != 3){
+ lrc = 137;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ur = 2;
+ fl -= ur;
+ if(fl != 3){
+ lrc = 138;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; fr = 2;
+ fl -= fr;
+ if(fl != 3){
+ lrc = 139;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; dr = 2;
+ fl -= dr;
+ if(fl != 3){
+ lrc = 140;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; cr = 2;
+ dl -= cr;
+ if(dl != 3){
+ lrc = 141;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; sr = 2;
+ dl -= sr;
+ if(dl != 3){
+ lrc = 142;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ir = 2;
+ dl -= ir;
+ if(dl != 3){
+ lrc = 143;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; lr = 2;
+ dl -= lr;
+ if(dl != 3){
+ lrc = 144;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ur = 2;
+ dl -= ur;
+ if(dl != 3){
+ lrc = 145;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; fr = 2;
+ dl -= fr;
+ if(dl != 3){
+ lrc = 146;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; dr = 2;
+ dl -= dr;
+ if(dl != 3){
+ lrc = 147;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; cr = 2;
+ cl *= cr;
+ if(cl != 10){
+ lrc = 148;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl *= sr;
+ if(cl != 10){
+ lrc = 149;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl *= ir;
+ if(cl != 10){
+ lrc = 150;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl *= lr;
+ if(cl != 10){
+ lrc = 151;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl *= ur;
+ if(cl != 10){
+ lrc = 152;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; fr = 2;
+ cl *= fr;
+ if(cl != 10){
+ lrc = 153;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; dr = 2;
+ cl *= dr;
+ if(cl != 10){
+ lrc = 154;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl *= cr;
+ if(sl != 10){
+ lrc = 155;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl *= sr;
+ if(sl != 10){
+ lrc = 156;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl *= ir;
+ if(sl != 10){
+ lrc = 157;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl *= lr;
+ if(sl != 10){
+ lrc = 158;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl *= ur;
+ if(sl != 10){
+ lrc = 159;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; fr = 2;
+ sl *= fr;
+ if(sl != 10){
+ lrc = 160;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; dr = 2;
+ sl *= dr;
+ if(sl != 10){
+ lrc = 161;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il *= cr;
+ if(il != 10){
+ lrc = 162;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il *= sr;
+ if(il != 10){
+ lrc = 163;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il *= ir;
+ if(il != 10){
+ lrc = 164;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il *= lr;
+ if(il != 10){
+ lrc = 165;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il *= ur;
+ if(il != 10){
+ lrc = 166;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; fr = 2;
+ il *= fr;
+ if(il != 10){
+ lrc = 167;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; dr = 2;
+ il *= dr;
+ if(il != 10){
+ lrc = 168;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll *= cr;
+ if(ll != 10){
+ lrc = 169;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll *= sr;
+ if(ll != 10){
+ lrc = 170;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll *= ir;
+ if(ll != 10){
+ lrc = 171;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll *= lr;
+ if(ll != 10){
+ lrc = 172;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll *= ur;
+ if(ll != 10){
+ lrc = 173;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; fr = 2;
+ ll *= fr;
+ if(ll != 10){
+ lrc = 174;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; dr = 2;
+ ll *= dr;
+ if(ll != 10){
+ lrc = 175;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul *= cr;
+ if(ul != 10){
+ lrc = 176;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul *= sr;
+ if(ul != 10){
+ lrc = 177;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul *= ir;
+ if(ul != 10){
+ lrc = 178;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul *= lr;
+ if(ul != 10){
+ lrc = 179;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul *= ur;
+ if(ul != 10){
+ lrc = 180;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; fr = 2;
+ ul *= fr;
+ if(ul != 10){
+ lrc = 181;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; dr = 2;
+ ul *= dr;
+ if(ul != 10){
+ lrc = 182;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; cr = 2;
+ fl *= cr;
+ if(fl != 10){
+ lrc = 183;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; sr = 2;
+ fl *= sr;
+ if(fl != 10){
+ lrc = 184;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ir = 2;
+ fl *= ir;
+ if(fl != 10){
+ lrc = 185;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; lr = 2;
+ fl *= lr;
+ if(fl != 10){
+ lrc = 186;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ur = 2;
+ fl *= ur;
+ if(fl != 10){
+ lrc = 187;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; fr = 2;
+ fl *= fr;
+ if(fl != 10){
+ lrc = 188;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; dr = 2;
+ fl *= dr;
+ if(fl != 10){
+ lrc = 189;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; cr = 2;
+ dl *= cr;
+ if(dl != 10){
+ lrc = 190;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; sr = 2;
+ dl *= sr;
+ if(dl != 10){
+ lrc = 191;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ir = 2;
+ dl *= ir;
+ if(dl != 10){
+ lrc = 192;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; lr = 2;
+ dl *= lr;
+ if(dl != 10){
+ lrc = 193;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ur = 2;
+ dl *= ur;
+ if(dl != 10){
+ lrc = 194;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; fr = 2;
+ dl *= fr;
+ if(dl != 10){
+ lrc = 195;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; dr = 2;
+ dl *= dr;
+ if(dl != 10){
+ lrc = 196;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; cr = 2;
+ cl /= cr;
+ if(cl != 2){
+ lrc = 197;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl /= sr;
+ if(cl != 2){
+ lrc = 198;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl /= ir;
+ if(cl != 2){
+ lrc = 199;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl /= lr;
+ if(cl != 2){
+ lrc = 200;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl /= ur;
+ if(cl != 2){
+ lrc = 201;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; fr = 2;
+ cl /= fr;
+ if(cl != 2){
+ lrc = 202;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; dr = 2;
+ cl /= dr;
+ if(cl != 2){
+ lrc = 203;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl /= cr;
+ if(sl != 2){
+ lrc = 204;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl /= sr;
+ if(sl != 2){
+ lrc = 205;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl /= ir;
+ if(sl != 2){
+ lrc = 206;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl /= lr;
+ if(sl != 2){
+ lrc = 207;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl /= ur;
+ if(sl != 2){
+ lrc = 208;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; fr = 2;
+ sl /= fr;
+ if(sl != 2){
+ lrc = 209;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; dr = 2;
+ sl /= dr;
+ if(sl != 2){
+ lrc = 210;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il /= cr;
+ if(il != 2){
+ lrc = 211;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il /= sr;
+ if(il != 2){
+ lrc = 212;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il /= ir;
+ if(il != 2){
+ lrc = 213;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il /= lr;
+ if(il != 2){
+ lrc = 214;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il /= ur;
+ if(il != 2){
+ lrc = 215;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; fr = 2;
+ il /= fr;
+ if(il != 2){
+ lrc = 216;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; dr = 2;
+ il /= dr;
+ if(il != 2){
+ lrc = 217;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll /= cr;
+ if(ll != 2){
+ lrc = 218;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll /= sr;
+ if(ll != 2){
+ lrc = 219;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll /= ir;
+ if(ll != 2){
+ lrc = 220;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll /= lr;
+ if(ll != 2){
+ lrc = 221;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll /= ur;
+ if(ll != 2){
+ lrc = 222;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; fr = 2;
+ ll /= fr;
+ if(ll != 2){
+ lrc = 223;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; dr = 2;
+ ll /= dr;
+ if(ll != 2){
+ lrc = 224;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul /= cr;
+ if(ul != 2){
+ lrc = 225;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul /= sr;
+ if(ul != 2){
+ lrc = 226;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul /= ir;
+ if(ul != 2){
+ lrc = 227;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul /= lr;
+ if(ul != 2){
+ lrc = 228;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul /= ur;
+ if(ul != 2){
+ lrc = 229;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; fr = 2;
+ ul /= fr;
+ if(ul != 2){
+ lrc = 230;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; dr = 2;
+ ul /= dr;
+ if(ul != 2){
+ lrc = 231;
+ if(prlc) printf(f,lrc);
+ }
+
+ #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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq714b.c b/test/val/cq714b.c
new file mode 100644
index 000000000..9a09a88f0
--- /dev/null
+++ b/test/val/cq714b.c
@@ -0,0 +1,1016 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 9: Statements
+ !!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 */
+
+#ifndef NO_OLD_FUNC_DECL
+s714(pd0) /* 7.14 Assignment operators */
+struct defs *pd0;
+{
+#else
+int s714(struct defs *pd0){
+#endif
+ static char f[] = "Local error %d.\n";
+ static char s714er[] = "s714,er%d\n";
+ static char qs714[8] = "s714 ";
+ register int prlc, lrc;
+ int rc;
+ char cl, cr;
+ short sl, sr;
+ int il, ir;
+ long ll, lr;
+ unsigned ul, ur;
+ #ifndef NO_FLOATS
+ float fl, fr;
+ double dl, dr;
+ #else
+ signed fl, fr;
+ signed dl, dr;
+ #endif
+ char *ps, *pt;
+ ps = qs714;
+ pt = pd0->rfs;
+ rc = 0;
+ lrc = 0;
+ prlc = pd0->flgl;
+ while (*pt++ = *ps++);
+
+ /* This section tests the assignment operators.
+
+ It is an exhaustive test of all assignment statements
+ of the form:
+
+ vl op vr
+
+ where vl and vr are variables from the set
+ {char,short,int,long,unsigned,float,double} and op is
+ one of the assignment operators. There are 395 such
+ statements.
+
+ The initial values for the variables have been chosen
+ so that both the initial values and the results will
+ "fit" in just about any implementation, and that the re-
+ sults will be such that they test for the proper form-
+ ation of composite operators, rather than checking for
+ the valid operation of those operators' components.
+ For example, in checking >>=, we want to verify that
+ a right shift and a move take place, rather than
+ whether or not there may be some peculiarities about
+ the right shift. Such tests have been made previously,
+ and to repeat them here would be to throw out a red
+ herring.
+
+ The table below lists the operators, assignment targets,
+ initial values for left and right operands, and the
+ expected values of the results.
+
+ = += -= *= /= %= >>= <<= &= ^= |=
+char 2 7 3 10 2 1 1 20 8 6 14
+short 2 7 3 10 2 1 1 20 8 6 14
+int 2 7 3 10 2 1 1 20 8 6 14
+long 2 7 3 10 2 1 1 20 8 6 14
+unsigned 2 7 3 10 2 1 1 20 8 6 14
+float 2 7 3 10 2.5 | |
+double 2 7 3 10 2.5 | |
+ | |
+initial (5,2) | (5,2) | (12,10)
+
+ The following machine-generated program reflects the
+ tests described in the table.
+ */
+
+ 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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq715.c b/test/val/cq715.c
new file mode 100644
index 000000000..dd829156c
--- /dev/null
+++ b/test/val/cq715.c
@@ -0,0 +1,151 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.15: Comma operator
+ !!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 */
+
+/*#include "cq26.c"*/ /* hardware check */
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+s715f(int x,int y,int z);
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s715(pd0) /* 7.15 Comma operator */
+struct defs *pd0;
+{
+#else
+int s715(struct defs *pd0) {
+#endif
+ static char s715er[] = "s715,er%d\n";
+ static char qs715[8] = "s715 ";
+ int rc;
+ char *ps, *pt;
+ int a, t, c, i;
+ a = c = 0;
+ ps = qs715;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* A pair of expressions separated by a comma is
+ evaluated left to right and the value of the left
+ expression is discarded.
+ */
+ i = 1;
+ if( i++,i++,i++,i++,++i != 6 ){
+ if(pd0->flgd != 0) printf(s715er,1);
+ rc = rc+1;
+ }
+
+ /* In contexts where the comma is given a special mean-
+ ing, for example in a list of actual arguments to
+ functions (sic) and lists of initializers, the comma
+ operator as described in this section can only appear
+ in parentheses; for example
+
+ f( a, (t=3, t+2), c)
+
+ has three arguments, the second of which has the
+ value 5.
+ */
+
+ if(s715f(a, (t=3, t+2), c) != 5){
+ if(pd0->flgd != 0) printf(s715er,2);
+ rc = rc+2;
+ }
+ return rc;
+}
+s715f(x,y,z)
+int x, y, z;
+{
+ return y;
+}
+
+/*********************************************************************************************
+ 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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq72.c b/test/val/cq72.c
new file mode 100644
index 000000000..5f60fdcad
--- /dev/null
+++ b/test/val/cq72.c
@@ -0,0 +1,345 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.2: Unary Operators
+ !!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 */
+
+#define CQ26_INCLUDED
+/*
+ section s26, which pokes around at the hardware
+ trying to figure out the characteristics of the machine that
+ it is running on, saves information that is subsequently
+ used by sections s626, s72, and s757. If this program is
+ to be broken up into smallish pieces, say for running on
+ a microcomputer, take care to see that s26 is called before
+ calling any of the latter three sections.
+*/
+
+/*
+ 2.6 Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+ static char qs26[8] = "s26 ";
+ char *ps, *pt;
+ char c0, c1;
+ #ifndef NO_FLOATS
+ float temp, one, delta;
+ double tempd, oned;
+ #endif
+ static char s[] = "%3d bits in %ss.\n";
+ static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+ ps = qs26;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+ /* Here, we shake the machinery a little to see what falls
+ out. First, we find out how many bits are in a char. */
+
+ pd0->cbits = 0;
+ c0 = 0;
+ c1 = 1;
+
+ while(c0 != c1) {
+ c1 = c1<<1;
+ pd0->cbits = pd0->cbits+1;
+ }
+ /* That information lets us determine the size of everything else. */
+
+ pd0->ibits = pd0->cbits * sizeof(int);
+ pd0->sbits = pd0->cbits * sizeof(short);
+ pd0->lbits = pd0->cbits * sizeof(long);
+ pd0->ubits = pd0->cbits * sizeof(unsigned);
+ #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;j<pd0->ibits;j++) k = (k<<1)|1;
+ if(~k != 0){
+ rc = rc+4;
+ printf(s72er,4);
+ }
+
+ /* Now we look at the ++ and -- operators, which can be
+ used in either prefix or suffix form. With side
+ effects they're loaded. */
+
+ k = 5;
+
+ if( ++k != 6 || --k != 5
+ || k++ != 5 || k-- != 6
+ || k != 5 ){
+ rc = rc+8;
+ printf(s72er,8);
+ }
+
+ /* An expression preceded by the parenthesised name of a
+ data type causes conversion of the value of the expression
+ to the named type. This construction is called a cast.
+ Here, we check to see that all of the possible casts and
+ their simple combinations are accepted by the compiler,
+ and that they all produce a correct result for this sample
+ of size one. */
+
+ c = 26; l = 26;
+ 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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq757.c b/test/val/cq757.c
new file mode 100644
index 000000000..7c898ca5b
--- /dev/null
+++ b/test/val/cq757.c
@@ -0,0 +1,335 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.5: Shift operators, 7.6 Relational operators, 7.7 Equality operator
+ !!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 */
+
+#define CQ26_INCLUDED
+/*
+ section s26, which pokes around at the hardware
+ trying to figure out the characteristics of the machine that
+ it is running on, saves information that is subsequently
+ used by sections s626, s72, and s757. If this program is
+ to be broken up into smallish pieces, say for running on
+ a microcomputer, take care to see that s26 is called before
+ calling any of the latter three sections.
+*/
+
+/*
+ 2.6 Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+ static char qs26[8] = "s26 ";
+ char *ps, *pt;
+ char c0, c1;
+ #ifndef NO_FLOATS
+ float temp, one, delta;
+ double tempd, oned;
+ #endif
+ static char s[] = "%3d bits in %ss.\n";
+ static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+ ps = qs26;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+ /* Here, we shake the machinery a little to see what falls
+ out. First, we find out how many bits are in a char. */
+
+ pd0->cbits = 0;
+ c0 = 0;
+ c1 = 1;
+
+ while(c0 != c1) {
+ c1 = c1<<1;
+ pd0->cbits = pd0->cbits+1;
+ }
+ /* That information lets us determine the size of everything else. */
+
+ pd0->ibits = pd0->cbits * sizeof(int);
+ pd0->sbits = pd0->cbits * sizeof(short);
+ pd0->lbits = pd0->cbits * sizeof(long);
+ pd0->ubits = pd0->cbits * sizeof(unsigned);
+ #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<=k<n.
+ We expect to find k 0s followed by n-k 1s (resp. n-k 1s
+ followed by k 0s). If not, we complain.
+ */
+
+ lrc = 0;
+ for(k=0; k<pd0->ubits; k++){
+ rs = 1;
+ ls = rs<<(pd0->ubits-1);
+
+ rt = 0;
+ lt = ~rt>>k;
+ rt = ~rt<<k;
+
+ for(j=0; j<pd0->ubits;j++){
+ if((j<k) != ((rs&rt) == 0) || (j<k) != ((ls<) == 0)) lrc = 1;
+ rs = rs<<1;
+ ls = ls>>1;
+ }
+ }
+
+ if(lrc != 0){
+ rc = rc+2;
+ if(pd0->flgd != 0) printf(s757er,2);
+ }
+
+ /* The relational operators group left-to-right, but this
+ fact is not very useful; a<b<c does not mean what it
+ seems to...
+ */
+
+ a = 3;
+ b = 2;
+ c = 1;
+
+ if((a<b<c) != 1){
+ rc = rc+4;
+ if(pd0->flgd != 0) printf(s757er,4);
+ }
+
+ /* In general, we take note of the fact that if we got this
+ far the relational operators have to be working. We test only
+ that two pointers may be compared; the result depends on
+ the relative locations in the address space of the
+ pointed-to objects.
+ */
+ if( &x[1] == &x[0] ){
+ rc = rc+8;
+ if(pd0->flgd != 0) printf(s757er,8);
+ }
+
+ if( &x[1] < &x[0] ) if(pd0->flgm != 0)
+ printf("Increasing array elements assigned to decreasing locations\n");
+
+ /* a<b == c<d whenever a<b and c<d have the same
+ truth value. */
+
+ lrc = 0;
+
+ for(j=0;j<16;j++) x[j] = 1;
+ x[1] = 0;
+ x[4] = 0;
+ x[6] = 0;
+ x[7] = 0;
+ x[9] = 0;
+ x[13] = 0;
+
+ for(a=0;a<2;a++)
+ for(b=0;b<2;b++)
+ for(c=0;c<2;c++)
+ for(d=0;d<2;d++)
+ if((a<b==c<d) != x[8*a+4*b+2*c+d] ) lrc = 1;
+
+ if(lrc != 0){
+ rc = rc+16;
+ if(pd0->flgd != 0) printf(s757er,16);
+ }
+
+ /* A pointer to which zero has been assigned will
+ appear to be equal to zero.
+ */
+
+ p = 0;
+
+ if(p != 0){
+ rc = rc+32;
+ if(pd0->flgd != 0) printf(s757er,32);
+ }
+
+ return rc;
+}
+
+/*********************************************************************************************
+ 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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq7813.c b/test/val/cq7813.c
new file mode 100644
index 000000000..77d34a2a6
--- /dev/null
+++ b/test/val/cq7813.c
@@ -0,0 +1,381 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.8: Bitwise AND operator, 7.9 Bitwise OR operator, 7.10 Bitwise exclusive OR operator, 7.11 Logical AND operator, 7.12 Logical OR operator, 7.13 Conditional operator
+ !!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 */
+
+#ifndef NO_OLD_FUNC_DECL
+s7813(pd0) /* 7.8 Bitwise AND operator
+ 7.9 Bitwise OR operator
+ 7.10 Bitwise exclusive OR operator
+ 7.11 Logical AND operator
+ 7.12 Logical OR operator
+ 7.13 Conditional operator */
+struct defs *pd0;
+{
+#else
+int s7813(struct defs *pd0){
+#endif
+ register int prlc, lrc;
+ int i, j, r, zero, one;
+ static char fl[] = "Local error %d.\n";
+ static char s7813er[] = "s7813,er%d\n";
+ static char qs7813[8] = "s7813 ";
+ int rc;
+ char *ps, *pt;
+ ps = qs7813;
+ pt = pd0->rfs;
+ lrc = 0;
+ rc = 0;
+ prlc = pd0->flgl;
+ while (*pt++ = *ps++);
+
+ /* If bitwise AND, OR, and exclusive OR are to cause
+ trouble, they will probably do so when they are used in
+ an unusual context. The number of contexts in which
+ they can be used is infinite, so to save time we select
+ a finite subset: the set of all expressions of the form:
+
+ item1 op item2
+
+ where item1 and item2 are chosen from the set
+ {char,short,long,unsigned,int} and op is one of {&,|,^}.
+ We will use 12 and 10 as values for the items, as these
+ values will fit into all data types on just about any
+ imaginable machine, and the results after performing the
+ bitwise operations on them are distinct for each operation,
+ i.e.,
+
+ 12 | 10 -> 1100 | 1010 -> 1110 -> 14
+ 12 ^ 10 -> 1100 ^ 1010 -> 0110 -> 6
+ 12 & 10 -> 1100 & 1010 -> 1000 -> 8
+
+ There are 75 such combinations:
+ */
+
+ if(((char)12 & (char)10) != 8) {lrc = 1;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 | (char)10) != 14) {lrc = 2;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 ^ (char)10) != 6) {lrc = 3;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 & (short)10) != 8) {lrc = 4;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 | (short)10) != 14) {lrc = 5;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 ^ (short)10) != 6) {lrc = 6;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 & (long)10) != 8) {lrc = 7;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 | (long)10) != 14) {lrc = 8;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 ^ (long)10) != 6) {lrc = 9;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 & (unsigned)10) != 8) {lrc = 10;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 | (unsigned)10) != 14) {lrc = 11;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 ^ (unsigned)10) != 6) {lrc = 12;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 & (int)10) != 8) {lrc = 13;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 | (int)10) != 14) {lrc = 14;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 ^ (int)10) != 6) {lrc = 15;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 & (char)10) != 8) {lrc = 16;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 | (char)10) != 14) {lrc = 17;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 ^ (char)10) != 6) {lrc = 18;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 & (short)10) != 8) {lrc = 16;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 | (short)10) != 14) {lrc = 20;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 ^ (short)10) != 6) {lrc = 21;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 & (long)10) != 8) {lrc = 22;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 | (long)10) != 14) {lrc = 23;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 ^ (long)10) != 6) {lrc = 24;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 & (unsigned)10) != 8) {lrc = 25;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 | (unsigned)10) != 14) {lrc = 26;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 ^ (unsigned)10) != 6) {lrc = 27;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 & (int)10) != 8) {lrc = 28;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 | (int)10) != 14) {lrc = 26;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 ^ (int)10) != 6) {lrc = 30;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 & (char)10) != 8) {lrc = 31;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 | (char)10) != 14) {lrc = 32;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 ^ (char)10) != 6) {lrc = 33;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 & (short)10) != 8) {lrc = 34;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 | (short)10) != 14) {lrc = 35;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 ^ (short)10) != 6) {lrc = 36;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 & (long)10) != 8) {lrc = 37;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 | (long)10) != 14) {lrc = 38;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 ^ (long)10) != 6) {lrc = 39;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 & (unsigned)10) != 8) {lrc = 40;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 | (unsigned)10) != 14) {lrc = 41;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 ^ (unsigned)10) != 6) {lrc = 42;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 & (int)10) != 8) {lrc = 43;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 | (int)10) != 14) {lrc = 44;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 ^ (int)10) != 6) {lrc = 45;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 & (char)10) != 8) {lrc = 46;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 | (char)10) != 14) {lrc = 47;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 ^ (char)10) != 6) {lrc = 48;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 & (short)10) != 8) {lrc = 49;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 | (short)10) != 14) {lrc = 50;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 ^ (short)10) != 6) {lrc = 51;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 & (long)10) != 8) {lrc = 52;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 | (long)10) != 14) {lrc = 53;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 ^ (long)10) != 6) {lrc = 54;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 & (unsigned)10) != 8) {lrc = 55;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 | (unsigned)10) != 14) {lrc = 56;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 ^ (unsigned)10) != 6) {lrc = 57;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 & (int)10) != 8) {lrc = 58;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 | (int)10) != 14) {lrc = 56;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 ^ (int)10) != 6) {lrc = 60;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 & (char)10) != 8) {lrc = 61;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 | (char)10) != 14) {lrc = 62;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 ^ (char)10) != 6) {lrc = 63;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 & (short)10) != 8) {lrc = 64;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 | (short)10) != 14) {lrc = 65;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 ^ (short)10) != 6) {lrc = 66;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 & (long)10) != 8) {lrc = 67;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 | (long)10) != 14) {lrc = 68;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 ^ (long)10) != 6) {lrc = 69;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 & (unsigned)10) != 8) {lrc = 70;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 | (unsigned)10) != 14) {lrc = 71;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 ^ (unsigned)10) != 6) {lrc = 72;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 & (int)10) != 8) {lrc = 73; if(prlc) printf(fl,lrc);}
+ if(((int)12 | (int)10) != 14) {lrc = 74; if(prlc) printf(fl,lrc);}
+ if(((int)12 ^ (int)10) != 6) {lrc = 75; if(prlc) printf(fl,lrc);}
+
+ if(lrc != 0){
+ if(pd0->flgd != 0) printf(s7813er,1);
+ rc = rc+1;
+ }
+
+ /* The && operator groups left to right. It returns 1
+ if both of the operands are nonzero; 0 otherwise.
+ It guarantees left to right evaluation; moreover, the
+ second operand is not evaluated if the value of the
+ first operand is 0.
+ */
+
+ lrc = 0;
+ i = j = 0;
+
+ r = i++ && j++;
+ if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);}
+ if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);}
+ if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);}
+ r = i && j++;
+ if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);}
+ if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);}
+ if(r!=0) {lrc = 6; if(prlc) printf(fl,lrc);}
+ r = i-- && j;
+ if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);}
+ if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);}
+ if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);}
+ r = i && j--;
+ if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);}
+ if(j!=1) {lrc = 11; if(prlc) printf(fl,lrc);}
+ if(r!=0) {lrc = 12; if(prlc) printf(fl,lrc);}
+
+ if(lrc!=0){
+ if(pd0->flgd != 0) printf(s7813er,2);
+ rc = rc+2;
+ }
+
+ /* The || operator groups left to right. It returns 1
+ if either of its operands is nonzero; 0 otherwise. It
+ guarantees left to right evaluation; moreover, the second
+ operand is not evaluated if the value of the first
+ operand is nonzero.
+ */
+
+ lrc = 0;
+ i = j = 0;
+ r = i++ || j;
+ if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);}
+ if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);}
+ if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);}
+ r = j++ || i;
+ if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);}
+ if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);}
+ if(r!=1) {lrc = 6; if(prlc) printf(fl,lrc);}
+ r = i-- || j--;
+ if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);}
+ if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);}
+ if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);}
+ r = i || j--;
+ if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);}
+ if(j!=0) {lrc = 11; if(prlc) printf(fl,lrc);}
+ if(r!=1) {lrc = 12; if(prlc) printf(fl,lrc);}
+
+ if(lrc!=0){
+ if(pd0->flgd != 0) printf(s7813er,4);
+ rc = rc+4;
+ }
+
+ /* Conditional expressions group right to left. */
+
+ i = j = 0;
+ zero = 0;
+ one = 1;
+ r = one?zero:one?i++:j++;
+ if(r!=0 || i!=0 || j!=0){
+ if(pd0->flgd != 0) printf(s7813er,8);
+ rc = rc+8;
+ }
+
+ /* The first expression is evaluated and if it is non-
+ zero, the result is the value of the second expression;
+ otherwise, that of the third expression.
+ */
+
+ if((one?zero:1) != 0 || (zero?1:zero) != 0){
+ if(pd0->flgd != 0) printf(s7813er,16);
+ rc = rc+16;
+ }
+ return rc;
+}
+
+/*********************************************************************************************
+ 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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq81.c b/test/val/cq81.c
new file mode 100644
index 000000000..198cbc4f6
--- /dev/null
+++ b/test/val/cq81.c
@@ -0,0 +1,727 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 8.1: storage class specifiers
+ !!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 */
+
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+regc();
+regp();
+regi();
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s81(pd0) /* 8.1 Storage Class Specifiers */
+struct defs *pd0;
+#else
+int s81(struct defs *pd0)
+#endif
+{
+ static char s81er[] = "s81,er%d\n";
+ static char qs81[8] = "s81 ";
+ char *ps, *pt;
+ int k, rc, j, crc, prc, irc;
+ register char rchar;
+ char nrchar;
+ register int *rptr;
+ int *nrptr;
+ register int rint;
+ int nrint;
+ static char badtest[] = "Register count for %s is unreliable.\n";
+ static char goodtest[] = "%d registers assigned to %s variables.\n";
+
+ rc = 0;
+ crc = 0;
+ prc = 0;
+ irc = 0;
+ ps = qs81;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+/* The storage class specifiers are:
+
+ auto
+ static
+ extern
+ register
+ typedef
+
+ The first three of these were treated earlier, in s4. The last
+ will be checked in s88. "Register" remains.
+
+ There are three flavors of register, viz., char, int and pointer.
+ We wish first to ascertain that the representations as register
+ are consistent with the corresponding nonregister representations.
+ */
+
+ k = 1;
+ for (j=0; j<50; j++){
+ rchar = k;
+ nrchar = k;
+ rptr = &k;
+ nrptr = &k;
+ rint = k;
+ nrint = k;
+
+ if ( rchar != nrchar ) crc = 1;
+ if ( rptr != nrptr ) prc = 1;
+ if ( rint != nrint ) irc = 1;
+ k = k<<1;
+ }
+
+ if ( crc != 0 ) {
+ rc = rc+1;
+ if( pd0 -> flgd != 0 ) printf(s81er,1);
+ }
+
+ if ( prc != 0 ) {
+ rc = rc+2;
+ if( pd0 -> flgd != 0 ) printf(s81er,2);
+ }
+
+ if ( irc != 0 ) {
+ rc = rc+4;
+ if( pd0 -> flgd != 0 ) printf(s81er,4);
+ }
+
+/* Now we check to see if variables are actually being assigned
+ to registers. */
+
+ k = regc();
+ if ( pd0->flgm != 0 ) {
+ if ( k < 0 ) printf(badtest,"char");
+ else printf(goodtest,k,"char");
+ }
+
+ k = regp();
+ if ( pd0->flgm != 0 ) {
+ if ( k<0 ) printf(badtest,"pointer");
+ else printf(goodtest,k,"pointer");
+ }
+
+ k = regi();
+ if ( pd0->flgm != 0 ) {
+ if ( k<0 ) printf(badtest,"int");
+ else printf(goodtest,k,"int");
+ }
+
+ return rc;
+}
+regc() { /* char to register assignment */
+/* Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be
+bunched together and ordered according to one of the following
+criteria:
+
+ (a) the order in which they were defined.
+ (b) the order in which they are used.
+ (c) alphabetically.
+ (d) the order in which they appear in the compiler's
+ symbol table.
+ (e) some other way.
+
+ Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid. */
+
+ char r00;
+ char r01;
+ char r02;
+ char r03;
+ register char r04;
+ char r05;
+ register char r06;
+ char r07;
+ register char r08;
+ char r09;
+ register char r10;
+ char r11;
+ register char r12;
+ char r13;
+ register char r14;
+ char r15;
+ register char r16;
+ char r17;
+ register char r18;
+ char r19;
+ register char r20;
+ char r21;
+ register char r22;
+ char r23;
+ register char r24;
+ char r25;
+ register char r26;
+ char r27;
+ register char r28;
+ char r29;
+ register char r30;
+ char r31;
+ register char r32;
+ char r33;
+ register char r34;
+ char r35;
+ char r36;
+ char r37;
+ char r38;
+
+ int s, n1, n2, nr, j, d[22];
+ r00 = 0;
+ r01 = 1;
+ r02 = 2;
+ r03 = 3;
+ r04 = 4;
+ r05 = 5;
+ r06 = 6;
+ r07 = 7;
+ r08 = 8;
+ r09 = 9;
+ r10 = 10;
+ r11 = 11;
+ r12 = 12;
+ r13 = 13;
+ r14 = 14;
+ r15 = 15;
+ r16 = 16;
+ r17 = 17;
+ r18 = 18;
+ r19 = 19;
+ r20 = 20;
+ r21 = 21;
+ r22 = 22;
+ r23 = 23;
+ r24 = 24;
+ r25 = 25;
+ r26 = 26;
+ r27 = 27;
+ r28 = 28;
+ r29 = 29;
+ r30 = 30;
+ r31 = 31;
+ r32 = 32;
+ r33 = 33;
+ r34 = 34;
+ r35 = 35;
+ r36 = 36;
+ r37 = 37;
+ r38 = 38;
+
+ d[0] = &r01 - &r00;
+ d[1] = &r02 - &r01;
+ d[2] = &r03 - &r02;
+ d[3] = &r05 - &r03;
+ d[4] = &r07 - &r05;
+ d[5] = &r09 - &r07;
+ d[6] = &r11 - &r09;
+ d[7] = &r13 - &r11;
+ d[8] = &r15 - &r13;
+ d[9] = &r17 - &r15;
+ d[10] = &r19 - &r17;
+ d[11] = &r21 - &r19;
+ d[12] = &r23 - &r21;
+ d[13] = &r25 - &r23;
+ d[14] = &r27 - &r25;
+ d[15] = &r29 - &r27;
+ d[16] = &r31 - &r29;
+ d[17] = &r33 - &r31;
+ d[18] = &r35 - &r33;
+ d[19] = &r36 - &r35;
+ d[20] = &r37 - &r36;
+ d[21] = &r38 - &r37;
+
+/* The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs,
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable. */
+
+ n1 = d[0];
+ s = 1;
+
+ for (j=0; j<22; j++)
+ switch (s) {
+ case 1: if (d[j] != n1) {
+ n2 = d[j];
+ s = 2;
+ nr = 1;
+ }
+ break;
+ case 2: if (d[j] == n1) {
+ s = 3;
+ break;
+ }
+ if (d[j] == n2) {
+ nr = nr+1;
+ break;
+ }
+ s = 4;
+ break;
+ case 3: if (d[j] != n1) s = 4;
+ break;
+ }
+ ;
+
+ if (s == 3) return 16-nr;
+ else return -1;
+}
+regi() { /* int to register assignment */
+/* Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be
+bunched together and ordered according to one of the following
+criteria:
+
+ (a) the order in which they were defined.
+ (b) the order in which they are used.
+ (c) alphabetically.
+ (d) the order in which they appear in the compiler's
+ symbol table.
+ (e) some other way.
+
+ Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid. */
+
+ int r00;
+ int r01;
+ int r02;
+ int r03;
+ register int r04;
+ int r05;
+ register int r06;
+ int r07;
+ register int r08;
+ int r09;
+ register int r10;
+ int r11;
+ register int r12;
+ int r13;
+ register int r14;
+ int r15;
+ register int r16;
+ int r17;
+ register int r18;
+ int r19;
+ register int r20;
+ int r21;
+ register int r22;
+ int r23;
+ register int r24;
+ int r25;
+ register int r26;
+ int r27;
+ register int r28;
+ int r29;
+ register int r30;
+ int r31;
+ register int r32;
+ int r33;
+ register int r34;
+ int r35;
+ int r36;
+ int r37;
+ int r38;
+
+ int s, n1, n2, nr, j, d[22];
+
+ r00 = 0;
+ r01 = 1;
+ r02 = 2;
+ r03 = 3;
+ r04 = 4;
+ r05 = 5;
+ r06 = 6;
+ r07 = 7;
+ r08 = 8;
+ r09 = 9;
+ r10 = 10;
+ r11 = 11;
+ r12 = 12;
+ r13 = 13;
+ r14 = 14;
+ r15 = 15;
+ r16 = 16;
+ r17 = 17;
+ r18 = 18;
+ r19 = 19;
+ r20 = 20;
+ r21 = 21;
+ r22 = 22;
+ r23 = 23;
+ r24 = 24;
+ r25 = 25;
+ r26 = 26;
+ r27 = 27;
+ r28 = 28;
+ r29 = 29;
+ r30 = 30;
+ r31 = 31;
+ r32 = 32;
+ r33 = 33;
+ r34 = 34;
+ r35 = 35;
+ r36 = 36;
+ r37 = 37;
+ r38 = 38;
+
+ d[0] = &r01 - &r00;
+ d[1] = &r02 - &r01;
+ d[2] = &r03 - &r02;
+ d[3] = &r05 - &r03;
+ d[4] = &r07 - &r05;
+ d[5] = &r09 - &r07;
+ d[6] = &r11 - &r09;
+ d[7] = &r13 - &r11;
+ d[8] = &r15 - &r13;
+ d[9] = &r17 - &r15;
+ d[10] = &r19 - &r17;
+ d[11] = &r21 - &r19;
+ d[12] = &r23 - &r21;
+ d[13] = &r25 - &r23;
+ d[14] = &r27 - &r25;
+ d[15] = &r29 - &r27;
+ d[16] = &r31 - &r29;
+ d[17] = &r33 - &r31;
+ d[18] = &r35 - &r33;
+ d[19] = &r36 - &r35;
+ d[20] = &r37 - &r36;
+ d[21] = &r38 - &r37;
+
+/* The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs,
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable. */
+
+ n1 = d[0];
+ s = 1;
+
+ for (j=0; j<22; j++)
+ switch (s) {
+ case 1: if (d[j] != n1) {
+ n2 = d[j];
+ s = 2;
+ nr = 1;
+ }
+ break;
+ case 2: if (d[j] == n1) {
+ s = 3;
+ break;
+ }
+ if (d[j] == n2) {
+ nr = nr+1;
+ break;
+ }
+ s = 4;
+ break;
+ case 3: if (d[j] != n1) s = 4;
+ break;
+ }
+ ;
+
+ if (s == 3) return 16-nr;
+ else return -1;
+}
+regp() { /* pointer to register assignment */
+/* Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be
+bunched together and ordered according to one of the following
+criteria:
+
+ (a) the order in which they were defined.
+ (b) the order in which they are used.
+ (c) alphabetically.
+ (d) the order in which they appear in the compiler's
+ symbol table.
+ (e) some other way.
+
+ Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid. */
+
+ int *r00;
+ int *r01;
+ int *r02;
+ int *r03;
+ register int *r04;
+ int *r05;
+ register int *r06;
+ int *r07;
+ register int *r08;
+ int *r09;
+ register int *r10;
+ int *r11;
+ register int *r12;
+ int *r13;
+ register int *r14;
+ int *r15;
+ register int *r16;
+ int *r17;
+ register int *r18;
+ int *r19;
+ register int *r20;
+ int *r21;
+ register int *r22;
+ int *r23;
+ register int *r24;
+ int *r25;
+ register int *r26;
+ int *r27;
+ register int *r28;
+ int *r29;
+ register int *r30;
+ int *r31;
+ register int *r32;
+ int *r33;
+ register int *r34;
+ int *r35;
+ int *r36;
+ int *r37;
+ int *r38;
+
+ int s, n1, n2, nr, j, d[22];
+
+ r00 = (int *)&r00;
+ r01 = (int *)&r01;
+ r02 = (int *)&r02;
+ r03 = (int *)&r03;
+ r04 = (int *)&r05;
+ r05 = (int *)&r05;
+ r06 = (int *)&r07;
+ r07 = (int *)&r07;
+ r08 = (int *)&r09;
+ r09 = (int *)&r09;
+ r10 = (int *)&r11;
+ r11 = (int *)&r11;
+ r12 = (int *)&r13;
+ r13 = (int *)&r13;
+ r14 = (int *)&r15;
+ r15 = (int *)&r15;
+ r16 = (int *)&r17;
+ r17 = (int *)&r17;
+ r18 = (int *)&r19;
+ r19 = (int *)&r19;
+ r20 = (int *)&r21;
+ r21 = (int *)&r21;
+ r22 = (int *)&r23;
+ r23 = (int *)&r23;
+ r24 = (int *)&r25;
+ r25 = (int *)&r25;
+ r26 = (int *)&r27;
+ r27 = (int *)&r27;
+ r28 = (int *)&r29;
+ r29 = (int *)&r29;
+ r30 = (int *)&r31;
+ r31 = (int *)&r31;
+ r32 = (int *)&r33;
+ r33 = (int *)&r33;
+ r34 = (int *)&r35;
+ r35 = (int *)&r35;
+ r36 = (int *)&r36;
+ r37 = (int *)&r37;
+ r38 = (int *)&r38;
+
+ d[0] = &r01 - &r00;
+ d[1] = &r02 - &r01;
+ d[2] = &r03 - &r02;
+ d[3] = &r05 - &r03;
+ d[4] = &r07 - &r05;
+ d[5] = &r09 - &r07;
+ d[6] = &r11 - &r09;
+ d[7] = &r13 - &r11;
+ d[8] = &r15 - &r13;
+ d[9] = &r17 - &r15;
+ d[10] = &r19 - &r17;
+ d[11] = &r21 - &r19;
+ d[12] = &r23 - &r21;
+ d[13] = &r25 - &r23;
+ d[14] = &r27 - &r25;
+ d[15] = &r29 - &r27;
+ d[16] = &r31 - &r29;
+ d[17] = &r33 - &r31;
+ d[18] = &r35 - &r33;
+ d[19] = &r36 - &r35;
+ d[20] = &r37 - &r36;
+ d[21] = &r38 - &r37;
+
+/* The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs,
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable. */
+
+ n1 = d[0];
+ s = 1;
+ for (j=0; j<22; j++)
+ switch (s) {
+ case 1: if (d[j] != n1) {
+ n2 = d[j];
+ s = 2;
+ nr = 1;
+ }
+ break;
+ case 2: if (d[j] == n1) {
+ s = 3;
+ break;
+ }
+ if (d[j] == n2) {
+ nr = nr+1;
+ break;
+ }
+ s = 4;
+ break;
+ case 3: if (d[j] != n1) s = 4;
+ break;
+ }
+ ;
+
+ if (s == 3) return 16-nr;
+ else return -1;
+}
+
+/*********************************************************************************************
+ 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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq84.c b/test/val/cq84.c
new file mode 100644
index 000000000..fcadd9af6
--- /dev/null
+++ b/test/val/cq84.c
@@ -0,0 +1,268 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 8.4: meaning of declarators
+ !!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 */
+
+#ifdef NO_SLOPPY_EXTERN
+ int *fip(int x);
+ int array(int a[],int size,int start);
+ int glork(int x);
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s84(pd0) /* 8.4 Meaning of declarators */
+struct defs *pd0;
+{
+#else
+int s84(struct defs *pd0){
+#endif
+#ifndef NO_SLOPPY_EXTERN
+ int *ip, i, *fip(), (*pfi)(), j, k, array(), glork();
+#else
+ int *ip, i, j, k,(*pfi)();
+/*
+ extern int
+ *fip(),
+ array(),
+ glork();
+ int *fip(int x);
+ int array(int a[],int size,int start);
+*/
+#endif
+ static int x3d[3][5][7];
+ #ifndef NO_FLOATS
+ float fa[17], *afp[17], sum;
+ #else
+ signed fa[17], *afp[17], sum;
+ #endif
+ static char s84er[] = "s84,er%d\n";
+ static char qs84[8] = "s84 ";
+ int rc;
+ char *ps, *pt;
+ ps = qs84;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* The more common varieties of declarators have al-
+ ready been touched upon, some more than others. It
+ is useful to compare *fip() and (*pfi)().
+ */
+
+ ip = fip(3);
+ if(*ip != 3){
+ if(pd0->flgd != 0) printf(s84er,1);
+ rc = rc+1;
+ }
+
+ /* 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; i<size; i++)
+ if(a[i] != i+start) return 1;
+
+ return 0;
+}
+#ifndef NO_OLD_FUNC_DECL
+int *fip(x)
+int x;
+{
+#else
+int *fip(int x){
+#endif
+ static int y;
+ y = x;
+ return &y;
+}
+#ifndef NO_OLD_FUNC_DECL
+glork(x)
+int x;
+{
+#else
+int glork(int x){
+#endif
+return x;}
+
+/*********************************************************************************************
+ 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 s84(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<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq85.c b/test/val/cq85.c
new file mode 100644
index 000000000..3e5ef938d
--- /dev/null
+++ b/test/val/cq85.c
@@ -0,0 +1,313 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 8.5: Structure and Union declarations
+ !!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 */
+
+#ifndef NO_OLD_FUNC_DECL
+s85(pd0) /* 8.5 Structure and union declarations */
+struct defs *pd0;
+{
+#else
+int s85(struct defs *pd0){
+#endif
+ static char s85er[] = "s85,er%d\n";
+ static char qs85[8] = "s85 ";
+ int rc;
+ char *ps, *pt;
+
+ struct tnode {
+ char tword[20];
+ int count;
+ struct tnode *left;
+ struct tnode *right;
+ };
+
+ struct tnode s1, s2, *sp;
+
+ struct{
+ char cdummy;
+ char c;
+ } sc;
+
+ struct{
+ char cdummy;
+ short s;
+ } ss;
+
+ struct{
+ char cdummy;
+ int i;
+ } si;
+
+ struct{
+ char cdummy;
+ long l;
+ } sl;
+
+ struct{
+ char cdummy;
+ unsigned u;
+ } su;
+
+ struct{
+ char cdummy;
+ #ifndef NO_FLOATS
+ float f;
+ #else
+ signed f;
+ #endif
+ } sf;
+
+ struct{
+ char cdummy;
+ #ifndef NO_FLOATS
+ double d;
+ #else
+ signed d;
+ #endif
+ } sd;
+
+ int diff[7], j;
+
+ static char *type[] = {
+ "char",
+ "short",
+ "int",
+ "long",
+ "unsigned",
+ #ifdef NO_FLOATS
+ "signed",
+ "signed",
+ #else
+ "float",
+ "double"
+ #endif
+ };
+
+ static char aln[] = " alignment: ";
+
+ #ifndef NO_BITFIELDS
+ struct{
+ int twobit:2;
+ int :1;
+ int threebit:3;
+ int onebit:1;
+ } s3;
+ #else
+ struct{
+ unsigned char twobit;
+ unsigned char threebit;
+ unsigned char onebit;
+ } s3;
+ #endif
+
+ union{
+ char u1[30];
+ short u2[30];
+ int u3[30];
+ long u4[30];
+ unsigned u5[30];
+ #ifndef NO_FLOATS
+ float u6[30];
+ double u7[30];
+ #else
+ signed u6[30];
+ signed u7[30];
+ #endif
+ } u0;
+
+ ps = qs85;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* Within a structure, the objects declared have
+ addresses which increase as their declarations are
+ read left to right.
+ */
+
+ if( (char *)&s1.count - &s1.tword[0] <= 0
+ ||(char *)&s1.left - (char *)&s1.count <= 0
+ ||(char *)&s1.right - (char *)&s1.left <= 0){
+ if(pd0->flgd != 0) printf(s85er,1);
+ rc = rc+1;
+ }
+
+ /* Each non-field member of a structure begins on an
+ addressing boundary appropriate to its type.
+ */
+
+ diff[0] = &sc.c - &sc.cdummy;
+ diff[1] = (char *)&ss.s - &ss.cdummy;
+ diff[2] = (char *)&si.i - &si.cdummy;
+ diff[3] = (char *)&sl.l - &sl.cdummy;
+ diff[4] = (char *)&su.u - &su.cdummy;
+ diff[5] = (char *)&sf.f - &sf.cdummy;
+ diff[6] = (char *)&sd.d - &sd.cdummy;
+
+ if(pd0->flgm != 0)
+ for(j=0; j<7; j++)
+ printf("%s%s%d\n",type[j],aln,diff[j]);
+
+ /* Field specifications are highly implementation de-
+ pendent. About the only thing we can do here is to
+ check is that the compiler accepts the field constructs,
+ and that they seem to work, after a fashion, at
+ run time...
+ */
+
+ s3.threebit = 7;
+ s3.twobit = s3.threebit;
+ s3.threebit = s3.twobit;
+
+ if(s3.threebit != 3){
+ if(s3.threebit == -1){
+ if(pd0->flgm != 0) printf("Sign extension in fields\n");
+ }
+ else{
+ #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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq86.c b/test/val/cq86.c
new file mode 100644
index 000000000..2800307f7
--- /dev/null
+++ b/test/val/cq86.c
@@ -0,0 +1,228 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 8.6: Initialization
+ !!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 */
+
+#ifdef NO_LOCAL_PROTOTYPES
+int one();
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s86(pd0) /* 8.6 Initialization */
+struct defs *pd0;
+{
+#else
+int s86(struct defs *pd0){
+#endif
+ static char s86er[] = "s86,er%d\n";
+ static char qs86[8] = "s86 ";
+ int lrc, rc;
+ char *ps, *pt;
+ #ifndef NO_LOCAL_PROTOTYPES
+ int one();
+ #endif
+ int i, j, k;
+ static int x[] = {1,3,5};
+ static int *pint = x+2;
+ static int zero[10];
+ int *apint = pint-1;
+ register int *rpint = apint+one();
+
+ #ifndef NO_FLOATS
+ static float y0[] = {1,3,5,2,4,6,3,5,7,0,0,0};
+ static float y1[4][3] = {
+ {1,3,5},
+ {2,4,6},
+ {3,5,7},
+ };
+ static float y2[4][3] = {1,3,5,2,4,6,3,5,7};
+ static float y3[4][3] = {
+ {1},{2},{3},{4}
+ };
+ #else
+ static signed y0[] = {1,3,5,2,4,6,3,5,7,0,0,0};
+ static signed y1[4][3] = {
+ {1,3,5},
+ {2,4,6},
+ {3,5,7},
+ };
+ #ifndef NO_SLOPPY_STRUCT_INIT
+ static signed y2[4][3] = {1,3,5,2,4,6,3,5,7};
+ #else
+ static signed y2[4][3] = {{1,3,5},{2,4,6},{3,5,7}};
+ #endif
+ static signed y3[4][3] = {
+ {1},{2},{3},{4}
+ };
+ #endif
+
+ ps = qs86;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* The expression in an initializer for a static or
+ external variable must be a constant expression or
+ an expression that reduces to the address of a pre-
+ viously declared variable, possibly offset by a
+ constant expression.
+ */
+
+ if(*pint != 5){
+ if(pd0->flgd != 0) printf(s86er,1);
+ rc = rc+1;
+ }
+
+ /* Automatic and register variables may be initialized
+ by arbitrary expressions involving constants and previously
+ declared variables and functions.
+ */
+
+ if(*apint != 3){
+ if(pd0->flgd != 0) printf(s86er,2);
+ rc = rc+2;
+ }
+
+ if(*rpint != 5){
+ if(pd0->flgd != 0) printf(s86er,4);
+ rc = rc+4;
+ }
+
+ /* Static variables that are not initialized are guar-
+ anteed to start off as zero.
+ */
+
+ lrc = 0;
+ for(j=0; j<10; j++)
+ if(zero[j] != 0) lrc = 1;
+ if(lrc != 0){
+ if(pd0->flgd != 0) printf(s86er,8);
+ rc = rc+8;
+ }
+
+ /* y0, y1, and y2, as declared, should define and
+ initialize identical arrays.
+ */
+ lrc = 0;
+ for(i=0; i<4; i++)
+ for(j=0; j<3; j++){
+ k = 3*i+j;
+ if( y1[i][j] != y2[i][j]
+ ||y1[i][j] != y0[k]) lrc = 1;
+ }
+
+ if(lrc != 0){
+ if(pd0->flgd != 0) printf(s86er,16);
+ rc = rc+16;
+ }
+
+ /* y3 initializes the first column of the array and
+ leaves the rest zero.
+ */
+
+ lrc = 0;
+ for(j=0; j<4; j++) if(y3[j][0] != j+1) lrc = 1;
+
+ if(lrc != 0){
+ if(pd0->flgd != 0) printf(s86er,32);
+ rc = rc+32;
+ }
+ return rc;
+}
+#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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq88.c b/test/val/cq88.c
new file mode 100644
index 000000000..77bb9e88c
--- /dev/null
+++ b/test/val/cq88.c
@@ -0,0 +1,184 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 8.8: typedef
+ !!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 */
+
+one(){
+ return 1;
+}
+int *metricp;
+#ifndef NO_OLD_FUNC_DECL
+s88(pd0) /* 8.8 Typedef */
+struct defs *pd0;
+{
+#else
+int s88(struct defs *pd0){
+#endif
+ static char s88er[] = "s88,er%d\n";
+ static char qs88[8] = "s88 ";
+ int rc;
+ char *ps, *pt;
+
+ /* Declarations whose "storage class" is typdef do not
+ define storage, but instead define identifiers which
+ can later be used as if they were type keywords naming
+ fundamental or derived types.
+ */
+
+ typedef int MILES, *KLICKSP;
+
+ #ifndef NO_FLOATS
+ typedef struct {double re, im;} complex;
+ #else
+ typedef struct {signed re, im;} complex;
+ #endif
+
+ MILES distance;
+ #ifndef NO_SLOPPY_EXTERN
+ extern KLICKSP metricp;
+ #else
+ KLICKSP metricp;
+ #endif
+ complex z, *zp;
+
+ ps = qs88;
+ pt = pd0->rfs;
+ rc = 0;
+ while(*pt++ = *ps++);
+
+ /* Hopefully, all of this stuff will compile. After that,
+ we can only make some superficial tests.
+
+ The type of distance is int,
+ */
+
+ if(sizeof distance != sizeof(int)){
+ if(pd0->flgd != 0) printf(s88er,1);
+ rc = rc+1;
+ }
+
+ /* that of metricp is "pointer to int", */
+
+ metricp = &distance;
+ distance = 2;
+ *metricp = 3;
+
+ if(distance != 3){
+ if(pd0->flgd != 0) printf(s88er,2);
+ rc = rc+2;
+ }
+
+ /* and that of z is the specified structure. zp is a
+ pointer to such a structure.
+ */
+
+ #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; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/cq9.c b/test/val/cq9.c
new file mode 100644
index 000000000..698443ce6
--- /dev/null
+++ b/test/val/cq9.c
@@ -0,0 +1,154 @@
+/*
+ !!DESCRIPTION!! C-Manual Chapter 9: Statements
+ !!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 */
+
+#ifndef NO_OLD_FUNC_DECL
+s9(pd0) /* 9 Statements */
+struct defs *pd0;
+{
+#else
+int s9(struct defs *pd0){
+#endif
+ static char s9er[] = "s9,er%d\n";
+ static char qs9[8] = "s9 ";
+ int rc;
+ char *ps, *pt;
+ int lrc, i;
+
+ ps = qs9;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* One would think that the section on statements would
+ provide the most variety in the entire sequence of tests.
+ As it turns out, most of the material in this section has
+ already been checked in the process of checking out
+ everything else, and the section at this point is somewhat
+ anticlimactic. For this reason, we restrict ourselves
+ to testing two features not already covered.
+
+ Compound statements are delimited by braces. They have the
+ nice property that identifiers of the auto and register
+ variety are pushed and popped. It is currently legal to
+ transfer into a block, but we wont...
+ */
+
+ lrc = 0;
+ for(i=0; i<2; i++){
+ int j;
+ register int k;
+ j = k = 2;
+ {
+ int j;
+ register int k;
+ j = k = 3;
+ if((j != 3) || (k != 3)) lrc = 1;
+ }
+ if((j != 2) || (k != 2)) lrc = 1;
+ }
+
+ if(lrc != 0){
+ if(pd0->flgd != 0) printf(s9er,1);
+ rc = rc+1;
+ }
+
+ /* Goto statements go to labeled statements, we hope. */
+
+ goto nobarf;
+ if(pd0->flgd != 0) printf(s9er,2);
+ rc = rc+2;
+ nobarf:;
+
+ return rc;
+}
+
+/*********************************************************************************************
+ 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<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
diff --git a/test/val/for.c b/test/val/for.c
new file mode 100644
index 000000000..58a608611
--- /dev/null
+++ b/test/val/for.c
@@ -0,0 +1,109 @@
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+#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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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<sizeof(buff); c++)
+ buff[c] = start_value++;
+}
+
+void check_array(char base_value)
+{
+ unsigned char c;
+
+ for(c=0; c<sizeof(buff); c++)
+ if(buff[c] != (base_value+c))
+ failures++;
+}
+
+void index_by_pointer(unsigned char *index, unsigned char expected_value)
+{
+ if(buff[*index] != expected_value)
+ failures++;
+}
+
+int
+main (void)
+{
+ init_array(4);
+ check_array(4);
+
+ if(buff[achar0 + 7] != 4+7)
+ failures++;
+
+ dummy = buff[achar0];
+
+ if(dummy != 4)
+ failures++;
+
+ if(dummy != (buff[achar0+1] -1))
+ failures++;
+
+ index_by_pointer(&dummy, 8);
+
+ f1 (&achar0);
+ f2 (&aint0);
+
+ acharP = f3 ();
+ if ((acharP == 0) || (*acharP))
+ failures++;
+ achar0 = 42;
+ if(*acharP != 42)
+ failures++;
+
+ achar0 = 5;
+ f4(&achar0, achar0);
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
diff --git a/test/val/ptrfunc.c b/test/val/ptrfunc.c
new file mode 100644
index 000000000..e1682507a
--- /dev/null
+++ b/test/val/ptrfunc.c
@@ -0,0 +1,136 @@
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdint.h> and <inttypes.h>
+
+ 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 <inttypes.h>.
+
+ Takes advantage of __Q8_* symbols defined by a particular
+ implementation of <stdint.h>, but doesn't require them.
+
+ NOTE: This is not a thorough validation test of the facilities.
+*/
+
+#define NO_INTERNAL_WCHAR
+/*#define STANDALONE*/
+
+#include <errno.h>
+#include <limits.h> /* for CHAR_BIT */
+#include <stdio.h>
+#include <stddef.h> /* for ptrdiff_t */
+#include <stdlib.h>
+#include <string.h>
+
+#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 <inttypes.h> /* embeds <stdint.h> */
+
+#include <signal.h> /* for sig_atomic_t */
+
+#if defined(INTMAX_MAX) /* <inttypes.h> has C99 features */
+#include <wchar.h>
+#endif
+
+#include <inttypes.h> /* 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 */
+
+
+ /* <stdint.h> 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
+
+ /* <inttypes.h> 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) /* <inttypes.h> 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+#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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+#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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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 <stdio.h>
+#include <limits.h>
+
+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;
+}
From adc5525e852ec61ea28eeaac66b47ad20e12b233 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Thu, 25 Sep 2014 18:47:23 +0200
Subject: [PATCH 02/40] added commandline option to quit after X cycles
---
src/sim65/main.c | 19 +++++++++++++++++--
1 file changed, 17 insertions(+), 2 deletions(-)
diff --git a/src/sim65/main.c b/src/sim65/main.c
index 3ed273bf8..10dbe3f91 100644
--- a/src/sim65/main.c
+++ b/src/sim65/main.c
@@ -60,7 +60,8 @@
/* Name of program file */
const char* ProgramFile;
-
+/* exit simulator after MaxCycles Cycles */
+unsigned long MaxCycles = 0;
/*****************************************************************************/
/* Code */
@@ -75,6 +76,7 @@ static void Usage (void)
" -h\t\t\tHelp (this text)\n"
" -v\t\t\tIncrease verbosity\n"
" -V\t\t\tPrint the simulator version number\n"
+ " -x <num>\t\tExit simulator after <num> cycles\n"
"\n"
"Long options:\n"
" --help\t\tHelp (this text)\n"
@@ -111,7 +113,12 @@ static void OptVersion (const char* Opt attribute ((unused)),
fprintf (stderr, "sim65 V%s\n", GetVersionAsString ());
}
-
+static void OptQuitXIns (const char* Opt attribute ((unused)),
+ const char* Arg attribute ((unused)))
+/* quit after MaxCycles cycles */
+{
+ MaxCycles = strtoul(Arg, NULL, 0);
+}
static void ReadProgramFile (void)
/* Load program into memory */
@@ -197,6 +204,10 @@ int main (int argc, char* argv[])
OptVersion (Arg, 0);
break;
+ case 'x':
+ OptQuitXIns (Arg, GetArg (&I, 2));
+ break;
+
default:
UnknownOption (Arg);
break;
@@ -225,6 +236,10 @@ int main (int argc, char* argv[])
while (1) {
ExecuteInsn ();
+ if (MaxCycles && (GetCycles () >= MaxCycles)) {
+ Error ("Maximum number of cycles reached.");
+ exit (EXIT_FAILURE);
+ }
}
/* Return an apropriate exit code */
From baaf815d8e7eac485f2c48477e32853df15e30c6 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Thu, 25 Sep 2014 23:19:14 +0200
Subject: [PATCH 03/40] fix cast to char, patch by Piotr Fusik
---
src/cc65/codegen.c | 72 +++++++++++++++++++++++++---------------------
1 file changed, 40 insertions(+), 32 deletions(-)
diff --git a/src/cc65/codegen.c b/src/cc65/codegen.c
index 6143b09fe..f6ec2f51a 100644
--- a/src/cc65/codegen.c
+++ b/src/cc65/codegen.c
@@ -1226,26 +1226,34 @@ void g_tosint (unsigned flags)
-void g_regint (unsigned Flags)
-/* Make sure, the value in the primary register an int. Convert if necessary */
+static void g_regchar (unsigned Flags)
+/* Make sure, the value in the primary register is in the range of char. Truncate if necessary */
{
unsigned L;
+ AddCodeLine ("ldx #$00");
+
+ if ((Flags & CF_UNSIGNED) == 0) {
+ /* Sign extend */
+ L = GetLocalLabel();
+ AddCodeLine ("cmp #$80");
+ AddCodeLine ("bcc %s", LocalLabelName (L));
+ AddCodeLine ("dex");
+ g_defcodelabel (L);
+ }
+}
+
+
+
+void g_regint (unsigned Flags)
+/* Make sure, the value in the primary register an int. Convert if necessary */
+{
switch (Flags & CF_TYPEMASK) {
case CF_CHAR:
if (Flags & CF_FORCECHAR) {
/* Conversion is from char */
- if (Flags & CF_UNSIGNED) {
- AddCodeLine ("ldx #$00");
- } else {
- L = GetLocalLabel();
- AddCodeLine ("ldx #$00");
- AddCodeLine ("cmp #$80");
- AddCodeLine ("bcc %s", LocalLabelName (L));
- AddCodeLine ("dex");
- g_defcodelabel (L);
- }
+ g_regchar (Flags);
}
/* FALLTHROUGH */
@@ -1263,8 +1271,6 @@ void g_regint (unsigned Flags)
void g_reglong (unsigned Flags)
/* Make sure, the value in the primary register a long. Convert if necessary */
{
- unsigned L;
-
switch (Flags & CF_TYPEMASK) {
case CF_CHAR:
@@ -1280,12 +1286,7 @@ void g_reglong (unsigned Flags)
}
} else {
if (IS_Get (&CodeSizeFactor) >= 366) {
- L = GetLocalLabel();
- AddCodeLine ("ldx #$00");
- AddCodeLine ("cmp #$80");
- AddCodeLine ("bcc %s", LocalLabelName (L));
- AddCodeLine ("dex");
- g_defcodelabel (L);
+ g_regchar (Flags);
AddCodeLine ("stx sreg");
AddCodeLine ("stx sreg+1");
} else {
@@ -1374,20 +1375,27 @@ unsigned g_typecast (unsigned lhs, unsigned rhs)
** by the lhs value. Return the result value.
*/
{
- unsigned ltype, rtype;
-
- /* Get the type spec from the flags */
- ltype = lhs & CF_TYPEMASK;
- rtype = rhs & CF_TYPEMASK;
-
/* Check if a conversion is needed */
if ((rhs & CF_CONST) == 0) {
- if (ltype == CF_LONG && rtype != CF_LONG) {
- /* We must promote the primary register to long */
- g_reglong (rhs);
- } else if (ltype == CF_INT && rtype != CF_INT) {
- /* We must promote the primary register to int */
- g_regint (rhs);
+ switch (lhs & CF_TYPEMASK) {
+
+ case CF_LONG:
+ /* We must promote the primary register to long */
+ g_reglong (rhs);
+ break;
+
+ case CF_INT:
+ /* We must promote the primary register to int */
+ g_regint (rhs);
+ break;
+
+ case CF_CHAR:
+ /* We must truncate the primary register to char */
+ g_regchar (lhs);
+ break;
+
+ default:
+ typeerror (lhs);
}
}
From ebbec9bfb7b422b58353b872c36d12af2f931a88 Mon Sep 17 00:00:00 2001
From: Oliver Schmidt <ol.sc@web.de>
Date: Mon, 3 Nov 2014 21:23:29 +0100
Subject: [PATCH 04/40] Modified doc generation to target 'doc' repository.
---
Makefile.travis | 13 ++++++-------
1 file changed, 6 insertions(+), 7 deletions(-)
diff --git a/Makefile.travis b/Makefile.travis
index 6f83e2439..9deba227c 100644
--- a/Makefile.travis
+++ b/Makefile.travis
@@ -6,19 +6,18 @@ all: gh-pages sf-files
GH_NAME = Oliver Schmidt
GH_MAIL = ol.sc@web.de
-GH_PATH = ../gh-pages
+GH_PATH = ../doc
gh-pages:
ifdef GH_TOKEN
- @echo 'git clone --branch=gh-pages https://$$(GH_TOKEN)@github.com/cc65/cc65.git $(GH_PATH)'
- @git clone --branch=gh-pages https://$(GH_TOKEN)@github.com/cc65/cc65.git $(GH_PATH)
+ @echo 'git clone --branch=gh-pages https://$$(GH_TOKEN)@github.com/cc65/doc.git $(GH_PATH)'
+ @git clone --branch=gh-pages https://$(GH_TOKEN)@github.com/cc65/doc.git $(GH_PATH)
cd $(GH_PATH) && git config user.name "$(GH_NAME)"
cd $(GH_PATH) && git config user.email "$(GH_MAIL)"
cd $(GH_PATH) && git config push.default simple
- cd $(GH_PATH) && $(RM) -r doc
- cd $(GH_PATH) && mkdir doc
- cp html/*.* $(GH_PATH)/doc
- cd $(GH_PATH) && git add -A doc
+ $(RM) $(GH_PATH)/*.*
+ cp html/*.* $(GH_PATH)
+ cd $(GH_PATH) && git add -A
-cd $(GH_PATH) && git commit -m "Updated from commit $(TRAVIS_COMMIT)."
cd $(GH_PATH) && git push
endif
From dc3167fcc82a73bea7d23a6a6a9965d8df5cf5de Mon Sep 17 00:00:00 2001
From: Oliver Schmidt <ol.sc@web.de>
Date: Mon, 3 Nov 2014 21:42:54 +0100
Subject: [PATCH 05/40] Adjusted doc URL.
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 81805f03b..198d5558c 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-[documentation](http://cc65.github.io/cc65/doc)
+[documentation](http://cc65.github.io/doc)
[wiki](https://github.com/cc65/wiki/wiki)
From b552c184054ce1a4633a2b1533ffbacb6cff2c5c Mon Sep 17 00:00:00 2001
From: Oliver Schmidt <ol.sc@web.de>
Date: Mon, 3 Nov 2014 23:21:52 +0100
Subject: [PATCH 06/40] Consistently rely on SSL redirection.
---
README.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/README.md b/README.md
index 198d5558c..bf7d6dcde 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
[documentation](http://cc65.github.io/doc)
-[wiki](https://github.com/cc65/wiki/wiki)
+[wiki](http://github.com/cc65/wiki/wiki)
-[](https://travis-ci.org/cc65/cc65/builds)
+[](http://travis-ci.org/cc65/cc65/builds)
cc65 is a complete cross development package for 65(C)02 systems, including
a powerful macro assembler, a C compiler, linker, librarian and several
From 5b55fa45006264a99b8e1eb026e728f377d82b9b Mon Sep 17 00:00:00 2001
From: Oliver Schmidt <ol.sc@web.de>
Date: Mon, 3 Nov 2014 23:31:54 +0100
Subject: [PATCH 07/40] Adjusted URL.
---
Makefile.travis | 2 +-
doc/index.sgml | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/Makefile.travis b/Makefile.travis
index 9deba227c..78ded63e6 100644
--- a/Makefile.travis
+++ b/Makefile.travis
@@ -19,7 +19,7 @@ ifdef GH_TOKEN
cp html/*.* $(GH_PATH)
cd $(GH_PATH) && git add -A
-cd $(GH_PATH) && git commit -m "Updated from commit $(TRAVIS_COMMIT)."
- cd $(GH_PATH) && git push
+ cd $(GH_PATH) && git push -q
endif
SF_USER = oliverschmidt
diff --git a/doc/index.sgml b/doc/index.sgml
index c77344865..7de8b26ce 100644
--- a/doc/index.sgml
+++ b/doc/index.sgml
@@ -2,7 +2,7 @@
<article>
<title>cc65 Documentation Overview
-<author><url url="https://github.com/cc65/cc65/">
+<author><url url="http://cc65.github.io/doc">
<date>
<sect>Program documentation<p>
From 202a2d677b46832513fe95107abf92efa3a53488 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Wed, 19 Nov 2014 22:04:32 +0100
Subject: [PATCH 08/40] starting branch for adding the missing undocumented
opcodes
---
src/ca65/instr.c | 2 +-
testcode/assembler/.gitignore | 2 +
testcode/assembler/Makefile | 19 +++
testcode/assembler/all.s | 255 ++++++++++++++++++++++++++++++++++
testcode/assembler/illegal.s | 153 ++++++++++++++++----
testcode/assembler/legal.ref | Bin 0 -> 321 bytes
testcode/assembler/legal.s | 184 ++++++++++++++++++++++++
7 files changed, 584 insertions(+), 31 deletions(-)
create mode 100644 testcode/assembler/.gitignore
create mode 100644 testcode/assembler/Makefile
create mode 100644 testcode/assembler/all.s
create mode 100644 testcode/assembler/legal.ref
create mode 100644 testcode/assembler/legal.s
diff --git a/src/ca65/instr.c b/src/ca65/instr.c
index c2482577c..9270f5601 100644
--- a/src/ca65/instr.c
+++ b/src/ca65/instr.c
@@ -783,7 +783,7 @@ static const InsTable* InsTabs[CPU_COUNT] = {
const InsTable* InsTab = (const InsTable*) &InsTab6502;
/* Table to build the effective 65xx opcode from a base opcode and an
-** addressing mode.
+** addressing mode. (The value in the table is ORed with the base opcode)
*/
static unsigned char EATab[10][AM65I_COUNT] = {
{ /* Table 0 */
diff --git a/testcode/assembler/.gitignore b/testcode/assembler/.gitignore
new file mode 100644
index 000000000..160ca9ba4
--- /dev/null
+++ b/testcode/assembler/.gitignore
@@ -0,0 +1,2 @@
+chkillegal.bin
+chklegal.bin
diff --git a/testcode/assembler/Makefile b/testcode/assembler/Makefile
new file mode 100644
index 000000000..ae08864f8
--- /dev/null
+++ b/testcode/assembler/Makefile
@@ -0,0 +1,19 @@
+
+all: chklegal.bin chkillegal.bin
+ @#
+
+.PHONY: chklegal.bin chkillegal.bin
+
+chklegal.bin: legal.s
+ ../../bin/cl65 --target none --cpu 6502X -o chklegal.bin legal.s
+ diff legal.ref chklegal.bin
+
+chkillegal.bin: illegal.s
+ ../../bin/cl65 --target none --cpu 6502X -o chkillegal.bin illegal.s
+
+ref: legal.s
+ ../../bin/cl65 --target none --cpu 6502X -o legal.ref legal.s
+
+clean:
+ rm -f legal.o chklegal.bin
+ rm -f illegal.o chkillegal.bin
diff --git a/testcode/assembler/all.s b/testcode/assembler/all.s
new file mode 100644
index 000000000..5471a2bb1
--- /dev/null
+++ b/testcode/assembler/all.s
@@ -0,0 +1,255 @@
+ brk ; 00
+ ora ($12,x) ; 01 12
+ jam ; 02
+ slo ($12,x) ; 03 12
+ noop $12 ; 04 12
+ ora $12 ; 05 12
+ asl $12 ; 06 12
+ slo $12 ; 07 12
+ php ; 08
+ ora #$12 ; 09 12
+ asl a ; 0a
+ anc #$12 ; 0b 12
+ noop $1234 ; 0c 34 12
+ ora $1234 ; 0d 34 12
+ asl $1234 ; 0e 34 12
+ slo $1234 ; 0f 34 12
+ bpl $101c ; 10 12
+ ora ($12),y ; 11 12
+ jam ; 12
+ slo ($12),y ; 13 12
+ noop $12,x ; 14 12
+ ora $12,x ; 15 12
+ asl $12,x ; 16 12
+ slo $12,x ; 17 12
+ clc ; 18
+ ora $1234,y ; 19 34 12
+ noop ; 1a
+ slo $1234,y ; 1b 34 12
+ noop $1234,x ; 1c 34 12
+ ora $1234,x ; 1d 34 12
+ asl $1234,x ; 1e 34 12
+ slo $1234,x ; 1f 34 12
+ jsr $1234 ; 20 34 12
+ and ($12,x) ; 21 12
+ jam ; 22
+ rla ($12,x) ; 23 12
+ bit $12 ; 24 12
+ and $12 ; 25 12
+ rol $12 ; 26 12
+ rla $12 ; 27 12
+ plp ; 28
+ and #$12 ; 29 12
+ rol a ; 2a
+ anc #$12 ; 2b 12
+ bit $1234 ; 2c 34 12
+ and $1234 ; 2d 34 12
+ rol $1234 ; 2e 34 12
+ rla $1234 ; 2f 34 12
+ bmi $107c ; 30 12
+ and ($12),y ; 31 12
+ jam ; 32
+ rla ($12),y ; 33 12
+ noop $12,x ; 34 12
+ and $12,x ; 35 12
+ rol $12,x ; 36 12
+ rla $12,x ; 37 12
+ sec ; 38
+ and $1234,y ; 39 34 12
+ noop ; 3a
+ rla $1234,y ; 3b 34 12
+ noop $1234,x ; 3c 34 12
+ and $1234,x ; 3d 34 12
+ rol $1234,x ; 3e 34 12
+ rla $1234,x ; 3f 34 12
+ rti ; 40
+ eor ($12,x) ; 41 12
+ jam ; 42
+ sre ($12,x) ; 43 12
+ noop $12 ; 44 12
+ eor $12 ; 45 12
+ lsr $12 ; 46 12
+ sre $12 ; 47 12
+ pha ; 48
+ eor #$12 ; 49 12
+ lsr a ; 4a
+ asr #$12 ; 4b 12
+ jmp $1234 ; 4c 34 12
+ eor $1234 ; 4d 34 12
+ lsr $1234 ; 4e 34 12
+ sre $1234 ; 4f 34 12
+ bvc $10dc ; 50 12
+ eor ($12),y ; 51 12
+ jam ; 52
+ sre ($12),y ; 53 12
+ noop $12,x ; 54 12
+ eor $12,x ; 55 12
+ lsr $12,x ; 56 12
+ sre $12,x ; 57 12
+ cli ; 58
+ eor $1234,y ; 59 34 12
+ noop ; 5a
+ sre $1234,y ; 5b 34 12
+ noop $1234,x ; 5c 34 12
+ eor $1234,x ; 5d 34 12
+ lsr $1234,x ; 5e 34 12
+ sre $1234,x ; 5f 34 12
+ rts ; 60
+ adc ($12,x) ; 61 12
+ jam ; 62
+ rra ($12,x) ; 63 12
+ noop $12 ; 64 12
+ adc $12 ; 65 12
+ ror $12 ; 66 12
+ rra $12 ; 67 12
+ pla ; 68
+ adc #$12 ; 69 12
+ ror a ; 6a
+ arr #$12 ; 6b 12
+ jmp ($1234) ; 6c 34 12
+ adc $1234 ; 6d 34 12
+ ror $1234 ; 6e 34 12
+ rra $1234 ; 6f 34 12
+ bvs $113c ; 70 12
+ adc ($12),y ; 71 12
+ jam ; 72
+ rra ($12),y ; 73 12
+ noop $12,x ; 74 12
+ adc $12,x ; 75 12
+ ror $12,x ; 76 12
+ rra $12,x ; 77 12
+ sei ; 78
+ adc $1234,y ; 79 34 12
+ noop ; 7a
+ rra $1234,y ; 7b 34 12
+ noop $1234,x ; 7c 34 12
+ adc $1234,x ; 7d 34 12
+ ror $1234,x ; 7e 34 12
+ rra $1234,x ; 7f 34 12
+ noop #$12 ; 80 12
+ sta ($12,x) ; 81 12
+ noop #$12 ; 82 12
+ sax ($12,x) ; 83 12
+ sty $12 ; 84 12
+ sta $12 ; 85 12
+ stx $12 ; 86 12
+ sax $12 ; 87 12
+ dey ; 88
+ noop #$12 ; 89 12
+ txa ; 8a
+ ane #$12 ; 8b 12
+ sty $1234 ; 8c 34 12
+ sta $1234 ; 8d 34 12
+ stx $1234 ; 8e 34 12
+ sax $1234 ; 8f 34 12
+ bcc $119c ; 90 12
+ sta ($12),y ; 91 12
+ jam ; 92
+ sha ($12),y ; 93 12
+ sty $12,x ; 94 12
+ sta $12,x ; 95 12
+ stx $12,y ; 96 12
+ sax $12,y ; 97 12
+ tya ; 98
+ sta $1234,y ; 99 34 12
+ txs ; 9a
+ shs $1234,y ; 9b 34 12
+ shy $1234,x ; 9c 34 12
+ sta $1234,x ; 9d 34 12
+ shx $1234,y ; 9e 34 12
+ sha $1234,y ; 9f 34 12
+ ldy #$12 ; a0 12
+ lda ($12,x) ; a1 12
+ ldx #$12 ; a2 12
+ lax ($12,x) ; a3 12
+ ldy $12 ; a4 12
+ lda $12 ; a5 12
+ ldx $12 ; a6 12
+ lax $12 ; a7 12
+ tay ; a8
+ lda #$12 ; a9 12
+ tax ; aa
+ lxa #$12 ; ab 12
+ ldy $1234 ; ac 34 12
+ lda $1234 ; ad 34 12
+ ldx $1234 ; ae 34 12
+ lax $1234 ; af 34 12
+ bcs $11fc ; b0 12
+ lda ($12),y ; b1 12
+ jam ; b2
+ lax ($12),y ; b3 12
+ ldy $12,x ; b4 12
+ lda $12,x ; b5 12
+ ldx $12,y ; b6 12
+ lax $12,y ; b7 12
+ clv ; b8
+ lda $1234,y ; b9 34 12
+ tsx ; ba
+ las $1234,y ; bb 34 12
+ ldy $1234,x ; bc 34 12
+ lda $1234,x ; bd 34 12
+ ldx $1234,y ; be 34 12
+ lax $1234,y ; bf 34 12
+ cpy #$12 ; c0 12
+ cmp ($12,x) ; c1 12
+ noop #$12 ; c2 12
+ dcp ($12,x) ; c3 12
+ cpy $12 ; c4 12
+ cmp $12 ; c5 12
+ dec $12 ; c6 12
+ dcp $12 ; c7 12
+ iny ; c8
+ cmp #$12 ; c9 12
+ dex ; ca
+ sbx #$12 ; cb 12
+ cpy $1234 ; cc 34 12
+ cmp $1234 ; cd 34 12
+ dec $1234 ; ce 34 12
+ dcp $1234 ; cf 34 12
+ bne $125c ; d0 12
+ cmp ($12),y ; d1 12
+ jam ; d2
+ dcp ($12),y ; d3 12
+ noop $12,x ; d4 12
+ cmp $12,x ; d5 12
+ dec $12,x ; d6 12
+ dcp $12,x ; d7 12
+ cld ; d8
+ cmp $1234,y ; d9 34 12
+ noop ; da
+ dcp $1234,y ; db 34 12
+ noop $1234,x ; dc 34 12
+ cmp $1234,x ; dd 34 12
+ dec $1234,x ; de 34 12
+ dcp $1234,x ; df 34 12
+ cpx #$12 ; e0 12
+ sbc ($12,x) ; e1 12
+ noop #$12 ; e2 12
+ isb ($12,x) ; e3 12
+ cpx $12 ; e4 12
+ sbc $12 ; e5 12
+ inc $12 ; e6 12
+ isb $12 ; e7 12
+ inx ; e8
+ sbc #$12 ; e9 12
+ nop ; ea
+ usbc #$12 ; eb 12
+ cpx $1234 ; ec 34 12
+ sbc $1234 ; ed 34 12
+ inc $1234 ; ee 34 12
+ isb $1234 ; ef 34 12
+ beq $12bc ; f0 12
+ sbc ($12),y ; f1 12
+ jam ; f2
+ isb ($12),y ; f3 12
+ noop $12,x ; f4 12
+ sbc $12,x ; f5 12
+ inc $12,x ; f6 12
+ isb $12,x ; f7 12
+ sed ; f8
+ sbc $1234,y ; f9 34 12
+ isb $1234,y ; fb 34 12
+ noop $1234,x ; fc 34 12
+ sbc $1234,x ; fd 34 12
+ inc $1234,x ; fe 34 12
+ isb $1234,x ; ff 34 12
diff --git a/testcode/assembler/illegal.s b/testcode/assembler/illegal.s
index 53b9ec5b0..5145e31e5 100644
--- a/testcode/assembler/illegal.s
+++ b/testcode/assembler/illegal.s
@@ -1,43 +1,136 @@
.setcpu "6502X"
+; first all totally staple undocs:
-.macro test opc
+ slo $12 ; 07 12
+ slo $1234 ; 0f 34 12
+ slo $1234,x ; 1f 34 12
+ slo $1234,y ; 1b 34 12
+ slo ($12,x) ; 03 12
+ slo $12,x ; 17 12
+ slo ($12),y ; 13 12
- opc $00
- opc $00,x
- opc ($00,x)
- opc ($00),y
- opc $1234
- opc $1234,x
- opc $1234,y
+ rla $12 ; 27 12
+ rla $1234 ; 2f 34 12
+ rla $1234,x ; 3f 34 12
+ rla $1234,y ; 3b 34 12
+ rla ($12,x) ; 23 12
+ rla $12,x ; 37 12
+ rla ($12),y ; 33 12
-.endmacro
+ sre $1234 ; 4f 34 12
+ sre $1234,x ; 5f 34 12
+ sre $1234,y ; 5b 34 12
+ sre $12 ; 47 12
+ sre ($12,x) ; 43 12
+ sre $12,x ; 57 12
+ sre ($12),y ; 53 12
+
+ rra $1234 ; 6f 34 12
+ rra $1234,x ; 7f 34 12
+ rra $1234,y ; 7b 34 12
+ rra $12 ; 67 12
+ rra ($12,x) ; 63 12
+ rra $12,x ; 77 12
+ rra ($12),y ; 73 12
+
+ dcp $1234 ; cf 34 12
+ dcp $1234,x ; df 34 12
+ dcp $1234,y ; db 34 12
+ dcp $12 ; c7 12
+ dcp ($12,x) ; c3 12
+ dcp $12,x ; d7 12
+ dcp ($12),y ; d3 12
+
+ isc $1234 ; ef 34 12
+ isc $1234,x ; ff 34 12
+ isc $1234,y ; fb 34 12
+ isc $12 ; e7 12
+ isc ($12,x) ; e3 12
+ isc $12,x ; f7 12
+ isc ($12),y ; f3 12
+
+ sax $1234 ; 8f 34 12
+ sax $12 ; 87 12
+ sax ($12,x) ; 83 12
+ sax $12,y ; 97 12
+
+ lax $1234 ; af 34 12
+ lax $1234,y ; bf 34 12
+ lax $12 ; a7 12
+ lax ($12,x) ; a3 12
+ lax ($12),y ; b3 12
+ lax $12,y ; b7 12
- test slo
- test rla
- test sre
- test rra
- test dcp
- test isc
+ anc #$12 ; 0b 12
+ ;anc #$12 ; 2b 12
- sax $00
- sax $00,y
- sax ($00,x)
- sax $1234
+ arr #$12 ; 6b 12
- lax $00
- lax $00,y
- lax ($00,x)
- lax ($00),y
- lax $1234
- lax $1234,y
+ alr #$12 ; 4b 12
- anc #$55
- alr #$55
- arr #$55
- axs #$55
+ axs #$12 ; cb 12
- las $1234,y
+; nop $12 ; 04 12
+; nop $1234 ; 0c 34 12
+; nop $1234,x ; 1c 34 12
+; nop $1234,x ; 3c 34 12
+; nop $1234,x ; 5c 34 12
+; nop $1234,x ; 7c 34 12
+; nop $1234,x ; dc 34 12
+; nop $1234,x ; fc 34 12
+; nop $12 ; 44 12
+; nop $12 ; 64 12
+; nop #$12 ; 80 12
+; nop #$12 ; 82 12
+; nop #$12 ; 89 12
+; nop #$12 ; c2 12
+; nop #$12 ; e2 12
+; nop $12,x ; 14 12
+; nop $12,x ; 34 12
+; nop $12,x ; 54 12
+; nop $12,x ; 74 12
+; nop $12,x ; d4 12
+; nop $12,x ; f4 12
+; nop ; 1a
+; nop ; 3a
+; nop ; 5a
+; nop ; 7a
+; nop ; da
+
+; jam ; 02
+; jam ; 12
+; jam ; 22
+; jam ; 32
+; jam ; 42
+; jam ; 52
+; jam ; 62
+; jam ; 72
+; jam ; 92
+; jam ; b2
+; jam ; d2
+; jam ; f2
+
+ ;sbc #$12 ; eb 12
+
+; and the so called "unstable" ones:
+
+ las $1234,y ; bb 34 12
+
+; sha $1234,y ; 9f 34 12
+; sha ($12),y ; 93 12
+
+; shs $1234,y ; 9b 34 12
+
+; shx $1234,y ; 9e 34 12
+
+; shy $1234,x ; 9c 34 12
+
+; the two "highly unstable" ones:
+
+; lax #$12 ; ab 12
+
+; ane #$12 ; 8b 12
diff --git a/testcode/assembler/legal.ref b/testcode/assembler/legal.ref
new file mode 100644
index 0000000000000000000000000000000000000000..4e9f5c45d9566f2d5e77236c7a2c5319959b5cce
GIT binary patch
literal 321
zcmV~$F(?IK07g*;LecLQF%X3iqCR3E211B|7>I$;BL-ri6p|2yPzoW0D1;D&5Mm$(
zq7Xt1#6Zp|6Lq3i6jDL~RaD|j0Kp<!L<w)g3BwjA;VE2k=rnWY-S`kBLd}UW#wy)Z
z7`Kb;<s)$=F2xS}Y;ndZFXDzf4#g(h9E)qQ%Q*)vsUlb8h<K8SBa;l?#GiQJi^shb
zVG&+pMy!h!F~%grEHclm*bpO(v&6Jm6GM!$K$^%C31pG{Y=b?H!b7+VYg}+9(XQCv
zj}Q?fA_y!O^`eMsN@Me1#jp4g_dIdSCm%$9*R+d4(Jz{4pocCxL^Hj#iAK7anpkZe
G==%pO4_>eU
literal 0
HcmV?d00001
diff --git a/testcode/assembler/legal.s b/testcode/assembler/legal.s
new file mode 100644
index 000000000..379d6cd3a
--- /dev/null
+++ b/testcode/assembler/legal.s
@@ -0,0 +1,184 @@
+ adc $1234 ; 6d 34 12
+ adc $1234,x ; 7d 34 12
+ adc $1234,y ; 79 34 12
+ adc $12 ; 65 12
+ adc #$12 ; 69 12
+ adc ($12,x) ; 61 12
+ adc $12,x ; 75 12
+ adc ($12),y ; 71 12
+
+ and $12 ; 25 12
+ and #$12 ; 29 12
+ and $1234 ; 2d 34 12
+ and $1234,x ; 3d 34 12
+ and $1234,y ; 39 34 12
+ and ($12,x) ; 21 12
+ and $12,x ; 35 12
+ and ($12),y ; 31 12
+
+ asl $12 ; 06 12
+ asl $1234 ; 0e 34 12
+ asl $1234,x ; 1e 34 12
+ asl $12,x ; 16 12
+ asl a ; 0a
+
+ bcc *+$12 ; 90 12
+ bcs *+$12 ; b0 12
+ beq *+$12 ; f0 12
+
+ bit $12 ; 24 12
+ bit $1234 ; 2c 34 12
+
+ bmi *+$12 ; 30 12
+ bne *+$12 ; d0 12
+ bpl *+$12 ; 10 12
+
+ brk ; 00
+
+ bvc *+$12 ; 50 12
+ bvs *+$12 ; 70 12
+
+ clc ; 18
+ cld ; d8
+ cli ; 58
+ clv ; b8
+
+ cmp $1234 ; cd 34 12
+ cmp $1234,x ; dd 34 12
+ cmp $1234,y ; d9 34 12
+ cmp $12 ; c5 12
+ cmp #$12 ; c9 12
+ cmp ($12,x) ; c1 12
+ cmp $12,x ; d5 12
+ cmp ($12),y ; d1 12
+
+ cpx $1234 ; ec 34 12
+ cpx #$12 ; e0 12
+ cpx $12 ; e4 12
+
+ cpy $1234 ; cc 34 12
+ cpy #$12 ; c0 12
+ cpy $12 ; c4 12
+
+ dec $1234 ; ce 34 12
+ dec $1234,x ; de 34 12
+ dec $12 ; c6 12
+ dec $12,x ; d6 12
+
+ dex ; ca
+ dey ; 88
+
+ eor $1234 ; 4d 34 12
+ eor $1234,x ; 5d 34 12
+ eor $1234,y ; 59 34 12
+ eor $12 ; 45 12
+ eor #$12 ; 49 12
+ eor ($12,x) ; 41 12
+ eor $12,x ; 55 12
+ eor ($12),y ; 51 12
+
+ inc $1234 ; ee 34 12
+ inc $1234,x ; fe 34 12
+ inc $12 ; e6 12
+ inc $12,x ; f6 12
+
+ inx ; e8
+ iny ; c8
+
+ jmp $1234 ; 4c 34 12
+ jmp ($1234) ; 6c 34 12
+
+ jsr $1234 ; 20 34 12
+
+ lda $1234 ; ad 34 12
+ lda $1234,x ; bd 34 12
+ lda $1234,y ; b9 34 12
+ lda $12 ; a5 12
+ lda #$12 ; a9 12
+ lda ($12,x) ; a1 12
+ lda $12,x ; b5 12
+ lda ($12),y ; b1 12
+
+ ldx $1234 ; ae 34 12
+ ldx $1234,y ; be 34 12
+ ldx #$12 ; a2 12
+ ldx $12 ; a6 12
+ ldx $12,y ; b6 12
+
+ ldy $1234 ; ac 34 12
+ ldy $1234,x ; bc 34 12
+ ldy #$12 ; a0 12
+ ldy $12 ; a4 12
+ ldy $12,x ; b4 12
+
+ lsr $1234 ; 4e 34 12
+ lsr $1234,x ; 5e 34 12
+ lsr $12 ; 46 12
+ lsr $12,x ; 56 12
+ lsr a ; 4a
+
+ nop ; ea
+
+ ora $12 ; 05 12
+ ora #$12 ; 09 12
+ ora $1234 ; 0d 34 12
+ ora $1234,x ; 1d 34 12
+ ora $1234,y ; 19 34 12
+ ora ($12,x) ; 01 12
+ ora $12,x ; 15 12
+ ora ($12),y ; 11 12
+
+ pha ; 48
+ php ; 08
+ pla ; 68
+ plp ; 28
+
+ rol $12 ; 26 12
+ rol $1234 ; 2e 34 12
+ rol $1234,x ; 3e 34 12
+ rol $12,x ; 36 12
+ rol a ; 2a
+ ror $1234 ; 6e 34 12
+ ror $1234,x ; 7e 34 12
+ ror $12 ; 66 12
+ ror $12,x ; 76 12
+ ror a ; 6a
+
+ rti ; 40
+ rts ; 60
+
+ sbc $1234 ; ed 34 12
+ sbc $1234,x ; fd 34 12
+ sbc $1234,y ; f9 34 12
+ sbc $12 ; e5 12
+ sbc #$12 ; e9 12
+ sbc ($12,x) ; e1 12
+ sbc $12,x ; f5 12
+ sbc ($12),y ; f1 12
+
+ sec ; 38
+ sed ; f8
+ sei ; 78
+
+ sta $1234 ; 8d 34 12
+ sta $1234,x ; 9d 34 12
+ sta $1234,y ; 99 34 12
+ sta $12 ; 85 12
+ sta ($12,x) ; 81 12
+ sta $12,x ; 95 12
+ sta ($12),y ; 91 12
+
+ stx $1234 ; 8e 34 12
+ stx $12 ; 86 12
+ stx $12,y ; 96 12
+
+ sty $1234 ; 8c 34 12
+ sty $12 ; 84 12
+ sty $12,x ; 94 12
+
+ tax ; aa
+ tay ; a8
+ tsx ; ba
+ txa ; 8a
+ txs ; 9a
+ tya ; 98
From 2dfdf4dec70b418b4fa3e63ed99d7be9cc59895f Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Wed, 19 Nov 2014 22:34:33 +0100
Subject: [PATCH 09/40] added support for ane, sha, shs, shy, shx
---
src/ca65/instr.c | 7 +++++-
testcode/assembler/illegal.s | 47 +++++++++++++++++-------------------
2 files changed, 28 insertions(+), 26 deletions(-)
diff --git a/src/ca65/instr.c b/src/ca65/instr.c
index 9270f5601..6e31896ea 100644
--- a/src/ca65/instr.c
+++ b/src/ca65/instr.c
@@ -215,7 +215,7 @@ static const struct {
/* Instruction table for the 6502 with illegal instructions */
static const struct {
unsigned Count;
- InsDesc Ins[70];
+ InsDesc Ins[75];
} InsTab6502X = {
sizeof (InsTab6502X.Ins) / sizeof (InsTab6502X.Ins[0]),
{
@@ -223,6 +223,7 @@ static const struct {
{ "ALR", 0x0800000, 0x4B, 0, PutAll }, /* X */
{ "ANC", 0x0800000, 0x0B, 0, PutAll }, /* X */
{ "AND", 0x080A26C, 0x20, 0, PutAll },
+ { "ANE", 0x0800000, 0x8B, 0, PutAll }, /* X */
{ "ARR", 0x0800000, 0x6B, 0, PutAll }, /* X */
{ "ASL", 0x000006e, 0x02, 1, PutAll },
{ "AXS", 0x0800000, 0xCB, 0, PutAll }, /* X */
@@ -278,6 +279,10 @@ static const struct {
{ "SEC", 0x0000001, 0x38, 0, PutAll },
{ "SED", 0x0000001, 0xf8, 0, PutAll },
{ "SEI", 0x0000001, 0x78, 0, PutAll },
+ { "SHA", 0x0002200, 0x93, 1, PutAll }, /* X */
+ { "SHS", 0x0000200, 0x9b, 0, PutAll }, /* X */
+ { "SHX", 0x0000200, 0x9e, 1, PutAll }, /* X */
+ { "SHY", 0x0000040, 0x9c, 1, PutAll }, /* X */
{ "SLO", 0x000A26C, 0x03, 0, PutAll }, /* X */
{ "SRE", 0x000A26C, 0x43, 0, PutAll }, /* X */
{ "STA", 0x000A26C, 0x80, 0, PutAll },
diff --git a/testcode/assembler/illegal.s b/testcode/assembler/illegal.s
index 5145e31e5..51d40afa7 100644
--- a/testcode/assembler/illegal.s
+++ b/testcode/assembler/illegal.s
@@ -1,7 +1,7 @@
.setcpu "6502X"
-; first all totally staple undocs:
+; first all totally stable undocs:
slo $12 ; 07 12
slo $1234 ; 0f 34 12
@@ -65,7 +65,7 @@
anc #$12 ; 0b 12
- ;anc #$12 ; 2b 12
+ ;anc #$12 ; 2b 12
arr #$12 ; 6b 12
@@ -101,36 +101,33 @@
; nop ; da
; jam ; 02
-; jam ; 12
-; jam ; 22
-; jam ; 32
-; jam ; 42
-; jam ; 52
-; jam ; 62
-; jam ; 72
-; jam ; 92
-; jam ; b2
-; jam ; d2
-; jam ; f2
+ ;jam ; 12
+ ;jam ; 22
+ ;jam ; 32
+ ;jam ; 42
+ ;jam ; 52
+ ;jam ; 62
+ ;jam ; 72
+ ;jam ; 92
+ ;jam ; b2
+ ;jam ; d2
+ ;jam ; f2
;sbc #$12 ; eb 12
-; and the so called "unstable" ones:
+; and the so-called "unstable" ones:
+ sha ($12),y ; 93 12
+ sha $1234,y ; 9f 34 12
+
+ shx $1234,y ; 9e 34 12
+ shy $1234,x ; 9c 34 12
+
+ shs $1234,y ; 9b 34 12
las $1234,y ; bb 34 12
-; sha $1234,y ; 9f 34 12
-; sha ($12),y ; 93 12
-
-; shs $1234,y ; 9b 34 12
-
-; shx $1234,y ; 9e 34 12
-
-; shy $1234,x ; 9c 34 12
-
; the two "highly unstable" ones:
; lax #$12 ; ab 12
-; ane #$12 ; 8b 12
-
+ ane #$12 ; 8b 12
From cf82bfaf373a5d8f292f50fb11f011a238e925d4 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Wed, 19 Nov 2014 22:54:33 +0100
Subject: [PATCH 10/40] renamed KIL to the more common JAM, which is also
accepted by ca65
---
src/da65/opc6502x.c | 24 ++++++++++++------------
1 file changed, 12 insertions(+), 12 deletions(-)
diff --git a/src/da65/opc6502x.c b/src/da65/opc6502x.c
index c02a145c6..3bdc8a549 100644
--- a/src/da65/opc6502x.c
+++ b/src/da65/opc6502x.c
@@ -51,7 +51,7 @@
const OpcDesc OpcTable_6502X[256] = {
{ "brk", 1, flNone, OH_Implicit }, /* $00 */
{ "ora", 2, flUseLabel, OH_DirectXIndirect }, /* $01 */
- { "kil", 1, flNone, OH_Implicit }, /* $02 */
+ { "jam", 1, flNone, OH_Implicit }, /* $02 */
{ "slo", 2, flUseLabel, OH_DirectXIndirect }, /* $03 */
{ "nop", 2, flUseLabel, OH_Direct }, /* $04 */
{ "ora", 2, flUseLabel, OH_Direct }, /* $05 */
@@ -67,7 +67,7 @@ const OpcDesc OpcTable_6502X[256] = {
{ "slo", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $0f */
{ "bpl", 2, flLabel, OH_Relative }, /* $10 */
{ "ora", 2, flUseLabel, OH_DirectIndirectY }, /* $11 */
- { "kil", 1, flNone, OH_Implicit }, /* $12 */
+ { "jam", 1, flNone, OH_Implicit }, /* $12 */
{ "slo", 2, flUseLabel, OH_DirectIndirectY }, /* $13 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $14 */
{ "ora", 2, flUseLabel, OH_DirectX }, /* $15 */
@@ -83,7 +83,7 @@ const OpcDesc OpcTable_6502X[256] = {
{ "slo", 3, flUseLabel|flAbsOverride, OH_AbsoluteX }, /* $1f */
{ "jsr", 3, flLabel, OH_Absolute }, /* $20 */
{ "and", 2, flUseLabel, OH_DirectXIndirect }, /* $21 */
- { "kil", 1, flNone, OH_Implicit, }, /* $22 */
+ { "jam", 1, flNone, OH_Implicit, }, /* $22 */
{ "rla", 2, flUseLabel, OH_DirectXIndirect }, /* $23 */
{ "bit", 2, flUseLabel, OH_Direct }, /* $24 */
{ "and", 2, flUseLabel, OH_Direct }, /* $25 */
@@ -99,7 +99,7 @@ const OpcDesc OpcTable_6502X[256] = {
{ "rla", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $2f */
{ "bmi", 2, flLabel, OH_Relative }, /* $30 */
{ "and", 2, flUseLabel, OH_DirectIndirectY }, /* $31 */
- { "kil", 1, flNone, OH_Implicit }, /* $32 */
+ { "jam", 1, flNone, OH_Implicit }, /* $32 */
{ "rla", 2, flUseLabel, OH_DirectIndirectY }, /* $33 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $34 */
{ "and", 2, flUseLabel, OH_DirectX }, /* $35 */
@@ -115,7 +115,7 @@ const OpcDesc OpcTable_6502X[256] = {
{ "rla", 3, flUseLabel|flAbsOverride, OH_AbsoluteX }, /* $3f */
{ "rti", 1, flNone, OH_Rts }, /* $40 */
{ "eor", 2, flUseLabel, OH_DirectXIndirect }, /* $41 */
- { "kil", 1, flNone, OH_Implicit }, /* $42 */
+ { "jam", 1, flNone, OH_Implicit }, /* $42 */
{ "sre", 2, flUseLabel, OH_DirectXIndirect }, /* $43 */
{ "nop", 2, flUseLabel, OH_Direct }, /* $44 */
{ "eor", 2, flUseLabel, OH_Direct }, /* $45 */
@@ -131,7 +131,7 @@ const OpcDesc OpcTable_6502X[256] = {
{ "sre", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $4f */
{ "bvc", 2, flLabel, OH_Relative }, /* $50 */
{ "eor", 2, flUseLabel, OH_DirectIndirectY }, /* $51 */
- { "kil", 1, flNone, OH_Implicit }, /* $52 */
+ { "jam", 1, flNone, OH_Implicit }, /* $52 */
{ "sre", 2, flUseLabel, OH_DirectIndirectY }, /* $53 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $54 */
{ "eor", 2, flUseLabel, OH_DirectX }, /* $55 */
@@ -147,7 +147,7 @@ const OpcDesc OpcTable_6502X[256] = {
{ "sre", 3, flUseLabel|flAbsOverride, OH_AbsoluteX }, /* $5f */
{ "rts", 1, flNone, OH_Rts }, /* $60 */
{ "adc", 2, flUseLabel, OH_DirectXIndirect }, /* $61 */
- { "kil", 1, flNone, OH_Implicit }, /* $62 */
+ { "jam", 1, flNone, OH_Implicit }, /* $62 */
{ "rra", 2, flUseLabel, OH_DirectXIndirect }, /* $63 */
{ "nop", 2, flUseLabel, OH_Direct }, /* $64 */
{ "adc", 2, flUseLabel, OH_Direct }, /* $65 */
@@ -163,7 +163,7 @@ const OpcDesc OpcTable_6502X[256] = {
{ "rra", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $6f */
{ "bvs", 2, flLabel, OH_Relative }, /* $70 */
{ "adc", 2, flUseLabel, OH_DirectIndirectY }, /* $71 */
- { "kil", 1, flNone, OH_Implicit }, /* $72 */
+ { "jam", 1, flNone, OH_Implicit }, /* $72 */
{ "rra", 2, flUseLabel, OH_DirectIndirectY }, /* $73 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $74 */
{ "adc", 2, flUseLabel, OH_DirectX }, /* $75 */
@@ -195,7 +195,7 @@ const OpcDesc OpcTable_6502X[256] = {
{ "sax", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $8f */
{ "bcc", 2, flLabel, OH_Relative }, /* $90 */
{ "sta", 2, flUseLabel, OH_DirectIndirectY }, /* $91 */
- { "kil", 1, flNone, OH_Implicit }, /* $92 */
+ { "jam", 1, flNone, OH_Implicit }, /* $92 */
{ "ahx", 2, flUseLabel, OH_DirectIndirectY }, /* $93 */
{ "sty", 2, flUseLabel, OH_DirectX }, /* $94 */
{ "sta", 2, flUseLabel, OH_DirectX }, /* $95 */
@@ -227,7 +227,7 @@ const OpcDesc OpcTable_6502X[256] = {
{ "lax", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $af */
{ "bcs", 2, flLabel, OH_Relative }, /* $b0 */
{ "lda", 2, flUseLabel, OH_DirectIndirectY }, /* $b1 */
- { "kil", 1, flNone, OH_Implicit }, /* $b2 */
+ { "jam", 1, flNone, OH_Implicit }, /* $b2 */
{ "lax", 2, flUseLabel, OH_DirectIndirectY }, /* $b3 */
{ "ldy", 2, flUseLabel, OH_DirectX }, /* $b4 */
{ "lda", 2, flUseLabel, OH_DirectX }, /* $b5 */
@@ -259,7 +259,7 @@ const OpcDesc OpcTable_6502X[256] = {
{ "dcp", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $cf */
{ "bne", 2, flLabel, OH_Relative }, /* $d0 */
{ "cmp", 2, flUseLabel, OH_DirectIndirectY }, /* $d1 */
- { "kil", 1, flNone, OH_Implicit }, /* $d2 */
+ { "jam", 1, flNone, OH_Implicit }, /* $d2 */
{ "dcp", 2, flUseLabel, OH_DirectIndirectY }, /* $d3 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $d4 */
{ "cmp", 2, flUseLabel, OH_DirectX }, /* $d5 */
@@ -291,7 +291,7 @@ const OpcDesc OpcTable_6502X[256] = {
{ "isc", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $ef */
{ "beq", 2, flLabel, OH_Relative }, /* $f0 */
{ "sbc", 2, flUseLabel, OH_DirectIndirectY }, /* $f1 */
- { "kil", 1, flNone, OH_Implicit }, /* $f2 */
+ { "jam", 1, flNone, OH_Implicit }, /* $f2 */
{ "isc", 2, flUseLabel, OH_DirectIndirectY }, /* $f3 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $f4 */
{ "sbc", 2, flUseLabel, OH_DirectX }, /* $f5 */
From 044aee7f8df14a611af9ce1164485e4b7244c308 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Wed, 19 Nov 2014 23:20:46 +0100
Subject: [PATCH 11/40] added support for undocumented NOPs
---
src/ca65/instr.c | 10 ++++--
testcode/assembler/.gitignore | 2 ++
testcode/assembler/all.s | 2 ++
testcode/assembler/illegal.s | 59 +++++++++++++++++------------------
testcode/assembler/legal.s | 3 ++
5 files changed, 44 insertions(+), 32 deletions(-)
diff --git a/src/ca65/instr.c b/src/ca65/instr.c
index 6e31896ea..945d5ee79 100644
--- a/src/ca65/instr.c
+++ b/src/ca65/instr.c
@@ -262,7 +262,7 @@ static const struct {
{ "LDX", 0x080030C, 0xa2, 1, PutAll },
{ "LDY", 0x080006C, 0xa0, 1, PutAll },
{ "LSR", 0x000006F, 0x42, 1, PutAll },
- { "NOP", 0x0000001, 0xea, 0, PutAll },
+ { "NOP", 0x080006D, 0x00, 10, PutAll }, /* X */
{ "ORA", 0x080A26C, 0x00, 0, PutAll },
{ "PHA", 0x0000001, 0x48, 0, PutAll },
{ "PHP", 0x0000001, 0x08, 0, PutAll },
@@ -790,7 +790,7 @@ const InsTable* InsTab = (const InsTable*) &InsTab6502;
/* Table to build the effective 65xx opcode from a base opcode and an
** addressing mode. (The value in the table is ORed with the base opcode)
*/
-static unsigned char EATab[10][AM65I_COUNT] = {
+static unsigned char EATab[11][AM65I_COUNT] = {
{ /* Table 0 */
0x00, 0x00, 0x05, 0x0D, 0x0F, 0x15, 0x1D, 0x1F,
0x00, 0x19, 0x12, 0x00, 0x07, 0x11, 0x17, 0x01,
@@ -851,6 +851,12 @@ static unsigned char EATab[10][AM65I_COUNT] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00
},
+ { /* Table 10 (NOPs) */
+ 0xea, 0x00, 0x04, 0x0c, 0x00, 0x14, 0x1c, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+ 0x00, 0x00, 0x00
+ },
};
/* Table to build the effective SWEET16 opcode from a base opcode and an
diff --git a/testcode/assembler/.gitignore b/testcode/assembler/.gitignore
index 160ca9ba4..3694d8702 100644
--- a/testcode/assembler/.gitignore
+++ b/testcode/assembler/.gitignore
@@ -1,2 +1,4 @@
chkillegal.bin
chklegal.bin
+legal.o
+illegal.o
diff --git a/testcode/assembler/all.s b/testcode/assembler/all.s
index 5471a2bb1..286f52670 100644
--- a/testcode/assembler/all.s
+++ b/testcode/assembler/all.s
@@ -1,3 +1,5 @@
+ .setcpu "6502X"
+
brk ; 00
ora ($12,x) ; 01 12
jam ; 02
diff --git a/testcode/assembler/illegal.s b/testcode/assembler/illegal.s
index 51d40afa7..1a1841fb3 100644
--- a/testcode/assembler/illegal.s
+++ b/testcode/assembler/illegal.s
@@ -63,7 +63,6 @@
lax ($12),y ; b3 12
lax $12,y ; b7 12
-
anc #$12 ; 0b 12
;anc #$12 ; 2b 12
@@ -73,34 +72,34 @@
axs #$12 ; cb 12
-; nop $12 ; 04 12
-; nop $1234 ; 0c 34 12
-; nop $1234,x ; 1c 34 12
-; nop $1234,x ; 3c 34 12
-; nop $1234,x ; 5c 34 12
-; nop $1234,x ; 7c 34 12
-; nop $1234,x ; dc 34 12
-; nop $1234,x ; fc 34 12
-; nop $12 ; 44 12
-; nop $12 ; 64 12
-; nop #$12 ; 80 12
-; nop #$12 ; 82 12
-; nop #$12 ; 89 12
-; nop #$12 ; c2 12
-; nop #$12 ; e2 12
-; nop $12,x ; 14 12
-; nop $12,x ; 34 12
-; nop $12,x ; 54 12
-; nop $12,x ; 74 12
-; nop $12,x ; d4 12
-; nop $12,x ; f4 12
-; nop ; 1a
-; nop ; 3a
-; nop ; 5a
-; nop ; 7a
-; nop ; da
+ nop $1234 ; 0c 34 12
+ nop $1234,x ; 1c 34 12
+ nop $12 ; 04 12
+ nop $12,x ; 14 12
+ nop #$12 ; 80 12
+ ;nop $1234,x ; 3c 34 12
+ ;nop $1234,x ; 5c 34 12
+ ;nop $1234,x ; 7c 34 12
+ ;nop $1234,x ; dc 34 12
+ ;nop $1234,x ; fc 34 12
+ ;nop $12 ; 44 12
+ ;nop $12 ; 64 12
+ ;nop #$12 ; 82 12
+ ;nop #$12 ; 89 12
+ ;nop #$12 ; c2 12
+ ;nop #$12 ; e2 12
+ ;nop $12,x ; 34 12
+ ;nop $12,x ; 54 12
+ ;nop $12,x ; 74 12
+ ;nop $12,x ; d4 12
+ ;nop $12,x ; f4 12
+ ;nop ; 1a
+ ;nop ; 3a
+ ;nop ; 5a
+ ;nop ; 7a
+ ;nop ; da
-; jam ; 02
+ jam ; 02
;jam ; 12
;jam ; 22
;jam ; 32
@@ -115,7 +114,7 @@
;sbc #$12 ; eb 12
-; and the so-called "unstable" ones:
+; the so-called "unstable" ones:
sha ($12),y ; 93 12
sha $1234,y ; 9f 34 12
@@ -126,7 +125,7 @@
shs $1234,y ; 9b 34 12
las $1234,y ; bb 34 12
-; the two "highly unstable" ones:
+; the two so-called "highly unstable" ones:
; lax #$12 ; ab 12
diff --git a/testcode/assembler/legal.s b/testcode/assembler/legal.s
index 379d6cd3a..10377b4b8 100644
--- a/testcode/assembler/legal.s
+++ b/testcode/assembler/legal.s
@@ -1,3 +1,6 @@
+
+ .setcpu "6502"
+
adc $1234 ; 6d 34 12
adc $1234,x ; 7d 34 12
adc $1234,y ; 79 34 12
From 8cc71f135ce0127c4cc54c3793fce8eeb4bebeaf Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Thu, 20 Nov 2014 00:18:12 +0100
Subject: [PATCH 12/40] added support for LAX#imm, all done
---
src/ca65/instr.c | 10 +++-
testcode/assembler/.gitignore | 2 +
testcode/assembler/Makefile | 14 +++--
testcode/assembler/all.s | 93 +++++++++++++++++----------------
testcode/assembler/illegal.ref | 1 +
testcode/assembler/illegal.s | 5 +-
testcode/assembler/legal.ref | Bin 321 -> 321 bytes
testcode/assembler/legal.s | 18 +++----
8 files changed, 81 insertions(+), 62 deletions(-)
create mode 100644 testcode/assembler/illegal.ref
diff --git a/src/ca65/instr.c b/src/ca65/instr.c
index 945d5ee79..09b86b393 100644
--- a/src/ca65/instr.c
+++ b/src/ca65/instr.c
@@ -257,7 +257,7 @@ static const struct {
{ "JMP", 0x0000808, 0x4c, 6, PutJMP },
{ "JSR", 0x0000008, 0x20, 7, PutAll },
{ "LAS", 0x0000200, 0xBB, 0, PutAll }, /* X */
- { "LAX", 0x000A30C, 0xA3, 1, PutAll }, /* X */
+ { "LAX", 0x080A30C, 0xA3, 11, PutAll }, /* X */
{ "LDA", 0x080A26C, 0xa0, 0, PutAll },
{ "LDX", 0x080030C, 0xa2, 1, PutAll },
{ "LDY", 0x080006C, 0xa0, 1, PutAll },
@@ -790,7 +790,7 @@ const InsTable* InsTab = (const InsTable*) &InsTab6502;
/* Table to build the effective 65xx opcode from a base opcode and an
** addressing mode. (The value in the table is ORed with the base opcode)
*/
-static unsigned char EATab[11][AM65I_COUNT] = {
+static unsigned char EATab[12][AM65I_COUNT] = {
{ /* Table 0 */
0x00, 0x00, 0x05, 0x0D, 0x0F, 0x15, 0x1D, 0x1F,
0x00, 0x19, 0x12, 0x00, 0x07, 0x11, 0x17, 0x01,
@@ -857,6 +857,12 @@ static unsigned char EATab[11][AM65I_COUNT] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
0x00, 0x00, 0x00
},
+ { /* Table 11 (LAX) */
+ 0x08, 0x08, 0x04, 0x0C, 0x00, 0x14, 0x1C, 0x00,
+ 0x14, 0x1C, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+ 0x00, 0x00, 0x80
+ },
};
/* Table to build the effective SWEET16 opcode from a base opcode and an
diff --git a/testcode/assembler/.gitignore b/testcode/assembler/.gitignore
index 3694d8702..93dedf2e2 100644
--- a/testcode/assembler/.gitignore
+++ b/testcode/assembler/.gitignore
@@ -1,4 +1,6 @@
chkillegal.bin
chklegal.bin
+chkall.bin
legal.o
illegal.o
+all.o
\ No newline at end of file
diff --git a/testcode/assembler/Makefile b/testcode/assembler/Makefile
index ae08864f8..a9257ce75 100644
--- a/testcode/assembler/Makefile
+++ b/testcode/assembler/Makefile
@@ -1,19 +1,25 @@
-all: chklegal.bin chkillegal.bin
+all: chklegal.bin chkillegal.bin chkall.bin
@#
-.PHONY: chklegal.bin chkillegal.bin
+.PHONY: chklegal.bin chkillegal.bin chkall.bin
chklegal.bin: legal.s
../../bin/cl65 --target none --cpu 6502X -o chklegal.bin legal.s
- diff legal.ref chklegal.bin
+ diff -q legal.ref chklegal.bin || hex chklegal.bin
chkillegal.bin: illegal.s
../../bin/cl65 --target none --cpu 6502X -o chkillegal.bin illegal.s
+ diff -q illegal.ref chkillegal.bin || hex chkillegal.bin
-ref: legal.s
+chkall.bin: all.s
+ ../../bin/cl65 --target none --cpu 6502X -o chkall.bin all.s
+
+ref: legal.s illegal.s
../../bin/cl65 --target none --cpu 6502X -o legal.ref legal.s
+ ../../bin/cl65 --target none --cpu 6502X -o illegal.ref illegal.s
clean:
rm -f legal.o chklegal.bin
rm -f illegal.o chkillegal.bin
+ rm -f all.o chkall.bin
diff --git a/testcode/assembler/all.s b/testcode/assembler/all.s
index 286f52670..b1795f99b 100644
--- a/testcode/assembler/all.s
+++ b/testcode/assembler/all.s
@@ -1,10 +1,13 @@
.setcpu "6502X"
+; all legal and illegal opcodes as they would be disassembled by da65
+; note that this would not assemble into the exact same binary
+
brk ; 00
ora ($12,x) ; 01 12
jam ; 02
slo ($12,x) ; 03 12
- noop $12 ; 04 12
+ nop $12 ; 04 12
ora $12 ; 05 12
asl $12 ; 06 12
slo $12 ; 07 12
@@ -12,23 +15,23 @@
ora #$12 ; 09 12
asl a ; 0a
anc #$12 ; 0b 12
- noop $1234 ; 0c 34 12
+ nop $1234 ; 0c 34 12
ora $1234 ; 0d 34 12
asl $1234 ; 0e 34 12
slo $1234 ; 0f 34 12
- bpl $101c ; 10 12
+ bpl *+$14 ; 10 12
ora ($12),y ; 11 12
jam ; 12
slo ($12),y ; 13 12
- noop $12,x ; 14 12
+ nop $12,x ; 14 12
ora $12,x ; 15 12
asl $12,x ; 16 12
slo $12,x ; 17 12
clc ; 18
ora $1234,y ; 19 34 12
- noop ; 1a
+ nop ; 1a
slo $1234,y ; 1b 34 12
- noop $1234,x ; 1c 34 12
+ nop $1234,x ; 1c 34 12
ora $1234,x ; 1d 34 12
asl $1234,x ; 1e 34 12
slo $1234,x ; 1f 34 12
@@ -48,19 +51,19 @@
and $1234 ; 2d 34 12
rol $1234 ; 2e 34 12
rla $1234 ; 2f 34 12
- bmi $107c ; 30 12
+ bmi *+$14 ; 30 12
and ($12),y ; 31 12
jam ; 32
rla ($12),y ; 33 12
- noop $12,x ; 34 12
+ nop $12,x ; 34 12
and $12,x ; 35 12
rol $12,x ; 36 12
rla $12,x ; 37 12
sec ; 38
and $1234,y ; 39 34 12
- noop ; 3a
+ nop ; 3a
rla $1234,y ; 3b 34 12
- noop $1234,x ; 3c 34 12
+ nop $1234,x ; 3c 34 12
and $1234,x ; 3d 34 12
rol $1234,x ; 3e 34 12
rla $1234,x ; 3f 34 12
@@ -68,31 +71,31 @@
eor ($12,x) ; 41 12
jam ; 42
sre ($12,x) ; 43 12
- noop $12 ; 44 12
+ nop $12 ; 44 12
eor $12 ; 45 12
lsr $12 ; 46 12
sre $12 ; 47 12
pha ; 48
eor #$12 ; 49 12
lsr a ; 4a
- asr #$12 ; 4b 12
+ alr #$12 ; 4b 12
jmp $1234 ; 4c 34 12
eor $1234 ; 4d 34 12
lsr $1234 ; 4e 34 12
sre $1234 ; 4f 34 12
- bvc $10dc ; 50 12
+ bvc *+$14 ; 50 12
eor ($12),y ; 51 12
jam ; 52
sre ($12),y ; 53 12
- noop $12,x ; 54 12
+ nop $12,x ; 54 12
eor $12,x ; 55 12
lsr $12,x ; 56 12
sre $12,x ; 57 12
cli ; 58
eor $1234,y ; 59 34 12
- noop ; 5a
+ nop ; 5a
sre $1234,y ; 5b 34 12
- noop $1234,x ; 5c 34 12
+ nop $1234,x ; 5c 34 12
eor $1234,x ; 5d 34 12
lsr $1234,x ; 5e 34 12
sre $1234,x ; 5f 34 12
@@ -100,7 +103,7 @@
adc ($12,x) ; 61 12
jam ; 62
rra ($12,x) ; 63 12
- noop $12 ; 64 12
+ nop $12 ; 64 12
adc $12 ; 65 12
ror $12 ; 66 12
rra $12 ; 67 12
@@ -112,39 +115,39 @@
adc $1234 ; 6d 34 12
ror $1234 ; 6e 34 12
rra $1234 ; 6f 34 12
- bvs $113c ; 70 12
+ bvs *+$14 ; 70 12
adc ($12),y ; 71 12
jam ; 72
rra ($12),y ; 73 12
- noop $12,x ; 74 12
+ nop $12,x ; 74 12
adc $12,x ; 75 12
ror $12,x ; 76 12
rra $12,x ; 77 12
sei ; 78
adc $1234,y ; 79 34 12
- noop ; 7a
+ nop ; 7a
rra $1234,y ; 7b 34 12
- noop $1234,x ; 7c 34 12
+ nop $1234,x ; 7c 34 12
adc $1234,x ; 7d 34 12
ror $1234,x ; 7e 34 12
rra $1234,x ; 7f 34 12
- noop #$12 ; 80 12
+ nop #$12 ; 80 12
sta ($12,x) ; 81 12
- noop #$12 ; 82 12
+ nop #$12 ; 82 12
sax ($12,x) ; 83 12
sty $12 ; 84 12
sta $12 ; 85 12
stx $12 ; 86 12
sax $12 ; 87 12
dey ; 88
- noop #$12 ; 89 12
+ nop #$12 ; 89 12
txa ; 8a
ane #$12 ; 8b 12
sty $1234 ; 8c 34 12
sta $1234 ; 8d 34 12
stx $1234 ; 8e 34 12
sax $1234 ; 8f 34 12
- bcc $119c ; 90 12
+ bcc *+$14 ; 90 12
sta ($12),y ; 91 12
jam ; 92
sha ($12),y ; 93 12
@@ -171,12 +174,12 @@
tay ; a8
lda #$12 ; a9 12
tax ; aa
- lxa #$12 ; ab 12
+ lax #$12 ; ab 12
ldy $1234 ; ac 34 12
lda $1234 ; ad 34 12
ldx $1234 ; ae 34 12
lax $1234 ; af 34 12
- bcs $11fc ; b0 12
+ bcs *+$14 ; b0 12
lda ($12),y ; b1 12
jam ; b2
lax ($12),y ; b3 12
@@ -194,7 +197,7 @@
lax $1234,y ; bf 34 12
cpy #$12 ; c0 12
cmp ($12,x) ; c1 12
- noop #$12 ; c2 12
+ nop #$12 ; c2 12
dcp ($12,x) ; c3 12
cpy $12 ; c4 12
cmp $12 ; c5 12
@@ -203,55 +206,55 @@
iny ; c8
cmp #$12 ; c9 12
dex ; ca
- sbx #$12 ; cb 12
+ axs #$12 ; cb 12
cpy $1234 ; cc 34 12
cmp $1234 ; cd 34 12
dec $1234 ; ce 34 12
dcp $1234 ; cf 34 12
- bne $125c ; d0 12
+ bne *+$14 ; d0 12
cmp ($12),y ; d1 12
jam ; d2
dcp ($12),y ; d3 12
- noop $12,x ; d4 12
+ nop $12,x ; d4 12
cmp $12,x ; d5 12
dec $12,x ; d6 12
dcp $12,x ; d7 12
cld ; d8
cmp $1234,y ; d9 34 12
- noop ; da
+ nop ; da
dcp $1234,y ; db 34 12
- noop $1234,x ; dc 34 12
+ nop $1234,x ; dc 34 12
cmp $1234,x ; dd 34 12
dec $1234,x ; de 34 12
dcp $1234,x ; df 34 12
cpx #$12 ; e0 12
sbc ($12,x) ; e1 12
- noop #$12 ; e2 12
- isb ($12,x) ; e3 12
+ nop #$12 ; e2 12
+ isc ($12,x) ; e3 12
cpx $12 ; e4 12
sbc $12 ; e5 12
inc $12 ; e6 12
- isb $12 ; e7 12
+ isc $12 ; e7 12
inx ; e8
sbc #$12 ; e9 12
nop ; ea
- usbc #$12 ; eb 12
+ sbc #$12 ; eb 12
cpx $1234 ; ec 34 12
sbc $1234 ; ed 34 12
inc $1234 ; ee 34 12
- isb $1234 ; ef 34 12
- beq $12bc ; f0 12
+ isc $1234 ; ef 34 12
+ beq *+$14 ; f0 12
sbc ($12),y ; f1 12
jam ; f2
- isb ($12),y ; f3 12
- noop $12,x ; f4 12
+ isc ($12),y ; f3 12
+ nop $12,x ; f4 12
sbc $12,x ; f5 12
inc $12,x ; f6 12
- isb $12,x ; f7 12
+ isc $12,x ; f7 12
sed ; f8
sbc $1234,y ; f9 34 12
- isb $1234,y ; fb 34 12
- noop $1234,x ; fc 34 12
+ isc $1234,y ; fb 34 12
+ nop $1234,x ; fc 34 12
sbc $1234,x ; fd 34 12
inc $1234,x ; fe 34 12
- isb $1234,x ; ff 34 12
+ isc $1234,x ; ff 34 12
diff --git a/testcode/assembler/illegal.ref b/testcode/assembler/illegal.ref
new file mode 100644
index 000000000..c8dc208b4
--- /dev/null
+++ b/testcode/assembler/illegal.ref
@@ -0,0 +1 @@
+4 44'/4?4;4#73O4_4[4GCWSo44{4gcws�4�4�4�����4�4�4�����4����4�4���� kK� 4 4���4�4�4�4�4��
\ No newline at end of file
diff --git a/testcode/assembler/illegal.s b/testcode/assembler/illegal.s
index 1a1841fb3..c73e2eba3 100644
--- a/testcode/assembler/illegal.s
+++ b/testcode/assembler/illegal.s
@@ -1,6 +1,9 @@
.setcpu "6502X"
+; all so called "illegal" opcodes. duplicated (functionally identical) ones
+; are commented out
+
; first all totally stable undocs:
slo $12 ; 07 12
@@ -127,6 +130,6 @@
; the two so-called "highly unstable" ones:
-; lax #$12 ; ab 12
+ lax #$12 ; ab 12
ane #$12 ; 8b 12
diff --git a/testcode/assembler/legal.ref b/testcode/assembler/legal.ref
index 4e9f5c45d9566f2d5e77236c7a2c5319959b5cce..c38f2901465090f656f005ccd12e091ee55c3911 100644
GIT binary patch
delta 31
ncmX@ebdYI+k*LrHp$|d^LKlPtgaU*Lgj9rdOoSLFy8i+Ilr;$0
delta 31
ncmX@ebdYI+k*L51fe!*ILOLcw1_BoZ1OylY1PTNuy8i+Ijx`9#
diff --git a/testcode/assembler/legal.s b/testcode/assembler/legal.s
index 10377b4b8..1de43b98b 100644
--- a/testcode/assembler/legal.s
+++ b/testcode/assembler/legal.s
@@ -25,22 +25,20 @@
asl $12,x ; 16 12
asl a ; 0a
- bcc *+$12 ; 90 12
- bcs *+$12 ; b0 12
- beq *+$12 ; f0 12
+ bcc *+$14 ; 90 12
+ bcs *+$14 ; b0 12
+ beq *+$14 ; f0 12
+ bmi *+$14 ; 30 12
+ bne *+$14 ; d0 12
+ bpl *+$14 ; 10 12
+ bvc *+$14 ; 50 12
+ bvs *+$14 ; 70 12
bit $12 ; 24 12
bit $1234 ; 2c 34 12
- bmi *+$12 ; 30 12
- bne *+$12 ; d0 12
- bpl *+$12 ; 10 12
-
brk ; 00
- bvc *+$12 ; 50 12
- bvs *+$12 ; 70 12
-
clc ; 18
cld ; d8
cli ; 58
From c2704ec72a3fcc9612b1b652bf173e787ced55ca Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Thu, 20 Nov 2014 01:31:39 +0100
Subject: [PATCH 13/40] uses TAS instead of SHS like da65 did
---
src/ca65/instr.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/ca65/instr.c b/src/ca65/instr.c
index 09b86b393..c29ff7446 100644
--- a/src/ca65/instr.c
+++ b/src/ca65/instr.c
@@ -280,7 +280,7 @@ static const struct {
{ "SED", 0x0000001, 0xf8, 0, PutAll },
{ "SEI", 0x0000001, 0x78, 0, PutAll },
{ "SHA", 0x0002200, 0x93, 1, PutAll }, /* X */
- { "SHS", 0x0000200, 0x9b, 0, PutAll }, /* X */
+ { "TAS", 0x0000200, 0x9b, 0, PutAll }, /* X */
{ "SHX", 0x0000200, 0x9e, 1, PutAll }, /* X */
{ "SHY", 0x0000040, 0x9c, 1, PutAll }, /* X */
{ "SLO", 0x000A26C, 0x03, 0, PutAll }, /* X */
From 6273d1cdc05eafa1d319fb630488c794e8896e65 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Thu, 20 Nov 2014 02:47:33 +0100
Subject: [PATCH 14/40] actually make TAS work :)
---
src/ca65/instr.c | 2 +-
testcode/assembler/all.s | 2 +-
testcode/assembler/illegal.s | 2 +-
3 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/src/ca65/instr.c b/src/ca65/instr.c
index c29ff7446..6acf8c94f 100644
--- a/src/ca65/instr.c
+++ b/src/ca65/instr.c
@@ -280,7 +280,6 @@ static const struct {
{ "SED", 0x0000001, 0xf8, 0, PutAll },
{ "SEI", 0x0000001, 0x78, 0, PutAll },
{ "SHA", 0x0002200, 0x93, 1, PutAll }, /* X */
- { "TAS", 0x0000200, 0x9b, 0, PutAll }, /* X */
{ "SHX", 0x0000200, 0x9e, 1, PutAll }, /* X */
{ "SHY", 0x0000040, 0x9c, 1, PutAll }, /* X */
{ "SLO", 0x000A26C, 0x03, 0, PutAll }, /* X */
@@ -288,6 +287,7 @@ static const struct {
{ "STA", 0x000A26C, 0x80, 0, PutAll },
{ "STX", 0x000010c, 0x82, 1, PutAll },
{ "STY", 0x000002c, 0x80, 1, PutAll },
+ { "TAS", 0x0000200, 0x9b, 0, PutAll }, /* X */
{ "TAX", 0x0000001, 0xaa, 0, PutAll },
{ "TAY", 0x0000001, 0xa8, 0, PutAll },
{ "TSX", 0x0000001, 0xba, 0, PutAll },
diff --git a/testcode/assembler/all.s b/testcode/assembler/all.s
index b1795f99b..2e8f55ec7 100644
--- a/testcode/assembler/all.s
+++ b/testcode/assembler/all.s
@@ -158,7 +158,7 @@
tya ; 98
sta $1234,y ; 99 34 12
txs ; 9a
- shs $1234,y ; 9b 34 12
+ tas $1234,y ; 9b 34 12
shy $1234,x ; 9c 34 12
sta $1234,x ; 9d 34 12
shx $1234,y ; 9e 34 12
diff --git a/testcode/assembler/illegal.s b/testcode/assembler/illegal.s
index c73e2eba3..b49b88761 100644
--- a/testcode/assembler/illegal.s
+++ b/testcode/assembler/illegal.s
@@ -125,7 +125,7 @@
shx $1234,y ; 9e 34 12
shy $1234,x ; 9c 34 12
- shs $1234,y ; 9b 34 12
+ tas $1234,y ; 9b 34 12
las $1234,y ; bb 34 12
; the two so-called "highly unstable" ones:
From c0567eb8b76e4bac11ca09b57c03680689577627 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Thu, 20 Nov 2014 13:16:04 +0100
Subject: [PATCH 15/40] add LF
---
testcode/assembler/.gitignore | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/testcode/assembler/.gitignore b/testcode/assembler/.gitignore
index 93dedf2e2..de179f4f3 100644
--- a/testcode/assembler/.gitignore
+++ b/testcode/assembler/.gitignore
@@ -3,4 +3,4 @@ chklegal.bin
chkall.bin
legal.o
illegal.o
-all.o
\ No newline at end of file
+all.o
From d5844bd63b757d1b6164b1661346998d340adab7 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Thu, 20 Nov 2014 14:49:35 +0100
Subject: [PATCH 16/40] changed return code to -99
---
src/sim65/main.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/src/sim65/main.c b/src/sim65/main.c
index 10dbe3f91..22f6831e4 100644
--- a/src/sim65/main.c
+++ b/src/sim65/main.c
@@ -238,7 +238,8 @@ int main (int argc, char* argv[])
ExecuteInsn ();
if (MaxCycles && (GetCycles () >= MaxCycles)) {
Error ("Maximum number of cycles reached.");
- exit (EXIT_FAILURE);
+ exit (-99); /* do not ues EXIT_FAILURE to avoid conflicts with the
+ same value being used in a test program */
}
}
From 0c204725bc2d5b1d50b097c21c1d5c9082c6101a Mon Sep 17 00:00:00 2001
From: peterferrie <peter.ferrie@gmail.com>
Date: Fri, 21 Nov 2014 16:04:11 -0800
Subject: [PATCH 17/40] implement ProDOS seek
---
libsrc/apple2/lseek.s | 96 +++++++++++++++++++++++++++++++++++++++++++
1 file changed, 96 insertions(+)
create mode 100644 libsrc/apple2/lseek.s
diff --git a/libsrc/apple2/lseek.s b/libsrc/apple2/lseek.s
new file mode 100644
index 000000000..058e6f53d
--- /dev/null
+++ b/libsrc/apple2/lseek.s
@@ -0,0 +1,96 @@
+;
+; Peter Ferrie, 21.11.2014
+;
+; off_t __fastcall__ lseek(int fd, off_t offset, int whence);
+;
+
+ .export _lseek
+ .import popax
+
+ .include "zeropage.inc"
+ .include "errno.inc"
+ .include "mli.inc"
+ .include "filedes.inc"
+
+_lseek:
+ ; Save whence
+ sta tmp1
+ stx tmp2
+
+ ; Get and save offset
+ jsr popax
+ sta ptr1
+ stx ptr1+1
+ jsr popax
+ sta ptr2
+
+ ; Get and process fd
+ jsr popax
+ jsr getfd ; Returns A, Y and C
+ bcs errno
+
+ ; Check for device
+ cmp #$80
+ bcs einval
+
+ ; Valid whence values are 0..2
+ ldx tmp2
+ bne einval
+ ldx tmp1
+ cpx #3
+ bcs einval
+
+ ; Set fd
+ sta mliparam + MLI::RW::REF_NUM
+
+ txa
+ beq cur
+ lda #GET_EOF_CALL
+ dex
+ beq end
+
+; SEEK_SET
+ dex
+ txa
+ tay
+ beq seek_common
+
+; SEEK_CUR
+cur:
+ lda #GET_MARK_CALL
+
+; SEEK_END
+end:
+ ldx #MARK_COUNT ; conveniently same as EOF_COUNT
+ jsr callmli
+ bcs oserr
+ lda mliparam + MLI::MARK::POSITION
+ ldx mliparam + MLI::MARK::POSITION+1
+ ldy mliparam + MLI::MARK::POSITION+2
+
+seek_common:
+ adc ptr1
+ sta mliparam + MLI::MARK::POSITION
+ txa
+ adc ptr1+1
+ sta mliparam + MLI::MARK::POSITION+1
+ tya
+ adc ptr2
+ sta mliparam + MLI::MARK::POSITION+2
+
+ ; Set file pointer
+ lda #SET_MARK_CALL
+ ldx #MARK_COUNT
+ jsr callmli
+ bcs oserr
+
+ rts
+
+ ; Load errno code
+einval: lda #EINVAL
+
+ ; Set __errno
+errno: jmp __directerrno
+
+ ; Set __oserror
+oserr: jmp __mappederrno
From 8d2ec80d5af44d221b2ad347db1d7ddae30c901c Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sat, 22 Nov 2014 15:30:07 +0100
Subject: [PATCH 18/40] cleanup
---
test/val/add1.o | Bin 6483 -> 0 bytes
test/val/add1.prg | Bin 3113 -> 0 bytes
test/val/add3.o | Bin 22855 -> 0 bytes
test/val/add3.prg | Bin 5022 -> 0 bytes
test/val/add4.o | Bin 5552 -> 0 bytes
test/val/add4.prg | Bin 3019 -> 0 bytes
6 files changed, 0 insertions(+), 0 deletions(-)
delete mode 100644 test/val/add1.o
delete mode 100644 test/val/add1.prg
delete mode 100644 test/val/add3.o
delete mode 100644 test/val/add3.prg
delete mode 100644 test/val/add4.o
delete mode 100644 test/val/add4.prg
diff --git a/test/val/add1.o b/test/val/add1.o
deleted file mode 100644
index bc6b2f50511213499261fc384d39aeb940fc73b6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 6483
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
U@IHeE49x1=C+gOrUc7+(2Rm>XtN;K2
diff --git a/test/val/add1.prg b/test/val/add1.prg
deleted file mode 100644
index c0bdb01a211531e1ab95a8bb62320f5c6600ee25..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 3113
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
diff --git a/test/val/add3.o b/test/val/add3.o
deleted file mode 100644
index 53a40880f534f9a6ae7b9f30a714459ca72b527d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 22855
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
diff --git a/test/val/add3.prg b/test/val/add3.prg
deleted file mode 100644
index 9ababe609fca2db3e52db3be1ae1696931b5b6a8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 5022
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
KAY|tnj_^N^XFyv3
diff --git a/test/val/add4.o b/test/val/add4.o
deleted file mode 100644
index cc6c6aa521e07b617db2c4b9f4bb55426254cc2a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 5552
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
diff --git a/test/val/add4.prg b/test/val/add4.prg
deleted file mode 100644
index b00f313293bf5322b34fa6052ab7098fb35db783..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 3019
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
From f82343c4840e5b0a4fd9ac81fd04a7c6642f0831 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sat, 22 Nov 2014 16:44:48 +0100
Subject: [PATCH 19/40] sitest can not work
---
test/val/sitest.c | 1591 ---------------------------------------------
1 file changed, 1591 deletions(-)
delete mode 100644 test/val/sitest.c
diff --git a/test/val/sitest.c b/test/val/sitest.c
deleted file mode 100644
index 9570f4989..000000000
--- a/test/val/sitest.c
+++ /dev/null
@@ -1,1591 +0,0 @@
-/*
- !!DESCRIPTION!! C99 WCHAR test
- !!ORIGIN!!
- !!LICENCE!! public domain
-*/
-
-/*
- sitest -- exercise features of C99 <stdint.h> and <inttypes.h>
-
- 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 <inttypes.h>.
-
- Takes advantage of __Q8_* symbols defined by a particular
- implementation of <stdint.h>, but doesn't require them.
-
- NOTE: This is not a thorough validation test of the facilities.
-*/
-
-#define NO_INTERNAL_WCHAR
-/*#define STANDALONE*/
-
-#include <errno.h>
-#include <limits.h> /* for CHAR_BIT */
-#include <stdio.h>
-#include <stddef.h> /* for ptrdiff_t */
-#include <stdlib.h>
-#include <string.h>
-
-#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 <inttypes.h> /* embeds <stdint.h> */
-
-#include <signal.h> /* for sig_atomic_t */
-
-#if defined(INTMAX_MAX) /* <inttypes.h> has C99 features */
-#include <wchar.h>
-#endif
-
-#include <inttypes.h> /* 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 */
-
-
- /* <stdint.h> 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
-
- /* <inttypes.h> 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) /* <inttypes.h> 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
From d712abfe27ed61e8f68281f1e60e33690aeab5d2 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sat, 22 Nov 2014 16:45:23 +0100
Subject: [PATCH 20/40] include s26 to get bitsize of char
---
test/val/cq4.c | 129 +++++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 126 insertions(+), 3 deletions(-)
diff --git a/test/val/cq4.c b/test/val/cq4.c
index 94f4d5fb7..8a8125c52 100644
--- a/test/val/cq4.c
+++ b/test/val/cq4.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
@@ -41,7 +43,124 @@ struct defs {
int crc; /* Cumulative return code */
char rfs[8]; /* Return from section */
-/*#include "cq26.c"*/ /* hardware check */
+#define CQ26_INCLUDED
+/*
+ section s26, which pokes around at the hardware
+ trying to figure out the characteristics of the machine that
+ it is running on, saves information that is subsequently
+ used by sections s626, s72, and s757. If this program is
+ to be broken up into smallish pieces, say for running on
+ a microcomputer, take care to see that s26 is called before
+ calling any of the latter three sections.
+*/
+
+/*
+ 2.6 Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+ static char qs26[8] = "s26 ";
+ char *ps, *pt;
+ char c0, c1;
+ #ifndef NO_FLOATS
+ float temp, one, delta;
+ double tempd, oned;
+ #endif
+ static char s[] = "%3d bits in %ss.\n";
+ static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+ ps = qs26;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+ /* Here, we shake the machinery a little to see what falls
+ out. First, we find out how many bits are in a char. */
+
+ pd0->cbits = 0;
+ c0 = 0;
+ c1 = 1;
+
+ while(c0 != c1) {
+ c1 = c1<<1;
+ pd0->cbits = pd0->cbits+1;
+ }
+ /* That information lets us determine the size of everything else. */
+
+ pd0->ibits = pd0->cbits * sizeof(int);
+ pd0->sbits = pd0->cbits * sizeof(short);
+ pd0->lbits = pd0->cbits * sizeof(long);
+ pd0->ubits = pd0->cbits * sizeof(unsigned);
+ #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;
@@ -125,10 +244,13 @@ implementation */
target = ~0U;
mask = 1;
+ printf("sizeof target: %08x pd0->cbits: %08x\n", sizeof target, pd0->cbits);
+ printf("mask: %08x target: %08x\n", mask, target);
for(j=0; j<(sizeof target)*pd0->cbits; j++){
mask = mask⌖
target = target>>1;
+ printf("mask: %08x target: %08x\n", mask, target);
}
if(mask != 1 || target != 0){
@@ -200,11 +322,12 @@ setev(){
int section(int j,void* pd0){
#endif
switch(j){
- case 0: return s4(pd0);
+ case 0: return s26(pd0);
+ case 1: return s4(pd0);
}
}
-#define cq_sections 1
+#define cq_sections 2
/*
C REFERENCE MANUAL (main)
From a20cb090320282c857f71825a79f38e573ded5c3 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sat, 22 Nov 2014 16:59:31 +0100
Subject: [PATCH 21/40] added makefile and common include
---
test/val/add3.c | 2 ++
test/val/cc65091020.c | 2 ++
test/val/compare5.c | 5 ++---
test/val/cq22.c | 2 ++
test/val/cq241.c | 2 ++
test/val/cq243.c | 2 ++
test/val/cq244.c | 2 ++
test/val/cq25.c | 2 ++
test/val/cq26.c | 2 ++
test/val/cq61.c | 2 ++
test/val/cq626.c | 2 ++
test/val/cq71.c | 2 ++
test/val/cq714.c | 2 ++
test/val/cq714b.c | 2 ++
test/val/cq715.c | 2 ++
test/val/cq72.c | 2 ++
test/val/cq757.c | 2 ++
test/val/cq7813.c | 2 ++
test/val/cq81.c | 2 ++
test/val/cq84.c | 2 ++
test/val/cq85.c | 2 ++
test/val/cq86.c | 2 ++
test/val/cq88.c | 2 ++
test/val/cq9.c | 2 ++
24 files changed, 48 insertions(+), 3 deletions(-)
diff --git a/test/val/add3.c b/test/val/add3.c
index abbc93b47..c031f1d0f 100644
--- a/test/val/add3.c
+++ b/test/val/add3.c
@@ -4,6 +4,8 @@
!!LICENCE!! GPL, read COPYING.GPL
*/
+#include "common.h"
+
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
diff --git a/test/val/cc65091020.c b/test/val/cc65091020.c
index 8ec11ef8d..8f62f970e 100644
--- a/test/val/cc65091020.c
+++ b/test/val/cc65091020.c
@@ -5,6 +5,8 @@
!!AUTHOR!! Johan Kotlinski
*/
+#include "common.h"
+
#include <assert.h>
struct {
diff --git a/test/val/compare5.c b/test/val/compare5.c
index b5dd93f01..b0a9f1649 100644
--- a/test/val/compare5.c
+++ b/test/val/compare5.c
@@ -4,6 +4,8 @@
!!LICENCE!! GPL, read COPYING.GPL
*/
+#include "common.h"
+
#include <stdio.h>
#include <limits.h>
@@ -291,19 +293,16 @@ void c_minus1(void)
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++;
}
/*
diff --git a/test/val/cq22.c b/test/val/cq22.c
index 4ce40ecc0..bcd1570c8 100644
--- a/test/val/cq22.c
+++ b/test/val/cq22.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq241.c b/test/val/cq241.c
index d7d8ed952..76f437e0c 100644
--- a/test/val/cq241.c
+++ b/test/val/cq241.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq243.c b/test/val/cq243.c
index 03b08b4d2..676c73182 100644
--- a/test/val/cq243.c
+++ b/test/val/cq243.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq244.c b/test/val/cq244.c
index 52695bfb6..bedf51e95 100644
--- a/test/val/cq244.c
+++ b/test/val/cq244.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq25.c b/test/val/cq25.c
index d4a0c4a90..9cb2f61c8 100644
--- a/test/val/cq25.c
+++ b/test/val/cq25.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq26.c b/test/val/cq26.c
index 42527e80f..399f0a45e 100644
--- a/test/val/cq26.c
+++ b/test/val/cq26.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
#ifndef CQ26_INCLUDED
struct defs {
int cbits; /* No. of bits per char */
diff --git a/test/val/cq61.c b/test/val/cq61.c
index f40b21d61..3dcca6454 100644
--- a/test/val/cq61.c
+++ b/test/val/cq61.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq626.c b/test/val/cq626.c
index 7fab43f53..166d3a95b 100644
--- a/test/val/cq626.c
+++ b/test/val/cq626.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq71.c b/test/val/cq71.c
index 342b9809a..7bf0d9e1e 100644
--- a/test/val/cq71.c
+++ b/test/val/cq71.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
/*include "cq26.c"*/ /* hardware check */
struct defs {
diff --git a/test/val/cq714.c b/test/val/cq714.c
index 1d36b18ab..f4c58801f 100644
--- a/test/val/cq714.c
+++ b/test/val/cq714.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq714b.c b/test/val/cq714b.c
index 9a09a88f0..b4908f4cb 100644
--- a/test/val/cq714b.c
+++ b/test/val/cq714b.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq715.c b/test/val/cq715.c
index dd829156c..fec9c6170 100644
--- a/test/val/cq715.c
+++ b/test/val/cq715.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq72.c b/test/val/cq72.c
index 5f60fdcad..2f956e59d 100644
--- a/test/val/cq72.c
+++ b/test/val/cq72.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq757.c b/test/val/cq757.c
index 7c898ca5b..60b588555 100644
--- a/test/val/cq757.c
+++ b/test/val/cq757.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq7813.c b/test/val/cq7813.c
index 77d34a2a6..0e743abcd 100644
--- a/test/val/cq7813.c
+++ b/test/val/cq7813.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq81.c b/test/val/cq81.c
index 198cbc4f6..0271cae5d 100644
--- a/test/val/cq81.c
+++ b/test/val/cq81.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq84.c b/test/val/cq84.c
index fcadd9af6..d37c82f29 100644
--- a/test/val/cq84.c
+++ b/test/val/cq84.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq85.c b/test/val/cq85.c
index 3e5ef938d..15b055b20 100644
--- a/test/val/cq85.c
+++ b/test/val/cq85.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq86.c b/test/val/cq86.c
index 2800307f7..9f2409e7a 100644
--- a/test/val/cq86.c
+++ b/test/val/cq86.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq88.c b/test/val/cq88.c
index 77bb9e88c..a15f75110 100644
--- a/test/val/cq88.c
+++ b/test/val/cq88.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
diff --git a/test/val/cq9.c b/test/val/cq9.c
index 698443ce6..228ac9e77 100644
--- a/test/val/cq9.c
+++ b/test/val/cq9.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
struct defs {
int cbits; /* No. of bits per char */
int ibits; /* int */
From 20072a379c009f24c5d6c7792265bcb26d4f7dfb Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sat, 22 Nov 2014 17:02:46 +0100
Subject: [PATCH 22/40] added makefile and common include
---
test/.gitignore | 2 ++
test/val/Makefile | 56 +++++++++++++++++++++++++++++++++++++++++++++++
test/val/common.h | 22 +++++++++++++++++++
3 files changed, 80 insertions(+)
create mode 100644 test/.gitignore
create mode 100644 test/val/Makefile
create mode 100644 test/val/common.h
diff --git a/test/.gitignore b/test/.gitignore
new file mode 100644
index 000000000..5baabe900
--- /dev/null
+++ b/test/.gitignore
@@ -0,0 +1,2 @@
+*.o
+*.prg
diff --git a/test/val/Makefile b/test/val/Makefile
new file mode 100644
index 000000000..5f93e1c34
--- /dev/null
+++ b/test/val/Makefile
@@ -0,0 +1,56 @@
+
+CC65FLAGS = -t sim6502
+
+CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
+SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
+
+RM := rm -f
+
+.PHONY: all
+
+TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.os.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.osi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.osir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.oi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.oir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.or.prg,$(wildcard *.c))
+
+all: $(TESTS)
+
+%.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $@
+
+%.o.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $@
+
+%.os.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $@
+
+%.osi.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $@
+
+%.osir.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $@
+
+%.oi.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $@
+
+%.oir.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $@
+
+%.or.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $@
+
+clean:
+ @$(RM) *.o
+ @$(RM) *.prg
diff --git a/test/val/common.h b/test/val/common.h
new file mode 100644
index 000000000..dada61a14
--- /dev/null
+++ b/test/val/common.h
@@ -0,0 +1,22 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NO_OLD_FUNC_DECL
+#define NO_TYPELESS_INT
+#define NO_TYPELESS_INT_PTR
+#define MAIN_RETURNS_INT
+#define NO_IMPLICIT_FUNC_PROTOTYPES
+#define NO_FLOATS
+#define NO_WCHAR
+#define NO_EMPTY_FUNC_ARGS
+#define NO_SLOPPY_STRUCT_INIT
+#define NO_FUNCS_TAKE_STRUCTS
+#define NO_FUNCS_RETURN_STRUCTS
+#define CAST_STRUCT_PTR
+#define NO_TYPELESS_STRUCT_PTR
+#define NO_IMPLICIT_FUNCPTR_CONV
+#define SIZEOF_INT_16BIT
+#define SIZEOF_LONG_32BIT
+#define UNSIGNED_CHARS
+#define UNSIGNED_BITFIELDS
From 6144063a6da78d74b3b251fbbe8a9e073de01935 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sat, 22 Nov 2014 18:28:05 +0100
Subject: [PATCH 23/40] fixed up the rest of the tests, added rudimentary
makefile(s)
---
test/.gitignore | 1 +
test/Makefile | 16 +++++++++++
test/err/Makefile | 42 +++++++++++++++++++++++++++++
test/ref/8q.c | 2 ++
test/ref/Makefile | 62 +++++++++++++++++++++++++++++++++++++++++++
test/ref/cc65080227.c | 2 ++
test/ref/cc65080328.c | 2 ++
test/ref/cc65090111.c | 2 ++
test/ref/cc65090124.c | 2 ++
test/ref/cc65090726.c | 2 ++
test/ref/cc65090910.c | 2 ++
test/ref/cc65090913.c | 2 ++
test/ref/cc65091007.c | 2 ++
test/ref/cc65091022.c | 2 ++
test/ref/cc65110211.c | 2 ++
test/ref/cf.c | 12 ++++++++-
test/ref/cf.in | 19 +++++++++++++
test/ref/charconst.c | 1 +
test/ref/common.h | 22 +++++++++++++++
test/ref/cvt.c | 3 +++
test/ref/fields.c | 2 ++
test/ref/init.c | 9 ++++---
test/ref/minimal.c | 2 ++
test/ref/otccex.c | 2 ++
test/ref/paranoia.c | 3 +++
test/ref/pointer2.c | 5 ++--
test/ref/spill.c | 1 +
test/ref/stdarg.c | 1 +
test/ref/struct.c | 2 ++
test/ref/switch.c | 1 +
test/ref/wf1.c | 9 +++++++
test/ref/wf1.in | 17 ++++++++++++
test/ref/yacc.c | 12 ++++++++-
test/ref/yacc.in | 1 +
test/ref/yacc2.c | 2 ++
test/val/Makefile | 19 +++++++------
36 files changed, 272 insertions(+), 16 deletions(-)
create mode 100644 test/Makefile
create mode 100644 test/err/Makefile
create mode 100644 test/ref/Makefile
create mode 100755 test/ref/cf.in
create mode 100644 test/ref/common.h
create mode 100644 test/ref/wf1.in
create mode 100755 test/ref/yacc.in
diff --git a/test/.gitignore b/test/.gitignore
index 5baabe900..ccdd4aef5 100644
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -1,2 +1,3 @@
*.o
*.prg
+*.out
diff --git a/test/Makefile b/test/Makefile
new file mode 100644
index 000000000..4c03f2cd5
--- /dev/null
+++ b/test/Makefile
@@ -0,0 +1,16 @@
+
+# toplevel makefile for the regression tests
+
+MAKE := make --no-print-dir
+
+.PHONY: all clean
+
+all:
+ @$(MAKE) -C val all
+ @$(MAKE) -C ref all
+ @$(MAKE) -C err all
+
+clean:
+ @$(MAKE) -C val clean
+ @$(MAKE) -C ref clean
+ @$(MAKE) -C err clean
diff --git a/test/err/Makefile b/test/err/Makefile
new file mode 100644
index 000000000..6f919b3d1
--- /dev/null
+++ b/test/err/Makefile
@@ -0,0 +1,42 @@
+
+# makefile for the tests that MUST NOT compile
+
+CC65FLAGS = -t sim6502
+
+CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
+SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
+
+RM := rm -f
+
+.PHONY: all
+
+TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.os.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.osi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.osir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.oi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.oir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.or.prg,$(wildcard *.c))
+
+all: $(TESTS)
+
+%.prg: %.c
+ ! $(CL65) $(CC65FLAGS) $< -o $@
+%.o.prg: %.c
+ ! $(CL65) $(CC65FLAGS) $< -o $@
+%.os.prg: %.c
+ ! $(CL65) $(CC65FLAGS) $< -o $@
+%.osi.prg: %.c
+ ! $(CL65) $(CC65FLAGS) $< -o $@
+%.osir.prg: %.c
+ ! $(CL65) $(CC65FLAGS) $< -o $@
+%.oi.prg: %.c
+ ! $(CL65) $(CC65FLAGS) $< -o $@
+%.oir.prg: %.c
+ ! $(CL65) $(CC65FLAGS) $< -o $@
+%.or.prg: %.c
+ ! $(CL65) $(CC65FLAGS) $< -o $@
+clean:
+ @$(RM) *.o
+ @$(RM) *.prg
diff --git a/test/ref/8q.c b/test/ref/8q.c
index afbe41c64..e8bd1ca2e 100644
--- a/test/ref/8q.c
+++ b/test/ref/8q.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include <stdio.h>
+
int up[15], down[15], rows[8], x[8];
void queens(int c);
void print(void);
diff --git a/test/ref/Makefile b/test/ref/Makefile
new file mode 100644
index 000000000..85cbb9bd8
--- /dev/null
+++ b/test/ref/Makefile
@@ -0,0 +1,62 @@
+
+# makefile for the regression tests that generate output which has to be
+# compared with reference output
+
+CC65FLAGS = -t sim6502
+SIM65FLAGS = -x 200000000
+
+CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
+SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
+
+RM := rm -f
+
+.PHONY: all
+
+TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.os.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.osi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.osir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.oi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.oir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.or.prg,$(wildcard *.c))
+
+all: $(TESTS)
+
+%.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $*.out
+
+%.o.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $*.out
+
+%.os.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $*.out
+
+%.osi.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $*.out
+
+%.osir.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $*.out
+
+%.oi.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $*.out
+
+%.oir.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $*.out
+
+%.or.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $*.out
+
+clean:
+ @$(RM) *.o
+ @$(RM) *.prg
+ @$(RM) *.out
+ @$(RM) *.ref
diff --git a/test/ref/cc65080227.c b/test/ref/cc65080227.c
index 4dd454b98..78afbb2c2 100644
--- a/test/ref/cc65080227.c
+++ b/test/ref/cc65080227.c
@@ -5,6 +5,8 @@
!!AUTHOR!!
*/
+#include <stdio.h>
+
long a; /* must be static life */
long b; /* must be static life */
diff --git a/test/ref/cc65080328.c b/test/ref/cc65080328.c
index 11ef73514..630638f3d 100644
--- a/test/ref/cc65080328.c
+++ b/test/ref/cc65080328.c
@@ -13,6 +13,8 @@ optimizations. If I remove the struct inside f() it compiles fine ?!?
Best, Oliver
*/
+#include <stdio.h>
+
void f(void){struct{int i;}d;}
struct{void(*p)(void);}s={f};
diff --git a/test/ref/cc65090111.c b/test/ref/cc65090111.c
index f515716f7..be889a608 100644
--- a/test/ref/cc65090111.c
+++ b/test/ref/cc65090111.c
@@ -5,6 +5,8 @@
!!AUTHOR!!
*/
+#include <stdio.h>
+
/*
cc65 doesn't compile this, if i use the "-O"-option.
but it works with "while(!0)"; instead of "for(;;);"
diff --git a/test/ref/cc65090124.c b/test/ref/cc65090124.c
index fef22268f..3f8279b27 100644
--- a/test/ref/cc65090124.c
+++ b/test/ref/cc65090124.c
@@ -5,6 +5,8 @@
!!AUTHOR!!
*/
+#include <stdio.h>
+
/*
there is a bug in the preprocessor (i think) ... the following works
(compiles) correctly:
diff --git a/test/ref/cc65090726.c b/test/ref/cc65090726.c
index fb4773afb..b260f0afd 100644
--- a/test/ref/cc65090726.c
+++ b/test/ref/cc65090726.c
@@ -5,6 +5,8 @@
!!AUTHOR!!
*/
+#include "common.h"
+
struct Record {
struct Record *PtrComp;
int x;
diff --git a/test/ref/cc65090910.c b/test/ref/cc65090910.c
index c8e5ce934..6ac5d9dcb 100644
--- a/test/ref/cc65090910.c
+++ b/test/ref/cc65090910.c
@@ -5,6 +5,8 @@
!!AUTHOR!! Oliver Schmidt
*/
+#include <stdio.h>
+
/*
After spending a "little" time I finally succeeded in isolating an
(maybe THE) optimizer bug causing Contiki to fail.
diff --git a/test/ref/cc65090913.c b/test/ref/cc65090913.c
index a319fec50..da6e37ef3 100644
--- a/test/ref/cc65090913.c
+++ b/test/ref/cc65090913.c
@@ -18,6 +18,8 @@
*/
+#include <stdio.h>
+
int foo=0,bar=2;
int main(void)
diff --git a/test/ref/cc65091007.c b/test/ref/cc65091007.c
index 1c69e02f9..31f725f8b 100644
--- a/test/ref/cc65091007.c
+++ b/test/ref/cc65091007.c
@@ -5,6 +5,8 @@
!!AUTHOR!! Johan Kotlinski
*/
+#include <stdio.h>
+
/*
This produces the compiler error "test.c(9): Error: Assignment to const"
Shouldn't be an error, should it? baz is const, bar isn't.
diff --git a/test/ref/cc65091022.c b/test/ref/cc65091022.c
index 222253992..25d197c11 100644
--- a/test/ref/cc65091022.c
+++ b/test/ref/cc65091022.c
@@ -5,6 +5,8 @@
!!AUTHOR!! Johan Kotlinski
*/
+#include <stdio.h>
+
/*
...gives "test.c(2): Error: Variable `foo' has unknown size" using -Cl.
Is it really unknown?
diff --git a/test/ref/cc65110211.c b/test/ref/cc65110211.c
index 76b3f4a70..83be84b67 100644
--- a/test/ref/cc65110211.c
+++ b/test/ref/cc65110211.c
@@ -8,6 +8,8 @@
test2 and test3 will result in an endless loop (SVN version: 4974M)
*/
+#include <stdio.h>
+
#define OPENTEST()
#define CLOSETEST()
diff --git a/test/ref/cf.c b/test/ref/cf.c
index 951f31295..66fb42b10 100644
--- a/test/ref/cf.c
+++ b/test/ref/cf.c
@@ -8,11 +8,16 @@
cf - print character frequencies
*/
+#include "common.h"
+
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
+FILE *in;
+
#define INFILE "cf.in"
+#define GETCHAR() fgetc(in)
#ifndef NO_FLOATS
float f[0x100];
@@ -35,6 +40,11 @@ char *argv[];
signed cutoff;
#endif
+ in = fopen(INFILE, "rb");
+ if (in == NULL) {
+ return EXIT_FAILURE;
+ }
+
if (argc <= 1)
#ifndef NO_FLOATS
cutoff = 0.0;
@@ -176,6 +186,6 @@ char *argv[];
#endif
}
}
-
+ fclose(in);
return 0;
}
diff --git a/test/ref/cf.in b/test/ref/cf.in
new file mode 100755
index 000000000..1b0a6f23a
--- /dev/null
+++ b/test/ref/cf.in
@@ -0,0 +1,19 @@
+start cf.input >
+The sky above the port was the color of television, tuned
+to a dead channel.
+"It's not like I'm using," Case heard someone say, as he
+shouldered his way through the crowd around the door of the
+Chat. "It's like my body's developed this massive drug deficiency."
+It was a Sprawl voice and a Sprawl joke. The Chatsubo
+was a bar for professional expatriates; you could drink there
+for a week and never hear two words in Japanese.
+Ratz was tending bar, his prosthetic arm jerking monotonously
+as he filled a tray of glasses with draft Kirin. He saw
+Case and smiled, his teeth a web work of East European steel
+and brown decay. Case found a place at the bar, between the
+unlikely tan on one of Lonny Zone's whores and the crisp naval
+uniform of a tall African whose cheekbones were ridged with
+Joe boys," Ratz said, shoving a draft across the bar with his
+good hand. "Maybe some business with you, Case?"
+Case shrugged. The girl to his right giggled and nudged
+< end cf.input
\ No newline at end of file
diff --git a/test/ref/charconst.c b/test/ref/charconst.c
index 1aa9f8e3f..65ebc70be 100644
--- a/test/ref/charconst.c
+++ b/test/ref/charconst.c
@@ -4,6 +4,7 @@
!!LICENCE!! Public Domain
*/
+#include "common.h"
#include <limits.h>
#include <ctype.h>
diff --git a/test/ref/common.h b/test/ref/common.h
new file mode 100644
index 000000000..dada61a14
--- /dev/null
+++ b/test/ref/common.h
@@ -0,0 +1,22 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NO_OLD_FUNC_DECL
+#define NO_TYPELESS_INT
+#define NO_TYPELESS_INT_PTR
+#define MAIN_RETURNS_INT
+#define NO_IMPLICIT_FUNC_PROTOTYPES
+#define NO_FLOATS
+#define NO_WCHAR
+#define NO_EMPTY_FUNC_ARGS
+#define NO_SLOPPY_STRUCT_INIT
+#define NO_FUNCS_TAKE_STRUCTS
+#define NO_FUNCS_RETURN_STRUCTS
+#define CAST_STRUCT_PTR
+#define NO_TYPELESS_STRUCT_PTR
+#define NO_IMPLICIT_FUNCPTR_CONV
+#define SIZEOF_INT_16BIT
+#define SIZEOF_LONG_32BIT
+#define UNSIGNED_CHARS
+#define UNSIGNED_BITFIELDS
diff --git a/test/ref/cvt.c b/test/ref/cvt.c
index ed7b6084e..841c1b3b2 100644
--- a/test/ref/cvt.c
+++ b/test/ref/cvt.c
@@ -4,6 +4,9 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+#include <stdio.h>
+
signed char c;
signed short s;
signed int i;
diff --git a/test/ref/fields.c b/test/ref/fields.c
index 794a81924..83bee82b7 100644
--- a/test/ref/fields.c
+++ b/test/ref/fields.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
#ifdef NO_BITFIELDS
main()
diff --git a/test/ref/init.c b/test/ref/init.c
index dc3f28a81..5a5816753 100644
--- a/test/ref/init.c
+++ b/test/ref/init.c
@@ -4,12 +4,13 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
/* todo: add back conditional stuff here ! */
typedef struct { int codes[3]; char name[6]; } Word;
-#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
-
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+
#ifdef NO_OLD_FUNC_DECL
f();
void g(Word *p);
@@ -42,8 +43,8 @@ Word 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 };
-
+int *y[] = { x[0], x[1], x[2], 0 };
+
main()
{
int i, j;
diff --git a/test/ref/minimal.c b/test/ref/minimal.c
index 5aa3c5f4f..b2e2d9d8f 100644
--- a/test/ref/minimal.c
+++ b/test/ref/minimal.c
@@ -5,6 +5,8 @@
!!AUTHOR!! Groepaz/Hitmen
*/
+#include <stdio.h>
+
int main(void)
{
#if 1
diff --git a/test/ref/otccex.c b/test/ref/otccex.c
index a967e4805..f3d6c71ec 100644
--- a/test/ref/otccex.c
+++ b/test/ref/otccex.c
@@ -4,6 +4,8 @@
!!LICENCE!! GPL (?), read COPYING.GPL
*/
+#include "common.h"
+
/*
* Sample OTCC C example. You can uncomment the first line and install
* otcc in /usr/local/bin to make otcc scripts !
diff --git a/test/ref/paranoia.c b/test/ref/paranoia.c
index 3616c9391..e9a47dd71 100644
--- a/test/ref/paranoia.c
+++ b/test/ref/paranoia.c
@@ -4,11 +4,14 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
#ifdef NO_FLOATS
main()
{
printf("NO_FLOATS\n\r");
+ return 0;
}
#else
diff --git a/test/ref/pointer2.c b/test/ref/pointer2.c
index 69d04a989..d8c064ef3 100644
--- a/test/ref/pointer2.c
+++ b/test/ref/pointer2.c
@@ -4,6 +4,7 @@
!!LICENCE!! public domain
*/
+#include "common.h"
#include <stdio.h>
/*
@@ -101,11 +102,11 @@ static void test30(void)
cc65 seems to have problems here aswell ;/
*/
-int main(void) {
+int main(void) {
test1();
test2();
test30();
test31();
/* test32(); */
- return 0;
+ return 0;
}
diff --git a/test/ref/spill.c b/test/ref/spill.c
index 2aedf0c8c..56b03d6a7 100644
--- a/test/ref/spill.c
+++ b/test/ref/spill.c
@@ -4,6 +4,7 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
#include <stdio.h>
int main(void)
diff --git a/test/ref/stdarg.c b/test/ref/stdarg.c
index b476cf338..295a2ccad 100644
--- a/test/ref/stdarg.c
+++ b/test/ref/stdarg.c
@@ -4,6 +4,7 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
#include <stdarg.h>
#ifndef NO_FUNCS_TAKE_STRUCTS
diff --git a/test/ref/struct.c b/test/ref/struct.c
index ccd74953f..a0f181e96 100644
--- a/test/ref/struct.c
+++ b/test/ref/struct.c
@@ -4,6 +4,8 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
+
typedef struct point { int x,y; } point;
typedef struct rect { point pt1, pt2; } rect;
diff --git a/test/ref/switch.c b/test/ref/switch.c
index 1fc315d90..0821d29ee 100644
--- a/test/ref/switch.c
+++ b/test/ref/switch.c
@@ -4,6 +4,7 @@
!!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/
+#include "common.h"
#include <limits.h>
#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
diff --git a/test/ref/wf1.c b/test/ref/wf1.c
index 3e9c80fb2..0539d8398 100644
--- a/test/ref/wf1.c
+++ b/test/ref/wf1.c
@@ -11,6 +11,9 @@
#define MAXWORDS 250
+FILE *in;
+#define getchar() fgetc(in)
+
struct node
{
int count; /* frequency count */
@@ -122,11 +125,17 @@ int main(void)
struct node *root;
char word[20];
+ in = fopen("wf1.in","rb");
+ if (in == NULL) {
+ return EXIT_FAILURE;
+ }
+
root = 0;
next = 0;
while (getword(word))
lookup(word, &root)->count++;
tprint(root);
+ fclose(in);
return 0;
}
diff --git a/test/ref/wf1.in b/test/ref/wf1.in
new file mode 100644
index 000000000..3e50fbac8
--- /dev/null
+++ b/test/ref/wf1.in
@@ -0,0 +1,17 @@
+The sky above the port was the color of television, tuned
+to a dead channel.
+"It's not like I'm using," Case heard someone say, as he
+shouldered his way through the crowd around the door of the
+Chat. "It's like my body's developed this massive drug deficiency."
+It was a Sprawl voice and a Sprawl joke. The Chatsubo
+was a bar for professional expatriates; you could drink there
+for a week and never hear two words in Japanese.
+Ratz was tending bar, his prosthetic arm jerking monotonously
+as he filled a tray of glasses with draft Kirin. He saw
+Case and smiled, his teeth a web work of East European steel
+and brown decay. Case found a place at the bar, between the
+unlikely tan on one of Lonny Zone's whores and the crisp naval
+uniform of a tall African whose cheekbones were ridged with
+Joe boys," Ratz said, shoving a draft across the bar with his
+good hand. "Maybe some business with you, Case?"
+Case shrugged. The girl to his right giggled and nudged
diff --git a/test/ref/yacc.c b/test/ref/yacc.c
index 3baefd348..5768f80d0 100644
--- a/test/ref/yacc.c
+++ b/test/ref/yacc.c
@@ -6,6 +6,8 @@
/*#define STANDALONE*/
+#include "common.h"
+
#ifndef YACCDBG
#include <stdio.h>
@@ -19,6 +21,9 @@
#endif
+FILE *infile, *outfile;
+#define getchar() fgetc(infile)
+
/* hack the original tables to work with both petscii and ascii */
#define CHARSETHACK
@@ -61,7 +66,6 @@ int yymorfg;
extern char *yysptr, yysbuf[];
int yytchar;
-/*FILE *yyin ={stdin}, *yyout ={stdout};*/
#define yyin infile
#define yyout outfile
@@ -665,7 +669,13 @@ yyunput(c)
main()
{
printf("main start\n");
+ infile = fopen("yacc.in","rb");
+ if (infile == NULL) {
+ return EXIT_FAILURE;
+ }
+ outfile = stdout;
yyparse();
+ fclose(infile);
printf("main end\n");
return 0;
}
diff --git a/test/ref/yacc.in b/test/ref/yacc.in
new file mode 100755
index 000000000..0b89df5d7
--- /dev/null
+++ b/test/ref/yacc.in
@@ -0,0 +1 @@
+x=(e+1)*3/(3+7)
diff --git a/test/ref/yacc2.c b/test/ref/yacc2.c
index c62fca34a..78d654ded 100644
--- a/test/ref/yacc2.c
+++ b/test/ref/yacc2.c
@@ -5,6 +5,8 @@
!!AUTHOR!! Groepaz/Hitmen
*/
+#include <stdio.h>
+
# define YYTYPE char
struct yywork
{
diff --git a/test/val/Makefile b/test/val/Makefile
index 5f93e1c34..0e4a6e94c 100644
--- a/test/val/Makefile
+++ b/test/val/Makefile
@@ -1,5 +1,8 @@
+# makefile for the regression tests that return an error code on failure
+
CC65FLAGS = -t sim6502
+SIM65FLAGS = -x 200000000
CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
@@ -21,35 +24,35 @@ all: $(TESTS)
%.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $@
+ $(SIM65) $(SIM65FLAGS) $@
%.o.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $@
+ $(SIM65) $(SIM65FLAGS) $@
%.os.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $@
+ $(SIM65) $(SIM65FLAGS) $@
%.osi.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $@
+ $(SIM65) $(SIM65FLAGS) $@
%.osir.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $@
+ $(SIM65) $(SIM65FLAGS) $@
%.oi.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $@
+ $(SIM65) $(SIM65FLAGS) $@
%.oir.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $@
+ $(SIM65) $(SIM65FLAGS) $@
%.or.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $@
+ $(SIM65) $(SIM65FLAGS) $@
clean:
@$(RM) *.o
From 20cf4e1cc7a65b1b0d57f6fb493157b016916c03 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sat, 22 Nov 2014 19:42:39 +0100
Subject: [PATCH 24/40] moved tests that need special care into misc dir
---
test/{ref => misc}/fields.c | 0
test/{ref => misc}/limits.c | 0
test/misc/sitest.c | 1591 +++++++++++++++++++++++++++++++++++
3 files changed, 1591 insertions(+)
rename test/{ref => misc}/fields.c (100%)
rename test/{ref => misc}/limits.c (100%)
create mode 100644 test/misc/sitest.c
diff --git a/test/ref/fields.c b/test/misc/fields.c
similarity index 100%
rename from test/ref/fields.c
rename to test/misc/fields.c
diff --git a/test/ref/limits.c b/test/misc/limits.c
similarity index 100%
rename from test/ref/limits.c
rename to test/misc/limits.c
diff --git a/test/misc/sitest.c b/test/misc/sitest.c
new file mode 100644
index 000000000..9570f4989
--- /dev/null
+++ b/test/misc/sitest.c
@@ -0,0 +1,1591 @@
+/*
+ !!DESCRIPTION!! C99 WCHAR test
+ !!ORIGIN!!
+ !!LICENCE!! public domain
+*/
+
+/*
+ sitest -- exercise features of C99 <stdint.h> and <inttypes.h>
+
+ 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 <inttypes.h>.
+
+ Takes advantage of __Q8_* symbols defined by a particular
+ implementation of <stdint.h>, but doesn't require them.
+
+ NOTE: This is not a thorough validation test of the facilities.
+*/
+
+#define NO_INTERNAL_WCHAR
+/*#define STANDALONE*/
+
+#include <errno.h>
+#include <limits.h> /* for CHAR_BIT */
+#include <stdio.h>
+#include <stddef.h> /* for ptrdiff_t */
+#include <stdlib.h>
+#include <string.h>
+
+#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 <inttypes.h> /* embeds <stdint.h> */
+
+#include <signal.h> /* for sig_atomic_t */
+
+#if defined(INTMAX_MAX) /* <inttypes.h> has C99 features */
+#include <wchar.h>
+#endif
+
+#include <inttypes.h> /* 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 */
+
+
+ /* <stdint.h> 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
+
+ /* <inttypes.h> 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) /* <inttypes.h> 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
From 875e0762e788301dcca836dbf32a6dad988ba41c Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sat, 22 Nov 2014 19:45:40 +0100
Subject: [PATCH 25/40] generate reference output using host compiler, compare
using diff, fix yacc input file to work on both host and sim65
---
test/.gitignore | 2 ++
test/ref/Makefile | 36 +++++++++++++++++++++++++++---------
test/ref/yacc.in | 1 +
3 files changed, 30 insertions(+), 9 deletions(-)
diff --git a/test/.gitignore b/test/.gitignore
index ccdd4aef5..6ca887d5c 100644
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -1,3 +1,5 @@
*.o
*.prg
*.out
+*.host
+*.ref
diff --git a/test/ref/Makefile b/test/ref/Makefile
index 85cbb9bd8..88d54a296 100644
--- a/test/ref/Makefile
+++ b/test/ref/Makefile
@@ -9,9 +9,14 @@ CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
RM := rm -f
+DIFF := diff -q
+
+CFLAGS := -O2 -Wall -W -Wextra -fwrapv -fno-strict-overflow
.PHONY: all
+REFS := $(patsubst %.c,%.ref,$(wildcard *.c))
+
TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
TESTS += $(patsubst %.c,%.os.prg,$(wildcard *.c))
@@ -21,42 +26,55 @@ TESTS += $(patsubst %.c,%.oi.prg,$(wildcard *.c))
TESTS += $(patsubst %.c,%.oir.prg,$(wildcard *.c))
TESTS += $(patsubst %.c,%.or.prg,$(wildcard *.c))
-all: $(TESTS)
+all: $(REFS) $(TESTS)
-%.prg: %.c
+%.ref: %.c
+ $(CC) $(CFLAGS) $< -o $*.host
+ ./$*.host > $@
+
+%.prg: %.c %.ref
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $*.out
+ $(DIFF) $*.out $*.ref
-%.o.prg: %.c
+%.o.prg: %.c %.ref
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $*.out
+ $(DIFF) $*.out $*.ref
-%.os.prg: %.c
+%.os.prg: %.c %.ref
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $*.out
+ $(DIFF) $*.out $*.ref
-%.osi.prg: %.c
+%.osi.prg: %.c %.ref
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $*.out
+ $(DIFF) $*.out $*.ref
-%.osir.prg: %.c
+%.osir.prg: %.c %.ref
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $*.out
+ $(DIFF) $*.out $*.ref
-%.oi.prg: %.c
+%.oi.prg: %.c %.ref
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $*.out
+ $(DIFF) $*.out $*.ref
-%.oir.prg: %.c
+%.oir.prg: %.c %.ref
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $*.out
+ $(DIFF) $*.out $*.ref
-%.or.prg: %.c
+%.or.prg: %.c %.ref
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $*.out
+ $(DIFF) $*.out $*.ref
clean:
@$(RM) *.o
@$(RM) *.prg
@$(RM) *.out
@$(RM) *.ref
+ @$(RM) *.host
diff --git a/test/ref/yacc.in b/test/ref/yacc.in
index 0b89df5d7..79e716878 100755
--- a/test/ref/yacc.in
+++ b/test/ref/yacc.in
@@ -1 +1,2 @@
x=(e+1)*3/(3+7)
+
\ No newline at end of file
From 4a9346d631de14f37561716522aaf5d08c0cbf6f Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sat, 22 Nov 2014 19:50:30 +0100
Subject: [PATCH 26/40] added todo
---
test/todo | 0
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 test/todo
diff --git a/test/todo b/test/todo
new file mode 100644
index 000000000..e69de29bb
From 9fe0b3817728156f7e0d51f78e66bb67eec9932a Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sat, 22 Nov 2014 21:29:26 +0100
Subject: [PATCH 27/40] added readme
---
test/readme.txt | 16 ++++++++++++++++
test/todo | 10 ++++++++++
2 files changed, 26 insertions(+)
create mode 100644 test/readme.txt
diff --git a/test/readme.txt b/test/readme.txt
new file mode 100644
index 000000000..308b2fa90
--- /dev/null
+++ b/test/readme.txt
@@ -0,0 +1,16 @@
+This directory contains test code for automatic regression testing of the CC65
+compiler.
+
+
+/val - the bulk of tests are contained here, individual tests should exit with
+ an exit code of EXIT_SUCCESS when they pass, or EXIT_FAILURE on error
+
+/ref - these tests produce output that must be compared with reference output
+
+/err - contains tests that MUST NOT compile
+
+/misc - a few tests that need special care of some sort
+
+
+to run the tests use "make clean all" in this (top) directory, the makefile
+should exit with no error.
diff --git a/test/todo b/test/todo
index e69de29bb..911eacdd3 100644
--- a/test/todo
+++ b/test/todo
@@ -0,0 +1,10 @@
+
+- the tests in ./misc need special care
+
+- check all tests in ./ref and make them return their results as exit code
+
+- in ./val use some other tool than "diff" for comparing the results
+
+- fixup makefiles to use "del" instead of "rm -f" on windows
+
+- reduce usage of "common.h" to a minimum
From 198bd893f9dd0e39ccff1e04b6d56ccd949bc44a Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sat, 22 Nov 2014 22:22:30 +0100
Subject: [PATCH 28/40] makefile for misc, endless.c
---
test/Makefile | 3 +++
test/misc/Makefile | 50 +++++++++++++++++++++++++++++++++++++++++++++
test/misc/common.h | 22 ++++++++++++++++++++
test/misc/endless.c | 13 ++++++++++++
4 files changed, 88 insertions(+)
create mode 100644 test/misc/Makefile
create mode 100644 test/misc/common.h
create mode 100644 test/misc/endless.c
diff --git a/test/Makefile b/test/Makefile
index 4c03f2cd5..65df4da4c 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -9,8 +9,11 @@ all:
@$(MAKE) -C val all
@$(MAKE) -C ref all
@$(MAKE) -C err all
+ @$(MAKE) -C misc all
clean:
@$(MAKE) -C val clean
@$(MAKE) -C ref clean
@$(MAKE) -C err clean
+ @$(MAKE) -C misc clean
+
diff --git a/test/misc/Makefile b/test/misc/Makefile
new file mode 100644
index 000000000..02f264cc6
--- /dev/null
+++ b/test/misc/Makefile
@@ -0,0 +1,50 @@
+
+CC65FLAGS = -t sim6502
+SIM65FLAGS = -x 200000000
+
+CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
+SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
+
+RM := rm -f
+DIFF := diff -q
+
+.PHONY: all
+
+TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.os.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.osi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.osir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.oi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.oir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,%.or.prg,$(wildcard *.c))
+
+all: $(TESTS)
+
+# should compile, but then hangs in an endless loop
+endless%prg: endless.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ ! $(SIM65) $(SIM65FLAGS) $@
+
+# these need reference data that cant be generated by a host compiled program
+# in a useful way
+limits%prg: limits.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > limits.out
+ $(DIFF) limits.out limits.ref
+
+# the rest are tests that fail currently for one reason or another
+fields%prg: fields.c
+ @echo "FIXME: " $@ "will currently fail"
+ $(CL65) $(CC65FLAGS) $< -o $@
+ -$(SIM65) $(SIM65FLAGS) $@
+sitest%prg: sitest.c
+ @echo "FIXME: " $@ "will currently fail"
+ -$(CL65) $(CC65FLAGS) $< -o $@
+ -$(SIM65) $(SIM65FLAGS) $@
+
+clean:
+ @$(RM) *.o
+ @$(RM) *.prg
+ @$(RM) *.out
+
diff --git a/test/misc/common.h b/test/misc/common.h
new file mode 100644
index 000000000..dada61a14
--- /dev/null
+++ b/test/misc/common.h
@@ -0,0 +1,22 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NO_OLD_FUNC_DECL
+#define NO_TYPELESS_INT
+#define NO_TYPELESS_INT_PTR
+#define MAIN_RETURNS_INT
+#define NO_IMPLICIT_FUNC_PROTOTYPES
+#define NO_FLOATS
+#define NO_WCHAR
+#define NO_EMPTY_FUNC_ARGS
+#define NO_SLOPPY_STRUCT_INIT
+#define NO_FUNCS_TAKE_STRUCTS
+#define NO_FUNCS_RETURN_STRUCTS
+#define CAST_STRUCT_PTR
+#define NO_TYPELESS_STRUCT_PTR
+#define NO_IMPLICIT_FUNCPTR_CONV
+#define SIZEOF_INT_16BIT
+#define SIZEOF_LONG_32BIT
+#define UNSIGNED_CHARS
+#define UNSIGNED_BITFIELDS
diff --git a/test/misc/endless.c b/test/misc/endless.c
new file mode 100644
index 000000000..7924d7902
--- /dev/null
+++ b/test/misc/endless.c
@@ -0,0 +1,13 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+ printf("entering endless loop\n");
+ for(;;) {
+ ;
+ }
+ printf("error: should not come here\n");
+ return EXIT_FAILURE;
+}
\ No newline at end of file
From 8a66605d5efd64828f75d5b4e3346a49d452e370 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sun, 23 Nov 2014 12:18:19 +0100
Subject: [PATCH 29/40] added some windows/cmd.exe stuff
---
test/Makefile | 8 ++++----
test/err/Makefile | 11 +++++++++--
test/misc/Makefile | 13 ++++++++++++-
test/readme.txt | 4 ++--
test/ref/Makefile | 11 ++++++++++-
test/todo | 6 ------
test/val/Makefile | 10 +++++++++-
7 files changed, 46 insertions(+), 17 deletions(-)
diff --git a/test/Makefile b/test/Makefile
index 65df4da4c..d71d5fda4 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -6,10 +6,10 @@ MAKE := make --no-print-dir
.PHONY: all clean
all:
- @$(MAKE) -C val all
- @$(MAKE) -C ref all
- @$(MAKE) -C err all
- @$(MAKE) -C misc all
+ @$(MAKE) -C val clean all
+ @$(MAKE) -C ref clean all
+ @$(MAKE) -C err clean all
+ @$(MAKE) -C misc clean all
clean:
@$(MAKE) -C val clean
diff --git a/test/err/Makefile b/test/err/Makefile
index 6f919b3d1..3ced60bc8 100644
--- a/test/err/Makefile
+++ b/test/err/Makefile
@@ -1,14 +1,21 @@
# makefile for the tests that MUST NOT compile
+ifneq ($(shell echo),)
+ CMD_EXE = 1
+endif
+
CC65FLAGS = -t sim6502
CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
-SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
+ifdef CMD_EXE
+RM := del /f
+else
RM := rm -f
+endif
-.PHONY: all
+.PHONY: all clean
TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
diff --git a/test/misc/Makefile b/test/misc/Makefile
index 02f264cc6..b9e4637d0 100644
--- a/test/misc/Makefile
+++ b/test/misc/Makefile
@@ -1,14 +1,25 @@
+# makefile for the remaining tests that need special care in one way or another
+
+ifneq ($(shell echo),)
+ CMD_EXE = 1
+endif
+
CC65FLAGS = -t sim6502
SIM65FLAGS = -x 200000000
CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
+ifdef CMD_EXE
+RM := del /f
+DIFF := fc
+else
RM := rm -f
DIFF := diff -q
+endif
-.PHONY: all
+.PHONY: all clean
TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
diff --git a/test/readme.txt b/test/readme.txt
index 308b2fa90..673ecabdb 100644
--- a/test/readme.txt
+++ b/test/readme.txt
@@ -12,5 +12,5 @@ compiler.
/misc - a few tests that need special care of some sort
-to run the tests use "make clean all" in this (top) directory, the makefile
-should exit with no error.
+to run the tests use "make" in this (top) directory, the makefile should exit
+with no error.
diff --git a/test/ref/Makefile b/test/ref/Makefile
index 88d54a296..b3b555aef 100644
--- a/test/ref/Makefile
+++ b/test/ref/Makefile
@@ -2,18 +2,27 @@
# makefile for the regression tests that generate output which has to be
# compared with reference output
+ifneq ($(shell echo),)
+ CMD_EXE = 1
+endif
+
CC65FLAGS = -t sim6502
SIM65FLAGS = -x 200000000
CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
+ifdef CMD_EXE
+RM := del /f
+DIFF := fc
+else
RM := rm -f
DIFF := diff -q
+endif
CFLAGS := -O2 -Wall -W -Wextra -fwrapv -fno-strict-overflow
-.PHONY: all
+.PHONY: all clean
REFS := $(patsubst %.c,%.ref,$(wildcard *.c))
diff --git a/test/todo b/test/todo
index 911eacdd3..75245507e 100644
--- a/test/todo
+++ b/test/todo
@@ -1,10 +1,4 @@
-- the tests in ./misc need special care
-
- check all tests in ./ref and make them return their results as exit code
-- in ./val use some other tool than "diff" for comparing the results
-
-- fixup makefiles to use "del" instead of "rm -f" on windows
-
- reduce usage of "common.h" to a minimum
diff --git a/test/val/Makefile b/test/val/Makefile
index 0e4a6e94c..e4841bd35 100644
--- a/test/val/Makefile
+++ b/test/val/Makefile
@@ -1,15 +1,23 @@
# makefile for the regression tests that return an error code on failure
+ifneq ($(shell echo),)
+ CMD_EXE = 1
+endif
+
CC65FLAGS = -t sim6502
SIM65FLAGS = -x 200000000
CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
+ifdef CMD_EXE
+RM := del /f
+else
RM := rm -f
+endif
-.PHONY: all
+.PHONY: all clean
TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
From 0079f5f6a2c83eb0891a84f45087af1f5eb1a3ad Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sun, 23 Nov 2014 12:31:47 +0100
Subject: [PATCH 30/40] checked tests in /val
---
test/todo | 2 --
1 file changed, 2 deletions(-)
diff --git a/test/todo b/test/todo
index 75245507e..08f04ad79 100644
--- a/test/todo
+++ b/test/todo
@@ -1,4 +1,2 @@
-- check all tests in ./ref and make them return their results as exit code
-
- reduce usage of "common.h" to a minimum
From e3fdbc0a4bf8832e230e011d8301ac60a48cd0f0 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sun, 23 Nov 2014 12:50:47 +0100
Subject: [PATCH 31/40] removed common.h reference
---
test/readme.txt | 7 +++++++
test/todo | 2 --
test/val/cc65091020.c | 3 +--
test/val/compare5.c | 5 -----
4 files changed, 8 insertions(+), 9 deletions(-)
delete mode 100644 test/todo
diff --git a/test/readme.txt b/test/readme.txt
index 673ecabdb..ca188878b 100644
--- a/test/readme.txt
+++ b/test/readme.txt
@@ -14,3 +14,10 @@ compiler.
to run the tests use "make" in this (top) directory, the makefile should exit
with no error.
+
+--------------------------------------------------------------------------------
+
+TODO:
+
+- reduce usage of "common.h" to a minimum
+- convert more tests from using reference output to returning an exit code
diff --git a/test/todo b/test/todo
deleted file mode 100644
index 08f04ad79..000000000
--- a/test/todo
+++ /dev/null
@@ -1,2 +0,0 @@
-
-- reduce usage of "common.h" to a minimum
diff --git a/test/val/cc65091020.c b/test/val/cc65091020.c
index 8f62f970e..d23b70a06 100644
--- a/test/val/cc65091020.c
+++ b/test/val/cc65091020.c
@@ -5,8 +5,7 @@
!!AUTHOR!! Johan Kotlinski
*/
-#include "common.h"
-
+#include <stdio.h>
#include <assert.h>
struct {
diff --git a/test/val/compare5.c b/test/val/compare5.c
index b0a9f1649..9e0c97a63 100644
--- a/test/val/compare5.c
+++ b/test/val/compare5.c
@@ -4,8 +4,6 @@
!!LICENCE!! GPL, read COPYING.GPL
*/
-#include "common.h"
-
#include <stdio.h>
#include <limits.h>
@@ -19,9 +17,6 @@ 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;
From bbd419f365d4229094bd33a61dae66bcef0f4370 Mon Sep 17 00:00:00 2001
From: peterferrie <peter.ferrie@gmail.com>
Date: Mon, 24 Nov 2014 10:07:16 -0800
Subject: [PATCH 32/40] assert parm count
---
libsrc/apple2/lseek.s | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/libsrc/apple2/lseek.s b/libsrc/apple2/lseek.s
index 058e6f53d..73f4136be 100644
--- a/libsrc/apple2/lseek.s
+++ b/libsrc/apple2/lseek.s
@@ -41,7 +41,7 @@ _lseek:
bcs einval
; Set fd
- sta mliparam + MLI::RW::REF_NUM
+ sta mliparam + MLI::MARK::REF_NUM
txa
beq cur
@@ -61,7 +61,9 @@ cur:
; SEEK_END
end:
- ldx #MARK_COUNT ; conveniently same as EOF_COUNT
+ ; MARK_COUNT must == EOF_COUNT, otherwise unexpected behaviour
+ .assert MARK_COUNT = EOF_COUNT, error
+ ldx #MARK_COUNT
jsr callmli
bcs oserr
lda mliparam + MLI::MARK::POSITION
From a0a03e5f73fa9975e3f3adb2b033588f6cd9956d Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Mon, 24 Nov 2014 20:35:35 +0100
Subject: [PATCH 33/40] added linefeeds
---
test/misc/endless.c | 2 +-
test/ref/cf.in | 2 +-
test/ref/yacc.in | 3 ++-
3 files changed, 4 insertions(+), 3 deletions(-)
diff --git a/test/misc/endless.c b/test/misc/endless.c
index 7924d7902..fe0782941 100644
--- a/test/misc/endless.c
+++ b/test/misc/endless.c
@@ -10,4 +10,4 @@ int main(void)
}
printf("error: should not come here\n");
return EXIT_FAILURE;
-}
\ No newline at end of file
+}
diff --git a/test/ref/cf.in b/test/ref/cf.in
index 1b0a6f23a..8190039e6 100755
--- a/test/ref/cf.in
+++ b/test/ref/cf.in
@@ -16,4 +16,4 @@ uniform of a tall African whose cheekbones were ridged with
Joe boys," Ratz said, shoving a draft across the bar with his
good hand. "Maybe some business with you, Case?"
Case shrugged. The girl to his right giggled and nudged
-< end cf.input
\ No newline at end of file
+< end cf.input
diff --git a/test/ref/yacc.in b/test/ref/yacc.in
index 79e716878..697b244d0 100755
--- a/test/ref/yacc.in
+++ b/test/ref/yacc.in
@@ -1,2 +1,3 @@
x=(e+1)*3/(3+7)
-
\ No newline at end of file
+
+
From 8a558a7ceff17a380fb8930f7f1dc4db85d42d16 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Mon, 24 Nov 2014 20:57:58 +0100
Subject: [PATCH 34/40] use own naive bdiff tool instead of diff/fc
---
test/Makefile | 23 ++++++++++++++++++++---
test/bdiff.c | 28 ++++++++++++++++++++++++++++
test/misc/Makefile | 4 ++--
test/ref/Makefile | 4 ++--
4 files changed, 52 insertions(+), 7 deletions(-)
create mode 100644 test/bdiff.c
diff --git a/test/Makefile b/test/Makefile
index d71d5fda4..f5f10c029 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -3,9 +3,26 @@
MAKE := make --no-print-dir
-.PHONY: all clean
+ifneq ($(shell echo),)
+ CMD_EXE = 1
+endif
-all:
+ifdef CMD_EXE
+RM := del /f
+EXE := .exe
+else
+RM := rm -f
+EXE :=
+endif
+
+.PHONY: dotests clean
+
+all: dotests
+
+bdiff:
+ @$(CC) -o bdiff$(EXE) bdiff.c
+
+dotests: bdiff
@$(MAKE) -C val clean all
@$(MAKE) -C ref clean all
@$(MAKE) -C err clean all
@@ -16,4 +33,4 @@ clean:
@$(MAKE) -C ref clean
@$(MAKE) -C err clean
@$(MAKE) -C misc clean
-
+ @$(RM) bdiff$(EXE)
diff --git a/test/bdiff.c b/test/bdiff.c
new file mode 100644
index 000000000..797ba4302
--- /dev/null
+++ b/test/bdiff.c
@@ -0,0 +1,28 @@
+
+// minimal tool to compare two binaries
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+ FILE *f1, *f2;
+ if (argc < 3) {
+ return EXIT_FAILURE;
+ }
+ f1 = fopen(argv[1], "rb");
+ f2 = fopen(argv[2], "rb");
+ if ((f1 == NULL) || (f2 == NULL)) {
+ return EXIT_FAILURE;
+ }
+ for(;;) {
+ if (feof(f1) && feof(f2)) {
+ return EXIT_SUCCESS;
+ } else if (feof(f1) || feof(f2)) {
+ return EXIT_FAILURE;
+ }
+ if (fgetc(f1) != fgetc(f2)) {
+ return EXIT_FAILURE;
+ }
+ }
+}
diff --git a/test/misc/Makefile b/test/misc/Makefile
index b9e4637d0..e3d60269d 100644
--- a/test/misc/Makefile
+++ b/test/misc/Makefile
@@ -13,12 +13,12 @@ SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
ifdef CMD_EXE
RM := del /f
-DIFF := fc
else
RM := rm -f
-DIFF := diff -q
endif
+DIFF := ./../bdiff
+
.PHONY: all clean
TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
diff --git a/test/ref/Makefile b/test/ref/Makefile
index b3b555aef..ccb52c3ba 100644
--- a/test/ref/Makefile
+++ b/test/ref/Makefile
@@ -14,12 +14,12 @@ SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
ifdef CMD_EXE
RM := del /f
-DIFF := fc
else
RM := rm -f
-DIFF := diff -q
endif
+DIFF := ./../bdiff
+
CFLAGS := -O2 -Wall -W -Wextra -fwrapv -fno-strict-overflow
.PHONY: all clean
From 9c03326360d2f8bc374b3a519a7529714bf0acb5 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Tue, 25 Nov 2014 12:56:45 +0100
Subject: [PATCH 35/40] use 'testwrk' dir for bdiff
---
.gitignore | 1 +
test/Makefile | 23 +++++++++++++++--------
test/err/Makefile | 2 ++
test/misc/Makefile | 4 +++-
test/ref/Makefile | 4 +++-
test/val/Makefile | 2 ++
6 files changed, 26 insertions(+), 10 deletions(-)
diff --git a/.gitignore b/.gitignore
index 1d5928af7..196cdc3d7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,5 +8,6 @@
/mou/
/ser/
/targetutil/
+/testwrk/
/tgi/
/wrk/
diff --git a/test/Makefile b/test/Makefile
index f5f10c029..be0360c41 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -8,21 +8,28 @@ ifneq ($(shell echo),)
endif
ifdef CMD_EXE
-RM := del /f
-EXE := .exe
+ RM := del /f
+ EXE := .exe
+ MKDIR = mkdir
else
-RM := rm -f
-EXE :=
+ RM := rm -f
+ EXE :=
+ MKDIR = mkdir -p
endif
+WORKDIR := ../testwrk
+
.PHONY: dotests clean
all: dotests
-bdiff:
- @$(CC) -o bdiff$(EXE) bdiff.c
+$(WORKDIR):
+ @$(MKDIR) $(WORKDIR)
-dotests: bdiff
+$(WORKDIR)/bdiff$(EXE): $(WORKDIR)
+ @$(CC) -o $(WORKDIR)/bdiff$(EXE) bdiff.c
+
+dotests: $(WORKDIR)/bdiff$(EXE)
@$(MAKE) -C val clean all
@$(MAKE) -C ref clean all
@$(MAKE) -C err clean all
@@ -33,4 +40,4 @@ clean:
@$(MAKE) -C ref clean
@$(MAKE) -C err clean
@$(MAKE) -C misc clean
- @$(RM) bdiff$(EXE)
+ @$(RM) $(WORKDIR)/bdiff$(EXE)
diff --git a/test/err/Makefile b/test/err/Makefile
index 3ced60bc8..fd18bf752 100644
--- a/test/err/Makefile
+++ b/test/err/Makefile
@@ -15,6 +15,8 @@ else
RM := rm -f
endif
+WORKDIR := ./../../testwrk
+
.PHONY: all clean
TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
diff --git a/test/misc/Makefile b/test/misc/Makefile
index e3d60269d..43cb6f576 100644
--- a/test/misc/Makefile
+++ b/test/misc/Makefile
@@ -17,7 +17,9 @@ else
RM := rm -f
endif
-DIFF := ./../bdiff
+WORKDIR := ./../../testwrk
+
+DIFF := $(WORKDIR)/bdiff
.PHONY: all clean
diff --git a/test/ref/Makefile b/test/ref/Makefile
index ccb52c3ba..a8d87c4c3 100644
--- a/test/ref/Makefile
+++ b/test/ref/Makefile
@@ -18,7 +18,9 @@ else
RM := rm -f
endif
-DIFF := ./../bdiff
+WORKDIR := ./../../testwrk
+
+DIFF := $(WORKDIR)/bdiff
CFLAGS := -O2 -Wall -W -Wextra -fwrapv -fno-strict-overflow
diff --git a/test/val/Makefile b/test/val/Makefile
index e4841bd35..6a40feb61 100644
--- a/test/val/Makefile
+++ b/test/val/Makefile
@@ -17,6 +17,8 @@ else
RM := rm -f
endif
+WORKDIR := ./../../testwrk
+
.PHONY: all clean
TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
From 60026925addaf1202909159bd118cc33fb3adf2b Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Tue, 25 Nov 2014 13:47:31 +0100
Subject: [PATCH 36/40] use testwrk for binaries, and generated reference data
---
test/Makefile | 3 ++
test/err/Makefile | 36 ++++++++++----------
test/misc/Makefile | 35 ++++++++++----------
test/ref/Makefile | 82 +++++++++++++++++++++++-----------------------
test/val/Makefile | 36 ++++++++++----------
5 files changed, 98 insertions(+), 94 deletions(-)
diff --git a/test/Makefile b/test/Makefile
index be0360c41..842985233 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -11,10 +11,12 @@ ifdef CMD_EXE
RM := del /f
EXE := .exe
MKDIR = mkdir
+ RMDIR = rmdir
else
RM := rm -f
EXE :=
MKDIR = mkdir -p
+ RMDIR = rmdir
endif
WORKDIR := ../testwrk
@@ -41,3 +43,4 @@ clean:
@$(MAKE) -C err clean
@$(MAKE) -C misc clean
@$(RM) $(WORKDIR)/bdiff$(EXE)
+ @$(RMDIR) $(WORKDIR)
diff --git a/test/err/Makefile b/test/err/Makefile
index fd18bf752..f7f41a03c 100644
--- a/test/err/Makefile
+++ b/test/err/Makefile
@@ -19,33 +19,33 @@ WORKDIR := ./../../testwrk
.PHONY: all clean
-TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.os.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.osi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.osir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.oi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.oir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.or.prg,$(wildcard *.c))
+TESTS := $(patsubst %.c,$(WORKDIR)/%.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.o.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.os.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.osi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.osir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.oi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.oir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.or.prg,$(wildcard *.c))
all: $(TESTS)
-%.prg: %.c
+$(WORKDIR)/%.prg: %.c
! $(CL65) $(CC65FLAGS) $< -o $@
-%.o.prg: %.c
+$(WORKDIR)/%.o.prg: %.c
! $(CL65) $(CC65FLAGS) $< -o $@
-%.os.prg: %.c
+$(WORKDIR)/%.os.prg: %.c
! $(CL65) $(CC65FLAGS) $< -o $@
-%.osi.prg: %.c
+$(WORKDIR)/%.osi.prg: %.c
! $(CL65) $(CC65FLAGS) $< -o $@
-%.osir.prg: %.c
+$(WORKDIR)/%.osir.prg: %.c
! $(CL65) $(CC65FLAGS) $< -o $@
-%.oi.prg: %.c
+$(WORKDIR)/%.oi.prg: %.c
! $(CL65) $(CC65FLAGS) $< -o $@
-%.oir.prg: %.c
+$(WORKDIR)/%.oir.prg: %.c
! $(CL65) $(CC65FLAGS) $< -o $@
-%.or.prg: %.c
+$(WORKDIR)/%.or.prg: %.c
! $(CL65) $(CC65FLAGS) $< -o $@
clean:
- @$(RM) *.o
- @$(RM) *.prg
+ @$(RM) $(TESTS)
+ @$(RM) $(patsubst %.c,$(WORKDIR)/%.o,$(wildcard *.c))
diff --git a/test/misc/Makefile b/test/misc/Makefile
index 43cb6f576..ce1956d86 100644
--- a/test/misc/Makefile
+++ b/test/misc/Makefile
@@ -23,41 +23,42 @@ DIFF := $(WORKDIR)/bdiff
.PHONY: all clean
-TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.os.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.osi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.osir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.oi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.oir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.or.prg,$(wildcard *.c))
+TESTS := $(patsubst %.c,$(WORKDIR)/%.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.o.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.os.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.osi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.osir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.oi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.oir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.or.prg,$(wildcard *.c))
all: $(TESTS)
# should compile, but then hangs in an endless loop
-endless%prg: endless.c
+$(WORKDIR)/endless%prg: endless.c
$(CL65) $(CC65FLAGS) $< -o $@
! $(SIM65) $(SIM65FLAGS) $@
# these need reference data that cant be generated by a host compiled program
# in a useful way
-limits%prg: limits.c
+$(WORKDIR)/limits%prg: limits.c
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $(SIM65FLAGS) $@ > limits.out
- $(DIFF) limits.out limits.ref
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/limits.out
+ $(DIFF) $(WORKDIR)/limits.out limits.ref
# the rest are tests that fail currently for one reason or another
-fields%prg: fields.c
+$(WORKDIR)/fields%prg: fields.c
@echo "FIXME: " $@ "will currently fail"
$(CL65) $(CC65FLAGS) $< -o $@
-$(SIM65) $(SIM65FLAGS) $@
-sitest%prg: sitest.c
+$(WORKDIR)/sitest%prg: sitest.c
@echo "FIXME: " $@ "will currently fail"
-$(CL65) $(CC65FLAGS) $< -o $@
-$(SIM65) $(SIM65FLAGS) $@
clean:
- @$(RM) *.o
- @$(RM) *.prg
- @$(RM) *.out
+ @$(RM) $(TESTS)
+ @$(RM) $(patsubst %.c,$(WORKDIR)/%.o,$(wildcard *.c))
+ @$(RM) $(patsubst %.c,$(WORKDIR)/%.out,$(wildcard *.c))
+
diff --git a/test/ref/Makefile b/test/ref/Makefile
index a8d87c4c3..f14db3ecf 100644
--- a/test/ref/Makefile
+++ b/test/ref/Makefile
@@ -26,66 +26,66 @@ CFLAGS := -O2 -Wall -W -Wextra -fwrapv -fno-strict-overflow
.PHONY: all clean
-REFS := $(patsubst %.c,%.ref,$(wildcard *.c))
+REFS := $(patsubst %.c,$(WORKDIR)/%.ref,$(wildcard *.c))
-TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.os.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.osi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.osir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.oi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.oir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.or.prg,$(wildcard *.c))
+TESTS := $(patsubst %.c,$(WORKDIR)/%.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.o.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.os.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.osi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.osir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.oi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.oir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.or.prg,$(wildcard *.c))
all: $(REFS) $(TESTS)
-%.ref: %.c
- $(CC) $(CFLAGS) $< -o $*.host
- ./$*.host > $@
+$(WORKDIR)/%.ref: %.c
+ $(CC) $(CFLAGS) $< -o $(WORKDIR)/$*.host
+ $(WORKDIR)/$*.host > $@
-%.prg: %.c %.ref
+$(WORKDIR)/%.prg: %.c $(WORKDIR)/%.ref
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $(SIM65FLAGS) $@ > $*.out
- $(DIFF) $*.out $*.ref
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
-%.o.prg: %.c %.ref
+$(WORKDIR)/%.o.prg: %.c $(WORKDIR)/%.ref
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $(SIM65FLAGS) $@ > $*.out
- $(DIFF) $*.out $*.ref
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
-%.os.prg: %.c %.ref
+$(WORKDIR)/%.os.prg: %.c $(WORKDIR)/%.ref
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $(SIM65FLAGS) $@ > $*.out
- $(DIFF) $*.out $*.ref
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
-%.osi.prg: %.c %.ref
+$(WORKDIR)/%.osi.prg: %.c $(WORKDIR)/%.ref
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $(SIM65FLAGS) $@ > $*.out
- $(DIFF) $*.out $*.ref
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
-%.osir.prg: %.c %.ref
+$(WORKDIR)/%.osir.prg: %.c $(WORKDIR)/%.ref
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $(SIM65FLAGS) $@ > $*.out
- $(DIFF) $*.out $*.ref
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
-%.oi.prg: %.c %.ref
+$(WORKDIR)/%.oi.prg: %.c $(WORKDIR)/%.ref
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $(SIM65FLAGS) $@ > $*.out
- $(DIFF) $*.out $*.ref
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
-%.oir.prg: %.c %.ref
+$(WORKDIR)/%.oir.prg: %.c $(WORKDIR)/%.ref
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $(SIM65FLAGS) $@ > $*.out
- $(DIFF) $*.out $*.ref
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
-%.or.prg: %.c %.ref
+$(WORKDIR)/%.or.prg: %.c $(WORKDIR)/%.ref
$(CL65) $(CC65FLAGS) $< -o $@
- $(SIM65) $(SIM65FLAGS) $@ > $*.out
- $(DIFF) $*.out $*.ref
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
clean:
- @$(RM) *.o
- @$(RM) *.prg
- @$(RM) *.out
- @$(RM) *.ref
- @$(RM) *.host
+ @$(RM) $(TESTS)
+ @$(RM) $(patsubst %.c,$(WORKDIR)/%.o,$(wildcard *.c))
+ @$(RM) $(patsubst %.c,$(WORKDIR)/%.out,$(wildcard *.c))
+ @$(RM) $(patsubst %.c,$(WORKDIR)/%.ref,$(wildcard *.c))
+ @$(RM) $(patsubst %.c,$(WORKDIR)/%.host,$(wildcard *.c))
diff --git a/test/val/Makefile b/test/val/Makefile
index 6a40feb61..591f95389 100644
--- a/test/val/Makefile
+++ b/test/val/Makefile
@@ -21,49 +21,49 @@ WORKDIR := ./../../testwrk
.PHONY: all clean
-TESTS := $(patsubst %.c,%.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.o.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.os.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.osi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.osir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.oi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.oir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,%.or.prg,$(wildcard *.c))
+TESTS := $(patsubst %.c,$(WORKDIR)/%.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.o.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.os.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.osi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.osir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.oi.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.oir.prg,$(wildcard *.c))
+TESTS += $(patsubst %.c,$(WORKDIR)/%.or.prg,$(wildcard *.c))
all: $(TESTS)
-%.prg: %.c
+$(WORKDIR)/%.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
-%.o.prg: %.c
+$(WORKDIR)/%.o.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
-%.os.prg: %.c
+$(WORKDIR)/%.os.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
-%.osi.prg: %.c
+$(WORKDIR)/%.osi.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
-%.osir.prg: %.c
+$(WORKDIR)/%.osir.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
-%.oi.prg: %.c
+$(WORKDIR)/%.oi.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
-%.oir.prg: %.c
+$(WORKDIR)/%.oir.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
-%.or.prg: %.c
+$(WORKDIR)/%.or.prg: %.c
$(CL65) $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
clean:
- @$(RM) *.o
- @$(RM) *.prg
+ @$(RM) $(TESTS)
+ @$(RM) $(patsubst %.c,$(WORKDIR)/%.o,$(wildcard *.c))
From 5f727ea56b1e0fe21a31d75c1a160858a5693563 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Tue, 25 Nov 2014 14:16:39 +0100
Subject: [PATCH 37/40] removed binaries and references from git ignore
---
test/.gitignore | 4 ----
1 file changed, 4 deletions(-)
diff --git a/test/.gitignore b/test/.gitignore
index 6ca887d5c..5761abcfd 100644
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -1,5 +1 @@
*.o
-*.prg
-*.out
-*.host
-*.ref
From 3e8ae54759757b441901f471f2a6c0c3ab5974bd Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Wed, 26 Nov 2014 01:38:30 +0100
Subject: [PATCH 38/40] actually use optimization switches
---
test/Makefile | 6 ++++++
test/err/Makefile | 14 +++++++-------
test/misc/Makefile | 2 ++
test/ref/Makefile | 14 +++++++-------
test/val/Makefile | 14 +++++++-------
5 files changed, 29 insertions(+), 21 deletions(-)
diff --git a/test/Makefile b/test/Makefile
index 842985233..b942cbcdf 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -37,6 +37,12 @@ dotests: $(WORKDIR)/bdiff$(EXE)
@$(MAKE) -C err clean all
@$(MAKE) -C misc clean all
+continue: $(WORKDIR)/bdiff$(EXE)
+ @$(MAKE) -C val all
+ @$(MAKE) -C ref all
+ @$(MAKE) -C err all
+ @$(MAKE) -C misc all
+
clean:
@$(MAKE) -C val clean
@$(MAKE) -C ref clean
diff --git a/test/err/Makefile b/test/err/Makefile
index f7f41a03c..f0fcf3486 100644
--- a/test/err/Makefile
+++ b/test/err/Makefile
@@ -33,19 +33,19 @@ all: $(TESTS)
$(WORKDIR)/%.prg: %.c
! $(CL65) $(CC65FLAGS) $< -o $@
$(WORKDIR)/%.o.prg: %.c
- ! $(CL65) $(CC65FLAGS) $< -o $@
+ ! $(CL65) -O $(CC65FLAGS) $< -o $@
$(WORKDIR)/%.os.prg: %.c
- ! $(CL65) $(CC65FLAGS) $< -o $@
+ ! $(CL65) -Os $(CC65FLAGS) $< -o $@
$(WORKDIR)/%.osi.prg: %.c
- ! $(CL65) $(CC65FLAGS) $< -o $@
+ ! $(CL65) -Osi $(CC65FLAGS) $< -o $@
$(WORKDIR)/%.osir.prg: %.c
- ! $(CL65) $(CC65FLAGS) $< -o $@
+ ! $(CL65) -Osir $(CC65FLAGS) $< -o $@
$(WORKDIR)/%.oi.prg: %.c
- ! $(CL65) $(CC65FLAGS) $< -o $@
+ ! $(CL65) -Oi $(CC65FLAGS) $< -o $@
$(WORKDIR)/%.oir.prg: %.c
- ! $(CL65) $(CC65FLAGS) $< -o $@
+ ! $(CL65) -Oir $(CC65FLAGS) $< -o $@
$(WORKDIR)/%.or.prg: %.c
- ! $(CL65) $(CC65FLAGS) $< -o $@
+ ! $(CL65) -Or $(CC65FLAGS) $< -o $@
clean:
@$(RM) $(TESTS)
@$(RM) $(patsubst %.c,$(WORKDIR)/%.o,$(wildcard *.c))
diff --git a/test/misc/Makefile b/test/misc/Makefile
index ce1956d86..0fa550d3f 100644
--- a/test/misc/Makefile
+++ b/test/misc/Makefile
@@ -32,6 +32,8 @@ TESTS += $(patsubst %.c,$(WORKDIR)/%.oi.prg,$(wildcard *.c))
TESTS += $(patsubst %.c,$(WORKDIR)/%.oir.prg,$(wildcard *.c))
TESTS += $(patsubst %.c,$(WORKDIR)/%.or.prg,$(wildcard *.c))
+# FIXME: actually use/build differently optimized programs here
+
all: $(TESTS)
# should compile, but then hangs in an endless loop
diff --git a/test/ref/Makefile b/test/ref/Makefile
index f14db3ecf..2a465b500 100644
--- a/test/ref/Makefile
+++ b/test/ref/Makefile
@@ -49,37 +49,37 @@ $(WORKDIR)/%.prg: %.c $(WORKDIR)/%.ref
$(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
$(WORKDIR)/%.o.prg: %.c $(WORKDIR)/%.ref
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -O $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
$(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
$(WORKDIR)/%.os.prg: %.c $(WORKDIR)/%.ref
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Os $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
$(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
$(WORKDIR)/%.osi.prg: %.c $(WORKDIR)/%.ref
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Osi $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
$(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
$(WORKDIR)/%.osir.prg: %.c $(WORKDIR)/%.ref
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Osir $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
$(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
$(WORKDIR)/%.oi.prg: %.c $(WORKDIR)/%.ref
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Oi $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
$(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
$(WORKDIR)/%.oir.prg: %.c $(WORKDIR)/%.ref
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Oir $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
$(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
$(WORKDIR)/%.or.prg: %.c $(WORKDIR)/%.ref
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Or $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
$(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
diff --git a/test/val/Makefile b/test/val/Makefile
index 591f95389..2dc4796e6 100644
--- a/test/val/Makefile
+++ b/test/val/Makefile
@@ -37,31 +37,31 @@ $(WORKDIR)/%.prg: %.c
$(SIM65) $(SIM65FLAGS) $@
$(WORKDIR)/%.o.prg: %.c
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -O $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
$(WORKDIR)/%.os.prg: %.c
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Os $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
$(WORKDIR)/%.osi.prg: %.c
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Osi $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
$(WORKDIR)/%.osir.prg: %.c
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Osir $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
$(WORKDIR)/%.oi.prg: %.c
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Oi $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
$(WORKDIR)/%.oir.prg: %.c
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Oir $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
$(WORKDIR)/%.or.prg: %.c
- $(CL65) $(CC65FLAGS) $< -o $@
+ $(CL65) -Or $(CC65FLAGS) $< -o $@
$(SIM65) $(SIM65FLAGS) $@
clean:
From 0387b8cf1df20990613af01da72d1986fbcf1920 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Wed, 26 Nov 2014 14:22:22 +0100
Subject: [PATCH 39/40] added note on how to continue after failure, added
missing limits.ref
---
test/misc/limits.ref | 24 ++++++++++++++++++++++++
test/readme.txt | 2 ++
2 files changed, 26 insertions(+)
create mode 100644 test/misc/limits.ref
diff --git a/test/misc/limits.ref b/test/misc/limits.ref
new file mode 100644
index 000000000..9be906beb
--- /dev/null
+++ b/test/misc/limits.ref
@@ -0,0 +1,24 @@
+CHAR_MAX: 0x000000ff=255
+UCHAR_MAX: 0x000000ff=255
+SCHAR_MAX: 0x0000007f=127
+SHRT_MAX: 0x00007fff=32767
+USHRT_MAX: 0x0000ffff=-1
+SSHRT_MAX: 0x00007fff=32767
+INT_MAX: 0x00007fff=32767
+UINT_MAX: 0x0000ffff=-1
+SINT_MAX: 0x00007fff=32767
+LONG_MAX: 0x7fffffff=2147483647
+ULONG_MAX: 0xffffffff=-1
+SLONG_MAX: 0x7fffffff=2147483647
+CHAR_MIN: 0x00000000=0
+UCHAR_MIN: 0x00000000=0
+SCHAR_MIN: 0x0000ff80=-128
+SHRT_MIN: 0x00008000=-32768
+USHRT_MIN: 0x00000000=0
+SSHRT_MIN: 0x00008000=-32768
+INT_MIN: 0x00008000=-32768
+UINT_MIN: 0x00000000=0
+SINT_MIN: 0x00008000=-32768
+LONG_MIN: 0x80000000=-2147483648
+ULONG_MIN: 0x00000000=0
+SLONG_MIN: 0x80000000=-2147483648
diff --git a/test/readme.txt b/test/readme.txt
index ca188878b..cd3b7501a 100644
--- a/test/readme.txt
+++ b/test/readme.txt
@@ -15,6 +15,8 @@ compiler.
to run the tests use "make" in this (top) directory, the makefile should exit
with no error.
+when a test failed you can use "make continue" to run further tests
+
--------------------------------------------------------------------------------
TODO:
From 92ed5fd64b0d9786fe3a3b59efd716d2855ad619 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Wed, 26 Nov 2014 19:32:54 +0100
Subject: [PATCH 40/40] scan sources just once
---
test/err/Makefile | 19 ++++++++++---------
test/misc/Makefile | 21 +++++++++++----------
test/ref/Makefile | 25 +++++++++++++------------
test/val/Makefile | 19 ++++++++++---------
4 files changed, 44 insertions(+), 40 deletions(-)
diff --git a/test/err/Makefile b/test/err/Makefile
index f0fcf3486..40ccfcb59 100644
--- a/test/err/Makefile
+++ b/test/err/Makefile
@@ -19,14 +19,15 @@ WORKDIR := ./../../testwrk
.PHONY: all clean
-TESTS := $(patsubst %.c,$(WORKDIR)/%.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.o.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.os.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.osi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.osir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.oi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.oir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.or.prg,$(wildcard *.c))
+SOURCES := $(wildcard *.c)
+TESTS := $(SOURCES:%.c=$(WORKDIR)/%.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.o.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.os.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.osi.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.osir.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.oi.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.oir.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.or.prg)
all: $(TESTS)
@@ -48,4 +49,4 @@ $(WORKDIR)/%.or.prg: %.c
! $(CL65) -Or $(CC65FLAGS) $< -o $@
clean:
@$(RM) $(TESTS)
- @$(RM) $(patsubst %.c,$(WORKDIR)/%.o,$(wildcard *.c))
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.o)
diff --git a/test/misc/Makefile b/test/misc/Makefile
index 0fa550d3f..b18d9165e 100644
--- a/test/misc/Makefile
+++ b/test/misc/Makefile
@@ -23,14 +23,15 @@ DIFF := $(WORKDIR)/bdiff
.PHONY: all clean
-TESTS := $(patsubst %.c,$(WORKDIR)/%.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.o.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.os.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.osi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.osir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.oi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.oir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.or.prg,$(wildcard *.c))
+SOURCES := $(wildcard *.c)
+TESTS := $(SOURCES:%.c=$(WORKDIR)/%.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.o.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.os.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.osi.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.osir.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.oi.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.oir.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.or.prg)
# FIXME: actually use/build differently optimized programs here
@@ -60,7 +61,7 @@ $(WORKDIR)/sitest%prg: sitest.c
clean:
@$(RM) $(TESTS)
- @$(RM) $(patsubst %.c,$(WORKDIR)/%.o,$(wildcard *.c))
- @$(RM) $(patsubst %.c,$(WORKDIR)/%.out,$(wildcard *.c))
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.o)
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.out)
diff --git a/test/ref/Makefile b/test/ref/Makefile
index 2a465b500..b752adc1d 100644
--- a/test/ref/Makefile
+++ b/test/ref/Makefile
@@ -28,14 +28,15 @@ CFLAGS := -O2 -Wall -W -Wextra -fwrapv -fno-strict-overflow
REFS := $(patsubst %.c,$(WORKDIR)/%.ref,$(wildcard *.c))
-TESTS := $(patsubst %.c,$(WORKDIR)/%.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.o.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.os.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.osi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.osir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.oi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.oir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.or.prg,$(wildcard *.c))
+SOURCES := $(wildcard *.c)
+TESTS := $(SOURCES:%.c=$(WORKDIR)/%.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.o.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.os.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.osi.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.osir.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.oi.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.oir.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.or.prg)
all: $(REFS) $(TESTS)
@@ -85,7 +86,7 @@ $(WORKDIR)/%.or.prg: %.c $(WORKDIR)/%.ref
clean:
@$(RM) $(TESTS)
- @$(RM) $(patsubst %.c,$(WORKDIR)/%.o,$(wildcard *.c))
- @$(RM) $(patsubst %.c,$(WORKDIR)/%.out,$(wildcard *.c))
- @$(RM) $(patsubst %.c,$(WORKDIR)/%.ref,$(wildcard *.c))
- @$(RM) $(patsubst %.c,$(WORKDIR)/%.host,$(wildcard *.c))
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.o)
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.out)
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.ref)
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.host)
diff --git a/test/val/Makefile b/test/val/Makefile
index 2dc4796e6..2e0aca278 100644
--- a/test/val/Makefile
+++ b/test/val/Makefile
@@ -21,14 +21,15 @@ WORKDIR := ./../../testwrk
.PHONY: all clean
-TESTS := $(patsubst %.c,$(WORKDIR)/%.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.o.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.os.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.osi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.osir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.oi.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.oir.prg,$(wildcard *.c))
-TESTS += $(patsubst %.c,$(WORKDIR)/%.or.prg,$(wildcard *.c))
+SOURCES := $(wildcard *.c)
+TESTS := $(SOURCES:%.c=$(WORKDIR)/%.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.o.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.os.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.osi.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.osir.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.oi.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.oir.prg)
+TESTS += $(SOURCES:%.c=$(WORKDIR)/%.or.prg)
all: $(TESTS)
@@ -66,4 +67,4 @@ $(WORKDIR)/%.or.prg: %.c
clean:
@$(RM) $(TESTS)
- @$(RM) $(patsubst %.c,$(WORKDIR)/%.o,$(wildcard *.c))
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.o)