Fixed test.

src/test/java/dk/camelot64/kickc/test/TestPrograms.java

@@ -37,16 +37,21 @@ public class TestPrograms {
    //   compileAndCompare("pointer-cast-3");
    //}
 
+   //@Test
+   //public void testTypeIdPlusByteProblem() throws IOException, URISyntaxException {
+   //   compileAndCompare("typeid-plus-byte-problem");
+   //}
+
+   //@Test
+   //public void testTypeIdPlusBytes() throws IOException, URISyntaxException {
+   //   compileAndCompare("typeid-plus-bytes");
+   //}
+
    @Test
    public void testTypeIdSimple() throws IOException, URISyntaxException {
       compileAndCompare("typeid-simple");
    }
 
-   @Test
-   public void testTypeIdPlusBytes() throws IOException, URISyntaxException {
-      compileAndCompare("typeid-plus-bytes");
-   }
-
    @Test
    public void testTypeSigned() throws IOException, URISyntaxException {
       compileAndCompare("type-signed");

src/test/kc/typeid-plus-byte-problem.kc

@@ -0,0 +1,9 @@
+// Test that byte+byte creates a byte - even when there is a value overflow
+
+const byte* SCREEN = $400;
+
+void main() {
+    unsigned byte ubc1 = 250;
+    SCREEN[0] = ubc1+250;
+}
+

src/test/kc/typeid-plus-bytes.kc

@@ -1,36 +1,98 @@
 // Test that plus creates the expected type for all legal combinations of bytes (signed/unsigned - constant/variable)
 
 const byte* SCREEN = $400;
+const signed byte* SSCREEN = $400;
 byte idx = 0;
 
 void main() {
     idx = 0;
     testUnsigned();
-    idx = $28;
+    idx += $28;
+    testUnsignedVals();
+    idx += $28;
     testSigned();
+    idx += $28;
+    testSignedVals();
 }
 
 
 void testUnsigned() {
-    volatile unsigned byte ubv1 = 91;
+    unsigned byte ubc1 = 250;
-    SCREEN[idx++] = typeid(123);
+    volatile unsigned byte ubv1 = 250;
+
+    SCREEN[idx++] = typeid(250);
+    SCREEN[idx++] = typeid(ubc1);
     SCREEN[idx++] = typeid(ubv1);
-    SCREEN[idx++] = typeid(121+71);
+
-    SCREEN[idx++] = typeid(ubv1+12);
+    SCREEN[idx++] = typeid(120+130);
-    SCREEN[idx++] = typeid(21+ubv1);
+
+    SCREEN[idx++] = typeid(ubc1+250);
+    SCREEN[idx++] = typeid(250+ubc1);
+
+    SCREEN[idx++] = typeid(ubv1+250);
+    SCREEN[idx++] = typeid(250+ubv1);
+    SCREEN[idx++] = typeid(ubv1+ubc1);
+    SCREEN[idx++] = typeid(ubc1+ubv1);
     SCREEN[idx++] = typeid(ubv1+ubv1);
 }
 
+void testUnsignedVals() {
+    unsigned byte ubc1 = 250;
+    volatile unsigned byte ubv1 = 250;
+
+    SCREEN[idx++] = 250;
+    SCREEN[idx++] = ubc1;
+    SCREEN[idx++] = ubv1;
+
+    SCREEN[idx++] = 120+130;
+
+    SCREEN[idx++] = ubc1+250;
+    SCREEN[idx++] = 250+ubc1;
+
+    SCREEN[idx++] = ubv1+250;
+    SCREEN[idx++] = 250+ubv1;
+    SCREEN[idx++] = ubv1+ubc1;
+    SCREEN[idx++] = ubc1+ubv1;
+    SCREEN[idx++] = ubv1+ubv1;
+}
+
 void testSigned() {
-    volatile signed byte sbv1 = 19;
+    signed byte sbc1 = -120;
-    SCREEN[idx++] = typeid(-12);
+    volatile signed byte sbv1 = -120;
+
+    SCREEN[idx++] = typeid(-120);
+    SCREEN[idx++] = typeid(sbc1);
     SCREEN[idx++] = typeid(sbv1);
-    SCREEN[idx++] = typeid(-41+-12);
+
-    SCREEN[idx++] = typeid(-41+12);
+    SCREEN[idx++] = typeid(-120+-130);
-    SCREEN[idx++] = typeid(-14+sbv1);
+
-    SCREEN[idx++] = typeid(sbv1+-31);
+    SCREEN[idx++] = typeid(sbc1+-120);
-    SCREEN[idx++] = typeid(sbv1+31);
+    SCREEN[idx++] = typeid(-120+sbc1);
+
+    SCREEN[idx++] = typeid(sbv1+-120);
+    SCREEN[idx++] = typeid(-120+sbv1);
+    SCREEN[idx++] = typeid(sbv1+sbc1);
+    SCREEN[idx++] = typeid(sbc1+sbv1);
     SCREEN[idx++] = typeid(sbv1+sbv1);
 }
 
+void testSignedVals() {
+    signed byte sbc1 = -120;
+    volatile signed byte sbv1 = -120;
+
+    SSCREEN[idx++] = (-120);
+    SSCREEN[idx++] = (sbc1);
+    SSCREEN[idx++] = (sbv1);
+
+    SSCREEN[idx++] = (-70+-50);
+
+    SSCREEN[idx++] = (sbc1+-120);
+    SSCREEN[idx++] = (-120+sbc1);
+
+    SSCREEN[idx++] = (sbv1+-120);
+    SSCREEN[idx++] = (-120+sbv1);
+    SSCREEN[idx++] = (sbv1+sbc1);
+    SSCREEN[idx++] = (sbc1+sbv1);
+    SSCREEN[idx++] = (sbv1+sbv1);
+}
 

src/test/ref/sizeof-expr.log

@@ -22,9 +22,9 @@ main: scope:[main]  from @1
   (string~) main::$2 ← (const string) main::$34 + (const string) main::$35
   (string~) main::$3 ← (string~) main::$2 + (const string) main::$36
   (byte[]) main::sb#0 ← (string~) main::$3
-  (byte/signed byte/word/signed word/dword/signed dword~) main::$4 ← sizeof  (byte/signed byte/word/signed word/dword/signed dword) 0
+  (byte~) main::$4 ← sizeof  (byte/signed byte/word/signed word/dword/signed dword) 0
-  (byte/signed word/word/dword/signed dword~) main::$5 ← (byte) '0' + (byte/signed byte/word/signed word/dword/signed dword~) main::$4
+  (byte~) main::$5 ← (byte) '0' + (byte~) main::$4
-  *((byte*) SCREEN#0 + (byte) main::idx#0) ← (byte/signed word/word/dword/signed dword~) main::$5
+  *((byte*) SCREEN#0 + (byte) main::idx#0) ← (byte~) main::$5
   (byte) main::idx#1 ← ++ (byte) main::idx#0
   (byte~) main::$6 ← sizeof  (byte) main::idx#1
   (byte~) main::$7 ← (byte) '0' + (byte~) main::$6
@@ -40,9 +40,9 @@ main: scope:[main]  from @1
   *((byte*) SCREEN#0 + (byte) main::idx#3) ← (byte~) main::$12
   (byte) main::idx#4 ← ++ (byte) main::idx#3
   (byte) main::idx#5 ← ++ (byte) main::idx#4
-  (byte/signed byte/word/signed word/dword/signed dword~) main::$13 ← sizeof  (word/signed word/dword/signed dword) $43ff
+  (byte~) main::$13 ← sizeof  (word/signed word/dword/signed dword) $43ff
-  (byte/signed word/word/dword/signed dword~) main::$14 ← (byte) '0' + (byte/signed byte/word/signed word/dword/signed dword~) main::$13
+  (byte~) main::$14 ← (byte) '0' + (byte~) main::$13
-  *((byte*) SCREEN#0 + (byte) main::idx#5) ← (byte/signed word/word/dword/signed dword~) main::$14
+  *((byte*) SCREEN#0 + (byte) main::idx#5) ← (byte~) main::$14
   (byte) main::idx#6 ← ++ (byte) main::idx#5
   (byte~) main::$15 ← sizeof  (word) main::w#0
   (byte~) main::$16 ← (byte) '0' + (byte~) main::$15
@@ -106,8 +106,8 @@ SYMBOL TABLE SSA
 (byte/signed word/word/dword/signed dword~) main::$10
 (byte~) main::$11
 (byte~) main::$12
-(byte/signed byte/word/signed word/dword/signed dword~) main::$13
+(byte~) main::$13
-(byte/signed word/word/dword/signed dword~) main::$14
+(byte~) main::$14
 (byte~) main::$15
 (byte~) main::$16
 (byte~) main::$17
@@ -132,8 +132,8 @@ SYMBOL TABLE SSA
 (const string) main::$34 = (string) "cml@"
 (const string) main::$35 = (string) " @"
 (const string) main::$36 = (string) "rules@"
-(byte/signed byte/word/signed word/dword/signed dword~) main::$4
+(byte~) main::$4
-(byte/signed word/word/dword/signed dword~) main::$5
+(byte~) main::$5
 (byte~) main::$6
 (byte~) main::$7
 (byte~) main::$8
@@ -196,14 +196,14 @@ Constant (const byte) main::sz#0 = $f
 Constant (const byte[]) main::bc#0 = { 1, 2, 3, 4 }
 Constant (const byte[]) main::sa#0 = main::$33
 Constant (const string) main::$2 = "cml@"+" @"
-Constant (const byte/signed byte/word/signed word/dword/signed dword) main::$4 = sizeof 0
+Constant (const byte) main::$4 = sizeof 0
-Constant (const byte/signed byte/word/signed word/dword/signed dword) main::$13 = sizeof $43ff
+Constant (const byte) main::$13 = sizeof $43ff
 Successful SSA optimization Pass2ConstantIdentification
 Constant (const byte/signed word/word/dword/signed dword) main::$1 = main::sz#0+2
 Constant (const byte[]) main::sb#0 = "cml@"+" @"+"rules@"
-Constant (const byte/signed word/word/dword/signed dword) main::$5 = '0'+main::$4
+Constant (const byte) main::$5 = '0'+main::$4
 Constant (const byte) main::idx#1 = ++main::idx#0
-Constant (const byte/signed word/word/dword/signed dword) main::$14 = '0'+main::$13
+Constant (const byte) main::$14 = '0'+main::$13
 Constant (const byte) main::$17 = sizeof main::bp#0
 Constant (const byte) main::$19 = sizeof main::wp#0
 Constant (const byte) main::$21 = sizeof main::ba#0