Added tests from Scott's PIC tests

git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@1181 4a8a32a2-be11-0410-ad9d-d568d2c75423

diff --git a/support/regression/tests/scott-add.c b/support/regression/tests/scott-add.c
new file mode 100644 (file)
index 0000000..5fb229b
--- /dev/null
+++ b/support/regression/tests/scott-add.c
@@ -0,0 +1,155 @@
+/* Addition tests
+ */
+#include <testfwk.h>
+
+/* bit types are not ANSI - so provide a way of disabling bit types
+ * if this file is used to test other compilers besides SDCC */
+#define SUPPORT_BIT_TYPES 0
+
+/* Some compilers that support bit types do not support bit arithmetic 
+ * (like bitx = bity + bitz;) */
+#define SUPPORT_BIT_ARITHMETIC 0
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+void 
+test_add_lit2uchar(void)
+{
+  achar0 = achar0 + 5;
+
+  ASSERT(achar0 == 5);
+
+  achar0 += 10;
+  
+  ASSERT(achar0 == 15);
+
+  achar0 = achar0 +1;  // Should be an increment
+
+  ASSERT(achar0 == 16);
+
+  for(achar1 = 0; achar1 < 100; achar1++)
+    achar0 += 2;
+
+  ASSERT(achar0 == 216);
+}
+
+void
+test_add_uchar2uchar_setup(void)
+{
+  achar0=16;
+  achar1=0;
+}
+
+void 
+test_add_uchar2uchar(void)
+{
+  achar1 = achar1 + achar0;
+
+  ASSERT(achar1 == 16);
+
+  for(achar2 = 0; achar2<7; achar2++)
+    achar1 += achar0;
+
+  ASSERT(achar1 == 128);
+}
+
+// assumes
+//  achar0 = 0
+//  achar1 = 32
+//  achar2, achar3 can be anything.
+
+void 
+test_add_uchar2uchar2_setup(void)
+{
+  achar0 = 0;
+  achar1 = 32;
+}
+
+void 
+test_add_uchar2uchar2(void)
+{
+  achar0++;
+  achar0 = achar0 + 1;
+  achar0 = achar0 + 2;
+  achar0 = achar0 + 3;
+
+  ASSERT(achar0 == 7);
+
+  achar1 += achar0;
+  ASSERT(achar1 == 39);
+
+  achar2 = achar1 + achar0;
+  ASSERT(achar2 == 46);
+
+  achar3 = achar2 + achar1 + achar0;
+  ASSERT(achar3 == 92);
+
+}
+
+#if SUPPORT_BIT_TYPES
+void add_bits(void)
+{
+
+  bit1 = bit0;
+
+  bit0 = 1;
+
+  if(bit1 != 0)
+    failures++;
+
+  bit1 = bit1+bit0;
+  ASSERT(bit1 == 1);
+
+#if SUPPORT_BIT_ARITHMETIC
+  bit2 = bit1+bit3;
+  ASSERT(bit2 != 0);
+
+  bit3 = bit4+bit5+bit6+bit7+bit0;
+  ASSERT(bit3 == 0);
+#endif
+}
+
+/* add_bit2uchar(void) - assumes bit0 = 1, achar0 = 7  */
+
+void 
+disabled_test_add_bit2uchar(void)
+{
+  achar0 += bit0;
+
+  ASSERT(achar0 == 8);
+
+  ASSERT(achar0 == bit0);
+}
+
+void 
+disabled_test_add_bit2uint(void)
+{
+  ASSERT(aint0 == bit11);
+
+  aint0 += bit0;
+  ASSERT(aint0 == 1);
+}
+#endif

