the10thwiz/cc65
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added tests as prepared by oliver

Browse Source
This commit is contained in:
mrdudz
2014-09-24 16:45:10 +02:00
committed by Ingo Korb
parent d75f9c2051
commit ca300826cf
121 changed files with 25206 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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 <20> 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 <20>APtr=(TypA*)&(Bs[7].Data[1]);
seems to work.
greetings,
<EFBFBD> <20>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"