--- /dev/null
+struct a d end;
+method f(b c s)
+ var t := 0;
+ /* lesender feldzugriff */
+ b := c*(s.a - 1);
+ b := c*(s.d - 1);
+ b := c*(t.a - 1);
+ /* Zusatz zu lewurm_05.0: ungültig, da c keine Feldvariable ist */
+ b := c*(t.c - 1);
+end;
--- /dev/null
+method test(arg1)
+ arg1.a := 10; /* undefined field */
+end;
+
+struct a end;
--- /dev/null
+method test(arg1)
+ var b := arg1.a; /* undefined field */
+end;
+
+struct a end;
--- /dev/null
+/* multiple field definition on "doubletrouble" here */
+struct doubletrouble foo end;
+method test(a b c)
+end;
+struct bar doubletrouble end;
--- /dev/null
+/* multiple variable definition in param list */
+method test(a b c a)
+end;
--- /dev/null
+/* fieldnames are NOT visible everywhere, but only after their definition */
+method foobar(a)
+ a.youdontseemeyet := 31337;
+end;
+
+struct youdontseemeyet end;
--- /dev/null
+method f(a b c)
+ /* x nicht deklariert */
+ if a < x then
+ c := 0x1;
+ end;
+end;
--- /dev/null
+method f(a b c)
+ if a < b then
+ var x := 0;
+ c := 1;
+ end;
+ /* x ist nicht im scope */
+ x := x - 1;
+end;
--- /dev/null
+method f(a b c)
+ /* x ist (noch) nicht im scope */
+ var x := x - 1;
+end;
--- /dev/null
+method f(b)
+ var t := 0;
+ /* identifier doppelt vorhanden */
+ var b := 0;
+end;
--- /dev/null
+struct mystruct
+end
--- /dev/null
+method testit()
+ var b := 10 - d * 20; /* should raise an error, since '(' ')' are missing */
+end;
--- /dev/null
+method abc(arg1 arg2)
+ if arg1 = arg2 then
+ var a := 42;
+ end;
+
+ var b := a - -1;
+end;
--- /dev/null
+struct a b c end;
+method test(arg1 arg2)
+ arg1.a := 10;
+end;
+
+struct c d e end;
--- /dev/null
+method abc(arg1 arg2)
+ var arg2 := 10; /* detect duplicates and fail */
+end;
--- /dev/null
+struct
+ a b c
+end;
+
+method bar(d e f)
+ var foo := a;
+ foo := b - c;
+ var bar := d - (e * f);
+
+ if(4 = 2) then
+ var x := 1;
+ var hiho := 0;
+ else
+ var hiho := 0x1f;
+ end;
+
+ var hiho := 2;
+
+ while 0 < hiho do
+ if (42) then
+ var hiho := 0xff; /* hiho existiert bereits */
+ hiho := hiho - 1;
+ end;
+ end;
+
+ return 0;
+end;
+
+struct
+ g
+ h
+end;
--- /dev/null
+struct
+ a b c
+end;
+
+method bar(d e f)
+ var foo := a;
+ foo := b - c;
+ var bar := d - (e * f);
+
+ if(4 = 2) then
+ var x := 1;
+ var hiho := 0;
+ else
+ var hiho := 0x1f;
+ end;
+
+ var hiho := 2;
+
+ while 0 < hiho do
+ if (42) then
+ hiho := hiho - 1;
+ else
+ hiho := hiho - (0 - g); /* g existiert noch nicht */
+ end;
+ end;
+
+ return 0;
+end;
+
+struct
+ g
+ h
+end;
--- /dev/null
+struct
+ a b c
+end;
+
+method bar(d e f)
+ var foo := a;
+ foo := b - c;
+ var bar := d - (e * f);
+
+ if(4 = 2) then
+ var x := 1;
+ var hiho := 0;
+ else
+ var hiho := 0x1f;
+ end;
+
+ var hiho := 2;
+
+ while 0 < hiho do
+ if (42) then
+ hiho := hiho - 1;
+ else
+ hiho := hiho - (0 - a);
+ end;
+ end;
+
+ var e := 22; /* e existiert bereits */
+ return 0;
+end;
+
+struct
+ g
+ h
+end;
--- /dev/null
+struct
+ a b c
+end;
+
+method bar(d e f)
+ var foo := a;
+ foo := b - c;
+ var bar := d - (e * f);
+
+ if(4 = 2) then
+ var x := 1;
+ var hiho := 0;
+ else
+ var hiho := 0x1f;
+ end;
+
+ if(9 < 8) then
+ var hohi := 12;
+ else
+ var hiho := 2;
+ end;
+
+
+ return hiho; /* hiho existiert nicht */
+end;
+
+struct
+ g
+ h
+end;
--- /dev/null
+struct g1 g2 g3 g4 end;
+struct g5 g6 end;
+
+method foo(p1 p2 p3)
+ var l1 := 0;
+ var l2 := g6;
+
+ g1.g2.l1 := 0xDEAD; /* l1 kein feld */
+end;
--- /dev/null
+struct g1 g2 g3 g4 end;
+struct g5 g6 end;
+
+method foo(p1 p2 p3)
+ var l1 := 0;
+ var l2 := g6;
+
+ g1.g2.p1 := 0xDEAD; /* p1 kein feld */
+end;
--- /dev/null
+struct g1 g2 g3 g4 end;
+struct g5 g6 end;
+
+method foo(p1 p2 p3)
+ var l1 := 0;
+ var l2 := g6;
+
+ g1.l2.g2 := 0xDEAD; /* l2 kein feld */
+end;
--- /dev/null
+struct g1 g2 g3 g4 end;
+struct g5 g6 end;
+
+method foo(p1 p2 p3)
+ var l1 := 0;
+ var l2 := g6;
+
+ g1.p3.g6:= 0xDEAD; /* p3 kein feld */
+end;
--- /dev/null
+struct
+ one struct_not defined
+end;
+
+method main(a b)
+ var something := 0x42;
+ var the := 0x42;
+ the.one.missing_struct := something;
+end;
--- /dev/null
+method foo ( )
+ if 1 then
+ var v1 := 1;
+ else
+ v1 := 2;
+ end;
+end;
--- /dev/null
+method foo ( p1 )
+ var p1 := 1;
+end;
--- /dev/null
+method foo ( )
+ if 1 then
+ var v1 := 1;
+ end;
+
+ return v1;
+end;
--- /dev/null
+method foo ( )
+ v1 := 1;
+ var v1 := 1;
+ return v1;
+end;
--- /dev/null
+struct f1 end;
+
+method foo ( )
+
+ var v1 := 1;
+
+ /* Bei einem Variablen/Feldzugriff muss eine Variable oder ein Feld mit dem Namen sichtbar sein */
+ f1 := f1;
+ v1 := v1;
+
+ /* Bei einem Feldzugriff muss ein Feld mit dem Namen sichtbar sein */
+ this.f1 := this.f1;
+ this.v1 := this.v1;
+
+ return v1;
+end;
--- /dev/null
+method f(a b c)
+ return (a*5) - (b*c) - this;
+end;
+
+/*verschachtelte mult*/
+method g(a b)
+ return (a * (b * (-4))) - this;
+end;
--- /dev/null
+long f(long, long, long, long);
+long g(long, long, long);
+
+RET(f(1, 100, 10, 5)==449 && g(5, -2, 7) == 51);
--- /dev/null
+method f(a)
+ return (a*a) * (2-3) * this * (3 * (2-3));
+end;
--- /dev/null
+long f(long, long);
+
+
+
+
+
+RET(f(9, 15) == 6075);
+
+
--- /dev/null
+method f(a b)
+ return ((this or 2) or (a or b)) - 10;
+end;
\ No newline at end of file
--- /dev/null
+long f(long, long, long);
+
+RET(f(1, 8, 16) == 17);
+
--- /dev/null
+method f(a b c)
+ return (a < (b < c)) * this;
+end;
+
--- /dev/null
+long f(long, long, long, long);
+
+
+RET(f(3, -2, 0, 15) == 3);
+
+
+
--- /dev/null
+method g(a b)
+ return a = b;
+end;
--- /dev/null
+long g(long, long, long);
+
+RET(g(0, -2, -2) == 1 && g(0, 1, 3) == 0);
--- /dev/null
+struct x y z b end;
+
+method f(a b)
+ return b;
+end;
+
+struct u v end;
+
+method g(a)
+ return u * a.v;
+end;
--- /dev/null
+extern long long f(long long*, long long*, long long);
+extern long long g(long long*, long long*);
+
+
+long long ar[10];
+long long ar2[10];
+int i = 1;
+for(; i <= 10; i++)
+ ar[i-1] = i;
+for (i = 1; i <= 10; i++)
+ ar2[i-1] = i * 10;
+
+RET(f(ar, ar, 4711) == 4711 && g(ar, ar2) == 20);
--- /dev/null
+struct x y z end;
+
+method f()
+ return (x - y) * z;
+end;
--- /dev/null
+extern long long f(long long*);
+
+
+long long ar[10];
+int i = 1;
+for(; i <= 10; i++)
+ ar[i-1] = i;
+
+RET(f(ar) == -3);
--- /dev/null
+struct x y z end;
+
+method f(a)
+ return (a - (-3*8)).y;
+end;
--- /dev/null
+extern long long f(long long*, long long*);
+
+long long ar[10];
+int i = 1;
+for(; i <= 10; i++)
+ ar[i-1] = i;
+
+RET(f(ar, ar) == 5);
--- /dev/null
+struct x y z end;
+
+method f(a)
+ return a.y - a.x - a.z;
+end;
--- /dev/null
+extern long long f(long long*, long long*);
+
+long long ar[10];
+int i = 1;
+for(; i <= 10; i++)
+ ar[i-1] = i;
+
+RET(f(ar, ar) == -2);
--- /dev/null
+method f(a b c)
+ return (a-5) - (b-c) - this;
+end;
--- /dev/null
+long f(long, long, long, long);
+
+RET(f(1, 100, 10, 5) == 89);
--- /dev/null
+method f(x)
+ return x;
+end;
--- /dev/null
+extern long f(long, long);
+RET((f(0xDEAD, 5)==5) && (f(0xDEAD, -3)==-3));
--- /dev/null
+method f(a b c d)
+ return this-(a-b-c-d);
+end;
--- /dev/null
+extern long f(long,long,long,long,long);
+RET(f(100,50,15,10,5)==80);
--- /dev/null
+method f()
+ return this;
+end;
--- /dev/null
+extern long f(long);
+RET(f(-1337)==-1337);
--- /dev/null
+method f()
+ return 666-this;
+end;
--- /dev/null
+extern long f(long);
+RET(f(111)==555);
--- /dev/null
+method Long(a b c d e)
+ return e - d - c - b - a - this;
+end;
--- /dev/null
+long Long(long, long, long, long, long, long);
+
+RET( Long(2, 6, 12, 25, 50, 100) == 5);
--- /dev/null
+method f(a b)
+ return a - ( b * -1 * a * -1 * b * -1 * -4 );
+end;
--- /dev/null
+long f(long, long, long);
+RET(f(0xCAFEBABE, 20, 10)==-7980);
--- /dev/null
+method w(a)
+ return this < a;
+end;
+
+method x()
+ return this < 3;
+end;
+
+method y()
+ return 3 < this;
+end;
+
+method z()
+ return 3 < 3;
+end;
+
+method override()
+ return 0x55555;
+end;
--- /dev/null
+long w(long,long);
+long x(long);
+long y(long);
+long z(long);
+long override(long);
+
+RET(w(20,30)==1 && override(0x1)==0x55555 && w(30,20)==0 && override(1)==0x55555 && x(400)==0 && override(0x1)==0x55555 && y(400)==1 && override(0x1)==0x55555 && z(400)==0 && override(0x1)==0x55555);
--- /dev/null
+method w(a)
+ return this = a;
+end;
+
+method x()
+ return this = 3;
+end;
+
+method y()
+ return 3 = this;
+end;
+
+method z()
+ return -13 = -13;
+end;
+
+method override()
+ return 0x55555;
+end;
--- /dev/null
+long w(long,long);
+long x(long);
+long y(long);
+long z(long);
+long override(long);
+
+RET(w(30,30)==1 && override(0x1)==0x55555 && w(30,20)==0 && override(1)==0x55555 && x(400)==0 && override(0x1)==0x55555 && y(3)==1 && override(0x1)==0x55555 && z(400)==1 && override(0x1)==0x55555);
--- /dev/null
+struct j k l end;
+method w()
+ return this.k;
+end;
+
+method x()
+ return l;
+end;
+
+method y()
+ return (this-8).k;
+end;
--- /dev/null
+long w(long);
+long x(long);
+long y(long);
+
+long t[3] = {5,6,7};
+RET(w((long)t)==6 && x((long)t)==7 && y((long)t)==5);
--- /dev/null
+method w()
+ return not this;
+end;
+
+method x()
+ return not (not this);
+end;
+
+method y()
+ return not (not (not this));
+end;
--- /dev/null
+long w(long);
+long x(long);
+long y(long);
+
+RET(w(0)==1 && x(0)==0 && y(1)==0);
--- /dev/null
+struct a b c end;
+
+method try0()
+ return 0x00100000.c;
+end;
+
+method try1()
+ return 0x01000000.c;
+end;
+
+method try2()
+ return 0xA0000000.c;
+end;
--- /dev/null
+#define TRIES 3
+
+/* ugly. copied from 'bits/mman.h' */
+#define PROT_READ 0x1
+#define PROT_WRITE 0x2
+#define MAP_PRIVATE 0x02
+#define MAP_FIXED 0x10
+#define MAP_ANONYMOUS 0x20
+
+void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
+
+long try0(long);
+long try1(long);
+long try2(long);
+
+/* try these adresses until one is free */
+long *tries[TRIES] = {
+ (long *)0x00100000,
+ (long *)0x01000000,
+ (long *)0xA0000000
+};
+
+int t = 0;
+long *addr = NULL;
+
+for (t = 0; t < TRIES; t++) {
+ addr = mmap(tries[t], 4096, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+
+ if (tries[t] == addr)
+ break;
+}
+
+if ((void *)-1 == addr) {
+ puts("unable to map memory");
+ RET(1); /* keep the statistic clean */
+}
+
+addr[2] = 1337;
+
+switch (t) {
+case 0: RET(try0(0xcafebabe) == 1337);
+case 1: RET(try1(0xcafebabe) == 1337);
+case 2: RET(try2(0xcafebabe) == 1337);
+}
+
--- /dev/null
+method f1()
+ return (this*2*3)*1;
+end;
+method f2()
+ return (this)*1;
+end;
+method f3()
+ return this*1;
+end;
+method f4()
+ return (this*1)*(this*1)*1;
+end;
--- /dev/null
+long f1(long);
+long f2(long);
+long f3(long);
+long f4(long);
+RET((f1(4) == 24) &&
+ (f2(4) == 4) &&
+ (f3(4) == 4));
--- /dev/null
+method f1()
+ return (this-0-0)-0-0-6;
+end;
+method f2()
+ return (this)-0;
+end;
+method f3()
+ return this-0;
+end;
--- /dev/null
+long f1(long);
+long f2(long);
+long f3(long);
+RET((f1(4) == -2) &&
+ (f2(4) == 4) &&
+ (f3(4) == 4));
--- /dev/null
+struct foo bar end;
+
+method f1(a b)
+ return a.foo * 5;
+end;
+
+method f2(a b)
+ return b.foo - (100 - a.foo);
+end;
+
+method f3(a b)
+ return b.foo - (100 - 50 - a.foo);
+end;
+
+method f4(a b)
+ return a.foo * a.bar;
+end;
+
+method f5(a b)
+ return b.foo - (100 - a.foo - b.foo);
+end;
--- /dev/null
+long f1(long, long*, long*);
+long f2(long, long*, long*);
+long f3(long, long*, long*);
+long f4(long, long*, long*);
+long f5(long, long*, long*);
+
+long muh[] = {0x05f05f, 0x223344};
+long kuh[] = {0x00AACC, 0x563425};
+
+RET(f1(0, muh, kuh) == muh[0] * 5 &&
+ f2(0, muh, kuh) == kuh[0] - (100 - muh[0]) &&
+ f3(0, muh, kuh) == kuh[0] - (100 - 50 - muh[0]) &&
+ f5(0, muh, kuh) == kuh[0] - (100 - muh[0] - kuh[0]) &&
+ f4(0, muh, kuh) == muh[0] * muh[1]
+ );
--- /dev/null
+struct
+ u v w x y z
+end;
+
+method f(a)
+ return u;
+end;
+
--- /dev/null
+long f(long *, long *);
+
+long v[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+
+RET(f(v, NULL) == v[0]);
+
--- /dev/null
+struct
+ u v w x y z
+end;
+
+method f(a)
+ return this.u;
+end;
+
--- /dev/null
+long f(long *, long *);
+
+long v[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+
+RET(f(v, NULL) == v[0]);
+
--- /dev/null
+struct
+ u v w x y z
+end;
+
+method f(a)
+ return v;
+end;
+
--- /dev/null
+long f(long *, long *);
+
+long v[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+
+RET(f(v, NULL) == v[1]);
+
--- /dev/null
+struct
+ u v w x y z
+end;
+
+method f(a)
+ return w;
+end;
+
--- /dev/null
+long f(long *, long *);
+
+long v[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+
+RET(f(v, NULL) == v[2]);
+
--- /dev/null
+struct
+ u v w x y z
+end;
+
+method f(a)
+ return x;
+end;
+
--- /dev/null
+long f(long *, long *);
+
+long v[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+
+RET(f(v, NULL) == v[3]);
+
--- /dev/null
+struct
+ u v w x y z
+end;
+
+method f(a)
+ return this.x;
+end;
+
--- /dev/null
+long f(long *, long *);
+
+long v[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+
+RET(f(v, NULL) == v[3]);
+
--- /dev/null
+struct
+ u v w x y z
+end;
+
+method f(a)
+ return a.v;
+end;
+
--- /dev/null
+long f(long *, long *);
+
+long v[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+
+RET(f(NULL, v) == v[1]);
+
--- /dev/null
+struct
+ u v w x y z
+end;
+
+method f(a)
+ return a.w;
+end;
+
--- /dev/null
+long f(long *, long *);
+
+long v[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+
+RET(f(NULL, v) == v[2]);
+
--- /dev/null
+struct
+ u v w x y z
+end;
+
+method f(a)
+ return (a - (-8 * 4) ).v;
+end;
+
--- /dev/null
+long f(long *, long *);
+
+long v[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+
+RET(f(NULL, v) == v[5]);
+
--- /dev/null
+method f(a b)
+ return a - b;
+end;
--- /dev/null
+long f(long, long, long);
+
+RET(f(0, 20, 10) == 10 &&
+ f(0, 10, 20) == -10);
--- /dev/null
+method f(a b)
+ return 20 - b;
+end;
--- /dev/null
+long f(long, long, long);
+
+RET(f(0, 0, 10) == 10 &&
+ f(0, 0, 20) == 0 &&
+ f(0, 0, 30) == -10);
--- /dev/null
+method f(a b)
+ return b - 20;
+end;
--- /dev/null
+long f(long, long, long);
+
+RET(f(0, 0, 10) == -10 &&
+ f(0, 0, 20) == 0 &&
+ f(0, 0, 30) == 10);
--- /dev/null
+method f(a b)
+ return a - (10 - b) - 20;
+end;
--- /dev/null
+long f(long, long, long);
+
+RET(f(0, 10, 20) == (10 - (10 - 20) - 20) &&
+ f(0, 40, 20) == (40 - (10 - 20) - 20) &&
+ f(0, 0, 30) == ( 0 - (10 - 30) - 20));
--- /dev/null
+method f1(a b)
+ return a - (-1 * b);
+end;
+
+method f2(a b)
+ return a - (-2 * b);
+end;
+
+method f4(a b)
+ return a - (-4 * b);
+end;
+
+method f8(a b)
+ return a - (-8 * b);
+end;
+
+method f(a b c d)
+ return a - (-8 * (b - (-4 * (c - (-2 * d)))));
+end;
--- /dev/null
+#define F1(a,b) ((long)(a) - (-1UL * (long)(b)))
+#define F2(a,b) ((long)(a) - (-2UL * (long)(b)))
+#define F4(a,b) ((long)(a) - (-4UL * (long)(b)))
+#define F8(a,b) ((long)(a) - (-8UL * (long)(b)))
+#define F(a,b,c,d) ((long)(a) - (-8UL * ((long)(b) - (-4UL * ((long)(c) - (-2UL * (long)(d)))))))
+
+long f1(long, long, long);
+long f2(long, long, long);
+long f4(long, long, long);
+long f8(long, long, long);
+long f(long, long, long, long, long);
+
+RET(f1(0, 3, 20) == F1( 3, 20) &&
+ f1(0, -100, 80) == F1(-100, 80) &&
+ f1(0, 50, -9) == F1( 50, -9) &&
+ f1(0, -77, -50) == F1( -77, -50) &&
+
+ f2(0, 3, 20) == F2( 3, 20) &&
+ f2(0, -100, 80) == F2(-100, 80) &&
+ f2(0, 50, -9) == F2( 50, -9) &&
+ f2(0, -77, -50) == F2( -77, -50) &&
+
+ f4(0, 3, 20) == F4( 3, 20) &&
+ f4(0, -100, 80) == F4(-100, 80) &&
+ f4(0, 50, -9) == F4( 50, -9) &&
+ f4(0, -77, -50) == F4( -77, -50) &&
+
+ f8(0, 3, 20) == F8( 3, 20) &&
+ f8(0, -100, 80) == F8(-100, 80) &&
+ f8(0, 50, -9) == F8( 50, -9) &&
+ f8(0, -77, -50) == F8( -77, -50) &&
+
+ f(0, 10, 20, 30, 40) == F( 10, 20, 30, 40) &&
+ f(0, -10, 20, -30, 40) == F(-10, 20, -30, 40) &&
+ f(0, 10, -20, 30, -40) == F( 10, -20, 30, -40) &&
+ f(0, -10, -20, -30, -40) == F(-10, -20, -30, -40) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f4(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F4(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f8(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F8(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f4(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F4(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f8(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F8(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL));
+
--- /dev/null
+method f1(a b)
+ return a - (b * -1);
+end;
+
+method f2(a b)
+ return a - (b * -2);
+end;
+
+method f4(a b)
+ return a - (b * -4);
+end;
+
+method f8(a b)
+ return a - (b * -8);
+end;
+
+method f(a b c d)
+ return a - ((b - ((c - (d * -2)) * -4)) * -8);
+end;
--- /dev/null
+#define F1(a,b) ((long)(a) - (-1UL * (long)(b)))
+#define F2(a,b) ((long)(a) - (-2UL * (long)(b)))
+#define F4(a,b) ((long)(a) - (-4UL * (long)(b)))
+#define F8(a,b) ((long)(a) - (-8UL * (long)(b)))
+#define F(a,b,c,d) ((long)(a) - (-8UL * ((long)(b) - (-4UL * ((long)(c) - (-2UL * (long)(d)))))))
+
+long f1(long, long, long);
+long f2(long, long, long);
+long f4(long, long, long);
+long f8(long, long, long);
+long f(long, long, long, long, long);
+
+RET(f1(0, 3, 20) == F1( 3, 20) &&
+ f1(0, -100, 80) == F1(-100, 80) &&
+ f1(0, 50, -9) == F1( 50, -9) &&
+ f1(0, -77, -50) == F1( -77, -50) &&
+
+ f2(0, 3, 20) == F2( 3, 20) &&
+ f2(0, -100, 80) == F2(-100, 80) &&
+ f2(0, 50, -9) == F2( 50, -9) &&
+ f2(0, -77, -50) == F2( -77, -50) &&
+
+ f4(0, 3, 20) == F4( 3, 20) &&
+ f4(0, -100, 80) == F4(-100, 80) &&
+ f4(0, 50, -9) == F4( 50, -9) &&
+ f4(0, -77, -50) == F4( -77, -50) &&
+
+ f8(0, 3, 20) == F8( 3, 20) &&
+ f8(0, -100, 80) == F8(-100, 80) &&
+ f8(0, 50, -9) == F8( 50, -9) &&
+ f8(0, -77, -50) == F8( -77, -50) &&
+
+ f(0, 10, 20, 30, 40) == F( 10, 20, 30, 40) &&
+ f(0, -10, 20, -30, 40) == F(-10, 20, -30, 40) &&
+ f(0, 10, -20, 30, -40) == F( 10, -20, 30, -40) &&
+ f(0, -10, -20, -30, -40) == F(-10, -20, -30, -40) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f4(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F4(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f8(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F8(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f4(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F4(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f8(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F8(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL));
+
--- /dev/null
+method f(a b)
+ return (a or 0x0A) or (0x50 or b);
+end;
--- /dev/null
+long f(long, long, long);
+
+RET(f(0, 0x00, 0x00) == 0x5A);
+
--- /dev/null
+method f(a b)
+ return (a = 0x0A) = (0x50 = b);
+end;
--- /dev/null
+long f(long, long, long);
+
+RET(f(0, 0x00, 0x00) == 1 &&
+ f(0, 0x0A, 0xFF) == 0 &&
+ f(0, 0xFF, 0x50) == 0 &&
+ f(0, 0x0A, 0x50) == 1);
+
--- /dev/null
+method f(a)
+ return (a < 0x0A);
+end;
+
+method g(a)
+ return (0x0A < a);
+end;
+
+method h()
+ return (0x0A < 0x09);
+end;
+
+method i()
+ return (0x0A < 0x0B);
+end;
+
--- /dev/null
+long f(long, long);
+long g(long, long);
+long h(long);
+long i(long);
+
+RET(f(0, 0x05) == 1 &&
+ f(0, -0x05) == 1 &&
+ f(0, 0x0A) == 0 &&
+ f(0, 0x0B) == 0 &&
+
+ g(0, 0x05) == 0 &&
+ g(0, -0x05) == 0 &&
+ g(0, 0x0A) == 0 &&
+ g(0, 0x0B) == 1 &&
+
+ h(0) == 0 &&
+ i(0) == 1);
+
--- /dev/null
+method w()
+ return not this;
+end;
+
+method x()
+ return not (not this);
+end;
+
+method y()
+ return not (not (not this));
+end;
--- /dev/null
+long w(long);
+long x(long);
+long y(long);
+
+RET(w(6)==0 && x(4)==1 && y(8)==0 && w(5) == 0 && x(3) == 1 && y(7) == 0 && w(0) == 1 && x(0) == 0 && y(0) == 1);
--- /dev/null
+method w()
+ return not 0;
+end;
+
+method x()
+ return not (not 0);
+end;
+
+method y()
+ return not 3;
+end;
+
+method z()
+ return not (not 3);
+end;
+
+method aa()
+ return not (not (not 0));
+end;
+
+method ab()
+ return not (not (not 3));
+end;
--- /dev/null
+long w(long);
+long x(long);
+long y(long);
+long z(long);
+long aa(long);
+long ab(long);
+
+RET(w(0xDEAD)==1 && x(1337)==0 && y(42)==0 && z(3141) == 1 && aa(0xabc) == 1 && ab(0xdef) == 0);
--- /dev/null
+method w(a)
+ return not a;
+end;
+
+method x(a)
+ return not (not a);
+end;
+
+method y(a)
+ return not (not (not a));
+end;
--- /dev/null
+long w(long,long);
+long x(long,long);
+long y(long,long);
+
+RET(w(6,6)==0 && x(4,4)==1 && y(8,8)==0 && w(5,5) == 0 && x(3,3) == 1 && y(7,7) == 0 && w(0,0) == 1 && x(0,0) == 0 && y(0,0) == 1);
--- /dev/null
+struct a b c end;
+
+method try0()
+ return (0x000FFFFB - -5).c;
+end;
+
+method try1()
+ return (0x00FFFFFD - -3).c;
+end;
+
+method try2()
+ return (0x9FFFFFFB - -5).c;
+end;
--- /dev/null
+#define TRIES 3
+
+/* ugly. copied from 'bits/mman.h' */
+#define PROT_READ 0x1
+#define PROT_WRITE 0x2
+#define MAP_PRIVATE 0x02
+#define MAP_FIXED 0x10
+#define MAP_ANONYMOUS 0x20
+
+void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
+
+long try0(long);
+long try1(long);
+long try2(long);
+
+/* try these adresses until one is free */
+long *tries[TRIES] = {
+ (long *)0x00100000,
+ (long *)0x01000000,
+ (long *)0xA0000000
+};
+
+int t = 0;
+long *addr = NULL;
+
+for (t = 0; t < TRIES; t++) {
+ addr = mmap(tries[t], 4096, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+
+ if (tries[t] == addr)
+ break;
+}
+
+if ((void *)-1 == addr) {
+ puts("unable to map memory");
+ RET(1); /* keep the statistic clean */
+}
+
+addr[2] = 1337;
+
+printf("try %d\n", t);
+
+switch (t) {
+case 0: RET(try0(0xcafebabe) == 1337);
+case 1: RET(try1(0xcafebabe) == 1337);
+case 2: RET(try2(0xcafebabe) == 1337);
+}
+
--- /dev/null
+method f1(a b)
+ return a - (-3 * b);
+end;
+
+method f2(a b)
+ return a - (2 * b);
+end;
+
+method f3(a b)
+ return a - (5 * b);
+end;
+
+method f(a b c d)
+ return a - (8 * (b - (-4 * (c - (-3 * d)))));
+end;
--- /dev/null
+#define F1(a,b) ((long)(a) - (-3UL * (long)(b)))
+#define F2(a,b) ((long)(a) - (2UL * (long)(b)))
+#define F3(a,b) ((long)(a) - (5UL * (long)(b)))
+#define F(a,b,c,d) ((long)(a) - (8UL * ((long)(b) - (-4UL * ((long)(c) - (-3UL * (long)(d)))))))
+
+/* based on mrstrcmp_13
+ in our language the lea opts are only possible for -1, -2, -4 and -8
+ this testcase tests other constants
+*/
+
+long f1(long, long, long);
+long f2(long, long, long);
+long f3(long, long, long);
+long f(long, long, long, long, long);
+
+RET(f1(0, 3, 20) == F1( 3, 20) &&
+ f1(0, -100, 80) == F1(-100, 80) &&
+ f1(0, 50, -9) == F1( 50, -9) &&
+ f1(0, -77, -50) == F1( -77, -50) &&
+
+ f2(0, 3, 20) == F2( 3, 20) &&
+ f2(0, -100, 80) == F2(-100, 80) &&
+ f2(0, 50, -9) == F2( 50, -9) &&
+ f2(0, -77, -50) == F2( -77, -50) &&
+
+ f3(0, 3, 20) == F3( 3, 20) &&
+ f3(0, -100, 80) == F3(-100, 80) &&
+ f3(0, 50, -9) == F3( 50, -9) &&
+ f3(0, -77, -50) == F3( -77, -50) &&
+
+ f(0, 10, 20, 30, 40) == F( 10, 20, 30, 40) &&
+ f(0, -10, 20, -30, 40) == F(-10, 20, -30, 40) &&
+ f(0, 10, -20, 30, -40) == F( 10, -20, 30, -40) &&
+ f(0, -10, -20, -30, -40) == F(-10, -20, -30, -40) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f3(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F3(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f3(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F3(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL)
+ );
+
--- /dev/null
+method f1(a b)
+ return (-3 * b) - a;
+end;
+
+method f2(a b)
+ return (2 * b) - a;
+end;
+
+method f3(a b)
+ return (5 * b) - a;
+end;
--- /dev/null
+#define F1(a,b) ((-3UL * (long)(b)) - (long)(a))
+#define F2(a,b) ((2UL * (long)(b)) - (long)(a))
+#define F3(a,b) ((5UL * (long)(b)) - (long)(a))
+
+
+/* based on mrstrcmp_13
+ this testcase tests an other order of ops where no lea is possible
+*/
+
+long f1(long, long, long);
+long f2(long, long, long);
+long f3(long, long, long);
+
+RET(f1(0, 3, 20) == F1( 3, 20) &&
+ f1(0, -100, 80) == F1(-100, 80) &&
+ f1(0, 50, -9) == F1( 50, -9) &&
+ f1(0, -77, -50) == F1( -77, -50) &&
+
+ f2(0, 3, 20) == F2( 3, 20) &&
+ f2(0, -100, 80) == F2(-100, 80) &&
+ f2(0, 50, -9) == F2( 50, -9) &&
+ f2(0, -77, -50) == F2( -77, -50) &&
+
+ f3(0, 3, 20) == F3( 3, 20) &&
+ f3(0, -100, 80) == F3(-100, 80) &&
+ f3(0, 50, -9) == F3( 50, -9) &&
+ f3(0, -77, -50) == F3( -77, -50) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f3(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F3(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f3(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F3(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL)
+ );
+
--- /dev/null
+method f1(a b)
+ return a - (b * -3);
+end;
+
+method f2(a b)
+ return a - (b * 2);
+end;
+
+method f3(a b)
+ return a - (b * 5);
+end;
+
+method f(a b c d)
+ return a - ((b - ((c - (d * -3)) * -4)) * 8);
+end;
--- /dev/null
+#define F1(a,b) ((long)(a) - ((long)(b) * -3UL))
+#define F2(a,b) ((long)(a) - ((long)(b) * 2UL))
+#define F3(a,b) ((long)(a) - ((long)(b) * 5UL))
+#define F(a,b,c,d) ((long)(a) - (8UL * ((long)(b) - (-4UL * ((long)(c) - (-3UL * (long)(d)))))))
+
+
+/* based on mrstrcmp_14
+ in our language the lea opts are only possible for -1, -2, -4 and -8
+ this testcase tests other constants and other op order in mul
+*/
+
+long f1(long, long, long);
+long f2(long, long, long);
+long f3(long, long, long);
+long f(long, long, long, long, long);
+
+RET(f1(0, 3, 20) == F1( 3, 20) &&
+ f1(0, -100, 80) == F1(-100, 80) &&
+ f1(0, 50, -9) == F1( 50, -9) &&
+ f1(0, -77, -50) == F1( -77, -50) &&
+
+ f2(0, 3, 20) == F2( 3, 20) &&
+ f2(0, -100, 80) == F2(-100, 80) &&
+ f2(0, 50, -9) == F2( 50, -9) &&
+ f2(0, -77, -50) == F2( -77, -50) &&
+
+ f3(0, 3, 20) == F3( 3, 20) &&
+ f3(0, -100, 80) == F3(-100, 80) &&
+ f3(0, 50, -9) == F3( 50, -9) &&
+ f3(0, -77, -50) == F3( -77, -50) &&
+
+ f(0, 10, 20, 30, 40) == F( 10, 20, 30, 40) &&
+ f(0, -10, 20, -30, 40) == F(-10, 20, -30, 40) &&
+ f(0, 10, -20, 30, -40) == F( 10, -20, 30, -40) &&
+ f(0, -10, -20, -30, -40) == F(-10, -20, -30, -40) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f3(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F3(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f3(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F3(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL)
+ );
--- /dev/null
+method f1(a b c)
+ return a - ((b - c) * -2);
+end;
+
+method f2(a b c)
+ return a - ((b - c) * -3);
+end;
--- /dev/null
+#define F1(a,b,c) ((long)(a) -(((long)(b) - (long)(c)) * -2UL))
+#define F2(a,b,c) ((long)(a) -(((long)(b) - (long)(c)) * -3UL))
+
+
+long f1(long, long, long, long);
+long f2(long, long, long, long);
+
+RET(f1(0, 3, 20, 15) == F1( 3, 20, 15) &&
+ f1(0, -100, 80, 23) == F1(-100, 80, 23) &&
+ f1(0, 50, -9, -5) == F1( 50, -9, -5) &&
+ f1(0, -77, -50, 87) == F1( -77, -50, 87) &&
+
+ f2(0, 3, 20, 15) == F2( 3, 20, 15) &&
+ f2(0, -100, 80, 23) == F2(-100, 80, 23) &&
+ f2(0, 50, -9, -5) == F2( 50, -9, -5) &&
+ f2(0, -77, -50, 87) == F2( -77, -50, 87) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL)
+ );
+
--- /dev/null
+method f1(a b c)
+ return a - (-2 * (b - c));
+end;
+
+method f2(a b c)
+ return a - (-3 * (b - c));
+end;
--- /dev/null
+#define F1(a,b,c) ((long)(a) -(-2UL * ((long)(b) - (long)(c))))
+#define F2(a,b,c) ((long)(a) -(-3UL * ((long)(b) - (long)(c))))
+
+
+long f1(long, long, long, long);
+long f2(long, long, long, long);
+
+RET(f1(0, 3, 20, 15) == F1( 3, 20, 15) &&
+ f1(0, -100, 80, 23) == F1(-100, 80, 23) &&
+ f1(0, 50, -9, -5) == F1( 50, -9, -5) &&
+ f1(0, -77, -50, 87) == F1( -77, -50, 87) &&
+
+ f2(0, 3, 20, 15) == F2( 3, 20, 15) &&
+ f2(0, -100, 80, 23) == F2(-100, 80, 23) &&
+ f2(0, 50, -9, -5) == F2( 50, -9, -5) &&
+ f2(0, -77, -50, 87) == F2( -77, -50, 87) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL)
+ );
+
--- /dev/null
+method f1(a b c)
+ return ((b - c) * -2) - a;
+end;
+
+method f2(a b c)
+ return ((b - c) * -3) - a;
+end;
--- /dev/null
+#define F1(a,b,c) ((((long)(b) - (long)(c)) * -2UL) - (long)(a))
+#define F2(a,b,c) ((((long)(b) - (long)(c)) * -3UL) - (long)(a))
+
+
+long f1(long, long, long, long);
+long f2(long, long, long, long);
+
+RET(f1(0, 3, 20, 15) == F1( 3, 20, 15) &&
+ f1(0, -100, 80, 23) == F1(-100, 80, 23) &&
+ f1(0, 50, -9, -5) == F1( 50, -9, -5) &&
+ f1(0, -77, -50, 87) == F1( -77, -50, 87) &&
+
+ f2(0, 3, 20, 15) == F2( 3, 20, 15) &&
+ f2(0, -100, 80, 23) == F2(-100, 80, 23) &&
+ f2(0, 50, -9, -5) == F2( 50, -9, -5) &&
+ f2(0, -77, -50, 87) == F2( -77, -50, 87) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL)
+ );
+
--- /dev/null
+method f1(a b c)
+ return (-2 * (b - c)) - a;
+end;
+
+method f2(a b c)
+ return (-3 * (b - c)) - a;
+end;
--- /dev/null
+#define F1(a,b,c) ((-2UL * ((long)(b) - (long)(c))) - (long)(a))
+#define F2(a,b,c) ((-3UL * ((long)(b) - (long)(c))) - (long)(a))
+
+
+long f1(long, long, long, long);
+long f2(long, long, long, long);
+
+RET(f1(0, 3, 20, 15) == F1( 3, 20, 15) &&
+ f1(0, -100, 80, 23) == F1(-100, 80, 23) &&
+ f1(0, 50, -9, -5) == F1( 50, -9, -5) &&
+ f1(0, -77, -50, 87) == F1( -77, -50, 87) &&
+
+ f2(0, 3, 20, 15) == F2( 3, 20, 15) &&
+ f2(0, -100, 80, 23) == F2(-100, 80, 23) &&
+ f2(0, 50, -9, -5) == F2( 50, -9, -5) &&
+ f2(0, -77, -50, 87) == F2( -77, -50, 87) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL)
+ );
+
--- /dev/null
+method f1(a b)
+ return (a - b) - (-3 * b);
+end;
+
+method f2(a b)
+ return (a -b) - (-2 * b);
+end;
--- /dev/null
+#define F1(a,b) (((long)(a) - (long)(b)) - (-3UL * (long)(b)))
+#define F2(a,b) (((long)(a) - (long)(b)) - (-2UL * (long)(b)))
+
+long f1(long, long, long);
+long f2(long, long, long);
+
+RET(f1(0, 3, 20) == F1( 3, 20) &&
+ f1(0, -100, 80) == F1(-100, 80) &&
+ f1(0, 50, -9) == F1( 50, -9) &&
+ f1(0, -77, -50) == F1( -77, -50) &&
+
+ f2(0, 3, 20) == F2( 3, 20) &&
+ f2(0, -100, 80) == F2(-100, 80) &&
+ f2(0, 50, -9) == F2( 50, -9) &&
+ f2(0, -77, -50) == F2( -77, -50) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL)
+ );
+
--- /dev/null
+method f1(a b)
+ return (a - b) - (b * -3);
+end;
+
+method f2(a b)
+ return (a -b) - (b * -2);
+end;
--- /dev/null
+#define F1(a,b) (((long)(a) - (long)(b)) - ((long)(b) * -3UL))
+#define F2(a,b) (((long)(a) - (long)(b)) - ((long)(b)* -2UL))
+
+long f1(long, long, long);
+long f2(long, long, long);
+
+RET(f1(0, 3, 20) == F1( 3, 20) &&
+ f1(0, -100, 80) == F1(-100, 80) &&
+ f1(0, 50, -9) == F1( 50, -9) &&
+ f1(0, -77, -50) == F1( -77, -50) &&
+
+ f2(0, 3, 20) == F2( 3, 20) &&
+ f2(0, -100, 80) == F2(-100, 80) &&
+ f2(0, 50, -9) == F2( 50, -9) &&
+ f2(0, -77, -50) == F2( -77, -50) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL)
+ );
+
--- /dev/null
+method f1(a b)
+ return (a - b) - (-3 * (b - a));
+end;
+
+method f2(a b)
+ return (a - b) - (-2 * (b - a));
+end;
--- /dev/null
+#define F1(a,b) (((long)(a) - (long)(b)) - (-3UL * ((long)(b) - (long)(a))))
+#define F2(a,b) (((long)(a) - (long)(b)) - (-2UL * ((long)(b) - (long)(a))))
+
+long f1(long, long, long);
+long f2(long, long, long);
+
+RET(f1(0, 3, 20) == F1( 3, 20) &&
+ f1(0, -100, 80) == F1(-100, 80) &&
+ f1(0, 50, -9) == F1( 50, -9) &&
+ f1(0, -77, -50) == F1( -77, -50) &&
+
+ f2(0, 3, 20) == F2( 3, 20) &&
+ f2(0, -100, 80) == F2(-100, 80) &&
+ f2(0, 50, -9) == F2( 50, -9) &&
+ f2(0, -77, -50) == F2( -77, -50) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL)
+ );
+
--- /dev/null
+method f1(a b)
+ return (a - b) - ((b - a) * -3);
+end;
+
+method f2(a b)
+ return (a - b) - ((b - a) * -2);
+end;
--- /dev/null
+#define F1(a,b) (((long)(a) - (long)(b)) - (((long)(b) -(long)(a))* -3UL))
+#define F2(a,b) (((long)(a) - (long)(b)) - (((long)(b) -(long)(a))* -2UL))
+
+long f1(long, long, long);
+long f2(long, long, long);
+
+RET(f1(0, 3, 20) == F1( 3, 20) &&
+ f1(0, -100, 80) == F1(-100, 80) &&
+ f1(0, 50, -9) == F1( 50, -9) &&
+ f1(0, -77, -50) == F1( -77, -50) &&
+
+ f2(0, 3, 20) == F2( 3, 20) &&
+ f2(0, -100, 80) == F2(-100, 80) &&
+ f2(0, 50, -9) == F2( 50, -9) &&
+ f2(0, -77, -50) == F2( -77, -50) &&
+
+ f1(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F1(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) ==
+ F2(0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL) &&
+
+ f1(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F1(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) &&
+ f2(0, 0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL) ==
+ F2(0x8FFFFFFFFFFFFFFFUL, 0x8FFFFFFFFFFFFFFFUL)
+ );
+
--- /dev/null
+struct foo bar end;
+
+method f1(a b)
+ return 4 or 5;
+end;
+
+method f2(a b)
+ return a.foo or 0x55555555;
+end;
+
+method f3(a b)
+ return 0x55555555 or b.bar;
+end;
+
+method f4(a b)
+ return (a.bar - b.foo) or (a.foo - b.bar);
+end;
+
+method f5(a b)
+ return (a.bar < b.foo) or this;
+end;
+
+method f6(a b)
+ return this or (b.bar = a.foo);
+end;
+
+method f7(a b)
+ return a or b;
+end;
+
+method f8(a b)
+ return this or 0x112233;
+end;
+
+method f9(a b)
+ return 0x11EEEEFF or this;
+end;
+
+method f10(a b)
+ return (a.foo - 5) or 6;
+end;
+
+method f11(a b)
+ return 7 or (b.bar - 3);
+end;
+
+method f12(a b)
+ return (a.bar - 3) or b.foo;
+end;
+
+method f13(a b)
+ return a.foo or (b.bar - -3);
+end;
+
+method f14(a b)
+ return this or a.foo;
+end;
+
+method f15(a b)
+ return b.bar or this;
+end;
+
+method f16(a b)
+ return b.bar or 0;
+end;
+
+method f17(a b)
+ return 0 or a.foo;
+end;
+
+method f18(a b)
+ return 0 or this;
+end;
+
+method f19(a b)
+ return this or 0;
+end;
+
+method f20(a b)
+ return 0 or (b.foo * 1);
+end;
+
+method f21(a b)
+ return (a.foo * 1) or 0;
+end;
--- /dev/null
+#define OR(a,b) ((long)(a) | (long)(b))
+
+long f1(long, long*, long*);
+long f2(long, long*, long*);
+long f3(long, long*, long*);
+long f4(long, long*, long*);
+long f5(long, long*, long*);
+long f6(long, long*, long*);
+long f7(long, long*, long*);
+long f8(long, long*, long*);
+long f9(long, long*, long*);
+long f10(long, long*, long*);
+long f11(long, long*, long*);
+long f12(long, long*, long*);
+long f13(long, long*, long*);
+long f14(long, long*, long*);
+long f15(long, long*, long*);
+long f16(long, long*, long*);
+long f17(long, long*, long*);
+long f18(long, long*, long*);
+long f19(long, long*, long*);
+long f20(long, long*, long*);
+long f21(long, long*, long*);
+
+long muh[] = {0x05f05f, 0x223344};
+long kuh[] = {0x00AACC, 0x563425};
+
+RET( f1(5, muh, kuh) == OR( 4, 5) &&
+ f2(5, muh, kuh) == OR( muh[0], 0x55555555) &&
+ f3(5, muh, kuh) == OR( 0x55555555, kuh[1]) &&
+ f4(5, muh, kuh) == OR(muh[1]-kuh[0], muh[0]-kuh[1]) &&
+ f5(5, muh, kuh) == OR( 0, 5) &&
+ f6(5, muh, kuh) == OR( 5, 0) &&
+ f7(5, muh, kuh) == OR( muh, kuh) &&
+ f8(5, muh, kuh) == OR( 5, 0x112233) &&
+ f9(5, muh, kuh) == OR( 0x11EEEEFF, 5) &&
+ f10(5, muh, kuh) == OR( muh[0]-5, 6) &&
+ f11(5, muh, kuh) == OR( 7, kuh[1]-3) &&
+ f12(5, muh, kuh) == OR( muh[1]-3, kuh[0]) &&
+ f13(5, muh, kuh) == OR( muh[0], kuh[1]+3) &&
+ f14(5, muh, kuh) == OR( 5, muh[0]) &&
+ f15(5, muh, kuh) == OR( kuh[1], 5) &&
+ f16(5, muh, kuh) == OR( kuh[1], 0) &&
+ f17(5, muh, kuh) == OR( 0, muh[0]) &&
+ f18(5, muh, kuh) == OR( 0, 5) &&
+ f19(5, muh, kuh) == OR( 5, 0) &&
+ f20(5, muh, kuh) == OR( 0, kuh[0]) &&
+ f21(5, muh, kuh) == OR( muh[0], 0)
+ );
+
--- /dev/null
+struct foo bar end;
+
+method f1(a)
+ return not(this-a.bar);
+end;
+
+method f2(a)
+ return not(a.foo);
+end;
+
+method f3(a)
+ return not(not(a.foo));
+end;
+
+method f4(a)
+ return not(a.bar);
+end;
+
+method f5(a)
+ return not(not(a.bar));
+end;
+
+method f6(a)
+ return not(not(a.foo - a.bar));
+end;
+
+method f7(a)
+ return not(not(a.foo * a.bar));
+end;
+
+method f8(a)
+ return not(this*a.bar);
+end;
--- /dev/null
+long f1(long, long*);
+long f2(long, long*);
+long f3(long, long*);
+long f4(long, long*);
+long f5(long, long*);
+long f6(long, long*);
+long f7(long, long*);
+long f8(long, long*);
+
+long muh[] = {6,4};
+long kuh[] = {1,0};
+long zod[] = {0,1};
+long pui[] = {1,1};
+
+printf("%d = %d , %d = %d, %d = %d, %d = %d \n", f8(5,muh) , 1 , f8(4,muh) , 1 , f8(0,muh) , 0 , f8(0,zod) , 0 );
+
+RET(f1(5,muh) == 0 && f1(4,muh) == 1 &&
+ f2(5,kuh) == 0 && f2(5,zod) == 1 &&
+ f3(5,kuh) == 1 && f3(5,zod) == 0 && f3(5,muh) == 1 &&
+ f4(5,kuh) == 1 && f4(5,zod) == 0 && f4(5,muh) == 0 &&
+ f5(5,kuh) == 0 && f5(5,zod) == 1 &&
+ f6(5,muh) == 1 && f6(5,kuh) == 1 && f6(5,pui) == 0 &&
+ f7(5,muh) == 1 && f7(5,kuh) == 0 && f7(5,pui) == 1 &&
+ f8(5,muh) == 0 && f8(4,muh) == 0 && f8(0,muh) == 1 && f8(0,zod) == 1
+ );
--- /dev/null
+struct foo bar end;
+
+method f1(a)
+ return 5 * a.foo;
+end;
+
+method f2(a)
+ return a.bar * this;
+end;
+
+method f3(a)
+ return (a.foo-3) < (a.bar-3);
+end;
+
+method f4(a)
+ return (a.foo*1) < 6;
+end;
+
+method f5(a)
+ return 5 < (a.bar * 1);
+end;
+
+method f6(a)
+ return (1 * a.foo) < this;
+end;
+
+method f7(a)
+ return a.foo < (a.bar * 1);
+end;
+
+method f8(a)
+ return a.foo < this;
+end;
+
+method f9(a)
+ return this < a.bar;
+end;
+
+method f10(a)
+ return a.foo < 6;
+end;
+
+method f11(a)
+ return 5 < a.bar;
+end;
--- /dev/null
+
+long f1(long, long*);
+long f2(long, long*);
+long f3(long, long*);
+long f4(long, long*);
+long f5(long, long*);
+long f6(long, long*);
+long f7(long, long*);
+long f8(long, long*);
+long f9(long, long*);
+long f10(long, long*);
+long f11(long, long*);
+
+long muh[] = {5, 6};
+long kuh[] = {6, 5};
+
+RET(f1(4,muh) == 25 &&
+ f2(5,muh) == 30 &&
+ f3(5,muh) == 1 && f3(5,kuh) == 0 &&
+ f4(5,muh) == 1 && f4(5,kuh) == 0 &&
+ f5(5,muh) == 1 && f5(5,kuh) == 0 &&
+ f6(6,muh) == 1 && f6(6,kuh) == 0 &&
+ f7(5,muh) == 1 && f7(5,kuh) == 0 &&
+ f8(5,muh) == 0 && f8(7,kuh) == 1 &&
+ f9(5,muh) == 1 && f9(5,kuh) == 0 &&
+ f10(5,muh) == 1 && f10(5,kuh) == 0 &&
+ f11(5,muh) == 1 && f11(5,kuh) == 0
+);
--- /dev/null
+struct foo bar end;
+
+method f1(a)
+ return (a.foo * 1) = 5;
+end;
+
+method f2(a)
+ return 5 = (a.bar * 1);
+end;
+
+method f3(a)
+ return (a.foo * 1) = this;
+end;
+
+method f4(a)
+ return this = (a.bar * 1);
+end;
+
+method f5(a)
+ return a.foo = (this * 1);
+end;
+
+method f6(a)
+ return a.foo = 5;
+end;
+
+method f7(a)
+ return 5 = a.bar;
+end;
+
+method f8(a)
+ return a.foo = this;
+end;
+
+method f9(a)
+ return this = a.bar;
+end;
+
--- /dev/null
+
+long f1(long, long*);
+long f2(long, long*);
+long f3(long, long*);
+long f4(long, long*);
+long f5(long, long*);
+long f6(long, long*);
+long f7(long, long*);
+long f8(long, long*);
+long f9(long, long*);
+
+long muh[] = {5, 6};
+long kuh[] = {6, 5};
+
+RET(f1(4,muh) == 1 && f1(5,kuh) == 0 &&
+ f2(5,muh) == 0 && f2(5,kuh) == 1 &&
+ f3(5,muh) == 1 && f3(5,kuh) == 0 &&
+ f4(5,muh) == 0 && f4(5,kuh) == 1 &&
+ f5(5,muh) == 1 && f5(5,kuh) == 0 &&
+ f6(6,muh) == 1 && f6(6,kuh) == 0 &&
+ f7(5,muh) == 0 && f7(5,kuh) == 1 &&
+ f8(5,muh) == 1 && f8(5,kuh) == 0 &&
+ f9(5,muh) == 0 && f9(5,kuh) == 1
+);
--- /dev/null
+method f1(a b)
+ return not(a or b);
+end;
+
+method f2(a b)
+ return not(not(a or b));
+end;
+
+method f3(a b)
+ return not(a - b);
+end;
+
+method f4(a b)
+ return not(not(a - b));
+end;
+
+method f5(a b)
+ return not(a < b);
+end;
+
+method f6(a b)
+ return not(not(a < b));
+end;
+
+method f7(a b)
+ return not(a = b);
+end;
+
+method f8(a b)
+ return not(not(a = b));
+end;
--- /dev/null
+long f1(long,long,long);
+long f2(long,long,long);
+long f3(long,long,long);
+long f4(long,long,long);
+long f5(long,long,long);
+long f6(long,long,long);
+long f7(long,long,long);
+long f8(long,long,long);
+
+RET(
+f1(0,0,0) == 1 && f1(0,1,1) == 0 &&
+f2(0,0,0) == 0 && f2(0,1,1) == 1 &&
+
+f3(0,4,4) == 1 && f3(0,4,3) == 0 &&
+f4(0,4,4) == 0 && f4(0,4,3) == 1 &&
+
+f5(0,5,4) == 1 && f5(0,4,5) == 0 &&
+f6(0,5,4) == 0 && f6(0,4,5) == 1 &&
+
+f7(0,5,4) == 1 && f7(0,5,5) == 0 &&
+f8(0,5,4) == 0 && f8(0,5,5) == 1
+);
--- /dev/null
+method f1(a)
+ return this - (a - 0);
+end;
+
+method f2(a)
+ return (this - a) - (0 - a);
+end;
+
+method f3(a)
+ return 5 - (a - 0);
+end;
--- /dev/null
+long f1(long, long);
+long f2(long, long);
+long f3(long, long);
+
+RET(f1(5,3) == 2 && f2(8,3) == 8 && f3(4,2) == 3);
--- /dev/null
+struct a b c end;
+
+method m(x)
+ return ((this-0)-8).c;
+end;
--- /dev/null
+long s[]={12,23,34,45,53,61};
+extern long m(long *,long);
+RET(m(s,12)==23 && m(s+2,13)==45);
--- /dev/null
+method foo(a b c)
+ return a;
+end;
+
+method bar(a b c)
+ return b;
+end;
+
+method foobar(a b c)
+ return c;
+end;
--- /dev/null
+extern long foo(long this, long, long, long);
+extern long bar(long this, long, long, long);
+extern long foobar(long this, long, long, long);
+
+RET( (foo(0xDEAD, 3, 4, 5) == 3) && (bar(0xDEAD, 3, 4, 5) == 4) && (foobar(0xDEAD, 3, 4, 5) == 5));
--- /dev/null
+method a()
+ return 5 - 3;
+end;
+
+method b(x)
+ return 5 - x;
+end;
+
+method c(x)
+ return x - 3;
+end;
--- /dev/null
+extern long a(long this);
+extern long b(long this, long x);
+extern long c(long this, long x);
+
+RET( (a(0xDEAD) == 2) && (b(0xDEAD, 23) == -18) && (c(0xDEAD, 23) == 20));
--- /dev/null
+method q(x y)
+ return 5 - ((x - 3) - y);
+end;
+
+method r(x y)
+ return (x - y) - 10;
+end;
+
+method s(x y)
+ return 6 - (x - 1);
+end;
--- /dev/null
+extern long q(long this, long, long);
+extern long r(long this, long, long);
+extern long s(long this, long, long);
+
+RET((q(0xDEAD, 33, 15) == -10) && (r(0xDEAD, 33, 15) == 8) && (s(0xDEAD, 33, 15) == -26));
--- /dev/null
+method Long(a b c d e)
+ return (a - (e - 20)) - (b - (c - (99 - d)));
+end;
+
+method Loong(a b c d e)
+ return a - (b - (c - (d - (e - (a - (b - (c - (d - (e - 10)))))))));
+end;
+
+method Looong(a b c d e)
+ return (11 - a) - (22 - b) - (33 - c - (44 - d)) - (55 - (77 - e - -66));
+end;
--- /dev/null
+long Long(long this, long, long, long, long, long);
+long Loong(long this, long, long, long, long, long);
+long Looong(long this, long, long, long, long, long);
+
+long erw1 = 9935366;
+long erw2 = 10;
+long erw3 = 11309;
+long ret1 = Long(0xDEAD, 23, 66, 1024, 9999999, 65535);
+long ret2 = Loong(0xDEAD, 11, 22, 33, 44, 55);
+long ret3 = Looong(0xDEAD, 34, 92934, 2991, 12389, 72281);
+
+printf("Long(erwartet: %i) : %i\n", erw1, ret1);
+printf("Loong(erwartet: %i) : %i\n", erw2, ret2);
+printf("Looong(erwartet: %i) : %i\n", erw3, ret3);
+
+RET(ret1 == erw1 && ret2 == erw2 && ret3 == erw3);
--- /dev/null
+method pvs1(a b)
+ return (this - a) * b;
+end;
+
+method pvs2(a b)
+ return this - (a * b);
+end;
+
+method pvs3(a b)
+ return (this * a) - b;
+end;
+
+method pvs4(a b)
+ return this * (a - b);
+end;
--- /dev/null
+long pvs1(long, long, long);
+long pvs2(long, long, long);
+long pvs3(long, long, long);
+long pvs4(long, long, long);
+
+
+RET((pvs1(2,3,5) == -5) && (pvs2(2,3,5) == -13) && (pvs3(2,3,5) == 1) && (pvs4(2,3,5) == -4));
--- /dev/null
+method meh(a b c d)
+ return (this * (a - b)) - (c - (a * d));
+end;
--- /dev/null
+long meh(long, long, long, long, long);
+
+RET(meh(2,11,5,15,32) == 349);
--- /dev/null
+struct a b end;
+
+method test64()
+ return this - -2139062144;
+end;
+
+method num()
+ return 15 - 4 - 2 - 6 - 7;
+end;
+
+method num2()
+ return 15 - (4 - 2 - 6 - 7);
+end;
+
+method globcmp()
+ return this.a < this.b;
+end;
+
+method globcmp2()
+ return this.a = this.b;
+end;
--- /dev/null
+long test64(long);
+long num(long);
+long num2(long);
+long globcmp(long*);
+long globcmp2(long*);
+
+
+long foo[] = {1337, 42};
+long bar[] = {23, 23};
+long foobar[] = {23, 42};
+
+RET((test64(0x1000000000) == (long) 0x1000000000 - (int) 0x80808080)
+ && (num(0) == -4)
+ && (num2(0) == 26)
+ && (globcmp(foo) == 0)
+ && (globcmp(bar) == 0)
+ && (globcmp(foobar) == 1)
+ && (globcmp2(foo) == 0)
+ && (globcmp2(bar) == 1)
+ && (globcmp2(foobar) == 0)
+ );
--- /dev/null
+/* BOF georg_asma_00.call */
+#include <string.h> /* strcmp() */
+char x[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char y[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char z[] = "UVWxyz6789abcDEFuvwxyz6789abcdefUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char *p = &y[16];
+extern char *asma(char *);
+int ret = (asma(p)==p && (strcmp(y,z)==0));
+if (ret != 1) {
+ x[sizeof(x)-1] = '\0'; /* just 2b sure */
+ y[sizeof(y)-1] = '\0'; /* just 2b sure */
+ z[sizeof(z)-1] = '\0'; /* just 2b sure */
+ fprintf(stderr, "### %s:%d:%s() x '%s'\n", __FILE__, __LINE__, __FUNCTION__, x);
+ fprintf(stderr, "### %s:%d:%s() y '%s'\n", __FILE__, __LINE__, __FUNCTION__, y);
+ fprintf(stderr, "### %s:%d:%s() z '%s'\n", __FILE__, __LINE__, __FUNCTION__, z);
+}
+RET(ret);
+/* vim: set filetype=c: */
+/* EOF georg_asma_00.call */
--- /dev/null
+/** asma - aka tolower() first 16 bytes.
+ *
+ * unsigned char *asma(unsigned char *s)
+ * {
+ * int i;
+ * for (i=0; i<16; i++)
+ * {
+ * unsigned char c = s[i];
+ * c += (c >= 'A' && c <= 'Z') ? 'a'-'A' : 0;
+ * s[i] = c;
+ * }
+ * return s;
+ * }
+ */
+/* AMD64 Little Endian byte order
+ * p[0] c0 c1 c2 c3 c4 c5 c6 c7
+ * p[1] c1 c2 c3 c4 c5 c6 c7 c8
+ * p[1] * 256 00 c1 c2 c3 c4 c5 c6 c7
+ * p[0] - 256 * p[1] c0
+ */
+/* WISHLIST signed!? p w/o i */
+struct f end;
+method asma()
+ var p := this;
+ var i := 0;
+ while i < 16
+ do
+ var a := (p-(0-i)).f;
+ var b := (p-(-1-i)).f;
+ var c := a - (256 * b);
+
+ /* add 'a'-'A' iff 'A' <= c <= 'Z' */
+ if 0x40 < c then if c < 0x5B then
+ c := c--0x20;
+ end;
+ end;
+
+ (p-(0-i)).f := (256 * b) -(0-c);
+
+ i := i--1;
+ end;
+ return this;
+end;
--- /dev/null
+/* BOF georg_asma_00.call */
+#include <string.h> /* strcmp() */
+char x[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char y[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char z[] = "UVWxyz6789abcDEFuvwxyz6789abcdefUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char *p = &y[16];
+extern char *asma(char *);
+int ret = (asma(p)==p && (strcmp(y,z)==0));
+if (ret != 1) {
+ x[sizeof(x)-1] = '\0'; /* just 2b sure */
+ y[sizeof(y)-1] = '\0'; /* just 2b sure */
+ z[sizeof(z)-1] = '\0'; /* just 2b sure */
+ fprintf(stderr, "### %s:%d:%s() x '%s'\n", __FILE__, __LINE__, __FUNCTION__, x);
+ fprintf(stderr, "### %s:%d:%s() y '%s'\n", __FILE__, __LINE__, __FUNCTION__, y);
+ fprintf(stderr, "### %s:%d:%s() z '%s'\n", __FILE__, __LINE__, __FUNCTION__, z);
+}
+RET(ret);
+/* vim: set filetype=c: */
+/* EOF georg_asma_00.call */
--- /dev/null
+/** asma - aka tolower() first 16 bytes.
+ *
+ * unsigned char *asma(unsigned char *s)
+ * {
+ * int i;
+ * for (i=0; i<16; i++)
+ * {
+ * unsigned char c = s[i];
+ * c += (c >= 'A' && c <= 'Z') ? 'a'-'A' : 0;
+ * s[i] = c;
+ * }
+ * return s;
+ * }
+ */
+/* AMD64 Little Endian byte order
+ * p[0] c0 c1 c2 c3 c4 c5 c6 c7
+ * p[1] c1 c2 c3 c4 c5 c6 c7 c8
+ * p[1] * 256 00 c1 c2 c3 c4 c5 c6 c7
+ * p[0] - 256 * p[1] c0
+ */
+/* WISHLIST signed!? p w/o i */
+struct f end;
+method asma()
+ var i := 0;
+ while i < 16
+ do
+ var a := (this-(0-i)).f;
+ var b := (this-(-1-i)).f;
+ var c := a - (256 * b);
+
+ /* add 'a'-'A' iff 'A' <= c <= 'Z' */
+ if 0x40 < c then if c < 0x5B then
+ c := c--0x20;
+ end;
+ end;
+
+ (this-(0-i)).f := (256 * b) -(0-c);
+
+ i := i--1;
+ end;
+ return this;
+end;
--- /dev/null
+/* BOF georg_asma_00.call */
+#include <string.h> /* strcmp() */
+char x[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char y[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char z[] = "UVWxyz6789abcDEFuvwxyz6789abcdefUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char *p = &y[16];
+extern char *asma(char *);
+int ret = (asma(p)==p && (strcmp(y,z)==0));
+if (ret != 1) {
+ x[sizeof(x)-1] = '\0'; /* just 2b sure */
+ y[sizeof(y)-1] = '\0'; /* just 2b sure */
+ z[sizeof(z)-1] = '\0'; /* just 2b sure */
+ fprintf(stderr, "### %s:%d:%s() x '%s'\n", __FILE__, __LINE__, __FUNCTION__, x);
+ fprintf(stderr, "### %s:%d:%s() y '%s'\n", __FILE__, __LINE__, __FUNCTION__, y);
+ fprintf(stderr, "### %s:%d:%s() z '%s'\n", __FILE__, __LINE__, __FUNCTION__, z);
+}
+RET(ret);
+/* vim: set filetype=c: */
+/* EOF georg_asma_00.call */
--- /dev/null
+/** asma - aka tolower() first 16 bytes.
+ *
+ * unsigned char *asma(unsigned char *s)
+ * {
+ * int i;
+ * for (i=0; i<16; i++)
+ * {
+ * unsigned char c = s[i];
+ * c += (c >= 'A' && c <= 'Z') ? 'a'-'A' : 0;
+ * s[i] = c;
+ * }
+ * return s;
+ * }
+ */
+/* AMD64 Little Endian byte order
+ * p[0] c0 c1 c2 c3 c4 c5 c6 c7
+ * p[1] c1 c2 c3 c4 c5 c6 c7 c8
+ * p[1] * 256 00 c1 c2 c3 c4 c5 c6 c7
+ * p[0] - 256 * p[1] c0
+ */
+/* WISHLIST signed!? */
+struct f end;
+method asma()
+ var p := this;
+ var q := this--16;
+ while p < q
+ do
+ var a := p.f;
+ var b := (p--1).f;
+ var c := a - (256 * b);
+
+ /* add 'a'-'A' iff 'A' <= c <= 'Z' */
+ if 0x40 < c then if c < 0x5B then
+ c := c--0x20;
+ end;
+ end;
+
+ p.f := (256 * b) -(0-c);
+
+ p := p--1;
+ end;
+ return this;
+end;
--- /dev/null
+/* BOF georg_asma_00.call */
+#include <string.h> /* strcmp() */
+char x[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char y[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char z[] = "UVWxyz6789abcDEFuvwxyz6789abcdefUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char *p = &y[16];
+extern char *asma(char *);
+int ret = (asma(p)==p && (strcmp(y,z)==0));
+if (ret != 1) {
+ x[sizeof(x)-1] = '\0'; /* just 2b sure */
+ y[sizeof(y)-1] = '\0'; /* just 2b sure */
+ z[sizeof(z)-1] = '\0'; /* just 2b sure */
+ fprintf(stderr, "### %s:%d:%s() x '%s'\n", __FILE__, __LINE__, __FUNCTION__, x);
+ fprintf(stderr, "### %s:%d:%s() y '%s'\n", __FILE__, __LINE__, __FUNCTION__, y);
+ fprintf(stderr, "### %s:%d:%s() z '%s'\n", __FILE__, __LINE__, __FUNCTION__, z);
+}
+RET(ret);
+/* vim: set filetype=c: */
+/* EOF georg_asma_00.call */
--- /dev/null
+/** asma - aka tolower() first 16 bytes.
+ *
+ * unsigned char *asma(unsigned char *s)
+ * {
+ * int i;
+ * for (i=0; i<16; i++)
+ * {
+ * unsigned char c = s[i];
+ * c += (c >= 'A' && c <= 'Z') ? 'a'-'A' : 0;
+ * s[i] = c;
+ * }
+ * return s;
+ * }
+ */
+/* AMD64 Little Endian byte order
+ * p[0] c0 c1 c2 c3 c4 c5 c6 c7
+ * p[1] c1 c2 c3 c4 c5 c6 c7 c8
+ * p[1] * 256 00 c1 c2 c3 c4 c5 c6 c7
+ * p[0] - 256 * p[1] c0
+ */
+/* WISHLIST signed!? */
+struct f end;
+method asma()
+ var p := this;
+ var q := this--16;
+ while p < q
+ do
+ var c := p.f - (256 * (p--1).f);
+
+ /* add 'a'-'A' iff 'A' <= c <= 'Z' */
+ if 0x40 < c then if c < 0x5B then
+ c := c--0x20;
+ end;
+ end;
+
+ p.f := (256 * (p--1).f)-(0-c);
+
+ p := p--1;
+ end;
+ return this;
+end;
--- /dev/null
+/* BOF georg_asma_00.call */
+#include <string.h> /* strcmp() */
+char x[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char y[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char z[] = "UVWxyz6789abcDEFuvwxyz6789abcdefUVWxyz6789abcDEFUVWxyz6789abcDEF";
+char *p = &y[16];
+extern char *asma(char *);
+int ret = (asma(p)==p && (strcmp(y,z)==0));
+if (ret != 1) {
+ x[sizeof(x)-1] = '\0'; /* just 2b sure */
+ y[sizeof(y)-1] = '\0'; /* just 2b sure */
+ z[sizeof(z)-1] = '\0'; /* just 2b sure */
+ fprintf(stderr, "### %s:%d:%s() x '%s'\n", __FILE__, __LINE__, __FUNCTION__, x);
+ fprintf(stderr, "### %s:%d:%s() y '%s'\n", __FILE__, __LINE__, __FUNCTION__, y);
+ fprintf(stderr, "### %s:%d:%s() z '%s'\n", __FILE__, __LINE__, __FUNCTION__, z);
+}
+RET(ret);
+/* vim: set filetype=c: */
+/* EOF georg_asma_00.call */
--- /dev/null
+/* BOF georg_asmb_00.call */
+#include <string.h> /* strcmp() strlen() */
+char x[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDE\0UVWxyz6789abcDEFUVWxyz6789abcDEF";
+char y[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDE\0UVWxyz6789abcDEFUVWxyz6789abcDEF";
+char z[] = "UVWxyz6789abcDEFuvwxyz6789abcdefuvwxyz6789abcde\0UVWxyz6789abcDEFUVWxyz6789abcDEF";
+char *p = &y[16];
+extern char *asmb(char *);
+int ret = (asmb(p)==p && (strcmp(y,z)==0));
+if (ret != 1) {
+ x[sizeof(x)-1] = '\0'; /* just 2b sure */
+ y[sizeof(y)-1] = '\0'; /* just 2b sure */
+ z[sizeof(z)-1] = '\0'; /* just 2b sure */
+ x[sizeof(x)-2] = '\0'; /* just 2b sure */
+ y[sizeof(y)-2] = '\0'; /* just 2b sure */
+ z[sizeof(z)-2] = '\0'; /* just 2b sure */
+ x[strlen(x)] = '#';
+ y[strlen(y)] = '#';
+ z[strlen(z)] = '#';
+ fprintf(stderr, "### %s:%d:%s() x '%s'\n", __FILE__, __LINE__, __FUNCTION__, x);
+ fprintf(stderr, "### %s:%d:%s() y '%s'\n", __FILE__, __LINE__, __FUNCTION__, y);
+ fprintf(stderr, "### %s:%d:%s() z '%s'\n", __FILE__, __LINE__, __FUNCTION__, z);
+}
+RET(ret);
+/* vim: set filetype=c: */
+/* EOF georg_asmb_00.call */
--- /dev/null
+/** asmb - aka tolower(), maybe more than strlen().
+ *
+ * unsigned char *asmb(unsigned char *s)
+ * {
+ * unsigned long i;
+ * for (i=0; s[i]; i++)
+ * {
+ * unsigned char c = s[i];
+ * c += (c >= 'A' && c <= 'Z') ? 'a'-'A' : 0;
+ * s[i] = c;
+ * }
+ * return s;
+ * }
+ */
+/* AMD64 Little Endian byte order
+ * p[0] c0 c1 c2 c3 c4 c5 c6 c7
+ * p[1] c1 c2 c3 c4 c5 c6 c7 c8
+ * p[1] * 256 00 c1 c2 c3 c4 c5 c6 c7
+ * p[0] - 256 * p[1] c0
+ */
+/* WISHLIST signed!? */
+struct f end;
+method asmb()
+ var p := this;
+ while p.f - (256 * (p--1).f)
+ do
+ var c := p.f - (256 * (p--1).f);
+
+ /* add 'a'-'A' iff 'A' <= c <= 'Z' */
+ if 0x40 < c then if c < 0x5B then
+ c := c--0x20;
+ end;
+ end;
+
+ p.f := (256 * (p--1).f)-(0-c);
+
+ p := p--1;
+ end;
+ return this;
+end;
--- /dev/null
+/* BOF georg_asmb_00.call */
+#include <string.h> /* strcmp() strlen() */
+char x[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDE\0UVWxyz6789abcDEFUVWxyz6789abcDEF";
+char y[] = "UVWxyz6789abcDEFUVWxyz6789abcDEFUVWxyz6789abcDE\0UVWxyz6789abcDEFUVWxyz6789abcDEF";
+char z[] = "UVWxyz6789abcDEFuvwxyz6789abcdefuvwxyz6789abcde\0UVWxyz6789abcDEFUVWxyz6789abcDEF";
+char *p = &y[16];
+extern char *asmb(char *);
+int ret = (asmb(p)==p && (strcmp(y,z)==0));
+if (ret != 1) {
+ x[sizeof(x)-1] = '\0'; /* just 2b sure */
+ y[sizeof(y)-1] = '\0'; /* just 2b sure */
+ z[sizeof(z)-1] = '\0'; /* just 2b sure */
+ x[sizeof(x)-2] = '\0'; /* just 2b sure */
+ y[sizeof(y)-2] = '\0'; /* just 2b sure */
+ z[sizeof(z)-2] = '\0'; /* just 2b sure */
+ x[strlen(x)] = '#';
+ y[strlen(y)] = '#';
+ z[strlen(z)] = '#';
+ fprintf(stderr, "### %s:%d:%s() x '%s'\n", __FILE__, __LINE__, __FUNCTION__, x);
+ fprintf(stderr, "### %s:%d:%s() y '%s'\n", __FILE__, __LINE__, __FUNCTION__, y);
+ fprintf(stderr, "### %s:%d:%s() z '%s'\n", __FILE__, __LINE__, __FUNCTION__, z);
+}
+RET(ret);
+/* vim: set filetype=c: */
+/* EOF georg_asmb_00.call */
--- /dev/null
+extern long fib(long);
+RET(fib(-1)==-1 && fib(0)==0 && fib(1)==1 && fib(2)==1 && fib(3)==2 && fib(7)+fib(8)==fib(9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+method fib()
+ if this < 2 then return this; end;
+ var a := 0;
+ var b := 1;
+ var c := this;
+ var x := this;
+ while not (x < 2)
+ do
+ c := a-(0-b);
+ a := b;
+ b := c;
+ x := x-1;
+ end;
+ return c;
+end;
--- /dev/null
+extern long fib(long);
+RET(fib(-1)==-1 && fib(0)==0 && fib(1)==1 && fib(2)==1 && fib(3)==2 && fib(7)+fib(8)==fib(9));
--- /dev/null
+extern long fib(long,long);
+RET(fib(0,-1)==-1 && fib(0,0)==0 && fib(0,1)==1 && fib(0,2)==1 && fib(0,3)==2 && fib(0,7)+fib(0,8)==fib(0,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+method fib(x)
+ if x < 2 then return x; end;
+ var a := 0;
+ var b := 1;
+ var c := x;
+ while not (x < 2)
+ do
+ c := a-(0-b);
+ a := b;
+ b := c;
+ x := x-1;
+ end;
+ return c;
+end;
--- /dev/null
+extern long fib(long,long);
+RET(fib(0,-1)==-1 && fib(0,0)==0 && fib(0,1)==1 && fib(0,2)==1 && fib(0,3)==2 && fib(0,7)+fib(0,8)==fib(0,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+method fib(x)
+ var a := 0;
+ var b := 1;
+ var c := x;
+ while not (x < 2)
+ do
+ c := a-(0-b);
+ a := b;
+ b := c;
+ x := x-1;
+ end;
+ return c;
+end;
--- /dev/null
+extern long fib(long,long);
+RET(fib(0,-1)==-1 && fib(0,0)==0 && fib(0,1)==1 && fib(0,2)==1 && fib(0,3)==2 && fib(0,7)+fib(0,8)==fib(0,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+method fib(x)
+ var a := 0;
+ var b := 1;
+ var c := x;
+ while not (x < 2)
+ do
+ var A := a;
+ var B := b;
+ a := B;
+ b := A-(0-B);
+ c := b;
+ x := x-1;
+ end;
+ return c;
+end;
--- /dev/null
+extern long fib(long,long);
+RET(fib(0,-1)==-1 && fib(0,0)==0 && fib(0,1)==1 && fib(0,2)==1 && fib(0,3)==2 && fib(0,7)+fib(0,8)==fib(0,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+method fib(x)
+ var a := 0;
+ var b := 1;
+ if x < 2 then return x; end;
+ while not (x < 2)
+ do
+ var A := a;
+ var B := b;
+ a := B;
+ b := A-(0-B);
+ x := x-1;
+ end;
+ return b;
+end;
--- /dev/null
+extern long fib(long,long);
+RET(fib(0,-1)==-1 && fib(0,0)==0 && fib(0,1)==1 && fib(0,2)==1 && fib(0,3)==2 && fib(0,7)+fib(0,8)==fib(0,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+method fib(x)
+ var a := 0;
+ var b := 1;
+ if x < 2 then return x; end;
+ while not (x < 2)
+ do
+ var A := a;
+ a := b;
+ b := A-(0-b);
+ x := x-1;
+ end;
+ return b;
+end;
--- /dev/null
+extern long fib(long,long);
+RET(fib(0,-1)==-1 && fib(0,0)==0 && fib(0,1)==1 && fib(0,2)==1 && fib(0,3)==2 && fib(0,7)+fib(0,8)==fib(0,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+method fib(x)
+ var a := 0;
+ var b := 1;
+ if x < 2 then return x; end;
+ while not (x < 2)
+ do
+ var A := a;
+ a := b;
+ b := b-(0-A);
+ x := x-1;
+ end;
+ return b;
+end;
--- /dev/null
+extern long fib(long,long);
+RET(fib(0,-1)==-1 && fib(0,0)==0 && fib(0,1)==1 && fib(0,2)==1 && fib(0,3)==2 && fib(0,7)+fib(0,8)==fib(0,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+method fib(x)
+ var a := 0;
+ var b := 1;
+ if x < 2 then return x; end;
+ while not (x < 2)
+ do
+ var A := a;
+ a := b;
+ b := 0-b;
+ b := A-b;
+ x := x-1;
+ end;
+ return b;
+end;
--- /dev/null
+extern long fib(long,long);
+RET(fib(0,-1)==-1 && fib(0,0)==0 && fib(0,1)==1 && fib(0,2)==1 && fib(0,3)==2 && fib(0,7)+fib(0,8)==fib(0,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+method fib(x)
+ var a := 0;
+ var b := 1;
+ if x < 2
+ then
+ return x;
+ end;
+ while not (x < 2)
+ do
+ var A := a;
+ a := b;
+ b := 0-b;
+ b := A-b;
+ x := x-1;
+ end;
+ return b;
+end;
--- /dev/null
+extern long fib(long,long);
+RET(fib(0,-1)==-1 && fib(0,0)==0 && fib(0,1)==1 && fib(0,2)==1 && fib(0,3)==2 && fib(0,7)+fib(0,8)==fib(0,9));
--- /dev/null
+long s[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+extern long fib(long *,long);
+RET(fib(s,-1)==-1 && fib(s,0)==0 && fib(s,1)==1 && fib(s,2)==1 && fib(s,3)==2 && fib(s,7)+fib(s,8)==fib(s,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+struct f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 end;
+
+method fib(x)
+ if x < 0 then return -1; end; f0 := 0;
+ if x < 1 then return f0; end; f1 := 1;
+ if x < 2 then return f1; end; f2 := 1;
+ if x < 3 then return f2; end; f3 := 2;
+ if x < 4 then return f3; end; f4 := 3;
+ if x < 5 then return f4; end; f5 := 5;
+ if x < 6 then return f5; end; f6 := 8;
+ if x < 7 then return f6; end; f7 := 13;
+ if x < 8 then return f7; end; f8 := 21;
+ if x < 9 then return f8; end; f9 := 34;
+ return f9;
+end;
--- /dev/null
+long s[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+extern long fib(long *,long);
+RET(fib(s,-1)==-1 && fib(s,0)==0 && fib(s,1)==1 && fib(s,2)==1 && fib(s,3)==2 && fib(s,7)+fib(s,8)==fib(s,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+struct f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 end;
+
+method fib(x)
+ if x < 0 then return -1; end; f0 := 0;
+ if x < 1 then return f0; end; f1 := 1;
+ if x < 2 then return f1; end; f2 := f0-(0-f1);
+ if x < 3 then return f2; end; f3 := f1-(0-f2);
+ if x < 4 then return f3; end; f4 := f2-(0-f3);
+ if x < 5 then return f4; end; f5 := f3-(0-f4);
+ if x < 6 then return f5; end; f6 := f4-(0-f5);
+ if x < 7 then return f6; end; f7 := f5-(0-f6);
+ if x < 8 then return f7; end; f8 := f6-(0-f7);
+ if x < 9 then return f8; end; f9 := f7-(0-f8);
+ return f9;
+end;
--- /dev/null
+long s[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+extern long fib(long *,long);
+RET(fib(s,-1)==-1 && fib(s,0)==0 && fib(s,1)==1 && fib(s,2)==1 && fib(s,3)==2 && fib(s,7)+fib(s,8)==fib(s,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+struct f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 end;
+
+method fib(x)
+ var t := this;
+ if x < 0 then return -1; end; t.f0 := 0;
+ if x < 1 then return f0; end; t.f1 := 1;
+ if x < 2 then return f1; end; t.f2 := t.f0-(0-t.f1); t := t--8;
+ if x < 3 then return f2; end; t.f2 := t.f0-(0-t.f1); t := t--8;
+ if x < 4 then return f3; end; t.f2 := t.f0-(0-t.f1); t := t--8;
+ if x < 5 then return f4; end; t.f2 := t.f0-(0-t.f1); t := t--8;
+ if x < 6 then return f5; end; t.f2 := t.f0-(0-t.f1); t := t--8;
+ if x < 7 then return f6; end; t.f2 := t.f0-(0-t.f1); t := t--8;
+ if x < 8 then return f7; end; t.f2 := t.f0-(0-t.f1); t := t--8;
+ if x < 9 then return f8; end; t.f2 := t.f0-(0-t.f1); t := t--8;
+ return f9;
+end;
--- /dev/null
+long s[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+extern long fib(long *,long);
+RET(fib(s,-1)==-1 && fib(s,0)==0 && fib(s,1)==1 && fib(s,2)==1 && fib(s,3)==2 && fib(s,7)+fib(s,8)==fib(s,9));
--- /dev/null
+/* fibonacci */
+
+/* F_0 = 0 */
+/* F_1 = 1 */
+/* F_n = F_{n-1} + F_{n-2} */
+
+struct a b c end;
+
+method fib(x)
+ if x < 0 then return x; end;
+ a := 0;
+ if x < 1 then return x; end;
+ b := 1;
+ if x < 2 then return x; end;
+ var t := this;
+
+ while not (x < 2)
+ do
+ t.c := t.a-(0-t.b);
+ t := t--8;
+ x := x-1;
+ end;
+ return (t-8).c;
+end;
--- /dev/null
+long s[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+extern long fib(long *,long);
+RET(fib(s,-1)==-1 && fib(s,0)==0 && fib(s,1)==1 && fib(s,2)==1 && fib(s,3)==2 && fib(s,7)+fib(s,8)==fib(s,9));
--- /dev/null
+struct goo gaa gee end;
+
+method s(x y)
+ var foobar := (this.gaa * x.goo) - (y * -2);
+ return foobar * foobar;
+end;
--- /dev/null
+extern long s(long *this, long*, long);
+
+long ar[] = {111, 222, 333};
+
+RET(s(ar, ar, 5) == ((ar[1] * ar[0]) - (5 * -2)) * ((ar[1] * ar[0]) - (5 * -2)));
--- /dev/null
+method a()
+ var u := 3;
+ var v := this;
+ return u - (v - 10);
+end;
+
+method b()
+ var u := 10;
+ var v := u;
+ return (u - (-1 * v));
+end;
+
+
--- /dev/null
+extern long a(long long this);
+extern long b(long long this);
+
+
+RET(a(20) == -7 && b(0xDEAD) == 20);
--- /dev/null
+struct x y z end;
+
+method a()
+ var u := this.x;
+ var v := 4711;
+ u := u * this.y;
+ v := u - (0 - v);
+ return u - v;
+end;
+
+method b(a)
+ var u := 10;
+ u := a.z;
+ return u * 2;
+end;
+
+
--- /dev/null
+extern long a(long long *this);
+extern long b(long long this, long long *a);
+
+long long ar[3] = { 2, 4, 8 };
+
+RET(a(ar) == -4711 && b(0xDEAD, ar) == 16);
--- /dev/null
+struct x y z end;
+
+method a()
+ this.x := /*0*/815;
+ /*z := y * this.x;*/
+ return this.x;
+end;
+
--- /dev/null
+extern long a(long long *this);
+
+
+long long ar[3] = { 2, 4, 8 };
+
+RET(a(ar) == 815 && ar[0] == 815);
--- /dev/null
+struct x y z end;
+
+method a()
+ this.x := /*0*/815;
+ z := y * this.x;
+ return this.z;
+end;
+
+
+
+
--- /dev/null
+extern long a(long long *this);
+
+
+long long ar[3] = { 2, 4, 8 };
+
+RET(a(ar) == 3260 && ar[2] == 3260 && ar[0] == 815);
\ No newline at end of file
--- /dev/null
+struct x y z end;
+
+method b(a)
+ a.x := 3;
+ a.y := 2;
+ a.z := (a.x * a.y) - 10;
+ return a;
+end;
--- /dev/null
+extern long long* b(long long this, long long *a);
+
+long long ar[3] = { 2, 4, 8 };
+
+RET(b(0xDEAD, ar) == ar && ar[0] == 3 && ar[1] == 2 && ar[2] == -4);
--- /dev/null
+struct x y z end;
+
+method m(x)
+ var a := x;
+ this.x := (this.y or this.z) = a;
+ x := 47;
+ return this.y * x;
+end;
--- /dev/null
+extern long long m(long long *this, long long x);
+
+long long ar[3] = { 2, 4, 8 };
+
+RET(m(ar, 12) == 188 && ar[0] == 1 && ar[1] == 4 && ar[2] == 8);
--- /dev/null
+method m()
+ if this < 10 then
+ return 3;
+ end;
+ return 0;
+end;
--- /dev/null
+extern long long m(long long this);
+
+RET(m(9) == 3 && m(10) == 0);
\ No newline at end of file
--- /dev/null
+method m(a)
+ var u := 10;
+ if this < 50 then
+ if 10 < a then
+ return a - 10;
+ end;
+ var x := 20;
+ u := u - (x * -1);
+ end;
+ return u;
+end;
--- /dev/null
+extern long long m(long long this, long long a);
+
+RET(m(51, 0) == 10 && m(-3, 5) == 30 && m(35, 18) == 8);
\ No newline at end of file
--- /dev/null
+method m(a)
+ var u := 10;
+ if this < 50 then
+ if 10 < a then
+ return a - 10;
+ end;
+ var x:= 20;
+ if this < 0 then
+ x := x or 64;
+ end;
+ u := u * x;
+ end;
+ return u;
+end;
--- /dev/null
+extern long long m(long long this, long long a);
+
+RET(m(60, 0) == 10 && m(0, 10) == 200 && m(35, 18) == 8 && m(-10, 0) == 840);
\ No newline at end of file
--- /dev/null
+method m()
+ if 5 < 10 then
+ return 10;
+ else
+ return 5;
+ end;
+end;
+
--- /dev/null
+extern long long m(long long this);
+
+RET(m(0xCCACC) == 10);
\ No newline at end of file
--- /dev/null
+2
\ No newline at end of file
--- /dev/null
+method m()
+ if this < -100 then
+ return -4711;
+ else
+ if (-10 < this) then
+ if (this < -5) then
+ if (this = -6) then
+ return 1;
+ else
+ return 2;
+ end;
+ else
+ if this = -4 then
+ return 3;
+ end;
+ if this = -3 then
+ return 6;
+ end;
+ if this = -2 then
+ return 7;
+ end;
+ end;
+ else
+ return 4;
+ end;
+ end;
+ return 5;
+end;
+
--- /dev/null
+extern long long m(long long this);
+
+RET(m(-2) == 7 && m(-1) == 5);
+
+//RET(m(-200) == -4711 && m(-6) == 1 && m(-7) == 2 && m(-4) == 3 && m(-11) == 4 && m(-3) == 6 && m(-2) == 7 && m(-1) == 5);
--- /dev/null
+method m()
+ var x := 10;
+ while 0 < x do
+ x := x-1;
+ end;
+ return x;
+end;
+
--- /dev/null
+extern long long m(long long this);
+
+RET(m(0xBABE) == 0);
\ No newline at end of file
--- /dev/null
+struct x end;
+
+method m(s)
+ var i := 0;
+ var sum := 0;
+ while i < s do
+ (this - (-8 * i)).x := (this - (-8 * i)).x * 10;
+ if (this - (-8 * i)).x = 47110 then
+ (this - (-8 * i)).x := 0815;
+ end;
+ sum := sum - ((this - (-8 * i)).x * -1);
+ i := i - (-1);
+ end;
+ return sum;
+end;
+
--- /dev/null
+extern long long m(long long *this, long long s);
+
+long long ar[] = { 1, 2, 3, 4};
+long long ar2[] = { -7, 4711, 3, 4};
+
+RET(m(ar, 3) == 60 && ar[0] == 10 && ar[1] == 20 && ar[2] == 30 && ar[3] == 4
+&& m(ar2, 2) == 745 && ar2[0] == -70 && ar2[1] == 815 && ar2[2] == 3);
--- /dev/null
+struct x end;
+
+method m1(size)
+ var x:= size - (-10);
+ x := (x * 0) - 20;
+ var i:= 0;
+ while not (i = size) do
+ if i < 1 then
+ (this - (i * -8)).x := (this - (i * -8)).x - (-20);
+ else
+ (this - (i * -8)).x := (this - ((i - 1) * -8)).x or 128;
+ end;
+ i := i - -1;
+ end;
+ return x;
+end;
+
+method m2(y)
+ if 100 < y then
+ return 0;
+ end;
+ var x := -10;
+ while x < y do
+ x := x * -2;
+ end;
+ if y < 0 then
+ return -1 * x;
+ else
+ return 1 * x;
+ end;
+end;
+
--- /dev/null
+extern long long m1(long long *this, long long size);
+extern long long m2(long long this, long long y);
+
+long long ar[] = { 2, 4, 8, 16, 32 };
+
+RET(m1(ar, 3) == -20 && ar[0] == 22 && ar[1] == 150 && ar[2] == 150 &&
+m2(0xABC, 101) == 0 && m2(0xABC, -5) == -20 && m2(0xABC, 100) == 320);
\ No newline at end of file
--- /dev/null
+struct bar end;
+
+method foo(bar)
+ while not(0 = bar) do
+ bar := (bar - 1);
+ this.bar := (this.bar * 2);
+ end;
+ return this.bar;
+end;
+
+method bar(x)
+ while 1 do
+ x := x - (-1);
+ if not(x = 10) then
+ x := x * 1;
+ else
+ return x;
+ end;
+ end;
+end;
+
+method blu(a)
+ while 0 do
+ return 3;
+ end;
+ return 4;
+end;
--- /dev/null
+
+long foo(long*, long);
+long bar(long, long);
+long blu(long, long);
+
+long inp[] = {2};
+
+RET(foo(inp, 4) == 32 && blu(1337,42) == 4 && bar(0xDEAD,4) == 10 && bar(0x1337, 9) == 10);
--- /dev/null
+struct a end;
+
+
+method foo(x)
+ if (x-1) then
+ return 5*(this*3);
+ else
+ return 4*(2*this);
+ end;
+end;
+
+method bar(n)
+ var x := 5;
+ var y := 6;
+ if n then
+ return x - a;
+ end;
+ if n < 7 then
+ return y * a;
+ end;
+ return x;
+end;
+
+method bla()
+ if a then
+ return 5;
+ else
+ return a;
+ end;
+end;
--- /dev/null
+
+long foo(long, long);
+long bar(long*, long);
+long bla(long*);
+
+long muh[] = {3}, kuh[] = {0};
+
+RET(foo(5,1) == 40 && foo(4,0) == 60 && bar(muh, 1) == 2 && bar(muh,0) == 18 && bla(muh) == 5 && bla(kuh) == 0);
+
--- /dev/null
+
+struct a b end;
+
+method foo()
+ var x := 5;
+ if this * x then
+ return (x - this) * x;
+ end;
+ return x;
+end;
+
+method bar(n)
+ var x := n;
+ this.a := x;
+ return x;
+end;
+
+method bla(m n)
+ if not((m-n) < (m*n)) then
+ return m;
+ else
+ return n;
+ end;
+end;
--- /dev/null
+
+long foo(long);
+long bar(long*, long);
+long bla(long, long, long);
+
+long muh[] = {1, 3};
+long kuh[] = {2,6};
+
+RET(foo(1) == 20 && foo(0) == 5 && bar(muh, 5) == 5 && muh[0] == 5 && bar(muh,10) == 10 && muh[0] == 10 && bla(0xDEAF, 10,1) == 1 && bla(0xABC, 10,-1) == 10 );
+
--- /dev/null
+struct a end;
+
+method foo(b)
+ if 0 * b then
+ return b;
+ else
+ return (b - a);
+ end;
+end;
+
+method bar(b c)
+ if b - b then
+ return 3;
+ else
+ if b - this then
+ return 2;
+ else
+ if b * 0 then
+ return 3;
+ else
+ if c * 1 then
+ return 1;
+ else
+ return 4;
+ end;
+ end;
+ end;
+ end;
+end;
+
+method bla()
+ if a * 0 then
+ return 3;
+ else
+ if a * 1 then
+ return 1;
+ else
+ return 2;
+ end;
+ end;
+end;
+
+method blub()
+ if 0 * a then
+ return 3;
+ else
+ if 1 * a then
+ return 1;
+ else
+ return 2;
+ end;
+ end;
+end;
+
+method miau(n)
+ if 0 * (a - n) then
+ return 3;
+ else
+ if 1 * (a -n) then
+ return 2;
+ else
+ return (n-(a-1));
+ end;
+ end;
+end;
+
+method null(n)
+ if (a - n) * 0 then
+ return 3;
+ else
+ if (a -n) * 1 then
+ return 2;
+ else
+ return (a - (n<a));
+ end;
+ end;
+end;
--- /dev/null
+
+long foo(long*, long);
+long bar(long, long, long);
+long bla(long*);
+long blub(long*);
+long miau(long*, long);
+long null(long*, long);
+
+long muh[] = {4}, kuh[] = {0};
+
+
+RET(foo(muh,5) == 1 && foo(muh, 2) == -2 && foo(muh,0) == -4 && bar(5,5,2) == 1&& bar(3,5,2) == 2 && bar(3,3, 0) == 4 && bla(muh) == 1 && bla(kuh) == 2 && blub(muh) == 1 && blub(kuh) == 2 && miau(muh, 3) == 2 && miau(muh,4) == 1 && null(muh,3) == 2 && null(muh,4) == 4 );
+
--- /dev/null
+
+struct a b end;
+
+method foo(n)
+ if 0 then
+ return 0;
+ end;
+ a := b;
+ if not(not(a = b)) then
+ return n - (a*b);
+ end;
+ return 0x9999;
+end;
+
+method bar(n)
+ var x := not(5 < (n*2));
+ if x then
+ return n - (2*n);
+ else
+ x := 3 * (4 * n);
+ return x;
+ end;
+end;
+
+method bla(n)
+ if not(not(2 * ( 5 * (n or n)))) then
+ return 1;
+ else
+ return 0;
+ end;
+end;
+
+method blubb(n)
+ if not((n*n) < 20) then
+ return 20;
+ else
+ if not(not(n)) then
+ return 10;
+ else
+ return 5;
+ end;
+ end;
+end;
+
+struct q r s t end;
+
+method miau(n m)
+ r := 5 * ((n-m) * 3);
+ s := 7 * (q * 5);
+ t := 40000000 * (4 * q);
+ return 0;
+end;
--- /dev/null
+
+long foo(long*, long);
+long bar(long, long);
+long bla(long, long);
+long blubb(long, long);
+long miau(long*, long, long);
+
+long muh[] = {10, 3};
+long kuh[] = {2,6};
+
+long narf[] = {1,4,5,6};
+long puit[] = {4,3,2,1};
+
+RET(foo(muh, 10) == 1 && muh[1] == 3 && muh[0] == 3 && foo(kuh, 50) == 14 && kuh[0] == 6 && kuh[1] == 6 && bar(0xf00,2) == -2 && bar(0xf00,3) == 36 && bla(0x42, 4) == 1 && bla(0x42, 0) == 0 && blubb(0x1337, 3) == 10 && blubb(0xA, 0) == 5 && blubb(0xB, 5) == 20 && miau(narf, 4, 5) == 0 && narf[0] == 1 && narf[1] == -15 && narf[2] == 35 && narf[3] == 160000000 && miau(puit, 6,3) == 0 && puit[0] == 4 && puit[1] == 45 && puit[2] == 140 && puit[3] == 640000000);
+
--- /dev/null
+method fib()
+ var n:=0;
+ var a:=0;
+ var b:=1;
+ while n<this do
+ n:=n--1;
+ b:=b-(0-a);
+ a:=b-a;
+ end;
+ return a;
+end;
--- /dev/null
+extern long fib(long);
+RET(3==fib(4));
--- /dev/null
+struct a end;
+
+method f()
+ this.a := this.a;
+ return this.a;
+end;
--- /dev/null
+
+long f(long*);
+
+long a[] = {1};
+
+RET(f(a) == 1);
--- /dev/null
+method q(x y)
+ var foo := 42;
+ return 5 - ((x - 3) - y);
+end;
+
+method r(x y)
+ var bar := x*y;
+ return (x - y) - 10;
+end;
+
+struct goo gaa gee end;
+
+method s(x y)
+ var foobar := (x.gaa * y.goo) - ((2*x) - y).gee;
+ return (x - 1);
+end;
--- /dev/null
+extern long q(long this, long, long);
+extern long r(long this, long, long);
+extern long s(long this, long*, long*);
+
+long ar[] = {111, 222, 333};
+
+RET((q(0xDEAD, 33, 15) == -10) && (r(0xDEAD, 33, 15) == 8) && (s(0xDEAD, ar, ar) == ((long) ar - 1)));
--- /dev/null
+#!/bin/bash
+
+i=$1
+beispiel=gesamt
+PROGRAM=./$beispiel
+
+#LOC=.
+LOC=/usr/ftp/pub/ubvl/test/$beispiel
+
+allow_null_glob_expansion=1
+
+if [ ! -d ~/abgabe/$beispiel ]; then
+ echo "Fehler: Verzeichnis ~/abgabe/$beispiel existiert nicht."
+ exit 1
+else
+ cd ~/abgabe/$beispiel
+ echo 'Teste "make"'
+ make
+fi
+
+if test ! -x $PROGRAM
+then
+ echo "Fehler: Kein Programm $PROGRAM"
+ exit 1
+fi
+let prgnum=0
+#for i in $LOC/*.0 $LOC2/*.0
+if [ -f $i ]; then
+ let prgnum=prgnum+1
+ let errorfound=0
+ echo "==========> Eingabe von $i:"
+ cat $i
+ echo
+ RESFILE=test${beispiel}out$$
+ $PROGRAM <$i >$RESFILE
+ retval=$?
+ echo -n "Übersetzung: "
+ if test $retval -eq 0
+ then
+ echo "Status korrekt"
+ else
+ echo "[Errot] Status=$retval. Erwartet: 0"
+ let errorfound=1
+ fi
+ echo
+ echo "Ausgabe:"
+ if [ -f ~/test/scripts/clr.py ]; then
+ cat $RESFILE | ~/test/scripts/clr.py
+ else
+ cat $RESFILE
+ fi
+ mv -f $RESFILE $RESFILE.s
+ CALLFILE=${i%.*}.call
+ echo
+ if [ ! -f $CALLFILE ]; then
+ echo "Fehler: Datei $CALLFILE existiert nicht, kann Code nicht ausführen..."
+ exit 1
+ else
+ echo "Übersetze und linke das Testprogramm:"
+ if cc -g -I. -DCALL=\"$CALLFILE\" $LOC/testmain.c $LOC/callingconvention.o $RESFILE.s; then
+ echo
+ echo "Rufe folgendes Codefragment auf:"
+ cat $CALLFILE
+ echo
+ gdb ./a.out
+ else
+ echo "[Error] Erzeugter Code konnte nicht assembliert und gelinkt werden."
+ let errorfound=1
+ fi
+ fi
+ rm -f a.out $RESFILE $RESFILE.s
+fi
projects / testub10.git / commitdiff