diff --git a/support/regression/tests/scott-arrays.c b/support/regression/tests/scott-arrays.c
new file mode 100644 (file)
index 0000000..a873653
--- /dev/null
+++ b/support/regression/tests/scott-arrays.c
@@ -0,0 +1,124 @@
+/*
+ */
+#include <testfwk.h>
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+bool_or1 (void)
+{
+
+  ASSERT (!((achar0 > 0) || (achar1 > 0)));
+}
+
+void
+bool_or2 (void)
+{
+
+  ASSERT (!(achar0 || achar1));
+}
+
+void
+bool_test1 (void)
+{
+
+  ASSERT (!((achar0 == 0) || achar1));
+}
+
+
+void
+bool_test2 (void)
+{
+
+  ASSERT (!((achar0 == 0) || aint0));
+}
+
+void
+bool_and1 (void)
+{
+
+  ASSERT (!(achar0 && achar1));
+}
+
+void
+bin_or1 (void)
+{
+
+  char t;
+
+  t = achar0 | achar1;
+  ASSERT (!(t));
+}
+
+void
+bin_xor1 (void)
+{
+
+  ASSERT (!(achar0 ^ achar1));
+}
+
+
+void
+bool_test3 (void)
+{
+
+  ASSERT (!((achar0 == 0x42) || (achar1 == 42)));
+}
+
+
+void
+bool_or_lit1 (void)
+{
+
+  achar0 |= 0x0f;
+
+  ASSERT (!(achar0 > 0x10));
+
+  ASSERT (!((achar0 | 0x10) > 0xf0));
+
+}
+
+void
+bool_and_lit1 (void)
+{
+
+  achar0 &= 0xf0;
+
+  ASSERT (!(achar0 > 0x10));
+
+  ASSERT (!((achar0 & 0x10) > 0xf0));
+
+  achar0 &= 0xef;
+
+}
+
+void
+testArrays (void)
+{
+
+  bool_or1 ();
+  bool_or2 ();
+  bool_and1 ();
+  bin_or1 ();
+  bin_xor1 ();
+
+  achar0++;
+  bool_and1 ();
+  bool_test1 ();
+  bool_test2 ();
+  bool_test3 ();
+
+
+  achar0--;
+  achar1++;
+  bool_and1 ();
+
+  achar0 = 0;
+  achar1 = 0;
+
+  bool_or_lit1 ();
+  bool_and_lit1 ();
+}

diff --git a/support/regression/tests/scott-b.c b/support/regression/tests/scott-b.c
new file mode 100644 (file)
index 0000000..534253b
--- /dev/null
+++ b/support/regression/tests/scott-b.c
@@ -0,0 +1,45 @@
+/*
+ */
+#include <testfwk.h>
+
+unsigned char uchar0=0;
+unsigned char uchar1=0;
+unsigned char uchar2=0;
+
+void inc(unsigned char k)
+{
+  uchar0 = uchar0 + k;
+}
+
+void f1(void)
+{
+
+  uchar2++;
+}
+
+void nested_call(unsigned char u)
+{
+
+  f1();
+  uchar1 = uchar1 + u;
+  inc(uchar1);
+
+}
+  //  uchar1 = uchar1 + uchar0;
+  //  uchar2 = uchar1 + k;
+
+void 
+testB(void)
+{
+
+  uchar0=1;
+  inc(uchar0);
+  ASSERT(uchar0 == 2);
+
+  uchar0 = 2;
+  uchar1 = 1;
+  uchar2 = 1;
+  nested_call(uchar2);
+
+  ASSERT(uchar0 == 4);
+}

