empathicqubit/cc65
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #135 from ikorb/patch1

Browse source 
added tests as prepared by oliver
This commit is contained in:
Oliver Schmidt 2014-09-25 21:50:28 +02:00
commit 295604b31f
121 changed files with 25206 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
test/err/cc65091001.c Normal file
View file

@ -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;
}

133
test/err/front.c Normal file
View file

@ -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 */
}

47
test/ref/8q.c Normal file
View file

@ -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");
}

62
test/ref/array.c Normal file
View file

@ -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");
}

38
test/ref/cc65070303.c Normal file
View file

@ -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
*/

37
test/ref/cc65080227.c Normal file
View file

@ -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 !
*/

24
test/ref/cc65080328.c Normal file
View file

@ -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;
}

49
test/ref/cc65090111.c Normal file
View file

@ -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;
}

61
test/ref/cc65090124.c Normal file
View file

@ -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;
}

46
test/ref/cc65090726.c Normal file
View file

@ -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;
}

26
test/ref/cc65090910.c Normal file
View file

@ -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;
}

31
test/ref/cc65090913.c Normal file
View file

@ -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;
}

27
test/ref/cc65091007.c Normal file
View file

@ -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;
}

20
test/ref/cc65091022.c Normal file
View file

@ -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;
}

56
test/ref/cc65101102.c Normal file
View file

@ -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;
}

38
test/ref/cc65101209.c Normal file
View file

@ -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.
*/

27
test/ref/cc65101216.c Normal file
View file

@ -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;
}

55
test/ref/cc65110210.c Normal file
View file

@ -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);
}

80
test/ref/cc65110211.c Normal file
View file

@ -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;
}

181
test/ref/cf.c Normal file
View file

@ -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;
}

59
test/ref/charconst.c Normal file
View file

@ -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;
}

93
test/ref/charset.c Normal file
View file

@ -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;
}

53
test/ref/cvt.c Normal file
View file

@ -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;
}

369
test/ref/dijkstra.c Normal file
View file

@ -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;
}

38
test/ref/divmod.c Normal file
View file

@ -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;
}

92
test/ref/fields.c Normal file
View file

@ -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

90
test/ref/hanoi.c Normal file
View file

@ -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;
}

36
test/ref/ifexpr.c Normal file
View file

@ -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;
}

51
test/ref/incr.c Normal file
View file

@ -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;
}

94
test/ref/init.c Normal file
View file

@ -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]);
}

56
test/ref/limits.c Normal file
View file

@ -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;
}

30
test/ref/macro.c Normal file
View file

@ -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;
}

84
test/ref/mandel.c Normal file
View file

@ -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;
}

14
test/ref/minimal.c Normal file
View file

@ -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;
}

148
test/ref/otccex.c Normal file
View file

@ -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;
}

2216
test/ref/paranoia.c Normal file
View file

File diff suppressed because it is too large Load diff

111
test/ref/pointer2.c Normal file
View file

@ -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;
}

96
test/ref/return.c Normal file
View file

@ -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;
}

75
test/ref/sort.c Normal file
View file

@ -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;
}

55
test/ref/spill.c Normal file
View file

@ -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];
}

93
test/ref/stdarg.c Normal file
View file

@ -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);
}

130
test/ref/strptr.c Normal file
View file

@ -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;
}

261
test/ref/struct.c Normal file
View file

@ -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 */

216
test/ref/switch.c Normal file
View file

@ -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;
}
}

262
test/ref/switch2.c Normal file
View file

@ -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;
}

105
test/ref/varargs.c Normal file
View file

@ -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;
}

132
test/ref/wf1.c Normal file
View file

@ -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;
}

996
test/ref/yacc.c Normal file
View file

@ -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;
}

227
test/ref/yacc2.c Normal file
View file

@ -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;
}

19
test/ref/yaccdbg.c Normal file
View file

@ -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"

181
test/val/add1.c Normal file
View file

@ -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;
}

BIN
test/val/add1.o Normal file
View file

Binary file not shown.

BIN
test/val/add1.prg Normal file
View file

Binary file not shown.

328
test/val/add2.c Normal file
View file

@ -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;
}

263
test/val/add3.c Normal file
View file

@ -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;
}

BIN
test/val/add3.o Normal file
View file

Binary file not shown.

BIN
test/val/add3.prg Normal file
View file

Binary file not shown.

94
test/val/add4.c Normal file
View file

@ -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;
}

BIN
test/val/add4.o Normal file
View file

Binary file not shown.

BIN
test/val/add4.prg Normal file
View file

Binary file not shown.

145
test/val/and1.c Normal file
View file

@ -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;
}

118
test/val/and2.c Normal file
View file

@ -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;
}

42
test/val/atoi-test.c Normal file
View file

@ -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;
}

130
test/val/bool1.c Normal file
View file

@ -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;
}

66
test/val/bool3.c Normal file
View file

@ -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;
}

157
test/val/call1.c Normal file
View file

@ -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;
}

26
test/val/cc65091020.c Normal file
View file

@ -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) */

183
test/val/compare1.c Normal file
View file

@ -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;
}

319
test/val/compare10.c Normal file
View file

@ -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;
}

362
test/val/compare2.c Normal file
View file

@ -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;
}

246
test/val/compare3.c Normal file
View file

@ -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;
}

349
test/val/compare4.c Normal file
View file

@ -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;
}

445
test/val/compare5.c Normal file
View file

@ -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;
}

176
test/val/compare6.c Normal file
View file

@ -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;
}

307
test/val/compare7.c Normal file
View file

@ -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;
}

311
test/val/compare8.c Normal file
View file

@ -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;
}

297
test/val/compare9.c Normal file
View file

@ -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;
}

144
test/val/cq22.c Normal file
View file

@ -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;
}

286
test/val/cq241.c Normal file
View file

@ -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;
}

264
test/val/cq243.c Normal file
View file

@ -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;
}

159
test/val/cq244.c Normal file
View file

@ -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;
}

171
test/val/cq25.c Normal file
View file

@ -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;
}

217
test/val/cq26.c Normal file
View file

@ -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

242
test/val/cq4.c Normal file
View file

@ -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 = 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;
}

186
test/val/cq61.c Normal file
View file

@ -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;
}

337
test/val/cq626.c Normal file
View file

@ -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;
}

240
test/val/cq71.c Normal file
View file

@ -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;
}

1795
test/val/cq714.c Normal file
View file

File diff suppressed because it is too large Load diff

1016
test/val/cq714b.c Normal file
View file

File diff suppressed because it is too large Load diff

151
test/val/cq715.c Normal file
View file

@ -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;
}

345
test/val/cq72.c Normal file
View file

@ -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;
}

335
test/val/cq757.c Normal file
View file

@ -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&lt) == 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;
}

381
test/val/cq7813.c Normal file
View file

@ -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;
}

727
test/val/cq81.c Normal file
View file

@ -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;
}

268
test/val/cq84.c Normal file
View file

@ -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;
}

313
test/val/cq85.c Normal file
View file

@ -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;
}

228
test/val/cq86.c Normal file
View file

@ -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;
}

184
test/val/cq88.c Normal file
View file

@ -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;
}

154
test/val/cq9.c Normal file
View file

@ -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;
}

109
test/val/for.c Normal file
View file

@ -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;
}

Some files were not shown because too many files have changed in this diff Show more