Added fragments - fixed object equality problem when incrementing complex expressions of non-byte type.

src/main/fragment/pbuz1_derefidx__deref_pbuz2=_inc_pbuz1_derefidx__deref_pbuz2.asm

@@ -0,0 +1,7 @@
+ldy #0
+lda ({z2}),y
+tay
+lda ({z1}),y
+clc
+adc #1
+sta ({z1}),y

src/main/fragment/pwuz1_derefidx_vbuyy=_inc_pwuz1_derefidx_vbuyy.asm

@@ -0,0 +1,10 @@
+lda ({z1}),y
+clc
+adc #1
+sta ({z1}),y
+bne !+
+iny
+lda ({z1}),y
+adc #0
+sta ({z1}),y
+!:

src/main/fragment/pwuz1_derefidx_vbuyy=vwuc1.asm

@@ -0,0 +1,5 @@
+lda #<{c1}
+sta ({z1}),y
+iny
+lda #>{c1}
+sta ({z1}),y

src/main/java/dk/camelot64/kickc/Compiler.java

@@ -242,6 +242,7 @@ public class Compiler {
 
    private void pass2AssertSSA() {
       List<Pass2SsaAssertion> assertions = new ArrayList<>();
+      //assertions.add(new Pass2AssertNoLValueObjectEquality(program));
       assertions.add(new Pass2AssertTypeMatch(program));
       assertions.add(new Pass2AssertSymbols(program));
       assertions.add(new Pass2AssertBlocks(program));

src/main/java/dk/camelot64/kickc/passes/Pass0GenerateStatementSequence.java

@@ -1429,7 +1429,7 @@ public class Pass0GenerateStatementSequence extends KickCBaseVisitor<Object> {
       return lValue;
    }
 
-   private LValue copyLValue(LValue lValue) {
+   private static LValue copyLValue(LValue lValue) {
       if(lValue instanceof VariableRef) {
          return new VariableRef(((VariableRef) lValue).getFullName());
       } else if(lValue instanceof LvalueIntermediate) {
@@ -1929,7 +1929,8 @@ public class Pass0GenerateStatementSequence extends KickCBaseVisitor<Object> {
             List<PrePostModifier> modifiers,
             StatementSource source) {
          for(PrePostModifier mod : modifiers) {
-            Statement stmt = new StatementAssignment((LValue) mod.child, mod.operator, mod.child, source, Comment.NO_COMMENTS);
+
+            Statement stmt = new StatementAssignment((LValue) mod.child, mod.operator, copyLValue((LValue) mod.child), source, Comment.NO_COMMENTS);
             parser.sequence.addStatement(stmt);
             if(parser.program.getLog().isVerboseParse()) {
                parser.program.getLog().append("Adding pre/post-modifier " + stmt.toString(parser.program, false));

src/main/java/dk/camelot64/kickc/passes/Pass2AssertNoLValueObjectEquality.java

@@ -0,0 +1,47 @@
+package dk.camelot64.kickc.passes;
+
+import dk.camelot64.kickc.model.InternalError;
+import dk.camelot64.kickc.model.Program;
+import dk.camelot64.kickc.model.iterator.ProgramValue;
+import dk.camelot64.kickc.model.iterator.ProgramValueIterator;
+import dk.camelot64.kickc.model.values.ConstantValue;
+import dk.camelot64.kickc.model.values.SymbolRef;
+import dk.camelot64.kickc.model.values.Value;
+
+import java.util.HashMap;
+
+/** Asserts that the program does not contain calls with lValues */
+public class Pass2AssertNoLValueObjectEquality extends Pass2SsaAssertion {
+
+   public Pass2AssertNoLValueObjectEquality(Program program) {
+      super(program);
+   }
+
+   @Override
+   public void check() throws AssertionFailed {
+      HashMap<Value, ValueInProgram> allValues = new HashMap<>();
+      ProgramValueIterator.execute(getGraph(), (programValue, currentStmt, stmtIt, currentBlock) -> {
+         Value value = programValue.get();
+         if(value!=null && !(value instanceof SymbolRef) && !(value instanceof ConstantValue)) {
+            ValueInProgram other = allValues.get(value);
+            if(other != null) {
+               if(other.value == value)
+                  throw new InternalError("Error! Value object equality in program " + value.toString(getProgram()), currentStmt.getSource());
+            } else {
+               allValues.put(value, new ValueInProgram(value, programValue));
+            }
+         }
+      });
+   }
+
+   private static class ValueInProgram {
+      Value value;
+      ProgramValue programValue;
+
+      public ValueInProgram(Value value, ProgramValue programValue) {
+         this.value = value;
+         this.programValue = programValue;
+      }
+   }
+
+}

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

@@ -46,6 +46,11 @@ public class TestPrograms {
       compileAndCompare("plasma-center");
    }
 
+   @Test
+   public void testScreenShowSpiralBuckets() throws IOException, URISyntaxException {
+      compileAndCompare("screen-show-spiral-buckets", log());
+   }
+
    @Test
    public void testScreenShowSpiral() throws IOException, URISyntaxException {
       compileAndCompare("screen-show-spiral");

src/test/kc/screen-show-spiral-buckets.kc

@@ -0,0 +1,117 @@
+// Fill screen using a spiral based on distance-to-center / angle-to-center
+// Utilizes a bucket sort for identifying the minimum angle/distance
+
+import "stdlib"
+import "sqr"
+import "atan2"
+
+
+// Screen containing distance to center
+const byte* SCREEN_DIST = malloc(1000);
+// Screen containing angle to center
+const byte* SCREEN_ANGLE = malloc(1000);
+// Screen containing angle to center
+const byte* SCREEN_FILL = 0x0400;
+
+// Char to fill with
+const byte FILL_CHAR = '@';
+
+void main() {
+    init_dist_screen(SCREEN_DIST);
+    init_angle_screen(SCREEN_ANGLE);
+    init_buckets();
+/*
+    while(true) {
+        // Find the minimum dist/angle that is not already filled
+        byte* dist = SCREEN_DIST;
+        byte* angle = SCREEN_ANGLE;
+        byte* fill = SCREEN_FILL;
+        word min_dist_angle = 0xffff;
+        byte* min_fill = SCREEN_FILL;
+        do {
+            if(*fill!=FILL_CHAR) {
+                word dist_angle = { *dist, *angle };
+                if(dist_angle<min_dist_angle) {
+                    min_fill = fill;
+                    min_dist_angle = dist_angle;
+                }
+            }
+            dist++;
+            angle++;
+            fill++;
+        } while (fill<SCREEN_FILL+1000);
+        // Break if not found (means we are done)
+        if(min_dist_angle==0xffff)
+            break;
+        // Fill the found location
+        *min_fill = FILL_CHAR;
+    }
+    */
+}
+
+// Array containing the bucket size for each of the 256 buckets
+const word* BUCKET_SIZES = malloc(0x80*sizeof(word));
+
+void init_buckets() {
+    // Init bucket sizes to 0
+    for(byte i:0..0x7f) BUCKET_SIZES[i]=0;
+    // first find bucket sizes - by counting number of chars with each distance value
+    byte* dist = SCREEN_DIST;
+    for( word i:0..999 ) {
+        BUCKET_SIZES[*dist]++;
+        dist++;
+    }
+}
+
+
+// Populates 1000 bytes (a screen) with values representing the angle to the center.
+// Utilizes symmetry around the  center
+void init_angle_screen(byte* screen) {
+/*
+    byte* screen_topline = screen+40*12;
+    byte *screen_bottomline = screen+40*12;
+    for(byte y: 0..12) {
+        for( byte x=0,xb=39; x<=19; x++, xb--) {
+            signed word xw = (signed word)(word){ 39-x*2, 0 };
+            signed word yw = (signed word)(word){ y*2, 0 };
+            word angle_w = atan2_16(xw, yw);
+            byte ang_w = >(angle_w+0x0080);
+            screen_bottomline[xb] = ang_w;
+            screen_topline[xb] = -ang_w;
+            screen_topline[x] = 0x80+ang_w;
+            screen_bottomline[x] = 0x80-ang_w;
+        }
+        screen_topline -= 40;
+        screen_bottomline += 40;
+    }
+    */
+}
+
+// Populates 1000 bytes (a screen) with values representing the distance to the center.
+// The actual value stored is distance*2 to increase precision
+void init_dist_screen(byte* screen) {
+/*
+    NUM_SQUARES = 0x30;
+    init_squares();
+    byte* screen_topline = screen;
+    byte *screen_bottomline = screen+40*24;
+    for(byte y: 0..12) {
+        byte y2 = y*2;
+        byte yd = (y2>=24)?(y2-24):(24-y2);
+        word yds = sqr(yd);
+        for( byte x=0,xb=39; x<=19; x++, xb--) {
+            byte x2 = x*2;
+            byte xd = (x2>=39)?(x2-39):(39-x2);
+            word xds = sqr(xd);
+            word ds = xds+yds;
+            byte d = sqrt(ds);
+            screen_topline[x] = d;
+            screen_bottomline[x] = d;
+            screen_topline[xb] = d;
+            screen_bottomline[xb] = d;
+        }
+        screen_topline += 40;
+        screen_bottomline -= 40;
+    }
+    */
+}

src/test/ref/screen-show-spiral-buckets.asm

@@ -0,0 +1,124 @@
+// Fill screen using a spiral based on distance-to-center / angle-to-center
+// Utilizes a bucket sort for identifying the minimum angle/distance
+.pc = $801 "Basic"
+:BasicUpstart(bbegin)
+.pc = $80d "Program"
+  .const SIZEOF_WORD = 2
+  // Start of the heap used by malloc()
+  .label HEAP_START = $c000
+  .label heap_head = 6
+  // Screen containing distance to center
+  .label SCREEN_DIST = 2
+  // Array containing the bucket size for each of the 256 buckets
+  .label BUCKET_SIZES = $a
+bbegin:
+  lda #<$3e8
+  sta malloc.size
+  lda #>$3e8
+  sta malloc.size+1
+  lda #<HEAP_START
+  sta heap_head
+  lda #>HEAP_START
+  sta heap_head+1
+  jsr malloc
+  lda malloc.mem
+  sta SCREEN_DIST
+  lda malloc.mem+1
+  sta SCREEN_DIST+1
+  lda #<$3e8
+  sta malloc.size
+  lda #>$3e8
+  sta malloc.size+1
+  jsr malloc
+  lda #$80*SIZEOF_WORD
+  sta malloc.size
+  lda #0
+  sta malloc.size+1
+  jsr malloc
+  jsr main
+  rts
+main: {
+    jsr init_dist_screen
+    jsr init_angle_screen
+    jsr init_buckets
+    rts
+}
+init_buckets: {
+    .label dist = 2
+    .label i1 = 4
+    ldx #0
+  // Init bucket sizes to 0
+  b1:
+    txa
+    asl
+    tay
+    lda #<0
+    sta (BUCKET_SIZES),y
+    iny
+    sta (BUCKET_SIZES),y
+    inx
+    cpx #$80
+    bne b1
+  // first find bucket sizes - by counting number of chars with each distance value
+    sta i1
+    sta i1+1
+  b3:
+    ldy #0
+    lda (dist),y
+    asl
+    tay
+    lda (BUCKET_SIZES),y
+    clc
+    adc #1
+    sta (BUCKET_SIZES),y
+    bne !+
+    iny
+    lda (BUCKET_SIZES),y
+    adc #0
+    sta (BUCKET_SIZES),y
+  !:
+    inc dist
+    bne !+
+    inc dist+1
+  !:
+    inc i1
+    bne !+
+    inc i1+1
+  !:
+    lda i1+1
+    cmp #>$3e8
+    bne b3
+    lda i1
+    cmp #<$3e8
+    bne b3
+    rts
+}
+// Populates 1000 bytes (a screen) with values representing the angle to the center.
+// Utilizes symmetry around the  center
+init_angle_screen: {
+    rts
+}
+// Populates 1000 bytes (a screen) with values representing the distance to the center.
+// The actual value stored is distance*2 to increase precision
+init_dist_screen: {
+    rts
+}
+// Allocates a block of size bytes of memory, returning a pointer to the beginning of the block.
+// The content of the newly allocated block of memory is not initialized, remaining with indeterminate values.
+// malloc(word zeropage(8) size)
+malloc: {
+    .label mem = $a
+    .label size = 8
+    lda heap_head
+    sta mem
+    lda heap_head+1
+    sta mem+1
+    lda heap_head
+    clc
+    adc size
+    sta heap_head
+    lda heap_head+1
+    adc size+1
+    sta heap_head+1
+    rts
+}

src/test/ref/screen-show-spiral-buckets.cfg

@@ -0,0 +1,85 @@
+@begin: scope:[]  from
+  [0] phi()
+  to:@1
+@1: scope:[]  from @begin
+  [1] phi()
+  [2] call malloc 
+  to:@4
+@4: scope:[]  from @1
+  [3] (void*) SCREEN_DIST#0 ← (void*)(byte*) malloc::mem#0
+  [4] call malloc 
+  to:@2
+@2: scope:[]  from @4
+  [5] phi()
+  [6] call malloc 
+  to:@5
+@5: scope:[]  from @2
+  [7] (void*) BUCKET_SIZES#0 ← (void*)(byte*) malloc::mem#0
+  to:@3
+@3: scope:[]  from @5
+  [8] phi()
+  [9] call main 
+  to:@end
+@end: scope:[]  from @3
+  [10] phi()
+main: scope:[main]  from @3
+  [11] phi()
+  [12] call init_dist_screen 
+  to:main::@1
+main::@1: scope:[main]  from main
+  [13] phi()
+  [14] call init_angle_screen 
+  to:main::@2
+main::@2: scope:[main]  from main::@1
+  [15] phi()
+  [16] call init_buckets 
+  to:main::@return
+main::@return: scope:[main]  from main::@2
+  [17] return 
+  to:@return
+init_buckets: scope:[init_buckets]  from main::@2
+  [18] phi()
+  to:init_buckets::@1
+init_buckets::@1: scope:[init_buckets]  from init_buckets init_buckets::@1
+  [19] (byte) init_buckets::i#2 ← phi( init_buckets/(byte) 0 init_buckets::@1/(byte) init_buckets::i#1 )
+  [20] (byte~) init_buckets::$2 ← (byte) init_buckets::i#2 << (byte) 1
+  [21] *((word*)(void*) BUCKET_SIZES#0 + (byte~) init_buckets::$2) ← (byte) 0
+  [22] (byte) init_buckets::i#1 ← ++ (byte) init_buckets::i#2
+  [23] if((byte) init_buckets::i#1!=(byte) $80) goto init_buckets::@1
+  to:init_buckets::@2
+init_buckets::@2: scope:[init_buckets]  from init_buckets::@1
+  [24] (byte*) init_buckets::dist#0 ← (byte*)(void*) SCREEN_DIST#0
+  to:init_buckets::@3
+init_buckets::@3: scope:[init_buckets]  from init_buckets::@2 init_buckets::@3
+  [25] (word) init_buckets::i1#2 ← phi( init_buckets::@2/(word) 0 init_buckets::@3/(word) init_buckets::i1#1 )
+  [25] (byte*) init_buckets::dist#2 ← phi( init_buckets::@2/(byte*) init_buckets::dist#0 init_buckets::@3/(byte*) init_buckets::dist#1 )
+  [26] (byte~) init_buckets::$3 ← *((byte*) init_buckets::dist#2) << (byte) 1
+  [27] *((word*)(void*) BUCKET_SIZES#0 + (byte~) init_buckets::$3) ← ++ *((word*)(void*) BUCKET_SIZES#0 + (byte~) init_buckets::$3)
+  [28] (byte*) init_buckets::dist#1 ← ++ (byte*) init_buckets::dist#2
+  [29] (word) init_buckets::i1#1 ← ++ (word) init_buckets::i1#2
+  [30] if((word) init_buckets::i1#1!=(word) $3e8) goto init_buckets::@3
+  to:init_buckets::@return
+init_buckets::@return: scope:[init_buckets]  from init_buckets::@3
+  [31] return 
+  to:@return
+init_angle_screen: scope:[init_angle_screen]  from main::@1
+  [32] phi()
+  to:init_angle_screen::@return
+init_angle_screen::@return: scope:[init_angle_screen]  from init_angle_screen
+  [33] return 
+  to:@return
+init_dist_screen: scope:[init_dist_screen]  from main
+  [34] phi()
+  to:init_dist_screen::@return
+init_dist_screen::@return: scope:[init_dist_screen]  from init_dist_screen
+  [35] return 
+  to:@return
+malloc: scope:[malloc]  from @1 @2 @4
+  [36] (word) malloc::size#3 ← phi( @4/(word) $3e8 @1/(word) $3e8 @2/(byte) $80*(const byte) SIZEOF_WORD )
+  [36] (byte*) heap_head#6 ← phi( @4/(byte*) heap_head#1 @1/(const byte*) HEAP_START#0 @2/(byte*) heap_head#1 )
+  [37] (byte*) malloc::mem#0 ← (byte*) heap_head#6
+  [38] (byte*) heap_head#1 ← (byte*) heap_head#6 + (word) malloc::size#3
+  to:malloc::@return
+malloc::@return: scope:[malloc]  from malloc
+  [39] return 
+  to:@return

src/test/ref/screen-show-spiral-buckets.sym

@@ -0,0 +1,61 @@
+(label) @1
+(label) @2
+(label) @3
+(label) @4
+(label) @5
+(label) @begin
+(label) @end
+(word*) BUCKET_SIZES
+(void*) BUCKET_SIZES#0 BUCKET_SIZES zp ZP_WORD:10 0.1
+(byte*) HEAP_START
+(const byte*) HEAP_START#0 HEAP_START = (byte*) 49152
+(byte*) SCREEN_ANGLE
+(byte*) SCREEN_DIST
+(void*) SCREEN_DIST#0 SCREEN_DIST zp ZP_WORD:2 0.11764705882352941
+(const byte) SIZEOF_WORD SIZEOF_WORD = (byte) 2
+(byte*) heap_head
+(byte*) heap_head#1 heap_head zp ZP_WORD:6 1.0
+(byte*) heap_head#6 heap_head zp ZP_WORD:6 4.0
+(void()) init_angle_screen((byte*) init_angle_screen::screen)
+(label) init_angle_screen::@return
+(byte*) init_angle_screen::screen
+(void()) init_buckets()
+(byte~) init_buckets::$2 reg byte a 22.0
+(byte~) init_buckets::$3 reg byte a 33.0
+(label) init_buckets::@1
+(label) init_buckets::@2
+(label) init_buckets::@3
+(label) init_buckets::@return
+(byte*) init_buckets::dist
+(byte*) init_buckets::dist#0 dist zp ZP_WORD:2 4.0
+(byte*) init_buckets::dist#1 dist zp ZP_WORD:2 7.333333333333333
+(byte*) init_buckets::dist#2 dist zp ZP_WORD:2 11.666666666666666
+(byte) init_buckets::i
+(byte) init_buckets::i#1 reg byte x 16.5
+(byte) init_buckets::i#2 reg byte x 11.0
+(word) init_buckets::i1
+(word) init_buckets::i1#1 i1 zp ZP_WORD:4 16.5
+(word) init_buckets::i1#2 i1 zp ZP_WORD:4 5.5
+(void()) init_dist_screen((byte*) init_dist_screen::screen)
+(label) init_dist_screen::@return
+(byte*) init_dist_screen::screen
+(void()) main()
+(label) main::@1
+(label) main::@2
+(label) main::@return
+(void*()) malloc((word) malloc::size)
+(label) malloc::@return
+(byte*) malloc::mem
+(byte*) malloc::mem#0 mem zp ZP_WORD:10 0.4
+(void*) malloc::return
+(word) malloc::size
+(word) malloc::size#3 size zp ZP_WORD:8 1.0
+
+reg byte x [ init_buckets::i#2 init_buckets::i#1 ]
+zp ZP_WORD:2 [ init_buckets::dist#2 init_buckets::dist#0 init_buckets::dist#1 SCREEN_DIST#0 ]
+zp ZP_WORD:4 [ init_buckets::i1#2 init_buckets::i1#1 ]
+zp ZP_WORD:6 [ heap_head#6 heap_head#1 ]
+zp ZP_WORD:8 [ malloc::size#3 ]
+zp ZP_WORD:10 [ BUCKET_SIZES#0 malloc::mem#0 ]
+reg byte a [ init_buckets::$2 ]
+reg byte a [ init_buckets::$3 ]