diff --git a/support/regression/tests/scott-bool1.c b/support/regression/tests/scott-bool1.c
new file mode 100644 (file)
index 0000000..24e0565
--- /dev/null
+++ b/support/regression/tests/scott-bool1.c
@@ -0,0 +1,113 @@
+/*
+ */
+#include <testfwk.h>
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void bool_or1(void)
+{
+
+  ASSERT(!( (achar0 >0) || (achar1 >0 )));
+}
+
+void bool_or2(void)
+{
+
+  ASSERT(!( achar0 || achar1));
+}
+
+void bool_test1(void)
+{
+
+  ASSERT(!( (achar0==0) || achar1));
+}
+
+
+void bool_test2(void)
+{
+
+  ASSERT(!( (achar0==0) || aint0));
+}
+
+void bool_and1(void)
+{
+
+  ASSERT(!( achar0 && achar1));
+}
+
+void bin_or1(void)
+{
+
+  char t;
+
+  t = achar0 | achar1;
+  ASSERT(!(t));
+}
+
+void bin_xor1(void)
+{
+
+  ASSERT(!(achar0 ^ achar1));
+}
+
+
+void bool_test3(void)
+{
+
+  ASSERT(!((achar0 == 0x42) || (achar1 == 42)));
+}
+
+
+void bool_or_lit1(void)
+{
+
+  achar0 |= 0x0f;
+
+  ASSERT(!(achar0 > 0x10));
+
+  ASSERT(!( (achar0 | 0x10) > 0xf0));
+
+}
+
+void bool_and_lit1(void)
+{
+
+  achar0 &= 0xf0;
+
+  ASSERT(!(achar0 > 0x10));
+
+  ASSERT(!( (achar0 & 0x10) > 0xf0));
+
+  achar0 &= 0xef;
+
+}
+
+void 
+testBool1(void)
+{
+
+  bool_or1();
+  bool_or2();
+  bool_and1();
+  bin_or1();
+  bin_xor1();
+
+  achar0++;
+  bool_and1();
+  bool_test1();
+  bool_test2();
+  bool_test3();
+
+
+  achar0--; achar1++;
+  bool_and1();
+
+  achar0=0;
+  achar1=0;
+
+  bool_or_lit1();
+  bool_and_lit1();
+}

diff --git a/support/regression/tests/scott-call1.c b/support/regression/tests/scott-call1.c
new file mode 100644 (file)
index 0000000..7ab9db2
--- /dev/null
+++ b/support/regression/tests/scott-call1.c
@@ -0,0 +1,67 @@
+/*
+ */
+#include <testfwk.h>
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+unsigned char call3 (void);
+
+void
+call1 (unsigned char uc0)
+{
+  ASSERT (!(uc0));
+}
+
+void
+call2 (unsigned int ui0)
+{
+  ASSERT (!(ui0));
+
+}
+
+unsigned char
+call3 (void)
+{
+  ASSERT (!(achar0));
+
+  return 0;
+}
+
+unsigned int
+call4 (void)
+{
+  unsigned int i = 0;
+
+  if (aint0)
+    i++;
+
+  return (i);
+
+}
+
+unsigned int
+call5 (unsigned int k)
+{
+
+  ASSERT (!(k));
+
+  return (k);
+
+}
+
+void
+testCall1 (void)
+{
+
+  call1 (achar0);
+  call2 (aint0);
+  achar1 = call3 ();
+  aint1 = call4 ();
+  ASSERT (!(aint1));
+
+  aint1 = call5 (aint0);
+  ASSERT (!(aint1));
+}

diff --git a/support/regression/tests/scott-compare.c b/support/regression/tests/scott-compare.c
new file mode 100644 (file)
index 0000000..b3c5920
--- /dev/null
+++ b/support/regression/tests/scott-compare.c
@@ -0,0 +1,144 @@
+/*
+   compare.c test compare
+
+ */
+#include <testfwk.h>
+
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+char schar0 = 0;
+char schar1 = 0;
+
+/* achar0 should be zero */
+
+void
+compare_char_to_lits1 (void)
+{
+
+  ASSERT (!(achar0));
+
+  ASSERT (!(achar0 == 1));
+
+  ASSERT (!(achar0 == 7));
+
+  ASSERT (!(achar0 != 0));
+}
+
+/* achar0 should be `5' */
+void
+compare_char_to_lits2 (void)
+{
+
+  ASSERT (!(!achar0));
+
+  ASSERT (!(achar0 == 1));
+
+  ASSERT (!(achar0 == 7));
+
+  ASSERT (!(achar0 != 5));
+}
+
+
+/* achar0 should equal achar1 */
+void
+compare_char_to_char1 (void)
+{
+
+  ASSERT (!(achar0 != achar1));
+
+  ASSERT (!(schar0 != schar1));
+}
+
+/* achar0 should be different than achar1 */
+void
+compare_char_to_char2 (void)
+{
+
+  ASSERT (!(achar0 == achar1));
+
+}
+
+/* aint0 should be zero */
+
+void
+compare_int_to_lits1 (void)
+{
+
+  ASSERT (!(aint0));
+
+  ASSERT (!(aint0 == 1));
+
+  ASSERT (!(aint0 == 7));
+
+  ASSERT (!(aint0 != 0));
+}
+
+/* aint0 should be `5' */
+void
+compare_int_to_lits2 (void)
+{
+
+  ASSERT (!(!aint0));
+
+  ASSERT (!(aint0 == 1));
+
+  ASSERT (!(aint0 == 7));
+
+  ASSERT (!(aint0 != 5));
+}
+
+/* aint0 should be `0x1234' */
+void
+compare_int_to_lits3 (void)
+{
+
+  ASSERT (!(!aint0));
+
+  ASSERT (!(aint0 == 1));
+
+  ASSERT (!(aint0 == 7));
+
+  ASSERT (!(aint0 != 0x1234));
+}
+
+/* aint0 should equal aint1 */
+void
+compare_int_to_int1 (void)
+{
+
+  ASSERT (!(aint0 != aint1));
+
+}
+
+/* aint0 should be different than aint1 */
+void
+compare_int_to_int2 (void)
+{
+
+  ASSERT (!(aint0 == aint1));
+
+}
+
+void
+testCompare (void)
+{
+
+  compare_char_to_lits1 ();
+  compare_char_to_char1 ();
+  achar0 = 5;
+  compare_char_to_lits2 ();
+  compare_char_to_char2 ();
+
+
+  compare_int_to_lits1 ();
+  aint0 = 5;
+  compare_int_to_lits2 ();
+  aint0 = 0x1234;
+  compare_int_to_lits3 ();
+  compare_int_to_int2 ();
+  aint0 = 0;
+  compare_int_to_int1 ();
+}

