added tests as prepared by oliver

2014-09-24 16:45:10 +02:00
parent d75f9c2051
commit 9b82eaadd0
121 changed files with 25206 additions and 0 deletions
--- a/test/val/add1.c
+++ b/test/val/add1.c
@@ -0,0 +1,181 @@
+/*
+  !!DESCRIPTION!! Addition tests
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void add_lit2uchar(void)
+{
+  achar0 = achar0 + 5;
+
+  if(achar0 != 5)
+    failures++;
+
+  achar0 += 10;
+
+  if(achar0 != 15)
+    failures++;
+
+  achar0 = achar0 +1;  /*Should be an increment */
+  if(achar0 != 16)
+    failures++;
+
+  for(achar1 = 0; achar1 < 100; achar1++)
+    achar0 += 2;
+
+  if(achar0 != 216)
+    failures++;
+}
+
+void add_uchar2uchar(void)
+{
+  achar1 = achar1 + achar0;
+
+  if(achar1 != 16)
+    failures++;
+
+  for(achar2 = 0; achar2<7; achar2++)
+    achar1 += achar0;
+
+  if(achar1 != 128)
+    failures++;
+}
+
+/* assumes
+  achar0 = 0
+  achar1 = 32
+  achar2, achar3 can be anything.
+*/
+void add_uchar2uchar2(void)
+{
+  achar0++;
+  achar0 = achar0 + 1;
+  achar0 = achar0 + 2;
+  achar0 = achar0 + 3;
+  if(achar0 != 7)
+    failures++;
+
+  achar1 += achar0;
+  if(achar1 != 39)
+    failures++;
+
+  achar2 = achar1 + achar0;
+  if(achar2 != 46)
+    failures++;
+
+  achar3 = achar2 + achar1 + achar0;
+  if(achar3 != 92)
+    failures++;
+}
+
+#ifdef SUPPORT_BIT_TYPES
+void add_bits(void)
+{
+  bit1 = bit0;
+
+  bit0 = 1;
+
+  if(bit1 != 0)
+    failures++;
+
+  bit1 = bit1+bit0;
+  if(bit1 != 1)
+    failures++;
+
+#ifdef SUPPORT_BIT_ARITHMETIC
+  bit2 = bit1+bit3;
+  if(!bit2)
+    failures++;
+
+  bit3 = bit4+bit5+bit6+bit7+bit0;
+  if(!bit3)
+    failures++;
+#endif
+}
+
+/* add_bit2uchar(void) - assumes bit0 = 1, achar0 = 7  */
+
+void add_bit2uchar(void)
+{
+  achar0 += bit0;
+
+  if(achar0 != 8)
+    failures++;
+
+  if(achar0 == bit0)
+    failures++;
+}
+
+void add_bit2uint(void)
+{
+  if(aint0 != bit11)
+    failures++;
+
+  aint0 += bit0;
+  if(aint0!=1)
+    failures++;
+}
+#endif
+
+int main(void)
+{
+  add_lit2uchar();
+
+  achar0=16;
+  achar1=0;
+  add_uchar2uchar();
+
+  achar0 = 0;
+  achar1 = 32;
+  add_uchar2uchar2();
+
+#ifdef SUPPORT_BIT_TYPES
+  add_bits();
+
+  add_bit2uchar();
+  add_bit2uint();
+#endif
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/add1.o
+++ b/test/val/add1.o
--- a/test/val/add1.prg
+++ b/test/val/add1.prg
--- a/test/val/add2.c
+++ b/test/val/add2.c
@@ -0,0 +1,328 @@
+/*
+  !!DESCRIPTION!! Addition tests - mostly int's
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+unsigned short aint0 = 0;
+unsigned short aint1 = 0;
+unsigned short aint2 = 0;
+unsigned short aint3 = 0;
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned int aint2 = 0;
+unsigned int aint3 = 0;
+
+#endif
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned int aint2 = 0;
+unsigned int aint3 = 0;
+
+#endif
+
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+void done()
+{
+  dummy++;
+}
+
+void add_lit2uint(void)
+{
+  aint0 = aint0 + 5;
+
+  if(aint0 != 5)
+    failures++;
+
+  aint0 += 10;
+
+  if(aint0 != 15)
+    failures++;
+
+  aint0 = aint0 +1;  /* Should be an increment */
+  if(aint0 != 16)
+    failures++;
+
+  for(aint1 = 0; aint1 < 100; aint1++)
+    aint0 += 2;
+
+  if(aint0 != 216)
+    failures++;
+}
+
+void add_uint2uint (void)
+{
+  aint1 = aint1 + aint0;
+
+  if(aint1 != 16)
+    failures++;
+
+  for(aint2 = 0; aint2<7; aint2++)
+    aint1 += aint0;
+
+  if(aint1 != 128)
+    failures++;
+}
+
+/* assumes
+  aint0 = 0
+  aint1 = 32
+  aint2, aint3 can be anything.
+*/
+void add_uint2uint2(void)
+{
+  aint0++;
+  aint0 = aint0 + 1;
+  aint0 = aint0 + 2;
+  aint0 = aint0 + 3;
+  if(aint0 != 7)
+    failures++;
+
+  aint1 += aint0;
+  if(aint1 != 0x27)
+    failures++;
+
+  aint2 = aint1 + aint0;
+  if(aint2 != 0x2e)
+    failures++;
+
+  aint3 = aint2 + aint1 + aint0;
+  if(aint3 != 0x5c)
+    failures++;
+
+  aint3 += 0xa0;
+  if(aint3 != 0xfc)
+    failures++;
+
+  aint3 += aint0;
+  if(aint3 != 0x103)
+    failures++;
+
+  aint1 += 0xffc0;
+  if(aint1 != 0xffe7)
+    failures++;
+
+  aint3 = aint2 + aint1 + aint0;
+  if(aint3 != 0x1c)
+    failures++;
+}
+
+#ifdef SUPPORT_BIT_TYPES
+void add_bits(void)
+{
+  bit1 = bit0;
+
+  bit0 = 1;
+
+  if(bit1 != 0)
+    failures++;
+
+  bit1 = bit1+bit0;
+  if(bit1 != 1)
+    failures++;
+
+  bit2 = bit1+bit3;
+  if(!bit2)
+    failures++;
+
+  bit3 = bit4+bit5+bit6+bit7+bit0;
+  if(!bit3)
+    failures++;
+}
+
+/* add_bit2uchar(void) - assumes bit0 = 1, aint0 = 7  */
+
+void add_bit2uchar(void)
+{
+  achar0 += bit0;
+
+  if(achar0 != 8)
+    failures++;
+
+  if(achar0 == bit0)
+    failures++;
+}
+
+void add_bit2uint(void)
+{
+  if(aint0 != bit11)
+    failures++;
+
+  aint0 += bit0;
+  if(aint0!=1)
+    failures++;
+}
+#endif
+
+/***********************************/
+
+void addlits(void)
+{
+  aint0 += 0x0001;
+
+  if(aint0 != 1)
+    failures++;
+
+  aint0 += 0x00;
+
+  if(aint0 != 1)
+    failures++;
+
+  aint0 += 0x00fe;
+  if(aint0 != 0x00ff)
+    failures++;
+
+  aint0 += 0x0001;
+
+  if(aint0 != 0x0100)
+    failures++;
+
+  aint0++;
+  if(aint0 != 0x0101)
+    failures++;
+
+  aint0 += 0x00ff;
+  if(aint0 != 0x0200)
+    failures++;
+
+  aint0 += 0x00a0;
+  if(aint0 != 0x02a0)
+    failures++;
+
+  aint0 += 0x0061;
+  if(aint0 != 0x0301)
+    failures++;
+
+  aint0 += 0x0100;
+  if(aint0 != 0x0401)
+    failures++;
+
+  aint0 += 0x0101;
+  if(aint0 != 0x0502)
+    failures++;
+
+  aint0 += 0x00fd;
+  if(aint0 != 0x05ff)
+    failures++;
+
+  aint0 += 0x0101;
+  if(aint0 != 0x0700)
+    failures++;
+
+  aint0 += 0x01ff;
+  if(aint0 != 0x08ff)
+    failures++;
+
+  aint0 += 0x01ff;
+  if(aint0 != 0x0afe)
+    failures++;
+
+  aint0 += 0xff02;
+  if(aint0 != 0x0a00)
+    failures++;
+
+  aint0 += 0xffff;
+  if(aint0 != 0x09ff)
+    failures++;
+
+  aint0 += 0xff01;
+  if(aint0 != 0x0900)
+    failures++;
+
+  aint0 += 0xff00;
+  if(aint0 != 0x0800)
+    failures++;
+
+  aint0 += 0xff01;
+  if(aint0 != 0x0701)
+    failures++;
+
+  aint0 += 0x0300;
+  if(aint0 != 0x0a01)
+    failures++;
+
+  aint0 += 0x03ff;
+  if(aint0 != 0x0e00)
+    failures++;
+
+  aint0 += 0x0301;
+  if(aint0 != 0x1101)
+    failures++;
+
+  aint0 += 0x03fe;
+  if(aint0 != 0x14ff)
+    failures++;
+
+  aint0 += 0x0301;
+  if(aint0 != 0x1800)
+    failures++;
+}
+
+int main(void)
+{
+  add_lit2uint();
+
+  aint0=16;
+  aint1=0;
+  add_uint2uint();
+
+  aint0 = 0;
+  aint1 = 32;
+  aint2 = 0;
+  add_uint2uint2();
+
+#ifdef SUPPORT_BIT_TYPES
+  add_bits();
+
+  achar0 = 7;
+  add_bit2uchar();
+
+  aint0 = 0;
+  bit0 = 1;
+  add_bit2uint();
+#endif
+
+  aint0 = 0;
+  addlits();
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/add3.c
+++ b/test/val/add3.c
@@ -0,0 +1,263 @@
+/*
+  !!DESCRIPTION!! Addition tests - mostly int's
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+unsigned char failures=0;
+
+char char0 = 0;
+char char1 = 0;
+char char2 = 0;
+
+/*
+  this test assumes:
+  sizeof(char) == 1
+  sizeof(int)  == 2
+  sizeof(long) == 4
+*/
+
+#ifdef REFERENCE
+
+/*
+   make sure the reference output uses types with
+   proper size
+*/
+
+#include <stdint.h>
+
+#ifdef SIZEOF_INT_16BIT
+int16_t int0 = 0;
+int16_t int1 = 0;
+#else
+int32_t int0 = 0;
+int32_t int1 = 0;
+#endif
+int32_t long0 = 0;
+int32_t long1 = 0;
+uint32_t ulong0 = 0;
+uint32_t ulong1 = 0;
+
+#else
+
+int int0 = 0;
+int int1 = 0;
+long long0 = 0;
+long long1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+
+#endif
+
+#ifdef SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+void done(char *name)
+{
+  printf("%s done - failures: %d\n", name, failures);
+
+  if(failures)
+    exit(failures);
+}
+
+void add_char2char(void)
+{
+  if(char0 != 4)
+    failures++;
+  if(char1 != 5)
+    failures++;
+
+  char0 = char0 + char1;
+
+  if(char0 != 9)
+    failures++;
+
+  char0 += 127;
+
+#if (!defined(REFCC) && defined(UNSIGNED_CHARS)) || (defined(REFCC) && defined(REFCC_UNSIGNED_CHARS))
+  if(char0 < 0)
+    failures++;
+
+  if(char0 != (127+9))
+    failures++;
+#else
+  if(char0 > 0)
+    failures++;
+
+  if(char0 != -0x78)
+    failures++;
+#endif
+
+  done("add_char2char");
+}
+
+void add_compound_char(void)
+{
+  char0 = char1+5;
+
+  if(char0 != 9)
+    failures++;
+
+  if((char0+char1) != 13)
+    failures++;
+
+  done("add_compound_char");
+}
+
+void add_int2int(void)
+{
+  if(int0 != 4)
+    failures++;
+  if(int1 != 5)
+    failures++;
+
+  int0 += int1;
+  if(int0 != 9)
+    failures++;
+
+  int0 += 0x7fff;
+  if(int0 != -0x7ff8)
+    failures++;
+
+  done("add_int2int");
+}
+
+void add_compound_int(void)
+{
+  int0 = int1+5;
+
+  if(int0 != 9)
+    failures++;
+
+  if((int0+int1) != 13)
+    failures++;
+
+  done("add_compound_int");
+}
+
+void add_lit2long(void)
+{
+  if(long0 != 0)
+    failures++;
+
+  long0++;
+
+  if(long0 != 1)
+    failures++;
+
+  long0 = long0 + 0xff;
+
+  if(long0 != 0x100)
+    failures++;
+
+  long0 = long0 + 0x100;
+  if(long0 != 0x200)
+    failures++;
+
+  long0 = long0 + 0xfe00;
+  if(long0 != 0x10000)
+    failures++;
+
+  long0 = long0 + 0xff0000;
+  if(long0 != 0x1000000)
+    failures++;
+
+  long0 = long0 + 0x7e000000;
+  if(long0 != 0x7f000000)
+    failures++;
+
+  /* wrap around zero */
+  long0 = long0 + 0x2000000;
+  if(long0 != -0x7f000000)
+    failures++;
+
+  long0 = long0 + 0x7f000000;
+  if(long0 != 0)
+    failures++;
+
+  done("add_lit2long");
+}
+
+void add_lit2ulong(void)
+{
+  if(ulong0 != 0)
+    failures++;
+
+  ulong0++;
+
+  if(ulong0 != 1)
+    failures++;
+
+  ulong0 = ulong0 + 0xff;
+
+  if(ulong0 != 0x100)
+    failures++;
+
+  ulong0 = ulong0 + 0x100;
+  if(ulong0 != 0x200)
+    failures++;
+
+  ulong0 = ulong0 + 0xfe00;
+  if(ulong0 != 0x10000)
+    failures++;
+
+  ulong0 = ulong0 + 0xff0000;
+  if(ulong0 != 0x1000000)
+    failures++;
+
+  ulong0 = ulong0 + 0x7e000000;
+  if(ulong0 != 0x7f000000)
+    failures++;
+
+  ulong0 = ulong0 + 0x2000000;
+  if(ulong0 != 0x81000000)
+    failures++;
+
+  /* wrap around zero */
+  ulong0 = ulong0 + 0x7f000000;
+  if(ulong0)
+    failures++;
+
+  done("add_lit2ulong");
+}
+
+int main(void)
+{
+  char0=4;
+  char1 = char0 + 1;
+  add_char2char();
+
+  char1=4;
+  add_compound_char();
+
+  int0 = 4;
+  int1 = int0 + 1;
+  add_int2int();
+
+  int1=4;
+  add_compound_int();
+
+  add_lit2long();
+  add_lit2ulong();
+
+  /* if not exit() */
+  return 0;
+}
--- a/test/val/add3.o
+++ b/test/val/add3.o
--- a/test/val/add3.prg
+++ b/test/val/add3.prg
--- a/test/val/add4.c
+++ b/test/val/add4.c
@@ -0,0 +1,94 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+int int0 = 0;
+int int1 = 0;
+char char0 = 0;
+char char1 = 0;
+long long0 = 0;
+long long1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+#define NULL 0
+char *cP0=NULL;
+char *cP1=NULL;
+int *iP0=NULL;
+int *iP1=NULL;
+
+void
+done ()
+{
+  dummy++;
+}
+
+/* pointer to char arithmetic */
+
+void pc_add(void)
+{
+  if(*cP1)
+    failures++;
+
+  *cP1 += 1;
+  if(*cP1 != 1)
+    failures++;
+
+  if(char0 != 1)
+    failures++;
+
+  char0++;
+
+  if(*cP1 != 2)
+    failures++;
+
+  char1 = char0 + *cP1;
+
+  if(char1 != 4)
+    failures++;
+}
+
+/* pointer to integer arithmetic */
+void pi_add(void)
+{
+  if(*iP0)
+    failures++;
+
+  *iP0 += 1;
+
+  if(*iP0 != 1)
+    failures++;
+
+  if(int0 != 1)
+    failures++;
+
+  int1 = int0 + *iP0;
+  if(int1 != 2)
+    failures++;
+}
+
+int main(void)
+{
+  cP1 = &char0;
+  pc_add();
+
+  iP0 = &int0;
+  pi_add();
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/add4.o
+++ b/test/val/add4.o
--- a/test/val/add4.prg
+++ b/test/val/add4.prg
--- a/test/val/and1.c
+++ b/test/val/and1.c
@@ -0,0 +1,145 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned long ulong0 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+/* uchar0 = 0xff; */
+void and_lit2uchar(void)
+{
+  if(uchar0 != 0xff)
+    failures++;
+
+  uchar0 &= 0x7f;
+
+  if(uchar0 != 0x7f)
+    failures++;
+
+  uchar0 &= 0x3f;
+
+  if(uchar0 != 0x3f)
+    failures++;
+
+  uchar0 &= 0xdf;
+
+  if(uchar0 != 0x1f)
+    failures++;
+}
+
+void and_lit2uint(void)
+{
+  if(uint0 != 0xffff)
+    failures++;
+
+  uint0 &= 0x7fff;
+
+  if(uint0 != 0x7fff)
+    failures++;
+
+  uint0 &= 0x3fff;
+
+  if(uint0 != 0x3fff)
+    failures++;
+
+  uint0 &= 0xdfff;
+
+  if(uint0 != 0x1fff)
+    failures++;
+
+  uint0 &= 0xff7f;
+
+  if(uint0 != 0x1f7f)
+    failures++;
+
+  uint0 &= 0x0f0f;
+
+  if(uint0 != 0x0f0f)
+    failures++;
+
+  uint0 &= 0xfefe;
+
+  if(uint0 != 0x0e0e)
+    failures++;
+
+  uint0 &= 0xf0f0;
+
+  if(uint0 != 0)
+    failures++;
+}
+
+void and_lit2ulong(void)
+{
+  if(ulong0 != 0xffffffff)
+    failures++;
+
+  ulong0 &= 0x7fffffff;
+
+  if(ulong0 != 0x7fffffff)
+    failures++;
+
+  ulong0 &= 0xff00ffff;
+
+  if(ulong0 != 0x7f00ffff)
+    failures++;
+
+  ulong0 &= 0xfeff00ff;
+
+  if(ulong0 != 0x7e0000ff)
+    failures++;
+}
+
+/*-----------*/
+void and_uchar2uchar(void)
+{
+  uchar0 &= uchar1;
+
+  if(uchar0 != 0x0f)
+    failures++;
+
+  uchar1 &= 0xf7;
+
+  uchar0 = uchar1 & 0xfe;
+
+  if(uchar0 != 0x06)
+    failures++;
+}
+
+int main(void)
+{
+  uchar0 = 0xff;
+  and_lit2uchar();
+
+  uint0 = 0xffff;
+  and_lit2uint();
+
+  ulong0 = 0xffffffff;
+  and_lit2ulong();
+
+  uchar0 = 0xff;
+  uchar1 = 0x0f;
+  and_uchar2uchar();
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/and2.c
+++ b/test/val/and2.c
@@ -0,0 +1,118 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned long ulong0 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+/* uchar0 = 0x13; */
+void and_compound1(void)
+{
+  uchar0 = (uchar0 + 1) & 0x0f;
+  if(uchar0 != 4)
+    failures++;
+}
+
+/* uchar1 = 0x42; */
+void and_compound2(void)
+{
+  uchar0 = (uchar1 + 1) & 0x0f;
+  if(uchar0 != 3)
+    failures++;
+
+  if(uchar1 != 0x42)
+    failures++;
+}
+
+/* uchar0 = 0x13; */
+void or_compound1(void)
+{
+  uchar0 = (uchar0 + 0xe) | 0x0f;
+  if(uchar0 != 0x2f)
+    failures++;
+}
+
+/* uchar1 = 0x47; */
+void or_compound2(void)
+{
+  uchar0 = (uchar1 + 0xf) | 0x0f;
+  if(uchar0 != 0x5f)
+    failures++;
+
+  if(uchar1 != 0x47)
+    failures++;
+}
+
+/* uchar0 = 0x13; */
+void xor_compound1(void)
+{
+  uchar0 = (uchar0 + 1) ^ 0x0f;
+  if(uchar0 != 0x1b)
+    failures++;
+}
+
+/* uchar1 = 0x47; */
+void xor_compound2(void)
+{
+  uchar0 = (uchar1 + 0xf) ^ 0x0f;
+  if(uchar0 != 0x59)
+    failures++;
+
+  if(uchar1 != 0x47)
+    failures++;
+}
+
+/* uchar0 = 0x13; */
+void neg_compound1(void)
+{
+  uchar0 = ~(uchar0 + 1);
+  if(uchar0 != 0xeb)
+    failures++;
+}
+
+int main(void)
+{
+  uchar0 = 0x13;
+  and_compound1();
+
+  uchar1 = 0x42;
+  and_compound2();
+
+  uchar0 = 0x13;
+  or_compound1();
+
+  uchar1 = 0x47;
+  or_compound2();
+
+  uchar0 = 0x13;
+  xor_compound1();
+
+  uchar1 = 0x47;
+  xor_compound2();
+
+  uchar0 = 0x13;
+  neg_compound1();
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/atoi-test.c
+++ b/test/val/atoi-test.c
@@ -0,0 +1,42 @@
+/*
+  !!DESCRIPTION!! A small test for atoi. Assumes twos complement
+  !!ORIGIN!!
+  !!LICENCE!!
+  !!AUTHOR!!
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+static unsigned int Failures = 0;
+
+static void CheckAtoi (const char* Str, int Val)
+{
+    int Res = atoi (Str);
+    if (Res != Val) {
+        printf ("atoi error in \"%s\":\n"
+                "  result = %d, should be %d\n", Str, Res, Val);
+        ++Failures;
+    }
+}
+
+int main (void)
+{
+    CheckAtoi ("\t +0A", 0);
+    CheckAtoi ("\t -0.123", 0);
+    CheckAtoi ("  -32  ", -32);
+    CheckAtoi (" +32  ", 32);
+    CheckAtoi ("0377", 377);
+    CheckAtoi (" 0377 ", 377);
+    CheckAtoi (" +0377 ", 377);
+    CheckAtoi (" -0377 ", -377);
+    CheckAtoi ("0x7FFF", 0);
+    CheckAtoi (" +0x7FFF", 0);
+    CheckAtoi (" -0x7FFF", 0);
+    printf ("Failures: %u\n", Failures);
+
+    return Failures;
+}
--- a/test/val/bool1.c
+++ b/test/val/bool1.c
@@ -0,0 +1,130 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void bool_or1(void)
+{
+  if( (achar0 >0) || (achar1 >0 ))
+    failures++;
+}
+
+void bool_or2(void)
+{
+  if( achar0 || achar1)
+    failures++;
+}
+
+void bool_test1(void)
+{
+  if( (achar0==0) || achar1)
+    failures++;
+}
+
+void bool_test2(void)
+{
+  if( (achar0==0) || aint0)
+    failures++;
+}
+
+void bool_and1(void)
+{
+  if( achar0 && achar1)
+    failures++;
+}
+
+void bin_or1(void)
+{
+  char t;
+
+  t = achar0 | achar1;
+  if(t)
+    failures++;
+}
+
+void bin_xor1(void)
+{
+  if(achar0 ^ achar1)
+    failures++;
+}
+
+void bool_test3(void)
+{
+  if((achar0 == 0x42) || (achar1 == 42))
+    failures++;
+}
+
+void bool_or_lit1(void)
+{
+  achar0 |= 0x0f;
+
+  if(achar0 > 0x10)
+    failures++;
+
+  if( (achar0 | 0x10) > 0xf0)
+    failures++;
+}
+
+void bool_and_lit1(void)
+{
+  achar0 &= 0xf0;
+
+  if(achar0 > 0x10)
+    failures++;
+
+  if( (achar0 & 0x10) > 0xf0)
+    failures++;
+
+  achar0 &= 0xef;
+}
+
+int  main(void)
+{
+  bool_or1();
+  bool_or2();
+  bool_and1();
+  bin_or1();
+  bin_xor1();
+
+  achar0++;
+  bool_and1();
+  bool_test1();
+  bool_test2();
+  bool_test3();
+
+  achar0--; achar1++;
+  bool_and1();
+
+  achar0=0;
+  achar1=0;
+
+  bool_or_lit1();
+  bool_and_lit1();
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/bool3.c
+++ b/test/val/bool3.c
@@ -0,0 +1,66 @@
+/*
+  !!DESCRIPTION!! Compound comparisons
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+bit bit1 = 0;
+#endif
+unsigned int ui0 = 0;
+unsigned int ui1 = 0;
+unsigned char uc0 = 0;
+unsigned char uc1 = 0;
+unsigned long uL0 = 0;
+unsigned long uL1 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void compound_compare_uc(void)
+{
+  failures += (uc0 != uc1);
+}
+
+void compound_compare_ui(void)
+{
+  failures += (ui0 != ui1);
+}
+
+void compound_compare_ul(void)
+{
+  failures += (uL0 != uL1);
+}
+
+void compound_compare_uc_lit(void)
+{
+  failures += (uc0 != 0xff);
+  failures += (uc0 != 0xff);
+  failures += (uc0 == 0);
+}
+
+int  main(void)
+{
+  compound_compare_uc();
+  compound_compare_ui();
+  compound_compare_ul();
+
+  uc0 = 0xff;
+  compound_compare_uc_lit();
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/call1.c
+++ b/test/val/call1.c
@@ -0,0 +1,157 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+
+unsigned char call3 (void);
+
+void
+done ()
+{
+  dummy++;
+}
+
+void
+call1 (unsigned char uc0)
+{
+  if (uc0)
+    failures++;
+}
+
+void
+call2 (unsigned int ui0)
+{
+  if (ui0)
+    failures++;
+}
+
+unsigned char
+call3 (void)
+{
+  if (uchar0)
+    failures++;
+
+  return (failures);
+}
+
+unsigned int
+call4 (void)
+{
+  unsigned int i = 0;
+
+  if (uint0)
+    i++;
+
+  return (i);
+}
+
+unsigned int
+call5 (unsigned int k)
+{
+  if (k)
+    failures++;
+
+  return (k);
+}
+
+unsigned char 
+call6a(unsigned char uc)
+{
+  if(uc>uchar1)
+    return 1;
+  else
+    return 0;
+}
+
+unsigned char
+call6(unsigned char uc)
+{
+  return(call6a(uc));
+}
+
+unsigned int 
+call7a(unsigned int ui)
+{
+  if(ui)
+    return 1;
+  else
+    return 0;
+}
+
+unsigned int
+call7(unsigned int ui)
+{
+  return(call7a(ui));
+}
+
+unsigned char
+call8(unsigned char uc1,unsigned char uc2)
+{
+  return uc1+uc2;
+}
+
+void call9(unsigned int ui1, unsigned int ui2)
+{
+  if(ui1 != 0x1234)
+    failures++;
+  if(ui2 != 0x5678)
+    failures++;
+}
+
+int
+main (void)
+{
+  call1 (uchar0);
+  call2 (uint0);
+  uchar1 = call3 ();
+  uint1 = call4 ();
+  if (uint1)
+    failures++;
+
+  uint1 = call5 (uint0);
+  if (uint1)
+    failures++;
+
+  if(call6(uchar0))
+    failures++;
+
+  if(call7(0))
+    failures++;
+
+  if(!call7(1))
+    failures++;
+
+  if(!call7(0xff00))
+    failures++;
+
+  uchar0=4;
+  uchar1=3;
+  uchar0 = call8(uchar0,uchar1);
+
+  if(uchar0 != 7)
+    failures++;
+
+  call9(0x1234,0x5678);
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/cc65091020.c
+++ b/test/val/cc65091020.c
@@ -0,0 +1,26 @@
+/*
+  !!DESCRIPTION!! bit field bug
+  !!ORIGIN!!      testsuite
+  !!LICENCE!!     Public Domain
+  !!AUTHOR!!      Johan Kotlinski
+*/
+
+#include <assert.h>
+
+struct {
+    int foo : 7;
+    int bar : 4;
+} baz = { 0, 2 };
+
+int main() {
+    char bar = baz.bar;
+
+    assert(2 == bar);
+
+    printf("it works :)\n");
+
+    /* if not assert() */
+    return 0;
+}
+
+/* Assert fails. (SVN rev 4381) */
--- a/test/val/compare1.c
+++ b/test/val/compare1.c
@@ -0,0 +1,183 @@
+/*
+  !!DESCRIPTION!! test compare
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/*
+   compare.c
+*/
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+bit bit1 = 0;
+#endif
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+char schar0 = 0;
+char schar1 = 0;
+
+void
+done ()
+{
+  dummy++;
+}
+
+/* achar0 should be zero */
+
+void
+compare_char_to_lits1 (void)
+{
+  if (achar0)
+    failures++;
+
+  if (achar0 == 1)
+    failures++;
+
+  if (achar0 == 7)
+    failures++;
+
+  if (achar0 != 0)
+    failures++;
+}
+
+/* achar0 should be `5' */
+void
+compare_char_to_lits2 (void)
+{
+  if (!achar0)
+    failures++;
+
+  if (achar0 == 1)
+    failures++;
+
+  if (achar0 == 7)
+    failures++;
+
+  if (achar0 != 5)
+    failures++;
+}
+
+/* achar0 should equal achar1 */
+void
+compare_char_to_char1 (void)
+{
+  if (achar0 != achar1)
+    failures++;
+
+  if (schar0 != schar1)
+    failures++;
+}
+
+/* achar0 should be different than achar1 */
+void
+compare_char_to_char2 (void)
+{
+  if (achar0 == achar1)
+    failures++;
+}
+
+/* aint0 should be zero */
+
+void
+compare_int_to_lits1 (void)
+{
+  if (aint0)
+    failures++;
+
+  if (aint0 == 1)
+    failures++;
+
+  if (aint0 == 7)
+    failures++;
+
+  if (aint0 != 0)
+    failures++;
+}
+
+/* aint0 should be `5' */
+void
+compare_int_to_lits2 (void)
+{
+  if (!aint0)
+    failures++;
+
+  if (aint0 == 1)
+    failures++;
+
+  if (aint0 == 7)
+    failures++;
+
+  if (aint0 != 5)
+    failures++;
+}
+
+/* aint0 should be `0x1234' */
+void
+compare_int_to_lits3 (void)
+{
+  if (!aint0)
+    failures++;
+
+  if (aint0 == 1)
+    failures++;
+
+  if (aint0 == 7)
+    failures++;
+
+  if (aint0 != 0x1234)
+    failures++;
+}
+
+/* aint0 should equal aint1 */
+void
+compare_int_to_int1 (void)
+{
+  if (aint0 != aint1)
+    failures++;
+}
+
+/* aint0 should be different than aint1 */
+void
+compare_int_to_int2 (void)
+{
+  if (aint0 == aint1)
+    failures++;
+}
+
+int
+main (void)
+{
+  compare_char_to_lits1 ();
+  compare_char_to_char1 ();
+  achar0 = 5;
+  compare_char_to_lits2 ();
+  compare_char_to_char2 ();
+
+  compare_int_to_lits1 ();
+  aint0 = 5;
+  compare_int_to_lits2 ();
+  aint0 = 0x1234;
+  compare_int_to_lits3 ();
+  compare_int_to_int2 ();
+  aint0 = 0;
+  compare_int_to_int1 ();
+
+  success = failures;
+  done ();
+
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/compare10.c
+++ b/test/val/compare10.c
@@ -0,0 +1,319 @@
+/*
+  !!DESCRIPTION!! Signed comparisons of the form:  (variable>=LIT)
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/* This regression test exercises all of the boundary
+ conditions in literal less than comparisons. There
+ are numerous opportunities to optimize these comparison
+ and each one has an astonishing capability of failing
+ a boundary condition.
+*/
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+unsigned char result = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+int int0 = 0;
+int int1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+/* *** NOTE ***  This particular test takes quite a while to run
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+void
+done ()
+{
+  dummy++;
+}
+
+void c_char_gte_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(char0 >= -0x7f)
+    result |= 1;
+
+  if(char0 >= -1)
+    result |= 2;
+
+  if(char0 >= 0)
+    result |= 4;
+
+  if(char0 >= 1)
+    result |= 8;
+
+  if(char0 >= 0x7e)
+    result |= 0x10;
+  
+  if(char0 >= 0x7f)
+    result |= 0x20;
+
+  if(result != expected_result)
+  {
+/*    LOG_ERROR(1); */
+    printf("c_char_gte_lit1: char %02x - result %02x expected: %02x\n",char0,result,expected_result);
+    failures++;
+  }
+
+/*  printf("char %02x - %02x failures: %d\n",char0,expected_result,failures); */
+}
+
+void char_compare(void)
+{
+  char0 = 0x7f;
+  c_char_gte_lit1(0x3f);
+
+  char0 = 0x7e;
+  c_char_gte_lit1(0x1f);
+
+  char0 = 0x40;
+  c_char_gte_lit1(0x0f);
+
+  char0 = 0x2;
+  c_char_gte_lit1(0x0f);
+
+  char0 = 0x1;
+  c_char_gte_lit1(0x0f);
+
+  char0 = 0;
+  c_char_gte_lit1(0x07);
+
+  char0 = -1;
+  c_char_gte_lit1(0x03);
+
+  char0 = -2;
+  c_char_gte_lit1(0x01);
+
+  char0 = -0x40;
+  c_char_gte_lit1(0x01);
+
+  char0 = -0x7e;
+  c_char_gte_lit1(0x01);
+
+  char0 = -0x7f;
+  c_char_gte_lit1(0x01);
+
+  char0 = 0x80;
+  c_char_gte_lit1(0x00);
+
+  /* Now test entire range */
+
+  for(char0=1; char0 != 0x7e; char0++)
+    c_char_gte_lit1(0x0f);
+
+  for(char0=-0x7f; char0 != -1; char0++)
+    c_char_gte_lit1(0x01);
+}
+
+void c_int_gte_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 >= 0)
+    result |= 1;
+
+  if(int0 >= 1)
+    result |= 2;
+
+  if(int0 >= 0xff)
+    result |= 4;
+
+  if(int0 >= 0x100)
+    result |= 8;
+
+  if(int0 >= 0x0101)
+    result |= 0x10;
+  
+  if(int0 >= 0x01ff)
+    result |= 0x20;
+  
+  if(int0 >= 0x0200)
+    result |= 0x40;
+
+  if(int0 >= 0x0201)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare1(void)
+{
+  int0 = -1;
+  c_int_gte_lit1(0x00);
+
+  int0 = 0;
+  c_int_gte_lit1(0x01);
+
+  int0 = 1;
+  c_int_gte_lit1(0x03);
+
+  int0 = 2;
+  c_int_gte_lit1(0x03);
+
+  int0 = 0xfe;
+  c_int_gte_lit1(0x03);
+
+  int0 = 0xff;
+  c_int_gte_lit1(0x07);
+
+  int0 = 0x100;
+  c_int_gte_lit1(0x0f);
+
+  int0 = 0x101;
+  c_int_gte_lit1(0x1f);
+
+  int0 = 0x102;
+  c_int_gte_lit1(0x1f);
+
+  int0 = 0x1fe;
+  c_int_gte_lit1(0x1f);
+
+  int0 = 0x1ff;
+  c_int_gte_lit1(0x3f);
+
+  int0 = 0x200;
+  c_int_gte_lit1(0x7f);
+
+  int0 = 0x201;
+  c_int_gte_lit1(0xff);
+
+  int0 = 0x7f00;
+  c_int_gte_lit1(0xff);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7fff; int0 != -1; int0++)
+    c_int_gte_lit1(0x00);
+
+  for(int0 = 1; int0 != 0xff; int0++)
+    c_int_gte_lit1(0x03);
+
+  for(int0 = 0x201; int0 != 0x7fff; int0++)
+    c_int_gte_lit1(0xff);
+}
+
+void c_int_gte_lit2(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 >= -0x7fff)
+    result |= 1;
+
+  if(int0 >= -0x7f00)
+    result |= 2;
+
+  if(int0 >= -0x7eff)
+    result |= 4;
+
+  if(int0 >= -0x7e00)
+    result |= 8;
+
+  if(int0 >= -0x0101)
+    result |= 0x10;
+  
+  if(int0 >= -0x0100)
+    result |= 0x20;
+  
+  if(int0 >= -0xff)
+    result |= 0x40;
+
+  if(int0 >= -1)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare2(void)
+{
+  int0 = -0x7fff;
+  c_int_gte_lit2(0x01);
+
+  int0 = -0x7f00;
+  c_int_gte_lit2(0x03);
+
+  int0 = -0x7eff;
+  c_int_gte_lit2(0x07);
+
+  int0 = -0x7e00;
+  c_int_gte_lit2(0x0f);
+
+  int0 = -0x7dff;
+  c_int_gte_lit2(0x0f);
+
+  int0 = -0x4567;
+  c_int_gte_lit2(0x0f);
+
+  int0 = -0x200;
+  c_int_gte_lit2(0x0f);
+
+  int0 = -0x102;
+  c_int_gte_lit2(0x0f);
+
+  int0 = -0x101;
+  c_int_gte_lit2(0x1f);
+
+  int0 = -0x100;
+  c_int_gte_lit2(0x3f);
+
+  int0 = -0xff;
+  c_int_gte_lit2(0x7f);
+
+  int0 = -0x02;
+  c_int_gte_lit2(0x7f);
+
+  int0 = -0x01;
+  c_int_gte_lit2(0xff);
+
+  int0 = 0;
+  c_int_gte_lit2(0xff);
+
+  int0 = 1;
+  c_int_gte_lit2(0xff);
+
+  int0 = 0x7fff;
+  c_int_gte_lit2(0xff);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7fff; int0 != -0x7f00; int0++)
+    c_int_gte_lit2(0x01);
+
+  for(int0 = -0x7e00; int0 != -0x101; int0++)
+    c_int_gte_lit2(0x0f);
+
+  for(int0 = -1; int0 != 0x7fff; int0++)
+    c_int_gte_lit2(0xff);
+}
+
+int
+main (void)
+{
+  char_compare();
+  printf("failures: %d\n",failures);
+  int_compare1();
+  printf("failures: %d\n",failures);
+  int_compare2();
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/compare2.c
+++ b/test/val/compare2.c
@@ -0,0 +1,362 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+done ()
+{
+  dummy++;
+}
+
+void
+char_lt_char (void)
+{
+  if (achar0 < achar1)
+    failures++;
+}
+
+void
+char_gt_char (void)
+{
+  if (achar1 > achar0)
+    failures++;
+}
+
+void
+char_lte_char (void)
+{
+  if (achar0 <= achar1)
+    failures++;
+}
+
+void
+char_gte_char (void)
+{
+  if (achar1 >= achar0)
+    failures++;
+}
+
+void
+char_lt_lit (void)
+{
+  if (achar1 < 0x10)
+    failures++;
+}
+
+void
+char_gt_lit (void)
+{
+  if (achar1 > 0x10)
+    failures++;
+}
+
+void
+char_lte_lit (void)
+{
+  if (achar1 <= 0x0f)
+    failures++;
+}
+
+void
+char_gte_lit (void)
+{
+  if (achar1 >= 0x11)
+    failures++;
+}
+
+/* now repeat test using negative logic */
+void
+char_lt_char_else (void)
+{
+  if (achar0 >= achar1)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_gt_char_else (void)
+{
+  if (achar1 <= achar0)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_lte_char_else (void)
+{
+  if (achar0 > achar1)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_gte_char_else (void)
+{
+  if (achar1 < achar0)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_lt_lit_else (void)
+{
+  if (achar1 >= 0x10)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_gt_lit_else (void)
+{
+  if (achar1 <= 0x10)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_lte_lit_else (void)
+{
+  if (achar1 > 0x0f)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_gte_lit_else (void)
+{
+  if (achar1 < 0x11)
+    dummy++;
+  else
+    failures++;
+}
+
+/* ints */
+
+void
+int_lt_int (void)
+{
+  if (aint0 < aint1)
+    failures++;
+}
+
+void
+int_gt_int (void)
+{
+  if (aint1 > aint0)
+    failures++;
+}
+
+void
+int_lte_int (void)
+{
+  if (aint0 <= aint1)
+    failures++;
+}
+
+void
+int_gte_int (void)
+{
+  if (aint1 >= aint0)
+    failures++;
+}
+
+void
+int_lt_lit (void)
+{
+  if (aint1 < 0x10)
+    failures++;
+}
+
+void
+int_gt_lit (void)
+{
+  if (aint1 > 0x10)
+    failures++;
+}
+
+void
+int_lte_lit (void)
+{
+  if (aint1 <= 0x0f)
+    failures++;
+}
+
+void
+int_gte_lit (void)
+{
+  if (aint1 >= 0x11)
+    failures++;
+}
+
+/* now repeat int comparisons using negative logic */
+
+void
+int_lt_int_else (void)
+{
+  if (aint0 >= aint1)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_gt_int_else (void)
+{
+  if (aint1 <= aint0)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_lte_int_else (void)
+{
+  if (aint0 > aint1)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_gte_int_else (void)
+{
+  if (aint1 < aint0)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_lt_lit_else (void)
+{
+  if (aint1 >= 0x10)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_gt_lit_else (void)
+{
+  if (aint1 <= 0x10)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_lte_lit_else (void)
+{
+  if (aint1 > 0x0f)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_gte_lit_else (void)
+{
+  if (aint1 < 0x11)
+    dummy++;
+  else
+    failures++;
+}
+
+int
+main (void)
+{
+  char_lt_char ();
+  char_gt_char ();
+
+  achar0++;
+  char_lt_char ();
+  char_gt_char ();
+  char_gte_char ();
+  char_lte_char ();
+
+  achar1 = 0x10;
+  char_lt_lit ();
+  char_gt_lit ();
+  char_lte_lit ();
+  char_gte_lit ();
+
+  achar0 = 0;
+  achar1 = 0;
+
+  char_lt_char_else ();
+  char_gt_char_else ();
+
+  achar0++;
+  char_lt_char_else ();
+  char_gt_char_else ();
+  char_gte_char_else ();
+  char_lte_char_else ();
+
+  achar1 = 0x10;
+  char_lt_lit_else ();
+  char_gt_lit_else ();
+  char_lte_lit_else ();
+  char_gte_lit_else ();
+
+  int_lt_int ();
+  int_gt_int ();
+
+  aint0++;
+  int_lt_int ();
+  int_gt_int ();
+  int_gte_int ();
+  int_lte_int ();
+
+  aint1 = 0x10;
+  int_lt_lit ();
+  int_gt_lit ();
+  int_lte_lit ();
+  int_gte_lit ();
+
+  aint0=0;
+  aint1=0;
+  int_lt_int_else ();
+  int_gt_int_else ();
+
+  aint0++;
+  int_lt_int_else ();
+  int_gt_int_else ();
+  int_gte_int_else ();
+  int_lte_int_else ();
+
+  aint1 = 0x10;
+  int_lt_lit_else ();
+  int_gt_lit_else ();
+  int_lte_lit_else ();
+  int_gte_lit_else ();
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/compare3.c
+++ b/test/val/compare3.c
@@ -0,0 +1,246 @@
+/*
+  !!DESCRIPTION!! regression testing program for comparing literals to variables
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/*
+ compare3.c
+*/
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+done ()
+{
+  dummy++;
+}
+
+/* compare to 0
+ assumes
+ achar0 == 0
+ achar1 != 0
+ aint0  == 0
+ aint1  != 0
+*/
+void c_0(void)
+{
+  if(achar0 != 0)
+    failures++;
+
+  if(achar0)
+    failures++;
+
+  if(achar1 == 0)
+    failures++;
+
+  if(!achar1)
+    failures++;
+
+  if(aint0 != 0)
+    failures++;
+
+  if(aint0)
+    failures++;
+
+  if(aint1 == 0)
+    failures++;
+
+  if(!aint1)
+    failures++;
+}
+
+/* compare to 1
+ assumes
+ achar0 != 1
+ achar1 == 1
+ aint0  != 1
+ aint1  == 1
+*/
+void c_1(void)
+{
+  if(achar0 == 1)
+    failures++;
+
+  if(achar1 != 1)
+    failures++;
+
+  if(aint0 == 1)
+    failures++;
+
+  if(aint1 != 1)
+    failures++;
+}
+
+/* compare to 2
+ assumes
+ achar0 == 2
+ aint0  == 2
+*/
+void c_2(void)
+{
+  if(achar0 != 2)
+    failures++;
+
+  if(aint0 != 2)
+    failures++;
+}
+
+/* compare to 0xff
+ assumes
+ achar0 == 0xff
+ aint0  == 0xff
+*/
+void c_ff(void)
+{
+  if(achar0 != 0xff)
+    failures++;
+
+  if(aint0 != 0xff)
+    failures++;
+
+  if(aint0 == 0xfe)
+    failures++;
+
+  if(aint0 == 0xff00)
+    failures++;
+}
+
+/* compare to 0x00a5
+ assumes
+ achar0  == 0xa5
+ aint0  == 0x00a5
+*/
+void c_a5(void)
+{
+  if(achar0 != 0xa5)
+    failures++;
+
+  if(aint0 != 0xa5)
+    failures++;
+
+  if(aint0 == 0xa4)
+    failures++;
+
+  if(aint0 == 0xa500)
+    failures++;
+}
+
+/* compare to 0xa500
+ assumes
+ achar0  == 0xa5
+ aint0  == 0xa500
+*/
+void c_a500(void)
+{
+  if(achar0 == 0xa500)
+    failures++;
+
+  if(aint0 != 0xa500)
+    failures++;
+
+  if(aint0 == 0xa400)
+    failures++;
+
+  if(aint0 == 0x00a5)
+    failures++;
+}
+
+/* compare to 0xabcd
+ assumes
+ achar0  == 0xa5
+ aint0  == 0xabcd
+*/
+void c_abcd(void)
+{
+  if(achar0 == 0xabcd)
+    failures++;
+
+  if(aint0 != 0xabcd)
+    failures++;
+
+  if(aint0 == 0xab00)
+    failures++;
+
+  if(aint0 == 0x00cd)
+    failures++;
+
+  if(aint0 == 0x05cd)
+    failures++;
+
+  if(aint0 == 0xab05)
+    failures++;
+
+  if(aint0 == 0xab01)
+    failures++;
+
+  if(aint0 == 0x01cd)
+    failures++;
+
+  /*
+  if(aint0 == 0x1234abcd)
+        failures++;
+  */
+}
+
+/* assumes achar1 == 0 */
+void c_ifelse1(void)
+{
+  if(achar0)
+    achar0 = achar1;
+  else
+    achar0 = 0;
+
+  if(achar0)
+    failures++;
+}
+
+int
+main (void)
+{
+  aint1 = 1;
+  achar1 = 1;
+  c_0();
+  c_1();
+
+  aint0 = 2;
+  achar0 = 2;
+  c_2();
+
+  aint0 = 0xff;
+  achar0 = 0xff;
+  c_ff();
+
+  aint0 = 0xa5;
+  achar0 = 0xa5;
+  c_a5();
+
+  aint0 = 0xabcd;
+  c_abcd();
+
+  achar0 = 0;
+  achar1 = 0;
+  c_ifelse1();
+
+  achar0 = 1;
+  c_ifelse1();
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/compare4.c
+++ b/test/val/compare4.c
@@ -0,0 +1,349 @@
+/*
+  !!DESCRIPTION!! regression testing program for comparing signed chars and ints
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/*
+ compare4.c
+*/
+
+/*#define  COMPARE_OUT_OF_RANGE 1*/
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+short int0 = 0;
+short int1 = 0;
+
+#else
+int int0 = 0;
+int int1 = 0;
+
+#endif
+
+#else
+int int0 = 0;
+int int1 = 0;
+
+#endif
+
+signed char char0 = 0;
+signed char char1 = 0;
+
+void
+done ()
+{
+  dummy++;
+}
+
+/* compare to 0
+ assumes
+ char0 == 0
+ char1 != 0
+ int0  == 0
+ int1  != 0
+*/
+void c_0(void)
+{
+  if(char0 != 0)
+    failures++;
+
+  if(char0)
+    failures++;
+
+  if(char1 == 0)
+    failures++;
+
+  if(!char1)
+    failures++;
+
+  if(int0 != 0)
+    failures++;
+
+  if(int0)
+    failures++;
+
+  if(int1 == 0)
+    failures++;
+
+  if(!int1)
+    failures++;
+
+  if(char0>0)
+    failures++;
+
+  if(int0>0)
+    failures++;
+
+  if(char0<0)
+    failures++;
+
+  if(int0<0)
+    failures++;
+}
+
+/* compare to 1
+ assumes
+ char0 != 1
+ char1 == 1
+ int0  != 1
+ int1  == 1
+*/
+void c_1(void)
+{
+  if(char0 == 1)
+    failures++;
+
+  if(char1 != 1)
+    failures++;
+
+  if(int0 == 1)
+    failures++;
+
+  if(int1 != 1)
+    failures++;
+
+  if(char0 < 0)
+    failures++;
+
+  if(int0 < 0)
+    failures++;
+}
+
+/* compare to 2
+ assumes
+ achar0 == 2
+ aint0  == 2
+*/
+void c_2(void)
+{
+  if(char0 != 2)
+    failures++;
+
+  if(int0 != 2)
+    failures++;
+}
+
+/* compare to 0xff
+ assumes
+ achar0 == 0xff
+ aint0  == 0xff
+*/
+void c_ff(void)
+{
+  if((unsigned char)char0 != 0xff)
+    failures++;
+
+  if((unsigned short)int0 != 0xff)
+    failures++;
+
+  if((unsigned short)int0 == 0xfe)
+    failures++;
+
+  if((unsigned short)int0 == 0xff00)
+    failures++;
+}
+
+/* compare to 0x00a5
+ assumes
+ char0  == 0xa5
+ int0  == 0x00a5
+*/
+void c_a5(void)
+{
+  if((unsigned char)char0 != 0xa5)
+    failures++;
+
+  if((unsigned short)int0 != 0xa5)
+    failures++;
+
+  if((unsigned short)int0 == 0xa4)
+    failures++;
+
+  if((unsigned short)int0 == 0xa500)
+    failures++;
+}
+
+/* compare to 0xa500
+ assumes
+ char0  == 0xa5
+ int0  == 0xa500
+*/
+void c_a500(void)
+{
+#ifdef COMPARE_OUT_OF_RANGE
+  if(char0 == 0xa500)
+    failures++;
+#endif
+
+  if((unsigned short)int0 != 0xa500)
+    failures++;
+
+  if(int0 != 0x44)
+    int0 = 0x28;
+
+  if((unsigned short)int0 == 0xa400)
+    failures++;
+
+  if(int0 == 0x00a5)
+    failures++;
+}
+
+/* compare to 0xabcd
+ assumes
+ char0  == 0xa5
+ int0  == 0xabcd
+*/
+void c_abcd(void)
+{
+#ifdef COMPARE_OUT_OF_RANGE
+  if(char0 == 0xabcd)
+    failures++;
+#endif
+/*
+  if(int0 != 0xabcd)
+    failures++;
+*/
+  if((unsigned short)int0 == 0xab00)
+    failures++;
+
+  if(int0 == 0x00cd)
+    failures++;
+
+  if(int0 == 0x05cd)
+    failures++;
+
+  if((unsigned short)int0 == 0xab05)
+    failures++;
+
+  if((unsigned short)int0 == 0xab01)
+    failures++;
+
+  if(int0 == 0x01cd)
+    failures++;
+
+  if(int0 > 0)
+    failures++;
+
+#ifdef COMPARE_OUT_OF_RANGE
+  if(int0 == 0x1234abcd)
+    failures++;
+#endif
+}
+
+/* assumes char1 == 0 */
+void c_ifelse1(void)
+{
+  if(char0)
+    char0 = char1;
+  else
+    char0 = 0;
+
+  if(char0)
+    failures++;
+}
+
+/* assumes char0 = -1
+ assumes int0 = -1
+*/
+void c_minus1(void)
+{
+  if(char0 != -1)
+    failures++;
+
+  printf("%d\n",failures);
+
+  if(int0 != -1)
+    failures++;
+
+  printf("%d\n",failures);
+
+  if(char0 != int0)
+    failures++;
+
+  printf("%d\n",failures);
+
+  if(char0>0)
+    failures++;
+
+  printf("%d\n",failures);
+
+  if(int0>0)
+    failures++;
+
+  printf("%d\n",failures);
+}
+
+void c_c0gtc1(void)
+{
+  if(char0 < char1)
+    failures++;
+
+  printf("%d\n",failures);
+}
+
+int main(void)
+{
+  int1 = 1;
+  char1 = 1;
+  c_0();
+  printf("failures: %d\n",failures);
+  c_1();
+  printf("failures: %d\n",failures);
+
+  int0 = 2;
+  char0 = 2;
+  c_2();
+  printf("failures: %d\n",failures);
+
+  int0 = 0xff;
+  char0 = 0xff;
+  c_ff();
+  printf("failures: %d\n",failures);
+
+  int0 = 0xa5;
+  char0 = 0xa5;
+  c_a5();
+  printf("failures: %d\n",failures);
+
+  int0 = 0xabcd;
+  /*c_abcd();*/
+
+  char0 = 0;
+  char1 = 0;
+  c_ifelse1();
+  printf("failures: %d\n",failures);
+
+  char0 = 1;
+  c_ifelse1();
+  printf("failures: %d\n",failures);
+
+  char0 = -1;
+  int0 = -1;
+  c_minus1();
+  printf("failures: %d\n",failures);
+
+  char0 = 5;
+  char1 = 3;
+  c_c0gtc1();
+  printf("failures: %d\n",failures);
+
+  char1 = -3;
+  c_c0gtc1();
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/compare5.c
+++ b/test/val/compare5.c
@@ -0,0 +1,445 @@
+/*
+  !!DESCRIPTION!! regression testing program for comparing longs
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/*
+ compare5.c
+*/
+
+#define  COMPARE_OUT_OF_RANGE 1
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+int int0 = 0;
+int int1 = 0;
+char char0 = 0;
+char char1 = 0;
+long long0 = 0;
+long long1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+
+void
+done ()
+{
+  dummy++;
+}
+
+/* compare to 0
+ assumes
+ long0 == 0
+ ulong0 == 0
+*/
+void c_0(void)
+{
+  if(long0 != 0)
+    failures++;
+
+  if(long0 > 0)
+    failures++;
+
+  if(ulong0 != 0)
+    failures++;
+
+  if(ulong0 > 0)
+    failures++;
+}
+
+/* compare to 1
+ assumes
+ long1 == 1
+ ulong1 == 1
+*/
+void c_1(void)
+{
+  if(long0 == 1)
+    failures++;
+
+  if(long1 != 1)
+    failures++;
+
+  if(ulong0 == 1)
+    failures++;
+
+  if(ulong1 != 1)
+    failures++;
+
+  if(long1 < 0)
+    failures++;
+
+  if(long1 < 1)
+    failures++;
+
+  if(ulong1 < 1)
+    failures++;
+
+  if(long1 > 1)
+    failures++;
+
+  if(ulong1 > 1)
+    failures++;
+}
+
+/* compare to 2
+ assumes
+ long0 == 2
+ ulong0  == 2
+*/
+void c_2(void)
+{
+  if(long0 != 2)
+    failures++;
+
+  if(ulong0 != 2)
+    failures++;
+
+  if(long1 == 2)
+    failures++;
+
+  if(ulong1 == 2)
+    failures++;
+}
+
+/* compare to 0xff
+ assumes
+ achar0 == 0xff
+ aint0  == 0xff
+*/
+void c_ff(void)
+{
+  if(long0 != 0xff)
+    failures++;
+
+  if(ulong0 != 0xff)
+    failures++;
+
+  if(long1 == 0xff)
+    failures++;
+
+  if(ulong1 == 0xff)
+    failures++;
+}
+
+/* compare to 0x200
+ assumes
+ achar0 == 0x200
+ aint0  == 0x200
+*/
+void c_200(void)
+{
+  if(long0 != 0x200)
+    failures++;
+
+  if(ulong0 != 0x200)
+    failures++;
+
+  if(long1 == 0x200)
+    failures++;
+
+  if(ulong1 == 0x200)
+    failures++;
+}
+
+/* compare to 0x20000
+ assumes
+ long0  == 0x20000
+ ulong0 == 0x20000
+ long1  != 0x20000
+ ulong1 != 0x20000
+*/
+void c_20000(void)
+{
+  if(long0 != 0x20000)
+    failures++;
+
+  if(ulong0 != 0x20000)
+    failures++;
+
+  if(long1 == 0x20000)
+    failures++;
+
+  if(ulong1 == 0x20000)
+    failures++;
+
+  if(long0 <= 0x10000)
+    failures++;
+
+  if(long0 < 0x10000)
+    failures++;
+
+/*  if(long0 < 0x12345)
+    failures++;
+*/
+  if(long0 == 0)
+    failures++;
+}
+
+/* compare to 0x00a5
+ assumes
+ char0  == 0xa5
+ int0  == 0x00a5
+*/
+void c_a5(void)
+{
+  if(char0 != 0xa5)
+    failures++;
+
+  if(int0 != 0xa5)
+    failures++;
+
+  if(int0 == 0xa4)
+    failures++;
+
+  if(int0 == 0xa500)
+    failures++;
+}
+
+/* compare to 0xa500
+ assumes
+ char0  == 0xa5
+ int0  == 0xa500
+*/
+void c_a500(void)
+{
+#ifdef COMPARE_OUT_OF_RANGE
+  if(char0 == 0xa500)
+    failures++;
+#endif
+
+  if(int0 != 0xa500)
+    failures++;
+
+  if(int0 == 0xa400)
+    failures++;
+
+  if(int0 == 0x00a5)
+    failures++;
+}
+
+/* compare to 0xabcd
+ assumes
+ char0  == 0xa5
+ int0  == 0xabcd
+*/
+void c_abcd(void)
+{
+#ifdef COMPARE_OUT_OF_RANGE
+  if(char0 == 0xabcd)
+    failures++;
+#endif
+
+  if(int0 != 0xabcd)
+    failures++;
+
+  if(int0 == 0xab00)
+    failures++;
+
+  if(int0 == 0x00cd)
+    failures++;
+
+  if(int0 == 0x05cd)
+    failures++;
+
+  if(int0 == 0xab05)
+    failures++;
+
+  if(int0 == 0xab01)
+    failures++;
+
+  if(int0 == 0x01cd)
+    failures++;
+
+  if(int0 > 0)
+    failures++;
+
+#ifdef COMPARE_OUT_OF_RANGE
+  if(int0 == 0x1234abcd)
+    failures++;
+#endif
+}
+
+/* assumes char1 == 0 */
+void c_ifelse1(void)
+{
+  if(char0)
+    char0 = char1;
+  else
+    char0 = 0;
+
+  if(char0)
+    failures++;
+}
+
+/*
+   assumes long0 = -1
+   assumes long1 = 1
+*/
+void c_minus1(void)
+{
+  printf("long0:%ld long1:%ld\n",long0,long1);
+  
+  printf("(long0 != -1)\n");
+  if(long0 != -1)
+  {
+	LOG_ERROR(1);
+	failures++;
+  }
+  printf("(long0 > 0)\n");
+  if(long0 > 0)
+  {
+	LOG_ERROR(1);
+	failures++;
+  }
+  printf("(long1 < 0)\n");
+  if(long1 < 0)
+  {
+	LOG_ERROR(1);
+	failures++;
+  }
+/*
+  if(long1 < 2)
+    failures++;
+*/
+}
+
+/* assumes
+ long0 = long1 = ulong0 = ulong1 == 0
+*/
+void c_long2long_eq(void)
+{
+  if(long0 != long1)
+    failures++;
+
+  if(ulong0 != ulong1)
+    failures++;
+
+  if(long0 != ulong1)
+    failures++;
+
+  if(long0 > long1)
+    failures++;
+
+  if(long0 < long1)
+    failures++;
+
+  if(long0 > ulong0)
+    failures++;
+
+  if(long0 < ulong0)
+    failures++;
+}
+
+/* assumes
+ long0 = ulong0 == 0
+ long1 = ulong1 == 1
+*/
+void c_long2long_neq(void)
+{
+  if(long0 == long1)
+    failures++;
+
+  if(ulong0 == ulong1)
+    failures++;
+
+  if(long1 != ulong1)
+    failures++;
+
+  if(long1 < long0)
+    failures++;
+
+  if(long1 <= long0)
+    failures++;
+
+  if(ulong1 < ulong0)
+    failures++;
+
+  if(ulong1 <= ulong0)
+    failures++;
+}
+
+/*  long0=-100;
+  long1=-1000;
+*/
+void
+c_long2neglit(void)
+{
+  if(long0>0)
+    failures++;
+  if(long1>0)
+    failures++;
+
+  if(long1 > long0)
+    failures++;
+
+  if(long1 > 100)
+    failures++;
+
+  if(long0 > -50)
+    failures++;
+
+  if(long1 < -5000)
+    failures++;
+}
+
+int
+main (void)
+{
+  c_0();
+  printf("c_0: %d\n",failures);
+
+  c_long2long_eq();
+  printf("c_long2long_eq: %d\n",failures);
+
+  long1 = 1;
+  ulong1 = 1;
+  c_1();
+  printf("c_1: %d\n",failures);
+  c_long2long_neq();
+  printf("c_long2long_neq: %d\n",failures);
+
+  long0 = 2;
+  ulong0 = 2;
+  c_2();
+  printf("c_2: %d\n",failures);
+
+  long0 = 0xff;
+  ulong0 = 0xff;
+  c_ff();
+  printf("c_ff: %d\n",failures);
+
+  long0 = 0x200;
+  ulong0 = 0x200;
+  c_200();
+  printf("c_200: %d\n",failures);
+
+  long0 = 0x20000;
+  ulong0 = 0x20000;
+  c_20000();
+  printf("c_20000: %d\n",failures);
+
+  long0 = -1;
+  c_minus1();
+  printf("c_minus1: %d\n",failures);
+
+  long0=-100;
+  long1=-1000;
+  c_long2neglit();
+  printf("c_long2neglit: %d\n",failures);
+
+  success = failures;
+  done ();
+  
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/compare6.c
+++ b/test/val/compare6.c
@@ -0,0 +1,176 @@
+/*
+  !!DESCRIPTION!! Compound comparisons
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+int int0 = 0;
+int int1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+char char0 = 0;
+char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+void
+done ()
+{
+  dummy++;
+}
+
+void c_char(void)
+{
+  if(char0 || char1)
+    failures++;
+
+  if(char0 && char1)
+    failures++;
+
+  if(char0 > char1)
+    failures++;
+
+  if((char0+1)  < char1)
+    failures++;
+
+  if((char0+5) >= (char1+9))
+    failures++;
+
+  char0++;
+
+  if(char0 && char1)
+    failures++;
+
+  if(char0 != (char1+1) )
+    failures++;
+
+  if(!char0)
+    failures++;
+
+  if(char1 || !char0)
+    failures++;
+
+  if((char0 >5 ) && (char0 < 10)) 
+    failures++;
+
+  char0 +=5; /* char0 = 6 now */
+
+  if(!((char0 >5 ) && (char0 < 10)))
+    failures++;
+}
+
+void c_int(void)
+{
+  if(int0 || int1)
+    failures++;
+
+  if(int0 && int1)
+    failures++;
+
+  if(int0 > int1)
+    failures++;
+
+  if((int0+1)  < int1)
+    failures++;
+
+  if((int0+5) >= (int1+9))
+    failures++;
+
+  int0++;
+
+  if(int0 && int1)
+    failures++;
+
+  if(int0 != (int1+1) )
+    failures++;
+
+  if(!int0)
+    failures++;
+
+  if(int1 || !int0)
+    failures++;
+
+  if((int0 >5 ) && (int0 < 10)) 
+    failures++;
+
+  int0 +=5; /* int0 = 6 now */
+
+  if(!((int0 >5 ) && (int0 < 10)))
+    failures++;
+}
+
+void c_long(void)
+{
+  if(long0 || long1)
+    failures++;
+
+  if(long0 && long1)
+    failures++;
+
+  if(long0 > long1)
+    failures++;
+
+  if((long0+1)  < long1)
+    failures++;
+
+  if((long0+5) >= (long1+9))
+    failures++;
+
+  long0++;
+
+  if(long0 && long1)
+    failures++;
+
+  if(long0 != (long1+1) )
+    failures++;
+
+  if(!long0)
+    failures++;
+
+  if(long1 || !long0)
+    failures++;
+
+  if((long0 >5 ) && (long0 < 10)) 
+    failures++;
+
+  long0 +=5; /* long0 = 6 now */
+
+  if(!((long0 >5 ) && (long0 < 10)))
+    failures++;
+}
+
+void c_uminus(void)
+{
+  int1 = -int0;
+  if(int1 < 0)
+    failures++;
+}
+
+int
+main (void)
+{
+  c_char();
+  c_int();
+  c_long();
+
+  int0 = -1;
+  c_uminus();
+  if(int1 != 1)
+    failures++;
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/compare7.c
+++ b/test/val/compare7.c
@@ -0,0 +1,307 @@
+/*
+  !!DESCRIPTION!! Signed comparisons of the form:  (variable<LIT)
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/* This regression test exercises all of the boundary
+ conditions in literal less than comparisons. There
+ are numerous opportunities to optimize these comparison
+ and each one has an astonishing capability of failing
+ a boundary condition.
+*/
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+unsigned char result = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+int int0 = 0;
+int int1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+/* *** NOTE ***  This particular test takes quite a while to run
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+void
+done ()
+{
+  dummy++;
+}
+
+void c_char_lt_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(char0 < -0x7f)
+    result |= 1;
+
+  if(char0 < -1)
+    result |= 2;
+
+  if(char0 < 0)
+    result |= 4;
+
+  if(char0 < 1)
+    result |= 8;
+
+  if(char0 < 0x7f)
+    result |= 0x10;
+
+  if(result != expected_result)
+    failures++;
+}
+
+void char_compare(void)
+{
+  char0 = 0x7f;
+  c_char_lt_lit1(0);
+
+/*  return; */
+
+  char0 = 0x7e;
+  c_char_lt_lit1(0x10);
+
+  char0 = 0x40;
+  c_char_lt_lit1(0x10);
+
+  char0 = 0x2;
+  c_char_lt_lit1(0x10);
+
+  char0 = 0x1;
+  c_char_lt_lit1(0x10);
+
+  char0 = 0;
+  c_char_lt_lit1(0x18);
+
+  char0 = -1;
+  c_char_lt_lit1(0x1c);
+
+  char0 = -2;
+  c_char_lt_lit1(0x1e);
+
+  char0 = -0x40;
+  c_char_lt_lit1(0x1e);
+
+  char0 = -0x7e;
+  c_char_lt_lit1(0x1e);
+
+  char0 = -0x7f;
+  c_char_lt_lit1(0x1e);
+
+  char0 = 0x80;
+  c_char_lt_lit1(0x1f);
+
+  /* Now test entire range */
+
+  for(char0=1; char0 != 0x7f; char0++)
+    c_char_lt_lit1(0x10);
+
+  for(char0=-0x7f; char0 != -1; char0++)
+    c_char_lt_lit1(0x1e);
+}
+
+void c_int_lt_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 < 0)
+    result |= 1;
+
+  if(int0 < 1)
+    result |= 2;
+
+  if(int0 < 0xff)
+    result |= 4;
+
+  if(int0 < 0x100)
+    result |= 8;
+
+  if(int0 < 0x0101)
+    result |= 0x10;
+  
+  if(int0 < 0x01ff)
+    result |= 0x20;
+  
+  if(int0 < 0x0200)
+    result |= 0x40;
+
+  if(int0 < 0x0201)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare1(void)
+{
+  int0 = -1;
+  c_int_lt_lit1(0xff);
+
+  int0 = 0;
+  c_int_lt_lit1(0xfe);
+
+  int0 = 1;
+  c_int_lt_lit1(0xfc);
+
+  int0 = 2;
+  c_int_lt_lit1(0xfc);
+
+  int0 = 0xfe;
+  c_int_lt_lit1(0xfc);
+
+  int0 = 0xff;
+  c_int_lt_lit1(0xf8);
+
+  int0 = 0x100;
+  c_int_lt_lit1(0xf0);
+
+  int0 = 0x101;
+  c_int_lt_lit1(0xe0);
+
+  int0 = 0x1fe;
+  c_int_lt_lit1(0xe0);
+
+  int0 = 0x1ff;
+  c_int_lt_lit1(0xc0);
+
+  int0 = 0x200;
+  c_int_lt_lit1(0x80);
+
+  int0 = 0x201;
+  c_int_lt_lit1(0x0);
+
+  int0 = 0x7f00;
+  c_int_lt_lit1(0x0);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7fff; int0 != -1; int0++)
+    c_int_lt_lit1(0xff);
+
+  for(int0 = 1; int0 != 0xff; int0++)
+    c_int_lt_lit1(0xfc);
+
+  for(int0 = 0x201; int0 != 0x7fff; int0++)
+    c_int_lt_lit1(0);
+}
+
+void c_int_lt_lit2(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 < -0x7fff)
+    result |= 1;
+
+  if(int0 < -0x7f00)
+    result |= 2;
+
+  if(int0 < -0x7eff)
+    result |= 4;
+
+  if(int0 < -0x7e00)
+    result |= 8;
+
+  if(int0 < -0x0101)
+    result |= 0x10;
+  
+  if(int0 < -0x0100)
+    result |= 0x20;
+  
+  if(int0 < -0xff)
+    result |= 0x40;
+
+  if(int0 < -1)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare2(void)
+{
+  int0 = -0x7fff;
+  c_int_lt_lit2(0xfe);
+
+  int0 = -0x7f00;
+  c_int_lt_lit2(0xfc);
+
+  int0 = -0x7eff;
+  c_int_lt_lit2(0xf8);
+
+  int0 = -0x7e00;
+  c_int_lt_lit2(0xf0);
+
+  int0 = -0x4567;
+  c_int_lt_lit2(0xf0);
+
+  int0 = -0x200;
+  c_int_lt_lit2(0xf0);
+
+  int0 = -0x102;
+  c_int_lt_lit2(0xf0);
+
+  int0 = -0x101;
+  c_int_lt_lit2(0xe0);
+
+  int0 = -0x100;
+  c_int_lt_lit2(0xc0);
+
+  int0 = -0xff;
+  c_int_lt_lit2(0x80);
+
+  int0 = -0x02;
+  c_int_lt_lit2(0x80);
+
+  int0 = -0x01;
+  c_int_lt_lit2(0x00);
+
+  int0 = 0;
+  c_int_lt_lit2(0x00);
+
+  int0 = 1;
+  c_int_lt_lit2(0x00);
+
+  int0 = 0x7fff;
+  c_int_lt_lit2(0x00);
+
+  /* now check contiguous ranges */
+  int0 = -0x7f01;
+  c_int_lt_lit2(0xfe);
+
+  for(int0 = -0x7ffe; int0 != -0x7f01; int0++)
+    c_int_lt_lit2(0xfe);
+
+  for(int0 = -0x7e00; int0 != -0x101; int0++)
+    c_int_lt_lit2(0xf0);
+
+  for(int0 = -1; int0 != 0x7fff; int0++)
+    c_int_lt_lit2(0);
+}
+
+int
+main (void)
+{
+  char_compare();
+  printf("failures: %d\n",failures);
+
+  int_compare1();
+  printf("failures: %d\n",failures);
+  int_compare2();
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/compare8.c
+++ b/test/val/compare8.c
@@ -0,0 +1,311 @@
+/*
+  !!DESCRIPTION!! Signed comparisons of the form:  (variable>LIT)
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/* This regression test exercises all of the boundary
+ conditions in literal less than comparisons. There
+ are numerous opportunities to optimize these comparison
+ and each one has an astonishing capability of failing
+ a boundary condition.
+*/
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+unsigned char result = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+int int0 = 0;
+int int1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+/* *** NOTE ***  This particular test takes quite a while to run
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+void
+done ()
+{
+  dummy++;
+}
+
+void c_char_gt_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(char0 > -0x7f)
+    result |= 1;
+
+  if(char0 > -1)
+    result |= 2;
+
+  if(char0 > 0)
+    result |= 4;
+
+  if(char0 > 1)
+    result |= 8;
+
+  if(char0 > 0x7e)
+    result |= 0x10;
+  
+  if(char0 > 0x7f)
+    result |= 0x20;
+  
+  if(result != expected_result)
+    failures++;
+}
+
+void char_compare(void)
+{
+  char0 = 0x7f;
+  c_char_gt_lit1(0x1f);
+
+  char0 = 0x7e;
+  c_char_gt_lit1(0x0f);
+
+  char0 = 0x40;
+  c_char_gt_lit1(0x0f);
+
+  char0 = 0x2;
+  c_char_gt_lit1(0x0f);
+
+  char0 = 0x1;
+  c_char_gt_lit1(0x07);
+
+  char0 = 0;
+  c_char_gt_lit1(0x03);
+
+  char0 = -1;
+  c_char_gt_lit1(0x01);
+
+  char0 = -2;
+  c_char_gt_lit1(0x01);
+
+  char0 = -0x40;
+  c_char_gt_lit1(0x01);
+
+  char0 = -0x7e;
+  c_char_gt_lit1(0x01);
+
+  char0 = -0x7f;
+  c_char_gt_lit1(0x00);
+
+  char0 = 0x80;
+  c_char_gt_lit1(0x00);
+
+  /* Now test entire range */
+
+  for(char0=2; char0 != 0x7f; char0++)
+    c_char_gt_lit1(0x0f);
+
+  for(char0=-0x7e; char0 != -1; char0++)
+    c_char_gt_lit1(0x01);
+}
+
+void c_int_gt_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 > 0)
+    result |= 1;
+
+  if(int0 > 1)
+    result |= 2;
+
+  if(int0 > 0xff)
+    result |= 4;
+
+  if(int0 > 0x100)
+    result |= 8;
+
+  if(int0 > 0x0101)
+    result |= 0x10;
+  
+  if(int0 > 0x01ff)
+    result |= 0x20;
+  
+  if(int0 > 0x0200)
+    result |= 0x40;
+
+  if(int0 > 0x0201)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare1(void)
+{
+  int0 = -1;
+  c_int_gt_lit1(0x00);
+
+  int0 = 0;
+  c_int_gt_lit1(0x00);
+
+  int0 = 1;
+  c_int_gt_lit1(0x01);
+
+  int0 = 2;
+  c_int_gt_lit1(0x03);
+
+  int0 = 0xfe;
+  c_int_gt_lit1(0x03);
+
+  int0 = 0xff;
+  c_int_gt_lit1(0x03);
+
+  int0 = 0x100;
+  c_int_gt_lit1(0x07);
+
+  int0 = 0x101;
+  c_int_gt_lit1(0x0f);
+
+  int0 = 0x102;
+  c_int_gt_lit1(0x1f);
+
+  int0 = 0x1fe;
+  c_int_gt_lit1(0x1f);
+
+  int0 = 0x1ff;
+  c_int_gt_lit1(0x1f);
+
+  int0 = 0x200;
+  c_int_gt_lit1(0x3f);
+
+  int0 = 0x201;
+  c_int_gt_lit1(0x7f);
+
+  int0 = 0x7f00;
+  c_int_gt_lit1(0xff);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7fff; int0 != -1; int0++)
+    c_int_gt_lit1(0x00);
+
+  for(int0 = 2; int0 != 0xff; int0++)
+    c_int_gt_lit1(0x03);
+
+  for(int0 = 0x202; int0 != 0x7fff; int0++)
+    c_int_gt_lit1(0xff);
+}
+
+void c_int_gt_lit2(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 > -0x7fff)
+    result |= 1;
+
+  if(int0 > -0x7f00)
+    result |= 2;
+
+  if(int0 > -0x7eff)
+    result |= 4;
+
+  if(int0 > -0x7e00)
+    result |= 8;
+
+  if(int0 > -0x0101)
+    result |= 0x10;
+  
+  if(int0 > -0x0100)
+    result |= 0x20;
+  
+  if(int0 > -0xff)
+    result |= 0x40;
+
+  if(int0 > -1)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare2(void)
+{
+  int0 = -0x7fff;
+  c_int_gt_lit2(0x00);
+
+  int0 = -0x7f00;
+  c_int_gt_lit2(0x01);
+
+  int0 = -0x7eff;
+  c_int_gt_lit2(0x03);
+
+  int0 = -0x7e00;
+  c_int_gt_lit2(0x07);
+
+  int0 = -0x7dff;
+  c_int_gt_lit2(0x0f);
+
+  int0 = -0x4567;
+  c_int_gt_lit2(0x0f);
+
+  int0 = -0x200;
+  c_int_gt_lit2(0x0f);
+
+  int0 = -0x102;
+  c_int_gt_lit2(0x0f);
+
+  int0 = -0x101;
+  c_int_gt_lit2(0x0f);
+
+  int0 = -0x100;
+  c_int_gt_lit2(0x1f);
+
+  int0 = -0xff;
+  c_int_gt_lit2(0x3f);
+
+  int0 = -0x02;
+  c_int_gt_lit2(0x7f);
+
+  int0 = -0x01;
+  c_int_gt_lit2(0x7f);
+
+  int0 = 0;
+  c_int_gt_lit2(0xff);
+
+  int0 = 1;
+  c_int_gt_lit2(0xff);
+
+  int0 = 0x7fff;
+  c_int_gt_lit2(0xff);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7ffe; int0 != -0x7f01; int0++)
+    c_int_gt_lit2(0x01);
+
+  for(int0 = -0x7dff; int0 != -0x101; int0++)
+    c_int_gt_lit2(0x0f);
+
+  for(int0 = 0; int0 != 0x7fff; int0++)
+    c_int_gt_lit2(0xff);
+}
+
+int
+main (void)
+{
+  char_compare();
+  int_compare1();
+  int_compare2();
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/compare9.c
+++ b/test/val/compare9.c
@@ -0,0 +1,297 @@
+/*
+  !!DESCRIPTION!! Signed comparisons of the form:  (variable<=LIT)
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/*
+ This regression test exercises all of the boundary
+ conditions in literal less than or equal comparisons. There
+ are numerous opportunities to optimize these comparison
+ and each one has an astonishing capability of failing
+ a boundary condition.
+*/
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+unsigned char result = 0;
+
+int int0 = 0;
+int int1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+
+/* *** NOTE ***  This particular test takes quite a while to run
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+void
+done ()
+{
+  dummy++;
+}
+
+void c_char_lte_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(char0 <= -0x7f)
+    result |= 1;
+
+  if(char0 <= -1)
+    result |= 2;
+
+  if(char0 <= 0)
+    result |= 4;
+
+  if(char0 <= 1)
+    result |= 8;
+
+  if(char0 <= 0x7f)
+    result |= 0x10;
+  
+  if(result != expected_result)
+    failures++;
+}
+
+void char_compare(void)
+{
+  char0 = 0x7f;
+  c_char_lte_lit1(0x10);
+
+  char0 = 0x7e;
+  c_char_lte_lit1(0x10);
+
+  char0 = 0x40;
+  c_char_lte_lit1(0x10);
+
+  char0 = 0x2;
+  c_char_lte_lit1(0x10);
+
+  char0 = 0x1;
+  c_char_lte_lit1(0x18);
+
+  char0 = 0;
+  c_char_lte_lit1(0x1c);
+
+  char0 = -1;
+  c_char_lte_lit1(0x1e);
+
+  char0 = -2;
+  c_char_lte_lit1(0x1e);
+
+  char0 = -0x40;
+  c_char_lte_lit1(0x1e);
+
+  char0 = -0x7e;
+  c_char_lte_lit1(0x1e);
+
+  char0 = -0x7f;
+  c_char_lte_lit1(0x1f);
+
+  char0 = 0x80;
+  /*  c_char_lte_lit1(0x1f); */
+
+  /* Now test entire range */
+
+  for(char0=2; char0 != 0x7f; char0++)
+    c_char_lte_lit1(0x10);
+
+  for(char0=-0x7e; char0 != 0; char0++)
+    c_char_lte_lit1(0x1e);
+}
+
+void c_int_lte_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 <= 0)
+    result |= 1;
+
+  if(int0 <= 1)
+    result |= 2;
+
+  if(int0 <= 0xff)
+    result |= 4;
+
+  if(int0 <= 0x100)
+    result |= 8;
+
+  if(int0 <= 0x0101)
+    result |= 0x10;
+  
+  if(int0 <= 0x01ff)
+    result |= 0x20;
+  
+  if(int0 <= 0x0200)
+    result |= 0x40;
+
+  if(int0 <= 0x0201)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare1(void)
+{
+  int0 = -1;
+  c_int_lte_lit1(0xff);
+
+  int0 = 0;
+  c_int_lte_lit1(0xff);
+
+  int0 = 1;
+  c_int_lte_lit1(0xfe);
+
+  int0 = 2;
+  c_int_lte_lit1(0xfc);
+
+  int0 = 0xfe;
+  c_int_lte_lit1(0xfc);
+
+  int0 = 0xff;
+  c_int_lte_lit1(0xfc);
+
+  int0 = 0x100;
+  c_int_lte_lit1(0xf8);
+
+  int0 = 0x101;
+  c_int_lte_lit1(0xf0);
+
+  int0 = 0x1fe;
+  c_int_lte_lit1(0xe0);
+
+  int0 = 0x1ff;
+  c_int_lte_lit1(0xe0);
+
+  int0 = 0x200;
+  c_int_lte_lit1(0xc0);
+
+  int0 = 0x201;
+  c_int_lte_lit1(0x80);
+
+  int0 = 0x7f00;
+  c_int_lte_lit1(0x0);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7fff; int0 != 1; int0++)
+    c_int_lte_lit1(0xff);
+
+  for(int0 = 2; int0 != 0xff; int0++)
+    c_int_lte_lit1(0xfc);
+
+  for(int0 = 0x202; int0 != 0x7fff; int0++)
+    c_int_lte_lit1(0);
+}
+
+void c_int_lte_lit2(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 <= -0x7fff)
+    result |= 1;
+
+  if(int0 <= -0x7f00)
+    result |= 2;
+
+  if(int0 <= -0x7eff)
+    result |= 4;
+
+  if(int0 <= -0x7e00)
+    result |= 8;
+
+  if(int0 <= -0x0101)
+    result |= 0x10;
+  
+  if(int0 <= -0x0100)
+    result |= 0x20;
+  
+  if(int0 <= -0xff)
+    result |= 0x40;
+
+  if(int0 <= -1)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare2(void)
+{
+  int0 = -0x7fff;
+  c_int_lte_lit2(0xff);
+
+  int0 = -0x7f00;
+  c_int_lte_lit2(0xfe);
+
+  int0 = -0x7eff;
+  c_int_lte_lit2(0xfc);
+
+  int0 = -0x7e00;
+  c_int_lte_lit2(0xf8);
+
+  int0 = -0x4567;
+  c_int_lte_lit2(0xf0);
+
+  int0 = -0x200;
+  c_int_lte_lit2(0xf0);
+
+  int0 = -0x102;
+  c_int_lte_lit2(0xf0);
+
+  int0 = -0x101;
+  c_int_lte_lit2(0xf0);
+
+  int0 = -0x100;
+  c_int_lte_lit2(0xe0);
+
+  int0 = -0xff;
+  c_int_lte_lit2(0xc0);
+
+  int0 = -0x02;
+  c_int_lte_lit2(0x80);
+
+  int0 = -0x01;
+  c_int_lte_lit2(0x80);
+
+  int0 = 0;
+  c_int_lte_lit2(0x00);
+
+  int0 = 1;
+  c_int_lte_lit2(0x00);
+
+  int0 = 0x7fff;
+  c_int_lte_lit2(0x00);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7ffe; int0 != -0x7f00; int0++)
+    c_int_lte_lit2(0xfe);
+
+  for(int0 = -0x7dff; int0 != -0x101; int0++)
+    c_int_lte_lit2(0xf0);
+
+  for(int0 = 0; int0 != 0x7fff; int0++)
+    c_int_lte_lit2(0);
+}
+
+int
+main (void)
+{
+  char_compare();
+  int_compare1();
+  int_compare2();
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/cq22.c
+++ b/test/val/cq22.c
@@ -0,0 +1,144 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 2.2: identifiers (names)
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+/*
+        2.2 Identifiers (Names)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s22(pd0)
+struct defs *pd0;
+{
+#else
+int s22(struct defs *pd0)
+{
+#endif
+
+   int a234, a;
+   int _, _234, A, rc;
+
+   static char s22er[] = "s22,er%d\n";
+   static char qs22[8] = "s22    ";
+
+   char *ps, *pt;
+                         /* Initialize                      */
+
+   rc = 0;
+   ps = qs22;
+   pt = pd0 -> rfs;
+   while (*pt++ = *ps++);
+
+     /* An identifier is a sequence of letters and digits;
+        the first character must be a letter. The under-
+        score _ counts as a letter.                        */
+
+   a=1;
+   _=2;
+   _234=3;
+   a234=4;
+   if(a+_+_234+a234 != 10) {
+     rc = rc+1;
+     if(pd0->flgd != 0) printf(s22er,1);
+   }
+
+   /* Upper and lower case letters are different.     */
+
+   A = 2;
+   if (A == a) {
+     rc = rc+4;
+     if (pd0->flgd != 0) printf(s22er,4);
+   }
+
+   return(rc);
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#define cq_sections 1
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s22(pd0);
+        }
+}
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq241.c
+++ b/test/val/cq241.c
@@ -0,0 +1,286 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 2.41: integer constants, 2.42: explizit long constants
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+/*
+        2.4.1 Integer constants
+        2.4.2 Explicit long constants
+*/
+
+/* Calculate 2**n by multiplying, not shifting  */
+#ifndef NO_OLD_FUNC_DECL
+long pow2(n)
+long n;
+{
+#else
+long pow2(long n) {
+#endif
+   long s;
+   s = 1;
+   while(n--) s = s*2;
+   return s;
+}
+
+   long d[39], o[39], x[39];
+
+#ifndef NO_OLD_FUNC_DECL
+s241(pd0)
+struct defs *pd0;
+{
+#else
+int s241(struct defs *pd0) {
+#endif
+
+/*   long pow2(); */
+   static char s241er[] = "s241,er%d\n";
+   static char qs241[8] = "s241   ";
+   char *ps, *pt;
+   int rc, j, lrc;
+   static long g[39] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                        0,6,0,8,0,12,0,16,0,18,0,20,0,24,
+                        0,28,0,30,0,32,0,36};
+/*   long d[39], o[39], x[39]; */
+
+   rc = 0;
+   lrc = 0;
+   ps = qs241;
+   pt = pd0 -> rfs;
+   while (*pt++ = *ps++);
+
+     /* An integer constant consisting of a sequence of digits is
+        taken to be octal if it begins with 0 (digit zero), decimal
+        otherwise.                                            */
+
+   if (   8 !=  010
+     ||  16 !=  020
+     ||  24 !=  030
+     ||  32 !=  040
+     ||  40 !=  050
+     ||  48 !=  060
+     ||  56 !=  070
+     ||  64 != 0100
+     ||  72 != 0110
+     ||  80 != 0120
+     ||   9 != 0011
+     ||  17 != 0021
+     ||  25 != 0031
+     ||  33 != 0041
+     ||  41 != 0051
+     ||  49 != 0061
+     ||  57 != 0071
+     ||  65 != 0101
+     ||  73 != 0111
+     ||  81 != 0121 ){
+     rc = rc+1;
+     if( pd0->flgd != 0 ) printf(s241er,1);
+   }
+
+     /* A sequence of digits preceded by 0x or 0X (digit zero)
+        is taken to be a hexadecimal integer. The hexadecimal
+        digits include a or A through f or F with values 10
+        through 15.     */
+
+   if ( 0x00abcdef != 0xabcdef
+     || 0xabcdef != 0Xabcdef || 0Xabcdef != 0XAbcdef
+     || 0XAbcdef != 0XABcdef || 0XABcdef != 0XABCdef
+     || 0XABCdef != 0XABCDef || 0XABCDef != 0XABCDEf
+     || 0XABCDEf != 0XABCDEF || 0xABCDEF != 11259375 ){
+     rc = rc+2;
+     if( pd0->flgd != 0 ) printf(s241er,2);
+   }
+
+     /* A decimal constant whose value exceeds the largest signed
+        machine integer is taken to be long; an octal or hex con-
+        stant which exceeds the largest unsigned machine integer
+        is likewise taken to be long.     */
+#if defined(REFERENCE) && defined(REFCC_SIZEOF_LONG_64BIT)
+/*#warning "sizeof(long)!=4, skipping test"*/
+#else
+   if ( sizeof 010000000000 != sizeof(long)      /* 2**30 */
+     || sizeof 1073741824   != sizeof(long)      /* ditto */
+     || sizeof 0x40000000   != sizeof(long) ){   /*   "   */
+
+     rc = rc+4;
+     if( pd0->flgd != 0 ) printf(s241er,4);
+   }
+#endif
+     /* A decimal, octal, or hexadecimal constant immediately followed
+        by l (letter ell) or L is a long constant.    */
+
+   if ( sizeof   67l != sizeof(long)
+     || sizeof   67L != sizeof(long)
+     || sizeof  067l != sizeof(long)
+     || sizeof  067L != sizeof(long)
+     || sizeof 0X67l != sizeof(long)
+     || sizeof 0x67L != sizeof(long) ){
+     rc = rc+8;
+     if( pd0 -> flgd != 0 ) printf(s241er,8);
+   }
+
+     /* Finally, we test to see that decimal (d), octal (o),
+        and hexadecimal (x) constants representing the same values
+        agree among themselves, and with computed values, at spec-
+        ified points over an appropriate range. The points select-
+        ed here are those with the greatest potential for caus-
+        ing trouble, i.e., zero, 1-16, and values of 2**n and
+        2**n - 1 where n is some multiple of 4 or 6. Unfortunately,
+        just what happens when a value is too big to fit in a
+        long is undefined; however, it would be nice if what
+        happened were at least consistent...      */
+
+   for ( j=0; j<17; j++ ) g[j] = j;
+   for ( j=18; j<39; ) {
+     g[j] = pow2(g[j]);
+     g[j-1] = g[j] - 1;
+     j = j+2;
+   }
+
+   d[0] = 0;                o[0] = 00;               x[0] = 0x0;
+   d[1] = 1;                o[1] = 01;               x[1] = 0x1;
+   d[2] = 2;                o[2] = 02;               x[2] = 0x2;
+   d[3] = 3;                o[3] = 03;               x[3] = 0x3;
+   d[4] = 4;                o[4] = 04;               x[4] = 0x4;
+   d[5] = 5;                o[5] = 05;               x[5] = 0x5;
+   d[6] = 6;                o[6] = 06;               x[6] = 0x6;
+   d[7] = 7;                o[7] = 07;               x[7] = 0x7;
+   d[8] = 8;                o[8] = 010;              x[8] = 0x8;
+   d[9] = 9;                o[9] = 011;              x[9] = 0x9;
+   d[10] = 10;              o[10] = 012;             x[10] = 0xa;
+   d[11] = 11;              o[11] = 013;             x[11] = 0xb;
+   d[12] = 12;              o[12] = 014;             x[12] = 0xc;
+   d[13] = 13;              o[13] = 015;             x[13] = 0xd;
+   d[14] = 14;              o[14] = 016;             x[14] = 0xe;
+   d[15] = 15;              o[15] = 017;             x[15] = 0xf;
+   d[16] = 16;              o[16] = 020;             x[16] = 0x10;
+   d[17] = 63;              o[17] = 077;             x[17] = 0x3f;
+   d[18] = 64;              o[18] = 0100;            x[18] = 0x40;
+   d[19] = 255;             o[19] = 0377;            x[19] = 0xff;
+   d[20] = 256;             o[20] = 0400;            x[20] = 0x100;
+   d[21] = 4095;            o[21] = 07777;           x[21] = 0xfff;
+   d[22] = 4096;            o[22] = 010000;          x[22] = 0x1000;
+   d[23] = 65535;           o[23] = 0177777;         x[23] = 0xffff;
+   d[24] = 65536;           o[24] = 0200000;         x[24] = 0x10000;
+   d[25] = 262143;          o[25] = 0777777;         x[25] = 0x3ffff;
+   d[26] = 262144;          o[26] = 01000000;        x[26] = 0x40000;
+   d[27] = 1048575;         o[27] = 03777777;        x[27] = 0xfffff;
+   d[28] = 1048576;         o[28] = 04000000;        x[28] = 0x100000;
+   d[29] = 16777215;        o[29] = 077777777;       x[29] = 0xffffff;
+   d[30] = 16777216;        o[30] = 0100000000;      x[30] = 0x1000000;
+   d[31] = 268435455;       o[31] = 01777777777;     x[31] = 0xfffffff;
+   d[32] = 268435456;       o[32] = 02000000000;     x[32] = 0x10000000;
+   d[33] = 1073741823;      o[33] = 07777777777;     x[33] = 0x3fffffff;
+   d[34] = 1073741824;      o[34] = 010000000000;    x[34] = 0x40000000;
+   d[35] = 4294967295;      o[35] = 037777777777;    x[35] = 0xffffffff;
+   d[36] = 4294967296;      o[36] = 040000000000;    x[36] = 0x100000000;
+   d[37] = 68719476735;     o[37] = 0777777777777;   x[37] = 0xfffffffff;
+   d[38] = 68719476736;     o[38] = 01000000000000;  x[38] = 0x1000000000;
+
+   /* WHEW! */
+
+   for (j=0; j<39; j++){
+     if ( g[j] != d[j]
+       || d[j] != o[j]
+       || o[j] != x[j]) {
+       if( pd0 -> flgm != 0 ) {
+/*       printf(s241er,16);          save in case opinions change...     */
+         printf("Decimal and octal/hex constants sometimes give\n");
+         printf("   different results when assigned to longs.\n");
+       }
+/*     lrc = 1;   save...   */
+     }
+   }
+
+   if (lrc != 0) rc =16;
+
+   return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#define cq_sections 1
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s241(pd0);
+        }
+}
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq243.c
+++ b/test/val/cq243.c
@@ -0,0 +1,264 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 2.43: character constants
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+/*********************************************************************************************
+        2.4.3 Character constants
+**********************************************************************************************/
+
+#ifndef NO_OLD_FUNC_DECL
+zerofill(x)
+char *x;
+{
+#else
+void zerofill(char *x) {
+#endif
+   int j;
+
+   for (j=0; j<256; j++) *x++ = 0;
+}
+
+#ifndef NO_OLD_FUNC_DECL
+sumof(x)
+char *x;
+{
+#else
+int sumof(char *x) {
+#endif
+   char *p;
+   int total, j;
+
+   p = x;
+   total = 0;
+
+   for(j=0; j<256; j++) total = total+ *p++;
+   return total;
+}
+
+char chars[256];
+
+#ifndef NO_OLD_FUNC_DECL
+s243(pd0)
+struct defs *pd0;
+{
+#else
+int s243(struct defs *pd0) {
+#endif
+   static char s243er[] = "s243,er%d\n";
+   static char qs243[8] = "s243   ";
+   char *ps, *pt;
+   int rc;
+/*   char chars[256]; */
+
+   rc = 0;
+   ps = qs243;
+   pt = pd0->rfs;
+   while(*pt++ = *ps++);
+
+     /* One of the problems that arises when testing character constants
+        is that of definition: What, exactly, is the character set?
+        In order to guarantee a certain amount of machine independence,
+        the character set we will use here is the set of characters writ-
+        able as escape sequences in C, plus those characters used in writ-
+        ing C programs, i.e.,
+
+        letters:
+                   ABCDEFGHIJKLMNOPQRSTUVWXYZ      26
+                   abcdefghijklmnopqrstuvwxyz      26
+        numbers:
+                   0123456789                      10
+        special characters:
+                   ~!"#%&()_=-^|{}[]+;*:<>,.?/     27
+        extra special characters:
+                   newline           \n
+                   horizontal tab    \t
+                   backspace         \b
+                   carriage return   \r
+                   form feed         \f
+                   backslash         \\
+                   single quote      \'             7
+        blank & NUL                                 2
+                                                  ---
+                                                   98
+
+        Any specific implementation of C may of course support additional
+        characters.                                       */
+
+        /* Since the value of a character constant is the numerical value
+           of the character in the machine's character set, there should
+           be a one-to-one correspondence between characters and values. */
+
+   zerofill(chars);
+
+   chars['a'] = 1;   chars['A'] = 1;   chars['~'] = 1;   chars['0'] = 1;
+   chars['b'] = 1;   chars['B'] = 1;   chars['!'] = 1;   chars['1'] = 1;
+   chars['c'] = 1;   chars['C'] = 1;   chars['"'] = 1;   chars['2'] = 1;
+   chars['d'] = 1;   chars['D'] = 1;   chars['#'] = 1;   chars['3'] = 1;
+   chars['e'] = 1;   chars['E'] = 1;   chars['%'] = 1;   chars['4'] = 1;
+   chars['f'] = 1;   chars['F'] = 1;   chars['&'] = 1;   chars['5'] = 1;
+   chars['g'] = 1;   chars['G'] = 1;   chars['('] = 1;   chars['6'] = 1;
+   chars['h'] = 1;   chars['H'] = 1;   chars[')'] = 1;   chars['7'] = 1;
+   chars['i'] = 1;   chars['I'] = 1;   chars['_'] = 1;   chars['8'] = 1;
+   chars['j'] = 1;   chars['J'] = 1;   chars['='] = 1;   chars['9'] = 1;
+   chars['k'] = 1;   chars['K'] = 1;   chars['-'] = 1;
+   chars['l'] = 1;   chars['L'] = 1;   chars['^'] = 1;
+   chars['m'] = 1;   chars['M'] = 1;   chars['|'] = 1;   chars['\n'] = 1;
+   chars['n'] = 1;   chars['N'] = 1;                     chars['\t'] = 1;
+   chars['o'] = 1;   chars['O'] = 1;   chars['{'] = 1;   chars['\b'] = 1;
+   chars['p'] = 1;   chars['P'] = 1;   chars['}'] = 1;   chars['\r'] = 1;
+   chars['q'] = 1;   chars['Q'] = 1;   chars['['] = 1;   chars['\f'] = 1;
+   chars['r'] = 1;   chars['R'] = 1;   chars[']'] = 1;
+   chars['s'] = 1;   chars['S'] = 1;   chars['+'] = 1;   chars['\\'] = 1;
+   chars['t'] = 1;   chars['T'] = 1;   chars[';'] = 1;   chars['\''] = 1;
+   chars['u'] = 1;   chars['U'] = 1;   chars['*'] = 1;
+   chars['v'] = 1;   chars['V'] = 1;   chars[':'] = 1;   chars['\0'] = 1;
+   chars['w'] = 1;   chars['W'] = 1;   chars['<'] = 1;   chars[' '] = 1;
+   chars['x'] = 1;   chars['X'] = 1;   chars['>'] = 1;
+   chars['y'] = 1;   chars['Y'] = 1;   chars[','] = 1;
+   chars['z'] = 1;   chars['Z'] = 1;   chars['.'] = 1;
+                                       chars['?'] = 1;
+                                       chars['/'] = 1;
+
+   if(sumof(chars) != 98){
+     rc = rc+1;
+     if(pd0->flgd != 0) printf(s243er,1);
+   }
+
+   #ifndef NO_BACKSLASH_CHARCODE
+
+   /* Finally, the escape \ddd consists of the backslash followed
+      by 1, 2, or 3 octal digits which are taken to specify  the
+      desired character.                           */
+
+/*
+    this test is non portable and inaccurate, we replace it
+    by a more failproof version
+
+   if(
+   	'\0'    !=   0 ||
+   	'\01'   !=   1 ||
+	'\02'   !=   2 ||
+	'\03'   !=   3 ||
+    	'\04'   !=   4 ||
+	'\05'   !=   5 ||
+	'\06'   !=   6 ||
+    	'\07'   !=   7 ||
+	'\10'   !=   8 ||
+    	'\17'   !=  15 ||
+	'\20'   !=  16 ||
+	'\77'   !=  63 ||
+    	'\100'  !=  64 ||
+	'\177'  != 127
+	)
+*/
+    if(
+     ('0' != '\60') ||
+     ('9' != '\71') ||
+     ('A' != '\101') ||
+     ('Z' != '\132') ||
+     ('a' != '\141') ||
+     ('z' != '\172')
+      )
+
+	{
+     rc = rc+8;
+     if(pd0->flgd != 0)
+     {
+        printf(s243er,8);
+     }
+   }
+
+   #endif
+
+   return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#define cq_sections 1
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s243(pd0);
+        }
+}
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq244.c
+++ b/test/val/cq244.c
@@ -0,0 +1,159 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 2.44: floating point constants
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#ifndef NO_OLD_FUNC_DECL
+s244(pd0)
+struct defs *pd0;
+{
+#else
+s244(struct defs *pd0) {
+#endif
+
+   #ifndef NO_FLOATS
+        double a[8];
+
+   int rc, lrc, j;
+   static char s244er[] = "s244,er%d\n";
+   static char qs244[8] = "s244   ";
+   char *ps, *pt;
+
+   ps = qs244;
+   pt = pd0->rfs;
+   while(*pt++ = *ps++);
+   rc = 0;
+   lrc = 0;
+
+   /* Unfortunately, there's not a lot we can do with floating constants.
+      We can check to see that the various representations can be com-
+      piled, that the conversion is such that they yield the same hard-
+      ware representations in all cases, and that all representations
+      thus checked are double precision.              */
+
+   a[0] = .1250E+04;
+   a[1] = 1.250E3;
+   a[2] = 12.50E02;
+   a[3] = 125.0e+1;
+   a[4] = 1250e00;
+   a[5] = 12500.e-01;
+   a[6] = 125000e-2;
+   a[7] = 1250.;
+
+   lrc = 0;
+   for (j=0; j<7; j++) if(a[j] != a[j+1]) lrc = 1;
+
+   if(lrc != 0) {
+     if(pd0->flgd != 0) printf(s244er,1);
+     rc = rc+1;
+   }
+
+   if ( (sizeof .1250E+04 ) != sizeof(double)
+     || (sizeof 1.250E3   ) != sizeof(double)
+     || (sizeof 12.50E02  ) != sizeof(double)
+     || (sizeof 1.250e+1  ) != sizeof(double)
+     || (sizeof 1250e00   ) != sizeof(double)
+     || (sizeof 12500.e-01) != sizeof(double)
+     || (sizeof 125000e-2 ) != sizeof(double)
+     || (sizeof 1250.     ) != sizeof(double)){
+     if(pd0->flgd != 0) printf(s244er,2);
+     rc = rc+2;
+   }
+
+   return rc;
+
+   #else
+
+   return 0;
+
+   #endif
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#define cq_sections 1
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s244(pd0);
+        }
+}
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq25.c
+++ b/test/val/cq25.c
@@ -0,0 +1,171 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 2.5: strings
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#ifndef NO_OLD_FUNC_DECL
+s25(pd0)
+struct defs *pd0;
+{
+#else
+int s25(struct defs *pd0) {
+#endif
+   char *s, *s2;
+   int rc, lrc, j;
+   static char s25er[] = "s25,er%d\n";
+   static char qs25[8] = "s25    ";
+   char *ps, *pt;
+
+   ps = qs25;
+   pt = pd0->rfs;
+   while(*pt++ = *ps++);
+   rc = 0;
+
+   /* A string is a sequence of characters surrounded by double
+      quotes, as in "...".                         */
+
+   s = "...";
+
+   /* A string has type "array of characters" and storage class
+      static and is initialized with the given characters.  */
+
+   if ( s[0] != s[1] || s[1] != s[2]
+     || s[2] != '.' ) {
+    rc = rc+1;
+     if(pd0->flgd != 0) printf(s25er,1);
+   }
+
+   /* The compiler places a null byte \0 at the end of each string
+      so the program which scans the string can find its end.   */
+
+   if( s[3] != '\0' ){
+     rc = rc+4;
+     if(pd0->flgd != 0) printf(s25er,4);
+   }
+
+   /* In a string, the double quote character " must be preceded
+      by a \.                                               */
+
+   if( ".\"."[1] != '"' ){
+    rc = rc+8;
+     if(pd0->flgd != 0) printf(s25er,8);
+   }
+
+   /* In addition, the same escapes described for character constants
+      may be used.                                            */
+
+   s = "\n\t\b\r\f\\\'";
+
+   if( s[0] != '\n'
+    || s[1] != '\t'
+    || s[2] != '\b'
+    || s[3] != '\r'
+    || s[4] != '\f'
+    || s[5] != '\\'
+    || s[6] != '\'' ){
+     rc = rc+16;
+     if( pd0->flgd != 0) printf(s25er,16);
+   }
+
+   /* Finally, a \ and an immediately following newline are ignored */
+
+   s2 = "queep!";
+   s = "queep!";
+
+   lrc = 0;
+   for (j=0; j<sizeof "queep!"; j++) if(s[j] != s2[j]) lrc = 1;
+   if (lrc != 0){
+     rc = rc+32;
+     if(pd0->flgd != 0) printf(s25er,32);
+   }
+   return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#define cq_sections 1
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s25(pd0);
+        }
+}
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq26.c
+++ b/test/val/cq26.c
@@ -0,0 +1,217 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 2.6: Hardware Characteristics
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#ifndef CQ26_INCLUDED
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#endif
+
+/*
+  section s26, which pokes around at the hardware
+  trying to figure out the characteristics of the machine that
+  it is running on, saves information that is subsequently
+  used by sections s626, s72, and s757. If this program is
+  to be broken up into smallish pieces, say for running on
+  a microcomputer, take care to see that s26 is called before
+  calling any of the latter three sections.
+*/
+
+/*
+        2.6  Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+   static char qs26[8] = "s26    ";
+   char *ps, *pt;
+   char c0, c1;
+   #ifndef NO_FLOATS
+        float temp, one, delta;
+        double tempd, oned;
+   #endif
+   static char s[] = "%3d bits in %ss.\n";
+   static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+   ps = qs26;
+   pt = pd0->rfs;
+
+   while(*pt++ = *ps++);
+
+          /* Here, we shake the machinery a little to see what falls
+             out.  First, we find out how many bits are in a char.  */
+
+   pd0->cbits = 0;
+   c0 = 0;
+   c1 = 1;
+
+   while(c0 != c1) {
+     c1 = c1<<1;
+     pd0->cbits = pd0->cbits+1;
+   }
+          /* That information lets us determine the size of everything else. */
+
+   pd0->ibits = pd0->cbits * sizeof(int);
+   pd0->sbits = pd0->cbits * sizeof(short);
+   pd0->lbits = pd0->cbits * sizeof(long);
+   pd0->ubits = pd0->cbits * sizeof(unsigned);
+   #ifndef NO_FLOATS
+        pd0->fbits = pd0->cbits * sizeof(float);
+        pd0->dbits = pd0->cbits * sizeof(double);
+   #endif
+
+          /* We have now almost reconstructed the table in section 2.6, the
+             exception being the range of the floating point hardware.
+             Now there are just so many ways to conjure up a floating point
+             representation system that it's damned near impossible to guess
+             what's going on by writing a program to interpret bit patterns.
+             Further, the information isn't all that useful, if we consider
+             the fact that machines that won't handle numbers between 10**30
+             and 10**-30 are very hard to find, and that people playing with
+             numbers outside that range have a lot more to worry about than
+             just the capacity of the characteristic.
+
+             A much more useful measure is the precision, which can be ex-
+             pressed in terms of the smallest number that can be added to
+             1. without loss of significance. We calculate that here, for
+             float and double.                       */
+
+#ifndef NO_FLOATS
+   one = 1.;
+   delta = 1.;
+   temp = 0.;
+   while(temp != one) {
+     temp = one+delta;
+     delta = delta/2.;
+   }
+   pd0->fprec = delta * 4.;
+   oned = 1.;
+   delta = 1.;
+   tempd = 0.;
+   while(tempd != oned) {
+     tempd = oned+delta;
+     delta = delta/2.;
+   }
+   pd0->dprec = delta * 4.;
+#endif
+
+          /* Now, if anyone's interested, we publish the results.       */
+
+#ifndef CQ26_INCLUDED
+   if(pd0->flgm != 0) {
+     printf(s,pd0->cbits,"char");
+     printf(s,pd0->ibits,"int");
+     printf(s,pd0->sbits,"short");
+     printf(s,pd0->lbits,"long");
+     printf(s,pd0->ubits,"unsigned");
+     printf(s,pd0->fbits,"float");
+     printf(s,pd0->dbits,"double");
+     #ifndef NO_FLOATS
+        printf(s2,pd0->fprec,"float");
+        printf(s2,pd0->dprec,"double");
+     #else
+        printf("NO_FLOATS\n");
+     #endif
+   }
+#endif
+          /* Since we are only exploring and perhaps reporting, but not
+             testing any features, we cannot return an error code.  */
+
+   return 0;
+}
+
+#ifndef CQ26_INCLUDED
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s26(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
+#endif
--- a/test/val/cq4.c
+++ b/test/val/cq4.c
@@ -0,0 +1,242 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 4: what's in a name?
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+/*#include "cq26.c"*/ /* hardware check */
+
+int extvar;
+
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+int s4(struct defs *pd0);
+int svtest(int n);
+zero();
+testev();
+setev();
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s4(pd0)                    /* 4. What's in a name?             */
+struct defs *pd0;
+{
+#else
+int s4(struct defs *pd0) {
+#endif
+   static char s4er[] = "s4,er%d\n";
+   static char qs4[8] = "s4     ";
+   char *ps, *pt;
+   int j, rc;
+
+   short sint;             /* short integer, for size test      */
+   int pint;               /* plain                             */
+   long lint;              /* long                              */
+   unsigned target;
+   unsigned int mask;
+
+   rc = 0;
+   ps = qs4;
+   pt = pd0->rfs;
+
+   while(*pt++ = *ps++);
+
+/*   There are four declarable storage classes: automatic,
+static, external, and register. Automatic variables have
+been dealt with extensively thus far, and will not be specif-
+ically treated in this section. Register variables are treated
+in section s81.
+
+     Static variables are local to a block, but retain their
+values upon reentry to a block, even after control has left
+the block.                                                     */
+
+   for (j=0; j<3; j++)
+     if(svtest(j) != zero()){
+       rc = 1;
+       if(pd0->flgd != 0) printf(s4er,1);
+     }
+   ;
+
+/*   External variables exist and retain their values throughout
+the execution of the entire program, and may be used for comm-
+unication between functions, even separately compiled functions.
+                                                                */
+
+   setev();
+   if(testev() != 0){
+     rc=rc+2;
+     if(pd0->flgd != 0) printf(s4er,2);
+   }
+/*
+     Characters have been tested elsewhere (in s243).
+
+     Up to three sizes of integer, declared short int, int, and
+long int, are available. Longer integers provide no less storage
+than shorter ones, but implementation may make either short
+integers, or long integers, or both, equivalent to plain
+integers.
+                                                                */
+
+   if(sizeof lint < sizeof pint || sizeof pint < sizeof sint){
+     rc = rc+4;
+     if(pd0->flgd != 0) printf(s4er,4);
+   }
+
+/*   Unsigned integers, declared unsigned, obey the laws of
+arithmetic modulo 2**n, where n is the number of bits in the
+implementation                                                  */
+
+   target = ~0U;
+   mask = 1;
+
+   for(j=0; j<(sizeof target)*pd0->cbits; j++){
+     mask = mask&target;
+     target = target>>1;
+   }
+
+   if(mask != 1 || target != 0){
+     rc = rc+8;
+     if(pd0->flgd != 0) printf(s4er,8);
+   }
+
+   return rc;
+}
+
+#ifndef NO_OLD_FUNC_DECL
+svtest(n)
+int n;
+{
+#else
+int svtest(int n) {
+#endif
+
+   static k;
+   int rc;
+   switch (n) {
+     case 0: k = 1978;
+             rc = 0;
+             break;
+
+     case 1: if(k != 1978) rc = 1;
+             else{
+              k = 1929;
+              rc = 0;
+             }
+             break;
+
+     case 2: if(k != 1929) rc = 1;
+             else rc = 0;
+             break;
+   }
+   return rc;
+}
+zero(){                 /* Returns a value of zero, possibly */
+   static k;            /* with side effects, as it's called */
+   int rc;              /* alternately with svtest, above,   */
+   k = 2;               /* and has the same internal storage */
+   rc = 0;              /* requirements.                     */
+   return rc;
+}
+testev(){
+   if(extvar != 1066) return 1;
+   else return 0;
+}
+
+/* Sets an external variable. Used  */
+/* by s4, and should be compiled    */
+/* separately from s4.              */
+
+setev(){
+#ifndef NO_SLOPPY_EXTERN
+   extern int extvar;
+#endif
+   extvar = 1066;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s4(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq61.c
+++ b/test/val/cq61.c
@@ -0,0 +1,186 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 6.1: characters and integers
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+/*#include "cq26.c"*/ /* hardware check */
+
+int extvar;
+
+#ifndef NO_OLD_FUNC_DECL
+s61(pd0)          /* Characters and integers */
+struct defs *pd0;
+{
+#else
+int s61(struct defs *pd0){
+#endif
+   static char s61er[] = "s61,er%d\n";
+   static char s61ok[] = "s61,ok%d\n";
+   static char qs61[8] = "s61    ";
+   short from, shortint;
+   long int to, longint;
+   int rc, lrc;
+   int j;
+   char fromc, charint;
+   char *wd, *pc[6];
+
+   static char upper_alpha[]             = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+   static char lower_alpha[]             = "abcdefghijklmnopqrstuvwxyz";
+   static char numbers[]               = "0123456789";
+   static char special_characters[]    = "~!\"#%&()_=-^|{}[]+;*:<>,.?/";
+   static char extra_special_characters[] = "\n\t\b\r\f\\\'";
+   static char blank_and_NUL[]            = " \0";
+
+   char *ps, *pt;
+   ps = qs61;
+   pt = pd0->rfs;
+   rc = 0;
+
+   printf(s61ok,0);
+
+   while (*pt++ = *ps++);
+
+/*      A character or a short integer may be used wherever
+an integer may be used. In all cases, the value is converted
+to integer. This principle is extensively used throughout this
+program, and will not be explicitly tested here.        */
+
+/*      Conversion of a shorter integer to a longer always
+involves sign extension.                                */
+
+   from = -19;
+   to = from;
+
+   if(to != -19){
+     rc = rc+1;
+     if(pd0->flgd != 0) printf(s61er,1);
+   }
+   else if(pd0->flgd != 0) printf(s61ok,1);
+
+/*      It is guaranteed that a member of the standard char-
+acter set is nonnegative.                               */
+
+   pc[0] = upper_alpha;
+   pc[1] = lower_alpha;
+   pc[2] = numbers;
+   pc[3] = special_characters;
+   pc[4] = extra_special_characters;
+   pc[5] = blank_and_NUL;
+
+   lrc = 0;
+   for (j=0; j<6; j++)
+     while(*pc[j]) if(*pc[j]++ < 0) lrc =1;
+
+   if(lrc != 0){
+     rc=rc+2;
+     if(pd0->flgd != 0) printf(s61er,2);
+   }
+   else if(pd0->flgd != 0) printf(s61ok,2);
+
+/*      When a longer integer is converted to a shorter or
+to  a char, it is truncated on the left; excess bits are
+simply discarded.                                       */
+
+   longint = 1048579;           /* =2**20+3 */
+   shortint = longint;
+   charint = longint;
+
+   if((shortint != longint && shortint != 3) ||
+      (charint  != longint && charint  != 3)) {
+     rc = rc+8;
+     if(pd0->flgd != 0) printf(s61er,8);
+   }
+   else if(pd0->flgd != 0) printf(s61ok,8);
+
+   return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                /*case 0: return s26(pd0);*/
+                case 0: return s61(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq626.c
+++ b/test/val/cq626.c
@@ -0,0 +1,337 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 6.2: Float and double, 6.3 Floating and integral, 6.4 Pointers and integers, 6.5 Unsigned, 6.6 Arithmetic conversions
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#define CQ26_INCLUDED
+/*
+  section s26, which pokes around at the hardware
+  trying to figure out the characteristics of the machine that
+  it is running on, saves information that is subsequently
+  used by sections s626, s72, and s757. If this program is
+  to be broken up into smallish pieces, say for running on
+  a microcomputer, take care to see that s26 is called before
+  calling any of the latter three sections.
+*/
+
+/*
+        2.6  Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+   static char qs26[8] = "s26    ";
+   char *ps, *pt;
+   char c0, c1;
+   #ifndef NO_FLOATS
+        float temp, one, delta;
+        double tempd, oned;
+   #endif
+   static char s[] = "%3d bits in %ss.\n";
+   static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+   ps = qs26;
+   pt = pd0->rfs;
+
+   while(*pt++ = *ps++);
+
+          /* Here, we shake the machinery a little to see what falls
+             out.  First, we find out how many bits are in a char.  */
+
+   pd0->cbits = 0;
+   c0 = 0;
+   c1 = 1;
+
+   while(c0 != c1) {
+     c1 = c1<<1;
+     pd0->cbits = pd0->cbits+1;
+   }
+          /* That information lets us determine the size of everything else. */
+
+   pd0->ibits = pd0->cbits * sizeof(int);
+   pd0->sbits = pd0->cbits * sizeof(short);
+   pd0->lbits = pd0->cbits * sizeof(long);
+   pd0->ubits = pd0->cbits * sizeof(unsigned);
+   #ifndef NO_FLOATS
+        pd0->fbits = pd0->cbits * sizeof(float);
+        pd0->dbits = pd0->cbits * sizeof(double);
+   #endif
+
+          /* We have now almost reconstructed the table in section 2.6, the
+             exception being the range of the floating point hardware.
+             Now there are just so many ways to conjure up a floating point
+             representation system that it's damned near impossible to guess
+             what's going on by writing a program to interpret bit patterns.
+             Further, the information isn't all that useful, if we consider
+             the fact that machines that won't handle numbers between 10**30
+             and 10**-30 are very hard to find, and that people playing with
+             numbers outside that range have a lot more to worry about than
+             just the capacity of the characteristic.
+
+             A much more useful measure is the precision, which can be ex-
+             pressed in terms of the smallest number that can be added to
+             1. without loss of significance. We calculate that here, for
+             float and double.                       */
+
+#ifndef NO_FLOATS
+   one = 1.;
+   delta = 1.;
+   temp = 0.;
+   while(temp != one) {
+     temp = one+delta;
+     delta = delta/2.;
+   }
+   pd0->fprec = delta * 4.;
+   oned = 1.;
+   delta = 1.;
+   tempd = 0.;
+   while(tempd != oned) {
+     tempd = oned+delta;
+     delta = delta/2.;
+   }
+   pd0->dprec = delta * 4.;
+#endif
+
+          /* Now, if anyone's interested, we publish the results.       */
+
+#ifndef CQ26_INCLUDED
+   if(pd0->flgm != 0) {
+     printf(s,pd0->cbits,"char");
+     printf(s,pd0->ibits,"int");
+     printf(s,pd0->sbits,"short");
+     printf(s,pd0->lbits,"long");
+     printf(s,pd0->ubits,"unsigned");
+     printf(s,pd0->fbits,"float");
+     printf(s,pd0->dbits,"double");
+     #ifndef NO_FLOATS
+        printf(s2,pd0->fprec,"float");
+        printf(s2,pd0->dprec,"double");
+     #else
+        printf("NO_FLOATS\n");
+     #endif
+   }
+#endif
+          /* Since we are only exploring and perhaps reporting, but not
+             testing any features, we cannot return an error code.  */
+
+   return 0;
+}
+
+int extvar;
+
+#ifndef NO_OLD_FUNC_DECL
+s626(pd0)          /* 6.2 Float and double                  */
+                   /* 6.3 Floating and integral                 */
+                   /* 6.4 Pointers and integers                 */
+                   /* 6.5 Unsigned                              */
+                   /* 6.6 Arithmetic conversions                */
+struct defs *pd0;
+{
+#else
+int s626(struct defs *pd0){
+#endif
+   static char s626er[] = "s626,er%d\n";
+   static char qs626[8] = "s626   ";
+   int rc;
+   char *ps, *pt;
+   #ifndef NO_FLOATS
+   float eps, f1, f2, f3, f4, f;
+   #endif
+   long lint1, lint2, l, ls;
+   char c, t[28], t0;
+   short s;
+   int is, i, j;
+   unsigned u, us;
+   #ifndef NO_FLOATS
+        double d, ds;
+   #endif
+   ps = qs626;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+   #ifndef NO_FLOATS
+
+        /* Conversions of integral values to floating type are
+        well-behaved.                                           */
+
+   f1 = 1.;
+   lint1 = 1.;
+   lint2 = 1.;
+
+   for(j=0;j<pd0->lbits-2;j++){
+     f1 = f1*2;
+     lint2 = (lint2<<1)|lint1;
+   }
+   f2 = lint2;
+   f1 = (f1-f2)/f1;
+   if(f1>2.*pd0->fprec){
+     rc = rc+2;
+     if(pd0->flgd != 0) printf(s626er,2);
+   }
+
+        /* Pointer-integer combinations are discussed in s74,
+        "Additive operators". The unsigned-int combination
+        appears below.                                          */
+
+   c = 125;
+   s = 125;
+   i = 125;     is = 15625;
+   u = 125;     us = 15625;
+   l = 125;     ls = 15625;
+   f = 125.;
+   d = 125.;    ds = 15625.;
+
+   for(j=0;j<28;j++) t[j] = 0;
+
+   if(c*c != is) t[ 0] = 1;
+   if(s*c != is) t[ 1] = 1;
+   if(s*s != is) t[ 2] = 1;
+   if(i*c != is) t[ 3] = 1;
+   if(i*s != is) t[ 4] = 1;
+   if(i*i != is) t[ 5] = 1;
+   if(u*c != us) t[ 6] = 1;
+   if(u*s != us) t[ 7] = 1;
+   if(u*i != us) t[ 8] = 1;
+   if(u*u != us) t[ 9] = 1;
+   if(l*c != ls) t[10] = 1;
+   if(l*s != ls) t[11] = 1;
+   if(l*i != ls) t[12] = 1;
+   if(l*u != us) t[13] = 1;
+   if(l*l != ls) t[14] = 1;
+   if(f*c != ds) t[15] = 1;
+   if(f*s != ds) t[16] = 1;
+   if(f*i != ds) t[17] = 1;
+   if(f*u != ds) t[18] = 1;
+   if(f*l != ds) t[19] = 1;
+   if(f*f != ds) t[20] = 1;
+   if(d*c != ds) t[21] = 1;
+   if(d*s != ds) t[22] = 1;
+   if(d*i != ds) t[23] = 1;
+   if(d*u != ds) t[24] = 1;
+   if(d*l != ds) t[25] = 1;
+   if(d*f != ds) t[26] = 1;
+   if(d*d != ds) t[27] = 1;
+
+   t0 = 0;
+   for(j=0; j<28; j++) t0 = t0+t[j];
+
+   if(t0 != 0){
+     rc = rc+4;
+     if(pd0->flgd != 0){
+       printf(s626er,4);
+       printf("   key=");
+       for(j=0;j<28;j++) printf("%d",t[j]);
+       printf("\n");
+     }
+   }
+
+   #endif
+
+        /* When an unsigned integer is converted to long,
+           the value of the result is the same numerically
+           as that of the unsigned integer.               */
+
+   l = (unsigned)0100000;
+   if((long)l > (unsigned)0100000){
+      rc = rc+8;
+      if(pd0->flgd != 0) printf(s626er,8);
+   }
+
+   return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s26(pd0);
+                case 1: return s626(pd0);
+        }
+}
+
+#define cq_sections 2
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq71.c
+++ b/test/val/cq71.c
@@ -0,0 +1,240 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 7.1: primary expressions
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+/*include "cq26.c"*/ /* hardware check */
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+int extvar;
+
+#ifndef NO_OLD_FUNC_DECL
+s71(pd0)          /*         7.1  Primary expressions   */
+struct defs *pd0;
+{
+#else
+int s71(struct defs *pd0){
+#endif
+   static char s71er[] = "s71,er%d\n";
+   static char qs71[8] = "s71    ";
+   int rc;
+   char *ps, *pt;
+   static char q = 'q';
+#ifndef NO_SLOPPY_EXTERN
+   int x[10], McCarthy(), clobber(), a, b, *p;
+#else
+   int x[10], a, b, *p;
+#endif
+   ps = qs71;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+/*   Testing of expressions and operators is quite complicated,
+     because (a) problems are apt to surface in queer combinations
+     of operators and operands, rather than in isolation,
+     and (b) the number of expressions needed to provoke a case
+     of improper behaviour may be quite large. Hence, we take the
+     following approach: for this section, and for subsequent
+     sections through 7.15, we will check the primitive operations
+     in isolation, thus verifying that the primitives work,
+     after a fashion. The job of testing combinations, we will
+     leave to a separate, machine-generated program, to be included
+     in the C test package at some later date.
+                                                                */
+
+/*   A string is a primary expression. The identifier points to
+     the first character of a string.
+                                                                  */
+
+   if(*"queep" != q){
+     rc = rc+1;
+     if(pd0->flgd  != 0) printf(s71er,1);
+   }
+/*   A parenthesized expression is a primary expression whose
+     type and value are the same as those of the unadorned
+     expression.
+                                                                */
+   if((2+3) != 2+3) {
+     rc = rc+2;
+     if(pd0->flgd != 0) printf(s71er,2);
+   }
+
+/*   A primary expression followed by an expression in square
+     brackets is a primary expression. The intuitive meaning is
+     that of a subscript. The expression E1[E2] is identical
+     (by definition) to *((E1)+(E2)).
+                                                                */
+
+   x[5] = 1942;
+   if(x[5] != 1942 || x[5] != *((x)+(5))){
+     rc = rc+4;
+     if(pd0->flgd != 0) printf(s71er,4);
+   }
+
+/*   If the various flavors of function calls didn't work, we
+     would never have gotten this far; however, we do need to
+     show that functions can be recursive...
+                                                               */
+
+   if ( McCarthy(-5) != 91){
+     rc = rc+8;
+     if(pd0->flgd != 0) printf(s71er,8);
+   }
+
+/*   and that argument passing is strictly by value.           */
+
+   a = 2;
+   b = 3;
+   p = &b;
+
+   clobber(a,p);
+
+   if(a != 2 || b != 2){
+     rc = rc+16;
+     if(pd0->flgd != 0) printf(s71er,16);
+   }
+
+/*   Finally, structures and unions are addressed thusly:      */
+
+   #ifndef NO_FLOATS
+
+   if(pd0->dprec != (*pd0).dprec){
+     rc = rc+32;
+     if(pd0->flgd != 0) printf(s71er,32);
+   }
+
+   #endif
+
+   return rc;
+}
+#ifndef NO_OLD_FUNC_DECL
+McCarthy(x)
+int x;
+{
+#else
+int McCarthy(int x){
+#endif
+   if(x>100) return x-10;
+   else return McCarthy( McCarthy(x+11));
+}
+
+#ifndef NO_OLD_FUNC_DECL
+clobber(x,y)
+int x,*y;
+#else
+int clobber(int x,int *y)
+#endif
+
+/*
+#ifndef NO_OLD_FUNC_DECL
+clobber(x,y)
+int x,
+#ifdef NO_TYPELESS_INT_PTR
+int
+#endif
+*y;
+{
+#else
+int clobber(int x,
+#ifdef NO_TYPELESS_INT_PTR
+int
+#endif
+*y
+){
+#endif
+*/
+
+{
+   x = 3;
+   *y = 2;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                /*case 0: return s26(pd0);*/
+                case 0: return s71(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq714.c
+++ b/test/val/cq714.c
--- a/test/val/cq714b.c
+++ b/test/val/cq714b.c
--- a/test/val/cq715.c
+++ b/test/val/cq715.c
@@ -0,0 +1,151 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 7.15: Comma operator
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+/*#include "cq26.c"*/ /* hardware check */
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+s715f(int x,int y,int z);
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s715(pd0)          /*  7.15 Comma operator     */
+struct defs *pd0;
+{
+#else
+int s715(struct defs *pd0) {
+#endif
+   static char s715er[] = "s715,er%d\n";
+   static char qs715[8] = "s715   ";
+   int rc;
+   char *ps, *pt;
+   int a, t, c, i;
+   a = c = 0;
+   ps = qs715;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* A pair of expressions separated by a comma is
+        evaluated left to right and the value of the left
+        expression is discarded.
+                                                                */
+   i = 1;
+   if( i++,i++,i++,i++,++i != 6 ){
+     if(pd0->flgd != 0) printf(s715er,1);
+     rc = rc+1;
+   }
+
+        /* In contexts where the comma is given a special mean-
+        ing, for example in a list of actual arguments to
+        functions (sic) and lists of initializers, the comma
+        operator as described in this section can only appear
+        in parentheses; for example
+
+                f( a, (t=3, t+2), c)
+
+        has three arguments, the second of which has the
+        value 5.
+                                                                */
+
+   if(s715f(a, (t=3, t+2), c) != 5){
+     if(pd0->flgd != 0) printf(s715er,2);
+     rc = rc+2;
+   }
+   return rc;
+}
+s715f(x,y,z)
+int x, y, z;
+{
+   return y;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                /*case 0: return s26(pd0);*/
+                case 0: return s715(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq72.c
+++ b/test/val/cq72.c
@@ -0,0 +1,345 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 7.2: Unary Operators
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#define CQ26_INCLUDED
+/*
+  section s26, which pokes around at the hardware
+  trying to figure out the characteristics of the machine that
+  it is running on, saves information that is subsequently
+  used by sections s626, s72, and s757. If this program is
+  to be broken up into smallish pieces, say for running on
+  a microcomputer, take care to see that s26 is called before
+  calling any of the latter three sections.
+*/
+
+/*
+        2.6  Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+   static char qs26[8] = "s26    ";
+   char *ps, *pt;
+   char c0, c1;
+   #ifndef NO_FLOATS
+        float temp, one, delta;
+        double tempd, oned;
+   #endif
+   static char s[] = "%3d bits in %ss.\n";
+   static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+   ps = qs26;
+   pt = pd0->rfs;
+
+   while(*pt++ = *ps++);
+
+          /* Here, we shake the machinery a little to see what falls
+             out.  First, we find out how many bits are in a char.  */
+
+   pd0->cbits = 0;
+   c0 = 0;
+   c1 = 1;
+
+   while(c0 != c1) {
+     c1 = c1<<1;
+     pd0->cbits = pd0->cbits+1;
+   }
+          /* That information lets us determine the size of everything else. */
+
+   pd0->ibits = pd0->cbits * sizeof(int);
+   pd0->sbits = pd0->cbits * sizeof(short);
+   pd0->lbits = pd0->cbits * sizeof(long);
+   pd0->ubits = pd0->cbits * sizeof(unsigned);
+   #ifndef NO_FLOATS
+        pd0->fbits = pd0->cbits * sizeof(float);
+        pd0->dbits = pd0->cbits * sizeof(double);
+   #endif
+
+          /* We have now almost reconstructed the table in section 2.6, the
+             exception being the range of the floating point hardware.
+             Now there are just so many ways to conjure up a floating point
+             representation system that it's damned near impossible to guess
+             what's going on by writing a program to interpret bit patterns.
+             Further, the information isn't all that useful, if we consider
+             the fact that machines that won't handle numbers between 10**30
+             and 10**-30 are very hard to find, and that people playing with
+             numbers outside that range have a lot more to worry about than
+             just the capacity of the characteristic.
+
+             A much more useful measure is the precision, which can be ex-
+             pressed in terms of the smallest number that can be added to
+             1. without loss of significance. We calculate that here, for
+             float and double.                       */
+
+#ifndef NO_FLOATS
+   one = 1.;
+   delta = 1.;
+   temp = 0.;
+   while(temp != one) {
+     temp = one+delta;
+     delta = delta/2.;
+   }
+   pd0->fprec = delta * 4.;
+   oned = 1.;
+   delta = 1.;
+   tempd = 0.;
+   while(tempd != oned) {
+     tempd = oned+delta;
+     delta = delta/2.;
+   }
+   pd0->dprec = delta * 4.;
+#endif
+
+          /* Now, if anyone's interested, we publish the results.       */
+
+#ifndef CQ26_INCLUDED
+   if(pd0->flgm != 0) {
+     printf(s,pd0->cbits,"char");
+     printf(s,pd0->ibits,"int");
+     printf(s,pd0->sbits,"short");
+     printf(s,pd0->lbits,"long");
+     printf(s,pd0->ubits,"unsigned");
+     printf(s,pd0->fbits,"float");
+     printf(s,pd0->dbits,"double");
+     #ifndef NO_FLOATS
+        printf(s2,pd0->fprec,"float");
+        printf(s2,pd0->dprec,"double");
+     #else
+        printf("NO_FLOATS\n");
+     #endif
+   }
+#endif
+          /* Since we are only exploring and perhaps reporting, but not
+             testing any features, we cannot return an error code.  */
+
+   return 0;
+}
+
+#ifndef NO_OLD_FUNC_DECL
+s72(pd0)          /*  7.2  Unary operators  */
+struct defs *pd0;
+{
+#else
+int s72(struct defs *pd0){
+#endif
+   static char s72er[] = "s72,er%d\n";
+   static char qs72[8] = "s72    ";
+   int rc;
+   char *ps, *pt;
+   int k, j, i, lrc;
+   char c;
+   short s;
+   long l;
+   unsigned u;
+
+   #ifndef NO_FLOATS
+        double d;
+        float f;
+   #else
+        signed d;
+        signed f;
+   #endif
+
+   ps = qs72;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* The *, denoting indirection, and the &, denoting a
+        pointer, are duals of each other, and ought to behave as
+        such...                                                 */
+
+   k = 2;
+   if(*&*&k != 2){
+     rc = rc+1;
+     printf(s72er,1);
+   }
+
+        /* The unary minus has the conventional meaning.        */
+
+   if(k+(-k) != 0){
+     rc = rc+2;
+     printf(s72er,2);
+   }
+
+        /*  The negation operator (!) has been thoroughly checked out,
+        perhaps more thoroughly than any of the others. The ~ oper-
+        ator gets us a ones complement.                         */
+
+   k = 0;
+   for(j=0;j<pd0->ibits;j++) k = (k<<1)|1;
+   if(~k != 0){
+     rc = rc+4;
+     printf(s72er,4);
+   }
+
+        /*  Now we look at the ++ and -- operators, which can be
+        used in either prefix or suffix form. With side
+        effects they're loaded.                                 */
+
+   k = 5;
+
+   if( ++k != 6 || --k != 5
+    || k++ != 5 || k-- != 6
+    ||   k != 5 ){
+     rc = rc+8;
+     printf(s72er,8);
+   }
+
+        /*  An expression preceded by the parenthesised name of a
+        data type causes conversion of the value of the expression
+        to the named type. This construction is called a cast.
+        Here, we check to see that all of the possible casts and
+        their simple combinations are accepted by the compiler,
+        and that they all produce a correct result for this sample
+        of size one.                                            */
+
+   c = 26;  l = 26;
+   s = 26;  u = 26;
+   i = 26;
+   #ifndef NO_FLOATS
+   f = 26.;
+   d = 26.;
+   #else
+   f = 26;
+   d = 26;
+   #endif
+
+   lrc = 0;
+
+   if( (char)s != 26 || (char)i != 26
+    || (char)l != 26 || (char)u != 26
+    || (char)f != 26 || (char)d != 26 ) lrc = lrc+1;
+
+   if( (short)c != 26 || (short)i != 26
+    || (short)l != 26 || (short)u != 26
+    || (short)f != 26 || (short)d != 26) lrc = lrc+2;
+
+   if( (int)c != 26 || (int)s != 26
+    || (int)l != 26 || (int)u != 26
+    || (int)f != 26 || (int)d != 26 ) lrc = lrc+4;
+
+   if( (long)c != 26 || (long)s != 26
+    || (long)i != 26 || (long)u != 26
+    || (long)f != 26 || (long)d != 26 ) lrc = lrc+8;
+
+   if( (unsigned)c != 26 || (unsigned)s != 26
+    || (unsigned)i != 26 || (unsigned)l != 26
+    || (unsigned)f != 26 || (unsigned)d != 26 ) lrc = lrc+16;
+
+   #ifndef NO_FLOATS
+   if( (float)c != 26. || (float)s != 26.
+    || (float)i != 26. || (float)l != 26.
+    || (float)u != 26. || (float)d != 26. ) lrc = lrc+32;
+
+   if( (double)c != 26. || (double)s != 26.
+    || (double)i != 26. || (double)l != 26.
+    || (double)u != 26. || (double)f != 26. ) lrc = lrc+64;
+   #endif
+
+   if(lrc != 0){
+     rc = rc+16;
+     printf(s72er,16);
+   }
+
+        /*  The sizeof operator has been tested previously.     */
+
+   return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s26(pd0);
+                case 1: return s72(pd0);
+        }
+}
+
+#define cq_sections 2
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq757.c
+++ b/test/val/cq757.c
@@ -0,0 +1,335 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 7.5: Shift operators, 7.6 Relational operators, 7.7 Equality operator
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#define CQ26_INCLUDED
+/*
+  section s26, which pokes around at the hardware
+  trying to figure out the characteristics of the machine that
+  it is running on, saves information that is subsequently
+  used by sections s626, s72, and s757. If this program is
+  to be broken up into smallish pieces, say for running on
+  a microcomputer, take care to see that s26 is called before
+  calling any of the latter three sections.
+*/
+
+/*
+        2.6  Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+   static char qs26[8] = "s26    ";
+   char *ps, *pt;
+   char c0, c1;
+   #ifndef NO_FLOATS
+        float temp, one, delta;
+        double tempd, oned;
+   #endif
+   static char s[] = "%3d bits in %ss.\n";
+   static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+   ps = qs26;
+   pt = pd0->rfs;
+
+   while(*pt++ = *ps++);
+
+          /* Here, we shake the machinery a little to see what falls
+             out.  First, we find out how many bits are in a char.  */
+
+   pd0->cbits = 0;
+   c0 = 0;
+   c1 = 1;
+
+   while(c0 != c1) {
+     c1 = c1<<1;
+     pd0->cbits = pd0->cbits+1;
+   }
+          /* That information lets us determine the size of everything else. */
+
+   pd0->ibits = pd0->cbits * sizeof(int);
+   pd0->sbits = pd0->cbits * sizeof(short);
+   pd0->lbits = pd0->cbits * sizeof(long);
+   pd0->ubits = pd0->cbits * sizeof(unsigned);
+   #ifndef NO_FLOATS
+        pd0->fbits = pd0->cbits * sizeof(float);
+        pd0->dbits = pd0->cbits * sizeof(double);
+   #endif
+
+          /* We have now almost reconstructed the table in section 2.6, the
+             exception being the range of the floating point hardware.
+             Now there are just so many ways to conjure up a floating point
+             representation system that it's damned near impossible to guess
+             what's going on by writing a program to interpret bit patterns.
+             Further, the information isn't all that useful, if we consider
+             the fact that machines that won't handle numbers between 10**30
+             and 10**-30 are very hard to find, and that people playing with
+             numbers outside that range have a lot more to worry about than
+             just the capacity of the characteristic.
+
+             A much more useful measure is the precision, which can be ex-
+             pressed in terms of the smallest number that can be added to
+             1. without loss of significance. We calculate that here, for
+             float and double.                       */
+
+#ifndef NO_FLOATS
+   one = 1.;
+   delta = 1.;
+   temp = 0.;
+   while(temp != one) {
+     temp = one+delta;
+     delta = delta/2.;
+   }
+   pd0->fprec = delta * 4.;
+   oned = 1.;
+   delta = 1.;
+   tempd = 0.;
+   while(tempd != oned) {
+     tempd = oned+delta;
+     delta = delta/2.;
+   }
+   pd0->dprec = delta * 4.;
+#endif
+
+          /* Now, if anyone's interested, we publish the results.       */
+
+#ifndef CQ26_INCLUDED
+   if(pd0->flgm != 0) {
+     printf(s,pd0->cbits,"char");
+     printf(s,pd0->ibits,"int");
+     printf(s,pd0->sbits,"short");
+     printf(s,pd0->lbits,"long");
+     printf(s,pd0->ubits,"unsigned");
+     printf(s,pd0->fbits,"float");
+     printf(s,pd0->dbits,"double");
+     #ifndef NO_FLOATS
+        printf(s2,pd0->fprec,"float");
+        printf(s2,pd0->dprec,"double");
+     #else
+        printf("NO_FLOATS\n");
+     #endif
+   }
+#endif
+          /* Since we are only exploring and perhaps reporting, but not
+             testing any features, we cannot return an error code.  */
+
+   return 0;
+}
+
+#ifndef NO_OLD_FUNC_DECL
+s757(pd0)          /* 7.5 Shift operators          */
+                   /* 7.6 Relational operators     */
+                   /* 7.7 Equality operator        */
+struct defs *pd0;
+{
+#else
+int s757(struct defs *pd0){
+#endif
+   static char s757er[] = "s757,er%d\n";
+   static char qs757[8] = "s757   ";
+   int rc;
+   char *ps, *pt;
+   int t,lrc,k,j,a,b,c,d,x[16],*p;
+   unsigned rs, ls, rt, lt;
+   ps = qs757;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* The shift operators << and >> group left-to-right.
+                                                                */
+
+   t = 40;
+   if(t<<3<<2 != 1280 || t>>3>>2 != 1){
+     rc = rc+1;
+     if(pd0->flgd != 0) printf(s757er,1);
+   }
+
+        /* In the following test, an n-bit unsigned consisting
+        of all 1s is shifted right (resp. left) k bits, 0<=k<n.
+        We expect to find k 0s followed by n-k 1s (resp. n-k 1s
+        followed by k 0s). If not, we complain.
+                                                                */
+
+   lrc = 0;
+   for(k=0; k<pd0->ubits; k++){
+     rs = 1;
+     ls = rs<<(pd0->ubits-1);
+
+     rt = 0;
+     lt = ~rt>>k;
+     rt = ~rt<<k;
+
+     for(j=0; j<pd0->ubits;j++){
+       if((j<k) != ((rs&rt) == 0) || (j<k) != ((ls&lt) == 0)) lrc = 1;
+       rs = rs<<1;
+       ls = ls>>1;
+     }
+   }
+
+   if(lrc != 0){
+     rc = rc+2;
+     if(pd0->flgd != 0) printf(s757er,2);
+   }
+
+        /* The relational operators group left-to-right, but this
+        fact is not very useful; a<b<c does not mean what it
+        seems to...
+                                                                */
+
+   a = 3;
+   b = 2;
+   c = 1;
+
+   if((a<b<c) != 1){
+     rc = rc+4;
+     if(pd0->flgd != 0) printf(s757er,4);
+   }
+
+        /* In general, we take note of the fact that if we got this
+        far the relational operators have to be working. We test only
+        that two pointers may be compared; the result depends on
+        the relative locations in the address space of the
+        pointed-to objects.
+                                                                */
+   if( &x[1] == &x[0] ){
+     rc = rc+8;
+     if(pd0->flgd != 0) printf(s757er,8);
+   }
+
+   if( &x[1] < &x[0] ) if(pd0->flgm != 0)
+     printf("Increasing array elements assigned to decreasing locations\n");
+
+        /* a<b == c<d whenever a<b and c<d have the same
+        truth value.                                            */
+
+   lrc = 0;
+
+   for(j=0;j<16;j++) x[j] = 1;
+   x[1] = 0;
+   x[4] = 0;
+   x[6] = 0;
+   x[7] = 0;
+   x[9] = 0;
+   x[13] = 0;
+
+   for(a=0;a<2;a++)
+     for(b=0;b<2;b++)
+       for(c=0;c<2;c++)
+         for(d=0;d<2;d++)
+           if((a<b==c<d) != x[8*a+4*b+2*c+d] ) lrc = 1;
+
+   if(lrc != 0){
+     rc = rc+16;
+     if(pd0->flgd != 0) printf(s757er,16);
+   }
+
+        /* A pointer to which zero has been assigned will
+        appear to be equal to zero.
+                                                                */
+
+   p = 0;
+
+   if(p != 0){
+     rc = rc+32;
+     if(pd0->flgd != 0) printf(s757er,32);
+   }
+
+   return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s26(pd0);
+                case 1: return s757(pd0);
+        }
+}
+
+#define cq_sections 2
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq7813.c
+++ b/test/val/cq7813.c
@@ -0,0 +1,381 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 7.8: Bitwise AND operator, 7.9 Bitwise OR operator, 7.10 Bitwise exclusive OR operator, 7.11 Logical AND operator, 7.12 Logical OR operator, 7.13 Conditional operator
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#ifndef NO_OLD_FUNC_DECL
+s7813(pd0)          /* 7.8 Bitwise AND operator
+                       7.9 Bitwise OR operator
+                       7.10 Bitwise exclusive OR operator
+                       7.11 Logical AND operator
+                       7.12 Logical OR operator
+                       7.13 Conditional operator            */
+struct defs *pd0;
+{
+#else
+int s7813(struct defs *pd0){
+#endif
+   register int prlc, lrc;
+   int i, j, r, zero, one;
+   static char fl[] = "Local error %d.\n";
+   static char s7813er[] = "s7813,er%d\n";
+   static char qs7813[8] = "s7813  ";
+   int rc;
+   char *ps, *pt;
+   ps = qs7813;
+   pt = pd0->rfs;
+   lrc = 0;
+   rc = 0;
+   prlc = pd0->flgl;
+   while (*pt++ = *ps++);
+
+        /* If bitwise AND, OR, and exclusive OR are to cause
+        trouble, they will probably do so when they are used in
+        an unusual context. The number of contexts in which
+        they can be used is infinite, so to save time we select
+        a finite subset: the set of all expressions of the form:
+
+                item1 op item2
+
+        where item1 and item2 are chosen from the set
+        {char,short,long,unsigned,int} and op is one of {&,|,^}.
+        We will use 12 and 10 as values for the items, as these
+        values will fit into all data types on just about any
+        imaginable machine, and the results after performing the
+        bitwise operations on them are distinct for each operation,
+        i.e.,
+
+                12 | 10  -> 1100 | 1010  -> 1110 -> 14
+                12 ^ 10  -> 1100 ^ 1010  -> 0110 ->  6
+                12 & 10  -> 1100 & 1010  -> 1000 ->  8
+
+        There are 75 such combinations:
+                                                                */
+
+   if(((char)12 & (char)10) !=  8) {lrc = 1;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 | (char)10) != 14) {lrc = 2;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 ^ (char)10) !=  6) {lrc = 3;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 & (short)10) !=  8) {lrc = 4;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 | (short)10) != 14) {lrc = 5;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 ^ (short)10) !=  6) {lrc = 6;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 & (long)10) !=  8) {lrc = 7;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 | (long)10) != 14) {lrc = 8;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 ^ (long)10) !=  6) {lrc = 9;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 & (unsigned)10) !=  8) {lrc = 10;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 | (unsigned)10) != 14) {lrc = 11;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 ^ (unsigned)10) !=  6) {lrc = 12;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 & (int)10) !=  8) {lrc = 13;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 | (int)10) != 14) {lrc = 14;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 ^ (int)10) !=  6) {lrc = 15;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 & (char)10) !=  8) {lrc = 16;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 | (char)10) != 14) {lrc = 17;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 ^ (char)10) !=  6) {lrc = 18;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 & (short)10) !=  8) {lrc = 16;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 | (short)10) != 14) {lrc = 20;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 ^ (short)10) !=  6) {lrc = 21;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 & (long)10) !=  8) {lrc = 22;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 | (long)10) != 14) {lrc = 23;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 ^ (long)10) !=  6) {lrc = 24;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 & (unsigned)10) !=  8) {lrc = 25;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 | (unsigned)10) != 14) {lrc = 26;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 ^ (unsigned)10) !=  6) {lrc = 27;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 & (int)10) !=  8) {lrc = 28;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 | (int)10) != 14) {lrc = 26;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 ^ (int)10) !=  6) {lrc = 30;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 & (char)10) !=  8) {lrc = 31;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 | (char)10) != 14) {lrc = 32;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 ^ (char)10) !=  6) {lrc = 33;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 & (short)10) !=  8) {lrc = 34;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 | (short)10) != 14) {lrc = 35;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 ^ (short)10) !=  6) {lrc = 36;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 & (long)10) !=  8) {lrc = 37;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 | (long)10) != 14) {lrc = 38;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 ^ (long)10) !=  6) {lrc = 39;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 & (unsigned)10) !=  8) {lrc = 40;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 | (unsigned)10) != 14) {lrc = 41;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 ^ (unsigned)10) !=  6) {lrc = 42;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 & (int)10) !=  8) {lrc = 43;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 | (int)10) != 14) {lrc = 44;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 ^ (int)10) !=  6) {lrc = 45;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 & (char)10) !=  8) {lrc = 46;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 | (char)10) != 14) {lrc = 47;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 ^ (char)10) !=  6) {lrc = 48;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 & (short)10) !=  8) {lrc = 49;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 | (short)10) != 14) {lrc = 50;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 ^ (short)10) !=  6) {lrc = 51;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 & (long)10) !=  8) {lrc = 52;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 | (long)10) != 14) {lrc = 53;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 ^ (long)10) !=  6) {lrc = 54;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 & (unsigned)10) !=  8) {lrc = 55;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 | (unsigned)10) != 14) {lrc = 56;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 ^ (unsigned)10) !=  6) {lrc = 57;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 & (int)10) !=  8) {lrc = 58;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 | (int)10) != 14) {lrc = 56;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 ^ (int)10) !=  6) {lrc = 60;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 & (char)10) !=  8) {lrc = 61;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 | (char)10) != 14) {lrc = 62;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 ^ (char)10) !=  6) {lrc = 63;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 & (short)10) !=  8) {lrc = 64;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 | (short)10) != 14) {lrc = 65;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 ^ (short)10) !=  6) {lrc = 66;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 & (long)10) !=  8) {lrc = 67;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 | (long)10) != 14) {lrc = 68;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 ^ (long)10) !=  6) {lrc = 69;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 & (unsigned)10) !=  8) {lrc = 70;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 | (unsigned)10) != 14) {lrc = 71;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 ^ (unsigned)10) !=  6) {lrc = 72;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 & (int)10) !=  8) {lrc = 73; if(prlc) printf(fl,lrc);}
+   if(((int)12 | (int)10) != 14) {lrc = 74; if(prlc) printf(fl,lrc);}
+   if(((int)12 ^ (int)10) !=  6) {lrc = 75; if(prlc) printf(fl,lrc);}
+
+   if(lrc != 0){
+     if(pd0->flgd != 0) printf(s7813er,1);
+     rc = rc+1;
+   }
+
+        /* The && operator groups left to right. It returns 1
+        if both of the operands are nonzero; 0 otherwise.
+        It guarantees left to right evaluation; moreover, the
+        second operand is not evaluated if the value of the
+        first operand is 0.
+                                                                */
+
+   lrc = 0;
+   i = j = 0;
+
+   r = i++ && j++;
+    if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);}
+    if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);}
+    if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);}
+   r = i && j++;
+    if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);}
+    if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);}
+    if(r!=0) {lrc = 6; if(prlc) printf(fl,lrc);}
+   r = i-- && j;
+    if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);}
+    if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);}
+    if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);}
+   r = i && j--;
+    if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);}
+    if(j!=1) {lrc = 11; if(prlc) printf(fl,lrc);}
+    if(r!=0) {lrc = 12; if(prlc) printf(fl,lrc);}
+
+   if(lrc!=0){
+     if(pd0->flgd != 0) printf(s7813er,2);
+     rc = rc+2;
+   }
+
+        /* The || operator groups left to right. It returns 1
+        if either of its operands is nonzero; 0 otherwise. It
+        guarantees left to right evaluation; moreover, the second
+        operand is not evaluated if the value of the first
+        operand is nonzero.
+                                                                */
+
+   lrc = 0;
+   i = j = 0;
+   r = i++ || j;
+    if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);}
+    if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);}
+    if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);}
+   r = j++ || i;
+    if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);}
+    if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);}
+    if(r!=1) {lrc = 6; if(prlc) printf(fl,lrc);}
+   r = i-- || j--;
+    if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);}
+    if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);}
+    if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);}
+   r = i || j--;
+    if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);}
+    if(j!=0) {lrc = 11; if(prlc) printf(fl,lrc);}
+    if(r!=1) {lrc = 12; if(prlc) printf(fl,lrc);}
+
+   if(lrc!=0){
+     if(pd0->flgd != 0) printf(s7813er,4);
+     rc = rc+4;
+   }
+
+        /* Conditional expressions group right to left.  */
+
+   i = j = 0;
+   zero = 0;
+   one = 1;
+   r = one?zero:one?i++:j++;
+   if(r!=0 || i!=0 || j!=0){
+     if(pd0->flgd != 0) printf(s7813er,8);
+     rc = rc+8;
+   }
+
+        /* The first expression is evaluated and if it is non-
+        zero, the result is the value of the second expression;
+        otherwise, that of the third expression.
+                                                                */
+
+   if((one?zero:1) != 0 || (zero?1:zero) != 0){
+     if(pd0->flgd != 0) printf(s7813er,16);
+     rc = rc+16;
+   }
+   return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s7813(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+     d0.flgs = 1;          /* These flags dictate            */
+     d0.flgm = 1;          /*     the verbosity of           */
+     d0.flgd = 1;          /*         the program.           */
+     d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq81.c
+++ b/test/val/cq81.c
@@ -0,0 +1,727 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 8.1: storage class specifiers
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+regc();
+regp();
+regi();
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s81(pd0)              /* 8.1 Storage Class Specifiers    */
+struct defs *pd0;
+#else
+int s81(struct defs *pd0)
+#endif
+{
+   static char s81er[] = "s81,er%d\n";
+   static char qs81[8] = "s81    ";
+   char *ps, *pt;
+   int k, rc, j, crc, prc, irc;
+   register char rchar;
+            char nrchar;
+   register int *rptr;
+            int *nrptr;
+   register int rint;
+            int nrint;
+   static char badtest[] = "Register count for %s is unreliable.\n";
+   static char goodtest[] = "%d registers assigned to %s variables.\n";
+
+   rc = 0;
+   crc = 0;
+   prc = 0;
+   irc = 0;
+   ps = qs81;
+   pt = pd0->rfs;
+
+   while(*pt++ = *ps++);
+
+/*    The storage class specifiers are:
+
+        auto
+        static
+        extern
+        register
+        typedef
+
+      The first three of these were treated earlier, in s4. The last
+   will be checked in s88. "Register" remains.
+
+      There are three flavors of register, viz., char, int and pointer.
+   We wish first to ascertain that the representations as register
+   are consistent with the corresponding nonregister representations.
+                                                                 */
+
+   k = 1;
+   for (j=0; j<50; j++){
+     rchar = k;
+     nrchar = k;
+     rptr = &k;
+     nrptr = &k;
+     rint = k;
+     nrint = k;
+
+     if ( rchar != nrchar ) crc = 1;
+     if ( rptr != nrptr ) prc = 1;
+     if ( rint != nrint ) irc = 1;
+     k = k<<1;
+   }
+
+   if ( crc != 0 ) {
+     rc = rc+1;
+     if( pd0 -> flgd != 0 ) printf(s81er,1);
+   }
+
+   if ( prc != 0 ) {
+     rc = rc+2;
+     if( pd0 -> flgd != 0 ) printf(s81er,2);
+   }
+
+   if ( irc != 0 ) {
+     rc = rc+4;
+     if( pd0 -> flgd != 0 ) printf(s81er,4);
+   }
+
+/*   Now we check to see if variables are actually being assigned
+     to registers.                       */
+
+   k = regc();
+   if ( pd0->flgm != 0 ) {
+     if ( k < 0 ) printf(badtest,"char");
+     else printf(goodtest,k,"char");
+   }
+
+   k = regp();
+   if ( pd0->flgm != 0 ) {
+     if ( k<0 ) printf(badtest,"pointer");
+     else printf(goodtest,k,"pointer");
+   }
+
+   k = regi();
+   if ( pd0->flgm != 0 ) {
+     if ( k<0 ) printf(badtest,"int");
+     else printf(goodtest,k,"int");
+   }
+
+   return rc;
+}
+regc() {     /*   char to register assignment   */
+/*   Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be
+bunched together and ordered according to one of the following
+criteria:
+
+     (a) the order in which they were defined.
+     (b) the order in which they are used.
+     (c) alphabetically.
+     (d) the order in which they appear in the compiler's
+         symbol table.
+     (e) some other way.
+
+     Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid.                                     */
+
+            char r00;
+            char r01;
+            char r02;
+            char r03;
+   register char r04;
+            char r05;
+   register char r06;
+            char r07;
+   register char r08;
+            char r09;
+   register char r10;
+            char r11;
+   register char r12;
+            char r13;
+   register char r14;
+            char r15;
+   register char r16;
+            char r17;
+   register char r18;
+            char r19;
+   register char r20;
+            char r21;
+   register char r22;
+            char r23;
+   register char r24;
+            char r25;
+   register char r26;
+            char r27;
+   register char r28;
+            char r29;
+   register char r30;
+            char r31;
+   register char r32;
+            char r33;
+   register char r34;
+            char r35;
+            char r36;
+            char r37;
+            char r38;
+
+   int s, n1, n2, nr, j, d[22];
+   r00 = 0;
+   r01 = 1;
+   r02 = 2;
+   r03 = 3;
+   r04 = 4;
+   r05 = 5;
+   r06 = 6;
+   r07 = 7;
+   r08 = 8;
+   r09 = 9;
+   r10 = 10;
+   r11 = 11;
+   r12 = 12;
+   r13 = 13;
+   r14 = 14;
+   r15 = 15;
+   r16 = 16;
+   r17 = 17;
+   r18 = 18;
+   r19 = 19;
+   r20 = 20;
+   r21 = 21;
+   r22 = 22;
+   r23 = 23;
+   r24 = 24;
+   r25 = 25;
+   r26 = 26;
+   r27 = 27;
+   r28 = 28;
+   r29 = 29;
+   r30 = 30;
+   r31 = 31;
+   r32 = 32;
+   r33 = 33;
+   r34 = 34;
+   r35 = 35;
+   r36 = 36;
+   r37 = 37;
+   r38 = 38;
+
+   d[0] = &r01 - &r00;
+   d[1] = &r02 - &r01;
+   d[2] = &r03 - &r02;
+   d[3] = &r05 - &r03;
+   d[4] = &r07 - &r05;
+   d[5] = &r09 - &r07;
+   d[6] = &r11 - &r09;
+   d[7] = &r13 - &r11;
+   d[8] = &r15 - &r13;
+   d[9] = &r17 - &r15;
+   d[10] = &r19 - &r17;
+   d[11] = &r21 - &r19;
+   d[12] = &r23 - &r21;
+   d[13] = &r25 - &r23;
+   d[14] = &r27 - &r25;
+   d[15] = &r29 - &r27;
+   d[16] = &r31 - &r29;
+   d[17] = &r33 - &r31;
+   d[18] = &r35 - &r33;
+   d[19] = &r36 - &r35;
+   d[20] = &r37 - &r36;
+   d[21] = &r38 - &r37;
+
+/*   The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs,
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable.              */
+
+   n1 = d[0];
+   s = 1;
+
+   for (j=0; j<22; j++)
+     switch (s) {
+       case 1: if (d[j] != n1) {
+                n2 = d[j];
+                s = 2;
+                nr = 1;
+               }
+               break;
+       case 2: if (d[j] == n1) {
+                s = 3;
+                break;
+               }
+               if (d[j] == n2) {
+                nr = nr+1;
+                break;
+               }
+               s = 4;
+               break;
+       case 3: if (d[j] != n1) s = 4;
+               break;
+     }
+   ;
+
+   if (s == 3) return 16-nr;
+   else return -1;
+}
+regi() {     /*   int to register assignment    */
+/*   Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be
+bunched together and ordered according to one of the following
+criteria:
+
+     (a) the order in which they were defined.
+     (b) the order in which they are used.
+     (c) alphabetically.
+     (d) the order in which they appear in the compiler's
+         symbol table.
+     (e) some other way.
+
+     Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid.                                     */
+
+            int r00;
+            int r01;
+            int r02;
+            int r03;
+   register int r04;
+            int r05;
+   register int r06;
+            int r07;
+   register int r08;
+            int r09;
+   register int r10;
+            int r11;
+   register int r12;
+            int r13;
+   register int r14;
+            int r15;
+   register int r16;
+            int r17;
+   register int r18;
+            int r19;
+   register int r20;
+            int r21;
+   register int r22;
+            int r23;
+   register int r24;
+            int r25;
+   register int r26;
+            int r27;
+   register int r28;
+            int r29;
+   register int r30;
+            int r31;
+   register int r32;
+            int r33;
+   register int r34;
+            int r35;
+            int r36;
+            int r37;
+            int r38;
+
+   int s, n1, n2, nr, j, d[22];
+
+   r00 = 0;
+   r01 = 1;
+   r02 = 2;
+   r03 = 3;
+   r04 = 4;
+   r05 = 5;
+   r06 = 6;
+   r07 = 7;
+   r08 = 8;
+   r09 = 9;
+   r10 = 10;
+   r11 = 11;
+   r12 = 12;
+   r13 = 13;
+   r14 = 14;
+   r15 = 15;
+   r16 = 16;
+   r17 = 17;
+   r18 = 18;
+   r19 = 19;
+   r20 = 20;
+   r21 = 21;
+   r22 = 22;
+   r23 = 23;
+   r24 = 24;
+   r25 = 25;
+   r26 = 26;
+   r27 = 27;
+   r28 = 28;
+   r29 = 29;
+   r30 = 30;
+   r31 = 31;
+   r32 = 32;
+   r33 = 33;
+   r34 = 34;
+   r35 = 35;
+   r36 = 36;
+   r37 = 37;
+   r38 = 38;
+
+   d[0] = &r01 - &r00;
+   d[1] = &r02 - &r01;
+   d[2] = &r03 - &r02;
+   d[3] = &r05 - &r03;
+   d[4] = &r07 - &r05;
+   d[5] = &r09 - &r07;
+   d[6] = &r11 - &r09;
+   d[7] = &r13 - &r11;
+   d[8] = &r15 - &r13;
+   d[9] = &r17 - &r15;
+   d[10] = &r19 - &r17;
+   d[11] = &r21 - &r19;
+   d[12] = &r23 - &r21;
+   d[13] = &r25 - &r23;
+   d[14] = &r27 - &r25;
+   d[15] = &r29 - &r27;
+   d[16] = &r31 - &r29;
+   d[17] = &r33 - &r31;
+   d[18] = &r35 - &r33;
+   d[19] = &r36 - &r35;
+   d[20] = &r37 - &r36;
+   d[21] = &r38 - &r37;
+
+/*   The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs,
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable.              */
+
+   n1 = d[0];
+   s = 1;
+
+   for (j=0; j<22; j++)
+     switch (s) {
+       case 1: if (d[j] != n1) {
+                n2 = d[j];
+                s = 2;
+                nr = 1;
+               }
+               break;
+       case 2: if (d[j] == n1) {
+                s = 3;
+                break;
+               }
+               if (d[j] == n2) {
+                nr = nr+1;
+                break;
+               }
+               s = 4;
+               break;
+       case 3: if (d[j] != n1) s = 4;
+               break;
+     }
+   ;
+
+   if (s == 3) return 16-nr;
+   else return -1;
+}
+regp() {     /*   pointer to register assignment   */
+/*   Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be
+bunched together and ordered according to one of the following
+criteria:
+
+     (a) the order in which they were defined.
+     (b) the order in which they are used.
+     (c) alphabetically.
+     (d) the order in which they appear in the compiler's
+         symbol table.
+     (e) some other way.
+
+     Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid.                                     */
+
+            int *r00;
+            int *r01;
+            int *r02;
+            int *r03;
+   register int *r04;
+            int *r05;
+   register int *r06;
+            int *r07;
+   register int *r08;
+            int *r09;
+   register int *r10;
+            int *r11;
+   register int *r12;
+            int *r13;
+   register int *r14;
+            int *r15;
+   register int *r16;
+            int *r17;
+   register int *r18;
+            int *r19;
+   register int *r20;
+            int *r21;
+   register int *r22;
+            int *r23;
+   register int *r24;
+            int *r25;
+   register int *r26;
+            int *r27;
+   register int *r28;
+            int *r29;
+   register int *r30;
+            int *r31;
+   register int *r32;
+            int *r33;
+   register int *r34;
+            int *r35;
+            int *r36;
+            int *r37;
+            int *r38;
+
+   int s, n1, n2, nr, j, d[22];
+
+   r00 = (int *)&r00;
+   r01 = (int *)&r01;
+   r02 = (int *)&r02;
+   r03 = (int *)&r03;
+   r04 = (int *)&r05;
+   r05 = (int *)&r05;
+   r06 = (int *)&r07;
+   r07 = (int *)&r07;
+   r08 = (int *)&r09;
+   r09 = (int *)&r09;
+   r10 = (int *)&r11;
+   r11 = (int *)&r11;
+   r12 = (int *)&r13;
+   r13 = (int *)&r13;
+   r14 = (int *)&r15;
+   r15 = (int *)&r15;
+   r16 = (int *)&r17;
+   r17 = (int *)&r17;
+   r18 = (int *)&r19;
+   r19 = (int *)&r19;
+   r20 = (int *)&r21;
+   r21 = (int *)&r21;
+   r22 = (int *)&r23;
+   r23 = (int *)&r23;
+   r24 = (int *)&r25;
+   r25 = (int *)&r25;
+   r26 = (int *)&r27;
+   r27 = (int *)&r27;
+   r28 = (int *)&r29;
+   r29 = (int *)&r29;
+   r30 = (int *)&r31;
+   r31 = (int *)&r31;
+   r32 = (int *)&r33;
+   r33 = (int *)&r33;
+   r34 = (int *)&r35;
+   r35 = (int *)&r35;
+   r36 = (int *)&r36;
+   r37 = (int *)&r37;
+   r38 = (int *)&r38;
+
+   d[0] = &r01 - &r00;
+   d[1] = &r02 - &r01;
+   d[2] = &r03 - &r02;
+   d[3] = &r05 - &r03;
+   d[4] = &r07 - &r05;
+   d[5] = &r09 - &r07;
+   d[6] = &r11 - &r09;
+   d[7] = &r13 - &r11;
+   d[8] = &r15 - &r13;
+   d[9] = &r17 - &r15;
+   d[10] = &r19 - &r17;
+   d[11] = &r21 - &r19;
+   d[12] = &r23 - &r21;
+   d[13] = &r25 - &r23;
+   d[14] = &r27 - &r25;
+   d[15] = &r29 - &r27;
+   d[16] = &r31 - &r29;
+   d[17] = &r33 - &r31;
+   d[18] = &r35 - &r33;
+   d[19] = &r36 - &r35;
+   d[20] = &r37 - &r36;
+   d[21] = &r38 - &r37;
+
+/*   The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs,
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable.              */
+
+   n1 = d[0];
+   s = 1;
+   for (j=0; j<22; j++)
+     switch (s) {
+       case 1: if (d[j] != n1) {
+                n2 = d[j];
+                s = 2;
+                nr = 1;
+               }
+               break;
+       case 2: if (d[j] == n1) {
+                s = 3;
+                break;
+               }
+               if (d[j] == n2) {
+                nr = nr+1;
+                break;
+               }
+               s = 4;
+               break;
+       case 3: if (d[j] != n1) s = 4;
+               break;
+     }
+   ;
+
+   if (s == 3) return 16-nr;
+   else return -1;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s81(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq84.c
+++ b/test/val/cq84.c
@@ -0,0 +1,268 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 8.4: meaning of declarators
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#ifdef NO_SLOPPY_EXTERN
+   int *fip(int x);
+   int array(int a[],int size,int start);
+   int glork(int x);
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s84(pd0)          /*  8.4 Meaning of declarators   */
+struct defs *pd0;
+{
+#else
+int s84(struct defs *pd0){
+#endif
+#ifndef NO_SLOPPY_EXTERN
+   int *ip, i, *fip(), (*pfi)(), j, k, array(), glork();
+#else
+   int *ip, i, j, k,(*pfi)();
+/*
+   extern int
+   *fip(),
+   array(),
+   glork();
+   int *fip(int x);
+   int array(int a[],int size,int start);
+*/
+#endif
+   static int x3d[3][5][7];
+   #ifndef NO_FLOATS
+   float fa[17], *afp[17], sum;
+   #else
+   signed fa[17], *afp[17], sum;
+   #endif
+   static char s84er[] = "s84,er%d\n";
+   static char qs84[8] = "s84    ";
+   int rc;
+   char *ps, *pt;
+   ps = qs84;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* The more common varieties of declarators have al-
+        ready been touched upon, some more than others. It
+        is useful to compare *fip() and (*pfi)().
+                                                                */
+
+   ip = fip(3);
+   if(*ip != 3){
+     if(pd0->flgd != 0) printf(s84er,1);
+     rc = rc+1;
+   }
+
+   /* kludges */
+   #if defined(FORCE_POINTERS) | defined(NO_OLD_FUNC_DECL)
+   if(glork(4) != 4){
+     if(pd0->flgd != 0) printf(s84er,2);
+     rc = rc+2;
+   }
+	#else
+   pfi = glork;
+   if((*pfi)(4) != 4){
+     if(pd0->flgd != 0) printf(s84er,2);
+     rc = rc+2;
+   }
+	#endif
+
+        /* Float fa[17] declares an array of floating point
+        numbers, and *afp[17] declares an array of pointers
+        to floats.
+                                                                */
+
+   for(j=0; j<17; j++){
+     fa[j] = j;
+     afp[j] = &fa[j];
+   }
+
+   #ifndef NO_FLOATS
+   sum = 0.;
+   #else
+   sum = 0;
+   #endif
+   for(j=0; j<17; j++) sum += *afp[j];
+   if(sum != 136){
+     if(pd0->flgd != 0) printf(s84er,4);
+     rc = rc+4;
+   }
+
+        /*  static int x3d[3][5][7] declares a static three
+        dimensional array of integers, with rank 3x5x7.
+        In complete detail, x3d is an array of three items;
+        each item is an array of five arrays, and each of
+        the latter arrays is an array of seven integers.
+        Any of the expressions x3d, x3d[i], x3d[i][j],
+        and x3d[i][j][k] may reasonably appear in an express-
+        ion. The first three have type "array"; the last has
+        type int.
+                                                                */
+
+   for (i=0; i<3; i++)
+     for (j=0; j<5; j++)
+       for (k=0; k<7; k++)
+         x3d[i][j][k] = i*35+j*7+k;
+
+   i = 1; j = 2; k = 3;
+
+   /* kludges */
+   #if defined(FORCE_POINTERS) | defined(NO_OLD_FUNC_DECL)
+   if( array((int*)x3d,105,0)
+      +array((int*)x3d[i],35,35)
+   #else
+   if( array(x3d,105,0)
+      +array(x3d[i],35,35)
+   #endif
+      +array(x3d[i][j],7,49)
+      +      x3d[i][j][k]-52){
+      if(pd0->flgd != 0) printf(s84er,8);
+      rc = rc+8;
+   }
+
+   return rc;
+}
+
+#ifndef NO_OLD_FUNC_DECL
+array(a,size,start)
+int a[],size,start;
+#else
+int array(int a[],int size,int start)
+#endif
+{
+/*
+#ifndef NO_OLD_FUNC_DECL
+array(a,size,start)
+int a[],
+#else
+int array(int a[],
+#endif
+#ifdef NO_TYPELESS_INT
+int
+#endif
+#ifdef NO_TYPELESS_INT
+int
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+start; {
+#else
+start){
+#endif
+*/
+   int i;
+   for(i=0; i<size; i++)
+     if(a[i] != i+start) return 1;
+
+   return 0;
+}
+#ifndef NO_OLD_FUNC_DECL
+int *fip(x)
+int x;
+{
+#else
+int *fip(int x){
+#endif
+   static int y;
+   y = x;
+   return &y;
+}
+#ifndef NO_OLD_FUNC_DECL
+glork(x)
+int x;
+{
+#else
+int glork(int x){
+#endif
+return x;}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s84(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq85.c
+++ b/test/val/cq85.c
@@ -0,0 +1,313 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 8.5: Structure and Union declarations
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#ifndef NO_OLD_FUNC_DECL
+s85(pd0)          /*  8.5 Structure and union declarations   */
+struct defs *pd0;
+{
+#else
+int s85(struct defs *pd0){
+#endif
+   static char s85er[] = "s85,er%d\n";
+   static char qs85[8] = "s85    ";
+   int rc;
+   char *ps, *pt;
+
+   struct tnode {
+     char tword[20];
+     int count;
+     struct tnode *left;
+     struct tnode *right;
+   };
+
+   struct tnode s1, s2, *sp;
+
+   struct{
+     char cdummy;
+     char c;
+   } sc;
+
+   struct{
+     char cdummy;
+     short s;
+   } ss;
+
+   struct{
+     char cdummy;
+     int i;
+   } si;
+
+   struct{
+     char cdummy;
+     long l;
+   } sl;
+
+   struct{
+     char cdummy;
+     unsigned u;
+   } su;
+
+   struct{
+     char cdummy;
+     #ifndef NO_FLOATS
+     float f;
+     #else
+     signed f;
+     #endif
+   } sf;
+
+   struct{
+     char cdummy;
+     #ifndef NO_FLOATS
+     double d;
+     #else
+     signed d;
+     #endif
+   } sd;
+
+   int diff[7], j;
+
+   static char *type[] = {
+     "char",
+     "short",
+     "int",
+     "long",
+     "unsigned",
+     #ifdef NO_FLOATS
+     "signed",
+     "signed",
+	 #else
+     "float",
+     "double"
+	 #endif
+   };
+
+   static char aln[] = " alignment: ";
+
+   #ifndef NO_BITFIELDS
+   struct{
+     int twobit:2;
+     int       :1;
+     int threebit:3;
+     int onebit:1;
+   } s3;
+   #else
+   struct{
+     unsigned char twobit;
+     unsigned char threebit;
+     unsigned char onebit;
+   } s3;
+   #endif
+
+   union{
+     char u1[30];
+     short u2[30];
+     int u3[30];
+     long u4[30];
+     unsigned u5[30];
+     #ifndef NO_FLOATS
+     float u6[30];
+     double u7[30];
+     #else
+     signed u6[30];
+     signed u7[30];
+     #endif
+   } u0;
+
+   ps = qs85;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* Within a structure, the objects declared have
+        addresses which increase as their declarations are
+        read left to right.
+                                                                */
+
+   if( (char *)&s1.count - &s1.tword[0] <= 0
+     ||(char *)&s1.left - (char *)&s1.count <= 0
+     ||(char *)&s1.right - (char *)&s1.left <= 0){
+     if(pd0->flgd != 0) printf(s85er,1);
+     rc = rc+1;
+   }
+
+        /* Each non-field member of a structure begins on an
+        addressing boundary appropriate to its type.
+                                                                */
+
+   diff[0] = &sc.c - &sc.cdummy;
+   diff[1] = (char *)&ss.s - &ss.cdummy;
+   diff[2] = (char *)&si.i - &si.cdummy;
+   diff[3] = (char *)&sl.l - &sl.cdummy;
+   diff[4] = (char *)&su.u - &su.cdummy;
+   diff[5] = (char *)&sf.f - &sf.cdummy;
+   diff[6] = (char *)&sd.d - &sd.cdummy;
+
+   if(pd0->flgm != 0)
+    for(j=0; j<7; j++)
+     printf("%s%s%d\n",type[j],aln,diff[j]);
+
+        /* Field specifications are highly implementation de-
+        pendent. About the only thing we can do here is to
+        check is that the compiler accepts the field constructs,
+        and that they seem to work, after a fashion, at
+        run time...
+                                                                */
+
+   s3.threebit = 7;
+   s3.twobit = s3.threebit;
+   s3.threebit = s3.twobit;
+
+   if(s3.threebit != 3){
+     if(s3.threebit == -1){
+       if(pd0->flgm != 0) printf("Sign extension in fields\n");
+     }
+     else{
+   	   #ifdef NO_BITFIELDS
+       		if(pd0->flgd != 0) printf("NO_BITFIELDS\n");
+	   #else
+       		if(pd0->flgd != 0) printf(s85er,2);
+       		rc = rc+2;
+	   #endif
+     }
+   }
+
+   s3.onebit = 1;
+   if(s3.onebit != 1){
+     if(pd0->flgm != 0)
+      printf("Be especially careful with 1-bit fields!\n");
+   }
+
+        /* A union may be thought of as a structure all of whose
+        members begin at offset 0 and whose size is sufficient
+        to contain any of its members.
+                                                                */
+
+   if( (char *)u0.u1 - (char *)&u0 != 0
+     ||(char *)u0.u2 - (char *)&u0 != 0
+     ||(char *)u0.u3 - (char *)&u0 != 0
+     ||(char *)u0.u4 - (char *)&u0 != 0
+     ||(char *)u0.u5 - (char *)&u0 != 0
+     ||(char *)u0.u6 - (char *)&u0 != 0
+     ||(char *)u0.u7 - (char *)&u0 != 0){
+     if(pd0->flgd != 0) printf(s85er,4);
+     rc = rc+4;
+   }
+
+   if( sizeof u0 < sizeof u0.u1
+     ||sizeof u0 < sizeof u0.u2
+     ||sizeof u0 < sizeof u0.u3
+     ||sizeof u0 < sizeof u0.u4
+     ||sizeof u0 < sizeof u0.u5
+     ||sizeof u0 < sizeof u0.u6
+     ||sizeof u0 < sizeof u0.u7){
+     if(pd0->flgd != 0) printf(s85er,8);
+     rc = rc+8;
+   }
+
+        /* Finally, we check that the pointers work.            */
+
+   s1.right = &s2;
+   s2.tword[0] = 2;
+   s1.right->tword[0] += 1;
+   if(s2.tword[0] != 3){
+     if(pd0->flgd != 0) printf(s85er,16);
+     rc = rc+16;
+   }
+   return rc;
+}
+
+#ifdef NO_LOCAL_PROTOTYPES
+int one();
+#endif
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s85(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq86.c
+++ b/test/val/cq86.c
@@ -0,0 +1,228 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 8.6: Initialization
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#ifdef NO_LOCAL_PROTOTYPES
+int one();
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s86(pd0)          /*  8.6 Initialization  */
+struct defs *pd0;
+{
+#else
+int s86(struct defs *pd0){
+#endif
+   static char s86er[] = "s86,er%d\n";
+   static char qs86[8] = "s86    ";
+   int lrc, rc;
+   char *ps, *pt;
+   #ifndef NO_LOCAL_PROTOTYPES
+   int one();
+   #endif
+   int i, j, k;
+   static int x[] = {1,3,5};
+   static int *pint = x+2;
+   static int zero[10];
+   int *apint = pint-1;
+   register int *rpint = apint+one();
+
+   #ifndef NO_FLOATS
+   static float y0[] = {1,3,5,2,4,6,3,5,7,0,0,0};
+   static float y1[4][3] = {
+     {1,3,5},
+     {2,4,6},
+     {3,5,7},
+   };
+   static float y2[4][3] = {1,3,5,2,4,6,3,5,7};
+   static float y3[4][3] = {
+     {1},{2},{3},{4}
+   };
+   #else
+   static signed y0[] = {1,3,5,2,4,6,3,5,7,0,0,0};
+   static signed y1[4][3] = {
+     {1,3,5},
+     {2,4,6},
+     {3,5,7},
+   };
+   #ifndef NO_SLOPPY_STRUCT_INIT
+   static signed y2[4][3] = {1,3,5,2,4,6,3,5,7};
+   #else
+   static signed y2[4][3] = {{1,3,5},{2,4,6},{3,5,7}};
+   #endif
+   static signed y3[4][3] = {
+     {1},{2},{3},{4}
+   };
+   #endif
+
+   ps = qs86;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* The expression in an initializer for a static or
+        external variable must be a constant expression or
+        an expression that reduces to the address of a pre-
+        viously declared variable, possibly offset by a
+        constant expression.
+                                                                */
+
+   if(*pint != 5){
+     if(pd0->flgd != 0) printf(s86er,1);
+     rc = rc+1;
+   }
+
+        /* Automatic and register variables may be initialized
+        by arbitrary expressions involving constants and previously
+        declared variables and functions.
+                                                                */
+
+   if(*apint != 3){
+     if(pd0->flgd != 0) printf(s86er,2);
+     rc = rc+2;
+   }
+
+   if(*rpint != 5){
+     if(pd0->flgd != 0) printf(s86er,4);
+     rc = rc+4;
+   }
+
+        /* Static variables that are not initialized are guar-
+        anteed to start off as zero.
+                                                        */
+
+   lrc = 0;
+   for(j=0; j<10; j++)
+     if(zero[j] != 0) lrc = 1;
+   if(lrc != 0){
+     if(pd0->flgd != 0) printf(s86er,8);
+     rc = rc+8;
+   }
+
+        /* y0, y1, and y2, as declared, should define and
+        initialize identical arrays.
+                                                                */
+   lrc = 0;
+   for(i=0; i<4; i++)
+     for(j=0; j<3; j++){
+       k = 3*i+j;
+       if( y1[i][j] != y2[i][j]
+         ||y1[i][j] != y0[k]) lrc = 1;
+     }
+
+   if(lrc != 0){
+     if(pd0->flgd != 0) printf(s86er,16);
+     rc = rc+16;
+   }
+
+        /* y3 initializes the first column of the array and
+        leaves the rest zero.
+                                                                */
+
+   lrc = 0;
+   for(j=0; j<4; j++) if(y3[j][0] != j+1) lrc = 1;
+
+   if(lrc != 0){
+     if(pd0->flgd != 0) printf(s86er,32);
+     rc = rc+32;
+   }
+   return rc;
+}
+#ifndef NO_OLD_FUNC_DECL
+one(){
+#else
+int one(){
+#endif
+   return 1;
+}
+int *metricp;
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s86(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq88.c
+++ b/test/val/cq88.c
@@ -0,0 +1,184 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 8.8: typedef
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+one(){
+   return 1;
+}
+int *metricp;
+#ifndef NO_OLD_FUNC_DECL
+s88(pd0)          /*  8.8 Typedef  */
+struct defs *pd0;
+{
+#else
+int s88(struct defs *pd0){
+#endif
+   static char s88er[] = "s88,er%d\n";
+   static char qs88[8] = "s88    ";
+   int rc;
+   char *ps, *pt;
+
+        /* Declarations whose "storage class" is typdef do not
+        define storage, but instead define identifiers which
+        can later be used as if they were type keywords naming
+        fundamental or derived types.
+                                                                */
+
+   typedef int MILES, *KLICKSP;
+
+   #ifndef NO_FLOATS
+   typedef struct {double re, im;} complex;
+   #else
+   typedef struct {signed re, im;} complex;
+   #endif
+
+   MILES distance;
+   #ifndef NO_SLOPPY_EXTERN
+   extern KLICKSP metricp;
+   #else
+   KLICKSP metricp;
+   #endif
+   complex z, *zp;
+
+   ps = qs88;
+   pt = pd0->rfs;
+   rc = 0;
+   while(*pt++ = *ps++);
+
+        /* Hopefully, all of this stuff will compile. After that,
+        we can only make some superficial tests.
+
+        The type of distance is int,
+                                                                */
+
+   if(sizeof distance != sizeof(int)){
+     if(pd0->flgd != 0) printf(s88er,1);
+     rc = rc+1;
+   }
+
+        /* that of metricp is "pointer to int",                 */
+
+   metricp = &distance;
+   distance = 2;
+   *metricp = 3;
+
+   if(distance != 3){
+     if(pd0->flgd != 0) printf(s88er,2);
+     rc = rc+2;
+   }
+
+        /* and that of z is the specified structure. zp is a
+        pointer to such a structure.
+                                                                */
+
+   #ifndef NO_FLOATS
+   z.re = 0.;
+   z.im = 0.;
+   zp = &z;
+   zp->re = 1.;
+   zp->im = 1.;
+   if(z.re+z.im != 2.){
+   #else
+   z.re = 0;
+   z.im = 0;
+   zp = &z;
+   zp->re = 1;
+   zp->im = 1;
+   if(z.re+z.im != 2){
+   #endif
+     if(pd0->flgd != 0) printf(s88er,4);
+     rc = rc+4;
+   }
+
+   return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s88(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+	
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/cq9.c
+++ b/test/val/cq9.c
@@ -0,0 +1,154 @@
+/*
+  !!DESCRIPTION!! C-Manual Chapter 9: Statements
+  !!ORIGIN!!      LCC 4.1 Testsuite
+  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+};
+
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     #ifndef NO_FLOATS
+        float fprec;        /* Smallest number that can be    */
+        float dprec;        /* significantly added to 1.      */
+     #endif
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+
+#ifndef NO_OLD_FUNC_DECL
+s9(pd0)          /*  9  Statements  */
+struct defs *pd0;
+{
+#else
+int s9(struct defs *pd0){
+#endif
+   static char s9er[] = "s9,er%d\n";
+   static char qs9[8] = "s9     ";
+   int rc;
+   char *ps, *pt;
+   int lrc, i;
+
+   ps = qs9;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* One would think that the section on statements would
+        provide the most variety in the entire sequence of tests.
+        As it turns out, most of the material in this section has
+        already been checked in the process of checking out
+        everything else, and the section at this point is somewhat
+        anticlimactic. For this reason, we restrict ourselves
+        to testing two features not already covered.
+
+        Compound statements are delimited by braces. They have the
+        nice property that identifiers of the auto and register
+        variety are pushed and popped. It is currently legal to
+        transfer into a block, but we wont...
+                                                                */
+
+   lrc = 0;
+   for(i=0; i<2; i++){
+     int j;
+     register int k;
+     j = k = 2;
+       {
+       int j;
+       register int k;
+       j = k = 3;
+       if((j != 3) || (k != 3)) lrc = 1;
+       }
+     if((j != 2) || (k != 2)) lrc = 1;
+   }
+
+   if(lrc != 0){
+     if(pd0->flgd != 0) printf(s9er,1);
+     rc = rc+1;
+   }
+
+        /* Goto statements go to labeled statements, we hope.   */
+
+   goto nobarf;
+     if(pd0->flgd != 0) printf(s9er,2);
+     rc = rc+2;
+   nobarf:;
+
+   return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+	int section(int j,struct* pd0){
+#else
+	int section(int j,void* pd0){
+#endif
+        switch(j){
+                case 0: return s9(pd0);
+        }
+}
+
+#define cq_sections 1
+
+/*
+        C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+   d0.flgs = 1;          /* These flags dictate            */
+   d0.flgm = 1;          /*     the verbosity of           */
+   d0.flgd = 1;          /*         the program.           */
+   d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<cq_sections; j++) {
+     d0.rrc=section(j,pd0);
+     d0.crc=d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+
+   return d0.crc;
+}
--- a/test/val/for.c
+++ b/test/val/for.c
@@ -0,0 +1,109 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void for1(void)
+{
+  unsigned char i=0;
+
+  for(i=0; i<10; i++)
+    uchar0++;
+
+  if(uchar0 != 10)
+    failures++;
+}
+
+void for2(void)
+{
+  unsigned char i=0;
+
+  for(i=0; i<10; i++)
+    uchar0++;
+
+  if(i < 10)
+    failures++;
+}
+
+void for3(void)
+{
+  unsigned int i=0;
+
+  for(i=0; i<10; i++)
+    uint0++;
+
+  if(i < 10)
+    failures++;
+}
+
+void for4(void)
+{
+  for(uint0=1; uint0<10; uint0++)
+    uchar0++;
+
+  if(uchar0 != 9)
+    failures++;
+}
+
+void for5(void)
+{
+  for(uint0=1; uint0<=10; uint0++)
+    uchar0++;
+
+  if(uchar0 != 10)
+    failures++;
+}
+
+void inc_uchar0(void)
+{
+  uchar0++;
+}
+
+void for6(void)
+{
+  uchar0 = 0;
+  for(uint0=1; uint0<=10; uint0++)
+    inc_uchar0();
+}
+
+int main(void)
+{
+  for1();
+  for2();
+  for3();
+  uchar0 = 0;
+  for4();
+  uchar0 = 0;
+  for5();
+
+  for6();
+  if(uchar0 != 10)
+    failures++;
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/mult1.c
+++ b/test/val/mult1.c
@@ -0,0 +1,117 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+#define TESTLIT 0x05
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+signed char c1,c2,c3;
+unsigned char uc1,uc2,uc3;
+
+unsigned int ui1,ui2,ui3;
+signed int i1,i2;
+
+void done()
+{
+  dummy++;
+}
+
+void m1(void)
+{
+  c1 = c1*5;       /* char = char * lit */
+
+  c2 = c1 *c3;     /* char = char * char */
+
+  uc1= uc1*5;      /* uchar = uchar * lit *
+  uc2=uc1*uc3;     /* uchar = uchar * uchar */
+
+  if(c2 != 25)
+    failures++;
+}
+
+void m2(unsigned char uc)
+{
+  uc2 = uc1 * uc;
+
+  if(uc2 != 0x20)
+    failures++;
+}
+
+void m3(unsigned char uc)
+{
+  volatile unsigned char vuc;
+  
+  /* uchar = uchar * lit */
+  /* testing literal multiply with same source and destination */
+  vuc = uc;
+  uc2 = 0;   
+  uc1 = vuc; uc1 = uc1*1; if( uc1 != (uc2+=TESTLIT) ) failures++; 
+  uc1 = vuc; uc1 = uc1*2; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*3; if( uc1 != (uc2+=TESTLIT) ) failures++;     
+  uc1 = vuc; uc1 = uc1*4; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*5; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*6; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*7; if( uc1 != (uc2+=TESTLIT) ) failures++;     
+  uc1 = vuc; uc1 = uc1*8; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*9; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*10; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*11; if( uc1 != (uc2+=TESTLIT) ) failures++;     
+  uc1 = vuc; uc1 = uc1*12; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*13; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*14; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*15; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*16; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*17; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*18; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*19; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*20; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*21; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*22; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*23; if( uc1 != (uc2+=TESTLIT) ) failures++;  
+  uc1 = vuc; uc1 = uc1*24; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  
+  uc1 = vuc; uc1 = uc1*31; if( uc1 != ((31*TESTLIT) & 0xff) ) failures++;
+  uc1 = vuc; uc1 = uc1*32; if( uc1 != ((32*TESTLIT) & 0xff) ) failures++;
+  uc1 = vuc; uc1 = uc1*64; if( uc1 != ((64*TESTLIT) & 0xff) ) failures++;
+  uc1 = vuc; uc1 = uc1*128;if( uc1 != ((128*TESTLIT)& 0xff) ) failures++;
+
+  /* testing literal multiply with different source and destination */
+  uc1 = vuc*1; if( uc1 != ((1*TESTLIT) & 0xff) ) failures++;    
+  uc1 = vuc*2; if( uc1 != ((2*TESTLIT) & 0xff) ) failures++;    
+  uc1 = vuc*4; if( uc1 != ((4*TESTLIT) & 0xff) ) failures++;
+}
+
+int  main(void)
+{
+  dummy = 0;
+
+  c1 = 1;
+  c3 = 5;
+
+  m1();
+
+  uc1 = 0x10;
+  m2(2);
+
+  ui1 = uc1*uc2;   /* uint = uchar * uchar */
+
+  i1 = c1*c2;      /* int = char * char */
+
+  ui3 = ui1*ui2;   /* uint = uint * unit */
+
+  /*m3(TESTLIT);*/
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/nestfor.c
+++ b/test/val/nestfor.c
@@ -0,0 +1,151 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+
+void dput(unsigned char val)
+{
+	/*PORTB = val;
+	PORTA = 0x01;
+	PORTA = 0x00;
+	*/
+}
+
+void done()
+{
+  dummy++;
+}
+
+/* both loops use the loop variable inside the inner loop */
+void for1(void)
+{
+	unsigned char i, j;
+
+	uchar0 = 0;
+	uchar1 = 0;
+	for(i = 0; i < 3; i++) {
+		uchar0++;
+		for(j = 0; j < 4; j++) {
+			uchar1++;
+			dput(i);
+			dput(j);
+		}
+	}
+	if(uchar0 != 3)
+		failures++;
+	if(uchar1 != 12)
+		failures++;
+}
+
+/* only the outer loop's variable is used inside, inner can be optimized into a repeat-loop */
+void for2(void)
+{
+	unsigned char i, j;
+
+	uchar0 = 0;
+	uchar1 = 0;
+	for(i = 0; i < 3; i++) {
+		uchar0++;
+		for(j = 0; j < 4; j++) {
+			uchar1++;
+			dput(i);
+		}
+	}
+	if(uchar0 != 3)
+		failures++;
+	if(uchar1 != 12)
+		failures++;
+}
+
+/* only the inner loop's variable is used inside */
+void for3(void)
+{
+	unsigned char i, j;
+
+	uchar0 = 0;
+	uchar1 = 0;
+	for(i = 0; i < 3; i++) {
+		uchar0++;
+		for(j = 0; j < 4; j++) {
+			uchar1++;
+			dput(j);
+		}
+	}
+	if(uchar0 != 3)
+		failures++;
+	if(uchar1 != 12)
+		failures++;
+}
+
+/* neither loop variable used inside the loops */
+void for4(void)
+{
+	unsigned char i, j;
+
+	uchar0 = 0;
+	uchar1 = 0;
+	for(i = 0; i < 3; i++) {
+		uchar0++;
+		for(j = 0; j < 4; j++) {
+			uchar1++;
+			dput(uchar0);
+			dput(uchar1);
+		}
+	}
+	if(uchar0 != 3)
+		failures++;
+	if(uchar1 != 12)
+		failures++;
+}
+
+/* like for1 but different condition in inner loop */
+void for5(void)
+{
+	unsigned char i, j;
+
+	uchar0 = 0;
+	uchar1 = 0;
+	for(i = 0; i < 3; i++) {
+		uchar0++;
+		for(j = 10; j >= 5; j--) {
+			uchar1++;
+			dput(i);
+			dput(j);
+		}
+	}
+	if(uchar0 != 3)
+		failures++;
+	if(uchar1 != 18)
+		failures++;
+}
+
+int  main(void)
+{
+  for1();
+  for2();
+  for3();
+  for4();
+  for5();
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/or1.c
+++ b/test/val/or1.c
@@ -0,0 +1,192 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#if SUPPORT_BIT_TYPES
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+#endif
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+/* uchar0 = 0; */
+void or_lit2uchar(void)
+{
+  if(uchar0)
+    failures++;
+
+  uchar0 |= 1;
+
+  if(uchar0 != 1)
+    failures++;
+
+  uchar0 |= 2;
+
+  if(uchar0 != 3)
+    failures++;
+
+  uchar0 |= 0x0e;
+
+  if(uchar0 != 0x0f)
+    failures++;
+}
+
+void or_lit2uint(void)
+{
+  if(uint0)
+    failures++;
+
+  uint0 |= 1;
+  if(uint0 != 1) 
+    failures++;
+
+  uint0 |= 2;
+  if(uint0 != 3) 
+    failures++;
+
+  uint0 |= 0x100;
+  if(uint0 != 0x103) 
+    failures++;
+
+  uint0 |= 0x102;
+  if(uint0 != 0x103) 
+    failures++;
+
+  uint0 |= 0x303;
+  if(uint0 != 0x303) 
+    failures++;
+}
+
+void or_lit2ulong(void)
+{
+  if(ulong0)
+    failures++;
+
+  ulong0 |= 1;
+  if(ulong0 != 1) 
+    failures++;
+
+  ulong0 |= 2;
+  if(ulong0 != 3) 
+    failures++;
+
+  ulong0 |= 0x100;
+  if(ulong0 != 0x103) 
+    failures++;
+
+  ulong0 |= 0x102;
+  if(ulong0 != 0x103) 
+    failures++;
+
+  ulong0 |= 0x303;
+  if(ulong0 != 0x303) 
+    failures++;
+
+  ulong0 |= 0x80000000;
+  if(ulong0 != 0x80000303) 
+    failures++;
+}
+
+/*-----------*/
+void or_uchar2uchar(void)
+{
+  uchar0 |= uchar1;
+
+  if(uchar0 != 1)
+    failures++;
+
+  uchar1 |= 0x0f;
+
+  uchar0 = uchar1 | 0x10;
+
+  if(uchar0 != 0x1f)
+    failures++;
+}
+
+void or_uint2uint(void)
+{
+  uint0 |= uint1;
+
+  if(uint0 != 1)
+    failures++;
+
+  uint1 |= 0x0f;
+
+  uint0 = uint1 | 0x10;
+
+  if(uint0 != 0x1f)
+    failures++;
+}
+
+#if SUPPORT_BIT_TYPES
+
+void or_bits1(void)
+{
+  bit0 = bit0 | bit1 | bit2;
+}
+
+void or_bits2(void)
+{
+  bit0 = bit1 | bit2;
+}
+#endif
+
+int  main(void)
+{
+  or_lit2uchar();
+  or_lit2uint();
+  or_lit2ulong();
+
+  uchar0=0;
+  uchar1=1;
+  or_uchar2uchar();
+
+  uint0=0;
+  uint1=1;
+  or_uint2uint();
+
+#if SUPPORT_BIT_TYPES
+  or_bits1();
+  if(bit0)
+    failures++;
+
+  or_bits2();
+  if(bit0)
+    failures++;
+
+  bit1=1;
+  or_bits1();
+  if(!bit0)
+    failures++;
+
+  or_bits2();
+  if(!bit0)
+    failures++;
+#endif
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/pointer1.c
+++ b/test/val/pointer1.c
@@ -0,0 +1,134 @@
+/*
+  !!DESCRIPTION!! Pointer tests
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char *acharP = 0;
+
+char buff[10];
+
+void
+done ()
+{
+  dummy++;
+}
+
+void
+f1 (unsigned char *ucP)
+{
+  if (ucP == 0)
+    {
+      failures++;
+      return;
+    }
+
+  if (*ucP)
+    failures++;
+}
+
+void
+f2 (unsigned int *uiP)
+{
+  if (uiP == 0)
+    {
+      failures++;
+      return;
+    }
+
+  if (*uiP)
+    failures++;
+}
+
+unsigned char *
+f3 (void)
+{
+  return &achar0;
+}
+
+void f4(unsigned char *ucP, unsigned char uc)
+{
+  if(!ucP) {
+    failures++;
+    return;
+  }
+
+  if(*ucP != uc)
+    failures++;
+}
+
+void init_array(char start_value)
+{
+  unsigned char c;
+
+  for(c=0; c<sizeof(buff); c++)
+    buff[c] = start_value++;
+}
+
+void check_array(char base_value)
+{
+  unsigned char c;
+
+  for(c=0; c<sizeof(buff); c++)
+    if(buff[c] != (base_value+c))
+      failures++;
+}
+
+void index_by_pointer(unsigned char *index, unsigned char expected_value)
+{
+  if(buff[*index] != expected_value)
+    failures++;
+}
+
+int
+main (void)
+{
+  init_array(4);
+  check_array(4);
+
+  if(buff[achar0 + 7] != 4+7)
+    failures++;
+
+  dummy = buff[achar0];
+
+  if(dummy != 4)
+    failures++;
+
+  if(dummy != (buff[achar0+1] -1))
+    failures++;
+
+  index_by_pointer(&dummy, 8);
+
+  f1 (&achar0);
+  f2 (&aint0);
+
+  acharP = f3 ();
+  if ((acharP == 0) || (*acharP))
+    failures++;
+  achar0 = 42;
+  if(*acharP != 42)
+    failures++;
+
+  achar0 = 5;
+  f4(&achar0, achar0);
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/ptrfunc.c
+++ b/test/val/ptrfunc.c
@@ -0,0 +1,136 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+
+/*
+ * BUG: if these aren't volatile, an overzealous optimizer or somthing
+ * wreaks havoc with the simple tests like "if(uchar != 3)failures++"
+ */
+
+#if 0
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned char uchar2 = 0;
+#else
+volatile unsigned char uchar0 = 0;
+volatile unsigned char uchar1 = 0;
+volatile unsigned char uchar2 = 0;
+#endif
+
+#ifdef NO_IMPLICIT_FUNCPTR_CONV
+void (*pfunc)(void);
+void (*p1func)(void);
+unsigned char (*pcfunc)(void);
+#else
+void (*pfunc)();
+void (*p1func)();
+unsigned char (*pcfunc)();
+#endif
+
+void done()
+{
+  dummy++;
+}
+
+void call0(void)
+{
+	uchar0++;
+}
+
+void call1(void)
+{
+	uchar1++;
+}
+
+unsigned char call2(void)
+{
+	return uchar0 + 9;
+}
+
+void docall0(void)
+{
+	pfunc = call0;
+	(pfunc)();
+	if(uchar0 != 1)
+		failures++;
+}
+
+void docall1()
+{
+	unsigned char i;
+	for(i = 0; i < 3; i++) {
+		(*p1func)();
+	}
+}
+
+#ifdef NO_IMPLICIT_FUNCPTR_CONV
+void docall2( void(*pf)(void) )
+#else
+void docall2( void(*pf)() )
+#endif
+{
+	unsigned char i;
+	for(i = 0; i < 2; i++) {
+		pf();
+	}
+}
+
+int  main(void)
+{
+    docall0();
+
+	p1func = call1;
+	docall1();
+	if(uchar1 != 3)
+		failures++;
+	if(uchar0 != 1)
+		failures++;
+
+	p1func = call0;
+	docall1();
+	if(uchar1 != 3)
+		failures++;
+	if(uchar0 != 4)
+		failures++;
+
+	docall2(call0);
+	if(uchar1 != 3)
+		failures++;
+	if(uchar0 != 6)
+		failures++;
+
+	docall2(call1);
+	if(uchar1 != 5)
+		failures++;
+	if(uchar0 != 6)
+		failures++;
+
+ 	pcfunc = call2;
+ 	uchar2 = (*pcfunc)();
+	if(uchar2 != 15)
+		failures++;
+
+ 	uchar2 += (pcfunc)();
+	uchar2 += pcfunc();
+
+	success = failures;
+	done();
+	printf("failures: %d\n",failures);
+
+	return failures;
+}
--- a/test/val/rotate1.c
+++ b/test/val/rotate1.c
@@ -0,0 +1,201 @@
+/*
+  !!DESCRIPTION!! Shift bytes left and right by a constant.
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void check(void)
+{
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_1(void)
+{
+  achar0 <<= 1;
+
+  check();
+}
+
+void shift_left_2(void)
+{
+  achar0 <<= 2;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_3(void)
+{
+  achar0 <<= 3;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_4(void)
+{
+  achar0 <<= 4;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_5(void)
+{
+  achar0 <<= 5;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_6(void)
+{
+  achar0 <<= 6;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_7(void)
+{
+  achar0 <<= 7;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_right_1(void)
+{
+  achar0 >>= 1;
+
+  check();
+}
+
+void shift_right_2(void)
+{
+  achar0 >>= 2;
+
+  check();
+}
+
+void shift_right_3(void)
+{
+  achar0 >>= 3;
+
+  check();
+}
+
+void shift_right_4(void)
+{
+  achar0 >>= 4;
+
+  check();
+}
+
+void shift_right_5(void)
+{
+  achar0 >>= 5;
+
+  check();
+}
+
+void shift_right_6(void)
+{
+  achar0 >>= 6;
+
+  check();
+}
+
+void shift_right_7(void)
+{
+  achar0 >>= 7;
+
+  check();
+}
+
+int main(void)
+{
+  /* call with both values zero */
+  shift_left_1();
+
+  achar0 = 1;
+  achar1 = 2;
+  for(achar2=0; achar2<6; achar2++) {
+    shift_left_1();
+    achar1 <<=1;
+  }
+
+  achar0 = 1;
+  achar1 = 4;
+  shift_left_2();
+
+  achar0 = 1;
+  achar1 = 8;
+  shift_left_3();
+
+  achar0 = 1;
+  achar1 = 0x10;
+  shift_left_4();
+
+  achar0 = 1;
+  achar1 = 0x20;
+  shift_left_5();
+
+  achar0 = 1;
+  achar1 = 0x40;
+  shift_left_6();
+
+  achar0 = 1;
+  achar1 = 0x80;
+  shift_left_7();
+
+  achar0 = 2;
+  achar1 = 1;
+  shift_right_1();
+
+  achar0 = 4;
+  shift_right_2();
+
+  achar0 = 8;
+  shift_right_3();
+
+  achar0 = 0x10;
+  shift_right_4();
+
+  achar0 = 0x20;
+  shift_right_5();
+
+  achar0 = 0x40;
+  shift_right_6();
+
+  achar0 = 0x80;
+  shift_right_7();
+
+  success=failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/rotate2.c
+++ b/test/val/rotate2.c
@@ -0,0 +1,71 @@
+/*
+  !!DESCRIPTION!! Shift bytes left and right by a variable.
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void shift_right_var(void)
+{
+  achar0 >>= achar1;
+}
+
+void shift_left_var(void)
+{
+  achar0 <<= achar1;
+}
+
+void shift_int_left_1(void)
+{
+  aint0 <<= 1;
+}
+
+int main(void)
+{
+  char i;
+
+  achar0 = 1;
+  achar1 = 1;
+  shift_left_var();
+
+  if(achar0 !=2)
+    failures++;
+
+  achar0 = 1;
+  achar1 = 1;
+  achar2 = 1;
+  for(i=0; i<7; i++) {
+    shift_left_var();
+    achar2 <<= 1;
+
+    if(achar2 != achar0)
+      failures++;
+  }
+
+  success=failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/rotate3.c
+++ b/test/val/rotate3.c
@@ -0,0 +1,384 @@
+/*
+  !!DESCRIPTION!! Shift ints left and right
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+unsigned short aint0 = 0;
+unsigned short aint1 = 0;
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+#endif
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+#endif
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void shift_int_left_1(void)
+{
+  aint0 <<= 1;
+}
+
+void shift_int_left_2(void)
+{
+  aint0 <<= 2;
+}
+
+void shift_int_left_3(void)
+{
+  aint0 <<= 3;
+}
+
+void shift_int_left_4(void)
+{
+  aint0 <<= 4;
+}
+
+void shift_int_left_5(void)
+{
+  aint0 <<= 5;
+}
+
+void shift_int_left_6(void)
+{
+  aint0 <<= 6;
+}
+
+void shift_int_left_7(void)
+{
+  aint0 <<= 7;
+}
+
+void shift_int_left_8(void)
+{
+  aint0 <<= 8;
+}
+
+void shift_int_left_9(void)
+{
+  aint0 <<= 9;
+}
+
+void shift_int_left_10(void)
+{
+  aint0 <<= 10;
+}
+
+void shift_int_left_11(void)
+{
+  aint0 <<= 11;
+}
+
+void shift_int_left_12(void)
+{
+  aint0 <<= 12;
+}
+
+void shift_int_left_13(void)
+{
+  aint0 <<= 13;
+}
+
+void shift_int_left_14(void)
+{
+  aint0 <<= 14;
+}
+
+void shift_int_left_15(void)
+{
+  aint0 <<= 15;
+}
+
+/*****************************************************/
+void shift_int_right_1(void)
+{
+  aint0 >>= 1;
+}
+
+void shift_int_right_2(void)
+{
+  aint0 >>= 2;
+}
+
+void shift_int_right_3(void)
+{
+  aint0 >>= 3;
+}
+
+void shift_int_right_4(void)
+{
+  aint0 >>= 4;
+}
+
+void shift_int_right_5(void)
+{
+  aint0 >>= 5;
+}
+
+void shift_int_right_6(void)
+{
+  aint0 >>= 6;
+}
+
+void shift_int_right_7(void)
+{
+  aint0 >>= 7;
+}
+
+void shift_int_right_8(void)
+{
+  aint0 >>= 8;
+}
+
+void shift_int_right_9(void)
+{
+  aint0 >>= 9;
+}
+
+void shift_int_right_10(void)
+{
+  aint0 >>= 10;
+}
+
+void shift_int_right_11(void)
+{
+  aint0 >>= 11;
+}
+
+void shift_int_right_12(void)
+{
+  aint0 >>= 12;
+}
+
+void shift_int_right_13(void)
+{
+  aint0 >>= 13;
+}
+
+void shift_int_right_14(void)
+{
+  aint0 >>= 14;
+}
+
+void shift_int_right_15(void)
+{
+  aint0 >>= 15;
+}
+
+/*****************************************************/
+int main(void)
+{
+  /*char i;*/
+  aint0 = 0xabcd;
+
+  shift_int_left_1();
+  if(aint0 != 0x579a)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_2();
+  if(aint0 != 0xaf34)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_3();
+  if(aint0 != 0x5e68)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_4();
+  if(aint0 != 0xbcd0)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_5();
+  if(aint0 != 0x79a0)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_6();
+  if(aint0 != 0xf340)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_7();
+  if(aint0 != 0xe680)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_8();
+  if(aint0 != 0xcd00)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_9();
+  if(aint0 != 0x9a00)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_10();
+  if(aint0 != 0x3400)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_11();
+  if(aint0 != 0x6800)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_12();
+  if(aint0 != 0xd000)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_13();
+  if(aint0 != 0xa000)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_14();
+  if(aint0 != 0x4000)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_15();
+  if(aint0 != 0x8000)
+    failures++;
+
+  /***********************/
+  aint0 = 0xabcd;
+
+  shift_int_right_1();
+  if(aint0 != 0x55e6)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_2();
+  if(aint0 != 0x2af3)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_3();
+  if(aint0 != 0x1579)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_4();
+  if(aint0 != 0x0abc)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_5();
+  if(aint0 != 0x055e)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_6();
+  if(aint0 != 0x02af)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_7();
+  if(aint0 != 0x0157)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_8();
+  if(aint0 != 0x00ab)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_9();
+  if(aint0 != 0x0055)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_10();
+  if(aint0 != 0x002a)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_11();
+  if(aint0 != 0x0015)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_12();
+  if(aint0 != 0x000a)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_13();
+  if(aint0 != 0x0005)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_14();
+  if(aint0 != 0x0002)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_15();
+  if(aint0 != 0x0001)
+    failures++;
+
+  success=failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/rotate4.c
+++ b/test/val/rotate4.c
@@ -0,0 +1,228 @@
+/*
+  !!DESCRIPTION!! rotate bytes left and right by a constant.
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+unsigned short aint0 = 0;
+unsigned short aint1 = 0;
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+#endif
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+#endif
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned char uchar2 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void check(void)
+{
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_left_1(void)
+{
+  uchar0 = (uchar0<<1) | (uchar0>>7);
+
+  check();
+}
+
+void rotate_left_2(void)
+{
+  uchar0 = (uchar0<<2) | (uchar0>>6);
+
+  check();
+}
+
+void rotate_left_3(void)
+{
+  uchar0 <<= 3;
+
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_left_4(void)
+{
+  uchar0 <<= 4;
+
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_left_5(void)
+{
+  uchar0 <<= 5;
+
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_left_6(void)
+{
+  uchar0 <<= 6;
+
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_left_7(void)
+{
+  uchar0 <<= 7;
+
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_right_1(void)
+{
+  uchar0 = (uchar0>>1) | (uchar0<<7);
+
+  check();
+}
+
+void rotate_right_2(void)
+{
+  uchar0 = (uchar0>>2) | (uchar0<<6);
+
+  check();
+}
+
+void rotate_right_3(void)
+{
+  uchar0 >>= 3;
+
+  check();
+}
+
+void rotate_right_4(void)
+{
+  uchar0 >>= 4;
+
+  check();
+}
+
+void rotate_right_5(void)
+{
+  uchar0 >>= 5;
+
+  check();
+}
+
+void rotate_right_6(void)
+{
+  uchar0 >>= 6;
+
+  check();
+}
+
+void rotate_right_7(void)
+{
+  uchar0 >>= 7;
+
+  check();
+}
+
+int main(void)
+{
+  /* call with both values zero */
+  rotate_left_1();
+
+  uchar0 = 1;
+  uchar1 = 2;
+
+  rotate_left_1();
+
+  uchar0 = 0x80;
+  uchar1 = 1;
+
+  rotate_left_1();
+
+  uchar1 = 2;
+  for(uchar2=0; uchar2<6; uchar2++) {
+    rotate_left_1();
+    uchar1 <<=1;
+  }
+
+  uchar0 = 1;
+  uchar1 = 4;
+  rotate_left_2();
+
+  uchar0 = 1;
+  uchar1 = 8;
+  rotate_left_3();
+
+  uchar0 = 1;
+  uchar1 = 0x10;
+  rotate_left_4();
+
+  uchar0 = 1;
+  uchar1 = 0x20;
+  rotate_left_5();
+
+  uchar0 = 1;
+  uchar1 = 0x40;
+  rotate_left_6();
+
+  uchar0 = 1;
+  uchar1 = 0x80;
+  rotate_left_7();
+
+  uchar0 = 2;
+  uchar1 = 1;
+  rotate_right_1();
+
+  uchar0 = 1;
+  uchar1 = 0x80;
+  rotate_right_1();
+
+  uchar0 = 4;
+  uchar1 = 1;
+  rotate_right_2();
+
+  uchar0 = 8;
+  rotate_right_3();
+
+  uchar0 = 0x10;
+  rotate_right_4();
+
+  uchar0 = 0x20;
+  rotate_right_5();
+
+  uchar0 = 0x40;
+  rotate_right_6();
+
+  uchar0 = 0x80;
+  rotate_right_7();
+
+  success=failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/rotate5.c
+++ b/test/val/rotate5.c
@@ -0,0 +1,260 @@
+/*
+  !!DESCRIPTION!! Shift bytes left and right by a constant.
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+signed short aint0 = 0;
+signed short aint1 = 0;
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+signed char achar0 = 0;
+signed char achar1 = 0;
+signed char achar2 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void check(void)
+{
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_1(void)
+{
+  achar0 <<= 1;
+
+  check();
+}
+
+void shift_left_2(void)
+{
+  achar0 <<= 2;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_3(void)
+{
+  achar0 <<= 3;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_4(void)
+{
+  achar0 <<= 4;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_5(void)
+{
+  achar0 <<= 5;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_6(void)
+{
+  achar0 <<= 6;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_7(void)
+{
+  achar0 <<= 7;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_right_1(void)
+{
+  achar0 >>= 1;
+
+  check();
+}
+
+void shift_right_2(void)
+{
+  achar0 >>= 2;
+
+  check();
+}
+
+void shift_right_3(void)
+{
+  achar0 >>= 3;
+
+  check();
+}
+
+void shift_right_4(void)
+{
+  achar0 >>= 4;
+
+  check();
+}
+
+void shift_right_5(void)
+{
+  achar0 >>= 5;
+
+  check();
+}
+
+void shift_right_6(void)
+{
+  achar0 >>= 6;
+
+  check();
+}
+
+void shift_right_7(void)
+{
+  achar0 >>= 7;
+
+  check();
+}
+
+int main(void)
+{
+  /* call with both values zero */
+  shift_left_1();
+  printf("failures: %d\n",failures);
+
+  achar0 = 1;
+  achar1 = 2;
+  for(achar2=0; achar2<6; achar2++) {
+    shift_left_1();
+    achar1 <<=1;
+  }
+  printf("failures: %d\n",failures);
+
+  achar0 = 1;
+  achar1 = 4;
+  shift_left_2();
+  printf("failures: %d\n",failures);
+
+  achar0 = 1;
+  achar1 = 8;
+  shift_left_3();
+  printf("failures: %d\n",failures);
+
+  achar0 = 1;
+  achar1 = 0x10;
+  shift_left_4();
+  printf("failures: %d\n",failures);
+
+  achar0 = 1;
+  achar1 = 0x20;
+  shift_left_5();
+  printf("failures: %d\n",failures);
+
+  achar0 = 1;
+  achar1 = 0x40;
+  shift_left_6();
+  printf("failures: %d\n",failures);
+
+  achar0 = 1;
+  achar1 = 0x80;
+  shift_left_7();
+  printf("failures: %d\n",failures);
+
+  achar0 = 2;
+  achar1 = 1;
+  shift_right_1();
+  printf("failures: %d\n",failures);
+
+  achar0 = 4;
+  shift_right_2();
+  printf("failures: %d\n",failures);
+
+  achar0 = 8;
+  shift_right_3();
+  printf("failures: %d\n",failures);
+
+  achar0 = 0x10;
+  shift_right_4();
+  printf("failures: %d\n",failures);
+
+  achar0 = 0x20;
+  shift_right_5();
+  printf("failures: %d\n",failures);
+
+  achar0 = 0x40;
+  shift_right_6();
+  printf("failures: %d\n",failures);
+
+  achar0 = 0xff;
+  achar1 = 0xff;
+  shift_right_1();
+  printf("failures: %d\n",failures);
+
+  achar0 = 0xfe;
+  achar1 = 0xff;
+  shift_right_1();
+  printf("failures: %d\n",failures);
+
+  achar0 = 0xfc;
+  shift_right_2();
+  printf("failures: %d\n",failures);
+
+  achar0 = 0xf8;
+  shift_right_3();
+  printf("failures: %d\n",failures);
+
+  achar0 = 0xf0;
+  shift_right_4();
+  printf("failures: %d\n",failures);
+
+  achar0 = 0xe0;
+  shift_right_5();
+  printf("failures: %d\n",failures);
+
+  achar0 = 0xc0;
+  shift_right_6();
+  printf("failures: %d\n",failures);
+
+  achar0 = 0x80;
+  achar1 = 0xff;
+  shift_right_7();
+
+  success=failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/rotate6.c
+++ b/test/val/rotate6.c
@@ -0,0 +1,158 @@
+/*
+  !!DESCRIPTION!! Shift bytes left and right by a variable.
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+signed short aint0 = 0;
+signed short aint1 = 0;
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+signed char achar0 = 0;
+signed char achar1 = 0;
+signed char achar2 = 0;
+signed char achar3 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void shift_right_var(void)
+{
+  achar0 >>= achar1;
+}
+
+void shift_left_var(void)
+{
+  achar0 <<= achar1;
+}
+
+void shift_int_left_var(void)
+{
+  aint0 <<= achar1;
+}
+
+void shift_int_right_var(void)
+{
+  aint0 >>= achar1;
+}
+
+void shift_int_right_var2(void)
+{
+  aint0 = aint1 >> achar1;
+}
+
+void shift_int_left_var2(void)
+{
+  aint0 = aint1 << achar1;
+}
+
+int
+main (void)
+{
+  char i;
+
+  achar0 = 1;
+  achar1 = 1;
+  shift_left_var();
+
+  if(achar0 !=2)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  achar0 = 1;
+  achar1 = 1;
+  achar2 = 1;
+  for(i=0; i<7; i++) {
+    shift_left_var();
+    achar2 <<= 1;
+
+    if(achar2 != achar0)
+      failures++;
+  }
+  printf("failures: %d\n",failures);
+
+  achar1 = 4;
+  achar0 = 0xf0;
+  shift_right_var();
+  if(((unsigned char)achar0) != 0xff)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 1;
+  aint1 = 1;
+  achar1 = 1;
+
+  for(i=0; i<15; i++) {
+    shift_int_left_var();
+    aint1 <<= 1;
+    if(aint0 != aint1)
+      failures++;
+  }
+  printf("failures: %d\n",failures);
+
+  aint0 = 0x4000;
+  aint1 = 0x4000;
+
+  for(i=0; i<15; i++) {
+    shift_int_right_var();
+    aint1 >>= 1;
+    if(aint0 != aint1)
+      failures++;
+  }
+  printf("failures: %d\n",failures);
+
+  aint0 = -0x4000;
+  aint1 = -0x4000;
+
+  for(i=0; i<15; i++) {
+    shift_int_right_var();
+    aint1 >>= 1;
+    if(aint0 != aint1)
+      failures++;
+  }
+  printf("failures: %d\n",failures);
+
+  aint1 = 0xf000;
+  achar1 = 10;
+  shift_int_right_var2();
+
+  if(((unsigned short)aint0) != 0xfffc)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint1 = aint0;
+  shift_int_left_var2();
+
+  if(((unsigned short)aint0) != 0xf000)
+    failures++;
+
+  success=failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/rotate7.c
+++ b/test/val/rotate7.c
@@ -0,0 +1,413 @@
+/*
+  !!DESCRIPTION!! Shift ints left and right
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+signed short aint0 = 0;
+signed short aint1 = 0;
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+
+/*
+signed char achar0 = 0;
+signed char achar1 = 0;
+signed char achar2 = 0;
+signed char achar3 = 0;
+*/
+
+void done()
+{
+  dummy++;
+}
+
+void shift_int_left_1(void)
+{
+  aint0 <<= 1;
+}
+
+void shift_int_left_2(void)
+{
+  aint0 <<= 2;
+}
+
+void shift_int_left_3(void)
+{
+  aint0 <<= 3;
+}
+
+void shift_int_left_4(void)
+{
+  aint0 <<= 4;
+}
+
+void shift_int_left_5(void)
+{
+  aint0 <<= 5;
+}
+
+void shift_int_left_6(void)
+{
+  aint0 <<= 6;
+}
+
+void shift_int_left_7(void)
+{
+  aint0 <<= 7;
+}
+
+void shift_int_left_8(void)
+{
+  aint0 <<= 8;
+}
+
+void shift_int_left_9(void)
+{
+  aint0 <<= 9;
+}
+
+void shift_int_left_10(void)
+{
+  aint0 <<= 10;
+}
+
+void shift_int_left_11(void)
+{
+  aint0 <<= 11;
+}
+
+void shift_int_left_12(void)
+{
+  aint0 <<= 12;
+}
+
+void shift_int_left_13(void)
+{
+  aint0 <<= 13;
+}
+
+void shift_int_left_14(void)
+{
+  aint0 <<= 14;
+}
+
+void shift_int_left_15(void)
+{
+  aint0 <<= 15;
+}
+
+/*****************************************************/
+void shift_int_right_1(void)
+{
+  aint0 >>= 1;
+}
+
+void shift_int_right_2(void)
+{
+  aint0 >>= 2;
+}
+
+void shift_int_right_3(void)
+{
+  aint0 >>= 3;
+}
+
+void shift_int_right_4(void)
+{
+  aint0 >>= 4;
+}
+
+void shift_int_right_5(void)
+{
+  aint0 >>= 5;
+}
+
+void shift_int_right_6(void)
+{
+  aint0 >>= 6;
+}
+
+void shift_int_right_7(void)
+{
+  aint0 >>= 7;
+}
+
+void shift_int_right_8(void)
+{
+  aint0 >>= 8;
+}
+
+void shift_int_right_9(void)
+{
+  aint0 >>= 9;
+}
+
+void shift_int_right_10(void)
+{
+  aint0 >>= 10;
+}
+
+void shift_int_right_11(void)
+{
+  aint0 >>= 11;
+}
+
+void shift_int_right_12(void)
+{
+  aint0 >>= 12;
+}
+
+void shift_int_right_13(void)
+{
+  aint0 >>= 13;
+}
+
+void shift_int_right_14(void)
+{
+  aint0 >>= 14;
+}
+
+void shift_int_right_15(void)
+{
+  aint0 >>= 15;
+}
+
+/*****************************************************/
+int
+main (void)
+{
+  aint0 = 0xabcd;
+
+  shift_int_left_1();
+  if(aint0 != 0x579a)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_2();
+  if((unsigned short)aint0 != 0xaf34)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_3();
+  if(aint0 != 0x5e68)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_4();
+  if((unsigned short)aint0 != 0xbcd0)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_5();
+  if(aint0 != 0x79a0)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_6();
+  if((unsigned short)aint0 != 0xf340)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_7();
+  if((unsigned short)aint0 != 0xe680)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_8();
+  if((unsigned short)aint0 != 0xcd00)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_9();
+  if((unsigned short)aint0 != 0x9a00)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_10();
+  if(aint0 != 0x3400)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_11();
+  if(aint0 != 0x6800)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_12();
+  if((unsigned short)aint0 != 0xd000)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_13();
+  if((unsigned short)aint0 != 0xa000)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_14();
+  if(aint0 != 0x4000)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_left_15();
+  if((unsigned short)aint0 != 0x8000)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  /***********************/
+  aint0 = 0xabcd;
+
+  shift_int_right_1();
+  if((unsigned short)aint0 != 0xd5e6)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_2();
+  if((unsigned short)aint0 != 0xeaf3)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_3();
+  if((unsigned short)aint0 != 0xf579)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_4();
+  if((unsigned short)aint0 != 0xfabc)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_5();
+  if((unsigned short)aint0 != 0xfd5e)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_6();
+  if((unsigned short)aint0 != 0xfeaf)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_7();
+  if((unsigned short)aint0 != 0xff57)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_8();
+  if((unsigned short)aint0 != 0xffab)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_9();
+  if((unsigned short)aint0 != 0xffd5)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_10();
+  if((unsigned short)aint0 != 0xffea)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_11();
+  if((unsigned short)aint0 != 0xfff5)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_12();
+  if((unsigned short)aint0 != 0xfffa)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_13();
+  if((unsigned short)aint0 != 0xfffd)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_14();
+  if((unsigned short)aint0 != 0xfffe)
+    failures++;
+  printf("failures: %d\n",failures);
+
+  aint0 = 0xabcd;
+
+  shift_int_right_15();
+  if(aint0 != -1)
+    failures++;
+
+  success=failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/sitest.c
+++ b/test/val/sitest.c
--- a/test/val/strtol-test.c
+++ b/test/val/strtol-test.c
@@ -0,0 +1,135 @@
+/*
+  !!DESCRIPTION!! A small test for atoi/strtol. Assumes twos complement
+  !!ORIGIN!!
+  !!LICENCE!!
+  !!AUTHOR!!
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+#define ERROR   0
+#define OK      1
+
+static unsigned int Failures = 0;
+
+static void IncStr (char* Buf)
+/* Increment a number represented as a string by one. The string MUST not
+ * start with a '9', we cannot handle overflow in this case.
+ */
+{
+    int Len = strlen (Buf);
+
+    while (--Len >= 0) {
+        switch (Buf[Len]) {
+            case '9':
+                Buf[Len] = '0';
+                break;
+
+            default:
+                ++(Buf[Len]);
+                return;
+        }
+    }
+}
+
+static void CheckStrToL (const char* Str, int Base, long Val, unsigned char Ok)
+{
+    char* EndPtr;
+    long Res = strtol (Str, &EndPtr, Base);
+    if (Ok) {
+        if (Res != Val) {
+            printf ("strtol error in \"%s\":\n"
+                    "  result = %ld, should be %ld, chars = %d\n",
+                    Str, Res, Val, EndPtr - Str);
+            ++Failures;
+        }
+    } else {
+        if (errno != ERANGE) {
+            printf ("strtol error in \"%s\":\n"
+                    "  should not convert, but errno = %d\n",
+                    Str, errno);
+            ++Failures;
+        }
+        if (Res != Val) {
+            printf ("strtol error in \"%s\":\n"
+                    "  result = %ld, should be %ld, chars = %d\n",
+                    Str, Res, Val, EndPtr - Str);
+            ++Failures;
+        }
+    }
+}
+
+int main (void)
+{
+    char Buf[80];
+
+    /* Prefixed allowed if base = 0 */
+    CheckStrToL ("\t 0x10G ", 0, 16L, OK);
+    CheckStrToL ("\t 0X10G ", 0, 16L, OK);
+    CheckStrToL (" \t0377\t", 0, 255L, OK);
+    CheckStrToL (" 377", 0, 377L, OK);
+
+    CheckStrToL ("\t -0x10G ", 0, -16L, OK);
+    CheckStrToL ("\t -0X10G ", 0, -16L, OK);
+    CheckStrToL (" \t-0377\t", 0, -255L, OK);
+    CheckStrToL (" -377", 0, -377L, OK);
+
+    /* No prefixes if base = 10 */
+    CheckStrToL ("\t 1234 ", 10, 1234L, OK);
+    CheckStrToL ("\t -1234 ", 10, -1234L, OK);
+    CheckStrToL ("\t -0x10G ", 10, 0L, OK);
+    CheckStrToL ("\t -0X10G ", 10, 0L, OK);
+    CheckStrToL (" \t-0377\t", 10, -377L, OK);
+    CheckStrToL (" 0377", 10, 377L, OK);
+
+    /* 0x prefix is allowed if base = 16 */
+    CheckStrToL ("\t 0x1234 ", 16, 0x1234L, OK);
+    CheckStrToL ("\t -0x1234 ", 16, -0x1234L, OK);
+    CheckStrToL ("\t -010G ", 16, -16L, OK);
+    CheckStrToL ("\t 10G ", 16, 16L, OK);
+
+    /* Check LONG_MIN and LONG_MAX */
+    sprintf (Buf, "%ld", LONG_MIN);
+    CheckStrToL (Buf, 0, LONG_MIN, OK);
+    sprintf (Buf, "%ld", LONG_MAX);
+    CheckStrToL (Buf, 0, LONG_MAX, OK);
+
+    /* Check value one smaller */
+    sprintf (Buf+1, "%ld", LONG_MIN);
+    Buf[1] = '0';       /* Overwrite '-' */
+    IncStr (Buf+1);
+    if (Buf[1] == '0') {
+        Buf[1] = '-';
+        Buf[0] = ' ';
+    } else {
+        Buf[0] = '-';
+    }
+    CheckStrToL (Buf, 0, LONG_MIN, ERROR);
+
+    /* Check value one larger */
+    sprintf (Buf+1, "%ld", LONG_MAX);
+    Buf[0] = '0';
+    IncStr (Buf);
+    if (Buf[0] == '0') {
+        Buf[0] = ' ';
+    }
+    CheckStrToL (Buf, 0, LONG_MAX, ERROR);
+
+    /* Check numbers that are much too large or small */
+    CheckStrToL ("-999999999999999999999999999999999999999999999999999999999", 0, LONG_MIN, ERROR);
+    CheckStrToL ("+999999999999999999999999999999999999999999999999999999999", 0, LONG_MAX, ERROR);
+    CheckStrToL (" 999999999999999999999999999999999999999999999999999999999", 0, LONG_MAX, ERROR);
+
+    /* Check a few other bases */
+    CheckStrToL ("aBcD", 36, 481261L, OK);
+    CheckStrToL ("zyaB", 35, 0L, ERROR);
+    CheckStrToL ("zyaB", 36, 1677395L, ERROR);
+
+    printf ("Failures: %u\n", Failures);
+
+    return Failures;
+}
--- a/test/val/strtoul-test.c
+++ b/test/val/strtoul-test.c
@@ -0,0 +1,121 @@
+/*
+  !!DESCRIPTION!! A small test for strtuol. Assumes twos complement
+  !!ORIGIN!!
+  !!LICENCE!!
+  !!AUTHOR!!
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+#define ERROR   0
+#define OK      1
+
+static unsigned int Failures = 0;
+
+static void IncStr (char* Buf)
+/* Increment a number represented as a string by one. The string MUST not
+ * start with a '9', we cannot handle overflow in this case.
+ */
+{
+    int Len = strlen (Buf);
+
+    while (--Len >= 0) {
+        switch (Buf[Len]) {
+            case '9':
+                Buf[Len] = '0';
+                break;
+
+            default:
+                ++(Buf[Len]);
+                return;
+        }
+    }
+}
+
+static void CheckStrToUL (const char* Str, int Base, unsigned long Val, unsigned char Ok)
+{
+    char* EndPtr;
+    unsigned long Res = strtoul (Str, &EndPtr, Base);
+    if (Ok) {
+        if (Res != Val) {
+            printf ("strtol error in \"%s\":\n"
+                    "  result = %lu, should be %lu, chars = %d\n",
+                    Str, Res, Val, EndPtr - Str);
+            ++Failures;
+        }
+    } else {
+        if (errno != ERANGE) {
+            printf ("strtol error in \"%s\":\n"
+                    "  should not convert, but errno = %d\n",
+                    Str, errno);
+            ++Failures;
+        }
+        if (Res != Val) {
+            printf ("strtol error in \"%s\":\n"
+                    "  result = %lu, should be %lu, chars = %d\n",
+                    Str, Res, Val, EndPtr - Str);
+            ++Failures;
+        }
+    }
+}
+
+int main (void)
+{
+    char Buf[80];
+
+    /* Prefixed allowed if base = 0 */
+    CheckStrToUL ("\t 0x10G ", 0, 16UL, OK);
+    CheckStrToUL ("\t 0X10G ", 0, 16UL, OK);
+    CheckStrToUL (" \t0377\t", 0, 255UL, OK);
+    CheckStrToUL (" 377", 0, 377UL, OK);
+
+    CheckStrToUL ("\t -0x10G ", 0, (unsigned long) -16L, OK);
+    CheckStrToUL ("\t -0X10G ", 0, (unsigned long) -16L, OK);
+    CheckStrToUL (" \t-0377\t", 0, (unsigned long) -255L, OK);
+    CheckStrToUL (" -377", 0, (unsigned long) -377L, OK);
+
+    /* No prefixes if base = 10 */
+    CheckStrToUL ("\t 1234 ", 10, 1234UL, OK);
+    CheckStrToUL ("\t -1234 ", 10, (unsigned long) -1234L, OK);
+    CheckStrToUL ("\t -0x10G ", 10, 0UL, OK);
+    CheckStrToUL ("\t -0X10G ", 10, 0UL, OK);
+    CheckStrToUL (" \t-0377\t", 10, (unsigned long) -377L, OK);
+    CheckStrToUL (" 0377", 10, 377UL, OK);
+
+    /* 0x prefix is allowed if base = 16 */
+    CheckStrToUL ("\t 0x1234 ", 16, 0x1234UL, OK);
+    CheckStrToUL ("\t -0x1234 ", 16, (unsigned long) -0x1234L, OK);
+    CheckStrToUL ("\t -010G ", 16, (unsigned long) -16L, OK);
+    CheckStrToUL ("\t 10G ", 16, 16UL, OK);
+
+    /* Check ULONG_MAX */
+    sprintf (Buf, "%lu", ULONG_MAX);
+    CheckStrToUL (Buf, 0, ULONG_MAX, OK);
+
+    /* Check value one larger */
+    sprintf (Buf+1, "%lu", ULONG_MAX);
+    Buf[0] = '0';
+    IncStr (Buf);
+    if (Buf[0] == '0') {
+        Buf[0] = ' ';
+    }
+    CheckStrToUL (Buf, 0, ULONG_MAX, ERROR);
+
+    /* Check numbers that are much too large or small */
+    CheckStrToUL ("-999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR);
+    CheckStrToUL ("+999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR);
+    CheckStrToUL (" 999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR);
+
+    /* Check a few other bases */
+    CheckStrToUL ("aBcD", 36, 481261UL, OK);
+    CheckStrToUL ("zyaB", 35, 0UL, ERROR);
+    CheckStrToUL ("zyaB", 36, 1677395UL, ERROR);
+
+    printf ("Failures: %u\n", Failures);
+
+    return Failures;
+}
--- a/test/val/struct1.c
+++ b/test/val/struct1.c
@@ -0,0 +1,100 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char *acharP = 0;
+
+struct chars
+  {
+    unsigned char c0, c1;
+    unsigned int  i0, i1;
+  };
+
+struct chars struct1;
+
+void
+done ()
+{
+  dummy++;
+}
+
+void
+struct_test (void)
+{
+  if (struct1.c0 || struct1.c1)
+    failures++;
+
+  struct1.c0++;
+
+  if (struct1.c0 != 1)
+    failures++;
+}
+
+void
+ptr_to_struct (struct chars *p)
+{
+  if (p->c1)
+    failures++;
+
+  p->c1++;
+
+  if (p->c1 != 1)
+    failures++;
+}
+
+void add_chars(void)
+{
+  achar0 = struct1.c0 + struct1.c1;
+
+  if(achar0 != 1)
+    failures++;
+}
+
+int
+main (void)
+{
+  struct1.c0 = 0;
+  struct1.c1 = 0;
+  struct_test ();
+  ptr_to_struct (&struct1);
+
+  struct1.c0 = 0;
+  struct1.c1 = 1;
+  add_chars();
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/sub1.c
+++ b/test/val/sub1.c
@@ -0,0 +1,272 @@
+/*
+  !!DESCRIPTION!! Substraction Test
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+unsigned short aint0 = 0;
+unsigned short aint1 = 0;
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+#endif
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+#endif
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void sub_lit_from_uchar(void)
+{
+  achar0 = achar0 - 5;
+
+  if(achar0 != 0xfb)
+    failures++;
+
+  achar0 -= 10;
+
+  if(achar0 != 0xf1)
+    failures++;
+
+  achar0 = achar0 -1;  /* Should be a decrement */
+  if(achar0 != 0xf0)
+    failures++;
+
+  for(achar1 = 0; achar1 < 100; achar1++)
+    achar0 -= 2;
+
+  if(achar0 != 40)
+    failures++;
+}
+
+/* achar0 = 1
+ achar1 = 100
+*/
+
+void sub_uchar2uchar(void)
+{
+  achar1 = achar1 - achar0;
+
+  if(achar1 != 99)
+    failures++;
+
+  for(achar2 = 0; achar2<7; achar2++)
+    achar1 -= achar0;
+
+  if(achar1 != 92)
+    failures++;
+}
+
+/* assumes
+  achar0 = 10
+  achar1 = 32
+  achar2, achar3 can be anything.
+*/
+void sub_uchar2uchar2(void)
+{
+  achar0--;
+  achar0 = achar0 - 1;
+  achar0 = achar0 - 2;
+  achar0 = achar0 - 3;
+  if(achar0 != 3)
+    failures++;
+
+  achar1 -= achar0;
+  if(achar1 != 29)
+    failures++;
+
+  achar2 = achar1 - achar0;
+  if(achar2 != 26)
+    failures++;
+
+  achar3 = achar2 - achar1 - achar0;
+  if(achar3 != 0xfa)
+    failures++;
+}
+
+/* sub_bits
+ all bit variables are 0 upon entry.
+*/
+#if SUPPORT_BIT_TYPES
+void sub_bits(void)
+{
+  bit1 = bit0;
+
+  bit0 = 1;
+
+  if(bit1 != 0)
+    failures++;
+
+  bit1 = bit0-bit1;   /* 1 - 0 => 1 */
+  if(bit1 != 1)
+    failures++;
+
+#if SUPPORT_BIT_ARITHMETIC
+  bit2 = bit1-bit0;   /* 1 - 1 => 0 */
+  if(bit2)
+    failures++;
+
+  bit7 = bit4-bit5;
+  bit6 = bit4+bit5;
+  bit3 = bit4-bit5-bit6-bit7-bit0; /* 0-0-0-0-1 => 1 */
+  if(!bit3)
+    failures++;
+#endif
+}
+
+/* sub_bit2uchar(void) - assumes bit0 = 1, achar0 = 7  */
+
+void sub_bit2uchar(void)
+{
+  achar0 -= bit0;
+
+  if(achar0 != 6)
+    failures++;
+
+  if(achar0 == bit0)
+    failures++;
+}
+
+void sub_bit2uint(void)
+{
+  if(aint0 != bit11)
+    failures++;
+
+  aint0 -= bit0;
+  if(aint0!=0xffff)
+    failures++;
+}
+#endif
+
+void sub_ucharFromLit(void)
+{
+  achar0 = 2 - achar0;
+
+  if(achar0 != 2)
+  {
+    printf("%x != %x\n",0x02,achar0);
+    failures++;
+  }
+
+  aint0 = 2 - aint0;
+
+  if(aint0 != 2)
+  {
+    printf("%x != %x\n",0x02,aint0);
+    failures++;
+  }
+
+  aint0--;
+
+  if(aint0 != 1)
+  {
+    printf("%x != %x\n",0x01,aint0);
+    failures++;
+  }
+
+  aint0 = 0x100 - aint0;
+
+  if(aint0 != 0xff)
+  {
+    printf("%x != %x\n",0xff,aint0);
+    failures++;
+  }
+
+  aint0 = 0xff00 - aint0;
+
+  if(aint0 != 0xfe01)
+  {
+    printf("%x != %x\n",0xfe01,aint0);
+    failures++;
+  }
+
+  aint0 = 0x0e01 - aint0;
+
+  if(aint0 != 0x1000)
+  {
+    printf("%x != %x\n",0x1000,aint0);
+    failures++;
+  }
+
+  aint0 = 0x10ff - aint0;
+
+  if(aint0 != 0xff)
+  {
+    printf("%x != %x\n",0xff,aint0);
+    failures++;
+  }
+}
+
+int main(void)
+{
+  sub_lit_from_uchar();
+  printf("failures: %d\n",failures);
+
+  achar0=1;
+  achar1=100;
+  sub_uchar2uchar();
+  printf("failures: %d\n",failures);
+
+  achar0 = 10;
+  achar1 = 32;
+  sub_uchar2uchar2();
+  printf("failures: %d\n",failures);
+
+#if SUPPORT_BIT_TYPES
+  sub_bits();
+
+  achar0 = 7;
+  bit0 = 1;
+  sub_bit2uchar();
+  printf("failures: %d\n",failures);
+  sub_bit2uint();
+  printf("failures: %d\n",failures);
+#endif
+
+  aint0 = 0;
+  achar0 = 0;
+  sub_ucharFromLit();
+
+  success = failures;
+  done();
+
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/sub2.c
+++ b/test/val/sub2.c
@@ -0,0 +1,169 @@
+/*
+  !!DESCRIPTION!! Substraction Test
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+int int0 = 0;
+int int1 = 0;
+
+signed char char0 = 0;
+signed char char1 = 0;
+signed char char2 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void sub_int1(void)
+{
+  if(int0 != 5)
+    failures++;
+
+  if(int1 != 4)
+    failures++;
+
+  int0 = int0 - int1;
+
+  if(int0 != 1)
+    failures++;
+
+  int0 = 4 - int0;
+  if(int0 != 3)
+    failures++;
+
+  int0 = int0 - int1;
+
+  if(int0 != -1)
+    failures++;
+
+  int0 = int0 - 0xff;
+
+  if(int0 != -0x100)
+    failures++;
+
+  int0 = 0xff - int0;
+
+  if(int0 != 0x1ff)
+    failures++;
+}
+
+void sub_char_int(void)
+{
+  int0 = int0 - char0;
+
+  if(int0 != 3)
+    failures++;
+
+  if(int0 < char0)
+    failures++;
+
+  int0 = int0 - char0;
+
+  if(int0 != 1)
+    failures++;
+
+  if(int0 > char0)
+    failures++;
+
+  int0 = int0 - char0;
+  if(int0 != -1)
+    failures++;
+
+  if(int0>0)
+    failures++;
+}
+
+void assign_char2int(void)
+{
+  int0 = char0;
+  if(int0 != 0x7f)
+    failures++;
+
+ /* printf("%2x %2x %2x %d\n",0x7f,int0,char0,failures); */
+
+  int1 = char1;
+  if(int1 != -5)
+    failures++;
+
+ /* printf("%2x,%d %2x,%d %2x,%d %d\n",-5,-5,(int)int1,(int)int1,(int)char1,(int)char1,failures); */
+}
+
+void sub_compound_char(void)
+{
+  char0 = char1 - 5;
+  if(char0 != 4)
+    failures++;
+
+  if((char1 - char0 - 5) != 0)
+    failures++;
+}
+
+void sub_compound_int(void)
+{
+  int0 = int1 - 5;
+  if(int0 != 4)
+    failures++;
+
+  if((int1 - int0 - 5) != 0)
+    failures++;
+}
+
+int main(void)
+{
+  int0 = 5;
+  int1 = 4;
+
+  sub_int1();
+  printf("failures: %d\n",failures);
+
+  int0 = 5;
+  int1 = 4;
+  char0 = 2;
+
+  sub_char_int();
+  printf("failures: %d\n",failures);
+
+  char0 = 0x7f;
+  char1 = -5;
+  assign_char2int();
+  printf("failures: %d\n",failures);
+
+  char1 = 9;
+  sub_compound_char();
+  printf("failures: %d\n",failures);
+
+  int1 = 9;
+  sub_compound_int();
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/switch1.c
+++ b/test/val/switch1.c
@@ -0,0 +1,91 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void switch1(void)
+{
+  switch(achar0) {
+  case 0:
+    achar0 = 9;
+    break;
+  case 1:
+    achar0 = 18;
+    break;
+
+  default:
+    achar0 = 0;
+  }
+}
+
+void switch2(void)
+{
+  switch(achar1) {
+  case 0:    achar0 = 9;    break;
+  case 1:    achar0 = 8;    break;
+  case 2:    achar0 = 7;    break;
+  case 3:    achar0 = 6;    break;
+  case 4:    achar0 = 5;    break;
+  case 5:    achar0 = 4;    break;
+  case 6:    achar0 = 3;    break;
+  case 7:    achar0 = 2;    break;
+  case 8:    achar0 = 1;    break;
+  case 9:    achar0 = 0;    break;
+  case 10:    achar0 = 9;    break;
+  case 11:    achar0 = 8;    break;
+  case 12:    achar0 = 7;    break;
+  default:    achar0 = 0xff;    break;
+  }
+}
+
+int main(void)
+{
+  achar0 = 0;
+  switch1();
+  if(achar0 != 9)
+    failures++;
+
+  switch1();
+  if(achar0 != 0)
+    failures++;
+
+  achar0++;
+
+  switch1();
+  if(achar0 != 18)
+    failures++;
+
+  for(achar1=0; achar1<10;achar1++){
+    switch2();
+    if(achar0 != (9-achar1))
+      failures++;
+
+  }
+
+  success=failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/while.c
+++ b/test/val/while.c
@@ -0,0 +1,53 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+done ()
+{
+  dummy++;
+}
+
+void
+while1 (void)
+{
+  unsigned char i = 10;
+
+  do
+    {
+      achar0++;
+    }
+  while (--i);
+
+  if (achar0 != 10)
+    failures++;
+}
+
+int
+main (void)
+{
+  while1 ();
+
+  success = failures;
+  done ();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}
--- a/test/val/xor.c
+++ b/test/val/xor.c
@@ -0,0 +1,64 @@
+/*
+  !!DESCRIPTION!!
+  !!ORIGIN!!      SDCC regression tests
+  !!LICENCE!!     GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+
+void done()
+{
+  dummy++;
+}
+
+void xor_chars_0_1(void)
+{
+  achar2 = achar0 ^ achar1;
+
+  achar0 = achar0 ^ 0x1;
+
+  achar1 = achar0 ^ achar1 ^ 4;
+}
+
+void xor_if(void)
+{
+  if(achar0 ^ achar1) 
+    failures++;
+
+  achar0 ^= 0xff;
+
+  if( !(achar0 ^ achar1) ) 
+    failures++;
+}
+
+int  main(void)
+{
+  xor_chars_0_1();
+
+  if(achar2)
+    failures++;
+
+  if(achar0 != 1)
+    failures++;
+
+  if(achar1 != 5)
+    failures++;
+
+  achar0 = achar1;
+  xor_if();
+
+  success = failures;
+  done();
+  printf("failures: %d\n",failures);
+
+  return failures;
+}