diff --git a/support/regression/tests/scott-compare2.c b/support/regression/tests/scott-compare2.c
new file mode 100644 (file)
index 0000000..2774775
--- /dev/null
+++ b/support/regression/tests/scott-compare2.c
@@ -0,0 +1,148 @@
+/*
+ */
+#include <testfwk.h>
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+char_lt_char (void)
+{
+  ASSERT (!(achar0 < achar1));
+}
+
+void
+char_gt_char (void)
+{
+  ASSERT (!(achar1 > achar0));
+}
+
+void
+char_lte_char (void)
+{
+  ASSERT (!(achar0 <= achar1));
+}
+
+void
+char_gte_char (void)
+{
+  ASSERT (!(achar1 >= achar0));
+}
+
+void
+char_lt_lit (void)
+{
+  ASSERT (!(achar1 < 0x10));
+}
+
+void
+char_gt_lit (void)
+{
+  ASSERT (!(achar1 > 0x10));
+}
+
+void
+char_lte_lit (void)
+{
+  ASSERT (!(achar1 <= 0x0f));
+}
+
+void
+char_gte_lit (void)
+{
+  ASSERT (!(achar1 >= 0x11));
+}
+
+
+/* ints */
+
+void
+int_lt_int (void)
+{
+  ASSERT (!(aint0 < aint1));
+}
+
+void
+int_gt_int (void)
+{
+  ASSERT (!(aint1 > aint0));
+}
+
+void
+int_lte_int (void)
+{
+  ASSERT (!(aint0 <= aint1));
+}
+
+void
+int_gte_int (void)
+{
+  ASSERT (!(aint1 >= aint0));
+}
+
+void
+int_lt_lit (void)
+{
+  ASSERT (!(aint1 < 0x10));
+}
+
+void
+int_gt_lit (void)
+{
+  ASSERT (!(aint1 > 0x10));
+}
+
+void
+int_lte_lit (void)
+{
+  ASSERT (!(aint1 <= 0x0f));
+}
+
+void
+int_gte_lit (void)
+{
+  ASSERT (!(aint1 >= 0x11));
+}
+
+
+
+
+
+
+
+void
+testCompare2 (void)
+{
+
+  char_lt_char ();
+  char_gt_char ();
+
+  achar0++;
+  char_lt_char ();
+  char_gt_char ();
+  char_gte_char ();
+  char_lte_char ();
+
+  achar1 = 0x10;
+  char_lt_lit ();
+  char_gt_lit ();
+  char_lte_lit ();
+  char_gte_lit ();
+
+
+
+  int_lt_int ();
+  int_gt_int ();
+
+  aint0++;
+  int_lt_int ();
+  int_gt_int ();
+  int_gte_int ();
+  int_lte_int ();
+
+  aint1 = 0x10;
+  int_lt_lit ();
+  int_gt_lit ();
+}

diff --git a/support/regression/tests/scott-compare3.c b/support/regression/tests/scott-compare3.c
new file mode 100644 (file)
index 0000000..fdca6b6
--- /dev/null
+++ b/support/regression/tests/scott-compare3.c
@@ -0,0 +1,172 @@
+/**
+   compare3.c
+   regression testing program for comparing literals to variables
+*/
+#include <testfwk.h>
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+// compare to 0
+// assumes
+// achar0 == 0
+// achar1 != 0
+// aint0  == 0
+// aint1  != 0
+
+void c_0(void)
+{
+
+  ASSERT(!(achar0 != 0));
+
+  ASSERT(!(achar0));
+
+  ASSERT(!(achar1 == 0));
+
+  ASSERT(!(!achar1));
+
+  ASSERT(!(aint0 != 0));
+
+  ASSERT(!(aint0));
+
+  ASSERT(!(aint1 == 0));
+
+  ASSERT(!(!aint1));
+
+}
+
+// compare to 1
+// assumes
+// achar0 != 1
+// achar1 == 1
+// aint0  != 1
+// aint1  == 1
+
+void c_1(void)
+{
+
+  ASSERT(!(achar0 == 1));
+
+  ASSERT(!(achar1 != 1));
+
+  ASSERT(!(aint0 == 1));
+
+  ASSERT(!(aint1 != 1));
+
+}
+
+// compare to 2
+// assumes
+// achar0 == 2
+// aint0  == 2
+
+void c_2(void)
+{
+
+  ASSERT(!(achar0 != 2));
+
+  ASSERT(!(aint0 != 2));
+
+}
+
+// compare to 0xff
+// assumes
+// achar0 == 0xff
+// aint0  == 0xff
+
+void c_ff(void)
+{
+
+  ASSERT(!(achar0 != 0xff));
+
+  ASSERT(!(aint0 != 0xff));
+
+  ASSERT(!(aint0 == 0xfe));
+
+  ASSERT(!(aint0 == 0xff00U));
+
+}
+
+
+// compare to 0x00a5
+// assumes
+// achar0  == 0xa5
+// aint0  == 0x00a5
+
+void c_a5(void)
+{
+
+  ASSERT(!(achar0 != 0xa5));
+
+  ASSERT(!(aint0 != 0xa5));
+
+  ASSERT(!(aint0 == 0xa4));
+
+  ASSERT(!(aint0 == 0xa500U));
+
+}
+
+// compare to 0xa500
+// assumes
+// achar0  == 0xa5
+// aint0  == 0xa500
+
+void c_a500(void)
+{
+
+  ASSERT(!(achar0 == 0xa500U));
+
+  ASSERT(!(aint0 != 0xa500U));
+
+  ASSERT(!(aint0 == 0xa400U));
+
+  ASSERT(!(aint0 == 0x00a5));
+
+}
+
+// compare to 0xabcd
+// assumes
+// achar0  == 0xa5
+// aint0  == 0xabcd
+
+void c_abcd(void)
+{
+
+  ASSERT(!(achar0 == 0xabcdU));
+
+  ASSERT(!(aint0 != 0xabcdU));
+
+  ASSERT(!(aint0 == 0xab00U));
+
+  ASSERT(!(aint0 == 0x00cd));
+
+  ASSERT(!(aint0 == 0x1234abcdU));
+
+}
+
+void
+testCompare3 (void)
+{
+
+  aint1 = 1;
+  achar1 = 1;
+  c_0();
+  c_1();
+
+  aint0 = 2;
+  achar0 = 2;
+  c_2();
+
+  aint0 = 0xff;
+  achar0 = 0xff;
+  c_ff();
+
+  aint0 = 0xa5;
+  achar0 = 0xa5;
+  c_a5();
+
+  aint0 = 0xabcd;
+  c_abcd();
+}

diff --git a/support/regression/tests/scott-for.c b/support/regression/tests/scott-for.c
new file mode 100644 (file)
index 0000000..91eff60
--- /dev/null
+++ b/support/regression/tests/scott-for.c
@@ -0,0 +1,39 @@
+/*
+ */
+#include <testfwk.h>
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+unsigned char call3(void);
+
+void for1(void)
+{
+  unsigned char i=0;
+
+  for(i=0; i<10; i++)
+    achar0++;
+
+  ASSERT(!(achar0 != 10));
+
+}
+
+void for2(void)
+{
+  unsigned char i=0;
+
+  for(i=0; i<10; i++)
+    achar0++;
+
+  ASSERT(!(i < 10));
+
+}
+
+void 
+testFor(void)
+{
+  for1();
+  for2();
+}

diff --git a/support/regression/tests/scott-pointer1.c b/support/regression/tests/scott-pointer1.c
new file mode 100644 (file)
index 0000000..dc7d61e
--- /dev/null
+++ b/support/regression/tests/scott-pointer1.c
@@ -0,0 +1,54 @@
+/*
+  Pointer tests
+*/
+#include <testfwk.h>
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char *acharP = 0;
+
+void
+f1 (unsigned char *ucP)
+{
+
+  if (ucP == 0)
+    {
+      ASSERT(0);
+      return;
+    }
+
+  ASSERT (!(*ucP));
+}
+
+void
+f2 (unsigned int *uiP)
+{
+
+  if (uiP == 0)
+    {
+      ASSERT(0);
+      return;
+    }
+
+  ASSERT (!(*uiP));
+
+}
+
+unsigned char *
+f3 (void)
+{
+
+  return &achar0;
+}
+
+void
+testPointer1 (void)
+{
+  f1 (&achar0);
+  f2 (&aint0);
+
+  acharP = f3 ();
+  ASSERT (!((acharP == 0) || (*acharP)));
+}

diff --git a/support/regression/tests/scott-struct1.c b/support/regression/tests/scott-struct1.c
new file mode 100644 (file)
index 0000000..5f49c70
--- /dev/null
+++ b/support/regression/tests/scott-struct1.c
@@ -0,0 +1,78 @@
+/*
+  Addition tests
+*/
+#include <testfwk.h>
+
+/* bit types are not ANSI - so provide a way of disabling bit types
+ * if this file is used to test other compilers besides SDCC */
+#define SUPPORT_BIT_TYPES 0
+
+/* Some compilers that support bit types do not support bit arithmetic 
+ * (like bitx = bity + bitz;) */
+#define SUPPORT_BIT_ARITHMETIC 0
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char *acharP = 0;
+
+struct chars
+  {
+    unsigned char c0, c1;
+    unsigned int  i0, i1;
+  };
+
+
+struct chars struct1;
+
+void
+struct_test (void)
+{
+
+  ASSERT (!(struct1.c0 || struct1.c1));
+
+  struct1.c0++;
+
+  ASSERT (!(struct1.c0 != 1));
+}
+
+void add_chars(void)
+{
+
+  achar0 = struct1.c0 + struct1.c1;
+
+  ASSERT(!(achar0 != 1));
+}
+
+void
+testStruct1 (void)
+{
+
+
+  struct1.c0 = 0;
+  struct1.c1 = 0;
+  struct_test ();
+  //  ptr_to_struct (&struct1);
+
+  struct1.c0 = 0;
+  struct1.c1 = 1;
+  add_chars();
+}

diff --git a/support/regression/tests/scott-sub.c b/support/regression/tests/scott-sub.c
new file mode 100644 (file)
index 0000000..c48d570
--- /dev/null
+++ b/support/regression/tests/scott-sub.c
@@ -0,0 +1,179 @@
+/*
+  Addition tests
+*/
+#include <testfwk.h>
+
+/* bit types are not ANSI - so provide a way of disabling bit types
+ * if this file is used to test other compilers besides SDCC */
+#define SUPPORT_BIT_TYPES 0
+
+/* Some compilers that support bit types do not support bit arithmetic 
+ * (like bitx = bity + bitz;) */
+#define SUPPORT_BIT_ARITHMETIC 0
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+void sub_lit_from_uchar(void)
+{
+
+  achar0 = achar0 - 5;
+
+  ASSERT(!(achar0 != 0xfb));
+
+  achar0 -= 10;
+
+  ASSERT(!(achar0 != 0xf1));
+
+  achar0 = achar0 -1;  // Should be a decrement
+  ASSERT(!(achar0 != 0xf0));
+
+  for(achar1 = 0; achar1 < 100; achar1++)
+    achar0 -= 2;
+
+  ASSERT(!(achar0 != 40));
+
+}
+
+// achar0 = 1
+// achar1 = 100
+
+void sub_uchar2uchar(void)
+{
+
+  achar1 = achar1 - achar0;
+
+  ASSERT(!(achar1 != 99));
+
+  for(achar2 = 0; achar2<7; achar2++)
+    achar1 -= achar0;
+
+  ASSERT(!(achar1 != 92));
+
+}
+
+// assumes
+//  achar0 = 10
+//  achar1 = 32
+//  achar2, achar3 can be anything.
+
+void sub_uchar2uchar2(void)
+{
+
+
+  achar0--;
+  achar0 = achar0 - 1;
+  achar0 = achar0 - 2;
+  achar0 = achar0 - 3;
+  ASSERT(!(achar0 != 3));
+
+
+  achar1 -= achar0;
+  ASSERT(!(achar1 != 29));
+
+  achar2 = achar1 - achar0;
+  ASSERT(!(achar2 != 26));
+
+
+  achar3 = achar2 - achar1 - achar0;
+  ASSERT(!(achar3 != 0xfa));
+
+}
+
+// sub_bits
+// all bit variables are 0 upon entry.
+
+#if SUPPORT_BIT_TYPES
+void sub_bits(void)
+{
+
+  bit1 = bit0;
+
+  bit0 = 1;
+
+  ASSERT(!(bit1 != 0));
+
+  bit1 = bit0-bit1;   // 1 - 0 => 1
+  ASSERT(!(bit1 != 1));
+
+#if SUPPORT_BIT_ARITHMETIC
+  bit2 = bit1-bit0;   // 1 - 1 => 0
+  ASSERT(!(bit2));
+
+  bit7 = bit4-bit5;
+  bit6 = bit4+bit5;
+  bit3 = bit4-bit5-bit6-bit7-bit0; // 0-0-0-0-1 => 1
+  ASSERT(!(!bit3));
+#endif
+}
+
+/* sub_bit2uchar(void) - assumes bit0 = 1, achar0 = 7  */
+
+void sub_bit2uchar(void)
+{
+
+  achar0 -= bit0;
+
+  ASSERT(!(achar0 != 6));
+
+  ASSERT(!(achar0 == bit0));
+
+}
+
+void sub_bit2uint(void)
+{
+
+  ASSERT(!(aint0 != bit11));
+
+  aint0 -= bit0;
+  ASSERT(!(aint0!=0xffff));
+
+}
+#endif
+
+void 
+testSub(void)
+{
+
+  sub_lit_from_uchar();
+
+  achar0=1;
+  achar1=100;
+  sub_uchar2uchar();
+
+
+  achar0 = 10;
+  achar1 = 32;
+  sub_uchar2uchar2();
+
+#if SUPPORT_BIT_TYPES
+  sub_bits();
+
+  achar0 = 7;
+  bit0 = 1;
+  sub_bit2uchar();
+  sub_bit2uint();
+#endif
+}

diff --git a/support/regression/tests/scott-while.c b/support/regression/tests/scott-while.c
new file mode 100644 (file)
index 0000000..6f5e136
--- /dev/null
+++ b/support/regression/tests/scott-while.c
@@ -0,0 +1,30 @@
+/*
+ */
+#include <testfwk.h>
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+while1 (void)
+{
+  unsigned char i = 10;
+
+  do
+    {
+      achar0++;
+    }
+  while (--i);
+
+  ASSERT (!(achar0 != 10));
+
+}
+
+
+void
+testWhile (void)
+{
+  while1 ();
+}