version 3.0

forever loop is gone (use repeat without iteration count).
struct literal is now same as array literal [...] to avoid parsing ambiguity with scope blocks.

.gitignore

@@ -14,7 +14,7 @@ docs/build
 out/
 parser/**/*.interp
 parser/**/*.tokens
-
+parser/**/*.java
 *.py[cod]
 *.egg
 *.egg-info

README.md

@@ -1,5 +1,6 @@
 [![saythanks](https://img.shields.io/badge/say-thanks-ff69b4.svg)](https://saythanks.io/to/irmen)
 [![Build Status](https://travis-ci.org/irmen/prog8.svg?branch=master)](https://travis-ci.org/irmen/prog8)
+[![Documentation](https://readthedocs.org/projects/prog8/badge/?version=latest)](https://prog8.readthedocs.io/)
 
 Prog8 - Structured Programming Language for 8-bit 6502/6510 microprocessors
 ===========================================================================
@@ -17,7 +18,7 @@ which aims to provide many conveniences over raw assembly code (even when using
 - modularity, symbol scoping, subroutines
 - various data types other than just bytes (16-bit words, floats, strings)
 - automatic variable allocations, automatic string and array variables and string sharing
-- subroutines with a input- and output parameter signature
+- subroutines with an input- and output parameter signature
 - constant folding in expressions
 - conditional branches
 - 'when' statement to provide a concise jump table alternative to if/elseif chains
@@ -30,20 +31,18 @@ which aims to provide many conveniences over raw assembly code (even when using
 
 Rapid edit-compile-run-debug cycle:
 
-- use modern PC to work on
-- quick compilation times (seconds)
-- option to automatically run the program in the Vice emulator
+- use a modern PC to do the work on
+- very quick compilation times
+- can automatically run the program in the Vice emulator after succesful compilation
 - breakpoints, that let the Vice emulator drop into the monitor if execution hits them
 - source code labels automatically loaded in Vice emulator so it can show them in disassembly
-- virtual machine that can execute compiled code directy on the host system,
-  without having to actually convert it to assembly to run on a real 6502
 
-It is mainly targeted at the Commodore-64 machine at this time.
+Prog8 is mainly targeted at the Commodore-64 machine at this time.
 Contributions to add support for other 8-bit (or other?!) machines are welcome.
 
 Documentation/manual
 --------------------
-This describes the language, but also how to build and run the compiler. See https://prog8.readthedocs.io/
+https://prog8.readthedocs.io/
 
 Required tools
 --------------

compiler/build.gradle

@@ -1,11 +1,11 @@
 buildscript {
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.70"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.72"
     }
 }
 
 plugins {
-    // id "org.jetbrains.kotlin.jvm" version "1.3.70"
+    // id "org.jetbrains.kotlin.jvm" version "1.3.72"
     id 'application'
     id 'org.jetbrains.dokka' version "0.9.18"
     id 'com.github.johnrengelman.shadow' version '5.2.0'

compiler/res/prog8lib/c64floats.asm

@@ -658,8 +658,8 @@ func_all_f	.proc
 		dey
 		cmp  #0
 		beq  +
-        cpy  #255
-        bne  -
+		cpy  #255
+        	bne  -
 		lda  #1
 		sta  c64.ESTACK_LO+1,x
 		rts
@@ -739,3 +739,60 @@ sign_f		.proc
 		dex
 		rts
 		.pend
+
+
+set_0_array_float	.proc
+		; -- set a float in an array to zero (index on stack, array in SCRATCH_ZPWORD1)
+		inx
+		lda  c64.ESTACK_LO,x
+		asl  a
+		asl  a
+		clc
+		adc  c64.ESTACK_LO,x
+		tay
+		lda  #0
+		sta  (c64.SCRATCH_ZPWORD1),y
+		iny
+		sta  (c64.SCRATCH_ZPWORD1),y
+		iny
+		sta  (c64.SCRATCH_ZPWORD1),y
+		iny
+		sta  (c64.SCRATCH_ZPWORD1),y
+		iny
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
+		.pend
+
+
+set_array_float		.proc
+		; -- set a float in an array to a value (index on stack, float in SCRATCH_ZPWORD1, array in SCRATCH_ZPWORD2)
+		inx
+		lda  c64.ESTACK_LO,x
+		asl  a
+		asl  a
+		clc
+		adc  c64.ESTACK_LO,x
+		clc
+		adc  c64.SCRATCH_ZPWORD2
+		ldy  c64.SCRATCH_ZPWORD2+1
+		bcc  +
+		iny
++		jmp  copy_float
+			; -- copies the 5 bytes of the mflt value pointed to by SCRATCH_ZPWORD1,
+			;    into the 5 bytes pointed to by A/Y.  Clobbers A,Y.
+		.pend
+
+
+swap_floats	.proc
+		; -- swap floats pointed to by SCRATCH_ZPWORD1, SCRATCH_ZPWORD2
+		ldy  #4
+-               lda  (c64.SCRATCH_ZPWORD1),y
+		pha
+		lda  (c64.SCRATCH_ZPWORD2),y
+		sta  (c64.SCRATCH_ZPWORD1),y
+		pla
+		sta  (c64.SCRATCH_ZPWORD2),y
+		dey
+		bpl  -
+		rts
+		.pend

compiler/res/prog8lib/c64flt.p8

@@ -10,8 +10,8 @@
 c64flt {
 	; ---- this block contains C-64 floating point related functions ----
 
-		const  float  PI	= 3.141592653589793
-		const  float  TWOPI	= 6.283185307179586
+        const  float  PI        = 3.141592653589793
+        const  float  TWOPI	    = 6.283185307179586
 
 
 ; ---- C64 basic and kernal ROM float constants and functions ----
@@ -34,7 +34,8 @@ c64flt {
 		&float  FL_PIHALF	= $e2e0  ; PI / 2
 		&float  FL_TWOPI	= $e2e5  ; 2 * PI
 		&float  FL_FR4		= $e2ea  ; .25
-		 float  FL_ZERO		= 0.0    ; oddly enough 0.0 isn't available in the kernel
+		; oddly enough, 0.0 isn't available in the kernel.
+        float   FL_ZERO     = 0.0    ; oddly enough 0.0 isn't available in the kernel
 
 
 ; note: fac1/2 might get clobbered even if not mentioned in the function's name.
@@ -209,8 +210,8 @@ sub  print_fln  (float value) {
 	; ---- prints the floating point value (with a newline at the end) using basic rom routines
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
-		lda  #<print_fln_value
-		ldy  #>print_fln_value
+		lda  #<value
+		ldy  #>value
 		jsr  MOVFM		; load float into fac1
 		jsr  FPRINTLN		; print fac1 with newline
 		ldx  c64.SCRATCH_ZPREGX

compiler/res/prog8lib/c64utils.p8

@@ -565,14 +565,9 @@ asmsub  clear_screenchars (ubyte char @ A) clobbers(Y)  {
 	%asm {{
 		ldy  #0
 _loop		sta  c64.Screen,y
-		sta  c64.Screen+1,y
 		sta  c64.Screen+$0100,y
-		sta  c64.Screen+$0101,y
 		sta  c64.Screen+$0200,y
-		sta  c64.Screen+$0201,y
 		sta  c64.Screen+$02e8,y
-		sta  c64.Screen+$02e9,y
-		iny
 		iny
 		bne  _loop
 		rts
@@ -585,14 +580,9 @@ asmsub  clear_screencolors (ubyte color @ A) clobbers(Y)  {
 	%asm {{
 		ldy  #0
 _loop		sta  c64.Colors,y
-		sta  c64.Colors+1,y
 		sta  c64.Colors+$0100,y
-		sta  c64.Colors+$0101,y
 		sta  c64.Colors+$0200,y
-		sta  c64.Colors+$0201,y
 		sta  c64.Colors+$02e8,y
-		sta  c64.Colors+$02e9,y
-		iny
 		iny
 		bne  _loop
 		rts
@@ -603,6 +593,7 @@ asmsub  scroll_left_full  (ubyte alsocolors @ Pc) clobbers(A, Y)  {
 	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
+
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
 		bcs  +
@@ -612,18 +603,7 @@ asmsub  scroll_left_full  (ubyte alsocolors @ Pc) clobbers(A, Y)  {
 		ldx  #0
 		ldy  #38
 -
-	.for row=0, row<=12, row+=1
-		lda  c64.Colors + 40*row + 1,x
-		sta  c64.Colors + 40*row,x
-	.next
-		inx
-		dey
-		bpl  -
-
-		ldx  #0
-		ldy  #38
--
-	.for row=13, row<=24, row+=1
+	.for row=0, row<=24, row+=1
 		lda  c64.Colors + 40*row + 1,x
 		sta  c64.Colors + 40*row,x
 	.next
@@ -635,18 +615,7 @@ _scroll_screen  ; scroll the screen memory
 		ldx  #0
 		ldy  #38
 -
-	.for row=0, row<=12, row+=1
-		lda  c64.Screen + 40*row + 1,x
-		sta  c64.Screen + 40*row,x
-	.next
-		inx
-		dey
-		bpl  -
-
-		ldx  #0
-		ldy  #38
--
-	.for row=13, row<=24, row+=1
+	.for row=0, row<=24, row+=1
 		lda  c64.Screen + 40*row + 1,x
 		sta  c64.Screen + 40*row,x
 	.next
@@ -671,41 +640,23 @@ asmsub  scroll_right_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 +               ; scroll the color memory
 		ldx  #38
 -
-	.for row=0, row<=12, row+=1
+	.for row=0, row<=24, row+=1
 		lda  c64.Colors + 40*row + 0,x
 		sta  c64.Colors + 40*row + 1,x
 	.next
 		dex
 		bpl  -
 
-		ldx  #38
--
-	.for row=13, row<=24, row+=1
-		lda  c64.Colors + 40*row,x
-		sta  c64.Colors + 40*row + 1,x
-	.next
-		dex
-		bpl  -
-
 _scroll_screen  ; scroll the screen memory
 		ldx  #38
 -
-	.for row=0, row<=12, row+=1
+	.for row=0, row<=24, row+=1
 		lda  c64.Screen + 40*row + 0,x
 		sta  c64.Screen + 40*row + 1,x
 	.next
 		dex
 		bpl  -
 
-		ldx  #38
--
-	.for row=13, row<=24, row+=1
-		lda  c64.Screen + 40*row,x
-		sta  c64.Screen + 40*row + 1,x
-	.next
-		dex
-		bpl  -
-
 		ldx  c64.SCRATCH_ZPREGX
 		rts
 	}}
@@ -723,16 +674,7 @@ asmsub  scroll_up_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 +               ; scroll the color memory
 		ldx #39
 -
-	.for row=1, row<=11, row+=1
-		lda  c64.Colors + 40*row,x
-		sta  c64.Colors + 40*(row-1),x
-	.next
-		dex
-		bpl  -
-
-		ldx #39
--
-	.for row=12, row<=24, row+=1
+	.for row=1, row<=24, row+=1
 		lda  c64.Colors + 40*row,x
 		sta  c64.Colors + 40*(row-1),x
 	.next
@@ -742,16 +684,7 @@ asmsub  scroll_up_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 _scroll_screen  ; scroll the screen memory
 		ldx #39
 -
-	.for row=1, row<=11, row+=1
-		lda  c64.Screen + 40*row,x
-		sta  c64.Screen + 40*(row-1),x
-	.next
-		dex
-		bpl  -
-
-		ldx #39
--
-	.for row=12, row<=24, row+=1
+	.for row=1, row<=24, row+=1
 		lda  c64.Screen + 40*row,x
 		sta  c64.Screen + 40*(row-1),x
 	.next
@@ -775,16 +708,7 @@ asmsub  scroll_down_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 +               ; scroll the color memory
 		ldx #39
 -
-	.for row=23, row>=12, row-=1
-		lda  c64.Colors + 40*row,x
-		sta  c64.Colors + 40*(row+1),x
-	.next
-		dex
-		bpl  -
-
-		ldx #39
--
-	.for row=11, row>=0, row-=1
+	.for row=23, row>=0, row-=1
 		lda  c64.Colors + 40*row,x
 		sta  c64.Colors + 40*(row+1),x
 	.next
@@ -794,16 +718,7 @@ asmsub  scroll_down_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 _scroll_screen  ; scroll the screen memory
 		ldx #39
 -
-	.for row=23, row>=12, row-=1
-		lda  c64.Screen + 40*row,x
-		sta  c64.Screen + 40*(row+1),x
-	.next
-		dex
-		bpl  -
-
-		ldx #39
--
-	.for row=11, row>=0, row-=1
+	.for row=23, row>=0, row-=1
 		lda  c64.Screen + 40*row,x
 		sta  c64.Screen + 40*(row+1),x
 	.next
@@ -862,11 +777,14 @@ _print_byte_digits
 		beq  +
 		tya
 		jsr  c64.CHROUT
+		pla
+		jsr  c64.CHROUT
+		jmp  _ones
 +       pla
         cmp  #'0'
-        beq  +
+        beq  _ones
         jsr  c64.CHROUT
-+       txa
+_ones   txa
 		jsr  c64.CHROUT
 		ldx  c64.SCRATCH_ZPREGX
 		rts

compiler/res/prog8lib/math.asm

@@ -239,7 +239,7 @@ mul_byte_3	.proc
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
-		
+
 mul_word_3	.proc
 		; W*2 + W
 		lda  c64.ESTACK_HI+1,x
@@ -255,7 +255,7 @@ mul_word_3	.proc
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
-		
+
 
 mul_byte_5	.proc
 		; X*4 + X
@@ -286,7 +286,7 @@ mul_word_5	.proc
 		rts
 		.pend
 
-		
+
 mul_byte_6	.proc
 		; (X*2 + X)*2
 		lda  c64.ESTACK_LO+1,x
@@ -327,7 +327,7 @@ mul_byte_7	.proc
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
-		
+
 mul_word_7	.proc
 		; W*8 - W
 		lda  c64.ESTACK_HI+1,x
@@ -411,7 +411,7 @@ mul_word_10	.proc
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
-		
+
 mul_byte_11	.proc
 		; (X*2 + X)*4 - X
 		lda  c64.ESTACK_LO+1,x
@@ -488,7 +488,7 @@ mul_byte_14	.proc
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
-		
+
 ; mul_word_14 is skipped (too much code)
 
 mul_byte_15	.proc
@@ -604,7 +604,7 @@ mul_word_25	.proc
 		adc  c64.ESTACK_HI+1,x
 		sta  c64.ESTACK_HI+1,x
 		rts
-		.pend		
+		.pend
 
 mul_byte_40	.proc
 		; (X*4 + X)*8
@@ -619,7 +619,7 @@ mul_byte_40	.proc
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
-		
+
 mul_word_40	.proc
 		; (W*4 + W)*8
 		lda  c64.ESTACK_HI+1,x
@@ -680,3 +680,192 @@ _sign_possibly_zero	lda  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
+
+
+
+; bit shifts.
+; anything below 3 is done inline. anything above 7 is done via other optimizations.
+
+shift_left_w_7	.proc
+		lda  c64.ESTACK_HI+1,x
+		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_LO+1,x
+
+		asl  a
+		rol  c64.SCRATCH_ZPB1
+_shift6		asl  a
+		rol  c64.SCRATCH_ZPB1
+_shift5		asl  a
+		rol  c64.SCRATCH_ZPB1
+_shift4		asl  a
+		rol  c64.SCRATCH_ZPB1
+_shift3		asl  a
+		rol  c64.SCRATCH_ZPB1
+		asl  a
+		rol  c64.SCRATCH_ZPB1
+		asl  a
+		rol  c64.SCRATCH_ZPB1
+
+		sta  c64.ESTACK_LO+1,x
+		lda  c64.SCRATCH_ZPB1
+		sta  c64.ESTACK_HI+1,x
+		rts
+		.pend
+
+shift_left_w_6	.proc
+		lda  c64.ESTACK_HI+1,x
+		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_LO+1,x
+		jmp  shift_left_w_7._shift6
+		.pend
+
+shift_left_w_5	.proc
+		lda  c64.ESTACK_HI+1,x
+		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_LO+1,x
+		jmp  shift_left_w_7._shift5
+		.pend
+
+shift_left_w_4	.proc
+		lda  c64.ESTACK_HI+1,x
+		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_LO+1,x
+		jmp  shift_left_w_7._shift4
+		.pend
+
+shift_left_w_3	.proc
+		lda  c64.ESTACK_HI+1,x
+		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_LO+1,x
+		jmp  shift_left_w_7._shift3
+		.pend
+
+shift_right_uw_7	.proc
+		lda  c64.ESTACK_LO+1,x
+		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_HI+1,x
+
+		lsr  a
+		ror  c64.SCRATCH_ZPB1
+_shift6		lsr  a
+		ror  c64.SCRATCH_ZPB1
+_shift5		lsr  a
+		ror  c64.SCRATCH_ZPB1
+_shift4		lsr  a
+		ror  c64.SCRATCH_ZPB1
+_shift3		lsr  a
+		ror  c64.SCRATCH_ZPB1
+		lsr  a
+		ror  c64.SCRATCH_ZPB1
+		lsr  a
+		ror  c64.SCRATCH_ZPB1
+
+		sta  c64.ESTACK_HI+1,x
+		lda  c64.SCRATCH_ZPB1
+		sta  c64.ESTACK_LO+1,x
+		rts
+		.pend
+
+shift_right_uw_6	.proc
+		lda  c64.ESTACK_LO+1,x
+		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_HI+1,x
+		jmp  shift_right_uw_7._shift6
+		.pend
+
+shift_right_uw_5	.proc
+		lda  c64.ESTACK_LO+1,x
+		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_HI+1,x
+		jmp  shift_right_uw_7._shift5
+		.pend
+
+shift_right_uw_4	.proc
+		lda  c64.ESTACK_LO+1,x
+		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_HI+1,x
+		jmp  shift_right_uw_7._shift4
+		.pend
+
+shift_right_uw_3	.proc
+		lda  c64.ESTACK_LO+1,x
+		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_HI+1,x
+		jmp  shift_right_uw_7._shift3
+		.pend
+
+
+shift_right_w_7		.proc
+		lda  c64.ESTACK_LO+1,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI+1,x
+		sta  c64.SCRATCH_ZPWORD1+1
+
+		asl  a
+		ror  c64.SCRATCH_ZPWORD1+1
+		ror  c64.SCRATCH_ZPWORD1
+
+		lda  c64.SCRATCH_ZPWORD1+1
+_shift6		asl  a
+		ror  c64.SCRATCH_ZPWORD1+1
+		ror  c64.SCRATCH_ZPWORD1
+		lda  c64.SCRATCH_ZPWORD1+1
+_shift5		asl  a
+		ror  c64.SCRATCH_ZPWORD1+1
+		ror  c64.SCRATCH_ZPWORD1
+		lda  c64.SCRATCH_ZPWORD1+1
+_shift4		asl  a
+		ror  c64.SCRATCH_ZPWORD1+1
+		ror  c64.SCRATCH_ZPWORD1
+		lda  c64.SCRATCH_ZPWORD1+1
+_shift3		asl  a
+		ror  c64.SCRATCH_ZPWORD1+1
+		ror  c64.SCRATCH_ZPWORD1
+		lda  c64.SCRATCH_ZPWORD1+1
+		asl  a
+		ror  c64.SCRATCH_ZPWORD1+1
+		ror  c64.SCRATCH_ZPWORD1
+		lda  c64.SCRATCH_ZPWORD1+1
+		asl  a
+		ror  c64.SCRATCH_ZPWORD1+1
+		ror  c64.SCRATCH_ZPWORD1
+
+		lda  c64.SCRATCH_ZPWORD1
+		sta  c64.ESTACK_LO+1,x
+		lda  c64.SCRATCH_ZPWORD1+1
+		sta  c64.ESTACK_HI+1,x
+		rts
+		.pend
+
+shift_right_w_6	.proc
+		lda  c64.ESTACK_LO+1,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI+1,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		jmp  shift_right_w_7._shift6
+		.pend
+
+shift_right_w_5	.proc
+		lda  c64.ESTACK_LO+1,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI+1,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		jmp  shift_right_w_7._shift5
+		.pend
+
+shift_right_w_4	.proc
+		lda  c64.ESTACK_LO+1,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI+1,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		jmp  shift_right_w_7._shift4
+		.pend
+
+shift_right_w_3	.proc
+		lda  c64.ESTACK_LO+1,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI+1,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		jmp  shift_right_w_7._shift3
+		.pend
+

compiler/res/prog8lib/prog8lib.asm

@@ -1788,7 +1788,6 @@ ror2_mem_ub	.proc
 
 rol2_mem_ub	.proc
 		; -- in-place 8-bit rol of byte at memory location on stack
-		;"  lda  ${number.toHex()} |  cmp  #\$80 |  rol  a |  sta  ${number.toHex()}"
 		inx
 		lda  c64.ESTACK_LO,x
 		sta  c64.SCRATCH_ZPWORD1
@@ -1803,57 +1802,403 @@ rol2_mem_ub	.proc
 		.pend
 
 lsl_array_b	.proc
-		.warn "lsl_array_b"		; TODO
-		.pend
-
-lsl_array_w	.proc
-		.warn "lsl_array_w"		; TODO
+		; -- lsl a (u)byte in an array (index and array address on stack)
+		inx
+		ldy  c64.ESTACK_LO,x
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		lda  (c64.SCRATCH_ZPWORD1),y
+		asl  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
 		.pend
 
 lsr_array_ub	.proc
-		.warn "lsr_array_ub"		; TODO
+		; -- lsr a ubyte in an array (index and array address on stack)
+		inx
+		ldy  c64.ESTACK_LO,x
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		lda  (c64.SCRATCH_ZPWORD1),y
+		lsr  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
 		.pend
 
 lsr_array_b	.proc
-		.warn "lsr_array_b"		; TODO
+		; -- lsr a byte in an array (index and array address on stack)
+		inx
+		ldy  c64.ESTACK_LO,x
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		lda  (c64.SCRATCH_ZPWORD1),y
+		asl  a
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ror  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
+		.pend
+
+lsl_array_w	.proc
+		; -- lsl a (u)word in an array (index and array address on stack)
+		inx
+		lda  c64.ESTACK_LO,x
+		asl  a
+		tay
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		lda  (c64.SCRATCH_ZPWORD1),y
+		asl  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		rol  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
 		.pend
 
 lsr_array_uw	.proc
-		.warn "lsr_array_uw"		; TODO
+		; -- lsr a uword in an array (index and array address on stack)
+		inx
+		lda  c64.ESTACK_LO,x
+		asl  a
+		tay
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		lsr  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ror  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
 		.pend
 
 lsr_array_w	.proc
-		.warn "lsr_array_w"		; TODO
+		; -- lsr a uword in an array (index and array address on stack)
+		inx
+		lda  c64.ESTACK_LO,x
+		asl  a
+		tay
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		asl  a
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ror  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ror  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
 		.pend
 
 rol_array_ub	.proc
-		.warn "rol_array_ub"		; TODO
+		; -- rol a ubyte in an array (index and array address on stack)
+		inx
+		ldy  c64.ESTACK_LO,x
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		lda  (c64.SCRATCH_ZPWORD1),y
+		rol  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
 		.pend
 
-rol_array_uw	.proc
-		.warn "rol_array_uw"		; TODO
-		.pend
-
-rol2_array_ub	.proc
-		.warn "rol2_array_ub"		; TODO
-		.pend
-
-rol2_array_uw	.proc
-		.warn "rol2_array_uw"		; TODO
-		.pend
 
 ror_array_ub	.proc
-		.warn "ror_array_ub"		; TODO
-		.pend
-
-ror_array_uw	.proc
-		.warn "ror_array_uw"		; TODO
+		; -- ror a ubyte in an array (index and array address on stack)
+		inx
+		ldy  c64.ESTACK_LO,x
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ror  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
 		.pend
 
 ror2_array_ub	.proc
-		.warn "ror2_array_ub"		; TODO
+		; -- ror2 (8-bit ror) a ubyte in an array (index and array address on stack)
+		inx
+		ldy  c64.ESTACK_LO,x
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		lda  (c64.SCRATCH_ZPWORD1),y
+		lsr  a
+		bcc  +
+		ora  #$80
++		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
+		.pend
+
+rol2_array_ub	.proc
+		; -- rol2 (8-bit rol) a ubyte in an array (index and array address on stack)
+		inx
+		ldy  c64.ESTACK_LO,x
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		lda  (c64.SCRATCH_ZPWORD1),y
+		cmp  #$80
+		rol  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
+		.pend
+
+ror_array_uw	.proc
+		; -- ror a uword in an array (index and array address on stack)
+		php
+		inx
+		lda  c64.ESTACK_LO,x
+		asl  a
+		tay
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		plp
+		ror  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ror  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
+		.pend
+
+rol_array_uw	.proc
+		; -- rol a uword in an array (index and array address on stack)
+		php
+		inx
+		lda  c64.ESTACK_LO,x
+		asl  a
+		tay
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		lda  (c64.SCRATCH_ZPWORD1),y
+		plp
+		rol  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		rol  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
+		.pend
+
+rol2_array_uw	.proc
+		; -- rol2 (16-bit rol) a uword in an array (index and array address on stack)
+		inx
+		lda  c64.ESTACK_LO,x
+		asl  a
+		tay
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		lda  (c64.SCRATCH_ZPWORD1),y
+		asl  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		rol  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		bcc  +
+		dey
+		lda  (c64.SCRATCH_ZPWORD1),y
+		adc  #0
+		sta  (c64.SCRATCH_ZPWORD1),y
++		rts
 		.pend
 
 ror2_array_uw	.proc
-		.warn "ror2_array_uw"		; TODO
+		; -- ror2 (16-bit ror) a uword in an array (index and array address on stack)
+		inx
+		lda  c64.ESTACK_LO,x
+		asl  a
+		tay
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		lsr  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ror  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		bcc  +
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ora  #$80
+		sta  (c64.SCRATCH_ZPWORD1),y
++		rts
+		.pend
+
+		
+strcpy		.proc
+		; copy a string (0-terminated) from A/Y to (ZPWORD1)
+		; it is assumed the target string is large enough.
+		sta  c64.SCRATCH_ZPWORD2
+		sty  c64.SCRATCH_ZPWORD2+1
+		ldy  #$ff
+-		iny
+		lda  (c64.SCRATCH_ZPWORD2),y
+		sta  (c64.SCRATCH_ZPWORD1),y
+		bne  -
+		rts
+		.pend
+		
+		
+func_leftstr	.proc
+		; leftstr(source, target, length) with params on stack
+		inx
+		lda  c64.ESTACK_LO,x
+		tay			; length
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD2
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD2+1
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		lda  #0
+		sta  (c64.SCRATCH_ZPWORD2),y
+-		dey
+		cpy  #$ff
+		bne  +
+		rts
++		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  (c64.SCRATCH_ZPWORD2),y
+		jmp  -
+		.pend
+
+func_rightstr	.proc
+		; rightstr(source, target, length) with params on stack
+		; make place for the 4 parameters for substr()
+		dex
+		dex
+		dex
+		dex
+		; X-> .
+		; x+1 -> length of segment
+		; x+2 -> start index
+		; X+3 -> target LO+HI
+		; X+4 -> source LO+HI
+		; original parameters:
+		;  x+5 -> original length LO
+		;  x+6 -> original targetLO + HI
+		;  x+7 -> original sourceLO + HI
+		; replicate paramters:
+		lda  c64.ESTACK_LO+5,x
+		sta  c64.ESTACK_LO+1,x
+		lda  c64.ESTACK_LO+6,x
+		sta  c64.ESTACK_LO+3,x
+		lda  c64.ESTACK_HI+6,x
+		sta  c64.ESTACK_HI+3,x
+		lda  c64.ESTACK_LO+7,x
+		sta  c64.ESTACK_LO+4,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI+7,x
+		sta  c64.ESTACK_HI+4,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		; determine string length
+		ldy  #0
+-		lda  (c64.SCRATCH_ZPWORD1),y
+		beq  +
+		iny
+		bne  -
++		tya
+		sec
+		sbc  c64.ESTACK_LO+1,x  ; start index = strlen - segment length
+		sta  c64.ESTACK_LO+2,x
+		jsr  func_substr
+		; unwind original params
+		inx
+		inx
+		inx
+		rts
+		.pend
+
+func_substr	.proc
+		; substr(source, target, start, length) with params on stack
+		inx
+		ldy  c64.ESTACK_LO,x	; length
+		inx
+		lda  c64.ESTACK_LO,x	; start
+		sta  c64.SCRATCH_ZPB1
+		inx
+		lda  c64.ESTACK_LO,x	
+		sta  c64.SCRATCH_ZPWORD2
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD2+1
+		inx
+		lda  c64.ESTACK_LO,x	
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		; adjust src location
+		clc
+		lda  c64.SCRATCH_ZPWORD1
+		adc  c64.SCRATCH_ZPB1
+		sta  c64.SCRATCH_ZPWORD1
+		bcc  +
+		inc  c64.SCRATCH_ZPWORD1+1
++		lda  #0
+		sta  (c64.SCRATCH_ZPWORD2),y
+		jmp  _startloop
+-		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  (c64.SCRATCH_ZPWORD2),y
+_startloop	dey
+		cpy  #$ff
+		bne  -
+		rts
+
 		.pend

compiler/res/version.txt

@@ -1 +1 @@
-1.81
+3.0

compiler/src/prog8/CompilerMain.kt

@@ -9,7 +9,6 @@ import prog8.compiler.target.c64.C64MachineDefinition
 import prog8.compiler.target.c64.Petscii
 import prog8.compiler.target.c64.codegen.AsmGen
 import prog8.parser.ParsingFailedError
-import prog8.vm.astvm.AstVm
 import java.io.IOException
 import java.nio.file.FileSystems
 import java.nio.file.Path
@@ -40,7 +39,6 @@ private fun compileMain(args: Array<String>) {
     val outputDir by cli.flagValueArgument("-out", "directory", "directory for output files instead of current directory", ".")
     val dontWriteAssembly by cli.flagArgument("-noasm", "don't create assembly code")
     val dontOptimize by cli.flagArgument("-noopt", "don't perform any optimizations")
-    val launchSimulator by cli.flagArgument("-sim", "launch the builtin execution simulator after compilation")
     val watchMode by cli.flagArgument("-watch", "continuous compilation mode (watches for file changes), greatly increases compilation speed")
     val compilationTarget by cli.flagValueArgument("-target", "compilertarget", "target output of the compiler, currently only 'c64' (C64 6502 assembly) available", "c64")
     val moduleFiles by cli.positionalArgumentsList("modules", "main module file(s) to compile", minArgs = 1)
@@ -119,18 +117,6 @@ private fun compileMain(args: Array<String>) {
                 exitProcess(1)
             }
 
-            if (launchSimulator) {
-//                val c64 = razorvine.c64emu.C64Machine("C64 emulator launched from Prog8 compiler")
-//                c64.cpu.addBreakpoint(0xea31) { cpu, address ->
-//                    println("zz")
-//                    Cpu6502.BreakpointResultAction()
-//                }
-//                c64.start()
-                println("\nLaunching AST-based simulator...")
-                val vm = AstVm(compilationResult.programAst, compilationTarget)
-                vm.run()
-            }
-
             if (startEmulator) {
                 if (compilationResult.programName.isEmpty())
                     println("\nCan't start emulator because no program was assembled.")

compiler/src/prog8/ast/AstToSourceCode.kt

@@ -102,6 +102,12 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
     }
 
     override fun visit(decl: VarDecl) {
+
+        // if the vardecl is a parameter of a subroutine, don't output it again
+        val paramNames = (decl.definingScope() as? Subroutine)?.parameters?.map { it.name }
+        if(paramNames!=null && decl.name in paramNames)
+            return
+
         when(decl.type) {
             VarDeclType.VAR -> {}
             VarDeclType.CONST -> output("const ")
@@ -177,8 +183,6 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
 
     private fun outputStatements(statements: List<Statement>) {
         for(stmt in statements) {
-            if(stmt is VarDecl && stmt.autogeneratedDontRemove)
-                continue    // skip autogenerated decls (to avoid generating a newline)
             outputi("")
             stmt.accept(this)
             output("\n")
@@ -283,16 +287,8 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
     }
 
     override fun visit(assignment: Assignment) {
-        if(assignment is VariableInitializationAssignment) {
-            val targetVar = assignment.target.identifier?.targetVarDecl(program.namespace)
-            if(targetVar?.struct != null) {
-                // skip STRUCT init assignments
-                return
-            }
-        }
-
         assignment.target.accept(this)
-        if (assignment.aug_op != null)
+        if (assignment.aug_op != null && assignment.aug_op != "setvalue")
             output(" ${assignment.aug_op} ")
         else
             output(" = ")
@@ -314,10 +310,7 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
 
     override fun visit(forLoop: ForLoop) {
         output("for ")
-        if(forLoop.loopRegister!=null)
-            output(forLoop.loopRegister.toString())
-        else
-            forLoop.loopVar!!.accept(this)
+        forLoop.loopVar.accept(this)
         output(" in ")
         forLoop.iterable.accept(this)
         output(" ")
@@ -331,16 +324,18 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
         whileLoop.body.accept(this)
     }
 
-    override fun visit(foreverLoop: ForeverLoop) {
-        output("forever ")
-        foreverLoop.body.accept(this)
-    }
-
     override fun visit(repeatLoop: RepeatLoop) {
         output("repeat ")
+        repeatLoop.iterations?.accept(this)
+        output(" ")
         repeatLoop.body.accept(this)
+    }
+
+    override fun visit(untilLoop: UntilLoop) {
+        output("do ")
+        untilLoop.body.accept(this)
         output(" until ")
-        repeatLoop.untilCondition.accept(this)
+        untilLoop.untilCondition.accept(this)
     }
 
     override fun visit(returnStmt: Return) {
@@ -356,12 +351,8 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
     }
 
     override fun visit(assignTarget: AssignTarget) {
-        if(assignTarget.register!=null)
-            output(assignTarget.register.toString())
-        else {
-            assignTarget.memoryAddress?.accept(this)
-            assignTarget.identifier?.accept(this)
-        }
+        assignTarget.memoryAddress?.accept(this)
+        assignTarget.identifier?.accept(this)
         assignTarget.arrayindexed?.accept(this)
     }
 
@@ -402,10 +393,6 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
         outputlni("}}")
     }
 
-    override fun visit(registerExpr: RegisterExpr) {
-        output(registerExpr.register.toString())
-    }
-
     override fun visit(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder) {
         output(builtinFunctionStatementPlaceholder.name)
     }
@@ -440,10 +427,6 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
         outputln("")
     }
 
-    override fun visit(structLv: StructLiteralValue) {
-        outputListMembers(structLv.values.asSequence(), '{', '}')
-    }
-
     override fun visit(nopStatement: NopStatement) {
         output("; NOP @ ${nopStatement.position}  $nopStatement")
     }

compiler/src/prog8/ast/AstToplevel.kt

@@ -3,6 +3,8 @@ package prog8.ast
 import prog8.ast.base.*
 import prog8.ast.expressions.Expression
 import prog8.ast.expressions.IdentifierReference
+import prog8.ast.processing.AstWalker
+import prog8.ast.processing.IAstVisitor
 import prog8.ast.statements.*
 import prog8.functions.BuiltinFunctions
 import java.nio.file.Path
@@ -33,6 +35,8 @@ interface Node {
             return this
         throw FatalAstException("scope missing from $this")
     }
+
+    fun replaceChildNode(node: Node, replacement: Node)
 }
 
 interface IFunctionCall {
@@ -48,32 +52,31 @@ interface INameScope {
 
     fun linkParents(parent: Node)
 
-    fun subScopes(): Map<String, INameScope> {
-        val subscopes = mutableMapOf<String, INameScope>()
+    fun subScope(name: String): INameScope? {
         for(stmt in statements) {
             when(stmt) {
                 // NOTE: if other nodes are introduced that are a scope, or contain subscopes, they must be added here!
-                is ForLoop -> subscopes[stmt.body.name] = stmt.body
-                is RepeatLoop -> subscopes[stmt.body.name] = stmt.body
-                is WhileLoop -> subscopes[stmt.body.name] = stmt.body
+                is ForLoop -> if(stmt.body.name==name) return stmt.body
+                is UntilLoop -> if(stmt.body.name==name) return stmt.body
+                is WhileLoop -> if(stmt.body.name==name) return stmt.body
                 is BranchStatement -> {
-                    subscopes[stmt.truepart.name] = stmt.truepart
-                    if(stmt.elsepart.containsCodeOrVars())
-                        subscopes[stmt.elsepart.name] = stmt.elsepart
+                    if(stmt.truepart.name==name) return stmt.truepart
+                    if(stmt.elsepart.containsCodeOrVars() && stmt.elsepart.name==name) return stmt.elsepart
                 }
                 is IfStatement -> {
-                    subscopes[stmt.truepart.name] = stmt.truepart
-                    if(stmt.elsepart.containsCodeOrVars())
-                        subscopes[stmt.elsepart.name] = stmt.elsepart
+                    if(stmt.truepart.name==name) return stmt.truepart
+                    if(stmt.elsepart.containsCodeOrVars() && stmt.elsepart.name==name) return stmt.elsepart
                 }
                 is WhenStatement -> {
-                    stmt.choices.forEach { subscopes[it.statements.name] = it.statements }
+                    val scope = stmt.choices.firstOrNull { it.statements.name==name }
+                    if(scope!=null)
+                        return scope.statements
                 }
-                is INameScope -> subscopes[stmt.name] = stmt
+                is INameScope -> if(stmt.name==name) return stmt
                 else -> {}
             }
         }
-        return subscopes
+        return null
     }
 
     fun getLabelOrVariable(name: String): Statement? {
@@ -121,7 +124,7 @@ interface INameScope {
             for(module in localContext.definingModule().program.modules) {
                 var scope: INameScope? = module
                 for(name in scopedName.dropLast(1)) {
-                    scope = scope?.subScopes()?.get(name)
+                    scope = scope?.subScope(name)
                     if(scope==null)
                         break
                 }
@@ -129,7 +132,7 @@ interface INameScope {
                     val result = scope.getLabelOrVariable(scopedName.last())
                     if(result!=null)
                         return result
-                    return scope.subScopes()[scopedName.last()] as Statement?
+                    return scope.subScope(scopedName.last()) as Statement?
                 }
             }
             return null
@@ -141,7 +144,7 @@ interface INameScope {
                 val result = localScope.getLabelOrVariable(scopedName[0])
                 if (result != null)
                     return result
-                val subscope = localScope.subScopes()[scopedName[0]] as Statement?
+                val subscope = localScope.subScope(scopedName[0]) as Statement?
                 if (subscope != null)
                     return subscope
                 // not found in this scope, look one higher up
@@ -152,6 +155,7 @@ interface INameScope {
     }
 
     fun containsCodeOrVars() = statements.any { it !is Directive || it.directive == "%asminclude" || it.directive == "%asm"}
+    fun containsNoVars() = statements.all { it !is VarDecl }
     fun containsNoCodeNorVars() = !containsCodeOrVars()
 
     fun remove(stmt: Statement) {
@@ -171,10 +175,11 @@ interface INameScope {
                         find(it.truepart)
                         find(it.elsepart)
                     }
+                    is UntilLoop -> find(it.body)
                     is RepeatLoop -> find(it.body)
-                    is ForeverLoop -> find(it.body)
                     is WhileLoop -> find(it.body)
                     is WhenStatement -> it.choices.forEach { choice->find(choice.statements) }
+                    else -> { /* do nothing */ }
                 }
             }
         }
@@ -182,6 +187,14 @@ interface INameScope {
         find(this)
         return result
     }
+
+    fun nextSibling(stmt: Statement): Statement? {
+        val nextIdx = statements.indexOfFirst { it===stmt } + 1
+        return if(nextIdx < statements.size)
+            statements[nextIdx]
+        else
+            null
+    }
 }
 
 interface IAssignable {
@@ -191,7 +204,7 @@ interface IAssignable {
 
 /*********** Everything starts from here, the Program; zero or more modules *************/
 
-class Program(val name: String, val modules: MutableList<Module>) {
+class Program(val name: String, val modules: MutableList<Module>): Node {
     val namespace = GlobalNamespace(modules)
 
     val definedLoadAddress: Int
@@ -206,11 +219,29 @@ class Program(val name: String, val modules: MutableList<Module>) {
         return if(mainBlocks.isEmpty()) {
             null
         } else {
-            mainBlocks[0].subScopes()["start"] as Subroutine?
+            mainBlocks[0].subScope("start") as Subroutine?
         }
     }
 
     fun allBlocks(): List<Block> = modules.flatMap { it.statements.filterIsInstance<Block>() }
+
+    override val position: Position = Position.DUMMY
+    override var parent: Node
+        get() = throw FatalAstException("program has no parent")
+        set(value) = throw FatalAstException("can't set parent of program")
+
+    override fun linkParents(parent: Node) {
+        modules.forEach {
+            it.linkParents(this)
+        }
+    }
+
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(node is Module && replacement is Module)
+        val idx = modules.indexOfFirst { it===node }
+        modules[idx] = replacement
+        replacement.parent = this
+    }
 }
 
 class Module(override val name: String,
@@ -218,6 +249,7 @@ class Module(override val name: String,
              override val position: Position,
              val isLibraryModule: Boolean,
              val source: Path) : Node, INameScope {
+
     override lateinit var parent: Node
     lateinit var program: Program
     val importedBy = mutableListOf<Module>()
@@ -231,10 +263,20 @@ class Module(override val name: String,
     }
 
     override fun definingScope(): INameScope = program.namespace
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(node is Statement && replacement is Statement)
+        val idx = statements.indexOfFirst { it===node }
+        statements[idx] = replacement
+        replacement.parent = this
+    }
 
     override fun toString() = "Module(name=$name, pos=$position, lib=$isLibraryModule)"
+
+    fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
+
 class GlobalNamespace(val modules: List<Module>): Node, INameScope {
     override val name = "<<<global>>>"
     override val position = Position("<<<global>>>", 0, 0, 0)
@@ -245,6 +287,10 @@ class GlobalNamespace(val modules: List<Module>): Node, INameScope {
         modules.forEach { it.linkParents(this) }
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        throw FatalAstException("cannot replace anything in the namespace")
+    }
+
     override fun lookup(scopedName: List<String>, localContext: Node): Statement? {
         if (scopedName.size == 1 && scopedName[0] in BuiltinFunctions) {
             // builtin functions always exist, return a dummy localContext for them
@@ -270,7 +316,7 @@ class GlobalNamespace(val modules: List<Module>): Node, INameScope {
         return when (val stmt = localContext.definingModule().lookup(scopedName, localContext)) {
             is Label, is VarDecl, is Block, is Subroutine -> stmt
             null -> null
-            else -> throw SyntaxError("wrong identifier target: $stmt", stmt.position)
+            else -> throw SyntaxError("wrong identifier target for $scopedName: $stmt", stmt.position)
         }
     }
 }

compiler/src/prog8/ast/antlr/Antr2Kotlin.kt

@@ -205,14 +205,14 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
     val forloop = forloop()?.toAst()
     if(forloop!=null) return forloop
 
-    val repeatloop = repeatloop()?.toAst()
-    if(repeatloop!=null) return repeatloop
+    val untilloop = untilloop()?.toAst()
+    if(untilloop!=null) return untilloop
 
     val whileloop = whileloop()?.toAst()
     if(whileloop!=null) return whileloop
 
-    val foreverloop = foreverloop()?.toAst()
-    if(foreverloop!=null) return foreverloop
+    val repeatloop = repeatloop()?.toAst()
+    if(repeatloop!=null) return repeatloop
 
     val breakstmt = breakstmt()?.toAst()
     if(breakstmt!=null) return breakstmt
@@ -247,7 +247,7 @@ private class AsmsubDecl(val name: String,
                          val returntypes: List<DataType>,
                          val asmParameterRegisters: List<RegisterOrStatusflag>,
                          val asmReturnvaluesRegisters: List<RegisterOrStatusflag>,
-                         val asmClobbers: Set<Register>)
+                         val asmClobbers: Set<CpuRegister>)
 
 private fun prog8Parser.Asmsub_declContext.toAst(): AsmsubDecl {
     val name = identifier().text
@@ -274,24 +274,43 @@ private class AsmSubroutineReturn(val type: DataType,
                                   val stack: Boolean,
                                   val position: Position)
 
-private fun prog8Parser.ClobberContext.toAst(): Set<Register>
-        = this.register().asSequence().map { it.toAst() }.toSet()
-
 private fun prog8Parser.Asmsub_returnsContext.toAst(): List<AsmSubroutineReturn>
-        = asmsub_return().map { AsmSubroutineReturn(it.datatype().toAst(), it.registerorpair()?.toAst(), it.statusregister()?.toAst(), !it.stack?.text.isNullOrEmpty(), toPosition()) }
+        = asmsub_return().map {
+            val register = it.identifier()?.toAst()
+            var registerorpair: RegisterOrPair? = null
+            var statusregister: Statusflag? = null
+            if(register!=null) {
+                when (val name = register.nameInSource.single()) {
+                    in RegisterOrPair.names -> registerorpair = RegisterOrPair.valueOf(name)
+                    in Statusflag.names -> statusregister = Statusflag.valueOf(name)
+                    else -> throw FatalAstException("invalid register or status flag in $it")
+                }
+            }
+            AsmSubroutineReturn(
+                    it.datatype().toAst(),
+                    registerorpair,
+                    statusregister,
+                    !it.stack?.text.isNullOrEmpty(), toPosition())
+        }
 
 private fun prog8Parser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParameter>
         = asmsub_param().map {
     val vardecl = it.vardecl()
     val datatype = vardecl.datatype()?.toAst() ?: DataType.STRUCT
-    AsmSubroutineParameter(vardecl.varname.text, datatype,
-            it.registerorpair()?.toAst(),
-            it.statusregister()?.toAst(),
+    val register = it.identifier()?.toAst()
+    var registerorpair: RegisterOrPair? = null
+    var statusregister: Statusflag? = null
+    if(register!=null) {
+        when (val name = register.nameInSource.single()) {
+            in RegisterOrPair.names -> registerorpair = RegisterOrPair.valueOf(name)
+            in Statusflag.names -> statusregister = Statusflag.valueOf(name)
+            else -> throw FatalAstException("invalid register or status flag in $it")
+        }
+    }
+    AsmSubroutineParameter(vardecl.varname.text, datatype, registerorpair, statusregister,
             !it.stack?.text.isNullOrEmpty(), toPosition())
 }
 
-private fun prog8Parser.StatusregisterContext.toAst() = Statusflag.valueOf(text)
-
 private fun prog8Parser.Functioncall_stmtContext.toAst(): Statement {
     val void = this.VOID() != null
     val location = scoped_identifier().toAst()
@@ -350,23 +369,22 @@ private fun prog8Parser.Sub_paramsContext.toAst(): List<SubroutineParameter> =
         }
 
 private fun prog8Parser.Assign_targetContext.toAst() : AssignTarget {
-    val register = register()?.toAst()
     val identifier = scoped_identifier()
     return when {
-        register!=null -> AssignTarget(register, null, null, null, toPosition())
-        identifier!=null -> AssignTarget(null, identifier.toAst(), null, null, toPosition())
-        arrayindexed()!=null -> AssignTarget(null, null, arrayindexed().toAst(), null, toPosition())
-        directmemory()!=null -> AssignTarget(null, null, null, DirectMemoryWrite(directmemory().expression().toAst(), toPosition()), toPosition())
-        else -> AssignTarget(null, scoped_identifier()?.toAst(), null, null, toPosition())
+        identifier!=null -> AssignTarget(identifier.toAst(), null, null, toPosition())
+        arrayindexed()!=null -> AssignTarget(null, arrayindexed().toAst(), null, toPosition())
+        directmemory()!=null -> AssignTarget(null, null, DirectMemoryWrite(directmemory().expression().toAst(), toPosition()), toPosition())
+        else -> AssignTarget(scoped_identifier()?.toAst(), null, null, toPosition())
     }
 }
 
-private fun prog8Parser.RegisterContext.toAst() = Register.valueOf(text.toUpperCase())
+private fun prog8Parser.ClobberContext.toAst() : Set<CpuRegister> {
+    val names = this.identifier().map { it.toAst().nameInSource.single() }
+    return names.map { CpuRegister.valueOf(it) }.toSet()
+}
 
 private fun prog8Parser.DatatypeContext.toAst() = DataType.valueOf(text.toUpperCase())
 
-private fun prog8Parser.RegisterorpairContext.toAst() = RegisterOrPair.valueOf(text.toUpperCase())
-
 private fun prog8Parser.ArrayindexContext.toAst() : ArrayIndex =
         ArrayIndex(expression().toAst(), toPosition())
 
@@ -469,18 +487,11 @@ private fun prog8Parser.ExpressionContext.toAst() : Expression {
                     // the ConstantFold takes care of that and converts the type if needed.
                     ArrayLiteralValue(InferredTypes.InferredType.unknown(), array, position = litval.toPosition())
                 }
-                litval.structliteral()!=null -> {
-                    val values = litval.structliteral().expression().map { it.toAst() }
-                    StructLiteralValue(values, litval.toPosition())
-                }
                 else -> throw FatalAstException("invalid parsed literal")
             }
         }
     }
 
-    if(register()!=null)
-        return RegisterExpr(register().toAst(), register().toPosition())
-
     if(scoped_identifier()!=null)
         return scoped_identifier().toAst()
 
@@ -572,15 +583,14 @@ private fun prog8Parser.Branch_stmtContext.toAst(): BranchStatement {
 private fun prog8Parser.BranchconditionContext.toAst() = BranchCondition.valueOf(text.substringAfter('_').toUpperCase())
 
 private fun prog8Parser.ForloopContext.toAst(): ForLoop {
-    val loopregister = register()?.toAst()
-    val loopvar = identifier()?.toAst()
+    val loopvar = identifier().toAst()
     val iterable = expression()!!.toAst()
     val scope =
             if(statement()!=null)
                 AnonymousScope(mutableListOf(statement().toAst()), statement().toPosition())
             else
                 AnonymousScope(statement_block().toAst(), statement_block().toPosition())
-    return ForLoop(loopregister, loopvar, iterable, scope, toPosition())
+    return ForLoop(loopvar, iterable, scope, toPosition())
 }
 
 private fun prog8Parser.ContinuestmtContext.toAst() = Continue(toPosition())
@@ -595,19 +605,20 @@ private fun prog8Parser.WhileloopContext.toAst(): WhileLoop {
     return WhileLoop(condition, scope, toPosition())
 }
 
-private fun prog8Parser.ForeverloopContext.toAst(): ForeverLoop {
+private fun prog8Parser.RepeatloopContext.toAst(): RepeatLoop {
+    val iterations = expression()?.toAst()
     val statements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
     val scope = AnonymousScope(statements, statement_block()?.toPosition()
             ?: statement().toPosition())
-    return ForeverLoop(scope, toPosition())
+    return RepeatLoop(iterations, scope, toPosition())
 }
 
-private fun prog8Parser.RepeatloopContext.toAst(): RepeatLoop {
+private fun prog8Parser.UntilloopContext.toAst(): UntilLoop {
     val untilCondition = expression().toAst()
     val statements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
     val scope = AnonymousScope(statements, statement_block()?.toPosition()
             ?: statement().toPosition())
-    return RepeatLoop(scope, untilCondition, toPosition())
+    return UntilLoop(scope, untilCondition, toPosition())
 }
 
 private fun prog8Parser.WhenstmtContext.toAst(): WhenStatement {

compiler/src/prog8/ast/base/Base.kt

@@ -24,7 +24,7 @@ enum class DataType {
      * is the type assignable to the given other type?
      */
     infix fun isAssignableTo(targetType: DataType) =
-            // what types are assignable to others without loss of precision?
+            // what types are assignable to others, perhaps via a typecast, without loss of precision?
             when(this) {
                 UBYTE -> targetType in setOf(UBYTE, WORD, UWORD, FLOAT)
                 BYTE -> targetType in setOf(BYTE, WORD, FLOAT)
@@ -64,7 +64,7 @@ enum class DataType {
     }
 }
 
-enum class Register {
+enum class CpuRegister {
     A,
     X,
     Y
@@ -76,14 +76,23 @@ enum class RegisterOrPair {
     Y,
     AX,
     AY,
-    XY
+    XY;
+
+    companion object {
+        val names by lazy { values().map { it.toString()} }
+    }
+
 }       // only used in parameter and return value specs in asm subroutines
 
 enum class Statusflag {
     Pc,
     Pz,
     Pv,
-    Pn
+    Pn;
+
+    companion object {
+        val names by lazy { values().map { it.toString()} }
+    }
 }
 
 enum class BranchCondition {
@@ -150,8 +159,15 @@ object ParentSentinel : Node {
     override val position = Position("<<sentinel>>", 0, 0, 0)
     override var parent: Node = this
     override fun linkParents(parent: Node) {}
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        replacement.parent = this
+    }
 }
 
 data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) {
     override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]"
+
+    companion object {
+        val DUMMY = Position("<dummy>", 0, 0, 0)
+    }
 }

compiler/src/prog8/ast/base/ErrorReporting.kt

@@ -8,13 +8,13 @@ class ErrorReporter {
         WARNING,
         ERROR
     }
-    private class CompilerMessage(val severity: MessageSeverity, val message: String, val position: Position?)
+    private class CompilerMessage(val severity: MessageSeverity, val message: String, val position: Position)
 
     private val messages = mutableListOf<CompilerMessage>()
     private val alreadyReportedMessages = mutableSetOf<String>()
 
-    fun err(msg: String, position: Position?) = messages.add(CompilerMessage(MessageSeverity.ERROR, msg, position))
-    fun warn(msg: String, position: Position?) = messages.add(CompilerMessage(MessageSeverity.WARNING, msg, position))
+    fun err(msg: String, position: Position) = messages.add(CompilerMessage(MessageSeverity.ERROR, msg, position))
+    fun warn(msg: String, position: Position) = messages.add(CompilerMessage(MessageSeverity.WARNING, msg, position))
 
     fun handle() {
         var numErrors = 0

compiler/src/prog8/ast/base/Errors.kt

@@ -2,7 +2,7 @@ package prog8.ast.base
 
 import prog8.ast.expressions.IdentifierReference
 
-class FatalAstException (override var message: String) : Exception(message)
+open class FatalAstException (override var message: String) : Exception(message)
 
 open class AstException (override var message: String) : Exception(message)
 

compiler/src/prog8/ast/base/Extensions.kt

@@ -4,17 +4,8 @@ import prog8.ast.Module
 import prog8.ast.Program
 import prog8.ast.processing.*
 import prog8.compiler.CompilationOptions
-import prog8.optimizer.FlattenAnonymousScopesAndRemoveNops
-
-
-// the name of the subroutine that should be called for every block to initialize its variables
-internal const val initvarsSubName="prog8_init_vars"
-
-
-internal fun Program.removeNopsFlattenAnonScopes() {
-    val flattener = FlattenAnonymousScopesAndRemoveNops()
-    flattener.visit(this)
-}
+import prog8.compiler.BeforeAsmGenerationAstChanger
+import prog8.optimizer.AssignmentTransformer
 
 
 internal fun Program.checkValid(compilerOptions: CompilationOptions, errors: ErrorReporter) {
@@ -22,29 +13,44 @@ internal fun Program.checkValid(compilerOptions: CompilationOptions, errors: Err
     checker.visit(this)
 }
 
-
-internal fun Program.anonscopeVarsCleanup(errors: ErrorReporter) {
-    val mover = AnonymousScopeVarsCleanup(errors)
-    mover.visit(this)
+internal fun Program.processAstBeforeAsmGeneration(errors: ErrorReporter) {
+    val fixer = BeforeAsmGenerationAstChanger(this, errors)
+    fixer.visit(this)
+    fixer.applyModifications()
 }
 
-
 internal fun Program.reorderStatements() {
-    val initvalueCreator = VarInitValueAndAddressOfCreator(this)
-    initvalueCreator.visit(this)
-
-    val checker = StatementReorderer(this)
-    checker.visit(this)
+    val reorder = StatementReorderer(this)
+    reorder.visit(this)
+    reorder.applyModifications()
 }
 
 internal fun Program.addTypecasts(errors: ErrorReporter) {
     val caster = TypecastsAdder(this, errors)
     caster.visit(this)
+    caster.applyModifications()
 }
 
-internal fun Module.checkImportedValid(errors: ErrorReporter) {
-    val checker = ImportedModuleDirectiveRemover(errors)
-    checker.visit(this)
+internal fun Program.verifyFunctionArgTypes() {
+    val fixer = VerifyFunctionArgTypes(this)
+    fixer.visit(this)
+}
+
+internal fun Program.transformAssignments(errors: ErrorReporter) {
+    val transform = AssignmentTransformer(this, errors)
+    transform.visit(this)
+    while(transform.optimizationsDone>0 && errors.isEmpty()) {
+        transform.applyModifications()
+        transform.optimizationsDone = 0
+        transform.visit(this)
+    }
+    transform.applyModifications()
+}
+
+internal fun Module.checkImportedValid() {
+    val imr = ImportedModuleDirectiveRemover()
+    imr.visit(this, this.parent)
+    imr.applyModifications()
 }
 
 internal fun Program.checkRecursion(errors: ErrorReporter) {
@@ -53,18 +59,24 @@ internal fun Program.checkRecursion(errors: ErrorReporter) {
     checker.processMessages(name)
 }
 
-
 internal fun Program.checkIdentifiers(errors: ErrorReporter) {
-    val checker = AstIdentifiersChecker(this, errors)
-    checker.visit(this)
 
-    if(modules.map {it.name}.toSet().size != modules.size) {
+    val checker2 = AstIdentifiersChecker(this, errors)
+    checker2.visit(this)
+
+    if(errors.isEmpty()) {
+        val transforms = AstVariousTransforms(this)
+        transforms.visit(this)
+        transforms.applyModifications()
+    }
+
+    if (modules.map { it.name }.toSet().size != modules.size) {
         throw FatalAstException("modules should all be unique")
     }
 }
 
-
-internal fun Program.makeForeverLoops() {
-    val checker = MakeForeverLoops()
-    checker.visit(this)
+internal fun Program.variousCleanups() {
+    val process = VariousCleanups()
+    process.visit(this)
+    process.applyModifications()
 }

compiler/src/prog8/ast/expressions/AstExpressions.kt

@@ -3,11 +3,12 @@ package prog8.ast.expressions
 import prog8.ast.*
 import prog8.ast.antlr.escape
 import prog8.ast.base.*
-import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.processing.AstWalker
 import prog8.ast.processing.IAstVisitor
 import prog8.ast.statements.*
 import prog8.compiler.target.CompilationTarget
 import prog8.functions.BuiltinFunctions
+import prog8.functions.CannotEvaluateException
 import prog8.functions.NotConstArgumentException
 import prog8.functions.builtinFunctionReturnType
 import java.util.*
@@ -19,30 +20,28 @@ val associativeOperators = setOf("+", "*", "&", "|", "^", "or", "and", "xor", "=
 
 sealed class Expression: Node {
     abstract fun constValue(program: Program): NumericLiteralValue?
-    abstract fun accept(visitor: IAstModifyingVisitor): Expression
     abstract fun accept(visitor: IAstVisitor)
-    abstract fun referencesIdentifiers(vararg name: String): Boolean     // todo: remove this and add identifier usage tracking into CallGraph instead
+    abstract fun accept(visitor: AstWalker, parent: Node)
+    abstract fun referencesIdentifiers(vararg name: String): Boolean
     abstract fun inferType(program: Program): InferredTypes.InferredType
 
     infix fun isSameAs(other: Expression): Boolean {
         if(this===other)
             return true
-        when(this) {
-            is RegisterExpr ->
-                return (other is RegisterExpr && other.register==register)
+        return when(this) {
             is IdentifierReference ->
-                return (other is IdentifierReference && other.nameInSource==nameInSource)
+                (other is IdentifierReference && other.nameInSource==nameInSource)
             is PrefixExpression ->
-                return (other is PrefixExpression && other.operator==operator && other.expression isSameAs expression)
+                (other is PrefixExpression && other.operator==operator && other.expression isSameAs expression)
             is BinaryExpression ->
-                return (other is BinaryExpression && other.operator==operator
+                (other is BinaryExpression && other.operator==operator
                         && other.left isSameAs left
                         && other.right isSameAs right)
             is ArrayIndexedExpression -> {
-                return (other is ArrayIndexedExpression && other.identifier.nameInSource == identifier.nameInSource
+                (other is ArrayIndexedExpression && other.identifier.nameInSource == identifier.nameInSource
                         && other.arrayspec.index isSameAs arrayspec.index)
             }
-            else -> return other==this
+            else -> other==this
         }
     }
 }
@@ -56,9 +55,16 @@ class PrefixExpression(val operator: String, var expression: Expression, overrid
         expression.linkParents(this)
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(node === expression && replacement is Expression)
+        expression = replacement
+        replacement.parent = this
+    }
+
     override fun constValue(program: Program): NumericLiteralValue? = null
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
+
     override fun referencesIdentifiers(vararg name: String) = expression.referencesIdentifiers(*name)
     override fun inferType(program: Program): InferredTypes.InferredType {
         val inferred = expression.inferType(program)
@@ -96,6 +102,16 @@ class BinaryExpression(var left: Expression, var operator: String, var right: Ex
         right.linkParents(this)
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Expression)
+        when {
+            node===left -> left = replacement
+            node===right -> right = replacement
+            else -> throw FatalAstException("invalid replace, no child $node")
+        }
+        replacement.parent = this
+    }
+
     override fun toString(): String {
         return "[$left $operator $right]"
     }
@@ -103,8 +119,9 @@ class BinaryExpression(var left: Expression, var operator: String, var right: Ex
     // binary expression should actually have been optimized away into a single value, before const value was requested...
     override fun constValue(program: Program): NumericLiteralValue? = null
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
+
     override fun referencesIdentifiers(vararg name: String) = left.referencesIdentifiers(*name) || right.referencesIdentifiers(*name)
     override fun inferType(program: Program): InferredTypes.InferredType {
         val leftDt = left.inferType(program)
@@ -205,9 +222,19 @@ class ArrayIndexedExpression(var identifier: IdentifierReference,
         arrayspec.linkParents(this)
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        when {
+            node===identifier -> identifier = replacement as IdentifierReference
+            node===arrayspec.index -> arrayspec.index = replacement as Expression
+            else -> throw FatalAstException("invalid replace")
+        }
+        replacement.parent = this
+    }
+
     override fun constValue(program: Program): NumericLiteralValue? = null
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
+
     override fun referencesIdentifiers(vararg name: String) = identifier.referencesIdentifiers(*name)
 
     override fun inferType(program: Program): InferredTypes.InferredType {
@@ -235,8 +262,15 @@ class TypecastExpression(var expression: Expression, var type: DataType, val imp
         expression.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Expression && node===expression)
+        expression = replacement
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
+
     override fun referencesIdentifiers(vararg name: String) = expression.referencesIdentifiers(*name)
     override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(type)
     override fun constValue(program: Program): NumericLiteralValue? {
@@ -259,11 +293,17 @@ data class AddressOf(var identifier: IdentifierReference, override val position:
         identifier.parent=this
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is IdentifierReference && node===identifier)
+        identifier = replacement
+        replacement.parent = this
+    }
+
     override fun constValue(program: Program): NumericLiteralValue? = null
     override fun referencesIdentifiers(vararg name: String) = false
     override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.UWORD)
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
 }
 
 class DirectMemoryRead(var addressExpression: Expression, override val position: Position) : Expression(), IAssignable {
@@ -274,8 +314,15 @@ class DirectMemoryRead(var addressExpression: Expression, override val position:
         this.addressExpression.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Expression && node===addressExpression)
+        addressExpression = replacement
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
+
     override fun referencesIdentifiers(vararg name: String) = false
     override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.UBYTE)
     override fun constValue(program: Program): NumericLiteralValue? = null
@@ -325,11 +372,15 @@ class NumericLiteralValue(val type: DataType,    // only numerical types allowed
         this.parent = parent
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        throw FatalAstException("can't replace here")
+    }
+
     override fun referencesIdentifiers(vararg name: String) = false
     override fun constValue(program: Program) = this
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
 
     override fun toString(): String = "NumericLiteral(${type.name}:$number)"
 
@@ -404,26 +455,6 @@ class NumericLiteralValue(val type: DataType,    // only numerical types allowed
     }
 }
 
-class StructLiteralValue(var values: List<Expression>,
-                         override val position: Position): Expression() {
-    override lateinit var parent: Node
-
-    override fun linkParents(parent: Node) {
-        this.parent=parent
-        values.forEach { it.linkParents(this) }
-    }
-
-    override fun constValue(program: Program): NumericLiteralValue?  = null
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
-    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
-    override fun referencesIdentifiers(vararg name: String) = values.any { it.referencesIdentifiers(*name) }
-    override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.STRUCT)
-
-    override fun toString(): String {
-        return "struct{ ${values.joinToString(", ")} }"
-    }
-}
-
 private var heapIdSequence = 0   // unique ids for strings and arrays "on the heap"
 
 class StringLiteralValue(val value: String,
@@ -436,10 +467,16 @@ class StringLiteralValue(val value: String,
     override fun linkParents(parent: Node) {
         this.parent = parent
     }
+
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        throw FatalAstException("can't replace here")
+    }
+
     override fun referencesIdentifiers(vararg name: String) = false
     override fun constValue(program: Program): NumericLiteralValue? = null
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
+
     override fun toString(): String = "'${escape(value)}'"
     override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.STR)
     operator fun compareTo(other: StringLiteralValue): Int = value.compareTo(other.value)
@@ -462,12 +499,21 @@ class ArrayLiteralValue(val type: InferredTypes.InferredType,     // inferred be
         this.parent = parent
         value.forEach {it.linkParents(this)}
     }
+
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Expression)
+        val idx = value.indexOfFirst { it===node }
+        value[idx] = replacement
+        replacement.parent = this
+    }
+
     override fun referencesIdentifiers(vararg name: String) = value.any { it.referencesIdentifiers(*name) }
     override fun constValue(program: Program): NumericLiteralValue? = null
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
+
     override fun toString(): String = "$value"
-    override fun inferType(program: Program): InferredTypes.InferredType = if(type.isUnknown) type else guessDatatype(program)
+    override fun inferType(program: Program): InferredTypes.InferredType = if(type.isKnown) type else guessDatatype(program)
 
     operator fun compareTo(other: ArrayLiteralValue): Int = throw ExpressionError("cannot order compare arrays", position)
     override fun hashCode(): Int = Objects.hash(value, type)
@@ -544,9 +590,21 @@ class RangeExpr(var from: Expression,
         step.linkParents(this)
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Expression)
+        when {
+            from===node -> from=replacement
+            to===node -> to=replacement
+            step===node -> step=replacement
+            else -> throw FatalAstException("invalid replacement")
+        }
+        replacement.parent = this
+    }
+
     override fun constValue(program: Program): NumericLiteralValue? = null
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
+
     override fun referencesIdentifiers(vararg name: String): Boolean  = from.referencesIdentifiers(*name) || to.referencesIdentifiers(*name)
     override fun inferType(program: Program): InferredTypes.InferredType {
         val fromDt=from.inferType(program)
@@ -611,24 +669,6 @@ internal fun makeRange(fromVal: Int, toVal: Int, stepVal: Int): IntProgression {
     }
 }
 
-class RegisterExpr(val register: Register, override val position: Position) : Expression(), IAssignable {
-    override lateinit var parent: Node
-
-    override fun linkParents(parent: Node) {
-        this.parent = parent
-    }
-
-    override fun constValue(program: Program): NumericLiteralValue? = null
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
-    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
-    override fun referencesIdentifiers(vararg name: String): Boolean = register.name in name
-    override fun toString(): String {
-        return "RegisterExpr(register=$register, pos=$position)"
-    }
-
-    override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.UBYTE)
-}
-
 data class IdentifierReference(val nameInSource: List<String>, override val position: Position) : Expression(), IAssignable {
     override lateinit var parent: Node
 
@@ -641,10 +681,17 @@ data class IdentifierReference(val nameInSource: List<String>, override val posi
     fun targetVarDecl(namespace: INameScope): VarDecl? = targetStatement(namespace) as? VarDecl
     fun targetSubroutine(namespace: INameScope): Subroutine? = targetStatement(namespace) as? Subroutine
 
+    override fun equals(other: Any?) = other is IdentifierReference && other.nameInSource==nameInSource
+    override fun hashCode() = nameInSource.hashCode()
+
     override fun linkParents(parent: Node) {
         this.parent = parent
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        throw FatalAstException("can't replace here")
+    }
+
     override fun constValue(program: Program): NumericLiteralValue? {
         val node = program.namespace.lookup(nameInSource, this)
                 ?: throw UndefinedSymbolError(this)
@@ -661,16 +708,17 @@ data class IdentifierReference(val nameInSource: List<String>, override val posi
         return "IdentifierRef($nameInSource)"
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
+
     override fun referencesIdentifiers(vararg name: String): Boolean = nameInSource.last() in name
 
     override fun inferType(program: Program): InferredTypes.InferredType {
         val targetStmt = targetStatement(program.namespace)
-        if(targetStmt is VarDecl) {
-            return InferredTypes.knownFor(targetStmt.datatype)
+        return if(targetStmt is VarDecl) {
+            InferredTypes.knownFor(targetStmt.datatype)
         } else {
-            throw FatalAstException("cannot get datatype from identifier reference ${this}, pos=$position")
+            InferredTypes.InferredType.unknown()
         }
     }
 
@@ -699,6 +747,16 @@ class FunctionCall(override var target: IdentifierReference,
         args.forEach { it.linkParents(this) }
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        if(node===target)
+            target=replacement as IdentifierReference
+        else {
+            val idx = args.indexOfFirst { it===node }
+            args[idx] = replacement as Expression
+        }
+        replacement.parent = this
+    }
+
     override fun constValue(program: Program) = constValue(program, true)
 
     private fun constValue(program: Program, withDatatypeCheck: Boolean): NumericLiteralValue? {
@@ -729,14 +787,19 @@ class FunctionCall(override var target: IdentifierReference,
             // const-evaluating the builtin function call failed.
             return null
         }
+        catch(x: CannotEvaluateException) {
+            // const-evaluating the builtin function call failed.
+            return null
+        }
     }
 
     override fun toString(): String {
         return "FunctionCall(target=$target, pos=$position)"
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
+
     override fun referencesIdentifiers(vararg name: String): Boolean = target.referencesIdentifiers(*name) || args.any{it.referencesIdentifiers(*name)}
 
     override fun inferType(program: Program): InferredTypes.InferredType {

compiler/src/prog8/ast/processing/AnonymousScopeVarsCleanup.kt

@@ -1,41 +0,0 @@
-package prog8.ast.processing
-
-import prog8.ast.Program
-import prog8.ast.base.ErrorReporter
-import prog8.ast.statements.AnonymousScope
-import prog8.ast.statements.Statement
-import prog8.ast.statements.VarDecl
-
-class AnonymousScopeVarsCleanup(private val errors: ErrorReporter): IAstModifyingVisitor {
-    private val varsToMove: MutableMap<AnonymousScope, List<VarDecl>> = mutableMapOf()
-
-    override fun visit(program: Program) {
-        varsToMove.clear()
-        super.visit(program)
-        for((scope, decls) in varsToMove) {
-            val sub = scope.definingSubroutine()!!
-            val existingVariables = sub.statements.filterIsInstance<VarDecl>().associateBy { it.name }
-            var conflicts = false
-            decls.forEach {
-                val existing = existingVariables[it.name]
-                if (existing!=null) {
-                    errors.err("variable ${it.name} already defined in subroutine ${sub.name} at ${existing.position}", it.position)
-                    conflicts = true
-                }
-            }
-            if (!conflicts) {
-                decls.forEach { scope.remove(it) }
-                sub.statements.addAll(0, decls)
-                decls.forEach { it.parent = sub }
-            }
-        }
-    }
-
-    override fun visit(scope: AnonymousScope): Statement {
-        val scope2 = super.visit(scope) as AnonymousScope
-        val vardecls = scope2.statements.filterIsInstance<VarDecl>()
-        varsToMove[scope2] = vardecls
-        return scope2
-    }
-}
-

compiler/src/prog8/ast/processing/AstChecker.kt

@@ -21,9 +21,11 @@ internal class AstChecker(private val program: Program,
         val mainBlocks = program.modules.flatMap { it.statements }.filter { b -> b is Block && b.name=="main" }.map { it as Block }
         if(mainBlocks.size>1)
             errors.err("more than one 'main' block", mainBlocks[0].position)
+        if(mainBlocks.isEmpty())
+            errors.err("there is no 'main' block", program.modules.firstOrNull()?.position ?: program.position)
 
         for(mainBlock in mainBlocks) {
-            val startSub = mainBlock.subScopes()["start"] as? Subroutine
+            val startSub = mainBlock.subScope("start") as? Subroutine
             if (startSub == null) {
                 errors.err("missing program entrypoint ('start' subroutine in 'main' block)", mainBlock.position)
             } else {
@@ -40,7 +42,6 @@ internal class AstChecker(private val program: Program,
                     is VarDecl -> true
                     is InlineAssembly -> true
                     is INameScope -> true
-                    is VariableInitializationAssignment -> true
                     is NopStatement -> true
                     else -> false
                 }
@@ -57,7 +58,7 @@ internal class AstChecker(private val program: Program,
         if(irqBlocks.size>1)
             errors.err("more than one 'irq' block", irqBlocks[0].position)
         for(irqBlock in irqBlocks) {
-            val irqSub = irqBlock.subScopes()["irq"] as? Subroutine
+            val irqSub = irqBlock.subScope("irq") as? Subroutine
             if (irqSub != null) {
                 if (irqSub.parameters.isNotEmpty() || irqSub.returntypes.isNotEmpty())
                     errors.err("irq entrypoint subroutine can't have parameters and/or return values", irqSub.position)
@@ -81,7 +82,7 @@ internal class AstChecker(private val program: Program,
     override fun visit(returnStmt: Return) {
         val expectedReturnValues = returnStmt.definingSubroutine()?.returntypes ?: emptyList()
         if(expectedReturnValues.size>1) {
-            throw AstException("cannot use a return with one value in a subroutine that has multiple return values: $returnStmt")
+            throw FatalAstException("cannot use a return with one value in a subroutine that has multiple return values: $returnStmt")
         }
 
         if(expectedReturnValues.isEmpty() && returnStmt.value!=null) {
@@ -96,7 +97,7 @@ internal class AstChecker(private val program: Program,
                 errors.err("return value type mismatch", returnStmt.value!!.position)
             } else {
                 if (expectedReturnValues[0] != valueDt.typeOrElse(DataType.STRUCT))
-                    errors.err("type $valueDt of return value doesn't match subroutine's return type", returnStmt.value!!.position)
+                    errors.err("type $valueDt of return value doesn't match subroutine's return type ${expectedReturnValues[0]}", returnStmt.value!!.position)
             }
         }
         super.visit(returnStmt)
@@ -109,49 +110,37 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(forLoop: ForLoop) {
-        if(forLoop.body.containsNoCodeNorVars())
-            errors.warn("for loop body is empty", forLoop.position)
-
         val iterableDt = forLoop.iterable.inferType(program).typeOrElse(DataType.BYTE)
         if(iterableDt !in IterableDatatypes && forLoop.iterable !is RangeExpr) {
             errors.err("can only loop over an iterable type", forLoop.position)
         } else {
-            if (forLoop.loopRegister != null) {
-                // loop register
-                if (iterableDt != DataType.ARRAY_UB && iterableDt != DataType.ARRAY_B && iterableDt != DataType.STR)
-                    errors.err("register can only loop over bytes", forLoop.position)
-                if(forLoop.loopRegister!=Register.A)
-                    errors.err("it's only possible to use A as a loop register", forLoop.position)
+            val loopvar = forLoop.loopVar.targetVarDecl(program.namespace)
+            if(loopvar==null || loopvar.type== VarDeclType.CONST) {
+                errors.err("for loop requires a variable to loop with", forLoop.position)
             } else {
-                // loop variable
-                val loopvar = forLoop.loopVar!!.targetVarDecl(program.namespace)
-                if(loopvar==null || loopvar.type== VarDeclType.CONST) {
-                    errors.err("for loop requires a variable to loop with", forLoop.position)
-                } else {
-                    when (loopvar.datatype) {
-                        DataType.UBYTE -> {
-                            if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.ARRAY_UB && iterableDt != DataType.STR)
-                                errors.err("ubyte loop variable can only loop over unsigned bytes or strings", forLoop.position)
-                        }
-                        DataType.UWORD -> {
-                            if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.UWORD && iterableDt != DataType.STR &&
-                                    iterableDt != DataType.ARRAY_UB && iterableDt!= DataType.ARRAY_UW)
-                                errors.err("uword loop variable can only loop over unsigned bytes, words or strings", forLoop.position)
-                        }
-                        DataType.BYTE -> {
-                            if(iterableDt!= DataType.BYTE && iterableDt!= DataType.ARRAY_B)
-                                errors.err("byte loop variable can only loop over bytes", forLoop.position)
-                        }
-                        DataType.WORD -> {
-                            if(iterableDt!= DataType.BYTE && iterableDt!= DataType.WORD &&
-                                    iterableDt != DataType.ARRAY_B && iterableDt!= DataType.ARRAY_W)
-                                errors.err("word loop variable can only loop over bytes or words", forLoop.position)
-                        }
-                        DataType.FLOAT -> {
-                            errors.err("for loop only supports integers", forLoop.position)
-                        }
-                        else -> errors.err("loop variable must be numeric type", forLoop.position)
+                when (loopvar.datatype) {
+                    DataType.UBYTE -> {
+                        if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.ARRAY_UB && iterableDt != DataType.STR)
+                            errors.err("ubyte loop variable can only loop over unsigned bytes or strings", forLoop.position)
                     }
+                    DataType.UWORD -> {
+                        if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.UWORD && iterableDt != DataType.STR &&
+                                iterableDt != DataType.ARRAY_UB && iterableDt!= DataType.ARRAY_UW)
+                            errors.err("uword loop variable can only loop over unsigned bytes, words or strings", forLoop.position)
+                    }
+                    DataType.BYTE -> {
+                        if(iterableDt!= DataType.BYTE && iterableDt!= DataType.ARRAY_B)
+                            errors.err("byte loop variable can only loop over bytes", forLoop.position)
+                    }
+                    DataType.WORD -> {
+                        if(iterableDt!= DataType.BYTE && iterableDt!= DataType.WORD &&
+                                iterableDt != DataType.ARRAY_B && iterableDt!= DataType.ARRAY_W)
+                            errors.err("word loop variable can only loop over bytes or words", forLoop.position)
+                    }
+                    DataType.FLOAT -> {
+                        errors.err("for loop only supports integers", forLoop.position)
+                    }
+                    else -> errors.err("loop variable must be numeric type", forLoop.position)
                 }
             }
         }
@@ -259,27 +248,27 @@ internal class AstChecker(private val program: Program,
                 }
             }
 
-            val regCounts = mutableMapOf<Register, Int>().withDefault { 0 }
+            val regCounts = mutableMapOf<CpuRegister, Int>().withDefault { 0 }
             val statusflagCounts = mutableMapOf<Statusflag, Int>().withDefault { 0 }
             fun countRegisters(from: Iterable<RegisterOrStatusflag>) {
                 regCounts.clear()
                 statusflagCounts.clear()
                 for(p in from) {
                     when(p.registerOrPair) {
-                        RegisterOrPair.A -> regCounts[Register.A]=regCounts.getValue(Register.A)+1
-                        RegisterOrPair.X -> regCounts[Register.X]=regCounts.getValue(Register.X)+1
-                        RegisterOrPair.Y -> regCounts[Register.Y]=regCounts.getValue(Register.Y)+1
+                        RegisterOrPair.A -> regCounts[CpuRegister.A]=regCounts.getValue(CpuRegister.A)+1
+                        RegisterOrPair.X -> regCounts[CpuRegister.X]=regCounts.getValue(CpuRegister.X)+1
+                        RegisterOrPair.Y -> regCounts[CpuRegister.Y]=regCounts.getValue(CpuRegister.Y)+1
                         RegisterOrPair.AX -> {
-                            regCounts[Register.A]=regCounts.getValue(Register.A)+1
-                            regCounts[Register.X]=regCounts.getValue(Register.X)+1
+                            regCounts[CpuRegister.A]=regCounts.getValue(CpuRegister.A)+1
+                            regCounts[CpuRegister.X]=regCounts.getValue(CpuRegister.X)+1
                         }
                         RegisterOrPair.AY -> {
-                            regCounts[Register.A]=regCounts.getValue(Register.A)+1
-                            regCounts[Register.Y]=regCounts.getValue(Register.Y)+1
+                            regCounts[CpuRegister.A]=regCounts.getValue(CpuRegister.A)+1
+                            regCounts[CpuRegister.Y]=regCounts.getValue(CpuRegister.Y)+1
                         }
                         RegisterOrPair.XY -> {
-                            regCounts[Register.X]=regCounts.getValue(Register.X)+1
-                            regCounts[Register.Y]=regCounts.getValue(Register.Y)+1
+                            regCounts[CpuRegister.X]=regCounts.getValue(CpuRegister.X)+1
+                            regCounts[CpuRegister.Y]=regCounts.getValue(CpuRegister.Y)+1
                         }
                         null ->
                             if(p.statusflag!=null)
@@ -324,17 +313,13 @@ internal class AstChecker(private val program: Program,
         visitStatements(subroutine.statements)
     }
 
-    override fun visit(repeatLoop: RepeatLoop) {
-        if(repeatLoop.untilCondition.referencesIdentifiers("A", "X", "Y"))
-            errors.warn("using a register in the loop condition is risky (it could get clobbered)", repeatLoop.untilCondition.position)
-        if(repeatLoop.untilCondition.inferType(program).typeOrElse(DataType.STRUCT) !in IntegerDatatypes)
-            errors.err("condition value should be an integer type", repeatLoop.untilCondition.position)
-        super.visit(repeatLoop)
+    override fun visit(untilLoop: UntilLoop) {
+        if(untilLoop.untilCondition.inferType(program).typeOrElse(DataType.STRUCT) !in IntegerDatatypes)
+            errors.err("condition value should be an integer type", untilLoop.untilCondition.position)
+        super.visit(untilLoop)
     }
 
     override fun visit(whileLoop: WhileLoop) {
-        if(whileLoop.condition.referencesIdentifiers("A", "X", "Y"))
-            errors.warn("using a register in the loop condition is risky (it could get clobbered)", whileLoop.condition.position)
         if(whileLoop.condition.inferType(program).typeOrElse(DataType.STRUCT) !in IntegerDatatypes)
             errors.err("condition value should be an integer type", whileLoop.condition.position)
         super.visit(whileLoop)
@@ -356,17 +341,30 @@ internal class AstChecker(private val program: Program,
             }
         }
 
-        val sourceIdent = assignment.value as? IdentifierReference
         val targetIdent = assignment.target.identifier
-        if(sourceIdent!=null && targetIdent!=null) {
-            val sourceVar = sourceIdent.targetVarDecl(program.namespace)
+        if(targetIdent!=null) {
             val targetVar = targetIdent.targetVarDecl(program.namespace)
-            if(sourceVar?.struct!=null && targetVar?.struct!=null) {
-                if(sourceVar.struct!==targetVar.struct)
-                    errors.err("assignment of different struct types", assignment.position)
+            if(targetVar?.struct != null) {
+                val sourceStructLv = assignment.value as? ArrayLiteralValue
+                if (sourceStructLv != null) {
+                    if (sourceStructLv.value.size != targetVar.struct?.numberOfElements)
+                        errors.err("number of elements doesn't match struct definition", sourceStructLv.position)
+                } else {
+                    val sourceIdent = assignment.value as? IdentifierReference
+                    if (sourceIdent != null) {
+                        val sourceVar = sourceIdent.targetVarDecl(program.namespace)
+                        if (sourceVar?.struct != null) {
+                            if (sourceVar.struct !== targetVar.struct)
+                                errors.err("assignment of different struct types", assignment.position)
+                        }
+                    }
+                }
             }
         }
 
+        if(assignment.value.inferType(program) != assignment.target.inferType(program, assignment))
+            errors.err("assignment value is of different type as the target", assignment.value.position)
+
         super.visit(assignment)
     }
 
@@ -383,8 +381,7 @@ internal class AstChecker(private val program: Program,
         val targetIdentifier = assignTarget.identifier
         if (targetIdentifier != null) {
             val targetName = targetIdentifier.nameInSource
-            val targetSymbol = program.namespace.lookup(targetName, assignment)
-            when (targetSymbol) {
+            when (val targetSymbol = program.namespace.lookup(targetName, assignment)) {
                 null -> {
                     errors.err("undefined symbol: ${targetIdentifier.nameInSource.joinToString(".")}", targetIdentifier.position)
                     return
@@ -401,15 +398,14 @@ internal class AstChecker(private val program: Program,
                 }
             }
         }
-        val targetDt = assignTarget.inferType(program, assignment).typeOrElse(DataType.STR)
-        if(targetDt in IterableDatatypes)
-            errors.err("cannot assign to a string or array type", assignTarget.position)
+
+// target type check is already done at the Assignment:
+//        val targetDt = assignTarget.inferType(program, assignment).typeOrElse(DataType.STR)
+//        if(targetDt in IterableDatatypes)
+//            errors.err("cannot assign to a string or array type", assignTarget.position)
 
         if (assignment is Assignment) {
 
-            if (assignment.aug_op != null)
-                throw FatalAstException("augmented assignment should have been converted into normal assignment")
-
             val targetDatatype = assignTarget.inferType(program, assignment)
             if (targetDatatype.isKnown) {
                 val constVal = assignment.value.constValue(program)
@@ -446,7 +442,7 @@ internal class AstChecker(private val program: Program,
 
     override fun visit(decl: VarDecl) {
         fun err(msg: String, position: Position?=null) {
-            err(msg, position ?: decl.position)
+            errors.err(msg, position ?: decl.position)
         }
 
         // the initializer value can't refer to the variable itself (recursive definition)
@@ -493,57 +489,25 @@ internal class AstChecker(private val program: Program,
                     if(decl.zeropage==ZeropageWish.PREFER_ZEROPAGE || decl.zeropage==ZeropageWish.REQUIRE_ZEROPAGE)
                         err("struct can not be in zeropage")
                 }
-                if (decl.value == null) {
-                    when {
-                        decl.datatype in NumericDatatypes -> {
-                            // initialize numeric var with value zero by default.
-                            val litVal =
-                                    when (decl.datatype) {
-                                        in ByteDatatypes -> NumericLiteralValue(decl.datatype, 0, decl.position)
-                                        in WordDatatypes -> NumericLiteralValue(decl.datatype, 0, decl.position)
-                                        else -> NumericLiteralValue(decl.datatype, 0.0, decl.position)
-                                    }
-                            litVal.parent = decl
-                            decl.value = litVal
-                        }
-                        decl.datatype == DataType.STRUCT -> {
-                            // structs may be initialized with an array, but it's okay to not initialize them as well.
-                        }
-                        decl.type == VarDeclType.VAR -> {
-                            if(decl.datatype in ArrayDatatypes) {
-                                // array declaration can have an optional initialization value
-                                // if it is absent, the size must be given, which should have been checked earlier
-                                if(decl.value==null && decl.arraysize==null)
-                                    throw FatalAstException("array init check failed")
-                            }
-                        }
-                        else -> err("var/const declaration needs a compile-time constant initializer value for type ${decl.datatype}")
-                        // const fold should have provided it!
-                    }
-                    super.visit(decl)
-                    return
-                }
+
                 when(decl.value) {
+                    null -> {
+                        // a vardecl without an initial value, don't bother with the rest
+                        return super.visit(decl)
+                    }
                     is RangeExpr -> throw FatalAstException("range expression should have been converted to a true array value")
                     is StringLiteralValue -> {
                         checkValueTypeAndRangeString(decl.datatype, decl.value as StringLiteralValue)
                     }
                     is ArrayLiteralValue -> {
-                        val arraySpec = decl.arraysize ?: ArrayIndex.forArray(decl.value as ArrayLiteralValue)
-                        checkValueTypeAndRangeArray(decl.datatype, decl.struct, arraySpec, decl.value as ArrayLiteralValue)
-                    }
-                    is NumericLiteralValue -> {
-                        checkValueTypeAndRange(decl.datatype, decl.value as NumericLiteralValue)
-                    }
-                    is StructLiteralValue -> {
                         if(decl.datatype==DataType.STRUCT) {
                             val struct = decl.struct!!
-                            val structLv = decl.value as StructLiteralValue
-                            if(struct.numberOfElements != structLv.values.size) {
+                            val structLv = decl.value as ArrayLiteralValue
+                            if(struct.numberOfElements != structLv.value.size) {
                                 errors.err("struct value has incorrect number of elements", structLv.position)
                                 return
                             }
-                            for(value in structLv.values.zip(struct.statements)) {
+                            for(value in structLv.value.zip(struct.statements)) {
                                 val memberdecl = value.second as VarDecl
                                 val constValue = value.first.constValue(program)
                                 if(constValue==null) {
@@ -556,8 +520,14 @@ internal class AstChecker(private val program: Program,
                                     return
                                 }
                             }
+                        } else {
+                            val arraySpec = decl.arraysize ?: ArrayIndex.forArray(decl.value as ArrayLiteralValue)
+                            checkValueTypeAndRangeArray(decl.datatype, decl.struct, arraySpec, decl.value as ArrayLiteralValue)
                         }
                     }
+                    is NumericLiteralValue -> {
+                        checkValueTypeAndRange(decl.datatype, decl.value as NumericLiteralValue)
+                    }
                     else -> {
                         err("var/const declaration needs a compile-time constant initializer value, or range, instead found: ${decl.value!!.javaClass.simpleName}")
                         super.visit(decl)
@@ -593,6 +563,20 @@ internal class AstChecker(private val program: Program,
             }
         }
 
+        val declValue = decl.value
+        if(declValue!=null && decl.type==VarDeclType.VAR) {
+            if(decl.datatype==DataType.STRUCT) {
+                val valueIdt = declValue.inferType(program)
+                if(valueIdt.isUnknown)
+                    throw AstException("invalid value type")
+                val valueDt = valueIdt.typeOrElse(DataType.STRUCT)
+                if(valueDt !in ArrayDatatypes)
+                    err("initialisation of struct should be with array value", declValue.position)
+            } else if (!declValue.inferType(program).istype(decl.datatype)) {
+                err("initialisation value has incompatible type (${declValue.inferType(program)}) for the variable (${decl.datatype})", declValue.position)
+            }
+        }
+
         super.visit(decl)
     }
 
@@ -719,9 +703,9 @@ internal class AstChecker(private val program: Program,
     override fun visit(expr: BinaryExpression) {
         val leftIDt = expr.left.inferType(program)
         val rightIDt = expr.right.inferType(program)
-        if(!leftIDt.isKnown || !rightIDt.isKnown) {
-            throw FatalAstException("can't determine datatype of both expression operands $expr")
-        }
+        if(!leftIDt.isKnown || !rightIDt.isKnown)
+            return     // hopefully this error will be detected elsewhere
+
         val leftDt = leftIDt.typeOrElse(DataType.STRUCT)
         val rightDt = rightIDt.typeOrElse(DataType.STRUCT)
 
@@ -738,7 +722,7 @@ internal class AstChecker(private val program: Program,
             }
             "**" -> {
                 if(leftDt in IntegerDatatypes)
-                    errors.err("power operator requires floating point", expr.position)
+                    errors.err("power operator requires floating point operands", expr.position)
             }
             "and", "or", "xor" -> {
                 // only integer numeric operands accepted, and if literal constants, only boolean values accepted (0 or 1)
@@ -850,8 +834,8 @@ internal class AstChecker(private val program: Program,
 
         if(functionCallStatement.target.nameInSource.last() in setOf("lsl", "lsr", "rol", "ror", "rol2", "ror2", "swap", "sort", "reverse")) {
             // in-place modification, can't be done on literals
-            if(functionCallStatement.args.any { it !is IdentifierReference && it !is RegisterExpr && it !is ArrayIndexedExpression && it !is DirectMemoryRead }) {
-                errors.err("can't use that as argument to a in-place modifying function", functionCallStatement.args.first().position)
+            if(functionCallStatement.args.any { it !is IdentifierReference && it !is ArrayIndexedExpression && it !is DirectMemoryRead }) {
+                errors.err("invalid argument to a in-place modifying function", functionCallStatement.args.first().position)
             }
         }
         super.visit(functionCallStatement)
@@ -899,6 +883,8 @@ internal class AstChecker(private val program: Program,
                 }
             }
         } else if(target is Subroutine) {
+            if(target.regXasResult())
+                errors.warn("subroutine call return value in X register is discarded and replaced by 0", position)
             if(args.size!=target.parameters.size)
                 errors.err("invalid number of arguments", position)
             else {
@@ -917,7 +903,7 @@ internal class AstChecker(private val program: Program,
                     if(target.isAsmSubroutine) {
                         if (target.asmParameterRegisters[arg.first.index].registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.XY, RegisterOrPair.X)) {
                             if (arg.first.value !is NumericLiteralValue && arg.first.value !is IdentifierReference)
-                                errors.warn("calling a subroutine that expects X as a parameter is problematic, more so when providing complex arguments. If you see a compiler error/crash about this later, try to simplify this call", position)
+                                errors.warn("calling a subroutine that expects X as a parameter is problematic. If you see a compiler error/crash about this later, try to change this call", position)
                         }
 
                         // check if the argument types match the register(pairs)
@@ -1059,13 +1045,19 @@ internal class AstChecker(private val program: Program,
 
     private fun visitStatements(statements: List<Statement>) {
         for((index, stmt) in statements.withIndex()) {
-            if(stmt is FunctionCallStatement
-                    && stmt.target.nameInSource.last()=="exit"
-                    && index < statements.lastIndex)
-                errors.warn("unreachable code, exit call above never returns", statements[index+1].position)
-
-            if(stmt is Return && index < statements.lastIndex)
-                errors.warn("unreachable code, return statement above", statements[index+1].position)
+            if(index < statements.lastIndex && statements[index+1] !is Subroutine) {
+                when {
+                    stmt is FunctionCallStatement && stmt.target.nameInSource.last() == "exit" -> {
+                        errors.warn("unreachable code, preceding exit call will never return", statements[index + 1].position)
+                    }
+                    stmt is Return && statements[index + 1] !is Subroutine -> {
+                        errors.warn("unreachable code, preceding return statement", statements[index + 1].position)
+                    }
+                    stmt is Jump && statements[index + 1] !is Subroutine -> {
+                        errors.warn("unreachable code, preceding jump statement", statements[index + 1].position)
+                    }
+                }
+            }
 
             stmt.accept(this)
         }
@@ -1265,7 +1257,7 @@ internal class AstChecker(private val program: Program,
                 correct = array.all { it in -32768..32767 }
             }
             DataType.ARRAY_F -> correct = true
-            else -> throw AstException("invalid array type $type")
+            else -> throw FatalAstException("invalid array type $type")
         }
         if (!correct)
             errors.err("array value out of range for type $type", value.position)
@@ -1290,8 +1282,8 @@ internal class AstChecker(private val program: Program,
             DataType.STR -> sourceDatatype== DataType.STR
             DataType.STRUCT -> {
                 if(sourceDatatype==DataType.STRUCT) {
-                    val structLv = sourceValue as StructLiteralValue
-                    val numValues = structLv.values.size
+                    val structLv = sourceValue as ArrayLiteralValue
+                    val numValues = structLv.value.size
                     val targetstruct = target.identifier!!.targetVarDecl(program.namespace)!!.struct!!
                     return targetstruct.numberOfElements == numValues
                 }

compiler/src/prog8/ast/processing/AstIdentifiersChecker.kt

@@ -1,8 +1,6 @@
 package prog8.ast.processing
 
-import prog8.ast.INameScope
 import prog8.ast.Module
-import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
@@ -10,93 +8,69 @@ import prog8.ast.statements.*
 import prog8.compiler.target.CompilationTarget
 import prog8.functions.BuiltinFunctions
 
-
-internal class AstIdentifiersChecker(private val program: Program,
-                                     private val errors: ErrorReporter) : IAstModifyingVisitor {
+internal class AstIdentifiersChecker(private val program: Program, private val errors: ErrorReporter) : IAstVisitor {
     private var blocks = mutableMapOf<String, Block>()
-    private val vardeclsToAdd = mutableMapOf<INameScope, MutableList<VarDecl>>()
 
     private fun nameError(name: String, position: Position, existing: Statement) {
         errors.err("name conflict '$name', also defined in ${existing.position.file} line ${existing.position.line}", position)
     }
 
     override fun visit(module: Module) {
-        vardeclsToAdd.clear()
         blocks.clear()  // blocks may be redefined within a different module
+
         super.visit(module)
-        // add any new vardecls to the various scopes
-        for((where, decls) in vardeclsToAdd) {
-            where.statements.addAll(0, decls)
-            decls.forEach { it.linkParents(where as Node) }
-        }
     }
 
-    override fun visit(block: Block): Statement {
+    override fun visit(block: Block) {
         val existing = blocks[block.name]
         if(existing!=null)
             nameError(block.name, block.position, existing)
         else
             blocks[block.name] = block
 
-        return super.visit(block)
+        super.visit(block)
     }
 
-    override fun visit(functionCall: FunctionCall): Expression {
-        if(functionCall.target.nameInSource.size==1 && functionCall.target.nameInSource[0]=="lsb") {
-            // lsb(...) is just an alias for type cast to ubyte, so replace with "... as ubyte"
-            val typecast = TypecastExpression(functionCall.args.single(), DataType.UBYTE, false, functionCall.position)
-            typecast.linkParents(functionCall.parent)
-            return super.visit(typecast)
-        }
-        return super.visit(functionCall)
-    }
-
-    override fun visit(decl: VarDecl): Statement {
-        // first, check if there are datatype errors on the vardecl
+    override fun visit(decl: VarDecl) {
         decl.datatypeErrors.forEach { errors.err(it.message, it.position) }
 
-        // now check the identifier
         if(decl.name in BuiltinFunctions)
-            // the builtin functions can't be redefined
             errors.err("builtin function cannot be redefined", decl.position)
 
         if(decl.name in CompilationTarget.machine.opcodeNames)
             errors.err("can't use a cpu opcode name as a symbol: '${decl.name}'", decl.position)
 
-        // is it a struct variable? then define all its struct members as mangled names,
-        //    and include the original decl as well.
         if(decl.datatype==DataType.STRUCT) {
-            if(decl.structHasBeenFlattened)
+            if (decl.structHasBeenFlattened)
                 return super.visit(decl)    // don't do this multiple times
 
-            if(decl.struct==null) {
+            if (decl.struct == null) {
                 errors.err("undefined struct type", decl.position)
                 return super.visit(decl)
             }
 
-            if(decl.struct!!.statements.any { (it as VarDecl).datatype !in NumericDatatypes})
+            if (decl.struct!!.statements.any { (it as VarDecl).datatype !in NumericDatatypes })
                 return super.visit(decl)     // a non-numeric member, not supported. proper error is given by AstChecker later
 
-            if(decl.value is NumericLiteralValue) {
+            if (decl.value is NumericLiteralValue) {
                 errors.err("you cannot initialize a struct using a single value", decl.position)
                 return super.visit(decl)
             }
 
-            val decls = decl.flattenStructMembers()
-            decls.add(decl)
-            val result = AnonymousScope(decls, decl.position)
-            result.linkParents(decl.parent)
-            return result
+            if (decl.value != null && decl.value !is ArrayLiteralValue) {
+                errors.err("initializing a struct requires array literal value", decl.value?.position ?: decl.position)
+                return super.visit(decl)
+            }
         }
 
         val existing = program.namespace.lookup(listOf(decl.name), decl)
         if (existing != null && existing !== decl)
             nameError(decl.name, decl.position, existing)
 
-        return super.visit(decl)
+        super.visit(decl)
     }
 
-    override fun visit(subroutine: Subroutine): Statement {
+    override fun visit(subroutine: Subroutine) {
         if(subroutine.name in CompilationTarget.machine.opcodeNames) {
             errors.err("can't use a cpu opcode name as a symbol: '${subroutine.name}'", subroutine.position)
         } else if(subroutine.name in BuiltinFunctions) {
@@ -133,31 +107,15 @@ internal class AstIdentifiersChecker(private val program: Program,
                     nameError(name, sub.position, subroutine)
             }
 
-            // inject subroutine params as local variables (if they're not there yet) (for non-kernel subroutines and non-asm parameters)
-            // NOTE:
-            // - numeric types BYTE and WORD and FLOAT are passed by value;
-            // - strings, arrays, matrices are passed by reference (their 16-bit address is passed as an uword parameter)
-            if(subroutine.asmAddress==null) {
-                if(subroutine.asmParameterRegisters.isEmpty()) {
-                    subroutine.parameters
-                            .filter { it.name !in namesInSub }
-                            .forEach {
-                                val vardecl = VarDecl(VarDeclType.VAR, it.type, ZeropageWish.NOT_IN_ZEROPAGE, null, it.name, null, null,
-                                        isArray = false, autogeneratedDontRemove = true, position = subroutine.position)
-                                vardecl.linkParents(subroutine)
-                                subroutine.statements.add(0, vardecl)
-                            }
-                }
-            }
-
             if(subroutine.isAsmSubroutine && subroutine.statements.any{it !is InlineAssembly}) {
                 errors.err("asmsub can only contain inline assembly (%asm)", subroutine.position)
             }
         }
-        return super.visit(subroutine)
+
+        super.visit(subroutine)
     }
 
-    override fun visit(label: Label): Statement {
+    override fun visit(label: Label) {
         if(label.name in CompilationTarget.machine.opcodeNames)
             errors.err("can't use a cpu opcode name as a symbol: '${label.name}'", label.position)
 
@@ -175,176 +133,24 @@ internal class AstIdentifiersChecker(private val program: Program,
                 }
             }
         }
-        return super.visit(label)
+
+        super.visit(label)
     }
 
-    override fun visit(forLoop: ForLoop): Statement {
-        // If the for loop has a decltype, it means to declare the loopvar inside the loop body
-        // rather than reusing an already declared loopvar from an outer scope.
-        // For loops that loop over an interable variable (instead of a range of numbers) get an
-        // additional interation count variable in their scope.
-        if(forLoop.loopRegister!=null) {
-            if(forLoop.loopRegister == Register.X)
-                errors.warn("writing to the X register is dangerous, because it's used as an internal pointer", forLoop.position)
-        } else {
-            val loopVar = forLoop.loopVar
-            if (loopVar != null) {
-                val validName = forLoop.body.name.replace("<", "").replace(">", "").replace("-", "")
-                val loopvarName = "prog8_loopvar_$validName"
-                if (forLoop.iterable !is RangeExpr) {
-                    val existing = if (forLoop.body.containsNoCodeNorVars()) null else forLoop.body.lookup(listOf(loopvarName), forLoop.body.statements.first())
-                    if (existing == null) {
-                        // create loop iteration counter variable (without value, to avoid an assignment)
-                        val vardecl = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.PREFER_ZEROPAGE, null, loopvarName, null, null,
-                                isArray = false, autogeneratedDontRemove = true, position = loopVar.position)
-                        vardecl.linkParents(forLoop.body)
-                        forLoop.body.statements.add(0, vardecl)
-                        loopVar.parent = forLoop.body   // loopvar 'is defined in the body'
-                    }
-                }
-            }
-        }
-        return super.visit(forLoop)
+    override fun visit(string: StringLiteralValue) {
+        if (string.value.length !in 1..255)
+            errors.err("string literal length must be between 1 and 255", string.position)
+
+        super.visit(string)
     }
 
-    override fun visit(assignTarget: AssignTarget): AssignTarget {
-        if(assignTarget.register== Register.X)
-            errors.warn("writing to the X register is dangerous, because it's used as an internal pointer", assignTarget.position)
-        return super.visit(assignTarget)
-    }
-
-    override fun visit(returnStmt: Return): Statement {
-        if(returnStmt.value!=null) {
-            // possibly adjust any literal values returned, into the desired returning data type
-            val subroutine = returnStmt.definingSubroutine()!!
-            if(subroutine.returntypes.size!=1)
-                return returnStmt  // mismatch in number of return values, error will be printed later.
-            val lval = returnStmt.value as? NumericLiteralValue
-            returnStmt.value = lval?.cast(subroutine.returntypes.single()) ?: returnStmt.value!!
-        }
-        return super.visit(returnStmt)
-    }
-
-
-    override fun visit(arrayLiteral: ArrayLiteralValue): Expression {
-        val array = super.visit(arrayLiteral)
-        if(array is ArrayLiteralValue) {
-            val vardecl = array.parent as? VarDecl
-            // adjust the datatype of the array (to an educated guess)
-            if(vardecl!=null) {
-                val arrayDt = array.type
-                if(!arrayDt.istype(vardecl.datatype)) {
-                    val cast = array.cast(vardecl.datatype)
-                    if (cast != null) {
-                        vardecl.value = cast
-                        cast.linkParents(vardecl)
-                        return cast
-                    }
-                }
-                return array
-            }
-            else {
-                val arrayDt = array.guessDatatype(program)
-                if(arrayDt.isKnown) {
-                    // this array literal is part of an expression, turn it into an identifier reference
-                    val litval2 = array.cast(arrayDt.typeOrElse(DataType.STRUCT))
-                    return if (litval2 != null) {
-                        litval2.parent = array.parent
-                        makeIdentifierFromRefLv(litval2)
-                    } else array
-                }
-            }
-        }
-        return array
-    }
-
-    override fun visit(stringLiteral: StringLiteralValue): Expression {
-        val string = super.visit(stringLiteral)
-        if(string is StringLiteralValue) {
-            val vardecl = string.parent as? VarDecl
-            // intern the string; move it into the heap
-            if (string.value.length !in 1..255)
-                errors.err("string literal length must be between 1 and 255", string.position)
-            return if (vardecl != null)
-                string
-            else
-                makeIdentifierFromRefLv(string)  // replace the literal string by a identifier reference.
-        }
-        return string
-    }
-
-    private fun makeIdentifierFromRefLv(array: ArrayLiteralValue): IdentifierReference {
-        // a referencetype literal value that's not declared as a variable
-        // we need to introduce an auto-generated variable for this to be able to refer to the value
-        // note: if the var references the same literal value, it is not yet de-duplicated here.
-        val scope = array.definingScope()
-        val variable = VarDecl.createAuto(array)
-        return replaceWithIdentifier(variable, scope, array.parent)
-    }
-
-    private fun makeIdentifierFromRefLv(string: StringLiteralValue): IdentifierReference {
-        // a referencetype literal value that's not declared as a variable
-        // we need to introduce an auto-generated variable for this to be able to refer to the value
-        // note: if the var references the same literal value, it is not yet de-duplicated here.
-        val scope = string.definingScope()
-        val variable = VarDecl.createAuto(string)
-        return replaceWithIdentifier(variable, scope, string.parent)
-    }
-
-    private fun replaceWithIdentifier(variable: VarDecl, scope: INameScope, parent: Node): IdentifierReference {
-        val variable1 = addVarDecl(scope, variable)
-        // replace the reference literal by a identifier reference
-        val identifier = IdentifierReference(listOf(variable1.name), variable1.position)
-        identifier.parent = parent
-        return identifier
-    }
-
-    override fun visit(structDecl: StructDecl): Statement {
+    override fun visit(structDecl: StructDecl) {
         for(member in structDecl.statements){
             val decl = member as? VarDecl
             if(decl!=null && decl.datatype !in NumericDatatypes)
                 errors.err("structs can only contain numerical types", decl.position)
         }
 
-        return super.visit(structDecl)
+        super.visit(structDecl)
     }
-
-    override fun visit(expr: BinaryExpression): Expression {
-        return when {
-            expr.left is StringLiteralValue ->
-                processBinaryExprWithString(expr.left as StringLiteralValue, expr.right, expr)
-            expr.right is StringLiteralValue ->
-                processBinaryExprWithString(expr.right as StringLiteralValue, expr.left, expr)
-            else -> super.visit(expr)
-        }
-    }
-
-    private fun processBinaryExprWithString(string: StringLiteralValue, operand: Expression, expr: BinaryExpression): Expression {
-        val constvalue = operand.constValue(program)
-        if(constvalue!=null) {
-            if (expr.operator == "*") {
-                // repeat a string a number of times
-                return StringLiteralValue(string.value.repeat(constvalue.number.toInt()), string.altEncoding, expr.position)
-            }
-        }
-        if(expr.operator == "+" && operand is StringLiteralValue) {
-            // concatenate two strings
-            return StringLiteralValue("${string.value}${operand.value}", string.altEncoding, expr.position)
-        }
-        return expr
-    }
-
-    private fun addVarDecl(scope: INameScope, variable: VarDecl): VarDecl {
-        if(scope !in vardeclsToAdd)
-            vardeclsToAdd[scope] = mutableListOf()
-        val declList = vardeclsToAdd.getValue(scope)
-        val existing = declList.singleOrNull { it.name==variable.name }
-        return if(existing!=null) {
-            existing
-        } else {
-            declList.add(variable)
-            variable
-        }
-    }
-
 }

compiler/src/prog8/ast/processing/AstRecursionChecker.kt

@@ -2,6 +2,7 @@ package prog8.ast.processing
 
 import prog8.ast.INameScope
 import prog8.ast.base.ErrorReporter
+import prog8.ast.base.Position
 import prog8.ast.expressions.FunctionCall
 import prog8.ast.statements.FunctionCallStatement
 import prog8.ast.statements.Subroutine
@@ -16,7 +17,7 @@ internal class AstRecursionChecker(private val namespace: INameScope,
         if(cycle.isEmpty())
             return
         val chain = cycle.joinToString(" <-- ") { "${it.name} at ${it.position}" }
-        errors.err("Program contains recursive subroutine calls, this is not supported. Recursive chain:\n (a subroutine call in) $chain", null)
+        errors.err("Program contains recursive subroutine calls, this is not supported. Recursive chain:\n (a subroutine call in) $chain", Position.DUMMY)
     }
 
     override fun visit(functionCallStatement: FunctionCallStatement) {

compiler/src/prog8/ast/processing/AstVariousTransforms.kt

@@ -0,0 +1,176 @@
+package prog8.ast.processing
+
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+
+
+internal class AstVariousTransforms(private val program: Program) : AstWalker() {
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
+        if(functionCallStatement.target.nameInSource == listOf("swap")) {
+            // if x and y are both just identifiers, do not rewrite (there should be asm generation for that)
+            // otherwise:
+            // rewrite swap(x,y) as follows:
+            // - declare a temp variable of the same datatype
+            // - temp = x, x = y, y= temp
+            val first = functionCallStatement.args[0]
+            val second = functionCallStatement.args[1]
+            if(first !is IdentifierReference && second !is IdentifierReference) {
+                val dt = first.inferType(program).typeOrElse(DataType.STRUCT)
+                val tempname = "prog8_swaptmp_${functionCallStatement.hashCode()}"
+                val tempvardecl = VarDecl(VarDeclType.VAR, dt, ZeropageWish.DONTCARE, null, tempname, null, null, isArray = false, autogeneratedDontRemove = true, position = first.position)
+                val tempvar = IdentifierReference(listOf(tempname), first.position)
+                val assignTemp = Assignment(
+                        AssignTarget(tempvar, null, null, first.position),
+                        null,
+                        first,
+                        first.position
+                )
+                val assignFirst = Assignment(
+                        AssignTarget.fromExpr(first),
+                        null,
+                        second,
+                        first.position
+                )
+                val assignSecond = Assignment(
+                        AssignTarget.fromExpr(second),
+                        null,
+                        tempvar,
+                        first.position
+                )
+                val scope = AnonymousScope(mutableListOf(tempvardecl, assignTemp, assignFirst, assignSecond), first.position)
+                return listOf(IAstModification.ReplaceNode(functionCallStatement, scope, parent))
+            }
+        }
+
+        return noModifications
+    }
+
+    override fun before(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> {
+        if(functionCall.target.nameInSource.size==1 && functionCall.target.nameInSource[0]=="lsb") {
+            // lsb(...) is just an alias for type cast to ubyte, so replace with "... as ubyte"
+            val typecast = TypecastExpression(functionCall.args.single(), DataType.UBYTE, false, functionCall.position)
+            return listOf(IAstModification.ReplaceNode(
+                    functionCall, typecast, parent
+            ))
+        }
+
+        return noModifications
+    }
+
+    override fun before(decl: VarDecl, parent: Node): Iterable<IAstModification> {
+        // is it a struct variable? then define all its struct members as mangled names,
+        //    and include the original decl as well.
+        if(decl.datatype==DataType.STRUCT && !decl.structHasBeenFlattened) {
+            val decls = decl.flattenStructMembers()
+            decls.add(decl)
+            val result = AnonymousScope(decls, decl.position)
+            return listOf(IAstModification.ReplaceNode(
+                    decl, result, parent
+            ))
+        }
+
+        return noModifications
+    }
+
+    override fun after(subroutine: Subroutine, parent: Node): Iterable<IAstModification> {
+        // For non-kernel subroutines and non-asm parameters:
+        // inject subroutine params as local variables (if they're not there yet).
+        val symbolsInSub = subroutine.allDefinedSymbols()
+        val namesInSub = symbolsInSub.map{ it.first }.toSet()
+        if(subroutine.asmAddress==null) {
+            if(subroutine.asmParameterRegisters.isEmpty() && subroutine.parameters.isNotEmpty()) {
+                val vars = subroutine.statements.filterIsInstance<VarDecl>().map { it.name }.toSet()
+                if(!vars.containsAll(subroutine.parameters.map{it.name})) {
+                    return subroutine.parameters
+                            .filter { it.name !in namesInSub }
+                            .map {
+                                val vardecl = ParameterVarDecl(it.name, it.type, subroutine.position)
+                                IAstModification.InsertFirst(vardecl, subroutine)
+                            }
+                }
+            }
+        }
+
+        return noModifications
+    }
+
+    override fun before(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
+        when {
+            expr.left is StringLiteralValue ->
+                return listOf(IAstModification.ReplaceNode(
+                        expr,
+                        processBinaryExprWithString(expr.left as StringLiteralValue, expr.right, expr),
+                        parent
+                ))
+            expr.right is StringLiteralValue ->
+                return listOf(IAstModification.ReplaceNode(
+                        expr,
+                        processBinaryExprWithString(expr.right as StringLiteralValue, expr.left, expr),
+                        parent
+                ))
+        }
+
+        return noModifications
+    }
+
+    override fun after(string: StringLiteralValue, parent: Node): Iterable<IAstModification> {
+        if(string.parent !is VarDecl) {
+            // replace the literal string by a identifier reference to a new local vardecl
+            val vardecl = VarDecl.createAuto(string)
+            val identifier = IdentifierReference(listOf(vardecl.name), vardecl.position)
+            return listOf(
+                    IAstModification.ReplaceNode(string, identifier, parent),
+                    IAstModification.InsertFirst(vardecl, string.definingScope() as Node)
+            )
+        }
+        return noModifications
+    }
+
+    override fun after(array: ArrayLiteralValue, parent: Node): Iterable<IAstModification> {
+        val vardecl = array.parent as? VarDecl
+        if(vardecl!=null) {
+            // adjust the datatype of the array (to an educated guess)
+            val arrayDt = array.type
+            if(!arrayDt.istype(vardecl.datatype)) {
+                val cast = array.cast(vardecl.datatype)
+                if (cast != null && cast!=array)
+                    return listOf(IAstModification.ReplaceNode(vardecl.value!!, cast, vardecl))
+            }
+        } else {
+            val arrayDt = array.guessDatatype(program)
+            if(arrayDt.isKnown) {
+                // this array literal is part of an expression, turn it into an identifier reference
+                val litval2 = array.cast(arrayDt.typeOrElse(DataType.STRUCT))
+                if(litval2!=null && litval2!=array) {
+                    val vardecl2 = VarDecl.createAuto(litval2)
+                    val identifier = IdentifierReference(listOf(vardecl2.name), vardecl2.position)
+                    return listOf(
+                            IAstModification.ReplaceNode(array, identifier, parent),
+                            IAstModification.InsertFirst(vardecl2, array.definingScope() as Node)
+                    )
+                }
+            }
+        }
+        return noModifications
+    }
+
+    private fun processBinaryExprWithString(string: StringLiteralValue, operand: Expression, expr: BinaryExpression): Expression {
+        val constvalue = operand.constValue(program)
+        if(constvalue!=null) {
+            if (expr.operator == "*") {
+                // repeat a string a number of times
+                return StringLiteralValue(string.value.repeat(constvalue.number.toInt()), string.altEncoding, expr.position)
+            }
+        }
+        if(expr.operator == "+" && operand is StringLiteralValue) {
+            // concatenate two strings
+            return StringLiteralValue("${string.value}${operand.value}", string.altEncoding, expr.position)
+        }
+        return expr
+    }
+}

compiler/src/prog8/ast/processing/AstWalker.kt

@@ -0,0 +1,437 @@
+package prog8.ast.processing
+
+import prog8.ast.*
+import prog8.ast.base.FatalAstException
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+
+
+interface IAstModification {
+    fun perform()
+
+    class Remove(val node: Node, val parent: Node) : IAstModification {
+        override fun perform() {
+            if(parent is INameScope) {
+                if (!parent.statements.remove(node) && parent !is GlobalNamespace)
+                    throw FatalAstException("attempt to remove non-existing node $node")
+            } else {
+                throw FatalAstException("parent of a remove modification is not an INameScope")
+            }
+        }
+    }
+
+    class SetExpression(val setter: (newExpr: Expression) -> Unit, val newExpr: Expression, val parent: Node) : IAstModification {
+        override fun perform() {
+            setter(newExpr)
+            newExpr.linkParents(parent)
+        }
+    }
+
+    class InsertFirst(val stmt: Statement, val parent: Node) : IAstModification {
+        override fun perform() {
+            if(parent is INameScope) {
+                parent.statements.add(0, stmt)
+                stmt.linkParents(parent)
+            } else {
+                throw FatalAstException("parent of an insert modification is not an INameScope")
+            }
+        }
+    }
+
+    class InsertLast(val stmt: Statement, val parent: Node) : IAstModification {
+        override fun perform() {
+            if(parent is INameScope) {
+                parent.statements.add(stmt)
+                stmt.linkParents(parent)
+            } else {
+                throw FatalAstException("parent of an insert modification is not an INameScope")
+            }
+        }
+    }
+
+    class InsertAfter(val after: Statement, val stmt: Statement, val parent: Node) : IAstModification {
+        override fun perform() {
+            if(parent is INameScope) {
+                val idx = parent.statements.indexOfFirst { it===after } + 1
+                parent.statements.add(idx, stmt)
+                stmt.linkParents(parent)
+            } else {
+                throw FatalAstException("parent of an insert modification is not an INameScope")
+            }
+        }
+    }
+
+    class ReplaceNode(val node: Node, val replacement: Node, val parent: Node) : IAstModification {
+        override fun perform() {
+            parent.replaceChildNode(node, replacement)
+            replacement.linkParents(parent)
+        }
+    }
+
+    class SwapOperands(val expr: BinaryExpression): IAstModification {
+        override fun perform() {
+            val tmp = expr.left
+            expr.left = expr.right
+            expr.right = tmp
+        }
+    }
+}
+
+
+abstract class AstWalker {
+    open fun before(addressOf: AddressOf, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(array: ArrayLiteralValue, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(arrayIndexedExpression: ArrayIndexedExpression, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(assignTarget: AssignTarget, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(assignment: Assignment, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(block: Block, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(branchStatement: BranchStatement, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(breakStmt: Break, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(contStmt: Continue, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(decl: VarDecl, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(directive: Directive, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(expr: BinaryExpression, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(expr: PrefixExpression, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(forLoop: ForLoop, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(repeatLoop: RepeatLoop, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(identifier: IdentifierReference, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(ifStatement: IfStatement, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(inlineAssembly: InlineAssembly, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(jump: Jump, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(label: Label, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(memread: DirectMemoryRead, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(memwrite: DirectMemoryWrite, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(module: Module, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(nopStatement: NopStatement, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(numLiteral: NumericLiteralValue, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(postIncrDecr: PostIncrDecr, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(program: Program, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(range: RangeExpr, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(untilLoop: UntilLoop, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(returnStmt: Return, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(scope: AnonymousScope, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(string: StringLiteralValue, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(structDecl: StructDecl, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(subroutine: Subroutine, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(typecast: TypecastExpression, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(whenChoice: WhenChoice, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(whenStatement: WhenStatement, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(whileLoop: WhileLoop, parent: Node): Iterable<IAstModification> = emptyList()
+
+    open fun after(addressOf: AddressOf, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(array: ArrayLiteralValue, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(arrayIndexedExpression: ArrayIndexedExpression, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(assignTarget: AssignTarget, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(block: Block, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(branchStatement: BranchStatement, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(breakStmt: Break, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(contStmt: Continue, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(directive: Directive, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(expr: PrefixExpression, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(forLoop: ForLoop, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(repeatLoop: RepeatLoop, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(identifier: IdentifierReference, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(ifStatement: IfStatement, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(inlineAssembly: InlineAssembly, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(jump: Jump, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(label: Label, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(memread: DirectMemoryRead, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(memwrite: DirectMemoryWrite, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(module: Module, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(nopStatement: NopStatement, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(numLiteral: NumericLiteralValue, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(postIncrDecr: PostIncrDecr, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(program: Program, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(range: RangeExpr, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(untilLoop: UntilLoop, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(returnStmt: Return, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(scope: AnonymousScope, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(string: StringLiteralValue, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(structDecl: StructDecl, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(subroutine: Subroutine, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(typecast: TypecastExpression, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(whenChoice: WhenChoice, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(whenStatement: WhenStatement, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(whileLoop: WhileLoop, parent: Node): Iterable<IAstModification> = emptyList()
+
+    private val modifications = mutableListOf<Triple<IAstModification, Node, Node>>()
+
+    private fun track(mods: Iterable<IAstModification>, node: Node, parent: Node) {
+        for (it in mods) modifications += Triple(it, node, parent)
+    }
+
+    fun applyModifications(): Int {
+        modifications.forEach {
+            it.first.perform()
+        }
+        val amount = modifications.size
+        modifications.clear()
+        return amount
+    }
+
+    fun visit(program: Program) {
+        track(before(program, program), program, program)
+        program.modules.forEach { it.accept(this, program) }
+        track(after(program, program), program, program)
+    }
+
+    fun visit(module: Module, parent: Node) {
+        track(before(module, parent), module, parent)
+        module.statements.forEach{ it.accept(this, module) }
+        track(after(module, parent), module, parent)
+    }
+
+    fun visit(expr: PrefixExpression, parent: Node) {
+        track(before(expr, parent), expr, parent)
+        expr.expression.accept(this, expr)
+        track(after(expr, parent), expr, parent)
+    }
+
+    fun visit(expr: BinaryExpression, parent: Node) {
+        track(before(expr, parent), expr, parent)
+        expr.left.accept(this, expr)
+        expr.right.accept(this, expr)
+        track(after(expr, parent), expr, parent)
+    }
+
+    fun visit(directive: Directive, parent: Node) {
+        track(before(directive, parent), directive, parent)
+        track(after(directive, parent), directive, parent)
+    }
+
+    fun visit(block: Block, parent: Node) {
+        track(before(block, parent), block, parent)
+        block.statements.forEach { it.accept(this, block) }
+        track(after(block, parent), block, parent)
+    }
+
+    fun visit(decl: VarDecl, parent: Node) {
+        track(before(decl, parent), decl, parent)
+        decl.value?.accept(this, decl)
+        decl.arraysize?.accept(this, decl)
+        track(after(decl, parent), decl, parent)
+    }
+
+    fun visit(subroutine: Subroutine, parent: Node) {
+        track(before(subroutine, parent), subroutine, parent)
+        subroutine.statements.forEach { it.accept(this, subroutine) }
+        track(after(subroutine, parent), subroutine, parent)
+    }
+
+    fun visit(functionCall: FunctionCall, parent: Node) {
+        track(before(functionCall, parent), functionCall, parent)
+        functionCall.target.accept(this, functionCall)
+        functionCall.args.forEach { it.accept(this, functionCall) }
+        track(after(functionCall, parent), functionCall, parent)
+    }
+
+    fun visit(functionCallStatement: FunctionCallStatement, parent: Node) {
+        track(before(functionCallStatement, parent), functionCallStatement, parent)
+        functionCallStatement.target.accept(this, functionCallStatement)
+        functionCallStatement.args.forEach { it.accept(this, functionCallStatement) }
+        track(after(functionCallStatement, parent), functionCallStatement, parent)
+    }
+
+    fun visit(identifier: IdentifierReference, parent: Node) {
+        track(before(identifier, parent), identifier, parent)
+        track(after(identifier, parent), identifier, parent)
+    }
+
+    fun visit(jump: Jump, parent: Node) {
+        track(before(jump, parent), jump, parent)
+        jump.identifier?.accept(this, jump)
+        track(after(jump, parent), jump, parent)
+    }
+
+    fun visit(ifStatement: IfStatement, parent: Node) {
+        track(before(ifStatement, parent), ifStatement, parent)
+        ifStatement.condition.accept(this, ifStatement)
+        ifStatement.truepart.accept(this, ifStatement)
+        ifStatement.elsepart.accept(this, ifStatement)
+        track(after(ifStatement, parent), ifStatement, parent)
+    }
+
+    fun visit(branchStatement: BranchStatement, parent: Node) {
+        track(before(branchStatement, parent), branchStatement, parent)
+        branchStatement.truepart.accept(this, branchStatement)
+        branchStatement.elsepart.accept(this, branchStatement)
+        track(after(branchStatement, parent), branchStatement, parent)
+    }
+
+    fun visit(range: RangeExpr, parent: Node) {
+        track(before(range, parent), range, parent)
+        range.from.accept(this, range)
+        range.to.accept(this, range)
+        range.step.accept(this, range)
+        track(after(range, parent), range, parent)
+    }
+
+    fun visit(label: Label, parent: Node) {
+        track(before(label, parent), label, parent)
+        track(after(label, parent), label, parent)
+    }
+
+    fun visit(numLiteral: NumericLiteralValue, parent: Node) {
+        track(before(numLiteral, parent), numLiteral, parent)
+        track(after(numLiteral, parent), numLiteral, parent)
+    }
+
+    fun visit(string: StringLiteralValue, parent: Node) {
+        track(before(string, parent), string, parent)
+        track(after(string, parent), string, parent)
+    }
+
+    fun visit(array: ArrayLiteralValue, parent: Node) {
+        track(before(array, parent), array, parent)
+        array.value.forEach { v->v.accept(this, array) }
+        track(after(array, parent), array, parent)
+    }
+
+    fun visit(assignment: Assignment, parent: Node) {
+        track(before(assignment, parent), assignment, parent)
+        assignment.target.accept(this, assignment)
+        assignment.value.accept(this, assignment)
+        track(after(assignment, parent), assignment, parent)
+    }
+
+    fun visit(postIncrDecr: PostIncrDecr, parent: Node) {
+        track(before(postIncrDecr, parent), postIncrDecr, parent)
+        postIncrDecr.target.accept(this, postIncrDecr)
+        track(after(postIncrDecr, parent), postIncrDecr, parent)
+    }
+
+    fun visit(contStmt: Continue, parent: Node) {
+        track(before(contStmt, parent), contStmt, parent)
+        track(after(contStmt, parent), contStmt, parent)
+    }
+
+    fun visit(breakStmt: Break, parent: Node) {
+        track(before(breakStmt, parent), breakStmt, parent)
+        track(after(breakStmt, parent), breakStmt, parent)
+    }
+
+    fun visit(forLoop: ForLoop, parent: Node) {
+        track(before(forLoop, parent), forLoop, parent)
+        forLoop.loopVar.accept(this, forLoop)
+        forLoop.iterable.accept(this, forLoop)
+        forLoop.body.accept(this, forLoop)
+        track(after(forLoop, parent), forLoop, parent)
+    }
+
+    fun visit(whileLoop: WhileLoop, parent: Node) {
+        track(before(whileLoop, parent), whileLoop, parent)
+        whileLoop.condition.accept(this, whileLoop)
+        whileLoop.body.accept(this, whileLoop)
+        track(after(whileLoop, parent), whileLoop, parent)
+    }
+
+    fun visit(repeatLoop: RepeatLoop, parent: Node) {
+        track(before(repeatLoop, parent), repeatLoop, parent)
+        repeatLoop.iterations?.accept(this, repeatLoop)
+        repeatLoop.body.accept(this, repeatLoop)
+        track(after(repeatLoop, parent), repeatLoop, parent)
+    }
+
+    fun visit(untilLoop: UntilLoop, parent: Node) {
+        track(before(untilLoop, parent), untilLoop, parent)
+        untilLoop.untilCondition.accept(this, untilLoop)
+        untilLoop.body.accept(this, untilLoop)
+        track(after(untilLoop, parent), untilLoop, parent)
+    }
+
+    fun visit(returnStmt: Return, parent: Node) {
+        track(before(returnStmt, parent), returnStmt, parent)
+        returnStmt.value?.accept(this, returnStmt)
+        track(after(returnStmt, parent), returnStmt, parent)
+    }
+
+    fun visit(arrayIndexedExpression: ArrayIndexedExpression, parent: Node) {
+        track(before(arrayIndexedExpression, parent), arrayIndexedExpression, parent)
+        arrayIndexedExpression.identifier.accept(this, arrayIndexedExpression)
+        arrayIndexedExpression.arrayspec.accept(this, arrayIndexedExpression)
+        track(after(arrayIndexedExpression, parent), arrayIndexedExpression, parent)
+    }
+
+    fun visit(assignTarget: AssignTarget, parent: Node) {
+        track(before(assignTarget, parent), assignTarget, parent)
+        assignTarget.arrayindexed?.accept(this, assignTarget)
+        assignTarget.identifier?.accept(this, assignTarget)
+        assignTarget.memoryAddress?.accept(this, assignTarget)
+        track(after(assignTarget, parent), assignTarget, parent)
+    }
+
+    fun visit(scope: AnonymousScope, parent: Node) {
+        track(before(scope, parent), scope, parent)
+        scope.statements.forEach { it.accept(this, scope) }
+        track(after(scope, parent), scope, parent)
+    }
+
+    fun visit(typecast: TypecastExpression, parent: Node) {
+        track(before(typecast, parent), typecast, parent)
+        typecast.expression.accept(this, typecast)
+        track(after(typecast, parent), typecast, parent)
+    }
+
+    fun visit(memread: DirectMemoryRead, parent: Node) {
+        track(before(memread, parent), memread, parent)
+        memread.addressExpression.accept(this, memread)
+        track(after(memread, parent), memread, parent)
+    }
+
+    fun visit(memwrite: DirectMemoryWrite, parent: Node) {
+        track(before(memwrite, parent), memwrite, parent)
+        memwrite.addressExpression.accept(this, memwrite)
+        track(after(memwrite, parent), memwrite, parent)
+    }
+
+    fun visit(addressOf: AddressOf, parent: Node) {
+        track(before(addressOf, parent), addressOf, parent)
+        addressOf.identifier.accept(this, addressOf)
+        track(after(addressOf, parent), addressOf, parent)
+    }
+
+    fun visit(inlineAssembly: InlineAssembly, parent: Node) {
+        track(before(inlineAssembly, parent), inlineAssembly, parent)
+        track(after(inlineAssembly, parent), inlineAssembly, parent)
+    }
+
+    fun visit(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder, parent: Node) {
+        track(before(builtinFunctionStatementPlaceholder, parent), builtinFunctionStatementPlaceholder, parent)
+        track(after(builtinFunctionStatementPlaceholder, parent), builtinFunctionStatementPlaceholder, parent)
+    }
+
+    fun visit(nopStatement: NopStatement, parent: Node) {
+        track(before(nopStatement, parent), nopStatement, parent)
+        track(after(nopStatement, parent), nopStatement, parent)
+    }
+
+    fun visit(whenStatement: WhenStatement, parent: Node) {
+        track(before(whenStatement, parent), whenStatement, parent)
+        whenStatement.condition.accept(this, whenStatement)
+        whenStatement.choices.forEach { it.accept(this, whenStatement) }
+        track(after(whenStatement, parent), whenStatement, parent)
+    }
+
+    fun visit(whenChoice: WhenChoice, parent: Node) {
+        track(before(whenChoice, parent), whenChoice, parent)
+        whenChoice.values?.forEach { it.accept(this, whenChoice) }
+        whenChoice.statements.accept(this, whenChoice)
+        track(after(whenChoice, parent), whenChoice, parent)
+    }
+
+    fun visit(structDecl: StructDecl, parent: Node) {
+        track(before(structDecl, parent), structDecl, parent)
+        structDecl.statements.forEach { it.accept(this, structDecl) }
+        track(after(structDecl, parent), structDecl, parent)
+    }
+}
+

compiler/src/prog8/ast/processing/IAstModifyingVisitor.kt

@@ -1,267 +0,0 @@
-package prog8.ast.processing
-
-import prog8.ast.Module
-import prog8.ast.Program
-import prog8.ast.base.FatalAstException
-import prog8.ast.expressions.*
-import prog8.ast.statements.*
-
-
-interface IAstModifyingVisitor {
-    fun visit(program: Program) {
-        program.modules.forEach { visit(it) }
-    }
-
-    fun visit(module: Module) {
-        module.statements = module.statements.map { it.accept(this) }.toMutableList()
-    }
-
-    fun visit(expr: PrefixExpression): Expression {
-        expr.expression = expr.expression.accept(this)
-        return expr
-    }
-
-    fun visit(expr: BinaryExpression): Expression {
-        expr.left = expr.left.accept(this)
-        expr.right = expr.right.accept(this)
-        return expr
-    }
-
-    fun visit(directive: Directive): Statement {
-        return directive
-    }
-
-    fun visit(block: Block): Statement {
-        block.statements = block.statements.map { it.accept(this) }.toMutableList()
-        return block
-    }
-
-    fun visit(decl: VarDecl): Statement {
-        decl.value = decl.value?.accept(this)
-        decl.arraysize?.accept(this)
-        return decl
-    }
-
-    fun visit(subroutine: Subroutine): Statement {
-        subroutine.statements = subroutine.statements.map { it.accept(this) }.toMutableList()
-        return subroutine
-    }
-
-    fun visit(functionCall: FunctionCall): Expression {
-        val newtarget = functionCall.target.accept(this)
-        if(newtarget is IdentifierReference)
-            functionCall.target = newtarget
-        else
-            throw FatalAstException("cannot change class of function call target")
-        functionCall.args = functionCall.args.map { it.accept(this) }.toMutableList()
-        return functionCall
-    }
-
-    fun visit(functionCallStatement: FunctionCallStatement): Statement {
-        val newtarget = functionCallStatement.target.accept(this)
-        if(newtarget is IdentifierReference)
-            functionCallStatement.target = newtarget
-        else
-            throw FatalAstException("cannot change class of function call target")
-        functionCallStatement.args = functionCallStatement.args.map { it.accept(this) }.toMutableList()
-        return functionCallStatement
-    }
-
-    fun visit(identifier: IdentifierReference): Expression {
-        // note: this is an identifier that is used in an expression.
-        // other identifiers are simply part of the other statements (such as jumps, subroutine defs etc)
-        return identifier
-    }
-
-    fun visit(jump: Jump): Statement {
-        if(jump.identifier!=null) {
-            val ident = jump.identifier.accept(this)
-            if(ident is IdentifierReference && ident!==jump.identifier) {
-                return Jump(null, ident, null, jump.position)
-            }
-        }
-        return jump
-    }
-
-    fun visit(ifStatement: IfStatement): Statement {
-        ifStatement.condition = ifStatement.condition.accept(this)
-        ifStatement.truepart = ifStatement.truepart.accept(this) as AnonymousScope
-        ifStatement.elsepart = ifStatement.elsepart.accept(this) as AnonymousScope
-        return ifStatement
-    }
-
-    fun visit(branchStatement: BranchStatement): Statement {
-        branchStatement.truepart = branchStatement.truepart.accept(this) as AnonymousScope
-        branchStatement.elsepart = branchStatement.elsepart.accept(this) as AnonymousScope
-        return branchStatement
-    }
-
-    fun visit(range: RangeExpr): Expression {
-        range.from = range.from.accept(this)
-        range.to = range.to.accept(this)
-        range.step = range.step.accept(this)
-        return range
-    }
-
-    fun visit(label: Label): Statement {
-        return label
-    }
-
-    fun visit(literalValue: NumericLiteralValue): NumericLiteralValue {
-        return literalValue
-    }
-
-    fun visit(stringLiteral: StringLiteralValue): Expression {
-        return stringLiteral
-    }
-
-    fun visit(arrayLiteral: ArrayLiteralValue): Expression {
-        for(av in arrayLiteral.value.withIndex()) {
-            val newvalue = av.value.accept(this)
-            arrayLiteral.value[av.index] = newvalue
-        }
-        return arrayLiteral
-    }
-
-    fun visit(assignment: Assignment): Statement {
-        assignment.target = assignment.target.accept(this)
-        assignment.value = assignment.value.accept(this)
-        return assignment
-    }
-
-    fun visit(postIncrDecr: PostIncrDecr): Statement {
-        postIncrDecr.target = postIncrDecr.target.accept(this)
-        return postIncrDecr
-    }
-
-    fun visit(contStmt: Continue): Statement {
-        return contStmt
-    }
-
-    fun visit(breakStmt: Break): Statement {
-        return breakStmt
-    }
-
-    fun visit(forLoop: ForLoop): Statement {
-        when(val newloopvar = forLoop.loopVar?.accept(this)) {
-            is IdentifierReference -> forLoop.loopVar = newloopvar
-            null -> forLoop.loopVar = null
-            else -> throw FatalAstException("can't change class of loopvar")
-        }
-        forLoop.iterable = forLoop.iterable.accept(this)
-        forLoop.body = forLoop.body.accept(this) as AnonymousScope
-        return forLoop
-    }
-
-    fun visit(whileLoop: WhileLoop): Statement {
-        whileLoop.condition = whileLoop.condition.accept(this)
-        whileLoop.body = whileLoop.body.accept(this) as AnonymousScope
-        return whileLoop
-    }
-
-    fun visit(foreverLoop: ForeverLoop): Statement {
-        foreverLoop.body = foreverLoop.body.accept(this) as AnonymousScope
-        return foreverLoop
-    }
-
-    fun visit(repeatLoop: RepeatLoop): Statement {
-        repeatLoop.untilCondition = repeatLoop.untilCondition.accept(this)
-        repeatLoop.body = repeatLoop.body.accept(this) as AnonymousScope
-        return repeatLoop
-    }
-
-    fun visit(returnStmt: Return): Statement {
-        returnStmt.value = returnStmt.value?.accept(this)
-        return returnStmt
-    }
-
-    fun visit(arrayIndexedExpression: ArrayIndexedExpression): ArrayIndexedExpression {
-        val ident = arrayIndexedExpression.identifier.accept(this)
-        if(ident is IdentifierReference)
-            arrayIndexedExpression.identifier = ident
-        arrayIndexedExpression.arrayspec.accept(this)
-        return arrayIndexedExpression
-    }
-
-    fun visit(assignTarget: AssignTarget): AssignTarget {
-        when (val ident = assignTarget.identifier?.accept(this)) {
-            is IdentifierReference -> assignTarget.identifier = ident
-            null -> assignTarget.identifier = null
-            else -> throw FatalAstException("can't change class of assign target identifier")
-        }
-        assignTarget.arrayindexed = assignTarget.arrayindexed?.accept(this)
-        assignTarget.memoryAddress?.let { visit(it) }
-        return assignTarget
-    }
-
-    fun visit(scope: AnonymousScope): Statement {
-        scope.statements = scope.statements.map { it.accept(this) }.toMutableList()
-        return scope
-    }
-
-    fun visit(typecast: TypecastExpression): Expression {
-        typecast.expression = typecast.expression.accept(this)
-        return typecast
-    }
-
-    fun visit(memread: DirectMemoryRead): Expression {
-        memread.addressExpression = memread.addressExpression.accept(this)
-        return memread
-    }
-
-    fun visit(memwrite: DirectMemoryWrite) {
-        memwrite.addressExpression = memwrite.addressExpression.accept(this)
-    }
-
-    fun visit(addressOf: AddressOf): Expression {
-        val ident = addressOf.identifier.accept(this)
-        if(ident is IdentifierReference)
-            addressOf.identifier = ident
-        else
-            throw FatalAstException("can't change class of addressof identifier")
-        return addressOf
-    }
-
-    fun visit(inlineAssembly: InlineAssembly): Statement {
-        return inlineAssembly
-    }
-
-    fun visit(registerExpr: RegisterExpr): Expression {
-        return registerExpr
-    }
-
-    fun visit(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder): Statement {
-        return builtinFunctionStatementPlaceholder
-    }
-
-    fun visit(nopStatement: NopStatement): Statement {
-        return nopStatement
-    }
-
-    fun visit(whenStatement: WhenStatement): Statement {
-        whenStatement.condition = whenStatement.condition.accept(this)
-        whenStatement.choices.forEach { it.accept(this) }
-        return whenStatement
-    }
-
-    fun visit(whenChoice: WhenChoice) {
-        whenChoice.values = whenChoice.values?.map { it.accept(this) }
-        val stmt = whenChoice.statements.accept(this)
-        if(stmt is AnonymousScope)
-            whenChoice.statements = stmt
-        else {
-            whenChoice.statements = AnonymousScope(mutableListOf(stmt), stmt.position)
-            whenChoice.statements.linkParents(whenChoice)
-        }
-    }
-
-    fun visit(structDecl: StructDecl): Statement {
-        structDecl.statements = structDecl.statements.map{ it.accept(this) }.toMutableList()
-        return structDecl
-    }
-
-    fun visit(structLv: StructLiteralValue): Expression {
-        structLv.values = structLv.values.map { it.accept(this) }
-        return structLv
-    }
-}

compiler/src/prog8/ast/processing/IAstVisitor.kt

@@ -7,7 +7,7 @@ import prog8.ast.statements.*
 
 interface IAstVisitor {
     fun visit(program: Program) {
-        program.modules.forEach { visit(it) }
+        program.modules.forEach { it.accept(this) }
     }
 
     fun visit(module: Module) {
@@ -102,7 +102,7 @@ interface IAstVisitor {
     }
 
     fun visit(forLoop: ForLoop) {
-        forLoop.loopVar?.accept(this)
+        forLoop.loopVar.accept(this)
         forLoop.iterable.accept(this)
         forLoop.body.accept(this)
     }
@@ -112,13 +112,14 @@ interface IAstVisitor {
         whileLoop.body.accept(this)
     }
 
-    fun visit(foreverLoop: ForeverLoop) {
-        foreverLoop.body.accept(this)
+    fun visit(repeatLoop: RepeatLoop) {
+        repeatLoop.iterations?.accept(this)
+        repeatLoop.body.accept(this)
     }
 
-    fun visit(repeatLoop: RepeatLoop) {
-        repeatLoop.untilCondition.accept(this)
-        repeatLoop.body.accept(this)
+    fun visit(untilLoop: UntilLoop) {
+        untilLoop.untilCondition.accept(this)
+        untilLoop.body.accept(this)
     }
 
     fun visit(returnStmt: Return) {
@@ -159,9 +160,6 @@ interface IAstVisitor {
     fun visit(inlineAssembly: InlineAssembly) {
     }
 
-    fun visit(registerExpr: RegisterExpr) {
-    }
-
     fun visit(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder) {
     }
 
@@ -181,8 +179,4 @@ interface IAstVisitor {
     fun visit(structDecl: StructDecl) {
         structDecl.statements.forEach { it.accept(this) }
     }
-
-    fun visit(structLv: StructLiteralValue) {
-        structLv.values.forEach { it.accept(this) }
-    }
 }

compiler/src/prog8/ast/processing/ImportedModuleDirectiveRemover.kt

@@ -1,29 +1,21 @@
 package prog8.ast.processing
 
-import prog8.ast.Module
-import prog8.ast.base.ErrorReporter
+import prog8.ast.Node
 import prog8.ast.statements.Directive
-import prog8.ast.statements.Statement
 
-internal class ImportedModuleDirectiveRemover(private val errors: ErrorReporter) : IAstModifyingVisitor {
+
+internal class ImportedModuleDirectiveRemover: AstWalker() {
     /**
      * Most global directives don't apply for imported modules, so remove them
      */
-    override fun visit(module: Module) {
-        super.visit(module)
-        val newStatements : MutableList<Statement> = mutableListOf()
 
-        val moduleLevelDirectives = listOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address")
-        for (sourceStmt in module.statements) {
-            val stmt = sourceStmt.accept(this)
-            if(stmt is Directive && stmt.parent is Module) {
-                if(stmt.directive in moduleLevelDirectives) {
-                    errors.warn("ignoring module directive because it was imported", stmt.position)
-                    continue
-                }
-            }
-            newStatements.add(stmt)
+    private val moduleLevelDirectives = listOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address")
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun before(directive: Directive, parent: Node): Iterable<IAstModification> {
+        if(directive.directive in moduleLevelDirectives) {
+            return listOf(IAstModification.Remove(directive, parent))
         }
-        module.statements = newStatements
+        return noModifications
     }
 }

compiler/src/prog8/ast/processing/MakeForeverLoops.kt

@@ -1,24 +0,0 @@
-package prog8.ast.processing
-
-import prog8.ast.expressions.NumericLiteralValue
-import prog8.ast.statements.ForeverLoop
-import prog8.ast.statements.RepeatLoop
-import prog8.ast.statements.Statement
-import prog8.ast.statements.WhileLoop
-
-internal class MakeForeverLoops : IAstModifyingVisitor {
-    override fun visit(whileLoop: WhileLoop): Statement {
-        val numeric = whileLoop.condition as? NumericLiteralValue
-        if(numeric!=null && numeric.number.toInt() != 0) {
-            return ForeverLoop(whileLoop.body, whileLoop.position)
-        }
-        return super.visit(whileLoop)
-    }
-
-    override fun visit(repeatLoop: RepeatLoop): Statement {
-        val numeric = repeatLoop.untilCondition as? NumericLiteralValue
-        if(numeric!=null && numeric.number.toInt() == 0)
-            return ForeverLoop(repeatLoop.body, repeatLoop.position)
-        return super.visit(repeatLoop)
-    }
-}

compiler/src/prog8/ast/processing/ReflectionAstWalker.kt

@@ -0,0 +1,71 @@
+package prog8.ast.processing
+
+
+/*
+This is here for reference only, reflection based ast walking is very slow
+when compared to the more verbose visitor pattern interfaces.
+Too bad, because the code is very small
+*/
+
+
+//import prog8.ast.NoAstWalk
+//import prog8.ast.Node
+//import prog8.ast.Program
+//import prog8.ast.base.Position
+//import prog8.ast.expressions.BinaryExpression
+//import prog8.ast.expressions.NumericLiteralValue
+//import kotlin.reflect.KClass
+//import kotlin.reflect.KVisibility
+//import kotlin.reflect.full.declaredMemberProperties
+//import kotlin.reflect.full.isSubtypeOf
+//import kotlin.reflect.full.starProjectedType
+//
+//
+//class ReflectionAstWalker {
+//    private val nodeType = Node::class.starProjectedType
+//    private val collectionType = Collection::class.starProjectedType
+//
+//
+//    fun walk(node: Node, nesting: Int) {
+//        val nodetype: KClass<out Node> = node::class
+//        val indent = "  ".repeat(nesting)
+//        //println("$indent VISITING ${nodetype.simpleName}")
+//        val visibleAstMembers = nodetype.declaredMemberProperties.filter {
+//            it.visibility!=KVisibility.PRIVATE && !it.isLateinit &&
+//                    !(it.annotations.any{a->a is NoAstWalk})
+//        }
+//        for(prop in visibleAstMembers) {
+//            if(prop.returnType.isSubtypeOf(nodeType)) {
+//                // println("$indent +PROP: ${prop.name}")
+//                walk(prop.call(node) as Node, nesting + 1)
+//            }
+//            else if(prop.returnType.isSubtypeOf(collectionType)) {
+//                val elementType = prop.returnType.arguments.single().type
+//                if(elementType!=null && elementType.isSubtypeOf(nodeType)) {
+//                    val nodes = prop.call(node) as Collection<Node>
+//                    nodes.forEach { walk(it, nesting+1) }
+//                }
+//            }
+//        }
+//    }
+//    fun walk(program: Program) {
+//        for(module in program.modules) {
+//            println("---MODULE $module---")
+//            walk(module, 0)
+//        }
+//    }
+//}
+//
+//
+//fun main() {
+//    val ast = BinaryExpression(
+//            NumericLiteralValue.optimalInteger(100, Position.DUMMY),
+//            "+",
+//            NumericLiteralValue.optimalInteger(200, Position.DUMMY),
+//            Position.DUMMY
+//    )
+//
+//    val walker = ReflectionAstWalker()
+//    walker.walk(ast,0)
+//
+//}

compiler/src/prog8/ast/processing/StatementReorderer.kt

@@ -1,257 +1,184 @@
 package prog8.ast.processing
 
 import prog8.ast.*
-import prog8.ast.base.DataType
-import prog8.ast.base.FatalAstException
-import prog8.ast.base.initvarsSubName
+import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 
 
-private fun flattenStructAssignmentFromIdentifier(structAssignment: Assignment, program: Program): List<Assignment> {
-    val identifier = structAssignment.target.identifier!!
-    val identifierName = identifier.nameInSource.single()
-    val targetVar = identifier.targetVarDecl(program.namespace)!!
-    val struct = targetVar.struct!!
-    when (structAssignment.value) {
-        is IdentifierReference -> {
-            val sourceVar = (structAssignment.value as IdentifierReference).targetVarDecl(program.namespace)!!
-            if (sourceVar.struct == null)
-                throw FatalAstException("can only assign arrays or structs to structs")
-            // struct memberwise copy
-            val sourceStruct = sourceVar.struct!!
-            if(sourceStruct!==targetVar.struct) {
-                // structs are not the same in assignment
-                return listOf()     // error will be printed elsewhere
-            }
-            return struct.statements.zip(sourceStruct.statements).map { member ->
-                val targetDecl = member.first as VarDecl
-                val sourceDecl = member.second as VarDecl
-                if(targetDecl.name != sourceDecl.name)
-                    throw FatalAstException("struct member mismatch")
-                val mangled = mangledStructMemberName(identifierName, targetDecl.name)
-                val idref = IdentifierReference(listOf(mangled), structAssignment.position)
-                val sourcemangled = mangledStructMemberName(sourceVar.name, sourceDecl.name)
-                val sourceIdref = IdentifierReference(listOf(sourcemangled), structAssignment.position)
-                val assign = Assignment(AssignTarget(null, idref, null, null, structAssignment.position),
-                        null, sourceIdref, member.second.position)
-                assign.linkParents(structAssignment)
-                assign
-            }
-        }
-        is StructLiteralValue -> {
-            throw IllegalArgumentException("not going to flatten a structLv assignment here")
-        }
-        else -> throw FatalAstException("strange struct value")
-    }
-}
-
-
-internal class StatementReorderer(private val program: Program): IAstModifyingVisitor {
+internal class StatementReorderer(val program: Program) : AstWalker() {
     // Reorders the statements in a way the compiler needs.
     // - 'main' block must be the very first statement UNLESS it has an address set.
-    // - blocks are ordered by address, where blocks without address are put at the end.
-    // - in every scope:
-    //      -- the directives '%output', '%launcher', '%zeropage', '%zpreserved', '%address' and '%option' will come first.
-    //      -- all vardecls then follow.
-    //      -- the remaining statements then follow in their original order.
-    //
-    // - the 'start' subroutine in the 'main' block will be moved to the top immediately following the directives.
-    // - all other subroutines will be moved to the end of their block.
+    // - library blocks are put last.
+    // - blocks are ordered by address, where blocks without address are placed last.
+    // - in every scope, most directives and vardecls are moved to the top.
+    // - the 'start' subroutine is moved to the top.
+    // - (syntax desugaring) a vardecl with a non-const initializer value is split into a regular vardecl and an assignment statement.
+    // - (syntax desugaring) augmented assignment is turned into regular assignment.
+    // - (syntax desugaring) struct value assignment is expanded into several struct member assignments.
     // - sorts the choices in when statement.
+    // - insert AddressOf (&) expression where required (string params to a UWORD function param etc).
 
+    private val noModifications = emptyList<IAstModification>()
     private val directivesToMove = setOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address", "%option")
 
-    private val addReturns = mutableListOf<Pair<INameScope, Int>>()
-
-    override fun visit(module: Module) {
-        addReturns.clear()
-        super.visit(module)
-
+    override fun after(module: Module, parent: Node): Iterable<IAstModification> {
         val (blocks, other) = module.statements.partition { it is Block }
         module.statements = other.asSequence().plus(blocks.sortedBy { (it as Block).address ?: Int.MAX_VALUE }).toMutableList()
 
-        // make sure user-defined blocks come BEFORE library blocks, and move the "main" block to the top of everything
-        val nonLibraryBlocks = module.statements.withIndex()
-                .filter { it.value is Block && !(it.value as Block).isInLibrary }
-                .map { it.index to it.value }
-                .reversed()
-        for(nonLibBlock in nonLibraryBlocks)
-            module.statements.removeAt(nonLibBlock.first)
-        for(nonLibBlock in nonLibraryBlocks)
-            module.statements.add(0, nonLibBlock.second)
-        val mainBlock = module.statements.singleOrNull { it is Block && it.name=="main" }
-        if(mainBlock!=null && (mainBlock as Block).address==null) {
-            module.remove(mainBlock)
+        val mainBlock = module.statements.filterIsInstance<Block>().firstOrNull { it.name=="main" }
+        if(mainBlock!=null && mainBlock.address==null) {
+            module.statements.remove(mainBlock)
             module.statements.add(0, mainBlock)
         }
 
-        val varDecls = module.statements.filterIsInstance<VarDecl>()
-        module.statements.removeAll(varDecls)
-        module.statements.addAll(0, varDecls)
+        reorderVardeclsAndDirectives(module.statements)
+        return noModifications
+    }
 
-        val directives = module.statements.filter {it is Directive && it.directive in directivesToMove}
-        module.statements.removeAll(directives)
-        module.statements.addAll(0, directives)
+    private fun reorderVardeclsAndDirectives(statements: MutableList<Statement>) {
+        val varDecls = statements.filterIsInstance<VarDecl>()
+        statements.removeAll(varDecls)
+        statements.addAll(0, varDecls)
 
-        for(pos in addReturns) {
-            val returnStmt = Return(null, pos.first.position)
-            returnStmt.linkParents(pos.first as Node)
-            pos.first.statements.add(pos.second, returnStmt)
+        val directives = statements.filterIsInstance<Directive>().filter {it.directive in directivesToMove}
+        statements.removeAll(directives)
+        statements.addAll(0, directives)
+    }
+
+    override fun before(block: Block, parent: Node): Iterable<IAstModification> {
+        parent as Module
+        if(block.isInLibrary) {
+            return listOf(
+                    IAstModification.Remove(block, parent),
+                    IAstModification.InsertLast(block, parent)
+            )
+        }
+
+        reorderVardeclsAndDirectives(block.statements)
+        return noModifications
+    }
+
+    override fun before(subroutine: Subroutine, parent: Node): Iterable<IAstModification> {
+        if(subroutine.name=="start" && parent is Block) {
+            if(parent.statements.filterIsInstance<Subroutine>().first().name!="start") {
+                return listOf(
+                        IAstModification.Remove(subroutine, parent),
+                        IAstModification.InsertFirst(subroutine, parent)
+                )
+            }
+        }
+        return noModifications
+    }
+
+    override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
+        val declValue = decl.value
+        if(declValue!=null && decl.type== VarDeclType.VAR && decl.datatype in NumericDatatypes) {
+            val declConstValue = declValue.constValue(program)
+            if(declConstValue==null) {
+                // move the vardecl (without value) to the scope and replace this with a regular assignment
+                decl.value = null
+                val target = AssignTarget(IdentifierReference(listOf(decl.name), decl.position), null, null, decl.position)
+                val assign = Assignment(target, null, declValue, decl.position)
+                return listOf(
+                        IAstModification.ReplaceNode(decl, assign, parent),
+                        IAstModification.InsertFirst(decl, decl.definingScope() as Node)
+                )
+            }
+        }
+        return noModifications
+    }
+
+    override fun after(whenStatement: WhenStatement, parent: Node): Iterable<IAstModification> {
+        val choices = whenStatement.choiceValues(program).sortedBy {
+            it.first?.first() ?: Int.MAX_VALUE
+        }
+        whenStatement.choices.clear()
+        choices.mapTo(whenStatement.choices) { it.second }
+        return noModifications
+    }
+
+    override fun before(assignment: Assignment, parent: Node): Iterable<IAstModification> {
+        if(assignment.aug_op!=null) {
+            return listOf(IAstModification.ReplaceNode(assignment, assignment.asDesugaredNonaugmented(), parent))
+        }
+
+        val valueType = assignment.value.inferType(program)
+        val targetType = assignment.target.inferType(program, assignment)
+        if(valueType.istype(DataType.STRUCT) && targetType.istype(DataType.STRUCT)) {
+            val assignments = if (assignment.value is ArrayLiteralValue) {
+                flattenStructAssignmentFromStructLiteral(assignment, program)    //  'structvar = [ ..... ] '
+            } else {
+                flattenStructAssignmentFromIdentifier(assignment, program)    //   'structvar1 = structvar2'
+            }
+            if(assignments.isNotEmpty()) {
+                val modifications = mutableListOf<IAstModification>()
+                assignments.reversed().mapTo(modifications) { IAstModification.InsertAfter(assignment, it, parent) }
+                modifications.add(IAstModification.Remove(assignment, parent))
+                return modifications
+            }
+        }
+
+        return noModifications
+    }
+
+    private fun flattenStructAssignmentFromStructLiteral(structAssignment: Assignment, program: Program): List<Assignment> {
+        val identifier = structAssignment.target.identifier!!
+        val identifierName = identifier.nameInSource.single()
+        val targetVar = identifier.targetVarDecl(program.namespace)!!
+        val struct = targetVar.struct!!
+
+        val slv = structAssignment.value as? ArrayLiteralValue
+        if(slv==null || slv.value.size != struct.numberOfElements)
+            throw FatalAstException("element count mismatch")
+
+        return struct.statements.zip(slv.value).map { (targetDecl, sourceValue) ->
+            targetDecl as VarDecl
+            val mangled = mangledStructMemberName(identifierName, targetDecl.name)
+            val idref = IdentifierReference(listOf(mangled), structAssignment.position)
+            val assign = Assignment(AssignTarget(idref, null, null, structAssignment.position),
+                    null, sourceValue, sourceValue.position)
+            assign.linkParents(structAssignment)
+            assign
         }
     }
 
-    override fun visit(block: Block): Statement {
-
-        val subroutines = block.statements.filterIsInstance<Subroutine>()
-        var numSubroutinesAtEnd = 0
-        // move all subroutines to the end of the block
-        for (subroutine in subroutines) {
-            if(subroutine.name!="start" || block.name!="main") {
-                block.remove(subroutine)
-                block.statements.add(subroutine)
-            }
-            numSubroutinesAtEnd++
-        }
-        // move the "start" subroutine to the top
-        if(block.name=="main") {
-            block.statements.singleOrNull { it is Subroutine && it.name == "start" } ?.let {
-                block.remove(it)
-                block.statements.add(0, it)
-                numSubroutinesAtEnd--
-            }
-        }
-
-        // make sure there is a 'return' in front of the first subroutine
-        // (if it isn't the first statement in the block itself, and isn't the program's entrypoint)
-        if(numSubroutinesAtEnd>0 && block.statements.size > (numSubroutinesAtEnd+1)) {
-            val firstSub = block.statements[block.statements.size - numSubroutinesAtEnd] as Subroutine
-            if(firstSub.name != "start" && block.name != "main") {
-                val stmtBeforeFirstSub = block.statements[block.statements.size - numSubroutinesAtEnd - 1]
-                if (stmtBeforeFirstSub !is Return
-                        && stmtBeforeFirstSub !is Jump
-                        && stmtBeforeFirstSub !is Subroutine
-                        && stmtBeforeFirstSub !is BuiltinFunctionStatementPlaceholder) {
-                    val ret = Return(null, stmtBeforeFirstSub.position)
-                    ret.linkParents(block)
-                    block.statements.add(block.statements.size - numSubroutinesAtEnd, ret)
+    private fun flattenStructAssignmentFromIdentifier(structAssignment: Assignment, program: Program): List<Assignment> {
+        val identifier = structAssignment.target.identifier!!
+        val identifierName = identifier.nameInSource.single()
+        val targetVar = identifier.targetVarDecl(program.namespace)!!
+        val struct = targetVar.struct!!
+        when (structAssignment.value) {
+            is IdentifierReference -> {
+                val sourceVar = (structAssignment.value as IdentifierReference).targetVarDecl(program.namespace)!!
+                if (sourceVar.struct == null)
+                    throw FatalAstException("can only assign arrays or structs to structs")
+                // struct memberwise copy
+                val sourceStruct = sourceVar.struct!!
+                if(sourceStruct!==targetVar.struct) {
+                    // structs are not the same in assignment
+                    return listOf()     // error will be printed elsewhere
+                }
+                return struct.statements.zip(sourceStruct.statements).map { member ->
+                    val targetDecl = member.first as VarDecl
+                    val sourceDecl = member.second as VarDecl
+                    if(targetDecl.name != sourceDecl.name)
+                        throw FatalAstException("struct member mismatch")
+                    val mangled = mangledStructMemberName(identifierName, targetDecl.name)
+                    val idref = IdentifierReference(listOf(mangled), structAssignment.position)
+                    val sourcemangled = mangledStructMemberName(sourceVar.name, sourceDecl.name)
+                    val sourceIdref = IdentifierReference(listOf(sourcemangled), structAssignment.position)
+                    val assign = Assignment(AssignTarget(idref, null, null, structAssignment.position),
+                            null, sourceIdref, member.second.position)
+                    assign.linkParents(structAssignment)
+                    assign
                 }
             }
+            is ArrayLiteralValue -> {
+                throw IllegalArgumentException("not going to flatten a structLv assignment here")
+            }
+            else -> throw FatalAstException("strange struct value")
         }
-
-        val varDecls = block.statements.filterIsInstance<VarDecl>()
-        block.statements.removeAll(varDecls)
-        block.statements.addAll(0, varDecls)
-        val directives = block.statements.filter {it is Directive && it.directive in directivesToMove}
-        block.statements.removeAll(directives)
-        block.statements.addAll(0, directives)
-        block.linkParents(block.parent)
-
-        // create subroutine that initializes the block's variables (if any)
-        val varInits = block.statements.withIndex().filter { it.value is VariableInitializationAssignment }
-        if(varInits.isNotEmpty()) {
-            val statements = varInits.map{it.value}.toMutableList()
-            val varInitSub = Subroutine(initvarsSubName, emptyList(), emptyList(), emptyList(), emptyList(),
-                    emptySet(), null, false, statements, block.position)
-            varInitSub.keepAlways = true
-            varInitSub.linkParents(block)
-            block.statements.add(varInitSub)
-
-            // remove the varinits from the block's statements
-            for(index in varInits.map{it.index}.reversed())
-                block.statements.removeAt(index)
-        }
-
-        return super.visit(block)
     }
 
-    override fun visit(subroutine: Subroutine): Statement {
-        super.visit(subroutine)
-
-        val scope = subroutine.definingScope()
-        if(scope is Subroutine) {
-            for(stmt in scope.statements.withIndex()) {
-                if(stmt.index>0 && stmt.value===subroutine) {
-                    val precedingStmt = scope.statements[stmt.index-1]
-                    if(precedingStmt !is Jump && precedingStmt !is Subroutine) {
-                        // insert a return statement before a nested subroutine, to avoid falling trough inside the subroutine
-                        addReturns.add(Pair(scope, stmt.index))
-                    }
-                }
-            }
-        }
-
-        val varDecls = subroutine.statements.filterIsInstance<VarDecl>()
-        subroutine.statements.removeAll(varDecls)
-        subroutine.statements.addAll(0, varDecls)
-        val directives = subroutine.statements.filter {it is Directive && it.directive in directivesToMove}
-        subroutine.statements.removeAll(directives)
-        subroutine.statements.addAll(0, directives)
-
-        if(subroutine.returntypes.isEmpty()) {
-            // add the implicit return statement at the end (if it's not there yet), but only if it's not a kernel routine.
-            // and if an assembly block doesn't contain a rts/rti
-            if(subroutine.asmAddress==null && subroutine.amountOfRtsInAsm()==0) {
-                if (subroutine.statements.lastOrNull {it !is VarDecl } !is Return) {
-                    val returnStmt = Return(null, subroutine.position)
-                    returnStmt.linkParents(subroutine)
-                    subroutine.statements.add(returnStmt)
-                }
-            }
-        }
-
-        return subroutine
-    }
-
-    override fun visit(assignment: Assignment): Statement {
-        val assg = super.visit(assignment)
-        if(assg !is Assignment)
-            return assg
-
-        // see if a typecast is needed to convert the value's type into the proper target type
-        val valueItype = assg.value.inferType(program)
-        val targetItype = assg.target.inferType(program, assg)
-
-        if(targetItype.isKnown && valueItype.isKnown) {
-            val targettype = targetItype.typeOrElse(DataType.STRUCT)
-            val valuetype = valueItype.typeOrElse(DataType.STRUCT)
-
-            // struct assignments will be flattened (if it's not a struct literal)
-            if (valuetype == DataType.STRUCT && targettype == DataType.STRUCT) {
-                if (assg.value is StructLiteralValue)
-                    return assg  // do NOT flatten it at this point!! (the compiler will take care if it, later, if needed)
-
-                val assignments = flattenStructAssignmentFromIdentifier(assg, program)    //   'structvar1 = structvar2'
-                return if (assignments.isEmpty()) {
-                    // something went wrong (probably incompatible struct types)
-                    // we'll get an error later from the AstChecker
-                    assg
-                } else {
-                    val scope = AnonymousScope(assignments.toMutableList(), assg.position)
-                    scope.linkParents(assg.parent)
-                    scope
-                }
-            }
-        }
-
-        if(assg.aug_op!=null) {
-            // transform augmented assg into normal assg so we have one case less to deal with later
-            val newTarget: Expression =
-                    when {
-                        assg.target.register != null -> RegisterExpr(assg.target.register!!, assg.target.position)
-                        assg.target.identifier != null -> assg.target.identifier!!
-                        assg.target.arrayindexed != null -> assg.target.arrayindexed!!
-                        assg.target.memoryAddress != null -> DirectMemoryRead(assg.target.memoryAddress!!.addressExpression, assg.value.position)
-                        else -> throw FatalAstException("strange assg")
-                    }
-
-            val expression = BinaryExpression(newTarget, assg.aug_op.substringBeforeLast('='), assg.value, assg.position)
-            expression.linkParents(assg.parent)
-            val convertedAssignment = Assignment(assg.target, null, expression, assg.position)
-            convertedAssignment.linkParents(assg.parent)
-            return super.visit(convertedAssignment)
-        }
-
-        return assg
-    }
 }

compiler/src/prog8/ast/processing/TypecastsAdder.kt

@@ -2,81 +2,93 @@ package prog8.ast.processing
 
 import prog8.ast.IFunctionCall
 import prog8.ast.INameScope
+import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.DataType
-import prog8.ast.base.ErrorReporter
-import prog8.ast.base.FatalAstException
+import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.functions.BuiltinFunctions
 
 
-internal class TypecastsAdder(private val program: Program,
-                              private val errors: ErrorReporter): IAstModifyingVisitor {
-    // Make sure any value assignments get the proper type casts if needed to cast them into the target variable's type.
-    // (this includes function call arguments)
+class TypecastsAdder(val program: Program, val errors: ErrorReporter) : AstWalker() {
+    /*
+     * Make sure any value assignments get the proper type casts if needed to cast them into the target variable's type.
+     * (this includes function call arguments)
+     */
 
-    override fun visit(expr: BinaryExpression): Expression {
-        val expr2 = super.visit(expr)
-        if(expr2 !is BinaryExpression)
-            return expr2
-        val leftDt = expr2.left.inferType(program)
-        val rightDt = expr2.right.inferType(program)
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
+        val leftDt = expr.left.inferType(program)
+        val rightDt = expr.right.inferType(program)
         if(leftDt.isKnown && rightDt.isKnown && leftDt!=rightDt) {
             // determine common datatype and add typecast as required to make left and right equal types
-            val (commonDt, toFix) = BinaryExpression.commonDatatype(leftDt.typeOrElse(DataType.STRUCT), rightDt.typeOrElse(DataType.STRUCT), expr2.left, expr2.right)
+            val (commonDt, toFix) = BinaryExpression.commonDatatype(leftDt.typeOrElse(DataType.STRUCT), rightDt.typeOrElse(DataType.STRUCT), expr.left, expr.right)
             if(toFix!=null) {
-                when {
-                    toFix===expr2.left -> {
-                        expr2.left = TypecastExpression(expr2.left, commonDt, true, expr2.left.position)
-                        expr2.left.linkParents(expr2)
-                    }
-                    toFix===expr2.right -> {
-                        expr2.right = TypecastExpression(expr2.right, commonDt, true, expr2.right.position)
-                        expr2.right.linkParents(expr2)
-                    }
+                return when {
+                    toFix===expr.left -> listOf(IAstModification.ReplaceNode(
+                            expr.left, TypecastExpression(expr.left, commonDt, true, expr.left.position), expr))
+                    toFix===expr.right -> listOf(IAstModification.ReplaceNode(
+                            expr.right, TypecastExpression(expr.right, commonDt, true, expr.right.position), expr))
                     else -> throw FatalAstException("confused binary expression side")
                 }
             }
         }
-        return expr2
+        return noModifications
     }
 
-    override fun visit(assignment: Assignment): Statement {
-        val assg = super.visit(assignment)
-        if(assg !is Assignment)
-            return assg
-
+    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
         // see if a typecast is needed to convert the value's type into the proper target type
-        val valueItype = assg.value.inferType(program)
-        val targetItype = assg.target.inferType(program, assg)
-
+        val valueItype = assignment.value.inferType(program)
+        val targetItype = assignment.target.inferType(program, assignment)
         if(targetItype.isKnown && valueItype.isKnown) {
             val targettype = targetItype.typeOrElse(DataType.STRUCT)
             val valuetype = valueItype.typeOrElse(DataType.STRUCT)
             if (valuetype != targettype) {
                 if (valuetype isAssignableTo targettype) {
-                    assg.value = TypecastExpression(assg.value, targettype, true, assg.value.position)
-                    assg.value.linkParents(assg)
+                    return listOf(IAstModification.ReplaceNode(
+                            assignment.value,
+                            TypecastExpression(assignment.value, targettype, true, assignment.value.position),
+                            assignment))
+                } else {
+                    fun castLiteral(cvalue: NumericLiteralValue): List<IAstModification.ReplaceNode> =
+                        listOf(IAstModification.ReplaceNode(cvalue, cvalue.cast(targettype), cvalue.parent))
+                    val cvalue = assignment.value.constValue(program)
+                    if(cvalue!=null) {
+                        val number = cvalue.number.toDouble()
+                        // more complex comparisons if the type is different, but the constant value is compatible
+                        if (valuetype == DataType.BYTE && targettype == DataType.UBYTE) {
+                            if(number>0)
+                                return castLiteral(cvalue)
+                        } else if (valuetype == DataType.WORD && targettype == DataType.UWORD) {
+                            if(number>0)
+                                return castLiteral(cvalue)
+                        } else if (valuetype == DataType.UBYTE && targettype == DataType.BYTE) {
+                            if(number<0x80)
+                                return castLiteral(cvalue)
+                        } else if (valuetype == DataType.UWORD && targettype == DataType.WORD) {
+                            if(number<0x8000)
+                                return castLiteral(cvalue)
+                        }
+                    }
                 }
-                // if they're not assignable, we'll get a proper error later from the AstChecker
             }
         }
-        return assg
+        return noModifications
     }
 
-    override fun visit(functionCallStatement: FunctionCallStatement): Statement {
-        checkFunctionCallArguments(functionCallStatement, functionCallStatement.definingScope())
-        return super.visit(functionCallStatement)
+    override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
+        return afterFunctionCallArgs(functionCallStatement, functionCallStatement.definingScope())
     }
 
-    override fun visit(functionCall: FunctionCall): Expression {
-        checkFunctionCallArguments(functionCall, functionCall.definingScope())
-        return super.visit(functionCall)
+    override fun after(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> {
+        return afterFunctionCallArgs(functionCall, functionCall.definingScope())
     }
 
-    private fun checkFunctionCallArguments(call: IFunctionCall, scope: INameScope) {
+    private fun afterFunctionCallArgs(call: IFunctionCall, scope: INameScope): Iterable<IAstModification> {
         // see if a typecast is needed to convert the arguments into the required parameter's type
+        val modifications = mutableListOf<IAstModification>()
+
         when(val sub = call.target.targetStatement(scope)) {
             is Subroutine -> {
                 for(arg in sub.parameters.zip(call.args.withIndex())) {
@@ -86,114 +98,106 @@ internal class TypecastsAdder(private val program: Program,
                         val requiredType = arg.first.type
                         if (requiredType != argtype) {
                             if (argtype isAssignableTo requiredType) {
-                                val typecasted = TypecastExpression(arg.second.value, requiredType, true, arg.second.value.position)
-                                typecasted.linkParents(arg.second.value.parent)
-                                call.args[arg.second.index] = typecasted
-                            }
-                            // if they're not assignable, we'll get a proper error later from the AstChecker
-                        }
-                    }
-                }
-            }
-            is BuiltinFunctionStatementPlaceholder -> {
-                val func = BuiltinFunctions.getValue(sub.name)
-                if(func.pure) {
-                    // non-pure functions don't get automatic typecasts because sometimes they act directly on their parameters
-                    for (arg in func.parameters.zip(call.args.withIndex())) {
-                        val argItype = arg.second.value.inferType(program)
-                        if (argItype.isKnown) {
-                            val argtype = argItype.typeOrElse(DataType.STRUCT)
-                            if (arg.first.possibleDatatypes.any { argtype == it })
-                                continue
-                            for (possibleType in arg.first.possibleDatatypes) {
-                                if (argtype isAssignableTo possibleType) {
-                                    val typecasted = TypecastExpression(arg.second.value, possibleType, true, arg.second.value.position)
-                                    typecasted.linkParents(arg.second.value.parent)
-                                    call.args[arg.second.index] = typecasted
-                                    break
+                                modifications += IAstModification.ReplaceNode(
+                                        call.args[arg.second.index],
+                                        TypecastExpression(arg.second.value, requiredType, true, arg.second.value.position),
+                                        call as Node)
+                            } else if(requiredType == DataType.UWORD && argtype in PassByReferenceDatatypes) {
+                                // we allow STR/ARRAY values in place of UWORD parameters. Take their address instead.
+                                modifications += IAstModification.ReplaceNode(
+                                        call.args[arg.second.index],
+                                        AddressOf(arg.second.value as IdentifierReference, arg.second.value.position),
+                                        call as Node)
+                            } else if(arg.second.value is NumericLiteralValue) {
+                                try {
+                                    val castedValue = (arg.second.value as NumericLiteralValue).cast(requiredType)
+                                    modifications += IAstModification.ReplaceNode(
+                                            call.args[arg.second.index],
+                                            castedValue,
+                                            call as Node)
+                                } catch (x: ExpressionError) {
+                                    // no cast possible
                                 }
                             }
                         }
                     }
                 }
             }
-            null -> {}
+            is BuiltinFunctionStatementPlaceholder -> {
+                val func = BuiltinFunctions.getValue(sub.name)
+                for (arg in func.parameters.zip(call.args.withIndex())) {
+                    val argItype = arg.second.value.inferType(program)
+                    if (argItype.isKnown) {
+                        val argtype = argItype.typeOrElse(DataType.STRUCT)
+                        if (arg.first.possibleDatatypes.any { argtype == it })
+                            continue
+                        for (possibleType in arg.first.possibleDatatypes) {
+                            if (argtype isAssignableTo possibleType) {
+                                modifications += IAstModification.ReplaceNode(
+                                        call.args[arg.second.index],
+                                        TypecastExpression(arg.second.value, possibleType, true, arg.second.value.position),
+                                        call as Node)
+                            }
+                        }
+                    }
+                }
+            }
+            null -> { }
             else -> throw FatalAstException("call to something weird $sub   ${call.target}")
         }
+
+        return modifications
     }
 
-    override fun visit(typecast: TypecastExpression): Expression {
+    override fun after(typecast: TypecastExpression, parent: Node): Iterable<IAstModification> {
         // warn about any implicit type casts to Float, because that may not be intended
         if(typecast.implicit && typecast.type in setOf(DataType.FLOAT, DataType.ARRAY_F)) {
             errors.warn("byte or word value implicitly converted to float. Suggestion: use explicit cast as float, a float number, or revert to integer arithmetic", typecast.position)
         }
-        return super.visit(typecast)
+        return noModifications
     }
 
-    override fun visit(memread: DirectMemoryRead): Expression {
+    override fun after(memread: DirectMemoryRead, parent: Node): Iterable<IAstModification> {
         // make sure the memory address is an uword
         val dt = memread.addressExpression.inferType(program)
         if(dt.isKnown && dt.typeOrElse(DataType.UWORD)!=DataType.UWORD) {
-            val literaladdr = memread.addressExpression as? NumericLiteralValue
-            if(literaladdr!=null) {
-                memread.addressExpression = literaladdr.cast(DataType.UWORD)
-            } else {
-                memread.addressExpression = TypecastExpression(memread.addressExpression, DataType.UWORD, true, memread.addressExpression.position)
-                memread.addressExpression.parent = memread
-            }
+            val typecast = (memread.addressExpression as? NumericLiteralValue)?.cast(DataType.UWORD)
+                    ?: TypecastExpression(memread.addressExpression, DataType.UWORD, true, memread.addressExpression.position)
+            return listOf(IAstModification.ReplaceNode(memread.addressExpression, typecast, memread))
         }
-        return super.visit(memread)
+        return noModifications
     }
 
-    override fun visit(memwrite: DirectMemoryWrite) {
+    override fun after(memwrite: DirectMemoryWrite, parent: Node): Iterable<IAstModification> {
+        // make sure the memory address is an uword
         val dt = memwrite.addressExpression.inferType(program)
         if(dt.isKnown && dt.typeOrElse(DataType.UWORD)!=DataType.UWORD) {
-            val literaladdr = memwrite.addressExpression as? NumericLiteralValue
-            if(literaladdr!=null) {
-                memwrite.addressExpression = literaladdr.cast(DataType.UWORD)
-            } else {
-                memwrite.addressExpression = TypecastExpression(memwrite.addressExpression, DataType.UWORD, true, memwrite.addressExpression.position)
-                memwrite.addressExpression.parent = memwrite
-            }
+            val typecast = (memwrite.addressExpression as? NumericLiteralValue)?.cast(DataType.UWORD)
+                    ?: TypecastExpression(memwrite.addressExpression, DataType.UWORD, true, memwrite.addressExpression.position)
+            return listOf(IAstModification.ReplaceNode(memwrite.addressExpression, typecast, memwrite))
         }
-        super.visit(memwrite)
+        return noModifications
     }
 
-    override fun visit(structLv: StructLiteralValue): Expression {
-        val litval = super.visit(structLv)
-        if(litval !is StructLiteralValue)
-            return litval
-
-        val decl = litval.parent as? VarDecl
-        if(decl != null) {
-            val struct = decl.struct
-            if(struct != null) {
-                addTypecastsIfNeeded(litval, struct)
-            }
-        } else {
-            val assign = litval.parent as? Assignment
-            if (assign != null) {
-                val decl2 = assign.target.identifier?.targetVarDecl(program.namespace)
-                if(decl2 != null) {
-                    val struct = decl2.struct
-                    if(struct != null) {
-                        addTypecastsIfNeeded(litval, struct)
-                    }
+    override fun after(returnStmt: Return, parent: Node): Iterable<IAstModification> {
+        // add a typecast to the return type if it doesn't match the subroutine's signature
+        val returnValue = returnStmt.value
+        if(returnValue!=null) {
+            val subroutine = returnStmt.definingSubroutine()!!
+            if(subroutine.returntypes.size==1) {
+                val subReturnType = subroutine.returntypes.first()
+                if (returnValue.inferType(program).istype(subReturnType))
+                    return noModifications
+                if (returnValue is NumericLiteralValue) {
+                    returnStmt.value = returnValue.cast(subroutine.returntypes.single())
+                } else {
+                    return listOf(IAstModification.ReplaceNode(
+                            returnValue,
+                            TypecastExpression(returnValue, subReturnType, true, returnValue.position),
+                            returnStmt))
                 }
             }
         }
-
-        return litval
-    }
-
-    private fun addTypecastsIfNeeded(structLv: StructLiteralValue, struct: StructDecl) {
-        structLv.values = struct.statements.zip(structLv.values).map {
-            val memberDt = (it.first as VarDecl).datatype
-            val valueDt = it.second.inferType(program)
-            if (valueDt.typeOrElse(memberDt) != memberDt)
-                TypecastExpression(it.second, memberDt, true, it.second.position)
-            else
-                it.second
-        }
+        return noModifications
     }
 }

compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt

@@ -1,156 +0,0 @@
-package prog8.ast.processing
-
-import prog8.ast.INameScope
-import prog8.ast.Module
-import prog8.ast.Node
-import prog8.ast.Program
-import prog8.ast.base.*
-import prog8.ast.expressions.*
-import prog8.ast.statements.*
-import prog8.compiler.CompilerException
-import prog8.functions.BuiltinFunctions
-import prog8.functions.FSignature
-
-
-internal class VarInitValueAndAddressOfCreator(private val program: Program): IAstModifyingVisitor {
-    // For VarDecls that declare an initialization value:
-    // Replace the vardecl with an assignment (to set the initial value),
-    // and add a new vardecl with the default constant value of that type (usually zero) to the scope.
-    // This makes sure the variables get reset to the intended value on a next run of the program.
-    // Variable decls without a value don't get this treatment, which means they retain the last
-    // value they had when restarting the program.
-    // This is done in a separate step because it interferes with the namespace lookup of symbols
-    // in other ast processors.
-
-    // Also takes care to insert AddressOf (&) expression where required (string params to a UWORD function param etc).
-
-    private val vardeclsToAdd = mutableMapOf<INameScope, MutableList<VarDecl>>()
-
-    override fun visit(module: Module) {
-        vardeclsToAdd.clear()
-        super.visit(module)
-        // add any new vardecls to the various scopes
-        for((where, decls) in vardeclsToAdd) {
-            where.statements.addAll(0, decls)
-            decls.forEach { it.linkParents(where as Node) }
-        }
-    }
-
-    override fun visit(decl: VarDecl): Statement {
-        super.visit(decl)
-
-        if(decl.isArray && decl.value==null) {
-            // array datatype without initialization value, add list of zeros
-            val arraysize = decl.arraysize!!.size()!!
-            val array = ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
-                    Array(arraysize) { NumericLiteralValue.optimalInteger(0, decl.position) },
-                    decl.position)
-            decl.value = array
-        }
-
-        if(decl.type!= VarDeclType.VAR || decl.value==null)
-            return decl
-
-        if(decl.datatype in NumericDatatypes) {
-            val scope = decl.definingScope()
-            addVarDecl(scope, decl.asDefaultValueDecl(null))
-            val declvalue = decl.value!!
-            val value =
-                    if(declvalue is NumericLiteralValue)
-                        declvalue.cast(decl.datatype)
-                    else
-                        declvalue
-            val identifierName = listOf(decl.name)    // this was: (scoped name) decl.scopedname.split(".")
-            return VariableInitializationAssignment(
-                    AssignTarget(null, IdentifierReference(identifierName, decl.position), null, null, decl.position),
-                    null,
-                    value,
-                    decl.position
-            )
-        }
-
-        return decl
-    }
-
-    override fun visit(functionCall: FunctionCall): Expression {
-        var parentStatement: Node = functionCall
-        while(parentStatement !is Statement)
-            parentStatement = parentStatement.parent
-        val targetStatement = functionCall.target.targetSubroutine(program.namespace)
-        if(targetStatement!=null) {
-            addAddressOfExprIfNeeded(targetStatement, functionCall.args, parentStatement)
-        } else {
-            val builtinFunc = BuiltinFunctions[functionCall.target.nameInSource.joinToString (".")]
-            if(builtinFunc!=null)
-                addAddressOfExprIfNeededForBuiltinFuncs(builtinFunc, functionCall.args, parentStatement)
-        }
-        return functionCall
-    }
-
-    override fun visit(functionCallStatement: FunctionCallStatement): Statement {
-        val targetStatement = functionCallStatement.target.targetSubroutine(program.namespace)
-        if(targetStatement!=null) {
-            addAddressOfExprIfNeeded(targetStatement, functionCallStatement.args, functionCallStatement)
-        } else {
-            val builtinFunc = BuiltinFunctions[functionCallStatement.target.nameInSource.joinToString (".")]
-            if(builtinFunc!=null)
-                addAddressOfExprIfNeededForBuiltinFuncs(builtinFunc, functionCallStatement.args, functionCallStatement)
-        }
-        return functionCallStatement
-    }
-
-    private fun addAddressOfExprIfNeeded(subroutine: Subroutine, arglist: MutableList<Expression>, parent: Statement) {
-        // functions that accept UWORD and are given an array type, or string, will receive the AddressOf (memory location) of that value instead.
-        for(argparam in subroutine.parameters.withIndex().zip(arglist)) {
-            if(argparam.first.value.type==DataType.UWORD || argparam.first.value.type == DataType.STR) {
-                if(argparam.second is AddressOf)
-                    continue
-                val idref = argparam.second as? IdentifierReference
-                val strvalue = argparam.second as? StringLiteralValue
-                if(idref!=null) {
-                    val variable = idref.targetVarDecl(program.namespace)
-                    if(variable!=null && variable.datatype in IterableDatatypes) {
-                        val pointerExpr = AddressOf(idref, idref.position)
-                        pointerExpr.linkParents(arglist[argparam.first.index].parent)
-                        arglist[argparam.first.index] = pointerExpr
-                    }
-                }
-                else if(strvalue!=null) {
-                    // add a vardecl so that the autovar can be resolved in later lookups
-                    val variable = VarDecl.createAuto(strvalue)
-                    addVarDecl(strvalue.definingScope(), variable)
-                    // replace the argument with &autovar
-                    val autoHeapvarRef = IdentifierReference(listOf(variable.name), strvalue.position)
-                    val pointerExpr = AddressOf(autoHeapvarRef, strvalue.position)
-                    pointerExpr.linkParents(arglist[argparam.first.index].parent)
-                    arglist[argparam.first.index] = pointerExpr
-                }
-            }
-        }
-    }
-
-    private fun addAddressOfExprIfNeededForBuiltinFuncs(signature: FSignature, args: MutableList<Expression>, parent: Statement) {
-        // val paramTypesForAddressOf = PassByReferenceDatatypes + DataType.UWORD
-        for(arg in args.withIndex().zip(signature.parameters)) {
-            val argvalue = arg.first.value
-            val argDt = argvalue.inferType(program)
-            if(argDt.typeOrElse(DataType.UBYTE) in PassByReferenceDatatypes && DataType.UWORD in arg.second.possibleDatatypes) {
-                if(argvalue !is IdentifierReference)
-                    throw CompilerException("pass-by-reference parameter isn't an identifier? $argvalue")
-                val addrOf = AddressOf(argvalue, argvalue.position)
-                args[arg.first.index] = addrOf
-                addrOf.linkParents(parent)
-            }
-        }
-    }
-
-
-    private fun addVarDecl(scope: INameScope, variable: VarDecl) {
-        if(scope !in vardeclsToAdd)
-            vardeclsToAdd[scope] = mutableListOf()
-        val declList = vardeclsToAdd.getValue(scope)
-        if(declList.all{it.name!=variable.name})
-            declList.add(variable)
-    }
-
-}

compiler/src/prog8/ast/processing/VariousCleanups.kt

@@ -0,0 +1,43 @@
+package prog8.ast.processing
+
+import prog8.ast.INameScope
+import prog8.ast.Node
+import prog8.ast.expressions.NumericLiteralValue
+import prog8.ast.expressions.TypecastExpression
+import prog8.ast.statements.AnonymousScope
+import prog8.ast.statements.NopStatement
+
+
+internal class VariousCleanups: AstWalker() {
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun before(nopStatement: NopStatement, parent: Node): Iterable<IAstModification> {
+        return listOf(IAstModification.Remove(nopStatement, parent))
+    }
+
+    override fun before(scope: AnonymousScope, parent: Node): Iterable<IAstModification> {
+        return if(parent is INameScope)
+            listOf(ScopeFlatten(scope, parent as INameScope))
+        else
+            noModifications
+    }
+
+    class ScopeFlatten(val scope: AnonymousScope, val into: INameScope) : IAstModification {
+        override fun perform() {
+            val idx = into.statements.indexOf(scope)
+            if(idx>=0) {
+                into.statements.addAll(idx+1, scope.statements)
+                into.statements.remove(scope)
+            }
+        }
+    }
+
+    override fun before(typecast: TypecastExpression, parent: Node): Iterable<IAstModification> {
+        if(typecast.expression is NumericLiteralValue) {
+            val value = (typecast.expression as NumericLiteralValue).cast(typecast.type)
+            return listOf(IAstModification.ReplaceNode(typecast, value, parent))
+        }
+
+        return noModifications
+    }
+}

compiler/src/prog8/ast/processing/VerifyFunctionArgTypes.kt

@@ -0,0 +1,42 @@
+package prog8.ast.processing
+
+import prog8.ast.IFunctionCall
+import prog8.ast.INameScope
+import prog8.ast.Program
+import prog8.ast.base.DataType
+import prog8.ast.expressions.FunctionCall
+import prog8.ast.statements.BuiltinFunctionStatementPlaceholder
+import prog8.ast.statements.FunctionCallStatement
+import prog8.ast.statements.Subroutine
+import prog8.compiler.CompilerException
+import prog8.functions.BuiltinFunctions
+
+class VerifyFunctionArgTypes(val program: Program) : IAstVisitor {
+
+    override fun visit(functionCall: FunctionCall)
+            = checkTypes(functionCall as IFunctionCall, functionCall.definingScope())
+
+    override fun visit(functionCallStatement: FunctionCallStatement)
+            = checkTypes(functionCallStatement as IFunctionCall, functionCallStatement.definingScope())
+
+    private fun checkTypes(call: IFunctionCall, scope: INameScope) {
+        val argtypes = call.args.map { it.inferType(program).typeOrElse(DataType.STRUCT) }
+        val target = call.target.targetStatement(scope)
+        when(target) {
+            is Subroutine -> {
+                val paramtypes = target.parameters.map { it.type }
+                if(argtypes!=paramtypes)
+                    throw CompilerException("parameter type mismatch $call")
+            }
+            is BuiltinFunctionStatementPlaceholder -> {
+                val func = BuiltinFunctions.getValue(target.name)
+                val paramtypes = func.parameters.map { it.possibleDatatypes }
+                for(x in argtypes.zip(paramtypes)) {
+                    if(x.first !in x.second)
+                        throw CompilerException("parameter type mismatch $call")
+                }
+            }
+            else -> {}
+        }
+    }
+}

compiler/src/prog8/ast/statements/AstStatements.kt

@@ -3,13 +3,14 @@ package prog8.ast.statements
 import prog8.ast.*
 import prog8.ast.base.*
 import prog8.ast.expressions.*
-import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.processing.AstWalker
 import prog8.ast.processing.IAstVisitor
 
 
 sealed class Statement : Node {
-    abstract fun accept(visitor: IAstModifyingVisitor) : Statement
     abstract fun accept(visitor: IAstVisitor)
+    abstract fun accept(visitor: AstWalker, parent: Node)
+
     fun makeScopedName(name: String): String {
         // easy way out is to always return the full scoped name.
         // it would be nicer to find only the minimal prefixed scoped name, but that's too much hassle for now.
@@ -28,8 +29,6 @@ sealed class Statement : Node {
         return scope.joinToString(".")
     }
 
-    abstract val expensiveToInline: Boolean
-
     fun definingBlock(): Block {
         if(this is Block)
             return this
@@ -37,13 +36,16 @@ sealed class Statement : Node {
     }
 }
 
+
 class BuiltinFunctionStatementPlaceholder(val name: String, override val position: Position) : Statement() {
     override var parent: Node = ParentSentinel
     override fun linkParents(parent: Node) {}
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
     override fun definingScope(): INameScope = BuiltinFunctionScopePlaceholder
-    override val expensiveToInline = false
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        replacement.parent = this
+    }
 }
 
 data class RegisterOrStatusflag(val registerOrPair: RegisterOrPair?, val statusflag: Statusflag?, val stack: Boolean)
@@ -54,16 +56,21 @@ class Block(override val name: String,
             val isInLibrary: Boolean,
             override val position: Position) : Statement(), INameScope {
     override lateinit var parent: Node
-    override val expensiveToInline
-        get() = statements.any { it.expensiveToInline }
 
     override fun linkParents(parent: Node) {
         this.parent = parent
         statements.forEach {it.linkParents(this)}
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Statement)
+        val idx = statements.indexOfFirst { it ===node }
+        statements[idx] = replacement
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     override fun toString(): String {
         return "Block(name=$name, address=$address, ${statements.size} statements)"
@@ -74,15 +81,15 @@ class Block(override val name: String,
 
 data class Directive(val directive: String, val args: List<DirectiveArg>, override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = false
 
     override fun linkParents(parent: Node) {
         this.parent = parent
         args.forEach{it.linkParents(this)}
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) = throw FatalAstException("can't replace here")
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
 data class DirectiveArg(val str: String?, val name: String?, val int: Int?, override val position: Position) : Node {
@@ -91,18 +98,19 @@ data class DirectiveArg(val str: String?, val name: String?, val int: Int?, over
     override fun linkParents(parent: Node) {
         this.parent = parent
     }
+    override fun replaceChildNode(node: Node, replacement: Node) = throw FatalAstException("can't replace here")
 }
 
 data class Label(val name: String, override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = false
 
     override fun linkParents(parent: Node) {
         this.parent = parent
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) = throw FatalAstException("can't replace here")
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     override fun toString(): String {
         return "Label(name=$name, pos=$position)"
@@ -111,15 +119,20 @@ data class Label(val name: String, override val position: Position) : Statement(
 
 open class Return(var value: Expression?, override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = value!=null && value !is NumericLiteralValue
 
     override fun linkParents(parent: Node) {
         this.parent = parent
         value?.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Expression)
+        value = replacement
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     override fun toString(): String {
         return "Return($value, pos=$position)"
@@ -127,36 +140,36 @@ open class Return(var value: Expression?, override val position: Position) : Sta
 }
 
 class ReturnFromIrq(override val position: Position) : Return(null, position) {
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
 
     override fun toString(): String {
         return "ReturnFromIrq(pos=$position)"
     }
+    override fun replaceChildNode(node: Node, replacement: Node) = throw FatalAstException("can't replace here")
 }
 
 class Continue(override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = false
 
     override fun linkParents(parent: Node) {
         this.parent=parent
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) = throw FatalAstException("can't replace here")
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
 class Break(override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = false
 
     override fun linkParents(parent: Node) {
         this.parent=parent
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) = throw FatalAstException("can't replace here")
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
 
@@ -167,7 +180,8 @@ enum class ZeropageWish {
     NOT_IN_ZEROPAGE
 }
 
-class VarDecl(val type: VarDeclType,
+
+open class VarDecl(val type: VarDeclType,
               private val declaredDatatype: DataType,
               val zeropage: ZeropageWish,
               var arraysize: ArrayIndex?,
@@ -183,9 +197,6 @@ class VarDecl(val type: VarDeclType,
     var structHasBeenFlattened = false      // set later
         private set
 
-    override val expensiveToInline
-            get() = value!=null && value !is NumericLiteralValue
-
     // prefix for literal values that are turned into a variable on the heap
 
     companion object {
@@ -204,6 +215,15 @@ class VarDecl(val type: VarDeclType,
             return VarDecl(VarDeclType.VAR, declaredType, ZeropageWish.NOT_IN_ZEROPAGE, arraysize, autoVarName, null, array,
                     isArray = true, autogeneratedDontRemove = true, position = array.position)
         }
+
+        fun defaultZero(dt: DataType, position: Position) = when(dt) {
+            DataType.UBYTE -> NumericLiteralValue(DataType.UBYTE, 0,  position)
+            DataType.BYTE -> NumericLiteralValue(DataType.BYTE, 0,  position)
+            DataType.UWORD -> NumericLiteralValue(DataType.UWORD, 0, position)
+            DataType.WORD -> NumericLiteralValue(DataType.WORD, 0, position)
+            DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, 0.0, position)
+            else -> throw FatalAstException("can only determine default zero value for a numeric type")
+        }
     }
 
     val datatypeErrors = mutableListOf<SyntaxError>()       // don't crash at init time, report them in the AstChecker
@@ -232,34 +252,25 @@ class VarDecl(val type: VarDeclType,
         }
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
-    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Expression && node===value)
+        value = replacement
+        replacement.parent = this
+    }
 
-    val scopedname: String by lazy { makeScopedName(name) }
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     override fun toString(): String {
         return "VarDecl(name=$name, vartype=$type, datatype=$datatype, struct=$structName, value=$value, pos=$position)"
     }
 
-    fun asDefaultValueDecl(parent: Node?): VarDecl {
-        val constValue = when(declaredDatatype) {
-            DataType.UBYTE -> NumericLiteralValue(DataType.UBYTE, 0,  position)
-            DataType.BYTE -> NumericLiteralValue(DataType.BYTE, 0,  position)
-            DataType.UWORD -> NumericLiteralValue(DataType.UWORD, 0, position)
-            DataType.WORD -> NumericLiteralValue(DataType.WORD, 0, position)
-            DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, 0.0, position)
-            else -> throw FatalAstException("can only set a default value for a numeric type")
-        }
-        val decl = VarDecl(type, declaredDatatype, zeropage, arraysize, name, structName, constValue, isArray, false, position)
-        if(parent!=null)
-            decl.linkParents(parent)
-        return decl
-    }
+    fun zeroElementValue() = defaultZero(declaredDatatype, position)
 
     fun flattenStructMembers(): MutableList<Statement> {
         val result = struct!!.statements.withIndex().map {
             val member = it.value as VarDecl
-            val initvalue = if(value!=null) (value as StructLiteralValue).values[it.index] else null
+            val initvalue = if(value!=null) (value as ArrayLiteralValue).value[it.index] else null
             VarDecl(
                     VarDeclType.VAR,
                     member.datatype,
@@ -278,6 +289,11 @@ class VarDecl(val type: VarDeclType,
     }
 }
 
+// a vardecl used only for subroutine parameters
+class ParameterVarDecl(name: String, declaredDatatype: DataType, position: Position)
+    : VarDecl(VarDeclType.VAR, declaredDatatype, ZeropageWish.NOT_IN_ZEROPAGE, null, name, null, null, false, true, position)
+
+
 class ArrayIndex(var index: Expression, override val position: Position) : Node {
     override lateinit var parent: Node
 
@@ -286,19 +302,20 @@ class ArrayIndex(var index: Expression, override val position: Position) : Node
         index.linkParents(this)
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Expression && node===index)
+        index = replacement
+        replacement.parent = this
+    }
+
     companion object {
         fun forArray(v: ArrayLiteralValue): ArrayIndex {
             return ArrayIndex(NumericLiteralValue.optimalNumeric(v.value.size, v.position), v.position)
         }
     }
 
-    fun accept(visitor: IAstModifyingVisitor) {
-        index = index.accept(visitor)
-    }
-
-    fun accept(visitor: IAstVisitor) {
-        index.accept(visitor)
-    }
+    fun accept(visitor: IAstVisitor) = index.accept(visitor)
+    fun accept(visitor: AstWalker, parent: Node) = index.accept(visitor, this)
 
     override fun toString(): String {
         return("ArrayIndex($index, pos=$position)")
@@ -307,10 +324,8 @@ class ArrayIndex(var index: Expression, override val position: Position) : Node
     fun size() = (index as? NumericLiteralValue)?.number?.toInt()
 }
 
-open class Assignment(var target: AssignTarget, val aug_op : String?, var value: Expression, override val position: Position) : Statement() {
+open class Assignment(var target: AssignTarget, var aug_op : String?, var value: Expression, override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline
-            get() = value !is NumericLiteralValue
 
     override fun linkParents(parent: Node) {
         this.parent = parent
@@ -318,21 +333,47 @@ open class Assignment(var target: AssignTarget, val aug_op : String?, var value:
         value.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        when {
+            node===target -> target = replacement as AssignTarget
+            node===value -> value = replacement as Expression
+            else -> throw FatalAstException("invalid replace")
+        }
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     override fun toString(): String {
         return("Assignment(augop: $aug_op, target: $target, value: $value, pos=$position)")
     }
+
+    fun asDesugaredNonaugmented(): Assignment {
+        val augmented = aug_op ?: return this
+
+        val leftOperand: Expression =
+                when {
+                    target.identifier != null -> target.identifier!!
+                    target.arrayindexed != null -> target.arrayindexed!!
+                    target.memoryAddress != null -> DirectMemoryRead(target.memoryAddress!!.addressExpression, value.position)
+                    else -> throw FatalAstException("strange this")
+                }
+
+        val assignment =
+            if(augmented=="setvalue") {
+                Assignment(target, null, value, position)
+            } else {
+                val expression = BinaryExpression(leftOperand, augmented.substringBeforeLast('='), value, position)
+                Assignment(target, null, expression, position)
+            }
+        assignment.linkParents(parent)
+
+        return assignment
+    }
 }
 
-// This is a special class so the compiler can see if the assignments are for initializing the vars in the scope,
-// or just a regular assignment. It may optimize the initialization step from this.
-class VariableInitializationAssignment(target: AssignTarget, aug_op: String?, value: Expression, position: Position)
-    : Assignment(target, aug_op, value, position)
-
-data class AssignTarget(val register: Register?,
-                        var identifier: IdentifierReference?,
+data class AssignTarget(var identifier: IdentifierReference?,
                         var arrayindexed: ArrayIndexedExpression?,
                         val memoryAddress: DirectMemoryWrite?,
                         override val position: Position) : Node {
@@ -345,25 +386,30 @@ data class AssignTarget(val register: Register?,
         memoryAddress?.linkParents(this)
     }
 
-    fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        when {
+            node===identifier -> identifier = replacement as IdentifierReference
+            node===arrayindexed -> arrayindexed = replacement as ArrayIndexedExpression
+            else -> throw FatalAstException("invalid replace")
+        }
+        replacement.parent = this
+    }
+
     fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     companion object {
         fun fromExpr(expr: Expression): AssignTarget {
             return when (expr) {
-                is RegisterExpr -> AssignTarget(expr.register, null, null, null, expr.position)
-                is IdentifierReference -> AssignTarget(null, expr, null, null, expr.position)
-                is ArrayIndexedExpression -> AssignTarget(null, null, expr, null, expr.position)
-                is DirectMemoryRead -> AssignTarget(null, null, null, DirectMemoryWrite(expr.addressExpression, expr.position), expr.position)
+                is IdentifierReference -> AssignTarget(expr, null, null, expr.position)
+                is ArrayIndexedExpression -> AssignTarget(null, expr, null, expr.position)
+                is DirectMemoryRead -> AssignTarget(null, null, DirectMemoryWrite(expr.addressExpression, expr.position), expr.position)
                 else -> throw FatalAstException("invalid expression object $expr")
             }
         }
     }
 
     fun inferType(program: Program, stmt: Statement): InferredTypes.InferredType {
-        if(register!=null)
-            return InferredTypes.knownFor(DataType.UBYTE)
-
         if(identifier!=null) {
             val symbol = program.namespace.lookup(identifier!!.nameInSource, stmt) ?: return InferredTypes.unknown()
             if (symbol is VarDecl) return InferredTypes.knownFor(symbol.datatype)
@@ -381,8 +427,13 @@ data class AssignTarget(val register: Register?,
 
     infix fun isSameAs(value: Expression): Boolean {
         return when {
-            this.memoryAddress!=null -> false
-            this.register!=null -> value is RegisterExpr && value.register==register
+            this.memoryAddress!=null -> {
+                // if the target is a memory write, and the value is a memory read, they're the same if the address matches
+                if(value is DirectMemoryRead)
+                    this.memoryAddress.addressExpression isSameAs value.addressExpression
+                else
+                    false
+            }
             this.identifier!=null -> value is IdentifierReference && value.nameInSource==identifier!!.nameInSource
             this.arrayindexed!=null -> value is ArrayIndexedExpression &&
                     value.identifier.nameInSource==arrayindexed!!.identifier.nameInSource &&
@@ -396,8 +447,6 @@ data class AssignTarget(val register: Register?,
     fun isSameAs(other: AssignTarget, program: Program): Boolean {
         if(this===other)
             return true
-        if(this.register!=null && other.register!=null)
-            return this.register==other.register
         if(this.identifier!=null && other.identifier!=null)
             return this.identifier!!.nameInSource==other.identifier!!.nameInSource
         if(this.memoryAddress!=null && other.memoryAddress!=null) {
@@ -416,8 +465,6 @@ data class AssignTarget(val register: Register?,
     }
 
     fun isNotMemory(namespace: INameScope): Boolean {
-        if(this.register!=null)
-            return true
         if(this.memoryAddress!=null)
             return false
         if(this.arrayindexed!=null) {
@@ -436,15 +483,20 @@ data class AssignTarget(val register: Register?,
 
 class PostIncrDecr(var target: AssignTarget, val operator: String, override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = false
 
     override fun linkParents(parent: Node) {
         this.parent = parent
         target.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is AssignTarget && node===target)
+        target = replacement
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     override fun toString(): String {
         return "PostIncrDecr(op: $operator, target: $target, pos=$position)"
@@ -456,15 +508,15 @@ class Jump(val address: Int?,
            val generatedLabel: String?,             // used in code generation scenarios
            override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = false
 
     override fun linkParents(parent: Node) {
         this.parent = parent
         identifier?.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) = throw FatalAstException("can't replace here")
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     override fun toString(): String {
         return "Jump(addr: $address, identifier: $identifier, label: $generatedLabel;  pos=$position)"
@@ -476,8 +528,6 @@ class FunctionCallStatement(override var target: IdentifierReference,
                             val void: Boolean,
                             override val position: Position) : Statement(), IFunctionCall {
     override lateinit var parent: Node
-    override val expensiveToInline
-            get() = args.any { it !is NumericLiteralValue }
 
     override fun linkParents(parent: Node) {
         this.parent = parent
@@ -485,8 +535,18 @@ class FunctionCallStatement(override var target: IdentifierReference,
         args.forEach { it.linkParents(this) }
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        if(node===target)
+            target = replacement as IdentifierReference
+        else {
+            val idx = args.indexOfFirst { it===node }
+            args[idx] = replacement as Expression
+        }
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     override fun toString(): String {
         return "FunctionCallStatement(target=$target, pos=$position)"
@@ -495,22 +555,20 @@ class FunctionCallStatement(override var target: IdentifierReference,
 
 class InlineAssembly(val assembly: String, override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = true
 
     override fun linkParents(parent: Node) {
         this.parent = parent
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) = throw FatalAstException("can't replace here")
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
 class AnonymousScope(override var statements: MutableList<Statement>,
                      override val position: Position) : INameScope, Statement() {
     override val name: String
     override lateinit var parent: Node
-    override val expensiveToInline
-        get() = statements.any { it.expensiveToInline }
 
     companion object {
         private var sequenceNumber = 1
@@ -526,28 +584,27 @@ class AnonymousScope(override var statements: MutableList<Statement>,
         statements.forEach { it.linkParents(this) }
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Statement)
+        val idx = statements.indexOfFirst { it===node }
+        statements[idx] = replacement
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
 class NopStatement(override val position: Position): Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = false
 
     override fun linkParents(parent: Node) {
         this.parent = parent
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) = throw FatalAstException("can't replace here")
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
-
-    companion object {
-        fun insteadOf(stmt: Statement): NopStatement {
-            val nop = NopStatement(stmt.position)
-            nop.parent = stmt.parent
-            return nop
-        }
-    }
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
 // the subroutine class covers both the normal user-defined subroutines,
@@ -558,20 +615,14 @@ class Subroutine(override val name: String,
                  val returntypes: List<DataType>,
                  val asmParameterRegisters: List<RegisterOrStatusflag>,
                  val asmReturnvaluesRegisters: List<RegisterOrStatusflag>,
-                 val asmClobbers: Set<Register>,
+                 val asmClobbers: Set<CpuRegister>,
                  val asmAddress: Int?,
                  val isAsmSubroutine: Boolean,
                  override var statements: MutableList<Statement>,
                  override val position: Position) : Statement(), INameScope {
 
     var keepAlways: Boolean = false
-    override val expensiveToInline
-            get() = statements.any { it.expensiveToInline }
-
     override lateinit var parent: Node
-    val calledBy = mutableListOf<Node>()
-    val calls = mutableSetOf<Subroutine>()
-
     val scopedname: String by lazy { makeScopedName(name) }
 
     override fun linkParents(parent: Node) {
@@ -580,13 +631,22 @@ class Subroutine(override val name: String,
         statements.forEach { it.linkParents(this) }
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Statement)
+        val idx = statements.indexOfFirst { it===node }
+        statements[idx] = replacement
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     override fun toString(): String {
         return "Subroutine(name=$name, parameters=$parameters, returntypes=$returntypes, ${statements.size} statements, address=$asmAddress)"
     }
 
+    fun regXasResult() = asmReturnvaluesRegisters.any { it.registerOrPair in setOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
+
     fun amountOfRtsInAsm(): Int = statements
             .asSequence()
             .filter { it is InlineAssembly }
@@ -603,6 +663,10 @@ open class SubroutineParameter(val name: String,
     override fun linkParents(parent: Node) {
         this.parent = parent
     }
+
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        throw FatalAstException("can't replace anything in a subroutineparameter node")
+    }
 }
 
 class IfStatement(var condition: Expression,
@@ -610,8 +674,6 @@ class IfStatement(var condition: Expression,
                   var elsepart: AnonymousScope,
                   override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline: Boolean
-        get() = truepart.expensiveToInline || elsepart.expensiveToInline
 
     override fun linkParents(parent: Node) {
         this.parent = parent
@@ -620,8 +682,19 @@ class IfStatement(var condition: Expression,
         elsepart.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        when {
+            node===condition -> condition = replacement as Expression
+            node===truepart -> truepart = replacement as AnonymousScope
+            node===elsepart -> elsepart = replacement as AnonymousScope
+            else -> throw FatalAstException("invalid replace")
+        }
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
+
 }
 
 class BranchStatement(var condition: BranchCondition,
@@ -629,8 +702,6 @@ class BranchStatement(var condition: BranchCondition,
                       var elsepart: AnonymousScope,
                       override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline: Boolean
-        get() = truepart.expensiveToInline || elsepart.expensiveToInline
 
     override fun linkParents(parent: Node) {
         this.parent = parent
@@ -638,44 +709,57 @@ class BranchStatement(var condition: BranchCondition,
         elsepart.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        when {
+            node===truepart -> truepart = replacement as AnonymousScope
+            node===elsepart -> elsepart = replacement as AnonymousScope
+            else -> throw FatalAstException("invalid replace")
+        }
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
+
 }
 
-class ForLoop(val loopRegister: Register?,
-              var loopVar: IdentifierReference?,
+class ForLoop(var loopVar: IdentifierReference,
               var iterable: Expression,
               var body: AnonymousScope,
               override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = true
 
     override fun linkParents(parent: Node) {
         this.parent=parent
-        loopVar?.linkParents(this)
+        loopVar.linkParents(this)
         iterable.linkParents(this)
         body.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        when {
+            node===loopVar -> loopVar = replacement as IdentifierReference
+            node===iterable -> iterable = replacement as Expression
+            node===body -> body = replacement as AnonymousScope
+            else -> throw FatalAstException("invalid replace")
+        }
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     override fun toString(): String {
-        return "ForLoop(loopVar: $loopVar, loopReg: $loopRegister, iterable: $iterable, pos=$position)"
+        return "ForLoop(loopVar: $loopVar, iterable: $iterable, pos=$position)"
     }
 
-    fun loopVarDt(program: Program): InferredTypes.InferredType {
-        val lv = loopVar
-        return if(loopRegister!=null) InferredTypes.InferredType.known(DataType.UBYTE)
-                else lv?.inferType(program) ?: InferredTypes.InferredType.unknown()
-    }
+    fun loopVarDt(program: Program) = loopVar.inferType(program)
 }
 
 class WhileLoop(var condition: Expression,
                 var body: AnonymousScope,
                 override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = true
 
     override fun linkParents(parent: Node) {
         this.parent = parent
@@ -683,28 +767,45 @@ class WhileLoop(var condition: Expression,
         body.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        when {
+            node===condition -> condition = replacement as Expression
+            node===body -> body = replacement as AnonymousScope
+            else -> throw FatalAstException("invalid replace")
+        }
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
-class ForeverLoop(var body: AnonymousScope, override val position: Position) : Statement() {
+class RepeatLoop(var iterations: Expression?, var body: AnonymousScope, override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = true
 
     override fun linkParents(parent: Node) {
         this.parent = parent
+        iterations?.linkParents(this)
         body.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        when {
+            node===iterations -> iterations = replacement as Expression
+            node===body -> body = replacement as AnonymousScope
+            else -> throw FatalAstException("invalid replace")
+        }
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
-class RepeatLoop(var body: AnonymousScope,
-                 var untilCondition: Expression,
-                 override val position: Position) : Statement() {
+class UntilLoop(var body: AnonymousScope,
+                var untilCondition: Expression,
+                override val position: Position) : Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline = true
 
     override fun linkParents(parent: Node) {
         this.parent = parent
@@ -712,15 +813,23 @@ class RepeatLoop(var body: AnonymousScope,
         body.linkParents(this)
     }
 
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        when {
+            node===untilCondition -> untilCondition = replacement as Expression
+            node===body -> body = replacement as AnonymousScope
+            else -> throw FatalAstException("invalid replace")
+        }
+        replacement.parent = this
+    }
+
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
 class WhenStatement(var condition: Expression,
                     var choices: MutableList<WhenChoice>,
                     override val position: Position): Statement() {
     override lateinit var parent: Node
-    override val expensiveToInline: Boolean = true
 
     override fun linkParents(parent: Node) {
         this.parent = parent
@@ -728,6 +837,16 @@ class WhenStatement(var condition: Expression,
         choices.forEach { it.linkParents(this) }
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        if(node===condition)
+            condition = replacement as Expression
+        else {
+            val idx = choices.withIndex().find { it.value===node }!!.index
+            choices[idx] = replacement as WhenChoice
+        }
+        replacement.parent = this
+    }
+
     fun choiceValues(program: Program): List<Pair<List<Int>?, WhenChoice>> {
         // only gives sensible results when the choices are all valid (constant integers)
         val result = mutableListOf<Pair<List<Int>?, WhenChoice>>()
@@ -746,7 +865,7 @@ class WhenStatement(var condition: Expression,
     }
 
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
 class WhenChoice(var values: List<Expression>?,           // if null,  this is the 'else' part
@@ -760,12 +879,18 @@ class WhenChoice(var values: List<Expression>?,           // if null,  this is t
         this.parent = parent
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is AnonymousScope && node===statements)
+        statements = replacement
+        replacement.parent = this
+    }
+
     override fun toString(): String {
         return "Choice($values at $position)"
     }
 
     fun accept(visitor: IAstVisitor) = visitor.visit(this)
-    fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
 
@@ -774,18 +899,24 @@ class StructDecl(override val name: String,
                  override val position: Position): Statement(), INameScope {
 
     override lateinit var parent: Node
-    override val expensiveToInline: Boolean = true
 
     override fun linkParents(parent: Node) {
         this.parent = parent
         this.statements.forEach { it.linkParents(this) }
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Statement)
+        val idx = statements.indexOfFirst { it===node }
+        statements[idx] = replacement
+        replacement.parent = this
+    }
+
     val numberOfElements: Int
         get() = this.statements.size
 
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
-    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     fun nameOfFirstMember() = (statements.first() as VarDecl).name
 }
@@ -798,10 +929,16 @@ class DirectMemoryWrite(var addressExpression: Expression, override val position
         this.addressExpression.linkParents(this)
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Expression && node===addressExpression)
+        addressExpression = replacement
+        replacement.parent = this
+    }
+
     override fun toString(): String {
         return "DirectMemoryWrite($addressExpression)"
     }
 
     fun accept(visitor: IAstVisitor) = visitor.visit(this)
-    fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }

compiler/src/prog8/compiler/BeforeAsmGenerationAstChanger.kt

@@ -0,0 +1,106 @@
+package prog8.compiler
+
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.AstWalker
+import prog8.ast.processing.IAstModification
+import prog8.ast.statements.*
+
+
+internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: ErrorReporter) : AstWalker() {
+
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
+        if (decl.value == null && decl.type == VarDeclType.VAR && decl.datatype in NumericDatatypes) {
+            // a numeric vardecl without an initial value is initialized with zero.
+            decl.value = decl.zeroElementValue()
+        }
+        return noModifications
+    }
+
+    override fun after(scope: AnonymousScope, parent: Node): Iterable<IAstModification> {
+        val decls = scope.statements.filterIsInstance<VarDecl>()
+        val sub = scope.definingSubroutine()
+        if (sub != null) {
+            val existingVariables = sub.statements.filterIsInstance<VarDecl>().associateBy { it.name }
+            var conflicts = false
+            decls.forEach {
+                val existing = existingVariables[it.name]
+                if (existing != null) {
+                    errors.err("variable ${it.name} already defined in subroutine ${sub.name} at ${existing.position}", it.position)
+                    conflicts = true
+                }
+            }
+            if (!conflicts) {
+                val numericVarsWithValue = decls.filter { it.value != null && it.datatype in NumericDatatypes }
+                return numericVarsWithValue.map {
+                    val initValue = it.value!!  // assume here that value has always been set by now
+                    it.value = null     // make sure no value init assignment for this vardecl will be created later (would be superfluous)
+                    val target = AssignTarget(IdentifierReference(listOf(it.name), it.position), null, null, it.position)
+                    val assign = Assignment(target, null, initValue, it.position)
+                    initValue.parent = assign
+                    IAstModification.InsertFirst(assign, scope)
+                } +  decls.map { IAstModification.ReplaceNode(it, NopStatement(it.position), scope) } +
+                     decls.map { IAstModification.InsertFirst(it, sub) }    // move it up to the subroutine
+            }
+        }
+        return noModifications
+    }
+
+    override fun after(subroutine: Subroutine, parent: Node): Iterable<IAstModification> {
+        // add the implicit return statement at the end (if it's not there yet), but only if it's not a kernel routine.
+        // and if an assembly block doesn't contain a rts/rti, and some other situations.
+        val mods = mutableListOf<IAstModification>()
+        val returnStmt = Return(null, subroutine.position)
+        if (subroutine.asmAddress == null
+                && subroutine.statements.isNotEmpty()
+                && subroutine.amountOfRtsInAsm() == 0
+                && subroutine.statements.lastOrNull { it !is VarDecl } !is Return
+                && subroutine.statements.last() !is Subroutine) {
+            mods += IAstModification.InsertLast(returnStmt, subroutine)
+        }
+
+        // precede a subroutine with a return to avoid falling through into the subroutine from code above it
+        val outerScope = subroutine.definingScope()
+        val outerStatements = outerScope.statements
+        val subroutineStmtIdx = outerStatements.indexOf(subroutine)
+        if (subroutineStmtIdx > 0
+                && outerStatements[subroutineStmtIdx - 1] !is Jump
+                && outerStatements[subroutineStmtIdx - 1] !is Subroutine
+                && outerStatements[subroutineStmtIdx - 1] !is Return
+                && outerScope !is Block) {
+            mods += IAstModification.InsertAfter(outerStatements[subroutineStmtIdx - 1], returnStmt, outerScope as Node)
+        }
+
+        return mods
+    }
+
+    override fun after(typecast: TypecastExpression, parent: Node): Iterable<IAstModification> {
+        // see if we can remove superfluous typecasts (outside of expressions)
+        // such as casting byte<->ubyte,  word<->uword
+        // Also the special typecast of a reference type (str, array) to an UWORD will be changed into address-of.
+        val sourceDt = typecast.expression.inferType(program).typeOrElse(DataType.STRUCT)
+        if (typecast.type in ByteDatatypes && sourceDt in ByteDatatypes
+                || typecast.type in WordDatatypes && sourceDt in WordDatatypes) {
+            if(typecast.parent !is Expression) {
+                return listOf(IAstModification.ReplaceNode(typecast, typecast.expression, parent))
+            }
+        }
+        else if(sourceDt in PassByReferenceDatatypes) {
+            if(typecast.type==DataType.UWORD) {
+                return listOf(IAstModification.ReplaceNode(
+                        typecast,
+                        AddressOf(typecast.expression as IdentifierReference, typecast.position),
+                        parent
+                ))
+            } else {
+                errors.err("cannot cast pass-by-reference value to type ${typecast.type} (only to UWORD)", typecast.position)
+            }
+        }
+
+        return noModifications
+    }
+}

compiler/src/prog8/compiler/Main.kt

@@ -5,6 +5,7 @@ import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.statements.Directive
 import prog8.compiler.target.CompilationTarget
+import prog8.optimizer.UnusedCodeRemover
 import prog8.optimizer.constantFold
 import prog8.optimizer.optimizeStatements
 import prog8.optimizer.simplifyExpressions
@@ -25,107 +26,31 @@ fun compileProgram(filepath: Path,
                    optimize: Boolean,
                    writeAssembly: Boolean,
                    outputDir: Path): CompilationResult {
+    var programName = ""
     lateinit var programAst: Program
-    var programName: String? = null
-
-    var importedFiles: List<Path> = emptyList()
-    var success=false
-
+    lateinit var importedFiles: List<Path>
     val errors = ErrorReporter()
 
     try {
         val totalTime = measureTimeMillis {
             // import main module and everything it needs
-            val importer = ModuleImporter(errors)
-            errors.handle()
-
-            println("Parsing...")
-            programAst = Program(moduleName(filepath.fileName), mutableListOf())
-            importer.importModule(programAst, filepath)
-            errors.handle()
-
-            importedFiles = programAst.modules.filter { !it.source.startsWith("@embedded@") }.map{ it.source }
-
-            val compilerOptions = determineCompilationOptions(programAst)
-            if (compilerOptions.launcher == LauncherType.BASIC && compilerOptions.output != OutputType.PRG)
-                throw ParsingFailedError("${programAst.modules.first().position} BASIC launcher requires output type PRG.")
-
-            // if we're producing a PRG or BASIC program, include the c64utils and c64lib libraries
-            if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG) {
-                importer.importLibraryModule(programAst, "c64lib")
-                importer.importLibraryModule(programAst, "c64utils")
-            }
-
-            // always import prog8lib and math
-            importer.importLibraryModule(programAst, "math")
-            importer.importLibraryModule(programAst, "prog8lib")
-            errors.handle()
-
-            // perform initial syntax checks and constant folding
-            println("Syntax check...")
-            val time1 = measureTimeMillis {
-                programAst.checkIdentifiers(errors)
-                errors.handle()
-                programAst.makeForeverLoops()
-            }
-
-            //println(" time1: $time1")
-            val time2 = measureTimeMillis {
-                programAst.constantFold(errors)
-                errors.handle()
-            }
-            //println(" time2: $time2")
-            val time3 = measureTimeMillis {
-                programAst.removeNopsFlattenAnonScopes()
-                programAst.reorderStatements()
-                programAst.addTypecasts(errors)
-                errors.handle()
-            }
-            //println(" time3: $time3")
-            val time4 = measureTimeMillis {
-                programAst.checkValid(compilerOptions, errors)          // check if tree is valid
-                errors.handle()
-            }
-            //println(" time4: $time4")
-
-            programAst.checkIdentifiers(errors)
-            errors.handle()
-
-            if (optimize) {
-                // optimize the parse tree
-                println("Optimizing...")
-                while (true) {
-                    // keep optimizing expressions and statements until no more steps remain
-                    val optsDone1 = programAst.simplifyExpressions()
-                    val optsDone2 = programAst.optimizeStatements(errors)
-                    errors.handle()
-                    if (optsDone1 + optsDone2 == 0)
-                        break
-                }
-            }
-
-            programAst.addTypecasts(errors)
-            errors.handle()
-            programAst.removeNopsFlattenAnonScopes()
-            programAst.checkValid(compilerOptions, errors)          // check if final tree is valid
-            errors.handle()
-            programAst.checkRecursion(errors)         // check if there are recursive subroutine calls
-            errors.handle()
+            val (ast, compilationOptions, imported) = parseImports(filepath, errors)
+            programAst = ast
+            importedFiles = imported
+            processAst(programAst, errors, compilationOptions)
+            if (optimize)
+                optimizeAst(programAst, errors)
+            postprocessAst(programAst, errors, compilationOptions)
 
             // printAst(programAst)
 
-            if(writeAssembly) {
-                // asm generation directly from the Ast, no need for intermediate code
-                val zeropage = CompilationTarget.machine.getZeropage(compilerOptions)
-                programAst.anonscopeVarsCleanup(errors)
-                errors.handle()
-                val assembly = CompilationTarget.asmGenerator(programAst, zeropage, compilerOptions, outputDir).compileToAssembly(optimize)
-                assembly.assemble(compilerOptions)
-                programName = assembly.name
-            }
-            success = true
+            if(writeAssembly)
+                programName = writeAssembly(programAst, errors, outputDir, optimize, compilationOptions)
         }
+        System.out.flush()
+        System.err.flush()
         println("\nTotal compilation+assemble time: ${totalTime / 1000.0} sec.")
+        return CompilationResult(true, programAst, programName, importedFiles)
 
     } catch (px: ParsingFailedError) {
         System.err.print("\u001b[91m")  // bright red
@@ -148,16 +73,35 @@ fun compileProgram(filepath: Path,
         System.out.flush()
         throw x
     }
-    return CompilationResult(success, programAst, programName ?: "", importedFiles)
+
+    return CompilationResult(false, Program("failed", mutableListOf()), programName, emptyList())
 }
 
-fun printAst(programAst: Program) {
-    println()
-    val printer = AstToSourceCode(::print, programAst)
-    printer.visit(programAst)
-    println()
-}
+private fun parseImports(filepath: Path, errors: ErrorReporter): Triple<Program, CompilationOptions, List<Path>> {
+    println("Parsing...")
+    val importer = ModuleImporter(errors)
+    val programAst = Program(moduleName(filepath.fileName), mutableListOf())
+    importer.importModule(programAst, filepath)
+    errors.handle()
 
+    val importedFiles = programAst.modules.filter { !it.source.startsWith("@embedded@") }.map { it.source }
+
+    val compilerOptions = determineCompilationOptions(programAst)
+    if (compilerOptions.launcher == LauncherType.BASIC && compilerOptions.output != OutputType.PRG)
+        throw ParsingFailedError("${programAst.modules.first().position} BASIC launcher requires output type PRG.")
+
+    // if we're producing a PRG or BASIC program, include the c64utils and c64lib libraries
+    if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG) {
+        importer.importLibraryModule(programAst, "c64lib")
+        importer.importLibraryModule(programAst, "c64utils")
+    }
+
+    // always import prog8lib and math
+    importer.importLibraryModule(programAst, "math")
+    importer.importLibraryModule(programAst, "prog8lib")
+    errors.handle()
+    return Triple(programAst, compilerOptions, importedFiles)
+}
 
 private fun determineCompilationOptions(program: Program): CompilationOptions {
     val mainModule = program.modules.first()
@@ -194,3 +138,79 @@ private fun determineCompilationOptions(program: Program): CompilationOptions {
             zpType, zpReserved, floatsEnabled
     )
 }
+
+private fun processAst(programAst: Program, errors: ErrorReporter, compilerOptions: CompilationOptions) {
+    // perform initial syntax checks and processings
+    println("Processing...")
+    programAst.checkIdentifiers(errors)
+    errors.handle()
+    programAst.constantFold(errors)
+    errors.handle()
+    programAst.reorderStatements()
+    programAst.addTypecasts(errors)
+    errors.handle()
+    programAst.variousCleanups()
+    programAst.checkValid(compilerOptions, errors)
+    errors.handle()
+    programAst.checkIdentifiers(errors)
+    errors.handle()
+}
+
+private fun optimizeAst(programAst: Program, errors: ErrorReporter) {
+    // optimize the parse tree
+    println("Optimizing...")
+    while (true) {
+        // keep optimizing expressions and statements until no more steps remain
+        val optsDone1 = programAst.simplifyExpressions()
+        val optsDone2 = programAst.optimizeStatements(errors)
+        programAst.constantFold(errors) // because simplified statements and expressions could give rise to more constants that can be folded away:
+        errors.handle()
+        if (optsDone1 + optsDone2 == 0)
+            break
+    }
+
+    val remover = UnusedCodeRemover()
+    remover.visit(programAst)
+    remover.applyModifications()
+}
+
+private fun postprocessAst(programAst: Program, errors: ErrorReporter, compilerOptions: CompilationOptions) {
+    programAst.transformAssignments(errors)
+    errors.handle()
+    programAst.addTypecasts(errors)
+    errors.handle()
+    programAst.variousCleanups()
+    programAst.checkValid(compilerOptions, errors)          // check if final tree is still valid
+    errors.handle()
+    programAst.checkRecursion(errors)         // check if there are recursive subroutine calls
+    errors.handle()
+    programAst.verifyFunctionArgTypes()
+}
+
+private fun writeAssembly(programAst: Program, errors: ErrorReporter, outputDir: Path,
+                          optimize: Boolean, compilerOptions: CompilationOptions): String {
+    // asm generation directly from the Ast,
+    val zeropage = CompilationTarget.machine.getZeropage(compilerOptions)
+    programAst.processAstBeforeAsmGeneration(errors)
+    errors.handle()
+
+    // printAst(programAst)
+
+    val assembly = CompilationTarget.asmGenerator(
+            programAst,
+            errors,
+            zeropage,
+            compilerOptions,
+            outputDir).compileToAssembly(optimize)
+    assembly.assemble(compilerOptions)
+    errors.handle()
+    return assembly.name
+}
+
+fun printAst(programAst: Program) {
+    println()
+    val printer = AstToSourceCode(::print, programAst)
+    printer.visit(programAst)
+    println()
+}
+

compiler/src/prog8/compiler/Zeropage.kt

@@ -30,7 +30,7 @@ abstract class Zeropage(protected val options: CompilationOptions) {
                             if(position!=null)
                                 errors.warn("allocated a large value (float) in zeropage", position)
                             else
-                                errors.warn("$scopedname: allocated a large value (float) in zeropage", null)
+                                errors.warn("$scopedname: allocated a large value (float) in zeropage", position ?: Position.DUMMY)
                             5
                         } else throw CompilerException("floating point option not enabled")
                     }

compiler/src/prog8/compiler/target/CompilationTarget.kt

@@ -1,16 +1,18 @@
 package prog8.compiler.target
 
 import prog8.ast.Program
+import prog8.ast.base.ErrorReporter
 import prog8.compiler.CompilationOptions
 import prog8.compiler.Zeropage
 import java.nio.file.Path
 
+
 internal interface CompilationTarget {
     companion object {
         lateinit var name: String
         lateinit var machine: IMachineDefinition
         lateinit var encodeString: (str: String, altEncoding: Boolean) -> List<Short>
         lateinit var decodeString: (bytes: List<Short>, altEncoding: Boolean) -> String
-        lateinit var asmGenerator: (Program, Zeropage, CompilationOptions, Path) -> IAssemblyGenerator
+        lateinit var asmGenerator: (Program, ErrorReporter, Zeropage, CompilationOptions, Path) -> IAssemblyGenerator
     }
 }

compiler/src/prog8/compiler/target/c64/C64MachineDefinition.kt

@@ -5,9 +5,6 @@ import prog8.compiler.CompilerException
 import prog8.compiler.Zeropage
 import prog8.compiler.ZeropageType
 import prog8.compiler.target.IMachineDefinition
-import java.awt.Color
-import java.awt.image.BufferedImage
-import javax.imageio.ImageIO
 import kotlin.math.absoluteValue
 import kotlin.math.pow
 
@@ -177,90 +174,4 @@ object C64MachineDefinition: IMachineDefinition {
             return if (sign) -result else result
         }
     }
-
-    object Charset {
-        private val normalImg = ImageIO.read(javaClass.getResource("/charset/c64/charset-normal.png"))
-        private val shiftedImg = ImageIO.read(javaClass.getResource("/charset/c64/charset-shifted.png"))
-
-        private fun scanChars(img: BufferedImage): Array<BufferedImage> {
-
-            val transparent = BufferedImage(img.width, img.height, BufferedImage.TYPE_INT_ARGB)
-            transparent.createGraphics().drawImage(img, 0, 0, null)
-
-            val black = Color(0, 0, 0).rgb
-            val nopixel = Color(0, 0, 0, 0).rgb
-            for (y in 0 until transparent.height) {
-                for (x in 0 until transparent.width) {
-                    val col = transparent.getRGB(x, y)
-                    if (col == black)
-                        transparent.setRGB(x, y, nopixel)
-                }
-            }
-
-            val numColumns = transparent.width / 8
-            val charImages = (0..255).map {
-                val charX = it % numColumns
-                val charY = it / numColumns
-                transparent.getSubimage(charX * 8, charY * 8, 8, 8)
-            }
-            return charImages.toTypedArray()
-        }
-
-        val normalChars = scanChars(normalImg)
-        val shiftedChars = scanChars(shiftedImg)
-
-        private val coloredNormalChars = mutableMapOf<Short, Array<BufferedImage>>()
-
-        fun getColoredChar(screenCode: Short, color: Short): BufferedImage {
-            val colorIdx = (color % colorPalette.size).toShort()
-            val chars = coloredNormalChars[colorIdx]
-            if (chars != null)
-                return chars[screenCode.toInt()]
-
-            val coloredChars = mutableListOf<BufferedImage>()
-            val transparent = Color(0, 0, 0, 0).rgb
-            val rgb = colorPalette[colorIdx.toInt()].rgb
-            for (c in normalChars) {
-                val colored = c.copy()
-                for (y in 0 until colored.height)
-                    for (x in 0 until colored.width) {
-                        if (colored.getRGB(x, y) != transparent) {
-                            colored.setRGB(x, y, rgb)
-                        }
-                    }
-                coloredChars.add(colored)
-            }
-            coloredNormalChars[colorIdx] = coloredChars.toTypedArray()
-            return coloredNormalChars.getValue(colorIdx)[screenCode.toInt()]
-        }
-
-    }
-
-    private fun BufferedImage.copy(): BufferedImage {
-        val bcopy = BufferedImage(this.width, this.height, this.type)
-        val g = bcopy.graphics
-        g.drawImage(this, 0, 0, null)
-        g.dispose()
-        return bcopy
-    }
-
-    val colorPalette = listOf(         // this is Pepto's Commodore-64 palette  http://www.pepto.de/projects/colorvic/
-            Color(0x000000),  // 0 = black
-            Color(0xFFFFFF),  // 1 = white
-            Color(0x813338),  // 2 = red
-            Color(0x75cec8),  // 3 = cyan
-            Color(0x8e3c97),  // 4 = purple
-            Color(0x56ac4d),  // 5 = green
-            Color(0x2e2c9b),  // 6 = blue
-            Color(0xedf171),  // 7 = yellow
-            Color(0x8e5029),  // 8 = orange
-            Color(0x553800),  // 9 = brown
-            Color(0xc46c71),  // 10 = light red
-            Color(0x4a4a4a),  // 11 = dark grey
-            Color(0x7b7b7b),  // 12 = medium grey
-            Color(0xa9ff9f),  // 13 = light green
-            Color(0x706deb),  // 14 = light blue
-            Color(0xb2b2b2)   // 15 = light grey
-    )
-
 }

compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt

@@ -1,5 +1,6 @@
 package prog8.compiler.target.c64.codegen
 
+import prog8.ast.INameScope
 import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.antlr.escape
@@ -26,9 +27,10 @@ import kotlin.math.absoluteValue
 
 
 internal class AsmGen(private val program: Program,
-             private val zeropage: Zeropage,
-             private val options: CompilationOptions,
-             private val outputDir: Path): IAssemblyGenerator {
+                      private val errors: ErrorReporter,
+                      private val zeropage: Zeropage,
+                      private val options: CompilationOptions,
+                      private val outputDir: Path): IAssemblyGenerator {
 
     private val assemblyLines = mutableListOf<String>()
     private val globalFloatConsts = mutableMapOf<Double, String>()     // all float values in the entire program (value -> varname)
@@ -38,10 +40,11 @@ internal class AsmGen(private val program: Program,
     private val forloopsAsmGen = ForLoopsAsmGen(program, this)
     private val postincrdecrAsmGen = PostIncrDecrAsmGen(program, this)
     private val functioncallAsmGen = FunctionCallAsmGen(program, this)
-    private val assignmentAsmGen = AssignmentAsmGen(program, this)
+    private val assignmentAsmGen = AssignmentAsmGen(program, errors, this)
     private val expressionsAsmGen = ExpressionsAsmGen(program, this)
     internal val loopEndLabels = ArrayDeque<String>()
     internal val loopContinueLabels = ArrayDeque<String>()
+    internal val blockLevelVarInits = mutableMapOf<Block, MutableSet<VarDecl>>()
 
     override fun compileToAssembly(optimize: Boolean): IAssemblyProgram {
         assemblyLines.clear()
@@ -125,11 +128,10 @@ internal class AsmGen(private val program: Program,
 
         out("  ldx  #\$ff\t; init estack pointer")
 
-        out("  ; initialize the variables in each block")
-        for (block in program.allBlocks()) {
-            val initVarsSub = block.statements.singleOrNull { it is Subroutine && it.name == initvarsSubName }
-            if(initVarsSub!=null)
-                out("  jsr  ${block.name}.$initvarsSubName")
+        out("  ; initialize the variables in each block that has globals")
+        program.allBlocks().forEach {
+            if(it.statements.filterIsInstance<VarDecl>().any { vd->vd.value!=null && vd.type==VarDeclType.VAR && vd.datatype in NumericDatatypes})
+                out("  jsr  ${it.name}.prog8_init_vars")
         }
 
         out("  clc")
@@ -175,6 +177,21 @@ internal class AsmGen(private val program: Program,
         stmts.forEach { translate(it) }
         subroutine.forEach { translateSubroutine(it as Subroutine) }
 
+        // if any global vars need to be initialized, generate a subroutine that does this
+        // it will be called from program init.
+        if(block in blockLevelVarInits) {
+            out("prog8_init_vars\t.proc\n")
+            blockLevelVarInits.getValue(block).forEach { decl ->
+                val scopedFullName = decl.makeScopedName(decl.name).split('.')
+                require(scopedFullName.first()==block.name)
+                val target = AssignTarget(IdentifierReference(scopedFullName.drop(1), decl.position), null, null, decl.position)
+                val assign = Assignment(target, null, decl.value!!, decl.position)
+                assign.linkParents(decl.parent)
+                assignmentAsmGen.translate(assign)
+            }
+            out("  rts\n  .pend")
+        }
+
         out(if("force_output" in block.options()) "\n\t.bend\n" else "\n\t.pend\n")
     }
 
@@ -220,7 +237,7 @@ internal class AsmGen(private val program: Program,
         val variables = statements.filterIsInstance<VarDecl>().filter { it.type==VarDeclType.VAR }
         for(variable in variables) {
             // should NOT allocate subroutine parameters on the zero page
-            val fullName = variable.scopedname
+            val fullName = variable.makeScopedName(variable.name)
             val zpVar = allocatedZeropageVariables[fullName]
             if(zpVar==null) {
                 // This var is not on the ZP yet. Attempt to move it there (if it's not a float, those take up too much space)
@@ -296,7 +313,14 @@ internal class AsmGen(private val program: Program,
                 }
             }
             DataType.ARRAY_F -> {
-                val array = (decl.value as ArrayLiteralValue).value
+                val array =
+                        if(decl.value!=null)
+                            (decl.value as ArrayLiteralValue).value
+                        else {
+                            // no init value, use zeros
+                            val zero = decl.zeroElementValue()
+                            Array(decl.arraysize!!.size()!!) { zero }
+                        }
                 val floatFills = array.map {
                     val number = (it as NumericLiteralValue).number
                     makeFloatFill(C64MachineDefinition.Mflpt5.fromNumber(number))
@@ -350,7 +374,7 @@ internal class AsmGen(private val program: Program,
 
         // non-string variables
         normalVars.filter{ it.datatype != DataType.STR }.sortedBy { it.datatype }.forEach {
-            if(it.scopedname !in allocatedZeropageVariables)
+            if(it.makeScopedName(it.name) !in allocatedZeropageVariables)
                 vardecl2asm(it)
         }
     }
@@ -364,7 +388,14 @@ internal class AsmGen(private val program: Program,
     }
 
     private fun makeArrayFillDataUnsigned(decl: VarDecl): List<String> {
-        val array = (decl.value as ArrayLiteralValue).value
+        val array =
+                if(decl.value!=null)
+                    (decl.value as ArrayLiteralValue).value
+                else {
+                    // no array init value specified, use a list of zeros
+                    val zero = decl.zeroElementValue()
+                    Array(decl.arraysize!!.size()!!) { zero }
+                }
         return when (decl.datatype) {
             DataType.ARRAY_UB ->
                 // byte array can never contain pointer-to types, so treat values as all integers
@@ -384,17 +415,22 @@ internal class AsmGen(private val program: Program,
     }
 
     private fun makeArrayFillDataSigned(decl: VarDecl): List<String> {
-        val array = (decl.value as ArrayLiteralValue).value
-
-        return when {
-            decl.datatype == DataType.ARRAY_UB ->
+        val array =
+                if(decl.value!=null)
+                    (decl.value as ArrayLiteralValue).value
+                else {
+                    // no array init value specified, use a list of zeros
+                    val zero = decl.zeroElementValue()
+                    Array(decl.arraysize!!.size()!!) { zero }
+                }
+        return when (decl.datatype) {
+            DataType.ARRAY_UB ->
                 // byte array can never contain pointer-to types, so treat values as all integers
                 array.map {
                     val number = (it as NumericLiteralValue).number.toInt()
-                    val hexnum = number.toString(16).padStart(2, '0')
-                    "$$hexnum"
+                    "$"+number.toString(16).padStart(2, '0')
                 }
-            decl.datatype == DataType.ARRAY_B ->
+            DataType.ARRAY_B ->
                 // byte array can never contain pointer-to types, so treat values as all integers
                 array.map {
                     val number = (it as NumericLiteralValue).number.toInt()
@@ -404,12 +440,11 @@ internal class AsmGen(private val program: Program,
                     else
                         "-$$hexnum"
                 }
-            decl.datatype== DataType.ARRAY_UW -> array.map {
+            DataType.ARRAY_UW -> array.map {
                 val number = (it as NumericLiteralValue).number.toInt()
-                val hexnum = number.toString(16).padStart(4, '0')
-                "$$hexnum"
+                "$" + number.toString(16).padStart(4, '0')
             }
-            decl.datatype== DataType.ARRAY_W -> array.map {
+            DataType.ARRAY_W -> array.map {
                 val number = (it as NumericLiteralValue).number.toInt()
                 val hexnum = number.absoluteValue.toString(16).padStart(4, '0')
                 if(number>=0)
@@ -527,19 +562,19 @@ internal class AsmGen(private val program: Program,
         }
     }
 
-    internal fun saveRegister(register: Register) {
+    internal fun saveRegister(register: CpuRegister) {
         when(register) {
-            Register.A -> out("  pha")
-            Register.X -> out("  txa | pha")
-            Register.Y -> out("  tya | pha")
+            CpuRegister.A -> out("  pha")
+            CpuRegister.X -> out("  txa | pha")
+            CpuRegister.Y -> out("  tya | pha")
         }
     }
 
-    internal fun restoreRegister(register: Register) {
+    internal fun restoreRegister(register: CpuRegister) {
         when(register) {
-            Register.A -> out("  pla")
-            Register.X -> out("  pla | tax")
-            Register.Y -> out("  pla | tay")
+            CpuRegister.A -> out("  pla")
+            CpuRegister.X -> out("  pla | tax")
+            CpuRegister.Y -> out("  pla | tay")
         }
     }
 
@@ -571,7 +606,9 @@ internal class AsmGen(private val program: Program,
     internal fun translate(stmt: Statement) {
         outputSourceLine(stmt)
         when(stmt) {
-            is VarDecl, is StructDecl, is NopStatement -> {}
+            is ParameterVarDecl -> { /* subroutine parameter vardecls don't get any special treatment here */ }
+            is VarDecl -> translate(stmt)
+            is StructDecl, is NopStatement -> {}
             is Directive -> translate(stmt)
             is Return -> translate(stmt)
             is Subroutine -> translateSubroutine(stmt)
@@ -604,13 +641,13 @@ internal class AsmGen(private val program: Program,
             is Continue -> out("  jmp  ${loopContinueLabels.peek()}")
             is Break -> out("  jmp  ${loopEndLabels.peek()}")
             is WhileLoop -> translate(stmt)
-            is ForeverLoop -> translate(stmt)
             is RepeatLoop -> translate(stmt)
+            is UntilLoop -> translate(stmt)
             is WhenStatement -> translate(stmt)
             is BuiltinFunctionStatementPlaceholder -> throw AssemblyError("builtin function should not have placeholder anymore?")
             is AnonymousScope -> translate(stmt)
             is Block -> throw AssemblyError("block should have been handled elsewhere")
-            else -> TODO("no translation for $stmt")
+            else -> throw AssemblyError("missing asm translation for $stmt")
         }
     }
 
@@ -636,26 +673,114 @@ internal class AsmGen(private val program: Program,
         }
     }
 
-    private fun translate(stmt: ForeverLoop) {
-        val foreverLabel = makeLabel("forever")
-        val endLabel = makeLabel("foreverend")
+    private fun translate(stmt: RepeatLoop) {
+        val repeatLabel = makeLabel("repeat")
+        val endLabel = makeLabel("repeatend")
+        val counterLabel = makeLabel("repeatcounter")
         loopEndLabels.push(endLabel)
-        loopContinueLabels.push(foreverLabel)
-        out(foreverLabel)
-        translate(stmt.body)
-        out("  jmp  $foreverLabel")
-        out(endLabel)
+        loopContinueLabels.push(repeatLabel)
+
+        when (stmt.iterations) {
+            null -> {
+                // endless loop
+                out(repeatLabel)
+                translate(stmt.body)
+                out("  jmp  $repeatLabel")
+                out(endLabel)
+            }
+            is NumericLiteralValue -> {
+                val iterations = (stmt.iterations as NumericLiteralValue).number.toInt()
+                if(iterations<0 || iterations > 65536)
+                    throw AssemblyError("invalid number of iterations")
+                when {
+                    iterations == 0 -> {}
+                    iterations <= 255 -> {
+                        out("  lda  #${iterations}")
+                        repeatByteCountInA(counterLabel, repeatLabel, endLabel, stmt.body)
+                    }
+                    else -> {
+                        out("  lda  #<${iterations} |  ldy  #>${iterations}")
+                        repeatWordCountInAY(counterLabel, repeatLabel, endLabel, stmt.body)
+                    }
+                }
+            }
+            is IdentifierReference -> {
+                val vardecl = (stmt.iterations as IdentifierReference).targetStatement(program.namespace) as VarDecl
+                val name = asmIdentifierName(stmt.iterations as IdentifierReference)
+                when(vardecl.datatype) {
+                    DataType.UBYTE, DataType.BYTE -> {
+                        out("  lda  $name")
+                        repeatByteCountInA(counterLabel, repeatLabel, endLabel, stmt.body)
+                    }
+                    DataType.UWORD, DataType.WORD -> {
+                        out("  lda  $name |  ldy  $name+1")
+                        repeatWordCountInAY(counterLabel, repeatLabel, endLabel, stmt.body)
+                    }
+                    else -> throw AssemblyError("invalid loop variable datatype $vardecl")
+                }
+            }
+            else -> {
+                translateExpression(stmt.iterations!!)
+                val dt = stmt.iterations!!.inferType(program).typeOrElse(DataType.STRUCT)
+                when (dt) {
+                    in ByteDatatypes -> {
+                        out("  inx |  lda  ${ESTACK_LO_HEX},x")
+                        repeatByteCountInA(counterLabel, repeatLabel, endLabel, stmt.body)
+                    }
+                    in WordDatatypes -> {
+                        out("  inx |  lda  ${ESTACK_LO_HEX},x |  ldy  ${ESTACK_HI_HEX},x")
+                        repeatWordCountInAY(counterLabel, repeatLabel, endLabel, stmt.body)
+                    }
+                    else -> throw AssemblyError("invalid loop expression datatype $dt")
+                }
+            }
+        }
+
         loopEndLabels.pop()
         loopContinueLabels.pop()
     }
 
+    private fun repeatWordCountInAY(counterLabel: String, repeatLabel: String, endLabel: String, body: AnonymousScope) {
+        // note: A/Y must have been loaded with the number of iterations already!
+        out("""
+                sta  $counterLabel
+                sty  $counterLabel+1
+$repeatLabel    lda  $counterLabel
+                bne  +
+                lda  $counterLabel+1
+                beq  $endLabel
++               lda  $counterLabel
+                bne  +
+                dec  $counterLabel+1
++               dec  $counterLabel
+""")
+        translate(body)
+        out("""
+            jmp  $repeatLabel
+$counterLabel    .word  0
+$endLabel""")
+    }
+
+    private fun repeatByteCountInA(counterLabel: String, repeatLabel: String, endLabel: String, body: AnonymousScope) {
+        // note: A must have been loaded with the number of iterations already!
+        out("""
+                sta  $counterLabel
+$repeatLabel    lda  $counterLabel
+                beq  $endLabel
+                dec  $counterLabel""")
+        translate(body)
+        out("""
+                jmp  $repeatLabel
+$counterLabel    .byte  0
+$endLabel""")
+    }
+
     private fun translate(stmt: WhileLoop) {
         val whileLabel = makeLabel("while")
         val endLabel = makeLabel("whileend")
         loopEndLabels.push(endLabel)
         loopContinueLabels.push(whileLabel)
         out(whileLabel)
-        // TODO optimize for the simple cases, can we avoid stack use?
         expressionsAsmGen.translateExpression(stmt.condition)
         val conditionDt = stmt.condition.inferType(program)
         if(!conditionDt.isKnown)
@@ -678,13 +803,12 @@ internal class AsmGen(private val program: Program,
         loopContinueLabels.pop()
     }
 
-    private fun translate(stmt: RepeatLoop) {
+    private fun translate(stmt: UntilLoop) {
         val repeatLabel = makeLabel("repeat")
         val endLabel = makeLabel("repeatend")
         loopEndLabels.push(endLabel)
         loopContinueLabels.push(repeatLabel)
         out(repeatLabel)
-        // TODO optimize this for the simple cases, can we avoid stack use?
         translate(stmt.body)
         expressionsAsmGen.translateExpression(stmt.untilCondition)
         val conditionDt = stmt.untilCondition.inferType(program)
@@ -735,7 +859,7 @@ internal class AsmGen(private val program: Program,
                             bne  +
                             cpy  #>${value.toHex()}
                             beq  $choiceLabel
-+                            
++
                             """)
                     }
                 }
@@ -789,6 +913,30 @@ internal class AsmGen(private val program: Program,
         }
     }
 
+    private fun translate(stmt: VarDecl) {
+        if(stmt.value!=null && stmt.type==VarDeclType.VAR && stmt.datatype in NumericDatatypes) {
+            // generate an assignment statement to (re)initialize the variable's value.
+            // if the vardecl is not in a subroutine however, we have to initialize it globally.
+            if(stmt.definingSubroutine()==null) {
+                val block = stmt.definingBlock()
+                var inits = blockLevelVarInits[block]
+                if(inits==null) {
+                    inits = mutableSetOf()
+                    blockLevelVarInits[block] = inits
+                }
+                inits.add(stmt)
+            } else {
+                val next = (stmt.parent as INameScope).nextSibling(stmt)
+                if (next !is ForLoop || next.loopVar.nameInSource.single() != stmt.name) {
+                    val target = AssignTarget(IdentifierReference(listOf(stmt.name), stmt.position), null, null, stmt.position)
+                    val assign = Assignment(target, null, stmt.value!!, stmt.position)
+                    assign.linkParents(stmt.parent)
+                    translate(assign)
+                }
+            }
+        }
+    }
+
     private fun translate(stmt: Directive) {
         when(stmt.directive) {
             "%asminclude" -> {
@@ -846,17 +994,11 @@ internal class AsmGen(private val program: Program,
     internal fun translateArrayIndexIntoA(expr: ArrayIndexedExpression) {
         when (val index = expr.arrayspec.index) {
             is NumericLiteralValue -> throw AssemblyError("this should be optimized directly")
-            is RegisterExpr -> {
-                when (index.register) {
-                    Register.A -> {}
-                    Register.X -> out("  txa")
-                    Register.Y -> out("  tya")
-                }
-            }
             is IdentifierReference -> {
                 val indexName = asmIdentifierName(index)
                 out("  lda  $indexName")
             }
+            // TODO optimize more cases
             else -> {
                 expressionsAsmGen.translateExpression(index)
                 out("  inx |  lda  $ESTACK_LO_HEX,x")
@@ -864,6 +1006,21 @@ internal class AsmGen(private val program: Program,
         }
     }
 
+    internal fun translateArrayIndexIntoY(expr: ArrayIndexedExpression) {
+        when (val index = expr.arrayspec.index) {
+            is NumericLiteralValue -> throw AssemblyError("this should be optimized directly")
+            is IdentifierReference -> {
+                val indexName = asmIdentifierName(index)
+                out("  ldy  $indexName")
+            }
+            // TODO optimize more cases, see translateArrayIndexIntoA
+            else -> {
+                expressionsAsmGen.translateExpression(index)
+                out("  inx |  ldy  $ESTACK_LO_HEX,x")
+            }
+        }
+    }
+
     internal fun translateExpression(expression: Expression) =
             expressionsAsmGen.translateExpression(expression)
 
@@ -894,9 +1051,12 @@ internal class AsmGen(private val program: Program,
     fun assignFromFloatVariable(target: AssignTarget, variable: IdentifierReference) =
             assignmentAsmGen.assignFromFloatVariable(target, variable)
 
-    fun assignFromRegister(target: AssignTarget, register: Register) =
+    fun assignFromRegister(target: AssignTarget, register: CpuRegister) =
             assignmentAsmGen.assignFromRegister(target, register)
 
     fun assignFromMemoryByte(target: AssignTarget, address: Int?, identifier: IdentifierReference?) =
             assignmentAsmGen.assignFromMemoryByte(target, address, identifier)
+
+    fun assignToRegister(reg: CpuRegister, value: Short?, identifier: IdentifierReference?) =
+            assignmentAsmGen.assignToRegister(reg, value, identifier)
 }

compiler/src/prog8/compiler/target/c64/codegen/AsmOptimizer.kt

@@ -13,43 +13,45 @@ fun optimizeAssembly(lines: MutableList<String>): Int {
 
     var linesByFour = getLinesBy(lines, 4)
 
-    var removeLines = optimizeUselessStackByteWrites(linesByFour)
-    if(removeLines.isNotEmpty()) {
-        for (i in removeLines.reversed())
-            lines.removeAt(i)
+    var mods = optimizeUselessStackByteWrites(linesByFour)
+    if(mods.isNotEmpty()) {
+        apply(mods, lines)
         linesByFour = getLinesBy(lines, 4)
         numberOfOptimizations++
     }
 
-    removeLines = optimizeIncDec(linesByFour)
-    if(removeLines.isNotEmpty()) {
-        for (i in removeLines.reversed())
-            lines.removeAt(i)
+    mods = optimizeIncDec(linesByFour)
+    if(mods.isNotEmpty()) {
+        apply(mods, lines)
         linesByFour = getLinesBy(lines, 4)
         numberOfOptimizations++
     }
 
-    removeLines = optimizeCmpSequence(linesByFour)
-    if(removeLines.isNotEmpty()) {
-        for (i in removeLines.reversed())
-            lines.removeAt(i)
+    mods = optimizeCmpSequence(linesByFour)
+    if(mods.isNotEmpty()) {
+        apply(mods, lines)
         linesByFour = getLinesBy(lines, 4)
         numberOfOptimizations++
     }
 
-    removeLines = optimizeStoreLoadSame(linesByFour)
-    if(removeLines.isNotEmpty()) {
-        for (i in removeLines.reversed())
-            lines.removeAt(i)
+    mods = optimizeStoreLoadSame(linesByFour)
+    if(mods.isNotEmpty()) {
+        apply(mods, lines)
+        linesByFour = getLinesBy(lines, 4)
+        numberOfOptimizations++
+    }
+
+    mods= optimizeJsrRts(linesByFour)
+    if(mods.isNotEmpty()) {
+        apply(mods, lines)
         linesByFour = getLinesBy(lines, 4)
         numberOfOptimizations++
     }
 
     var linesByFourteen = getLinesBy(lines, 14)
-    removeLines = optimizeSameAssignments(linesByFourteen)
-    if(removeLines.isNotEmpty()) {
-        for (i in removeLines.reversed())
-            lines.removeAt(i)
+    mods = optimizeSameAssignments(linesByFourteen)
+    if(mods.isNotEmpty()) {
+        apply(mods, lines)
         linesByFourteen = getLinesBy(lines, 14)
         numberOfOptimizations++
     }
@@ -59,7 +61,22 @@ fun optimizeAssembly(lines: MutableList<String>): Int {
     return numberOfOptimizations
 }
 
-fun optimizeCmpSequence(linesByFour: List<List<IndexedValue<String>>>): List<Int> {
+private class Modification(val lineIndex: Int, val remove: Boolean, val replacement: String?)
+
+private fun apply(modifications: List<Modification>, lines: MutableList<String>) {
+    for (modification in modifications.sortedBy { it.lineIndex }.reversed()) {
+        if(modification.remove)
+            lines.removeAt(modification.lineIndex)
+        else
+            lines[modification.lineIndex] = modification.replacement!!
+    }
+}
+
+private fun getLinesBy(lines: MutableList<String>, windowSize: Int) =
+// all lines (that aren't empty or comments) in sliding windows of certain size
+        lines.withIndex().filter { it.value.isNotBlank() && !it.value.trimStart().startsWith(';') }.windowed(windowSize, partialWindows = false)
+
+private fun optimizeCmpSequence(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
     // the when statement (on bytes) generates a sequence of:
     //	 lda $ce01,x
     //	 cmp #$20
@@ -68,42 +85,42 @@ fun optimizeCmpSequence(linesByFour: List<List<IndexedValue<String>>>): List<Int
     //	 cmp #$21
     //	 beq  check_prog8_s73choice_33
     // the repeated lda can be removed
-    val removeLines = mutableListOf<Int>()
+    val mods = mutableListOf<Modification>()
     for(lines in linesByFour) {
         if(lines[0].value.trim()=="lda  $ESTACK_LO_PLUS1_HEX,x" &&
                 lines[1].value.trim().startsWith("cmp ") &&
                 lines[2].value.trim().startsWith("beq ") &&
                 lines[3].value.trim()=="lda  $ESTACK_LO_PLUS1_HEX,x") {
-            removeLines.add(lines[3].index) // remove the second lda
+            mods.add(Modification(lines[3].index, true, null)) // remove the second lda
         }
     }
-    return removeLines
+    return mods
 }
 
-fun optimizeUselessStackByteWrites(linesByFour: List<List<IndexedValue<String>>>): List<Int> {
+private fun optimizeUselessStackByteWrites(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
     // sta on stack, dex, inx, lda from stack -> eliminate this useless stack byte write
     // this is a lot harder for word values because the instruction sequence varies.
-    val removeLines = mutableListOf<Int>()
+    val mods = mutableListOf<Modification>()
     for(lines in linesByFour) {
         if(lines[0].value.trim()=="sta  $ESTACK_LO_HEX,x" &&
                 lines[1].value.trim()=="dex" &&
                 lines[2].value.trim()=="inx" &&
                 lines[3].value.trim()=="lda  $ESTACK_LO_HEX,x") {
-            removeLines.add(lines[1].index)
-            removeLines.add(lines[2].index)
-            removeLines.add(lines[3].index)
+            mods.add(Modification(lines[1].index, true, null))
+            mods.add(Modification(lines[2].index, true, null))
+            mods.add(Modification(lines[3].index, true, null))
         }
     }
-    return removeLines
+    return mods
 }
 
-fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>): List<Int> {
+private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>): List<Modification> {
 
     // optimize sequential assignments of the isSameAs value to various targets (bytes, words, floats)
     // the float one is the one that requires 2*7=14 lines of code to check...
     // @todo a better place to do this is in the Compiler instead and transform the Ast, or the AsmGen, and never even create the inefficient asm in the first place...
 
-    val removeLines = mutableListOf<Int>()
+    val mods = mutableListOf<Modification>()
     for (pair in linesByFourteen) {
         val first = pair[0].value.trimStart()
         val second = pair[1].value.trimStart()
@@ -122,8 +139,8 @@ fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>):
             val fourthvalue = sixth.substring(4)
             if(firstvalue==thirdvalue && secondvalue==fourthvalue) {
                 // lda/ldy   sta/sty   twice the isSameAs word -->  remove second lda/ldy pair (fifth and sixth lines)
-                removeLines.add(pair[4].index)
-                removeLines.add(pair[5].index)
+                mods.add(Modification(pair[4].index, true, null))
+                mods.add(Modification(pair[5].index, true, null))
             }
         }
 
@@ -132,7 +149,7 @@ fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>):
             val secondvalue = third.substring(4)
             if(firstvalue==secondvalue) {
                 // lda value / sta ? / lda isSameAs-value / sta ?  -> remove second lda (third line)
-                removeLines.add(pair[2].index)
+                mods.add(Modification(pair[2].index, true, null))
             }
         }
 
@@ -151,24 +168,20 @@ fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>):
 
                 if(first.substring(4) == eighth.substring(4) && second.substring(4)==nineth.substring(4)) {
                     // identical float init
-                    removeLines.add(pair[7].index)
-                    removeLines.add(pair[8].index)
-                    removeLines.add(pair[9].index)
-                    removeLines.add(pair[10].index)
+                    mods.add(Modification(pair[7].index, true, null))
+                    mods.add(Modification(pair[8].index, true, null))
+                    mods.add(Modification(pair[9].index, true, null))
+                    mods.add(Modification(pair[10].index, true, null))
                 }
             }
         }
     }
-    return removeLines
+    return mods
 }
 
-private fun getLinesBy(lines: MutableList<String>, windowSize: Int) =
-// all lines (that aren't empty or comments) in sliding windows of certain size
-        lines.withIndex().filter { it.value.isNotBlank() && !it.value.trimStart().startsWith(';') }.windowed(windowSize, partialWindows = false)
-
-private fun optimizeStoreLoadSame(linesByFour: List<List<IndexedValue<String>>>): List<Int> {
+private fun optimizeStoreLoadSame(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
     // sta X + lda X,  sty X + ldy X,   stx X + ldx X  -> the second instruction can be eliminated
-    val removeLines = mutableListOf<Int>()
+    val mods = mutableListOf<Modification>()
     for (pair in linesByFour) {
         val first = pair[0].value.trimStart()
         val second = pair[1].value.trimStart()
@@ -186,26 +199,40 @@ private fun optimizeStoreLoadSame(linesByFour: List<List<IndexedValue<String>>>)
             val firstLoc = first.substring(4)
             val secondLoc = second.substring(4)
             if (firstLoc == secondLoc) {
-                removeLines.add(pair[1].index)
+                mods.add(Modification(pair[1].index, true, null))
             }
         }
     }
-    return removeLines
+    return mods
 }
 
-private fun optimizeIncDec(linesByTwo: List<List<IndexedValue<String>>>): List<Int> {
+private fun optimizeIncDec(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
     // sometimes, iny+dey / inx+dex / dey+iny / dex+inx sequences are generated, these can be eliminated.
-    val removeLines = mutableListOf<Int>()
-    for (pair in linesByTwo) {
+    val mods = mutableListOf<Modification>()
+    for (pair in linesByFour) {
         val first = pair[0].value
         val second = pair[1].value
         if ((" iny" in first || "\tiny" in first) && (" dey" in second || "\tdey" in second)
                 || (" inx" in first || "\tinx" in first) && (" dex" in second || "\tdex" in second)
                 || (" dey" in first || "\tdey" in first) && (" iny" in second || "\tiny" in second)
                 || (" dex" in first || "\tdex" in first) && (" inx" in second || "\tinx" in second)) {
-            removeLines.add(pair[0].index)
-            removeLines.add(pair[1].index)
+            mods.add(Modification(pair[0].index, true, null))
+            mods.add(Modification(pair[1].index, true, null))
         }
     }
-    return removeLines
+    return mods
+}
+
+private fun optimizeJsrRts(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
+    // jsr Sub + rts -> jmp Sub
+    val mods = mutableListOf<Modification>()
+    for (pair in linesByFour) {
+        val first = pair[0].value
+        val second = pair[1].value
+        if ((" jsr" in first || "\tjsr" in first ) && (" rts" in second || "\trts" in second)) {
+            mods += Modification(pair[0].index, false, pair[0].value.replace("jsr", "jmp"))
+            mods += Modification(pair[1].index, true, null)
+        }
+    }
+    return mods
 }

compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt

@@ -4,6 +4,7 @@ import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.compiler.AssemblyError
+import prog8.compiler.target.c64.C64MachineDefinition
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_PLUS1_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
@@ -24,11 +25,9 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
             is AddressOf -> translateExpression(expression)
             is DirectMemoryRead -> translateExpression(expression)
             is NumericLiteralValue -> translateExpression(expression)
-            is RegisterExpr -> translateExpression(expression)
             is IdentifierReference -> translateExpression(expression)
             is FunctionCall -> translateExpression(expression)
-            is ArrayLiteralValue, is StringLiteralValue -> TODO("string/array/struct assignment?")
-            is StructLiteralValue -> throw AssemblyError("struct literal value assignment should have been flattened")
+            is ArrayLiteralValue, is StringLiteralValue -> throw AssemblyError("no asm gen for string/array literal value assignment - should have been replaced by a variable")
             is RangeExpr -> throw AssemblyError("range expression should have been changed into array values")
         }
     }
@@ -39,8 +38,8 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
         if (builtinFunc != null) {
             asmgen.translateFunctioncallExpression(expression, builtinFunc)
         } else {
-            asmgen.translateFunctionCall(expression)
             val sub = expression.target.targetSubroutine(program.namespace)!!
+            asmgen.translateFunctionCall(expression)
             val returns = sub.returntypes.zip(sub.asmReturnvaluesRegisters)
             for ((_, reg) in returns) {
                 if (!reg.stack) {
@@ -50,7 +49,18 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                             RegisterOrPair.A -> asmgen.out("  sta  $ESTACK_LO_HEX,x |  dex")
                             RegisterOrPair.Y -> asmgen.out("  tya |  sta  $ESTACK_LO_HEX,x |  dex")
                             RegisterOrPair.AY -> asmgen.out("  sta  $ESTACK_LO_HEX,x |  tya |  sta  $ESTACK_HI_HEX,x |  dex")
-                            RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY -> throw AssemblyError("can't push X register - use a variable")
+                            RegisterOrPair.X -> {
+                                // return value in X register has been discarded, just push a zero
+                                asmgen.out("  lda  #0 |  sta  $ESTACK_LO_HEX,x |  dex")
+                            }
+                            RegisterOrPair.AX -> {
+                                // return value in X register has been discarded, just push a zero in this place
+                                asmgen.out("  sta  $ESTACK_LO_HEX,x |  lda  #0 |  sta  $ESTACK_HI_HEX,x |  dex")
+                            }
+                            RegisterOrPair.XY -> {
+                                // return value in X register has been discarded, just push a zero in this place
+                                asmgen.out("  lda  #0 |  sta  $ESTACK_LO_HEX,x |  tya |  sta  $ESTACK_HI_HEX,x |  dex")
+                            }
                         }
                     }
                     // return value from a statusregister is not put on the stack, it should be acted on via a conditional branch such as if_cc
@@ -109,7 +119,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                     else -> throw AssemblyError("weird type")
                 }
             }
-            in PassByReferenceDatatypes -> throw AssemblyError("cannot case a pass-by-reference datatypes into something else")
+            in PassByReferenceDatatypes -> throw AssemblyError("cannot cast pass-by-reference value into another type")
             else -> throw AssemblyError("weird type")
         }
     }
@@ -126,8 +136,16 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 asmgen.out("  lda  ${address.toHex()} |  sta  $ESTACK_LO_HEX,x |  dex")
             }
             is IdentifierReference -> {
+                // the identifier is a pointer variable, so read the value from the address in it
                 val sourceName = asmgen.asmIdentifierName(expr.addressExpression as IdentifierReference)
-                asmgen.out("  lda  $sourceName |  sta  $ESTACK_LO_HEX,x |  dex")
+                asmgen.out("""
+        lda  $sourceName
+        sta  (+) +1
+        lda  $sourceName+1
+        sta  (+) +2
++       lda  ${'$'}ffff     ; modified
+        sta  $ESTACK_LO_HEX,x
+        dex""")
             }
             else -> {
                 translateExpression(expr.addressExpression)
@@ -155,14 +173,6 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
         }
     }
 
-    private fun translateExpression(expr: RegisterExpr) {
-        when(expr.register) {
-            Register.A -> asmgen.out(" sta  $ESTACK_LO_HEX,x | dex")
-            Register.X -> asmgen.out(" txa |  sta  $ESTACK_LO_HEX,x | dex")
-            Register.Y -> asmgen.out(" tya |  sta  $ESTACK_LO_HEX,x | dex")
-        }
-    }
-
     private fun translateExpression(expr: IdentifierReference) {
         val varname = asmgen.asmIdentifierName(expr)
         when(expr.inferType(program).typeOrElse(DataType.STRUCT)) {
@@ -201,10 +211,46 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 translateExpression(expr.left)
                 val amount = expr.right.constValue(program)!!.number.toInt()
                 when (leftDt) {
-                    DataType.UBYTE -> repeat(amount) { asmgen.out("  lsr  $ESTACK_LO_PLUS1_HEX,x") }
-                    DataType.BYTE -> repeat(amount) { asmgen.out("  lda  $ESTACK_LO_PLUS1_HEX,x |  asl  a |  ror  $ESTACK_LO_PLUS1_HEX,x") }
-                    DataType.UWORD -> repeat(amount) { asmgen.out("  lsr  $ESTACK_HI_PLUS1_HEX,x |  ror  $ESTACK_LO_PLUS1_HEX,x") }
-                    DataType.WORD -> repeat(amount) { asmgen.out("  lda  $ESTACK_HI_PLUS1_HEX,x |  asl a  |  ror  $ESTACK_HI_PLUS1_HEX,x |  ror  $ESTACK_LO_PLUS1_HEX,x") }
+                    DataType.UBYTE -> {
+                        if(amount<=2)
+                            repeat(amount) { asmgen.out(" lsr  $ESTACK_LO_PLUS1_HEX,x") }
+                        else {
+                            asmgen.out(" lda  $ESTACK_LO_PLUS1_HEX,x")
+                            repeat(amount) { asmgen.out(" lsr  a") }
+                            asmgen.out(" sta  $ESTACK_LO_PLUS1_HEX,x")
+                        }
+                    }
+                    DataType.BYTE -> {
+                        if(amount<=2)
+                            repeat(amount) { asmgen.out(" lda  $ESTACK_LO_PLUS1_HEX,x |  asl  a |  ror  $ESTACK_LO_PLUS1_HEX,x") }
+                        else {
+                            asmgen.out(" lda  $ESTACK_LO_PLUS1_HEX,x |  sta  ${C64MachineDefinition.C64Zeropage.SCRATCH_B1}")
+                            repeat(amount) { asmgen.out(" asl  a |  ror  ${C64MachineDefinition.C64Zeropage.SCRATCH_B1} |  lda  ${C64MachineDefinition.C64Zeropage.SCRATCH_B1}") }
+                            asmgen.out(" sta  $ESTACK_LO_PLUS1_HEX,x")
+                        }
+                    }
+                    DataType.UWORD -> {
+                        var left = amount
+                        while(left>=7) {
+                            asmgen.out(" jsr  math.shift_right_uw_7")
+                            left -= 7
+                        }
+                        if (left in 0..2)
+                            repeat(left) { asmgen.out(" lsr  $ESTACK_HI_PLUS1_HEX,x |  ror  $ESTACK_LO_PLUS1_HEX,x") }
+                        else
+                            asmgen.out(" jsr  math.shift_right_uw_$left")
+                    }
+                    DataType.WORD -> {
+                        var left = amount
+                        while(left>=7) {
+                            asmgen.out(" jsr  math.shift_right_w_7")
+                            left -= 7
+                        }
+                        if (left in 0..2)
+                            repeat(left) { asmgen.out(" lda  $ESTACK_HI_PLUS1_HEX,x |  asl a  |  ror  $ESTACK_HI_PLUS1_HEX,x |  ror  $ESTACK_LO_PLUS1_HEX,x") }
+                        else
+                            asmgen.out(" jsr  math.shift_right_w_$left")
+                    }
                     else -> throw AssemblyError("weird type")
                 }
                 return
@@ -213,10 +259,26 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 // bit-shifts are always by a constant number (for now)
                 translateExpression(expr.left)
                 val amount = expr.right.constValue(program)!!.number.toInt()
-                if (leftDt in ByteDatatypes)
-                    repeat(amount) { asmgen.out("  asl  $ESTACK_LO_PLUS1_HEX,x") }
-                else
-                    repeat(amount) { asmgen.out("  asl  $ESTACK_LO_PLUS1_HEX,x |  rol  $ESTACK_HI_PLUS1_HEX,x") }
+                if (leftDt in ByteDatatypes) {
+                    if(amount<=2)
+                        repeat(amount) { asmgen.out("  asl  $ESTACK_LO_PLUS1_HEX,x") }
+                    else {
+                        asmgen.out("  lda  $ESTACK_LO_PLUS1_HEX,x")
+                        repeat(amount) { asmgen.out("  asl  a") }
+                        asmgen.out("  sta  $ESTACK_LO_PLUS1_HEX,x")
+                    }
+                }
+                else {
+                    var left=amount
+                    while(left>=7) {
+                        asmgen.out(" jsr  math.shift_left_w_7")
+                        left -= 7
+                    }
+                    if (left in 0..2)
+                        repeat(left) { asmgen.out("  asl  $ESTACK_LO_PLUS1_HEX,x |  rol  $ESTACK_HI_PLUS1_HEX,x") }
+                    else
+                        asmgen.out(" jsr  math.shift_left_w_$left")
+                }
                 return
             }
             "*" -> {
@@ -273,8 +335,10 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
         // the general, non-optimized cases
         translateExpression(expr.left)
         translateExpression(expr.right)
-        if(leftDt!=rightDt)
-            throw AssemblyError("binary operator ${expr.operator} left/right dt not identical")     // is this strictly required always?
+        if((leftDt in ByteDatatypes && rightDt !in ByteDatatypes)
+                || (leftDt in WordDatatypes && rightDt !in WordDatatypes))
+            throw AssemblyError("binary operator ${expr.operator} left/right dt not identical")
+
         when (leftDt) {
             in ByteDatatypes -> translateBinaryOperatorBytes(expr.operator, leftDt)
             in WordDatatypes -> translateBinaryOperatorWords(expr.operator, leftDt)

compiler/src/prog8/compiler/target/c64/codegen/ForLoopsAsmGen.kt

@@ -2,7 +2,6 @@ package prog8.compiler.target.c64.codegen
 
 import prog8.ast.Program
 import prog8.ast.base.DataType
-import prog8.ast.base.Register
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.RangeExpr
 import prog8.ast.statements.AssignTarget
@@ -16,7 +15,7 @@ import prog8.compiler.toHex
 import kotlin.math.absoluteValue
 
 // todo choose more efficient comparisons to avoid needless lda's
-// todo optimize common case step == 2 / -2
+// todo optimize common case when step == 2 or -2
 
 
 internal class ForLoopsAsmGen(private val program: Program, private val asmgen: AsmGen) {
@@ -37,7 +36,7 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen:
             is IdentifierReference -> {
                 translateForOverIterableVar(stmt, iterableDt.typeOrElse(DataType.STRUCT), stmt.iterable as IdentifierReference)
             }
-            else -> throw AssemblyError("can't iterate over ${stmt.iterable}")
+            else -> throw AssemblyError("can't iterate over ${stmt.iterable.javaClass} - should have been replaced by a variable")
         }
     }
 
@@ -55,31 +54,11 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen:
                     // bytes, step 1 or -1
 
                     val incdec = if(stepsize==1) "inc" else "dec"
-                    if (stmt.loopRegister != null) {
-                        // loop register over range
-                        if(stmt.loopRegister!= Register.A)
-                            throw AssemblyError("can only use A")
-                        asmgen.translateExpression(range.to)
-                        asmgen.translateExpression(range.from)
-                        asmgen.out("""
-                inx
-                lda  ${ESTACK_LO_HEX},x
-                sta  $loopLabel+1
-$loopLabel      lda  #0                 ; modified""")
-                        asmgen.translate(stmt.body)
-                        asmgen.out("""
-$continueLabel  lda  $loopLabel+1
-                cmp  $ESTACK_LO_PLUS1_HEX,x
-                beq  $endLabel
-                $incdec  $loopLabel+1
-                jmp  $loopLabel
-$endLabel       inx""")
-                    } else {
-                        // loop over byte range via loopvar
-                        val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
-                        asmgen.translateExpression(range.to)
-                        asmgen.translateExpression(range.from)
-                        asmgen.out("""
+                    // loop over byte range via loopvar
+                    val varname = asmgen.asmIdentifierName(stmt.loopVar)
+                    asmgen.translateExpression(range.to)
+                    asmgen.translateExpression(range.from)
+                    asmgen.out("""
                 inx
                 lda  ${ESTACK_LO_HEX},x
                 sta  $varname
@@ -92,76 +71,41 @@ $continueLabel  lda  $varname
                 $incdec  $varname
                 jmp  $loopLabel
 $endLabel       inx""")
-                    }
                 }
                 else {
 
                     // bytes, step >= 2 or <= -2
 
-                    if (stmt.loopRegister != null) {
-                        // loop register over range
-                        if(stmt.loopRegister!= Register.A)
-                            throw AssemblyError("can only use A")
-                        asmgen.translateExpression(range.to)
-                        asmgen.translateExpression(range.from)
-                        asmgen.out("""
-                inx
-                lda  ${ESTACK_LO_HEX},x
-                sta  $loopLabel+1
-$loopLabel      lda  #0                 ; modified""")
-                        asmgen.translate(stmt.body)
-                        asmgen.out("""
-$continueLabel  lda  $loopLabel+1""")
-                        if(stepsize>0) {
-                            asmgen.out("""
-                clc
-                adc  #$stepsize
-                sta  $loopLabel+1
-                cmp  $ESTACK_LO_PLUS1_HEX,x
-                bcc  $loopLabel
-                beq  $loopLabel""")
-                        } else {
-                            asmgen.out("""
-                sec
-                sbc  #${stepsize.absoluteValue}
-                sta  $loopLabel+1
-                cmp  $ESTACK_LO_PLUS1_HEX,x
-                bcs  $loopLabel""")
-                        }
-                        asmgen.out("""
-$endLabel       inx""")
-                    } else {
-                        // loop over byte range via loopvar
-                        val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
-                        asmgen.translateExpression(range.to)
-                        asmgen.translateExpression(range.from)
-                        asmgen.out("""
+                    // loop over byte range via loopvar
+                    val varname = asmgen.asmIdentifierName(stmt.loopVar)
+                    asmgen.translateExpression(range.to)
+                    asmgen.translateExpression(range.from)
+                    asmgen.out("""
                 inx
                 lda  ${ESTACK_LO_HEX},x
                 sta  $varname
 $loopLabel""")
-                        asmgen.translate(stmt.body)
-                        asmgen.out("""
+                    asmgen.translate(stmt.body)
+                    asmgen.out("""
 $continueLabel  lda  $varname""")
-                        if(stepsize>0) {
-                            asmgen.out("""
+                    if(stepsize>0) {
+                        asmgen.out("""
                 clc
                 adc  #$stepsize
                 sta  $varname
                 cmp  $ESTACK_LO_PLUS1_HEX,x
                 bcc  $loopLabel
                 beq  $loopLabel""")
-                        } else {
-                            asmgen.out("""
+                    } else {
+                        asmgen.out("""
                 sec
                 sbc  #${stepsize.absoluteValue}
                 sta  $varname
                 cmp  $ESTACK_LO_PLUS1_HEX,x
                 bcs  $loopLabel""")
-                        }
-                        asmgen.out("""
-$endLabel       inx""")
                     }
+                    asmgen.out("""
+$endLabel       inx""")
                 }
             }
             DataType.ARRAY_W, DataType.ARRAY_UW -> {
@@ -171,8 +115,8 @@ $endLabel       inx""")
 
                     stepsize == 1 || stepsize == -1 -> {
                         asmgen.translateExpression(range.to)
-                        val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
-                        val assignLoopvar = Assignment(AssignTarget(null, stmt.loopVar, null, null, stmt.loopVar!!.position),
+                        val varname = asmgen.asmIdentifierName(stmt.loopVar)
+                        val assignLoopvar = Assignment(AssignTarget(stmt.loopVar, null, null, stmt.loopVar.position),
                                 null, range.from, range.position)
                         assignLoopvar.linkParents(stmt)
                         asmgen.translate(assignLoopvar)
@@ -207,8 +151,8 @@ $endLabel       inx""")
                         // (u)words, step >= 2
 
                         asmgen.translateExpression(range.to)
-                        val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
-                        val assignLoopvar = Assignment(AssignTarget(null, stmt.loopVar, null, null, stmt.loopVar!!.position),
+                        val varname = asmgen.asmIdentifierName(stmt.loopVar)
+                        val assignLoopvar = Assignment(AssignTarget(stmt.loopVar, null, null, stmt.loopVar.position),
                                 null, range.from, range.position)
                         assignLoopvar.linkParents(stmt)
                         asmgen.translate(assignLoopvar)
@@ -256,8 +200,8 @@ $endLabel       inx""")
 
                         // (u)words, step <= -2
                         asmgen.translateExpression(range.to)
-                        val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
-                        val assignLoopvar = Assignment(AssignTarget(null, stmt.loopVar, null, null, stmt.loopVar!!.position),
+                        val varname = asmgen.asmIdentifierName(stmt.loopVar)
+                        val assignLoopvar = Assignment(AssignTarget(stmt.loopVar, null, null, stmt.loopVar.position),
                                 null, range.from, range.position)
                         assignLoopvar.linkParents(stmt)
                         asmgen.translate(assignLoopvar)
@@ -319,8 +263,6 @@ $endLabel       inx""")
         val decl = ident.targetVarDecl(program.namespace)!!
         when(iterableDt) {
             DataType.STR -> {
-                if(stmt.loopRegister!=null && stmt.loopRegister!= Register.A)
-                    throw AssemblyError("can only use A")
                 asmgen.out("""
                     lda  #<$iterableName
                     ldy  #>$iterableName
@@ -328,8 +270,7 @@ $endLabel       inx""")
                     sty  $loopLabel+2
 $loopLabel          lda  ${65535.toHex()}       ; modified
                     beq  $endLabel""")
-                if(stmt.loopVar!=null)
-                    asmgen.out("  sta  ${asmgen.asmIdentifierName(stmt.loopVar!!)}")
+                asmgen.out("  sta  ${asmgen.asmIdentifierName(stmt.loopVar)}")
                 asmgen.translate(stmt.body)
                 asmgen.out("""
 $continueLabel      inc  $loopLabel+1
@@ -339,10 +280,8 @@ $continueLabel      inc  $loopLabel+1
 $endLabel""")
             }
             DataType.ARRAY_UB, DataType.ARRAY_B -> {
-                // TODO: optimize loop code when the length of the array is < 256, don't need a separate counter in such cases
+                // TODO: optimize loop code when the length of the array is < 256, don't need a separate counter var in such cases
                 val length = decl.arraysize!!.size()!!
-                if(stmt.loopRegister!=null && stmt.loopRegister!= Register.A)
-                    throw AssemblyError("can only use A")
                 val counterLabel = asmgen.makeLabel("for_counter")
                 val modifiedLabel = asmgen.makeLabel("for_modified")
                 asmgen.out("""
@@ -353,8 +292,7 @@ $endLabel""")
                     ldy  #0
 $loopLabel          sty  $counterLabel
 $modifiedLabel      lda  ${65535.toHex()},y       ; modified""")
-                if(stmt.loopVar!=null)
-                    asmgen.out("  sta  ${asmgen.asmIdentifierName(stmt.loopVar!!)}")
+                asmgen.out("  sta  ${asmgen.asmIdentifierName(stmt.loopVar)}")
                 asmgen.translate(stmt.body)
                 asmgen.out("""
 $continueLabel      ldy  $counterLabel
@@ -366,14 +304,12 @@ $counterLabel       .byte  0
 $endLabel""")
             }
             DataType.ARRAY_W, DataType.ARRAY_UW -> {
-                // TODO: optimize loop code when the length of the array is < 256, don't need a separate counter in such cases
+                // TODO: optimize loop code when the length of the array is < 256, don't need a separate counter var in such cases
                 val length = decl.arraysize!!.size()!! * 2
-                if(stmt.loopRegister!=null)
-                    throw AssemblyError("can't use register to loop over words")
                 val counterLabel = asmgen.makeLabel("for_counter")
                 val modifiedLabel = asmgen.makeLabel("for_modified")
                 val modifiedLabel2 = asmgen.makeLabel("for_modified2")
-                val loopvarName = asmgen.asmIdentifierName(stmt.loopVar!!)
+                val loopvarName = asmgen.asmIdentifierName(stmt.loopVar)
                 asmgen.out("""
                     lda  #<$iterableName
                     ldy  #>$iterableName
@@ -410,7 +346,7 @@ $endLabel""")
     }
 
     private fun translateForOverConstRange(stmt: ForLoop, iterableDt: DataType, range: IntProgression) {
-        // TODO: optimize loop code when the range is < 256 iterations, don't need a separate counter in such cases
+        // TODO: optimize loop code when the range is < 256 iterations, don't need a separate counter var in such cases
         if (range.isEmpty())
             throw AssemblyError("empty range")
         val loopLabel = asmgen.makeLabel("for_loop")
@@ -421,93 +357,12 @@ $endLabel""")
         when(iterableDt) {
             DataType.ARRAY_B, DataType.ARRAY_UB -> {
                 val counterLabel = asmgen.makeLabel("for_counter")
-                if(stmt.loopRegister!=null) {
-
-                    // loop register over range
-
-                    if(stmt.loopRegister!= Register.A)
-                        throw AssemblyError("can only use A")
-                    when {
-                        range.step==1 -> {
-                            // step = 1
-                            asmgen.out("""
-                lda  #${range.first}
-                sta  $loopLabel+1
-                lda  #${range.last-range.first+1 and 255}
-                sta  $counterLabel
-$loopLabel      lda  #0                 ; modified""")
-                            asmgen.translate(stmt.body)
-                            asmgen.out("""
-$continueLabel  dec  $counterLabel
-                beq  $endLabel
-                inc  $loopLabel+1
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
-                        }
-                        range.step==-1 -> {
-                            // step = -1
-                            asmgen.out("""
-                lda  #${range.first}
-                sta  $loopLabel+1
-                lda  #${range.first-range.last+1 and 255}
-                sta  $counterLabel
-$loopLabel      lda  #0                 ; modified """)
-                            asmgen.translate(stmt.body)
-                            asmgen.out("""
-$continueLabel  dec  $counterLabel
-                beq  $endLabel
-                dec  $loopLabel+1
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
-                        }
-                        range.step >= 2 -> {
-                            // step >= 2
-                            asmgen.out("""
-                lda  #${(range.last-range.first) / range.step + 1}
-                sta  $counterLabel
-                lda  #${range.first}
-$loopLabel      pha""")
-                            asmgen.translate(stmt.body)
-                            asmgen.out("""
-$continueLabel  pla
-                dec  $counterLabel
-                beq  $endLabel
-                clc
-                adc  #${range.step}
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
-                        }
-                        else -> {
-                            // step <= -2
-                            asmgen.out("""
-                lda  #${(range.first-range.last) / range.step.absoluteValue + 1}
-                sta  $counterLabel
-                lda  #${range.first}
-$loopLabel      pha""")
-                            asmgen.translate(stmt.body)
-                            asmgen.out("""
-$continueLabel  pla
-                dec  $counterLabel
-                beq  $endLabel
-                sec
-                sbc  #${range.step.absoluteValue}
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
-                        }
-                    }
-
-                } else {
-
-                    // loop over byte range via loopvar
-                    val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
-                    when {
-                        range.step==1 -> {
-                            // step = 1
-                            asmgen.out("""
+                // loop over byte range via loopvar
+                val varname = asmgen.asmIdentifierName(stmt.loopVar)
+                when {
+                    range.step==1 -> {
+                        // step = 1
+                        asmgen.out("""
                 lda  #${range.first}
                 sta  $varname
                 lda  #${range.last-range.first+1 and 255}
@@ -521,34 +376,34 @@ $continueLabel  dec  $counterLabel
                 jmp  $loopLabel
 $counterLabel   .byte  0                
 $endLabel""")
-                        }
-                        range.step==-1 -> {
-                            // step = -1
-                            asmgen.out("""
+                    }
+                    range.step==-1 -> {
+                        // step = -1
+                        asmgen.out("""
                 lda  #${range.first}
                 sta  $varname
                 lda  #${range.first-range.last+1 and 255}
                 sta  $counterLabel
 $loopLabel""")
-                            asmgen.translate(stmt.body)
-                            asmgen.out("""
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
 $continueLabel  dec  $counterLabel
                 beq  $endLabel
                 dec  $varname
                 jmp  $loopLabel
 $counterLabel   .byte  0                
 $endLabel""")
-                        }
-                        range.step >= 2 -> {
-                            // step >= 2
-                            asmgen.out("""
+                    }
+                    range.step >= 2 -> {
+                        // step >= 2
+                        asmgen.out("""
                 lda  #${(range.last-range.first) / range.step + 1}
                 sta  $counterLabel
                 lda  #${range.first}
                 sta  $varname
 $loopLabel""")
-                            asmgen.translate(stmt.body)
-                            asmgen.out("""
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
 $continueLabel  dec  $counterLabel
                 beq  $endLabel
                 lda  $varname
@@ -558,17 +413,17 @@ $continueLabel  dec  $counterLabel
                 jmp  $loopLabel
 $counterLabel   .byte  0                
 $endLabel""")
-                        }
-                        else -> {
-                            // step <= -2
-                            asmgen.out("""
+                    }
+                    else -> {
+                        // step <= -2
+                        asmgen.out("""
                 lda  #${(range.first-range.last) / range.step.absoluteValue + 1}
                 sta  $counterLabel
                 lda  #${range.first}
                 sta  $varname
 $loopLabel""")
-                            asmgen.translate(stmt.body)
-                            asmgen.out("""
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
 $continueLabel  dec  $counterLabel
                 beq  $endLabel
                 lda  $varname
@@ -578,13 +433,12 @@ $continueLabel  dec  $counterLabel
                 jmp  $loopLabel
 $counterLabel   .byte  0                
 $endLabel""")
-                        }
                     }
                 }
             }
             DataType.ARRAY_W, DataType.ARRAY_UW -> {
                 // loop over word range via loopvar
-                val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
+                val varname = asmgen.asmIdentifierName(stmt.loopVar)
                 when {
                     range.step == 1 -> {
                         // word, step = 1

compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt

@@ -19,103 +19,170 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         // output the code to setup the parameters and perform the actual call
         // does NOT output the code to deal with the result values!
         val sub = stmt.target.targetSubroutine(program.namespace) ?: throw AssemblyError("undefined subroutine ${stmt.target}")
-        if(Register.X in sub.asmClobbers)
+        val saveX = CpuRegister.X in sub.asmClobbers || sub.regXasResult()
+        if(saveX)
             asmgen.out("  stx  c64.SCRATCH_ZPREGX")        // we only save X for now (required! is the eval stack pointer), screw A and Y...
 
         val subName = asmgen.asmIdentifierName(stmt.target)
         if(stmt.args.isNotEmpty()) {
-            for(arg in sub.parameters.withIndex().zip(stmt.args)) {
-                translateFuncArguments(arg.first, arg.second, sub)
+            if(sub.asmParameterRegisters.isEmpty()) {
+                // via variables
+                for(arg in sub.parameters.withIndex().zip(stmt.args)) {
+                    argumentViaVariable(sub, arg.first, arg.second)
+                }
+            } else {
+                // via registers
+                if(sub.parameters.size==1) {
+                    // just a single parameter, no risk of clobbering registers
+                    argumentViaRegister(sub, sub.parameters.withIndex().single(), stmt.args[0])
+                } else {
+                    // multiple register arguments, risk of register clobbering.
+                    // evaluate arguments onto the stack, and load the registers from the evaluated values on the stack.
+                    when {
+                        stmt.args.all {it is AddressOf ||
+                                it is NumericLiteralValue ||
+                                it is StringLiteralValue ||
+                                it is ArrayLiteralValue ||
+                                it is IdentifierReference} -> {
+                            // no risk of clobbering for these simple argument types. Optimize the register loading.
+                            for(arg in sub.parameters.withIndex().zip(stmt.args)) {
+                                argumentViaRegister(sub, arg.first, arg.second)
+                            }
+                        }
+                        else -> {
+                            // Risk of clobbering due to complex expression args. Work via the stack.
+                            argsViaStackEvaluation(stmt, sub)
+                        }
+                    }
+                }
             }
         }
         asmgen.out("  jsr  $subName")
 
-        if(Register.X in sub.asmClobbers)
+        if(saveX)
             asmgen.out("  ldx  c64.SCRATCH_ZPREGX")        // restore X again
     }
 
-    private fun translateFuncArguments(parameter: IndexedValue<SubroutineParameter>, value: Expression, sub: Subroutine) {
-        val sourceIDt = value.inferType(program)
-        if(!sourceIDt.isKnown)
-            throw AssemblyError("arg type unknown")
-        val sourceDt = sourceIDt.typeOrElse(DataType.STRUCT)
-        if(!argumentTypeCompatible(sourceDt, parameter.value.type))
-            throw AssemblyError("argument type incompatible")
-        if(sub.asmParameterRegisters.isEmpty()) {
-            // pass parameter via a variable
-            val paramVar = parameter.value
-            val scopedParamVar = (sub.scopedname+"."+paramVar.name).split(".")
-            val target = AssignTarget(null, IdentifierReference(scopedParamVar, sub.position), null, null, sub.position)
-            target.linkParents(value.parent)
-            when (value) {
-                is NumericLiteralValue -> {
-                    // optimize when the argument is a constant literal
-                    when(parameter.value.type) {
-                        in ByteDatatypes -> asmgen.assignFromByteConstant(target, value.number.toShort())
-                        in WordDatatypes -> asmgen.assignFromWordConstant(target, value.number.toInt())
-                        DataType.FLOAT -> asmgen.assignFromFloatConstant(target, value.number.toDouble())
-                        in PassByReferenceDatatypes -> throw AssemblyError("can't pass string/array as arguments?")
-                        else -> throw AssemblyError("weird parameter datatype")
-                    }
-                }
-                is IdentifierReference -> {
-                    // optimize when the argument is a variable
-                    when (parameter.value.type) {
-                        in ByteDatatypes -> asmgen.assignFromByteVariable(target, value)
-                        in WordDatatypes -> asmgen.assignFromWordVariable(target, value)
-                        DataType.FLOAT -> asmgen.assignFromFloatVariable(target, value)
-                        in PassByReferenceDatatypes -> throw AssemblyError("can't pass string/array as arguments?")
-                        else -> throw AssemblyError("weird parameter datatype")
-                    }
-                }
-                is RegisterExpr -> {
-                    asmgen.assignFromRegister(target, value.register)
-                }
-                is DirectMemoryRead -> {
-                    when(value.addressExpression) {
-                        is NumericLiteralValue -> {
-                            val address = (value.addressExpression as NumericLiteralValue).number.toInt()
-                            asmgen.assignFromMemoryByte(target, address, null)
-                        }
-                        is IdentifierReference -> {
-                            asmgen.assignFromMemoryByte(target, null, value.addressExpression as IdentifierReference)
-                        }
-                        else -> {
-                            asmgen.translateExpression(value.addressExpression)
-                            asmgen.out("  jsr  prog8_lib.read_byte_from_address |  inx")
-                            asmgen.assignFromRegister(target, Register.A)
-                        }
-                    }
-                }
-                else -> {
-                    asmgen.translateExpression(value)
-                    asmgen.assignFromEvalResult(target)
+    private fun argsViaStackEvaluation(stmt: IFunctionCall, sub: Subroutine) {
+        for (arg in stmt.args.reversed())
+            asmgen.translateExpression(arg)
+        for (regparam in sub.asmParameterRegisters) {
+            when (regparam.registerOrPair) {
+                RegisterOrPair.A -> asmgen.out(" inx |  lda  $ESTACK_LO_HEX,x")
+                RegisterOrPair.X -> throw AssemblyError("can't pop into X register - use a variable instead")
+                RegisterOrPair.Y -> asmgen.out(" inx |  ldy  $ESTACK_LO_HEX,x")
+                RegisterOrPair.AX -> throw AssemblyError("can't pop into X register - use a variable instead")
+                RegisterOrPair.AY -> asmgen.out(" inx |  lda  $ESTACK_LO_HEX,x |  ldy  $ESTACK_HI_HEX,x")
+                RegisterOrPair.XY -> throw AssemblyError("can't pop into X register - use a variable instead")
+                null -> {
                 }
             }
-        } else {
-            // pass parameter via a register parameter
-            val paramRegister = sub.asmParameterRegisters[parameter.index]
-            val statusflag = paramRegister.statusflag
-            val register = paramRegister.registerOrPair
-            val stack = paramRegister.stack
-            when {
-                stack -> {
-                    // push arg onto the stack
-                    // note: argument order is reversed (first argument will be deepest on the stack)
-                    asmgen.translateExpression(value)
+            when (regparam.statusflag) {
+                Statusflag.Pc -> asmgen.out("""
+                        inx
+                        pha
+                        lda  $ESTACK_LO_HEX,x
+                        beq  +
+                        sec  
+                        bcs  ++
+            +           clc
+            +           pla
+            """)
+                null -> {
                 }
-                statusflag!=null -> {
-                    if (statusflag == Statusflag.Pc) {
-                        // this param needs to be set last, right before the jsr
-                        // for now, this is already enforced on the subroutine definition by the Ast Checker
-                        when(value) {
-                            is NumericLiteralValue -> {
-                                val carrySet = value.number.toInt() != 0
-                                asmgen.out(if(carrySet) "  sec" else "  clc")
-                            }
-                            is IdentifierReference -> {
-                                val sourceName = asmgen.asmIdentifierName(value)
-                                asmgen.out("""
+                else -> throw AssemblyError("can only use Carry as status flag parameter")
+            }
+        }
+    }
+
+    private fun argumentViaVariable(sub: Subroutine, parameter: IndexedValue<SubroutineParameter>, value: Expression) {
+        // pass parameter via a regular variable (not via registers)
+        val valueIDt = value.inferType(program)
+        if(!valueIDt.isKnown)
+            throw AssemblyError("arg type unknown")
+        val valueDt = valueIDt.typeOrElse(DataType.STRUCT)
+        if(!argumentTypeCompatible(valueDt, parameter.value.type))
+            throw AssemblyError("argument type incompatible")
+
+        val paramVar = parameter.value
+        val scopedParamVar = (sub.scopedname+"."+paramVar.name).split(".")
+        val target = AssignTarget(IdentifierReference(scopedParamVar, sub.position), null, null, sub.position)
+        target.linkParents(value.parent)
+        when (value) {
+            is NumericLiteralValue -> {
+                // optimize when the argument is a constant literal
+                when(parameter.value.type) {
+                    in ByteDatatypes -> asmgen.assignFromByteConstant(target, value.number.toShort())
+                    in WordDatatypes -> asmgen.assignFromWordConstant(target, value.number.toInt())
+                    DataType.FLOAT -> asmgen.assignFromFloatConstant(target, value.number.toDouble())
+                    in PassByReferenceDatatypes -> throw AssemblyError("can't pass string/array as argument via a variable?")    // TODO huh
+                    else -> throw AssemblyError("weird parameter datatype")
+                }
+            }
+            is IdentifierReference -> {
+                // optimize when the argument is a variable
+                when (parameter.value.type) {
+                    in ByteDatatypes -> asmgen.assignFromByteVariable(target, value)
+                    in WordDatatypes -> asmgen.assignFromWordVariable(target, value)
+                    DataType.FLOAT -> asmgen.assignFromFloatVariable(target, value)
+                    in PassByReferenceDatatypes -> throw AssemblyError("can't pass string/array as argument via a variable?")     // TODO huh
+                    else -> throw AssemblyError("weird parameter datatype")
+                }
+            }
+            is DirectMemoryRead -> {
+                when(value.addressExpression) {
+                    is NumericLiteralValue -> {
+                        val address = (value.addressExpression as NumericLiteralValue).number.toInt()
+                        asmgen.assignFromMemoryByte(target, address, null)
+                    }
+                    is IdentifierReference -> {
+                        asmgen.assignFromMemoryByte(target, null, value.addressExpression as IdentifierReference)
+                    }
+                    else -> {
+                        asmgen.translateExpression(value.addressExpression)
+                        asmgen.out("  jsr  prog8_lib.read_byte_from_address |  inx")
+                        asmgen.assignFromRegister(target, CpuRegister.A)
+                    }
+                }
+            }
+            else -> {
+                asmgen.translateExpression(value)
+                asmgen.assignFromEvalResult(target)
+            }
+        }
+    }
+
+    private fun argumentViaRegister(sub: Subroutine, parameter: IndexedValue<SubroutineParameter>, value: Expression) {
+        // pass argument via a register parameter
+        val valueIDt = value.inferType(program)
+        if(!valueIDt.isKnown)
+            throw AssemblyError("arg type unknown")
+        val valueDt = valueIDt.typeOrElse(DataType.STRUCT)
+        if(!argumentTypeCompatible(valueDt, parameter.value.type))
+            throw AssemblyError("argument type incompatible")
+
+        val paramRegister = sub.asmParameterRegisters[parameter.index]
+        val statusflag = paramRegister.statusflag
+        val register = paramRegister.registerOrPair
+        val stack = paramRegister.stack
+        when {
+            stack -> {
+                // push arg onto the stack
+                // note: argument order is reversed (first argument will be deepest on the stack)
+                asmgen.translateExpression(value)
+            }
+            statusflag!=null -> {
+                if (statusflag == Statusflag.Pc) {
+                    // this param needs to be set last, right before the jsr
+                    // for now, this is already enforced on the subroutine definition by the Ast Checker
+                    when(value) {
+                        is NumericLiteralValue -> {
+                            val carrySet = value.number.toInt() != 0
+                            asmgen.out(if(carrySet) "  sec" else "  clc")
+                        }
+                        is IdentifierReference -> {
+                            val sourceName = asmgen.asmIdentifierName(value)
+                            asmgen.out("""
             lda  $sourceName
             beq  +
             sec  
@@ -123,85 +190,76 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
 +           clc
 +
 """)
-                            }
-                            is RegisterExpr -> {
-                                when(value.register) {
-                                    Register.A -> asmgen.out("  cmp  #0")
-                                    Register.X -> asmgen.out("  txa")
-                                    Register.Y -> asmgen.out("  tya")
-                                }
-                                asmgen.out("""
-            beq  +
-            sec
-            bcs  ++
-+           clc
-+
-""")
-                            }
-                            else -> {
-                                asmgen.translateExpression(value)
-                                asmgen.out("""
-            inx                        
+                        }
+                        else -> {
+                            asmgen.translateExpression(value)
+                            asmgen.out("""
+            inx
+            pha
             lda  $ESTACK_LO_HEX,x
             beq  +
             sec  
             bcs  ++
 +           clc
-+
++           pla
 """)
-                            }
-                        }
-                    }
-                    else throw AssemblyError("can only use Carry as status flag parameter")
-                }
-                register!=null && register.name.length==1 -> {
-                    when (value) {
-                        is NumericLiteralValue -> {
-                            val target = AssignTarget(Register.valueOf(register.name), null, null, null, sub.position)
-                            target.linkParents(value.parent)
-                            asmgen.assignFromByteConstant(target, value.number.toShort())
-                        }
-                        is IdentifierReference -> {
-                            val target = AssignTarget(Register.valueOf(register.name), null, null, null, sub.position)
-                            target.linkParents(value.parent)
-                            asmgen.assignFromByteVariable(target, value)
-                        }
-                        else -> {
-                            asmgen.translateExpression(value)
-                            when(register) {
-                                RegisterOrPair.A -> asmgen.out("  inx | lda  $ESTACK_LO_HEX,x")
-                                RegisterOrPair.X -> throw AssemblyError("can't pop into X register - use a variable instead")
-                                RegisterOrPair.Y -> asmgen.out("  inx | ldy  $ESTACK_LO_HEX,x")
-                                else -> throw AssemblyError("cannot assign to register pair")
-                            }
                         }
                     }
                 }
-                register!=null && register.name.length==2 -> {
-                    // register pair as a 16-bit value (only possible for subroutine parameters)
-                    when (value) {
-                        is NumericLiteralValue -> {
-                            // optimize when the argument is a constant literal
-                            val hex = value.number.toHex()
-                            when (register) {
-                                RegisterOrPair.AX -> asmgen.out("  lda  #<$hex  |  ldx  #>$hex")
-                                RegisterOrPair.AY -> asmgen.out("  lda  #<$hex  |  ldy  #>$hex")
-                                RegisterOrPair.XY -> asmgen.out("  ldx  #<$hex  |  ldy  #>$hex")
-                                else -> {}
-                            }
+                else throw AssemblyError("can only use Carry as status flag parameter")
+            }
+            register!=null && register.name.length==1 -> {
+                when (value) {
+                    is NumericLiteralValue -> {
+                        asmgen.assignToRegister(CpuRegister.valueOf(register.name), value.number.toShort(), null)
+                    }
+                    is IdentifierReference -> {
+                        asmgen.assignToRegister(CpuRegister.valueOf(register.name), null, value)
+                    }
+                    else -> {
+                        asmgen.translateExpression(value)
+                        when(register) {
+                            RegisterOrPair.A -> asmgen.out("  inx | lda  $ESTACK_LO_HEX,x")
+                            RegisterOrPair.X -> throw AssemblyError("can't pop into X register - use a variable instead")
+                            RegisterOrPair.Y -> asmgen.out("  inx | ldy  $ESTACK_LO_HEX,x")
+                            else -> throw AssemblyError("cannot assign to register pair")
                         }
-                        is AddressOf -> {
-                            // optimize when the argument is an address of something
-                            val sourceName = asmgen.asmIdentifierName(value.identifier)
+                    }
+                }
+            }
+            register!=null && register.name.length==2 -> {
+                // register pair as a 16-bit value (only possible for subroutine parameters)
+                when (value) {
+                    is NumericLiteralValue -> {
+                        // optimize when the argument is a constant literal
+                        val hex = value.number.toHex()
+                        when (register) {
+                            RegisterOrPair.AX -> asmgen.out("  lda  #<$hex  |  ldx  #>$hex")
+                            RegisterOrPair.AY -> asmgen.out("  lda  #<$hex  |  ldy  #>$hex")
+                            RegisterOrPair.XY -> asmgen.out("  ldx  #<$hex  |  ldy  #>$hex")
+                            else -> {}
+                        }
+                    }
+                    is AddressOf -> {
+                        // optimize when the argument is an address of something
+                        val sourceName = asmgen.asmIdentifierName(value.identifier)
+                        when (register) {
+                            RegisterOrPair.AX -> asmgen.out("  lda  #<$sourceName  |  ldx  #>$sourceName")
+                            RegisterOrPair.AY -> asmgen.out("  lda  #<$sourceName  |  ldy  #>$sourceName")
+                            RegisterOrPair.XY -> asmgen.out("  ldx  #<$sourceName  |  ldy  #>$sourceName")
+                            else -> {}
+                        }
+                    }
+                    is IdentifierReference -> {
+                        val sourceName = asmgen.asmIdentifierName(value)
+                        if(valueDt in PassByReferenceDatatypes) {
                             when (register) {
                                 RegisterOrPair.AX -> asmgen.out("  lda  #<$sourceName  |  ldx  #>$sourceName")
                                 RegisterOrPair.AY -> asmgen.out("  lda  #<$sourceName  |  ldy  #>$sourceName")
                                 RegisterOrPair.XY -> asmgen.out("  ldx  #<$sourceName  |  ldy  #>$sourceName")
                                 else -> {}
                             }
-                        }
-                        is IdentifierReference -> {
-                            val sourceName = asmgen.asmIdentifierName(value)
+                        } else {
                             when (register) {
                                 RegisterOrPair.AX -> asmgen.out("  lda  $sourceName  |  ldx  $sourceName+1")
                                 RegisterOrPair.AY -> asmgen.out("  lda  $sourceName  |  ldy  $sourceName+1")
@@ -209,13 +267,13 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                                 else -> {}
                             }
                         }
-                        else -> {
-                            asmgen.translateExpression(value)
-                            if (register == RegisterOrPair.AX || register == RegisterOrPair.XY)
-                                throw AssemblyError("can't use X register here - use a variable")
-                            else if (register == RegisterOrPair.AY)
-                                asmgen.out("  inx |  lda  $ESTACK_LO_HEX,x  |  ldy  $ESTACK_HI_HEX,x")
-                        }
+                    }
+                    else -> {
+                        asmgen.translateExpression(value)
+                        if (register == RegisterOrPair.AX || register == RegisterOrPair.XY)
+                            throw AssemblyError("can't use X register here - use a variable")
+                        else if (register == RegisterOrPair.AY)
+                            asmgen.out("  inx |  lda  $ESTACK_LO_HEX,x  |  ldy  $ESTACK_HI_HEX,x")
                     }
                 }
             }
@@ -225,6 +283,10 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
     private fun argumentTypeCompatible(argType: DataType, paramType: DataType): Boolean {
         if(argType isAssignableTo paramType)
             return true
+        if(argType in ByteDatatypes && paramType in ByteDatatypes)
+            return true
+        if(argType in WordDatatypes && paramType in WordDatatypes)
+            return true
 
         // we have a special rule for some types.
         // strings are assignable to UWORD, for example, and vice versa

compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt

@@ -4,7 +4,6 @@ import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteralValue
-import prog8.ast.expressions.RegisterExpr
 import prog8.ast.statements.PostIncrDecr
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.c64.C64MachineDefinition.C64Zeropage
@@ -17,28 +16,10 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
         val targetIdent = stmt.target.identifier
         val targetMemory = stmt.target.memoryAddress
         val targetArrayIdx = stmt.target.arrayindexed
-        val targetRegister = stmt.target.register
         when {
-            targetRegister!=null -> {
-                when(targetRegister) {
-                    Register.A -> {
-                        if(incr)
-                            asmgen.out("  clc |  adc  #1 ")
-                        else
-                            asmgen.out("  sec |  sbc  #1 ")
-                    }
-                    Register.X -> {
-                        if(incr) asmgen.out("  inx") else asmgen.out("  dex")
-                    }
-                    Register.Y -> {
-                        if(incr) asmgen.out("  iny") else asmgen.out("  dey")
-                    }
-                }
-            }
             targetIdent!=null -> {
                 val what = asmgen.asmIdentifierName(targetIdent)
-                val dt = stmt.target.inferType(program, stmt).typeOrElse(DataType.STRUCT)
-                when (dt) {
+                when (stmt.target.inferType(program, stmt).typeOrElse(DataType.STRUCT)) {
                     in ByteDatatypes -> asmgen.out(if (incr) "  inc  $what" else "  dec  $what")
                     in WordDatatypes -> {
                         if(incr)
@@ -66,7 +47,11 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                     }
                     is IdentifierReference -> {
                         val what = asmgen.asmIdentifierName(addressExpr)
-                        asmgen.out(if(incr) "  inc  $what" else "  dec  $what")
+                        asmgen.out("  lda  $what |  sta  (+) +1 |  lda  $what+1 |  sta  (+) +2")
+                        if(incr)
+                            asmgen.out("+\tinc  ${'$'}ffff\t; modified")
+                        else
+                            asmgen.out("+\tdec  ${'$'}ffff\t; modified")
                     }
                     else -> throw AssemblyError("weird target type $targetMemory")
                 }
@@ -99,18 +84,11 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                             else -> throw AssemblyError("need numeric type")
                         }
                     }
-                    is RegisterExpr -> {
-                        // TODO optimize common cases
-                        asmgen.translateArrayIndexIntoA(targetArrayIdx)
-                        incrDecrArrayvalueWithIndexA(incr, arrayDt, what)
-                    }
                     is IdentifierReference -> {
-                        // TODO optimize common cases
                         asmgen.translateArrayIndexIntoA(targetArrayIdx)
                         incrDecrArrayvalueWithIndexA(incr, arrayDt, what)
                     }
                     else -> {
-                        // TODO optimize common cases
                         asmgen.translateArrayIndexIntoA(targetArrayIdx)
                         incrDecrArrayvalueWithIndexA(incr, arrayDt, what)
                     }

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -87,7 +87,20 @@ val BuiltinFunctions = mapOf(
                             FParam("address", IterableDatatypes + DataType.UWORD),
                             FParam("numwords", setOf(DataType.UWORD)),
                             FParam("wordvalue", setOf(DataType.UWORD, DataType.WORD))), null),
-    "strlen"      to FSignature(true, listOf(FParam("string", setOf(DataType.STR))), DataType.UBYTE, ::builtinStrlen)
+    "strlen"      to FSignature(true, listOf(FParam("string", setOf(DataType.STR))), DataType.UBYTE, ::builtinStrlen),
+    "substr"      to FSignature(false, listOf(
+            FParam("source", IterableDatatypes + DataType.UWORD),
+            FParam("target", IterableDatatypes + DataType.UWORD),
+            FParam("start", setOf(DataType.UBYTE)),
+            FParam("length", setOf(DataType.UBYTE))), null),
+    "leftstr"      to FSignature(false, listOf(
+            FParam("source", IterableDatatypes + DataType.UWORD),
+            FParam("target", IterableDatatypes + DataType.UWORD),
+            FParam("length", setOf(DataType.UBYTE))), null),
+    "rightstr"      to FSignature(false, listOf(
+            FParam("source", IterableDatatypes + DataType.UWORD),
+            FParam("target", IterableDatatypes + DataType.UWORD),
+            FParam("length", setOf(DataType.UBYTE))), null)
 )
 
 fun builtinMax(array: List<Number>): Number = array.maxBy { it.toDouble() }!!
@@ -172,6 +185,7 @@ fun builtinFunctionReturnType(function: String, args: List<Expression>, program:
 
 
 class NotConstArgumentException: AstException("not a const argument to a built-in function")
+class CannotEvaluateException(func:String, msg: String): FatalAstException("cannot evaluate built-in function $func: $msg")
 
 
 private fun oneDoubleArg(args: List<Expression>, position: Position, program: Program, function: (arg: Double)->Number): NumericLiteralValue {
@@ -252,17 +266,22 @@ private fun builtinLen(args: List<Expression>, position: Position, program: Prog
         return NumericLiteralValue.optimalInteger((args[0] as ArrayLiteralValue).value.size, position)
     if(args[0] !is IdentifierReference)
         throw SyntaxError("len argument should be an identifier, but is ${args[0]}", position)
-    val target = (args[0] as IdentifierReference).targetVarDecl(program.namespace)!!
+    val target = (args[0] as IdentifierReference).targetVarDecl(program.namespace)
+            ?: throw CannotEvaluateException("len", "no target vardecl")
 
     return when(target.datatype) {
         DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
-            arraySize = target.arraysize!!.size()!!
+            arraySize = target.arraysize?.size()
+            if(arraySize==null)
+                throw CannotEvaluateException("len", "arraysize unknown")
             if(arraySize>256)
                 throw CompilerException("array length exceeds byte limit ${target.position}")
             NumericLiteralValue.optimalInteger(arraySize, args[0].position)
         }
         DataType.ARRAY_F -> {
-            arraySize = target.arraysize!!.size()!!
+            arraySize = target.arraysize?.size()
+            if(arraySize==null)
+                throw CannotEvaluateException("len", "arraysize unknown")
             if(arraySize>256)
                 throw CompilerException("array length exceeds byte limit ${target.position}")
             NumericLiteralValue.optimalInteger(arraySize, args[0].position)

compiler/src/prog8/optimizer/AssignmentTransformer.kt

@@ -0,0 +1,157 @@
+package prog8.optimizer
+
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.base.ErrorReporter
+import prog8.ast.expressions.BinaryExpression
+import prog8.ast.processing.AstWalker
+import prog8.ast.processing.IAstModification
+import prog8.ast.statements.Assignment
+import prog8.ast.statements.PostIncrDecr
+
+
+
+internal class AssignmentTransformer(val program: Program, val errors: ErrorReporter) : AstWalker() {
+
+    var optimizationsDone: Int = 0
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun before(assignment: Assignment, parent: Node): Iterable<IAstModification> {
+        // modify A = A + 5 back into augmented form A += 5 for easier code generation for optimized in-place assignments
+        // also to put code generation stuff together, single value assignment (A = 5) is converted to a special
+        // augmented form as wel (with the operator "setvalue")
+        if (assignment.aug_op == null) {
+            val binExpr = assignment.value as? BinaryExpression
+            if (binExpr != null) {
+                if (assignment.target.isSameAs(binExpr.left)) {
+                    assignment.value = binExpr.right
+                    assignment.aug_op = binExpr.operator + "="
+                    assignment.value.parent = assignment
+                    optimizationsDone++
+                    return noModifications
+                }
+            }
+            assignment.aug_op = "setvalue"
+            optimizationsDone++
+        } else if(assignment.aug_op == "+=") {
+            val binExpr = assignment.value as? BinaryExpression
+            if (binExpr != null) {
+                val leftnum = binExpr.left.constValue(program)?.number?.toDouble()
+                val rightnum = binExpr.right.constValue(program)?.number?.toDouble()
+                if(binExpr.operator == "+") {
+                    when {
+                        leftnum == 1.0 -> {
+                            optimizationsDone++
+                            return listOf(IAstModification.SwapOperands(binExpr))
+                        }
+                        leftnum == 2.0 -> {
+                            optimizationsDone++
+                            return listOf(IAstModification.SwapOperands(binExpr))
+                        }
+                        rightnum == 1.0 -> {
+                            // x += y + 1  -> x += y ,  x++
+                            return listOf(
+                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent)
+                            )
+                        }
+                        rightnum == 2.0 -> {
+                            // x += y + 2  -> x += y ,  x++,  x++
+                            return listOf(
+                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent)
+                            )
+                        }
+                    }
+                } else if(binExpr.operator == "-") {
+                    when {
+                        leftnum == 1.0 -> {
+                            optimizationsDone++
+                            return listOf(IAstModification.SwapOperands(binExpr))
+                        }
+                        leftnum == 2.0 -> {
+                            optimizationsDone++
+                            return listOf(IAstModification.SwapOperands(binExpr))
+                        }
+                        rightnum == 1.0 -> {
+                            // x += y - 1  -> x += y ,  x--
+                            return listOf(
+                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent)
+                            )
+                        }
+                        rightnum == 2.0 -> {
+                            // x += y - 2  -> x += y ,  x--,  x--
+                            return listOf(
+                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent)
+                            )
+                        }
+                    }
+                }
+            }
+        } else if(assignment.aug_op == "-=") {
+            val binExpr = assignment.value as? BinaryExpression
+            if (binExpr != null) {
+                val leftnum = binExpr.left.constValue(program)?.number?.toDouble()
+                val rightnum = binExpr.right.constValue(program)?.number?.toDouble()
+                if(binExpr.operator == "+") {
+                    when {
+                        leftnum == 1.0 -> {
+                            optimizationsDone++
+                            return listOf(IAstModification.SwapOperands(binExpr))
+                        }
+                        leftnum == 2.0 -> {
+                            optimizationsDone++
+                            return listOf(IAstModification.SwapOperands(binExpr))
+                        }
+                        rightnum == 1.0 -> {
+                            // x -= y + 1  -> x -= y ,  x--
+                            return listOf(
+                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent)
+                            )
+                        }
+                        rightnum == 2.0 -> {
+                            // x -= y + 2  -> x -= y ,  x--,  x--
+                            return listOf(
+                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent)
+                            )
+                        }
+                    }
+                } else if(binExpr.operator == "-") {
+                    when {
+                        leftnum == 1.0 -> {
+                            optimizationsDone++
+                            return listOf(IAstModification.SwapOperands(binExpr))
+                        }
+                        leftnum == 2.0 -> {
+                            optimizationsDone++
+                            return listOf(IAstModification.SwapOperands(binExpr))
+                        }
+                        rightnum == 1.0 -> {
+                            // x -= y - 1  -> x -= y ,  x++
+                            return listOf(
+                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent)
+                            )
+                        }
+                        rightnum == 2.0 -> {
+                            // x -= y - 2  -> x -= y ,  x++,  x++
+                            return listOf(
+                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent),
+                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent)
+                            )
+                        }
+                    }
+                }
+            }
+        }
+        return noModifications
+    }
+}

compiler/src/prog8/optimizer/CallGraph.kt

@@ -6,8 +6,6 @@ import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.base.DataType
 import prog8.ast.base.ParentSentinel
-import prog8.ast.base.VarDeclType
-import prog8.ast.base.initvarsSubName
 import prog8.ast.expressions.FunctionCall
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.processing.IAstVisitor
@@ -26,12 +24,12 @@ private val asmRefRx = Regex("""[\-+a-zA-Z0-9_ \t]+(...)[ \t]+(\S+).*""", RegexO
 
 class CallGraph(private val program: Program) : IAstVisitor {
 
-    val modulesImporting = mutableMapOf<Module, List<Module>>().withDefault { mutableListOf() }
-    val modulesImportedBy = mutableMapOf<Module, List<Module>>().withDefault { mutableListOf() }
-    val subroutinesCalling = mutableMapOf<INameScope, List<Subroutine>>().withDefault { mutableListOf() }
-    val subroutinesCalledBy = mutableMapOf<Subroutine, List<Node>>().withDefault { mutableListOf() }
+    val imports = mutableMapOf<Module, List<Module>>().withDefault { mutableListOf() }
+    val importedBy = mutableMapOf<Module, List<Module>>().withDefault { mutableListOf() }
+    val calls = mutableMapOf<INameScope, List<Subroutine>>().withDefault { mutableListOf() }
+    val calledBy = mutableMapOf<Subroutine, List<Node>>().withDefault { mutableListOf() }
 
-    // TODO  add dataflow graph: what statements use what variables
+    // TODO  add dataflow graph: what statements use what variables - can be used to eliminate unused vars
     val usedSymbols = mutableSetOf<Statement>()
 
     init {
@@ -57,17 +55,8 @@ class CallGraph(private val program: Program) : IAstVisitor {
             it.importedBy.clear()
             it.imports.clear()
 
-            it.importedBy.addAll(modulesImportedBy.getValue(it))
-            it.imports.addAll(modulesImporting.getValue(it))
-
-            forAllSubroutines(it) { sub ->
-                sub.calledBy.clear()
-                sub.calls.clear()
-
-                sub.calledBy.addAll(subroutinesCalledBy.getValue(sub))
-                sub.calls.addAll(subroutinesCalling.getValue(sub))
-            }
-
+            it.importedBy.addAll(importedBy.getValue(it))
+            it.imports.addAll(imports.getValue(it))
         }
 
         val rootmodule = program.modules.first()
@@ -87,8 +76,8 @@ class CallGraph(private val program: Program) : IAstVisitor {
         val thisModule = directive.definingModule()
         if (directive.directive == "%import") {
             val importedModule: Module = program.modules.single { it.name == directive.args[0].name }
-            modulesImporting[thisModule] = modulesImporting.getValue(thisModule).plus(importedModule)
-            modulesImportedBy[importedModule] = modulesImportedBy.getValue(importedModule).plus(thisModule)
+            imports[thisModule] = imports.getValue(thisModule).plus(importedModule)
+            importedBy[importedModule] = importedBy.getValue(importedModule).plus(thisModule)
         } else if (directive.directive == "%asminclude") {
             val asm = loadAsmIncludeFile(directive.args[0].str!!, thisModule.source)
             val scope = directive.definingScope()
@@ -120,7 +109,7 @@ class CallGraph(private val program: Program) : IAstVisitor {
 
     override fun visit(subroutine: Subroutine) {
         if (Pair(subroutine.definingScope().name, subroutine.name) in alwaysKeepSubroutines
-                || subroutine.name == initvarsSubName || subroutine.definingModule().isLibraryModule) {
+                || subroutine.definingModule().isLibraryModule) {
             // make sure the entrypoint is mentioned in the used symbols
             addNodeAndParentScopes(subroutine)
         }
@@ -128,8 +117,8 @@ class CallGraph(private val program: Program) : IAstVisitor {
     }
 
     override fun visit(decl: VarDecl) {
-        if (decl.autogeneratedDontRemove || (decl.definingModule().isLibraryModule && decl.type != VarDeclType.VAR)) {
-            // make sure autogenerated vardecls are in the used symbols
+        if (decl.autogeneratedDontRemove || decl.definingModule().isLibraryModule) {
+            // make sure autogenerated vardecls are in the used symbols and are never removed as 'unused'
             addNodeAndParentScopes(decl)
         }
 
@@ -143,8 +132,8 @@ class CallGraph(private val program: Program) : IAstVisitor {
         val otherSub = functionCall.target.targetSubroutine(program.namespace)
         if (otherSub != null) {
             functionCall.definingSubroutine()?.let { thisSub ->
-                subroutinesCalling[thisSub] = subroutinesCalling.getValue(thisSub).plus(otherSub)
-                subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(functionCall)
+                calls[thisSub] = calls.getValue(thisSub).plus(otherSub)
+                calledBy[otherSub] = calledBy.getValue(otherSub).plus(functionCall)
             }
         }
         super.visit(functionCall)
@@ -154,8 +143,8 @@ class CallGraph(private val program: Program) : IAstVisitor {
         val otherSub = functionCallStatement.target.targetSubroutine(program.namespace)
         if (otherSub != null) {
             functionCallStatement.definingSubroutine()?.let { thisSub ->
-                subroutinesCalling[thisSub] = subroutinesCalling.getValue(thisSub).plus(otherSub)
-                subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(functionCallStatement)
+                calls[thisSub] = calls.getValue(thisSub).plus(otherSub)
+                calledBy[otherSub] = calledBy.getValue(otherSub).plus(functionCallStatement)
             }
         }
         super.visit(functionCallStatement)
@@ -165,8 +154,8 @@ class CallGraph(private val program: Program) : IAstVisitor {
         val otherSub = jump.identifier?.targetSubroutine(program.namespace)
         if (otherSub != null) {
             jump.definingSubroutine()?.let { thisSub ->
-                subroutinesCalling[thisSub] = subroutinesCalling.getValue(thisSub).plus(otherSub)
-                subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(jump)
+                calls[thisSub] = calls.getValue(thisSub).plus(otherSub)
+                calledBy[otherSub] = calledBy.getValue(otherSub).plus(jump)
             }
         }
         super.visit(jump)
@@ -192,14 +181,14 @@ class CallGraph(private val program: Program) : IAstVisitor {
                 if (jumptarget != null && (jumptarget[0].isLetter() || jumptarget[0] == '_')) {
                     val node = program.namespace.lookup(jumptarget.split('.'), context)
                     if (node is Subroutine) {
-                        subroutinesCalling[scope] = subroutinesCalling.getValue(scope).plus(node)
-                        subroutinesCalledBy[node] = subroutinesCalledBy.getValue(node).plus(context)
+                        calls[scope] = calls.getValue(scope).plus(node)
+                        calledBy[node] = calledBy.getValue(node).plus(context)
                     } else if (jumptarget.contains('.')) {
                         // maybe only the first part already refers to a subroutine
                         val node2 = program.namespace.lookup(listOf(jumptarget.substringBefore('.')), context)
                         if (node2 is Subroutine) {
-                            subroutinesCalling[scope] = subroutinesCalling.getValue(scope).plus(node2)
-                            subroutinesCalledBy[node2] = subroutinesCalledBy.getValue(node2).plus(context)
+                            calls[scope] = calls.getValue(scope).plus(node2)
+                            calledBy[node2] = calledBy.getValue(node2).plus(context)
                         }
                     }
                 }
@@ -211,8 +200,8 @@ class CallGraph(private val program: Program) : IAstVisitor {
                         if (target.contains('.')) {
                             val node = program.namespace.lookup(listOf(target.substringBefore('.')), context)
                             if (node is Subroutine) {
-                                subroutinesCalling[scope] = subroutinesCalling.getValue(scope).plus(node)
-                                subroutinesCalledBy[node] = subroutinesCalledBy.getValue(node).plus(context)
+                                calls[scope] = calls.getValue(scope).plus(node)
+                                calledBy[node] = calledBy.getValue(node).plus(context)
                             }
                         }
                     }

compiler/src/prog8/optimizer/ConstantFolding.kt

@@ -1,704 +0,0 @@
-package prog8.optimizer
-
-import prog8.ast.IFunctionCall
-import prog8.ast.Program
-import prog8.ast.base.*
-import prog8.ast.expressions.*
-import prog8.ast.processing.IAstModifyingVisitor
-import prog8.ast.statements.*
-import prog8.compiler.target.CompilationTarget
-import prog8.functions.BuiltinFunctions
-import kotlin.math.floor
-
-
-class ConstantFolding(private val program: Program, private val errors: ErrorReporter) : IAstModifyingVisitor {
-    var optimizationsDone: Int = 0
-
-    override fun visit(decl: VarDecl): Statement {
-        // the initializer value can't refer to the variable itself (recursive definition)
-        // TODO: use call tree for this?
-        if(decl.value?.referencesIdentifiers(decl.name) == true || decl.arraysize?.index?.referencesIdentifiers(decl.name) == true) {
-            errors.err("recursive var declaration", decl.position)
-            return decl
-        }
-
-        if(decl.type==VarDeclType.CONST || decl.type==VarDeclType.VAR) {
-            if(decl.isArray){
-                if(decl.arraysize==null) {
-                    // for arrays that have no size specifier (or a non-constant one) attempt to deduce the size
-                    val arrayval = decl.value as? ArrayLiteralValue
-                    if(arrayval!=null) {
-                        decl.arraysize = ArrayIndex(NumericLiteralValue.optimalInteger(arrayval.value.size, decl.position), decl.position)
-                        optimizationsDone++
-                    }
-                }
-                else if(decl.arraysize?.size()==null) {
-                    val size = decl.arraysize!!.index.accept(this)
-                    if(size is NumericLiteralValue) {
-                        decl.arraysize = ArrayIndex(size, decl.position)
-                        optimizationsDone++
-                    }
-                }
-            }
-
-            when(decl.datatype) {
-                DataType.FLOAT -> {
-                    // vardecl: for scalar float vars, promote constant integer initialization values to floats
-                    val litval = decl.value as? NumericLiteralValue
-                    if (litval!=null && litval.type in IntegerDatatypes) {
-                        val newValue = NumericLiteralValue(DataType.FLOAT, litval.number.toDouble(), litval.position)
-                        decl.value = newValue
-                        optimizationsDone++
-                        return super.visit(decl)
-                    }
-                }
-                DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
-                    val numericLv = decl.value as? NumericLiteralValue
-                    val rangeExpr = decl.value as? RangeExpr
-                    if(rangeExpr!=null) {
-                        // convert the initializer range expression to an actual array
-                        val declArraySize = decl.arraysize?.size()
-                        if(declArraySize!=null && declArraySize!=rangeExpr.size())
-                            errors.err("range expression size doesn't match declared array size", decl.value?.position!!)
-                        val constRange = rangeExpr.toConstantIntegerRange()
-                        if(constRange!=null) {
-                            val eltType = rangeExpr.inferType(program).typeOrElse(DataType.UBYTE)
-                            if(eltType in ByteDatatypes) {
-                                decl.value = ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
-                                        constRange.map { NumericLiteralValue(eltType, it.toShort(), decl.value!!.position) }.toTypedArray(),
-                                        position = decl.value!!.position)
-                            } else {
-                                decl.value = ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
-                                        constRange.map { NumericLiteralValue(eltType, it, decl.value!!.position) }.toTypedArray(),
-                                        position = decl.value!!.position)
-                            }
-                            decl.value!!.linkParents(decl)
-                            optimizationsDone++
-                            return super.visit(decl)
-                        }
-                    }
-                    if(numericLv!=null && numericLv.type== DataType.FLOAT)
-                        errors.err("arraysize requires only integers here", numericLv.position)
-                    val size = decl.arraysize?.size() ?: return decl
-                    if (rangeExpr==null && numericLv!=null) {
-                        // arraysize initializer is empty or a single int, and we know the size; create the arraysize.
-                        val fillvalue = numericLv.number.toInt()
-                        when(decl.datatype){
-                            DataType.ARRAY_UB -> {
-                                if(fillvalue !in 0..255)
-                                    errors.err("ubyte value overflow", numericLv.position)
-                            }
-                            DataType.ARRAY_B -> {
-                                if(fillvalue !in -128..127)
-                                    errors.err("byte value overflow", numericLv.position)
-                            }
-                            DataType.ARRAY_UW -> {
-                                if(fillvalue !in 0..65535)
-                                    errors.err("uword value overflow", numericLv.position)
-                            }
-                            DataType.ARRAY_W -> {
-                                if(fillvalue !in -32768..32767)
-                                    errors.err("word value overflow", numericLv.position)
-                            }
-                            else -> {}
-                        }
-                        // create the array itself, filled with the fillvalue.
-                        val array = Array(size) {fillvalue}.map { NumericLiteralValue.optimalInteger(it, numericLv.position) as Expression}.toTypedArray()
-                        val refValue = ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype), array, position = numericLv.position)
-                        decl.value = refValue
-                        refValue.parent=decl
-                        optimizationsDone++
-                        return super.visit(decl)
-                    }
-                }
-                DataType.ARRAY_F  -> {
-                    val size = decl.arraysize?.size() ?: return decl
-                    val litval = decl.value as? NumericLiteralValue
-                    if(litval==null) {
-                        // there's no initialization value, but the size is known, so we're ok.
-                        return super.visit(decl)
-                    } else {
-                        // arraysize initializer is a single int, and we know the size.
-                        val fillvalue = litval.number.toDouble()
-                        if (fillvalue < CompilationTarget.machine.FLOAT_MAX_NEGATIVE || fillvalue > CompilationTarget.machine.FLOAT_MAX_POSITIVE)
-                            errors.err("float value overflow", litval.position)
-                        else {
-                            // create the array itself, filled with the fillvalue.
-                            val array = Array(size) {fillvalue}.map { NumericLiteralValue(DataType.FLOAT, it, litval.position) as Expression}.toTypedArray()
-                            val refValue = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_F), array, position = litval.position)
-                            decl.value = refValue
-                            refValue.parent=decl
-                            optimizationsDone++
-                            return super.visit(decl)
-                        }
-                    }
-                }
-                else -> {
-                    // nothing to do for this type
-                    // this includes strings and structs
-                }
-            }
-        }
-
-        return super.visit(decl)
-    }
-
-    /**
-     * replace identifiers that refer to const value, with the value itself (if it's a simple type)
-     */
-    override fun visit(identifier: IdentifierReference): Expression {
-        // don't replace when it's an assignment target or loop variable
-        if(identifier.parent is AssignTarget)
-            return identifier
-        var forloop = identifier.parent as? ForLoop
-        if(forloop==null)
-            forloop = identifier.parent.parent as? ForLoop
-        if(forloop!=null && identifier===forloop.loopVar)
-            return identifier
-
-        return try {
-            val cval = identifier.constValue(program) ?: return identifier
-            return when (cval.type) {
-                in NumericDatatypes -> {
-                    val copy = NumericLiteralValue(cval.type, cval.number, identifier.position)
-                    copy.parent = identifier.parent
-                    copy
-                }
-                in PassByReferenceDatatypes -> throw FatalAstException("pass-by-reference type should not be considered a constant")
-                else -> identifier
-            }
-        } catch (ax: AstException) {
-            errors.err("unhandled AST error: $ax", identifier.position)
-            identifier
-        }
-    }
-
-    override fun visit(functionCall: FunctionCall): Expression {
-        super.visit(functionCall)
-        typeCastConstArguments(functionCall)
-        return try {
-            functionCall.constValue(program) ?: functionCall
-        } catch (ax: AstException) {
-            errors.err("unhandled AST error: $ax", functionCall.position)
-            functionCall
-        }
-    }
-
-    override fun visit(functionCallStatement: FunctionCallStatement): Statement {
-        super.visit(functionCallStatement)
-        typeCastConstArguments(functionCallStatement)
-        return functionCallStatement
-    }
-
-    private fun typeCastConstArguments(functionCall: IFunctionCall) {
-        if(functionCall.target.nameInSource.size==1) {
-            val builtinFunction = BuiltinFunctions[functionCall.target.nameInSource.single()]
-            if(builtinFunction!=null) {
-                // match the arguments of a builtin function signature.
-                for(arg in functionCall.args.withIndex().zip(builtinFunction.parameters)) {
-                    val possibleDts = arg.second.possibleDatatypes
-                    val argConst = arg.first.value.constValue(program)
-                    if(argConst!=null && argConst.type !in possibleDts) {
-                        val convertedValue = argConst.cast(possibleDts.first())
-                        functionCall.args[arg.first.index] = convertedValue
-                        optimizationsDone++
-                    }
-                }
-                return
-            }
-        }
-        // match the arguments of a subroutine.
-        val subroutine = functionCall.target.targetSubroutine(program.namespace)
-        if(subroutine!=null) {
-            // if types differ, try to typecast constant arguments to the function call to the desired data type of the parameter
-            for(arg in functionCall.args.withIndex().zip(subroutine.parameters)) {
-                val expectedDt = arg.second.type
-                val argConst = arg.first.value.constValue(program)
-                if(argConst!=null && argConst.type!=expectedDt) {
-                    val convertedValue = argConst.cast(expectedDt)
-                    functionCall.args[arg.first.index] = convertedValue
-                    optimizationsDone++
-                }
-            }
-        }
-    }
-
-    override fun visit(memread: DirectMemoryRead): Expression {
-        // @( &thing )  -->  thing
-        val addrOf = memread.addressExpression as? AddressOf
-        if(addrOf!=null)
-            return super.visit(addrOf.identifier)
-        return super.visit(memread)
-    }
-
-    /**
-     * Try to accept a unary prefix expression.
-     * Compile-time constant sub expressions will be evaluated on the spot.
-     * For instance, the expression for "- 4.5" will be optimized into the float literal -4.5
-     */
-    override fun visit(expr: PrefixExpression): Expression {
-        return try {
-            val prefixExpr=super.visit(expr)
-            if(prefixExpr !is PrefixExpression)
-                return prefixExpr
-
-            val subexpr = prefixExpr.expression
-            if (subexpr is NumericLiteralValue) {
-                // accept prefixed literal values (such as -3, not true)
-                return when (prefixExpr.operator) {
-                    "+" -> subexpr
-                    "-" -> when (subexpr.type) {
-                        in IntegerDatatypes -> {
-                            optimizationsDone++
-                            NumericLiteralValue.optimalNumeric(-subexpr.number.toInt(), subexpr.position)
-                        }
-                        DataType.FLOAT -> {
-                            optimizationsDone++
-                            NumericLiteralValue(DataType.FLOAT, -subexpr.number.toDouble(), subexpr.position)
-                        }
-                        else -> throw ExpressionError("can only take negative of int or float", subexpr.position)
-                    }
-                    "~" -> when (subexpr.type) {
-                        in IntegerDatatypes -> {
-                            optimizationsDone++
-                            NumericLiteralValue.optimalNumeric(subexpr.number.toInt().inv(), subexpr.position)
-                        }
-                        else -> throw ExpressionError("can only take bitwise inversion of int", subexpr.position)
-                    }
-                    "not" -> {
-                        optimizationsDone++
-                        NumericLiteralValue.fromBoolean(subexpr.number.toDouble() == 0.0, subexpr.position)
-                    }
-                    else -> throw ExpressionError(prefixExpr.operator, subexpr.position)
-                }
-            }
-            return prefixExpr
-        } catch (ax: AstException) {
-            errors.err("unhandled AST error: $ax", expr.position)
-            expr
-        }
-    }
-
-    /**
-     * Try to accept a binary expression.
-     * Compile-time constant sub expressions will be evaluated on the spot.
-     * For instance, "9 * (4 + 2)" will be optimized into the integer literal 54.
-     *
-     * More complex stuff: reordering to group constants:
-     * If one of our operands is a Constant,
-     *   and the other operand is a Binary expression,
-     *   and one of ITS operands is a Constant,
-     *   and ITS other operand is NOT a Constant,
-     *   ...it may be possible to rewrite the expression to group the two Constants together,
-     *      to allow them to be const-folded away.
-     *
-     *  examples include:
-     *        (X / c1) * c2  ->  X / (c2/c1)
-     *        (X + c1) - c2  ->  X + (c1-c2)
-     */
-    override fun visit(expr: BinaryExpression): Expression {
-        return try {
-            super.visit(expr)
-
-            if(expr.left is StringLiteralValue || expr.left is ArrayLiteralValue
-                    || expr.right is StringLiteralValue || expr.right is ArrayLiteralValue)
-                throw FatalAstException("binexpr with reference litval instead of numeric")
-
-            val leftconst = expr.left.constValue(program)
-            val rightconst = expr.right.constValue(program)
-
-            val subExpr: BinaryExpression? = when {
-                leftconst!=null -> expr.right as? BinaryExpression
-                rightconst!=null -> expr.left as? BinaryExpression
-                else -> null
-            }
-            if(subExpr!=null) {
-                val subleftconst = subExpr.left.constValue(program)
-                val subrightconst = subExpr.right.constValue(program)
-                if ((subleftconst != null && subrightconst == null) || (subleftconst==null && subrightconst!=null)) {
-                    // try reordering.
-                    return groupTwoConstsTogether(expr, subExpr,
-                            leftconst != null, rightconst != null,
-                            subleftconst != null, subrightconst != null)
-                }
-            }
-
-            // const fold when both operands are a const
-            return when {
-                leftconst != null && rightconst != null -> {
-                    optimizationsDone++
-                    val evaluator = ConstExprEvaluator()
-                    evaluator.evaluate(leftconst, expr.operator, rightconst)
-                }
-
-                else -> expr
-            }
-        } catch (ax: AstException) {
-            errors.err("unhandled AST error: $ax", expr.position)
-            expr
-        }
-    }
-
-    private fun groupTwoConstsTogether(expr: BinaryExpression,
-                                       subExpr: BinaryExpression,
-                                       leftIsConst: Boolean,
-                                       rightIsConst: Boolean,
-                                       subleftIsConst: Boolean,
-                                       subrightIsConst: Boolean): Expression
-    {
-        // todo: this implements only a small set of possible reorderings at this time
-        if(expr.operator==subExpr.operator) {
-            // both operators are the isSameAs.
-            // If + or *,  we can simply swap the const of expr and Var in subexpr.
-            if(expr.operator=="+" || expr.operator=="*") {
-                if(leftIsConst) {
-                    if(subleftIsConst)
-                        expr.left = subExpr.right.also { subExpr.right = expr.left }
-                    else
-                        expr.left = subExpr.left.also { subExpr.left = expr.left }
-                } else {
-                    if(subleftIsConst)
-                        expr.right = subExpr.right.also {subExpr.right = expr.right }
-                    else
-                        expr.right = subExpr.left.also { subExpr.left = expr.right }
-                }
-                optimizationsDone++
-                return expr
-            }
-
-            // If - or /,  we simetimes must reorder more, and flip operators (- -> +, / -> *)
-            if(expr.operator=="-" || expr.operator=="/") {
-                optimizationsDone++
-                if(leftIsConst) {
-                    return if(subleftIsConst) {
-                        val tmp = subExpr.right
-                        subExpr.right = subExpr.left
-                        subExpr.left = expr.left
-                        expr.left = tmp
-                        expr.operator = if(expr.operator=="-") "+" else "*"
-                        expr
-                    } else
-                        BinaryExpression(
-                                BinaryExpression(expr.left, if (expr.operator == "-") "+" else "*", subExpr.right, subExpr.position),
-                                expr.operator, subExpr.left, expr.position)
-                } else {
-                    return if(subleftIsConst) {
-                        expr.right = subExpr.right.also { subExpr.right = expr.right }
-                        expr
-                    } else
-                        BinaryExpression(
-                                subExpr.left, expr.operator,
-                                BinaryExpression(expr.right, if (expr.operator == "-") "+" else "*", subExpr.right, subExpr.position),
-                                expr.position)
-                }
-            }
-            return expr
-
-        }
-        else
-        {
-
-            if(expr.operator=="/" && subExpr.operator=="*") {
-                optimizationsDone++
-                if(leftIsConst) {
-                    return if(subleftIsConst) {
-                        // C1/(C2*V) -> (C1/C2)/V
-                        BinaryExpression(
-                                BinaryExpression(expr.left, "/", subExpr.left, subExpr.position),
-                                "/",
-                                subExpr.right, expr.position)
-                    } else {
-                        // C1/(V*C2) -> (C1/C2)/V
-                        BinaryExpression(
-                                BinaryExpression(expr.left, "/", subExpr.right, subExpr.position),
-                                "/",
-                                subExpr.left, expr.position)
-                    }
-                } else {
-                    return if(subleftIsConst) {
-                        // (C1*V)/C2 -> (C1/C2)*V
-                        BinaryExpression(
-                                BinaryExpression(subExpr.left, "/", expr.right, subExpr.position),
-                                "*",
-                                subExpr.right, expr.position)
-                    } else {
-                        // (V*C1)/C2 -> (C1/C2)*V
-                        BinaryExpression(
-                                BinaryExpression(subExpr.right, "/", expr.right, subExpr.position),
-                                "*",
-                                subExpr.left, expr.position)
-                    }
-                }
-            }
-            else if(expr.operator=="*" && subExpr.operator=="/") {
-                optimizationsDone++
-                if(leftIsConst) {
-                    return if(subleftIsConst) {
-                        // C1*(C2/V) -> (C1*C2)/V
-                        BinaryExpression(
-                                BinaryExpression(expr.left, "*", subExpr.left, subExpr.position),
-                                "/",
-                                subExpr.right, expr.position)
-                    } else {
-                        // C1*(V/C2) -> (C1/C2)*V
-                        BinaryExpression(
-                                BinaryExpression(expr.left, "/", subExpr.right, subExpr.position),
-                                "*",
-                                subExpr.left, expr.position)
-                    }
-                } else {
-                    return if(subleftIsConst) {
-                        // (C1/V)*C2 -> (C1*C2)/V
-                        BinaryExpression(
-                                BinaryExpression(subExpr.left, "*", expr.right, subExpr.position),
-                                "/",
-                                subExpr.right, expr.position)
-                    } else {
-                        // (V/C1)*C2 -> (C1/C2)*V
-                        BinaryExpression(
-                                BinaryExpression(expr.right, "/", subExpr.right, subExpr.position),
-                                "*",
-                                subExpr.left, expr.position)
-                    }
-                }
-            }
-            else if(expr.operator=="+" && subExpr.operator=="-") {
-                optimizationsDone++
-                if(leftIsConst){
-                    return if(subleftIsConst){
-                        // c1+(c2-v)  ->  (c1+c2)-v
-                        BinaryExpression(
-                                BinaryExpression(expr.left, "+", subExpr.left, subExpr.position),
-                                "-",
-                                subExpr.right, expr.position)
-                    } else {
-                        // c1+(v-c2)  ->  v+(c1-c2)
-                        BinaryExpression(
-                                BinaryExpression(expr.left, "-", subExpr.right, subExpr.position),
-                                "+",
-                                subExpr.left, expr.position)
-                    }
-                } else {
-                    return if(subleftIsConst) {
-                        // (c1-v)+c2  ->  (c1+c2)-v
-                        BinaryExpression(
-                                BinaryExpression(subExpr.left, "+", expr.right, subExpr.position),
-                                "-",
-                                subExpr.right, expr.position)
-                    } else {
-                        // (v-c1)+c2  ->  v+(c2-c1)
-                        BinaryExpression(
-                                BinaryExpression(expr.right, "-", subExpr.right, subExpr.position),
-                                "+",
-                                subExpr.left, expr.position)
-                    }
-                }
-            }
-            else if(expr.operator=="-" && subExpr.operator=="+") {
-                optimizationsDone++
-                if(leftIsConst) {
-                    return if(subleftIsConst) {
-                        // c1-(c2+v)  ->  (c1-c2)-v
-                        BinaryExpression(
-                                BinaryExpression(expr.left, "-", subExpr.left, subExpr.position),
-                                "-",
-                                subExpr.right, expr.position)
-                    } else {
-                        // c1-(v+c2)  ->  (c1-c2)-v
-                        BinaryExpression(
-                                BinaryExpression(expr.left, "-", subExpr.right, subExpr.position),
-                                "-",
-                                subExpr.left, expr.position)
-                    }
-                } else {
-                    return if(subleftIsConst) {
-                        // (c1+v)-c2  ->  v+(c1-c2)
-                        BinaryExpression(
-                                BinaryExpression(subExpr.left, "-", expr.right, subExpr.position),
-                                "+",
-                                subExpr.right, expr.position)
-                    } else {
-                        // (v+c1)-c2  ->  v+(c1-c2)
-                        BinaryExpression(
-                                BinaryExpression(subExpr.right, "-", expr.right, subExpr.position),
-                                "+",
-                                subExpr.left, expr.position)
-                    }
-                }
-            }
-
-            return expr
-        }
-    }
-
-    override fun visit(forLoop: ForLoop): Statement {
-
-        fun adjustRangeDt(rangeFrom: NumericLiteralValue, targetDt: DataType, rangeTo: NumericLiteralValue, stepLiteral: NumericLiteralValue?, range: RangeExpr): RangeExpr {
-            val newFrom: NumericLiteralValue
-            val newTo: NumericLiteralValue
-            try {
-                newFrom = rangeFrom.cast(targetDt)
-                newTo = rangeTo.cast(targetDt)
-            } catch (x: ExpressionError) {
-                return range
-            }
-            val newStep: Expression = try {
-                stepLiteral?.cast(targetDt)?: range.step
-            } catch(ee: ExpressionError) {
-                range.step
-            }
-            return RangeExpr(newFrom, newTo, newStep, range.position)
-        }
-
-        val forLoop2 = super.visit(forLoop) as ForLoop
-
-        // check if we need to adjust an array literal to the loop variable's datatype
-        val array = forLoop2.iterable as? ArrayLiteralValue
-        if(array!=null) {
-            val loopvarDt: DataType = when {
-                forLoop.loopVar!=null -> forLoop.loopVar!!.inferType(program).typeOrElse(DataType.UBYTE)
-                forLoop.loopRegister!=null -> DataType.UBYTE
-                else -> throw FatalAstException("weird for loop")
-            }
-
-            val arrayType = when(loopvarDt) {
-                DataType.UBYTE -> DataType.ARRAY_UB
-                DataType.BYTE -> DataType.ARRAY_B
-                DataType.UWORD -> DataType.ARRAY_UW
-                DataType.WORD -> DataType.ARRAY_W
-                DataType.FLOAT -> DataType.ARRAY_F
-                else -> throw FatalAstException("invalid array elt type")
-            }
-            val array2 = array.cast(arrayType)
-            if(array2!=null && array2!==array) {
-                forLoop2.iterable = array2
-                array2.linkParents(forLoop2)
-            }
-        }
-
-        // adjust the datatype of a range expression in for loops to the loop variable.
-        val iterableRange = forLoop2.iterable as? RangeExpr ?: return forLoop2
-        val rangeFrom = iterableRange.from as? NumericLiteralValue
-        val rangeTo = iterableRange.to as? NumericLiteralValue
-        if(rangeFrom==null || rangeTo==null) return forLoop2
-
-        val loopvar = forLoop2.loopVar?.targetVarDecl(program.namespace)
-        if(loopvar!=null) {
-            val stepLiteral = iterableRange.step as? NumericLiteralValue
-            when(loopvar.datatype) {
-                DataType.UBYTE -> {
-                    if(rangeFrom.type!= DataType.UBYTE) {
-                        // attempt to translate the iterable into ubyte values
-                        forLoop2.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
-                    }
-                }
-                DataType.BYTE -> {
-                    if(rangeFrom.type!= DataType.BYTE) {
-                        // attempt to translate the iterable into byte values
-                        forLoop2.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
-                    }
-                }
-                DataType.UWORD -> {
-                    if(rangeFrom.type!= DataType.UWORD) {
-                        // attempt to translate the iterable into uword values
-                        forLoop2.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
-                    }
-                }
-                DataType.WORD -> {
-                    if(rangeFrom.type!= DataType.WORD) {
-                        // attempt to translate the iterable into word values
-                        forLoop2.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
-                    }
-                }
-                else -> throw FatalAstException("invalid loopvar datatype $loopvar")
-            }
-        }
-        return forLoop2
-    }
-
-    override fun visit(arrayLiteral: ArrayLiteralValue): Expression {
-        // because constant folding can result in arrays that are now suddenly capable
-        // of telling the type of all their elements (for instance, when they contained -2 which
-        // was a prefix expression earlier), we recalculate the array's datatype.
-        val array = super.visit(arrayLiteral)
-        if(array is ArrayLiteralValue) {
-            if(array.type.isKnown)
-                return array
-            val arrayDt = array.guessDatatype(program)
-            if(arrayDt.isKnown) {
-                val newArray = arrayLiteral.cast(arrayDt.typeOrElse(DataType.STRUCT))
-                if(newArray!=null)
-                    return newArray
-            }
-        }
-        return array
-    }
-
-    override fun visit(assignment: Assignment): Statement {
-        super.visit(assignment)
-        val lv = assignment.value as? NumericLiteralValue
-        if(lv!=null) {
-            // see if we can promote/convert a literal value to the required datatype
-            val idt = assignment.target.inferType(program, assignment)
-            if(!idt.isKnown)
-                return assignment
-            when(idt.typeOrElse(DataType.STRUCT)) {
-                DataType.UWORD -> {
-                    // we can convert to UWORD: any UBYTE, BYTE/WORD that are >=0, FLOAT that's an integer 0..65535,
-                    if(lv.type== DataType.UBYTE)
-                        assignment.value = NumericLiteralValue(DataType.UWORD, lv.number.toInt(), lv.position)
-                    else if(lv.type== DataType.BYTE && lv.number.toInt()>=0)
-                        assignment.value = NumericLiteralValue(DataType.UWORD, lv.number.toInt(), lv.position)
-                    else if(lv.type== DataType.WORD && lv.number.toInt()>=0)
-                        assignment.value = NumericLiteralValue(DataType.UWORD, lv.number.toInt(), lv.position)
-                    else if(lv.type== DataType.FLOAT) {
-                        val d = lv.number.toDouble()
-                        if(floor(d)==d && d>=0 && d<=65535)
-                            assignment.value = NumericLiteralValue(DataType.UWORD, floor(d).toInt(), lv.position)
-                    }
-                }
-                DataType.UBYTE -> {
-                    // we can convert to UBYTE: UWORD <=255, BYTE >=0, FLOAT that's an integer 0..255,
-                    if(lv.type== DataType.UWORD && lv.number.toInt() <= 255)
-                        assignment.value = NumericLiteralValue(DataType.UBYTE, lv.number.toShort(), lv.position)
-                    else if(lv.type== DataType.BYTE && lv.number.toInt() >=0)
-                        assignment.value = NumericLiteralValue(DataType.UBYTE, lv.number.toShort(), lv.position)
-                    else if(lv.type== DataType.FLOAT) {
-                        val d = lv.number.toDouble()
-                        if(floor(d)==d && d >=0 && d<=255)
-                            assignment.value = NumericLiteralValue(DataType.UBYTE, floor(d).toShort(), lv.position)
-                    }
-                }
-                DataType.BYTE -> {
-                    // we can convert to BYTE: UWORD/UBYTE <= 127, FLOAT that's an integer 0..127
-                    if(lv.type== DataType.UWORD && lv.number.toInt() <= 127)
-                        assignment.value = NumericLiteralValue(DataType.BYTE, lv.number.toShort(), lv.position)
-                    else if(lv.type== DataType.UBYTE && lv.number.toInt() <= 127)
-                        assignment.value = NumericLiteralValue(DataType.BYTE, lv.number.toShort(), lv.position)
-                    else if(lv.type== DataType.FLOAT) {
-                        val d = lv.number.toDouble()
-                        if(floor(d)==d && d>=0 && d<=127)
-                            assignment.value = NumericLiteralValue(DataType.BYTE, floor(d).toShort(), lv.position)
-                    }
-                }
-                DataType.WORD -> {
-                    // we can convert to WORD: any UBYTE/BYTE, UWORD <= 32767, FLOAT that's an integer -32768..32767,
-                    if(lv.type== DataType.UBYTE || lv.type== DataType.BYTE)
-                        assignment.value = NumericLiteralValue(DataType.WORD, lv.number.toInt(), lv.position)
-                    else if(lv.type== DataType.UWORD && lv.number.toInt() <= 32767)
-                        assignment.value = NumericLiteralValue(DataType.WORD, lv.number.toInt(), lv.position)
-                    else if(lv.type== DataType.FLOAT) {
-                        val d = lv.number.toDouble()
-                        if(floor(d)==d && d>=-32768 && d<=32767)
-                            assignment.value = NumericLiteralValue(DataType.BYTE, floor(d).toShort(), lv.position)
-                    }
-                }
-                DataType.FLOAT -> {
-                    assignment.value = NumericLiteralValue(DataType.FLOAT, lv.number.toDouble(), lv.position)
-                }
-                else -> {}
-            }
-        }
-        return assignment
-    }
-}

compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt

@@ -0,0 +1,592 @@
+package prog8.optimizer
+
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.AstWalker
+import prog8.ast.processing.IAstModification
+import prog8.ast.statements.*
+import prog8.compiler.target.CompilationTarget
+
+
+// First thing to do is replace all constant identifiers with their actual value,
+// and the array var initializer values and sizes.
+// This is needed because further constant optimizations depend on those.
+internal class ConstantIdentifierReplacer(private val program: Program, private val errors: ErrorReporter) : AstWalker() {
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun after(identifier: IdentifierReference, parent: Node): Iterable<IAstModification> {
+        // replace identifiers that refer to const value, with the value itself
+        // if it's a simple type and if it's not a left hand side variable
+        if(identifier.parent is AssignTarget)
+            return noModifications
+        var forloop = identifier.parent as? ForLoop
+        if(forloop==null)
+            forloop = identifier.parent.parent as? ForLoop
+        if(forloop!=null && identifier===forloop.loopVar)
+            return noModifications
+
+        val cval = identifier.constValue(program) ?: return noModifications
+        return when (cval.type) {
+            in NumericDatatypes -> listOf(IAstModification.ReplaceNode(identifier, NumericLiteralValue(cval.type, cval.number, identifier.position), identifier.parent))
+            in PassByReferenceDatatypes -> throw FatalAstException("pass-by-reference type should not be considered a constant")
+            else -> noModifications
+        }
+    }
+
+    override fun before(decl: VarDecl, parent: Node): Iterable<IAstModification> {
+        // the initializer value can't refer to the variable itself (recursive definition)
+        // TODO: use call graph for this?
+        if(decl.value?.referencesIdentifiers(decl.name) == true || decl.arraysize?.index?.referencesIdentifiers(decl.name) == true) {
+            errors.err("recursive var declaration", decl.position)
+            return noModifications
+        }
+
+        if(decl.type==VarDeclType.CONST || decl.type==VarDeclType.VAR) {
+            if(decl.isArray){
+                if(decl.arraysize==null) {
+                    // for arrays that have no size specifier (or a non-constant one) attempt to deduce the size
+                    val arrayval = decl.value as? ArrayLiteralValue
+                    if(arrayval!=null) {
+                        return listOf(IAstModification.SetExpression(
+                                { decl.arraysize = ArrayIndex(it, decl.position) },
+                                NumericLiteralValue.optimalInteger(arrayval.value.size, decl.position),
+                                decl
+                        ))
+                    }
+                }
+                else if(decl.arraysize?.size()==null) {
+                    val size = decl.arraysize!!.index.constValue(program)
+                    if(size!=null) {
+                        return listOf(IAstModification.SetExpression(
+                                { decl.arraysize = ArrayIndex(it, decl.position) },
+                                size, decl
+                        ))
+                    }
+                }
+            }
+
+            when(decl.datatype) {
+                DataType.FLOAT -> {
+                    // vardecl: for scalar float vars, promote constant integer initialization values to floats
+                    val litval = decl.value as? NumericLiteralValue
+                    if (litval!=null && litval.type in IntegerDatatypes) {
+                        val newValue = NumericLiteralValue(DataType.FLOAT, litval.number.toDouble(), litval.position)
+                        return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
+                    }
+                }
+                DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                    val numericLv = decl.value as? NumericLiteralValue
+                    val rangeExpr = decl.value as? RangeExpr
+                    if(rangeExpr!=null) {
+                        // convert the initializer range expression to an actual array
+                        val declArraySize = decl.arraysize?.size()
+                        if(declArraySize!=null && declArraySize!=rangeExpr.size())
+                            errors.err("range expression size doesn't match declared array size", decl.value?.position!!)
+                        val constRange = rangeExpr.toConstantIntegerRange()
+                        if(constRange!=null) {
+                            val eltType = rangeExpr.inferType(program).typeOrElse(DataType.UBYTE)
+                            val newValue = if(eltType in ByteDatatypes) {
+                                ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
+                                        constRange.map { NumericLiteralValue(eltType, it.toShort(), decl.value!!.position) }.toTypedArray(),
+                                        position = decl.value!!.position)
+                            } else {
+                                ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
+                                        constRange.map { NumericLiteralValue(eltType, it, decl.value!!.position) }.toTypedArray(),
+                                        position = decl.value!!.position)
+                            }
+                            return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
+                        }
+                    }
+                    if(numericLv!=null && numericLv.type==DataType.FLOAT)
+                        errors.err("arraysize requires only integers here", numericLv.position)
+                    val size = decl.arraysize?.size() ?: return noModifications
+                    if (rangeExpr==null && numericLv!=null) {
+                        // arraysize initializer is empty or a single int, and we know the size; create the arraysize.
+                        val fillvalue = numericLv.number.toInt()
+                        when(decl.datatype){
+                            DataType.ARRAY_UB -> {
+                                if(fillvalue !in 0..255)
+                                    errors.err("ubyte value overflow", numericLv.position)
+                            }
+                            DataType.ARRAY_B -> {
+                                if(fillvalue !in -128..127)
+                                    errors.err("byte value overflow", numericLv.position)
+                            }
+                            DataType.ARRAY_UW -> {
+                                if(fillvalue !in 0..65535)
+                                    errors.err("uword value overflow", numericLv.position)
+                            }
+                            DataType.ARRAY_W -> {
+                                if(fillvalue !in -32768..32767)
+                                    errors.err("word value overflow", numericLv.position)
+                            }
+                            else -> {}
+                        }
+                        // create the array itself, filled with the fillvalue.
+                        val array = Array(size) {fillvalue}.map { NumericLiteralValue(ArrayElementTypes.getValue(decl.datatype), it, numericLv.position) as Expression}.toTypedArray()
+                        val refValue = ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype), array, position = numericLv.position)
+                        return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
+                    }
+                }
+                DataType.ARRAY_F  -> {
+                    val size = decl.arraysize?.size() ?: return noModifications
+                    val litval = decl.value as? NumericLiteralValue
+                    val rangeExpr = decl.value as? RangeExpr
+                    if(rangeExpr!=null) {
+                        // convert the initializer range expression to an actual array of floats
+                        val declArraySize = decl.arraysize?.size()
+                        if(declArraySize!=null && declArraySize!=rangeExpr.size())
+                            errors.err("range expression size doesn't match declared array size", decl.value?.position!!)
+                        val constRange = rangeExpr.toConstantIntegerRange()
+                        if(constRange!=null) {
+                            val newValue = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_F),
+                                        constRange.map { NumericLiteralValue(DataType.FLOAT, it.toDouble(), decl.value!!.position) }.toTypedArray(),
+                                        position = decl.value!!.position)
+                            return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
+                        }
+                    }
+                    if(rangeExpr==null && litval!=null) {
+                        // arraysize initializer is a single int, and we know the size.
+                        val fillvalue = litval.number.toDouble()
+                        if (fillvalue < CompilationTarget.machine.FLOAT_MAX_NEGATIVE || fillvalue > CompilationTarget.machine.FLOAT_MAX_POSITIVE)
+                            errors.err("float value overflow", litval.position)
+                        else {
+                            // create the array itself, filled with the fillvalue.
+                            val array = Array(size) {fillvalue}.map { NumericLiteralValue(DataType.FLOAT, it, litval.position) as Expression}.toTypedArray()
+                            val refValue = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_F), array, position = litval.position)
+                            return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
+                        }
+                    }
+                }
+                else -> {
+                    // nothing to do for this type
+                    // this includes strings and structs
+                }
+            }
+        }
+
+        val declValue = decl.value
+        if(declValue!=null && decl.type==VarDeclType.VAR
+                && declValue is NumericLiteralValue && !declValue.inferType(program).istype(decl.datatype)) {
+            // cast the numeric literal to the appropriate datatype of the variable
+            return listOf(IAstModification.ReplaceNode(decl.value!!, declValue.cast(decl.datatype), decl))
+        }
+
+        return noModifications
+    }
+}
+
+
+internal class ConstantFoldingOptimizer(private val program: Program, private val errors: ErrorReporter) : AstWalker() {
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun before(memread: DirectMemoryRead, parent: Node): Iterable<IAstModification> {
+        // @( &thing )  -->  thing
+        val addrOf = memread.addressExpression as? AddressOf
+        return if(addrOf!=null)
+            listOf(IAstModification.ReplaceNode(memread, addrOf.identifier, parent))
+        else
+            noModifications
+    }
+
+    override fun after(expr: PrefixExpression, parent: Node): Iterable<IAstModification> {
+        // Try to turn a unary prefix expression into a single constant value.
+        // Compile-time constant sub expressions will be evaluated on the spot.
+        // For instance, the expression for "- 4.5" will be optimized into the float literal -4.5
+        val subexpr = expr.expression
+        if (subexpr is NumericLiteralValue) {
+            // accept prefixed literal values (such as -3, not true)
+            return when (expr.operator) {
+                "+" -> listOf(IAstModification.ReplaceNode(expr, subexpr, parent))
+                "-" -> when (subexpr.type) {
+                    in IntegerDatatypes -> {
+                        listOf(IAstModification.ReplaceNode(expr,
+                                NumericLiteralValue.optimalNumeric(-subexpr.number.toInt(), subexpr.position),
+                                parent))
+                    }
+                    DataType.FLOAT -> {
+                        listOf(IAstModification.ReplaceNode(expr,
+                                NumericLiteralValue(DataType.FLOAT, -subexpr.number.toDouble(), subexpr.position),
+                                parent))
+                    }
+                    else -> throw ExpressionError("can only take negative of int or float", subexpr.position)
+                }
+                "~" -> when (subexpr.type) {
+                    in IntegerDatatypes -> {
+                        listOf(IAstModification.ReplaceNode(expr,
+                                NumericLiteralValue.optimalNumeric(subexpr.number.toInt().inv(), subexpr.position),
+                                parent))
+                    }
+                    else -> throw ExpressionError("can only take bitwise inversion of int", subexpr.position)
+                }
+                "not" -> {
+                    listOf(IAstModification.ReplaceNode(expr,
+                            NumericLiteralValue.fromBoolean(subexpr.number.toDouble() == 0.0, subexpr.position),
+                            parent))
+                }
+                else -> throw ExpressionError(expr.operator, subexpr.position)
+            }
+        }
+        return noModifications
+    }
+
+    /**
+     * Try to constfold a binary expression.
+     * Compile-time constant sub expressions will be evaluated on the spot.
+     * For instance, "9 * (4 + 2)" will be optimized into the integer literal 54.
+     *
+     * More complex stuff: reordering to group constants:
+     * If one of our operands is a Constant,
+     *   and the other operand is a Binary expression,
+     *   and one of ITS operands is a Constant,
+     *   and ITS other operand is NOT a Constant,
+     *   ...it may be possible to rewrite the expression to group the two Constants together,
+     *      to allow them to be const-folded away.
+     *
+     *  examples include:
+     *        (X / c1) * c2  ->  X / (c2/c1)
+     *        (X + c1) - c2  ->  X + (c1-c2)
+     */
+    override fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
+        val leftconst = expr.left.constValue(program)
+        val rightconst = expr.right.constValue(program)
+
+        val subExpr: BinaryExpression? = when {
+            leftconst!=null -> expr.right as? BinaryExpression
+            rightconst!=null -> expr.left as? BinaryExpression
+            else -> null
+        }
+        if(subExpr!=null) {
+            val subleftconst = subExpr.left.constValue(program)
+            val subrightconst = subExpr.right.constValue(program)
+            if ((subleftconst != null && subrightconst == null) || (subleftconst==null && subrightconst!=null)) {
+                // try reordering.
+                val change = groupTwoConstsTogether(expr, subExpr,
+                        leftconst != null, rightconst != null,
+                        subleftconst != null, subrightconst != null)
+                return change?.let { listOf(it) } ?: noModifications
+            }
+        }
+
+        // const fold when both operands are a const
+        if(leftconst != null && rightconst != null) {
+            val evaluator = ConstExprEvaluator()
+            return listOf(IAstModification.ReplaceNode(
+                    expr,
+                    evaluator.evaluate(leftconst, expr.operator, rightconst),
+                    parent
+            ))
+        }
+
+        return noModifications
+    }
+
+    override fun after(array: ArrayLiteralValue, parent: Node): Iterable<IAstModification> {
+        // because constant folding can result in arrays that are now suddenly capable
+        // of telling the type of all their elements (for instance, when they contained -2 which
+        // was a prefix expression earlier), we recalculate the array's datatype.
+        if(array.type.isKnown)
+            return noModifications
+
+        // if the array literalvalue is inside an array vardecl, take the type from that
+        // otherwise infer it from the elements of the array
+        val vardeclType = (array.parent as? VarDecl)?.datatype
+        if(vardeclType!=null) {
+            val newArray = array.cast(vardeclType)
+            if (newArray != null && newArray != array)
+                return listOf(IAstModification.ReplaceNode(array, newArray, parent))
+        } else {
+            val arrayDt = array.guessDatatype(program)
+            if (arrayDt.isKnown) {
+                val newArray = array.cast(arrayDt.typeOrElse(DataType.STRUCT))
+                if (newArray != null && newArray != array)
+                    return listOf(IAstModification.ReplaceNode(array, newArray, parent))
+            }
+        }
+
+        return noModifications
+    }
+
+    override fun after(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> {
+        // the args of a fuction are constfolded via recursion already.
+        val constvalue = functionCall.constValue(program)
+        return if(constvalue!=null)
+            listOf(IAstModification.ReplaceNode(functionCall, constvalue, parent))
+        else
+            noModifications
+    }
+
+    override fun after(forLoop: ForLoop, parent: Node): Iterable<IAstModification> {
+        fun adjustRangeDt(rangeFrom: NumericLiteralValue, targetDt: DataType, rangeTo: NumericLiteralValue, stepLiteral: NumericLiteralValue?, range: RangeExpr): RangeExpr {
+            val newFrom: NumericLiteralValue
+            val newTo: NumericLiteralValue
+            try {
+                newFrom = rangeFrom.cast(targetDt)
+                newTo = rangeTo.cast(targetDt)
+            } catch (x: ExpressionError) {
+                return range
+            }
+            val newStep: Expression = try {
+                stepLiteral?.cast(targetDt)?: range.step
+            } catch(ee: ExpressionError) {
+                range.step
+            }
+            return RangeExpr(newFrom, newTo, newStep, range.position)
+        }
+
+        // adjust the datatype of a range expression in for loops to the loop variable.
+        val iterableRange = forLoop.iterable as? RangeExpr ?: return noModifications
+        val rangeFrom = iterableRange.from as? NumericLiteralValue
+        val rangeTo = iterableRange.to as? NumericLiteralValue
+        if(rangeFrom==null || rangeTo==null) return noModifications
+
+        val loopvar = forLoop.loopVar.targetVarDecl(program.namespace)!!
+        val stepLiteral = iterableRange.step as? NumericLiteralValue
+        when(loopvar.datatype) {
+            DataType.UBYTE -> {
+                if(rangeFrom.type!= DataType.UBYTE) {
+                    // attempt to translate the iterable into ubyte values
+                    val newIter = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
+                    return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
+                }
+            }
+            DataType.BYTE -> {
+                if(rangeFrom.type!= DataType.BYTE) {
+                    // attempt to translate the iterable into byte values
+                    val newIter = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
+                    return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
+                }
+            }
+            DataType.UWORD -> {
+                if(rangeFrom.type!= DataType.UWORD) {
+                    // attempt to translate the iterable into uword values
+                    val newIter = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
+                    return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
+                }
+            }
+            DataType.WORD -> {
+                if(rangeFrom.type!= DataType.WORD) {
+                    // attempt to translate the iterable into word values
+                    val newIter = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
+                    return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
+                }
+            }
+            else -> throw FatalAstException("invalid loopvar datatype $loopvar")
+        }
+
+        return noModifications
+    }
+
+    private class ShuffleOperands(val expr: BinaryExpression,
+                                  val exprOperator: String?,
+                                  val subExpr: BinaryExpression,
+                                  val newExprLeft: Expression?,
+                                  val newExprRight: Expression?,
+                                  val newSubexprLeft: Expression?,
+                                  val newSubexprRight: Expression?
+                                  ): IAstModification {
+        override fun perform() {
+            if(exprOperator!=null) expr.operator = exprOperator
+            if(newExprLeft!=null) expr.left = newExprLeft
+            if(newExprRight!=null) expr.right = newExprRight
+            if(newSubexprLeft!=null) subExpr.left = newSubexprLeft
+            if(newSubexprRight!=null) subExpr.right = newSubexprRight
+        }
+    }
+
+    private fun groupTwoConstsTogether(expr: BinaryExpression,
+                                       subExpr: BinaryExpression,
+                                       leftIsConst: Boolean,
+                                       rightIsConst: Boolean,
+                                       subleftIsConst: Boolean,
+                                       subrightIsConst: Boolean): IAstModification?
+    {
+        // todo: this implements only a small set of possible reorderings at this time
+        if(expr.operator==subExpr.operator) {
+            // both operators are the same.
+            // If + or *,  we can simply shuffle the const operands around to optimize.
+            if(expr.operator=="+" || expr.operator=="*") {
+                return if(leftIsConst) {
+                    if(subleftIsConst)
+                        ShuffleOperands(expr, null, subExpr, subExpr.right, null, null, expr.left)
+                    else
+                        ShuffleOperands(expr, null, subExpr, subExpr.left, null, expr.left, null)
+                } else {
+                    if(subleftIsConst)
+                        ShuffleOperands(expr, null, subExpr, null, subExpr.right, null, expr.right)
+                    else
+                        ShuffleOperands(expr, null, subExpr, null, subExpr.left, expr.right, null)
+                }
+            }
+
+            // If - or /,  we simetimes must reorder more, and flip operators (- -> +, / -> *)
+            if(expr.operator=="-" || expr.operator=="/") {
+                if(leftIsConst) {
+                    return if (subleftIsConst) {
+                        ShuffleOperands(expr, if (expr.operator == "-") "+" else "*", subExpr, subExpr.right, null, expr.left, subExpr.left)
+                    } else {
+                        IAstModification.ReplaceNode(expr,
+                                BinaryExpression(
+                                        BinaryExpression(expr.left, if (expr.operator == "-") "+" else "*", subExpr.right, subExpr.position),
+                                        expr.operator, subExpr.left, expr.position),
+                                expr.parent)
+                    }
+                } else {
+                    return if(subleftIsConst) {
+                        return ShuffleOperands(expr, null, subExpr, null, subExpr.right, null, expr.right)
+                    } else {
+                        IAstModification.ReplaceNode(expr,
+                                BinaryExpression(
+                                        subExpr.left, expr.operator,
+                                        BinaryExpression(expr.right, if (expr.operator == "-") "+" else "*", subExpr.right, subExpr.position),
+                                        expr.position),
+                                expr.parent)
+                    }
+                }
+            }
+            return null
+
+        }
+        else
+        {
+
+            if(expr.operator=="/" && subExpr.operator=="*") {
+                if(leftIsConst) {
+                    val change = if(subleftIsConst) {
+                        // C1/(C2*V) -> (C1/C2)/V
+                        BinaryExpression(
+                                BinaryExpression(expr.left, "/", subExpr.left, subExpr.position),
+                                "/",
+                                subExpr.right, expr.position)
+                    } else {
+                        // C1/(V*C2) -> (C1/C2)/V
+                        BinaryExpression(
+                                BinaryExpression(expr.left, "/", subExpr.right, subExpr.position),
+                                "/",
+                                subExpr.left, expr.position)
+                    }
+                    return IAstModification.ReplaceNode(expr, change, expr.parent)
+                } else {
+                    val change = if(subleftIsConst) {
+                        // (C1*V)/C2 -> (C1/C2)*V
+                        BinaryExpression(
+                                BinaryExpression(subExpr.left, "/", expr.right, subExpr.position),
+                                "*",
+                                subExpr.right, expr.position)
+                    } else {
+                        // (V*C1)/C2 -> (C1/C2)*V
+                        BinaryExpression(
+                                BinaryExpression(subExpr.right, "/", expr.right, subExpr.position),
+                                "*",
+                                subExpr.left, expr.position)
+                    }
+                    return IAstModification.ReplaceNode(expr, change, expr.parent)
+                }
+            }
+            else if(expr.operator=="*" && subExpr.operator=="/") {
+                if(leftIsConst) {
+                    val change = if(subleftIsConst) {
+                        // C1*(C2/V) -> (C1*C2)/V
+                        BinaryExpression(
+                                BinaryExpression(expr.left, "*", subExpr.left, subExpr.position),
+                                "/",
+                                subExpr.right, expr.position)
+                    } else {
+                        // C1*(V/C2) -> (C1/C2)*V
+                        BinaryExpression(
+                                BinaryExpression(expr.left, "/", subExpr.right, subExpr.position),
+                                "*",
+                                subExpr.left, expr.position)
+                    }
+                    return IAstModification.ReplaceNode(expr, change, expr.parent)
+                } else {
+                    val change = if(subleftIsConst) {
+                        // (C1/V)*C2 -> (C1*C2)/V
+                        BinaryExpression(
+                                BinaryExpression(subExpr.left, "*", expr.right, subExpr.position),
+                                "/",
+                                subExpr.right, expr.position)
+                    } else {
+                        // (V/C1)*C2 -> (C1/C2)*V
+                        BinaryExpression(
+                                BinaryExpression(expr.right, "/", subExpr.right, subExpr.position),
+                                "*",
+                                subExpr.left, expr.position)
+                    }
+                    return IAstModification.ReplaceNode(expr, change, expr.parent)
+                }
+            }
+            else if(expr.operator=="+" && subExpr.operator=="-") {
+                if(leftIsConst){
+                    val change = if(subleftIsConst){
+                        // c1+(c2-v)  ->  (c1+c2)-v
+                        BinaryExpression(
+                                BinaryExpression(expr.left, "+", subExpr.left, subExpr.position),
+                                "-",
+                                subExpr.right, expr.position)
+                    } else {
+                        // c1+(v-c2)  ->  v+(c1-c2)
+                        BinaryExpression(
+                                BinaryExpression(expr.left, "-", subExpr.right, subExpr.position),
+                                "+",
+                                subExpr.left, expr.position)
+                    }
+                    return IAstModification.ReplaceNode(expr, change, expr.parent)
+                } else {
+                    val change = if(subleftIsConst) {
+                        // (c1-v)+c2  ->  (c1+c2)-v
+                        BinaryExpression(
+                                BinaryExpression(subExpr.left, "+", expr.right, subExpr.position),
+                                "-",
+                                subExpr.right, expr.position)
+                    } else {
+                        // (v-c1)+c2  ->  v+(c2-c1)
+                        BinaryExpression(
+                                BinaryExpression(expr.right, "-", subExpr.right, subExpr.position),
+                                "+",
+                                subExpr.left, expr.position)
+                    }
+                    return IAstModification.ReplaceNode(expr, change, expr.parent)
+                }
+            }
+            else if(expr.operator=="-" && subExpr.operator=="+") {
+                if(leftIsConst) {
+                    val change = if(subleftIsConst) {
+                        // c1-(c2+v)  ->  (c1-c2)-v
+                        BinaryExpression(
+                                BinaryExpression(expr.left, "-", subExpr.left, subExpr.position),
+                                "-",
+                                subExpr.right, expr.position)
+                    } else {
+                        // c1-(v+c2)  ->  (c1-c2)-v
+                        BinaryExpression(
+                                BinaryExpression(expr.left, "-", subExpr.right, subExpr.position),
+                                "-",
+                                subExpr.left, expr.position)
+                    }
+                    return IAstModification.ReplaceNode(expr, change, expr.parent)
+                } else {
+                    val change = if(subleftIsConst) {
+                        // (c1+v)-c2  ->  v+(c1-c2)
+                        BinaryExpression(
+                                BinaryExpression(subExpr.left, "-", expr.right, subExpr.position),
+                                "+",
+                                subExpr.right, expr.position)
+                    } else {
+                        // (v+c1)-c2  ->  v+(c1-c2)
+                        BinaryExpression(
+                                BinaryExpression(subExpr.right, "-", expr.right, subExpr.position),
+                                "+",
+                                subExpr.left, expr.position)
+                    }
+                    return IAstModification.ReplaceNode(expr, change, expr.parent)
+                }
+            }
+
+            return null
+        }
+    }
+
+}

compiler/src/prog8/optimizer/ExpressionSimplifier.kt

@@ -0,0 +1,668 @@
+package prog8.optimizer
+
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.AstWalker
+import prog8.ast.processing.IAstModification
+import prog8.ast.statements.Assignment
+import kotlin.math.abs
+import kotlin.math.log2
+import kotlin.math.pow
+
+/*
+    todo add more expression optimizations
+
+    Investigate what optimizations binaryen has, also see  https://egorbo.com/peephole-optimizations.html
+
+ */
+
+
+internal class ExpressionSimplifier(private val program: Program) : AstWalker() {
+    private val powersOfTwo = (1..16).map { (2.0).pow(it) }.toSet()
+    private val negativePowersOfTwo = powersOfTwo.map { -it }.toSet()
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
+        if (assignment.aug_op != null)
+            throw FatalAstException("augmented assignments should have been converted to normal assignments before this optimizer: $assignment")
+        return noModifications
+    }
+
+    override fun after(typecast: TypecastExpression, parent: Node): Iterable<IAstModification> {
+        val mods = mutableListOf<IAstModification>()
+
+        // try to statically convert a literal value into one of the desired type
+        val literal = typecast.expression as? NumericLiteralValue
+        if (literal != null) {
+            val newLiteral = literal.cast(typecast.type)
+            if (newLiteral !== literal)
+                mods += IAstModification.ReplaceNode(typecast.expression, newLiteral, typecast)
+        }
+
+        // remove redundant nested typecasts:
+        // if the typecast casts a value to the same type, remove the cast.
+        // if the typecast contains another typecast, remove the inner typecast.
+        val subTypecast = typecast.expression as? TypecastExpression
+        if (subTypecast != null) {
+            mods += IAstModification.ReplaceNode(typecast.expression, subTypecast.expression, typecast)
+        } else {
+            if (typecast.expression.inferType(program).istype(typecast.type))
+                mods += IAstModification.ReplaceNode(typecast, typecast.expression, parent)
+        }
+
+        return mods
+    }
+
+    override fun before(expr: PrefixExpression, parent: Node): Iterable<IAstModification> {
+        if (expr.operator == "+") {
+            // +X --> X
+            return listOf(IAstModification.ReplaceNode(expr, expr.expression, parent))
+        } else if (expr.operator == "not") {
+            when(expr.expression) {
+                is PrefixExpression -> {
+                    // NOT(NOT(...)) -> ...
+                    val pe = expr.expression as PrefixExpression
+                    if(pe.operator == "not")
+                        return listOf(IAstModification.ReplaceNode(expr, pe.expression, parent))
+                }
+                is BinaryExpression -> {
+                    // NOT (xxxx)  ->   invert the xxxx
+                    val be = expr.expression as BinaryExpression
+                    val newExpr = when (be.operator) {
+                        "<" -> BinaryExpression(be.left, ">=", be.right, be.position)
+                        ">" -> BinaryExpression(be.left, "<=", be.right, be.position)
+                        "<=" -> BinaryExpression(be.left, ">", be.right, be.position)
+                        ">=" -> BinaryExpression(be.left, "<", be.right, be.position)
+                        "==" -> BinaryExpression(be.left, "!=", be.right, be.position)
+                        "!=" -> BinaryExpression(be.left, "==", be.right, be.position)
+                        else -> null
+                    }
+
+                    if (newExpr != null)
+                        return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+                }
+                else -> return noModifications
+            }
+        }
+        return noModifications
+    }
+
+    override fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
+        val leftVal = expr.left.constValue(program)
+        val rightVal = expr.right.constValue(program)
+
+        val leftIDt = expr.left.inferType(program)
+        val rightIDt = expr.right.inferType(program)
+        if (!leftIDt.isKnown || !rightIDt.isKnown)
+            throw FatalAstException("can't determine datatype of both expression operands $expr")
+
+        // ConstValue <associativeoperator> X -->  X <associativeoperator> ConstValue
+        if (leftVal != null && expr.operator in associativeOperators && rightVal == null)
+            return listOf(IAstModification.SwapOperands(expr))
+
+        // X + (-A)  -->  X - A
+        if (expr.operator == "+" && (expr.right as? PrefixExpression)?.operator == "-") {
+            return listOf(IAstModification.ReplaceNode(
+                    expr,
+                    BinaryExpression(expr.left, "-", (expr.right as PrefixExpression).expression, expr.position),
+                    parent
+            ))
+        }
+
+        // (-A) + X  -->  X - A
+        if (expr.operator == "+" && (expr.left as? PrefixExpression)?.operator == "-") {
+            return listOf(IAstModification.ReplaceNode(
+                    expr,
+                    BinaryExpression(expr.right, "-", (expr.left as PrefixExpression).expression, expr.position),
+                    parent
+            ))
+        }
+
+        // X - (-A)  -->  X + A
+        if (expr.operator == "-" && (expr.right as? PrefixExpression)?.operator == "-") {
+            return listOf(IAstModification.ReplaceNode(
+                    expr,
+                    BinaryExpression(expr.left, "+", (expr.right as PrefixExpression).expression, expr.position),
+                    parent
+            ))
+        }
+
+        val leftDt = leftIDt.typeOrElse(DataType.STRUCT)
+        val rightDt = rightIDt.typeOrElse(DataType.STRUCT)
+
+        if (expr.operator == "+" || expr.operator == "-"
+                && leftVal == null && rightVal == null
+                && leftDt in NumericDatatypes && rightDt in NumericDatatypes) {
+            val leftBinExpr = expr.left as? BinaryExpression
+            val rightBinExpr = expr.right as? BinaryExpression
+            if (leftBinExpr?.operator == "*") {
+                if (expr.operator == "+") {
+                    // Y*X + X  ->  X*(Y + 1)
+                    // X*Y + X  ->  X*(Y + 1)
+                    val x = expr.right
+                    val y = determineY(x, leftBinExpr)
+                    if (y != null) {
+                        val yPlus1 = BinaryExpression(y, "+", NumericLiteralValue(leftDt, 1, y.position), y.position)
+                        val newExpr = BinaryExpression(x, "*", yPlus1, x.position)
+                        return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+                    }
+                } else {
+                    // Y*X - X  ->  X*(Y - 1)
+                    // X*Y - X  ->  X*(Y - 1)
+                    val x = expr.right
+                    val y = determineY(x, leftBinExpr)
+                    if (y != null) {
+                        val yMinus1 = BinaryExpression(y, "-", NumericLiteralValue(leftDt, 1, y.position), y.position)
+                        val newExpr = BinaryExpression(x, "*", yMinus1, x.position)
+                        return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+                    }
+                }
+            } else if (rightBinExpr?.operator == "*") {
+                if (expr.operator == "+") {
+                    // X + Y*X  ->  X*(Y + 1)
+                    // X + X*Y  ->  X*(Y + 1)
+                    val x = expr.left
+                    val y = determineY(x, rightBinExpr)
+                    if (y != null) {
+                        val yPlus1 = BinaryExpression(y, "+", NumericLiteralValue.optimalInteger(1, y.position), y.position)
+                        val newExpr = BinaryExpression(x, "*", yPlus1, x.position)
+                        return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+                    }
+                }
+            }
+        }
+
+        if(expr.operator == ">=" && rightVal?.number == 0) {
+            if (leftDt == DataType.UBYTE || leftDt == DataType.UWORD) {
+                // unsigned >= 0 --> true
+                return listOf(IAstModification.ReplaceNode(expr, NumericLiteralValue.fromBoolean(true, expr.position), parent))
+            }
+            when(leftDt) {
+                DataType.BYTE -> {
+                    // signed >=0   --> signed ^ $80
+                    return listOf(IAstModification.ReplaceNode(
+                            expr,
+                            BinaryExpression(expr.left, "^", NumericLiteralValue.optimalInteger(0x80, expr.position), expr.position),
+                            parent
+                    ))
+                }
+                DataType.WORD -> {
+                    // signedw >=0   --> msb(signedw) ^ $80
+                    return listOf(IAstModification.ReplaceNode(
+                            expr,
+                            BinaryExpression(FunctionCall(IdentifierReference(listOf("msb"), expr.position),
+                                    mutableListOf(expr.left),
+                                    expr.position
+                            ), "^", NumericLiteralValue.optimalInteger(0x80, expr.position), expr.position),
+                            parent
+                    ))
+                }
+                else -> {}
+            }
+        }
+
+        if(expr.operator == "<" && rightVal?.number == 0) {
+            if (leftDt == DataType.UBYTE || leftDt == DataType.UWORD) {
+                // unsigned < 0 --> false
+                return listOf(IAstModification.ReplaceNode(expr, NumericLiteralValue.fromBoolean(false, expr.position), parent))
+            }
+            when(leftDt) {
+                DataType.BYTE -> {
+                    // signed < 0  -->  signed & $80
+                    return listOf(IAstModification.ReplaceNode(
+                            expr,
+                            BinaryExpression(expr.left, "&", NumericLiteralValue.optimalInteger(0x80, expr.position), expr.position),
+                            parent
+                    ))
+                }
+                DataType.WORD -> {
+                    // signedw < 0 -->  msb(signedw) & $80
+                    return listOf(IAstModification.ReplaceNode(
+                            expr,
+                            BinaryExpression(FunctionCall(IdentifierReference(listOf("msb"), expr.position),
+                                    mutableListOf(expr.left),
+                                    expr.position
+                            ), "&", NumericLiteralValue.optimalInteger(0x80, expr.position), expr.position),
+                            parent
+                    ))
+                }
+                else -> {}
+            }
+        }
+
+        // simplify when a term is constant and directly determines the outcome
+        val constTrue = NumericLiteralValue.fromBoolean(true, expr.position)
+        val constFalse = NumericLiteralValue.fromBoolean(false, expr.position)
+        val newExpr: Expression? = when (expr.operator) {
+            "or" -> {
+                if ((leftVal != null && leftVal.asBooleanValue) || (rightVal != null && rightVal.asBooleanValue))
+                    constTrue
+                else if (leftVal != null && !leftVal.asBooleanValue)
+                    expr.right
+                else if (rightVal != null && !rightVal.asBooleanValue)
+                    expr.left
+                else
+                    null
+            }
+            "and" -> {
+                if ((leftVal != null && !leftVal.asBooleanValue) || (rightVal != null && !rightVal.asBooleanValue))
+                    constFalse
+                else if (leftVal != null && leftVal.asBooleanValue)
+                    expr.right
+                else if (rightVal != null && rightVal.asBooleanValue)
+                    expr.left
+                else
+                    null
+            }
+            "xor" -> {
+                if (leftVal != null && !leftVal.asBooleanValue)
+                    expr.right
+                else if (rightVal != null && !rightVal.asBooleanValue)
+                    expr.left
+                else if (leftVal != null && leftVal.asBooleanValue)
+                    PrefixExpression("not", expr.right, expr.right.position)
+                else if (rightVal != null && rightVal.asBooleanValue)
+                    PrefixExpression("not", expr.left, expr.left.position)
+                else
+                    null
+            }
+            "|", "^" -> {
+                if (leftVal != null && !leftVal.asBooleanValue)
+                    expr.right
+                else if (rightVal != null && !rightVal.asBooleanValue)
+                    expr.left
+                else
+                    null
+            }
+            "&" -> {
+                if (leftVal != null && !leftVal.asBooleanValue)
+                    constFalse
+                else if (rightVal != null && !rightVal.asBooleanValue)
+                    constFalse
+                else
+                    null
+            }
+            "*" -> optimizeMultiplication(expr, leftVal, rightVal)
+            "/" -> optimizeDivision(expr, leftVal, rightVal)
+            "+" -> optimizeAdd(expr, leftVal, rightVal)
+            "-" -> optimizeSub(expr, leftVal, rightVal)
+            "**" -> optimizePower(expr, leftVal, rightVal)
+            "%" -> optimizeRemainder(expr, leftVal, rightVal)
+            ">>" -> optimizeShiftRight(expr, rightVal)
+            "<<" -> optimizeShiftLeft(expr, rightVal)
+            else -> null
+        }
+
+        if(newExpr != null)
+            return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+
+        return noModifications
+    }
+
+    private fun determineY(x: Expression, subBinExpr: BinaryExpression): Expression? {
+        return when {
+            subBinExpr.left isSameAs x -> subBinExpr.right
+            subBinExpr.right isSameAs x -> subBinExpr.left
+            else -> null
+        }
+    }
+
+    private fun optimizeAdd(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression? {
+        if(expr.left.isSameAs(expr.right)) {
+            // optimize X+X into X *2
+            expr.operator = "*"
+            expr.right = NumericLiteralValue.optimalInteger(2, expr.right.position)
+            expr.right.linkParents(expr)
+            return expr
+        }
+
+        if (leftVal == null && rightVal == null)
+            return null
+
+        val (expr2, _, rightVal2) = reorderAssociative(expr, leftVal)
+        if (rightVal2 != null) {
+            // right value is a constant, see if we can optimize
+            val rightConst: NumericLiteralValue = rightVal2
+            when (rightConst.number.toDouble()) {
+                0.0 -> {
+                    // left
+                    return expr2.left
+                }
+            }
+        }
+        // no need to check for left val constant (because of associativity)
+
+        return null
+    }
+
+    private fun optimizeSub(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression? {
+        if(expr.left.isSameAs(expr.right)) {
+            // optimize X-X into 0
+            return NumericLiteralValue.optimalInteger(0, expr.position)
+        }
+
+        if (leftVal == null && rightVal == null)
+            return null
+
+        if (rightVal != null) {
+            // right value is a constant, see if we can optimize
+            val rightConst: NumericLiteralValue = rightVal
+            when (rightConst.number.toDouble()) {
+                0.0 -> {
+                    // left
+                    return expr.left
+                }
+            }
+        }
+        if (leftVal != null) {
+            // left value is a constant, see if we can optimize
+            when (leftVal.number.toDouble()) {
+                0.0 -> {
+                    // -right
+                    return PrefixExpression("-", expr.right, expr.position)
+                }
+            }
+        }
+
+        return null
+    }
+
+    private fun optimizePower(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression? {
+        if (leftVal == null && rightVal == null)
+            return null
+
+        if (rightVal != null) {
+            // right value is a constant, see if we can optimize
+            val rightConst: NumericLiteralValue = rightVal
+            when (rightConst.number.toDouble()) {
+                -3.0 -> {
+                    // -1/(left*left*left)
+                    return BinaryExpression(NumericLiteralValue(DataType.FLOAT, -1.0, expr.position), "/",
+                            BinaryExpression(expr.left, "*", BinaryExpression(expr.left, "*", expr.left, expr.position), expr.position),
+                            expr.position)
+                }
+                -2.0 -> {
+                    // -1/(left*left)
+                    return BinaryExpression(NumericLiteralValue(DataType.FLOAT, -1.0, expr.position), "/",
+                            BinaryExpression(expr.left, "*", expr.left, expr.position),
+                            expr.position)
+                }
+                -1.0 -> {
+                    // -1/left
+                    return BinaryExpression(NumericLiteralValue(DataType.FLOAT, -1.0, expr.position), "/",
+                            expr.left, expr.position)
+                }
+                0.0 -> {
+                    // 1
+                    return NumericLiteralValue(rightConst.type, 1, expr.position)
+                }
+                0.5 -> {
+                    // sqrt(left)
+                    return FunctionCall(IdentifierReference(listOf("sqrt"), expr.position), mutableListOf(expr.left), expr.position)
+                }
+                1.0 -> {
+                    // left
+                    return expr.left
+                }
+                2.0 -> {
+                    // left*left
+                    return BinaryExpression(expr.left, "*", expr.left, expr.position)
+                }
+                3.0 -> {
+                    // left*left*left
+                    return BinaryExpression(expr.left, "*", BinaryExpression(expr.left, "*", expr.left, expr.position), expr.position)
+                }
+            }
+        }
+        if (leftVal != null) {
+            // left value is a constant, see if we can optimize
+            when (leftVal.number.toDouble()) {
+                -1.0 -> {
+                    // -1
+                    return NumericLiteralValue(DataType.FLOAT, -1.0, expr.position)
+                }
+                0.0 -> {
+                    // 0
+                    return NumericLiteralValue(leftVal.type, 0, expr.position)
+                }
+                1.0 -> {
+                    //1
+                    return NumericLiteralValue(leftVal.type, 1, expr.position)
+                }
+
+            }
+        }
+
+        return null
+    }
+
+    private fun optimizeRemainder(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression? {
+        if (leftVal == null && rightVal == null)
+            return null
+
+        // simplify assignments  A = B <operator> C
+
+        val cv = rightVal?.number?.toInt()?.toDouble()
+        when (expr.operator) {
+            "%" -> {
+                if (cv == 1.0) {
+                    return NumericLiteralValue(expr.inferType(program).typeOrElse(DataType.STRUCT), 0, expr.position)
+                } else if (cv == 2.0) {
+                    expr.operator = "&"
+                    expr.right = NumericLiteralValue.optimalInteger(1, expr.position)
+                    return null
+                }
+            }
+        }
+        return null
+
+    }
+
+    private fun optimizeDivision(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression? {
+        if (leftVal == null && rightVal == null)
+            return null
+
+        // cannot shuffle assiciativity with division!
+        if (rightVal != null) {
+            // right value is a constant, see if we can optimize
+            val rightConst: NumericLiteralValue = rightVal
+            val cv = rightConst.number.toDouble()
+            val leftIDt = expr.left.inferType(program)
+            if (!leftIDt.isKnown)
+                return null
+            val leftDt = leftIDt.typeOrElse(DataType.STRUCT)
+            when (cv) {
+                -1.0 -> {
+                    //  '/' -> -left
+                    if (expr.operator == "/") {
+                        return PrefixExpression("-", expr.left, expr.position)
+                    }
+                }
+                1.0 -> {
+                    //  '/' -> left
+                    if (expr.operator == "/") {
+                        return expr.left
+                    }
+                }
+                in powersOfTwo -> {
+                    if (leftDt in IntegerDatatypes) {
+                        // divided by a power of two => shift right
+                        val numshifts = log2(cv).toInt()
+                        return BinaryExpression(expr.left, ">>", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
+                    }
+                }
+                in negativePowersOfTwo -> {
+                    if (leftDt in IntegerDatatypes) {
+                        // divided by a negative power of two => negate, then shift right
+                        val numshifts = log2(-cv).toInt()
+                        return BinaryExpression(PrefixExpression("-", expr.left, expr.position), ">>", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
+                    }
+                }
+            }
+
+            if (leftDt == DataType.UBYTE) {
+                if (abs(rightConst.number.toDouble()) >= 256.0) {
+                    return NumericLiteralValue(DataType.UBYTE, 0, expr.position)
+                }
+            } else if (leftDt == DataType.UWORD) {
+                if (abs(rightConst.number.toDouble()) >= 65536.0) {
+                    return NumericLiteralValue(DataType.UBYTE, 0, expr.position)
+                }
+            }
+        }
+
+        if (leftVal != null) {
+            // left value is a constant, see if we can optimize
+            when (leftVal.number.toDouble()) {
+                0.0 -> {
+                    // 0
+                    return NumericLiteralValue(leftVal.type, 0, expr.position)
+                }
+            }
+        }
+
+        return null
+    }
+
+    private fun optimizeMultiplication(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression? {
+        if (leftVal == null && rightVal == null)
+            return null
+
+        val (expr2, _, rightVal2) = reorderAssociative(expr, leftVal)
+        if (rightVal2 != null) {
+            // right value is a constant, see if we can optimize
+            val leftValue: Expression = expr2.left
+            val rightConst: NumericLiteralValue = rightVal2
+            when (val cv = rightConst.number.toDouble()) {
+                -1.0 -> {
+                    // -left
+                    return PrefixExpression("-", leftValue, expr.position)
+                }
+                0.0 -> {
+                    // 0
+                    return NumericLiteralValue(rightConst.type, 0, expr.position)
+                }
+                1.0 -> {
+                    // left
+                    return expr2.left
+                }
+                in powersOfTwo -> {
+                    if (leftValue.inferType(program).typeOrElse(DataType.STRUCT) in IntegerDatatypes) {
+                        // times a power of two => shift left
+                        val numshifts = log2(cv).toInt()
+                        return BinaryExpression(expr2.left, "<<", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
+                    }
+                }
+                in negativePowersOfTwo -> {
+                    if (leftValue.inferType(program).typeOrElse(DataType.STRUCT) in IntegerDatatypes) {
+                        // times a negative power of two => negate, then shift left
+                        val numshifts = log2(-cv).toInt()
+                        return BinaryExpression(PrefixExpression("-", expr2.left, expr.position), "<<", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
+                    }
+                }
+            }
+        }
+        // no need to check for left val constant (because of associativity)
+
+        return null
+    }
+
+    private fun optimizeShiftLeft(expr: BinaryExpression, amountLv: NumericLiteralValue?): Expression? {
+        if (amountLv == null)
+            return null
+
+        val amount = amountLv.number.toInt()
+        if (amount == 0) {
+            return expr.left
+        }
+        val targetDt = expr.left.inferType(program).typeOrElse(DataType.STRUCT)
+        when (targetDt) {
+            DataType.UBYTE, DataType.BYTE -> {
+                if (amount >= 8) {
+                    return NumericLiteralValue(targetDt, 0, expr.position)
+                }
+            }
+            DataType.UWORD, DataType.WORD -> {
+                if (amount >= 16) {
+                    return NumericLiteralValue(targetDt, 0, expr.position)
+                } else if (amount >= 8) {
+                    val lsb = TypecastExpression(expr.left, DataType.UBYTE, true, expr.position)
+                    if (amount == 8) {
+                        return FunctionCall(IdentifierReference(listOf("mkword"), expr.position), mutableListOf(NumericLiteralValue.optimalInteger(0, expr.position), lsb), expr.position)
+                    }
+                    val shifted = BinaryExpression(lsb, "<<", NumericLiteralValue.optimalInteger(amount - 8, expr.position), expr.position)
+                    return FunctionCall(IdentifierReference(listOf("mkword"), expr.position), mutableListOf(NumericLiteralValue.optimalInteger(0, expr.position), shifted), expr.position)
+                }
+            }
+            else -> {
+            }
+        }
+        return null
+    }
+
+    private fun optimizeShiftRight(expr: BinaryExpression, amountLv: NumericLiteralValue?): Expression? {
+        if (amountLv == null)
+            return null
+
+        val amount = amountLv.number.toInt()
+        if (amount == 0) {
+            return expr.left
+        }
+        when (expr.left.inferType(program).typeOrElse(DataType.STRUCT)) {
+            DataType.UBYTE -> {
+                if (amount >= 8) {
+                    return NumericLiteralValue.optimalInteger(0, expr.position)
+                }
+            }
+            DataType.BYTE -> {
+                if (amount > 8) {
+                    expr.right = NumericLiteralValue.optimalInteger(8, expr.right.position)
+                    return null
+                }
+            }
+            DataType.UWORD -> {
+                if (amount >= 16) {
+                    return NumericLiteralValue.optimalInteger(0, expr.position)
+                } else if (amount >= 8) {
+                    val msb = FunctionCall(IdentifierReference(listOf("msb"), expr.position), mutableListOf(expr.left), expr.position)
+                    if (amount == 8)
+                        return msb
+                    return BinaryExpression(msb, ">>", NumericLiteralValue.optimalInteger(amount - 8, expr.position), expr.position)
+                }
+            }
+            DataType.WORD -> {
+                if (amount > 16) {
+                    expr.right = NumericLiteralValue.optimalInteger(16, expr.right.position)
+                    return null
+                } else if (amount >= 8) {
+                    val msbAsByte = TypecastExpression(
+                            FunctionCall(IdentifierReference(listOf("msb"), expr.position), mutableListOf(expr.left), expr.position),
+                            DataType.BYTE,
+                            true, expr.position)
+                    if (amount == 8)
+                        return msbAsByte
+                    return BinaryExpression(msbAsByte, ">>", NumericLiteralValue.optimalInteger(amount - 8, expr.position), expr.position)
+                }
+            }
+            else -> {
+            }
+        }
+        return null
+    }
+
+    private fun reorderAssociative(expr: BinaryExpression, leftVal: NumericLiteralValue?): ReorderedAssociativeBinaryExpr {
+        if (expr.operator in associativeOperators && leftVal != null) {
+            // swap left and right so that right is always the constant
+            val tmp = expr.left
+            expr.left = expr.right
+            expr.right = tmp
+            return ReorderedAssociativeBinaryExpr(expr, expr.right.constValue(program), leftVal)
+        }
+        return ReorderedAssociativeBinaryExpr(expr, leftVal, expr.right.constValue(program))
+    }
+
+    private data class ReorderedAssociativeBinaryExpr(val expr: BinaryExpression, val leftVal: NumericLiteralValue?, val rightVal: NumericLiteralValue?)
+
+}

compiler/src/prog8/optimizer/Extensions.kt

@@ -5,12 +5,21 @@ import prog8.ast.base.ErrorReporter
 
 
 internal fun Program.constantFold(errors: ErrorReporter) {
-    val optimizer = ConstantFolding(this, errors)
-    optimizer.visit(this)
+    val replacer = ConstantIdentifierReplacer(this, errors)
+    replacer.visit(this)
+    if(errors.isEmpty()) {
+        replacer.applyModifications()
 
-    while(errors.isEmpty() && optimizer.optimizationsDone>0) {
-        optimizer.optimizationsDone = 0
+        val optimizer = ConstantFoldingOptimizer(this, errors)
         optimizer.visit(this)
+        while (errors.isEmpty() && optimizer.applyModifications() > 0) {
+            optimizer.visit(this)
+        }
+
+        if(errors.isEmpty()) {
+            replacer.visit(this)
+            replacer.applyModifications()
+        }
     }
 
     if(errors.isEmpty())
@@ -21,13 +30,15 @@ internal fun Program.constantFold(errors: ErrorReporter) {
 internal fun Program.optimizeStatements(errors: ErrorReporter): Int {
     val optimizer = StatementOptimizer(this, errors)
     optimizer.visit(this)
+    val optimizationCount = optimizer.applyModifications()
+
     modules.forEach { it.linkParents(this.namespace) }   // re-link in final configuration
 
-    return optimizer.optimizationsDone
+    return optimizationCount
 }
 
 internal fun Program.simplifyExpressions() : Int {
-    val optimizer = SimplifyExpressions(this)
-    optimizer.visit(this)
-    return optimizer.optimizationsDone
+    val opti = ExpressionSimplifier(this)
+    opti.visit(this)
+    return opti.applyModifications()
 }

compiler/src/prog8/optimizer/SimplifyExpressions.kt

@@ -1,828 +0,0 @@
-package prog8.optimizer
-
-import prog8.ast.Program
-import prog8.ast.base.*
-import prog8.ast.expressions.*
-import prog8.ast.processing.IAstModifyingVisitor
-import prog8.ast.statements.Assignment
-import prog8.ast.statements.Statement
-import kotlin.math.abs
-import kotlin.math.log2
-import kotlin.math.pow
-
-/*
-    todo add more expression optimizations
-
-    Investigate what optimizations binaryen has, also see  https://egorbo.com/peephole-optimizations.html
-
- */
-
-internal class SimplifyExpressions(private val program: Program) : IAstModifyingVisitor {
-    var optimizationsDone: Int = 0
-
-    override fun visit(assignment: Assignment): Statement {
-        if (assignment.aug_op != null)
-            throw AstException("augmented assignments should have been converted to normal assignments before this optimizer: $assignment")
-        return super.visit(assignment)
-    }
-
-    override fun visit(memread: DirectMemoryRead): Expression {
-        // @( &thing )  -->  thing
-        val addrOf = memread.addressExpression as? AddressOf
-        if(addrOf!=null)
-            return super.visit(addrOf.identifier)
-        return super.visit(memread)
-    }
-
-    override fun visit(typecast: TypecastExpression): Expression {
-        var tc = typecast
-
-        // try to statically convert a literal value into one of the desired type
-        val literal = tc.expression as? NumericLiteralValue
-        if(literal!=null) {
-            val newLiteral = literal.cast(tc.type)
-            if(newLiteral!==literal) {
-                optimizationsDone++
-                return newLiteral
-            }
-        }
-
-        // remove redundant typecasts
-        while(true) {
-            val expr = tc.expression
-            if(expr !is TypecastExpression || expr.type!=tc.type) {
-                val assignment = typecast.parent as? Assignment
-                if(assignment!=null) {
-                    val targetDt = assignment.target.inferType(program, assignment)
-                    if(tc.expression.inferType(program)==targetDt) {
-                        optimizationsDone++
-                        return tc.expression
-                    }
-                }
-
-                val subTc = tc.expression as? TypecastExpression
-                if(subTc!=null) {
-                    // if the previous typecast was casting to a 'bigger' type, just ignore that one
-                    // if the previous typecast was casting to a similar type, ignore that one
-                    if(subTc.type largerThan tc.type || subTc.type equalsSize tc.type) {
-                        subTc.type = tc.type
-                        subTc.parent = tc.parent
-                        optimizationsDone++
-                        return subTc
-                    }
-                }
-
-                return super.visit(tc)
-            }
-
-            optimizationsDone++
-            tc = expr
-        }
-    }
-
-    override fun visit(expr: PrefixExpression): Expression {
-        if (expr.operator == "+") {
-            // +X --> X
-            optimizationsDone++
-            return expr.expression.accept(this)
-        } else if (expr.operator == "not") {
-            (expr.expression as? BinaryExpression)?.let {
-                // NOT (...)  ->   invert  ...
-                when (it.operator) {
-                    "<" -> {
-                        it.operator = ">="
-                        optimizationsDone++
-                        return it
-                    }
-                    ">" -> {
-                        it.operator = "<="
-                        optimizationsDone++
-                        return it
-                    }
-                    "<=" -> {
-                        it.operator = ">"
-                        optimizationsDone++
-                        return it
-                    }
-                    ">=" -> {
-                        it.operator = "<"
-                        optimizationsDone++
-                        return it
-                    }
-                    "==" -> {
-                        it.operator = "!="
-                        optimizationsDone++
-                        return it
-                    }
-                    "!=" -> {
-                        it.operator = "=="
-                        optimizationsDone++
-                        return it
-                    }
-                    else -> {
-                    }
-                }
-            }
-        }
-        return super.visit(expr)
-    }
-
-    override fun visit(expr: BinaryExpression): Expression {
-        super.visit(expr)
-        val leftVal = expr.left.constValue(program)
-        val rightVal = expr.right.constValue(program)
-        val constTrue = NumericLiteralValue.fromBoolean(true, expr.position)
-        val constFalse = NumericLiteralValue.fromBoolean(false, expr.position)
-
-        val leftIDt = expr.left.inferType(program)
-        val rightIDt = expr.right.inferType(program)
-        if(!leftIDt.isKnown || !rightIDt.isKnown)
-            throw FatalAstException("can't determine datatype of both expression operands $expr")
-
-        val leftDt = leftIDt.typeOrElse(DataType.STRUCT)
-        val rightDt = rightIDt.typeOrElse(DataType.STRUCT)
-        if (leftDt != rightDt) {
-            // try to convert a datatype into the other (where ddd
-            if (adjustDatatypes(expr, leftVal, leftDt, rightVal, rightDt)) {
-                optimizationsDone++
-                return expr
-            }
-        }
-
-        // Value <associativeoperator> X -->  X <associativeoperator> Value
-        if (leftVal != null && expr.operator in associativeOperators && rightVal == null) {
-            val tmp = expr.left
-            expr.left = expr.right
-            expr.right = tmp
-            optimizationsDone++
-            return expr
-        }
-
-        // X + (-A)  -->  X - A
-        if (expr.operator == "+" && (expr.right as? PrefixExpression)?.operator == "-") {
-            expr.operator = "-"
-            expr.right = (expr.right as PrefixExpression).expression
-            optimizationsDone++
-            return expr
-        }
-
-        // (-A) + X  -->  X - A
-        if (expr.operator == "+" && (expr.left as? PrefixExpression)?.operator == "-") {
-            expr.operator = "-"
-            val newRight = (expr.left as PrefixExpression).expression
-            expr.left = expr.right
-            expr.right = newRight
-            optimizationsDone++
-            return expr
-        }
-
-        // X + (-value)  -->  X - value
-        if (expr.operator == "+" && rightVal != null) {
-            val rv = rightVal.number.toDouble()
-            if (rv < 0.0) {
-                expr.operator = "-"
-                expr.right = NumericLiteralValue(rightVal.type, -rv, rightVal.position)
-                optimizationsDone++
-                return expr
-            }
-        }
-
-        // (-value) + X  -->  X - value
-        if (expr.operator == "+" && leftVal != null) {
-            val lv = leftVal.number.toDouble()
-            if (lv < 0.0) {
-                expr.operator = "-"
-                expr.right = NumericLiteralValue(leftVal.type, -lv, leftVal.position)
-                optimizationsDone++
-                return expr
-            }
-        }
-
-        // X - (-A)  -->  X + A
-        if (expr.operator == "-" && (expr.right as? PrefixExpression)?.operator == "-") {
-            expr.operator = "+"
-            expr.right = (expr.right as PrefixExpression).expression
-            optimizationsDone++
-            return expr
-        }
-
-        // X - (-value)  -->  X + value
-        if (expr.operator == "-" && rightVal != null) {
-            val rv = rightVal.number.toDouble()
-            if (rv < 0.0) {
-                expr.operator = "+"
-                expr.right = NumericLiteralValue(rightVal.type, -rv, rightVal.position)
-                optimizationsDone++
-                return expr
-            }
-        }
-
-        if (expr.operator == "+" || expr.operator == "-"
-                && leftVal == null && rightVal == null
-                && leftDt in NumericDatatypes && rightDt in NumericDatatypes) {
-            val leftBinExpr = expr.left as? BinaryExpression
-            val rightBinExpr = expr.right as? BinaryExpression
-            if (leftBinExpr?.operator == "*") {
-                if (expr.operator == "+") {
-                    // Y*X + X  ->  X*(Y - 1)
-                    // X*Y + X  ->  X*(Y - 1)
-                    val x = expr.right
-                    val y = determineY(x, leftBinExpr)
-                    if(y!=null) {
-                        val yPlus1 = BinaryExpression(y, "+", NumericLiteralValue(leftDt, 1, y.position), y.position)
-                        return BinaryExpression(x, "*", yPlus1, x.position)
-                    }
-                } else {
-                    // Y*X - X  ->  X*(Y - 1)
-                    // X*Y - X  ->  X*(Y - 1)
-                    val x = expr.right
-                    val y = determineY(x, leftBinExpr)
-                    if(y!=null) {
-                        val yMinus1 = BinaryExpression(y, "-", NumericLiteralValue(leftDt, 1, y.position), y.position)
-                        return BinaryExpression(x, "*", yMinus1, x.position)
-                    }
-                }
-            }
-            else if(rightBinExpr?.operator=="*") {
-                if(expr.operator=="+") {
-                    // X + Y*X  ->  X*(Y + 1)
-                    // X + X*Y  ->  X*(Y + 1)
-                    val x = expr.left
-                    val y = determineY(x, rightBinExpr)
-                    if(y!=null) {
-                        val yPlus1 = BinaryExpression(y, "+", NumericLiteralValue.optimalInteger(1, y.position), y.position)
-                        return BinaryExpression(x, "*", yPlus1, x.position)
-                    }
-                } else {
-                    // X - Y*X  ->  X*(1 - Y)
-                    // X - X*Y  ->  X*(1 - Y)
-                    val x = expr.left
-                    val y = determineY(x, rightBinExpr)
-                    if(y!=null) {
-                        val oneMinusY = BinaryExpression(NumericLiteralValue.optimalInteger(1, y.position), "-", y, y.position)
-                        return BinaryExpression(x, "*", oneMinusY, x.position)
-                    }
-                }
-            }
-        }
-
-
-        // simplify when a term is constant and determines the outcome
-        when (expr.operator) {
-            "or" -> {
-                if ((leftVal != null && leftVal.asBooleanValue) || (rightVal != null && rightVal.asBooleanValue)) {
-                    optimizationsDone++
-                    return constTrue
-                }
-                if (leftVal != null && !leftVal.asBooleanValue) {
-                    optimizationsDone++
-                    return expr.right
-                }
-                if (rightVal != null && !rightVal.asBooleanValue) {
-                    optimizationsDone++
-                    return expr.left
-                }
-            }
-            "and" -> {
-                if ((leftVal != null && !leftVal.asBooleanValue) || (rightVal != null && !rightVal.asBooleanValue)) {
-                    optimizationsDone++
-                    return constFalse
-                }
-                if (leftVal != null && leftVal.asBooleanValue) {
-                    optimizationsDone++
-                    return expr.right
-                }
-                if (rightVal != null && rightVal.asBooleanValue) {
-                    optimizationsDone++
-                    return expr.left
-                }
-            }
-            "xor" -> {
-                if (leftVal != null && !leftVal.asBooleanValue) {
-                    optimizationsDone++
-                    return expr.right
-                }
-                if (rightVal != null && !rightVal.asBooleanValue) {
-                    optimizationsDone++
-                    return expr.left
-                }
-                if (leftVal != null && leftVal.asBooleanValue) {
-                    optimizationsDone++
-                    return PrefixExpression("not", expr.right, expr.right.position)
-                }
-                if (rightVal != null && rightVal.asBooleanValue) {
-                    optimizationsDone++
-                    return PrefixExpression("not", expr.left, expr.left.position)
-                }
-            }
-            "|", "^" -> {
-                if (leftVal != null && !leftVal.asBooleanValue) {
-                    optimizationsDone++
-                    return expr.right
-                }
-                if (rightVal != null && !rightVal.asBooleanValue) {
-                    optimizationsDone++
-                    return expr.left
-                }
-            }
-            "&" -> {
-                if (leftVal != null && !leftVal.asBooleanValue) {
-                    optimizationsDone++
-                    return constFalse
-                }
-                if (rightVal != null && !rightVal.asBooleanValue) {
-                    optimizationsDone++
-                    return constFalse
-                }
-            }
-            "*" -> return optimizeMultiplication(expr, leftVal, rightVal)
-            "/" -> return optimizeDivision(expr, leftVal, rightVal)
-            "+" -> return optimizeAdd(expr, leftVal, rightVal)
-            "-" -> return optimizeSub(expr, leftVal, rightVal)
-            "**" -> return optimizePower(expr, leftVal, rightVal)
-            "%" -> return optimizeRemainder(expr, leftVal, rightVal)
-            ">>" -> return optimizeShiftRight(expr, rightVal)
-            "<<" -> return optimizeShiftLeft(expr, rightVal)
-        }
-        return expr
-    }
-
-    private fun determineY(x: Expression, subBinExpr: BinaryExpression): Expression? {
-        return when {
-            subBinExpr.left isSameAs x -> subBinExpr.right
-            subBinExpr.right isSameAs x -> subBinExpr.left
-            else -> null
-        }
-    }
-
-    private fun adjustDatatypes(expr: BinaryExpression,
-                                leftConstVal: NumericLiteralValue?, leftDt: DataType,
-                                rightConstVal: NumericLiteralValue?, rightDt: DataType): Boolean {
-
-        fun adjust(value: NumericLiteralValue, targetDt: DataType): Pair<Boolean, NumericLiteralValue>{
-            if(value.type==targetDt)
-                return Pair(false, value)
-            when(value.type) {
-                DataType.UBYTE -> {
-                    if (targetDt == DataType.BYTE) {
-                        if(value.number.toInt() < 127)
-                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
-                    }
-                    else if (targetDt == DataType.UWORD || targetDt == DataType.WORD)
-                        return Pair(true, NumericLiteralValue(targetDt, value.number.toInt(), value.position))
-                }
-                DataType.BYTE -> {
-                    if (targetDt == DataType.UBYTE) {
-                        if(value.number.toInt() >= 0)
-                            return Pair(true, NumericLiteralValue(targetDt, value.number.toInt(), value.position))
-                    }
-                    else if (targetDt == DataType.UWORD) {
-                        if(value.number.toInt() >= 0)
-                            return Pair(true, NumericLiteralValue(targetDt, value.number.toInt(), value.position))
-                    }
-                    else if (targetDt == DataType.WORD) return Pair(true, NumericLiteralValue(targetDt, value.number.toInt(), value.position))
-                }
-                DataType.UWORD -> {
-                    if (targetDt == DataType.UBYTE) {
-                        if(value.number.toInt() <= 255)
-                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
-                    }
-                    else if (targetDt == DataType.BYTE) {
-                        if(value.number.toInt() <= 127)
-                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
-                    }
-                    else if (targetDt == DataType.WORD) {
-                        if(value.number.toInt() <= 32767)
-                            return Pair(true, NumericLiteralValue(targetDt, value.number.toInt(), value.position))
-                    }
-                }
-                DataType.WORD -> {
-                    if (targetDt == DataType.UBYTE) {
-                        if(value.number.toInt() in 0..255)
-                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
-                    }
-                    else if (targetDt == DataType.BYTE) {
-                        if(value.number.toInt() in -128..127)
-                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
-                    }
-                    else if (targetDt == DataType.UWORD) {
-                        if(value.number.toInt() >= 0)
-                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
-                    }
-                }
-                else -> {}
-            }
-            return Pair(false, value)
-        }
-
-        if(leftConstVal==null && rightConstVal!=null) {
-            if(leftDt largerThan rightDt) {
-                val (adjusted, newValue) = adjust(rightConstVal, leftDt)
-                if (adjusted) {
-                    expr.right = newValue
-                    optimizationsDone++
-                    return true
-                }
-            }
-            return false
-        } else if(leftConstVal!=null && rightConstVal==null) {
-            if(rightDt largerThan leftDt) {
-                val (adjusted, newValue) = adjust(leftConstVal, rightDt)
-                if (adjusted) {
-                    expr.left = newValue
-                    optimizationsDone++
-                    return true
-                }
-            }
-            return false
-        } else {
-            return false    // two const values, don't adjust (should have been const-folded away)
-        }
-    }
-
-    private data class ReorderedAssociativeBinaryExpr(val expr: BinaryExpression, val leftVal: NumericLiteralValue?, val rightVal: NumericLiteralValue?)
-
-    private fun reorderAssociative(expr: BinaryExpression, leftVal: NumericLiteralValue?): ReorderedAssociativeBinaryExpr {
-        if(expr.operator in associativeOperators && leftVal!=null) {
-            // swap left and right so that right is always the constant
-            val tmp = expr.left
-            expr.left = expr.right
-            expr.right = tmp
-            optimizationsDone++
-            return ReorderedAssociativeBinaryExpr(expr, expr.right.constValue(program), leftVal)
-        }
-        return ReorderedAssociativeBinaryExpr(expr, leftVal, expr.right.constValue(program))
-    }
-
-    private fun optimizeAdd(pexpr: BinaryExpression, pleftVal: NumericLiteralValue?, prightVal: NumericLiteralValue?): Expression {
-        if(pleftVal==null && prightVal==null)
-            return pexpr
-
-        val (expr, _, rightVal) = reorderAssociative(pexpr, pleftVal)
-        if(rightVal!=null) {
-            // right value is a constant, see if we can optimize
-            val rightConst: NumericLiteralValue = rightVal
-            when(rightConst.number.toDouble()) {
-                0.0 -> {
-                    // left
-                    optimizationsDone++
-                    return expr.left
-                }
-            }
-        }
-        // no need to check for left val constant (because of associativity)
-
-        return expr
-    }
-
-    private fun optimizeSub(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression {
-        if(leftVal==null && rightVal==null)
-            return expr
-
-        if(rightVal!=null) {
-            // right value is a constant, see if we can optimize
-            val rightConst: NumericLiteralValue = rightVal
-            when(rightConst.number.toDouble()) {
-                0.0 -> {
-                    // left
-                    optimizationsDone++
-                    return expr.left
-                }
-            }
-        }
-        if(leftVal!=null) {
-            // left value is a constant, see if we can optimize
-            when(leftVal.number.toDouble()) {
-                0.0 -> {
-                    // -right
-                    optimizationsDone++
-                    return PrefixExpression("-", expr.right, expr.position)
-                }
-            }
-        }
-
-        return expr
-    }
-
-    private fun optimizePower(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression {
-        if(leftVal==null && rightVal==null)
-            return expr
-
-        if(rightVal!=null) {
-            // right value is a constant, see if we can optimize
-            val rightConst: NumericLiteralValue = rightVal
-            when(rightConst.number.toDouble()) {
-                -3.0 -> {
-                    // -1/(left*left*left)
-                    optimizationsDone++
-                    return BinaryExpression(NumericLiteralValue(DataType.FLOAT, -1.0, expr.position), "/",
-                            BinaryExpression(expr.left, "*", BinaryExpression(expr.left, "*", expr.left, expr.position), expr.position),
-                            expr.position)
-                }
-                -2.0 -> {
-                    // -1/(left*left)
-                    optimizationsDone++
-                    return BinaryExpression(NumericLiteralValue(DataType.FLOAT, -1.0, expr.position), "/",
-                            BinaryExpression(expr.left, "*", expr.left, expr.position),
-                            expr.position)
-                }
-                -1.0 -> {
-                    // -1/left
-                    optimizationsDone++
-                    return BinaryExpression(NumericLiteralValue(DataType.FLOAT, -1.0, expr.position), "/",
-                            expr.left, expr.position)
-                }
-                0.0 -> {
-                    // 1
-                    optimizationsDone++
-                    return NumericLiteralValue(rightConst.type, 1, expr.position)
-                }
-                0.5 -> {
-                    // sqrt(left)
-                    optimizationsDone++
-                    return FunctionCall(IdentifierReference(listOf("sqrt"), expr.position), mutableListOf(expr.left), expr.position)
-                }
-                1.0 -> {
-                    // left
-                    optimizationsDone++
-                    return expr.left
-                }
-                2.0 -> {
-                    // left*left
-                    optimizationsDone++
-                    return BinaryExpression(expr.left, "*", expr.left, expr.position)
-                }
-                3.0 -> {
-                    // left*left*left
-                    optimizationsDone++
-                    return BinaryExpression(expr.left, "*", BinaryExpression(expr.left, "*", expr.left, expr.position), expr.position)
-                }
-            }
-        }
-        if(leftVal!=null) {
-            // left value is a constant, see if we can optimize
-            when(leftVal.number.toDouble()) {
-                -1.0 -> {
-                    // -1
-                    optimizationsDone++
-                    return NumericLiteralValue(DataType.FLOAT, -1.0, expr.position)
-                }
-                0.0 -> {
-                    // 0
-                    optimizationsDone++
-                    return NumericLiteralValue(leftVal.type, 0, expr.position)
-                }
-                1.0 -> {
-                    //1
-                    optimizationsDone++
-                    return NumericLiteralValue(leftVal.type, 1, expr.position)
-                }
-
-            }
-        }
-
-        return expr
-    }
-
-    private fun optimizeRemainder(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression {
-        if(leftVal==null && rightVal==null)
-            return expr
-
-        // simplify assignments  A = B <operator> C
-
-        val cv = rightVal?.number?.toInt()?.toDouble()
-        when(expr.operator) {
-            "%" -> {
-                if (cv == 1.0) {
-                    optimizationsDone++
-                    return NumericLiteralValue(expr.inferType(program).typeOrElse(DataType.STRUCT), 0, expr.position)
-                } else if (cv == 2.0) {
-                    optimizationsDone++
-                    expr.operator = "&"
-                    expr.right = NumericLiteralValue.optimalInteger(1, expr.position)
-                    return expr
-                }
-            }
-        }
-        return expr
-
-    }
-
-    private val powersOfTwo = (1 .. 16).map { (2.0).pow(it) }.toSet()
-    private val negativePowersOfTwo = powersOfTwo.map { -it }.toSet()
-
-    private fun optimizeDivision(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression {
-        if(leftVal==null && rightVal==null)
-            return expr
-
-        // cannot shuffle assiciativity with division!
-        if(rightVal!=null) {
-            // right value is a constant, see if we can optimize
-            val rightConst: NumericLiteralValue = rightVal
-            val cv = rightConst.number.toDouble()
-            val leftIDt = expr.left.inferType(program)
-            if(!leftIDt.isKnown)
-                return expr
-            val leftDt = leftIDt.typeOrElse(DataType.STRUCT)
-            when(cv) {
-                -1.0 -> {
-                    //  '/' -> -left
-                    if (expr.operator == "/") {
-                        optimizationsDone++
-                        return PrefixExpression("-", expr.left, expr.position)
-                    }
-                }
-                1.0 -> {
-                    //  '/' -> left
-                    if (expr.operator == "/") {
-                        optimizationsDone++
-                        return expr.left
-                    }
-                }
-                in powersOfTwo -> {
-                    if(leftDt in IntegerDatatypes) {
-                        // divided by a power of two => shift right
-                        optimizationsDone++
-                        val numshifts = log2(cv).toInt()
-                        return BinaryExpression(expr.left, ">>", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
-                    }
-                }
-                in negativePowersOfTwo -> {
-                    if(leftDt in IntegerDatatypes) {
-                        // divided by a negative power of two => negate, then shift right
-                        optimizationsDone++
-                        val numshifts = log2(-cv).toInt()
-                        return BinaryExpression(PrefixExpression("-", expr.left, expr.position), ">>", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
-                    }
-                }
-            }
-
-            if (leftDt == DataType.UBYTE) {
-                if(abs(rightConst.number.toDouble()) >= 256.0) {
-                    optimizationsDone++
-                    return NumericLiteralValue(DataType.UBYTE, 0, expr.position)
-                }
-            }
-            else if (leftDt == DataType.UWORD) {
-                if(abs(rightConst.number.toDouble()) >= 65536.0) {
-                    optimizationsDone++
-                    return NumericLiteralValue(DataType.UBYTE, 0, expr.position)
-                }
-            }
-        }
-
-        if(leftVal!=null) {
-            // left value is a constant, see if we can optimize
-            when(leftVal.number.toDouble()) {
-                0.0 -> {
-                    // 0
-                    optimizationsDone++
-                    return NumericLiteralValue(leftVal.type, 0, expr.position)
-                }
-            }
-        }
-
-        return expr
-    }
-
-    private fun optimizeMultiplication(pexpr: BinaryExpression, pleftVal: NumericLiteralValue?, prightVal: NumericLiteralValue?): Expression {
-        if(pleftVal==null && prightVal==null)
-            return pexpr
-
-        val (expr, _, rightVal) = reorderAssociative(pexpr, pleftVal)
-        if(rightVal!=null) {
-            // right value is a constant, see if we can optimize
-            val leftValue: Expression = expr.left
-            val rightConst: NumericLiteralValue = rightVal
-            when(val cv = rightConst.number.toDouble()) {
-                -1.0 -> {
-                    // -left
-                    optimizationsDone++
-                    return PrefixExpression("-", leftValue, expr.position)
-                }
-                0.0 -> {
-                    // 0
-                    optimizationsDone++
-                    return NumericLiteralValue(rightConst.type, 0, expr.position)
-                }
-                1.0 -> {
-                    // left
-                    optimizationsDone++
-                    return expr.left
-                }
-                in powersOfTwo -> {
-                    if(leftValue.inferType(program).typeOrElse(DataType.STRUCT) in IntegerDatatypes) {
-                        // times a power of two => shift left
-                        optimizationsDone++
-                        val numshifts = log2(cv).toInt()
-                        return BinaryExpression(expr.left, "<<", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
-                    }
-                }
-                in negativePowersOfTwo -> {
-                    if(leftValue.inferType(program).typeOrElse(DataType.STRUCT) in IntegerDatatypes) {
-                        // times a negative power of two => negate, then shift left
-                        optimizationsDone++
-                        val numshifts = log2(-cv).toInt()
-                        return BinaryExpression(PrefixExpression("-", expr.left, expr.position), "<<", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
-                    }
-                }
-            }
-        }
-        // no need to check for left val constant (because of associativity)
-
-        return expr
-    }
-
-    private fun optimizeShiftLeft(expr: BinaryExpression, amountLv: NumericLiteralValue?): Expression {
-        if(amountLv==null)
-            return expr
-
-        val amount=amountLv.number.toInt()
-        if(amount==0) {
-            optimizationsDone++
-            return expr.left
-        }
-        val targetDt = expr.left.inferType(program).typeOrElse(DataType.STRUCT)
-        when(targetDt) {
-            DataType.UBYTE, DataType.BYTE -> {
-                if(amount>=8) {
-                    optimizationsDone++
-                    return NumericLiteralValue.optimalInteger(0, expr.position)
-                }
-            }
-            DataType.UWORD, DataType.WORD -> {
-                if(amount>=16) {
-                    optimizationsDone++
-                    return NumericLiteralValue.optimalInteger(0, expr.position)
-                }
-                else if(amount>=8) {
-                    optimizationsDone++
-                    val lsb=TypecastExpression(expr.left, DataType.UBYTE, true, expr.position)
-                    if(amount==8) {
-                        return FunctionCall(IdentifierReference(listOf("mkword"), expr.position), mutableListOf(NumericLiteralValue.optimalInteger(0, expr.position), lsb), expr.position)
-                    }
-                    val shifted = BinaryExpression(lsb, "<<", NumericLiteralValue.optimalInteger(amount-8, expr.position), expr.position)
-                    return FunctionCall(IdentifierReference(listOf("mkword"), expr.position), mutableListOf(NumericLiteralValue.optimalInteger(0, expr.position), shifted), expr.position)
-                }
-            }
-            else -> {}
-        }
-        return expr
-    }
-
-    private fun optimizeShiftRight(expr: BinaryExpression, amountLv: NumericLiteralValue?): Expression {
-        if(amountLv==null)
-            return expr
-
-        val amount=amountLv.number.toInt()
-        if(amount==0) {
-            optimizationsDone++
-            return expr.left
-        }
-        val targetDt = expr.left.inferType(program).typeOrElse(DataType.STRUCT)
-        when(targetDt) {
-            DataType.UBYTE -> {
-                if(amount>=8) {
-                    optimizationsDone++
-                    return NumericLiteralValue.optimalInteger(0, expr.position)
-                }
-            }
-            DataType.BYTE -> {
-                if(amount>8) {
-                    expr.right = NumericLiteralValue.optimalInteger(8, expr.right.position)
-                    return expr
-                }
-            }
-            DataType.UWORD -> {
-                if(amount>=16) {
-                    optimizationsDone++
-                    return NumericLiteralValue.optimalInteger(0, expr.position)
-                }
-                else if(amount>=8) {
-                    optimizationsDone++
-                    val msb=FunctionCall(IdentifierReference(listOf("msb"), expr.position), mutableListOf(expr.left), expr.position)
-                    if(amount==8)
-                        return msb
-                    return BinaryExpression(msb, ">>", NumericLiteralValue.optimalInteger(amount-8, expr.position), expr.position)
-                }
-            }
-            DataType.WORD -> {
-                if(amount>16) {
-                    expr.right = NumericLiteralValue.optimalInteger(16, expr.right.position)
-                    return expr
-                } else if(amount>=8) {
-                    optimizationsDone++
-                    val msbAsByte = TypecastExpression(
-                            FunctionCall(IdentifierReference(listOf("msb"), expr.position), mutableListOf(expr.left), expr.position),
-                            DataType.BYTE,
-                            true, expr.position)
-                    if(amount==8)
-                        return msbAsByte
-                    return BinaryExpression(msbAsByte, ">>", NumericLiteralValue.optimalInteger(amount-8, expr.position), expr.position)
-                }
-            }
-            else -> {}
-        }
-        return expr
-    }
-}

compiler/src/prog8/optimizer/StatementOptimizer.kt

@@ -1,12 +1,12 @@
 package prog8.optimizer
 
 import prog8.ast.INameScope
-import prog8.ast.Module
 import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
-import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.processing.AstWalker
+import prog8.ast.processing.IAstModification
 import prog8.ast.processing.IAstVisitor
 import prog8.ast.statements.*
 import prog8.compiler.target.CompilationTarget
@@ -16,93 +16,41 @@ import kotlin.math.floor
 
 /*
     TODO: remove unreachable code after return and exit()
-    TODO: proper inlining of tiny subroutines (at first, restrict to subs without parameters and variables in them, and build it up from there: correctly renaming/relocating all variables in them and refs to those as well)
 */
 
 
 internal class StatementOptimizer(private val program: Program,
-                                  private val errors: ErrorReporter) : IAstModifyingVisitor {
-    var optimizationsDone: Int = 0
-        private set
+                                  private val errors: ErrorReporter) : AstWalker() {
 
-    private val pureBuiltinFunctions = BuiltinFunctions.filter { it.value.pure }
+    private val noModifications = emptyList<IAstModification>()
     private val callgraph = CallGraph(program)
-    private val vardeclsToRemove = mutableListOf<VarDecl>()
+    private val pureBuiltinFunctions = BuiltinFunctions.filter { it.value.pure }
 
-    override fun visit(program: Program) {
-        removeUnusedCode(callgraph)
-        super.visit(program)
-
-        for(decl in vardeclsToRemove) {
-            decl.definingScope().remove(decl)
-        }
-    }
-
-    private fun removeUnusedCode(callgraph: CallGraph) {
-        // remove all subroutines that aren't called, or are empty
-        val removeSubroutines = mutableSetOf<Subroutine>()
-        val entrypoint = program.entrypoint()
-        program.modules.forEach {
-            callgraph.forAllSubroutines(it) { sub ->
-                if (sub !== entrypoint && !sub.keepAlways && (sub.calledBy.isEmpty() || (sub.containsNoCodeNorVars() && !sub.isAsmSubroutine)))
-                    removeSubroutines.add(sub)
-            }
-        }
-
-        if (removeSubroutines.isNotEmpty()) {
-            removeSubroutines.forEach {
-                it.definingScope().remove(it)
-            }
-        }
-
-        val removeBlocks = mutableSetOf<Block>()
-        program.modules.flatMap { it.statements }.filterIsInstance<Block>().forEach { block ->
-            if (block.containsNoCodeNorVars() && "force_output" !in block.options())
-                removeBlocks.add(block)
-        }
-
-        if (removeBlocks.isNotEmpty()) {
-            removeBlocks.forEach { it.definingScope().remove(it) }
-        }
-
-        // remove modules that are not imported, or are empty (unless it's a library modules)
-        val removeModules = mutableSetOf<Module>()
-        program.modules.forEach {
-            if (!it.isLibraryModule && (it.importedBy.isEmpty() || it.containsNoCodeNorVars()))
-                removeModules.add(it)
-        }
-
-        if (removeModules.isNotEmpty()) {
-            program.modules.removeAll(removeModules)
-        }
-    }
-
-    override fun visit(block: Block): Statement {
+    override fun after(block: Block, parent: Node): Iterable<IAstModification> {
         if("force_output" !in block.options()) {
             if (block.containsNoCodeNorVars()) {
-                optimizationsDone++
                 errors.warn("removing empty block '${block.name}'", block.position)
-                return NopStatement.insteadOf(block)
+                return listOf(IAstModification.Remove(block, parent))
             }
 
             if (block !in callgraph.usedSymbols) {
-                optimizationsDone++
                 errors.warn("removing unused block '${block.name}'", block.position)
-                return NopStatement.insteadOf(block)  // remove unused block
+                return listOf(IAstModification.Remove(block, parent))
             }
         }
-
-        return super.visit(block)
+        return noModifications
     }
 
-    override fun visit(subroutine: Subroutine): Statement {
-        super.visit(subroutine)
+    override fun after(subroutine: Subroutine, parent: Node): Iterable<IAstModification> {
         val forceOutput = "force_output" in subroutine.definingBlock().options()
         if(subroutine.asmAddress==null && !forceOutput) {
             if(subroutine.containsNoCodeNorVars()) {
                 errors.warn("removing empty subroutine '${subroutine.name}'", subroutine.position)
-                optimizationsDone++
-                return NopStatement.insteadOf(subroutine)
+                val removals = callgraph.calledBy.getValue(subroutine).map {
+                    IAstModification.Remove(it, it.parent)
+                }.toMutableList()
+                removals += IAstModification.Remove(subroutine, parent)
+                return removals
             }
         }
 
@@ -113,24 +61,359 @@ internal class StatementOptimizer(private val program: Program,
 
         if(subroutine !in callgraph.usedSymbols && !forceOutput) {
             errors.warn("removing unused subroutine '${subroutine.name}'", subroutine.position)
-            optimizationsDone++
-            return NopStatement.insteadOf(subroutine)
+            return listOf(IAstModification.Remove(subroutine, parent))
         }
 
-        visitStatements(subroutine.statements)
-        return subroutine
+        return noModifications
     }
 
-    override fun visit(decl: VarDecl): Statement {
+    override fun after(scope: AnonymousScope, parent: Node): Iterable<IAstModification> {
+        val linesToRemove = deduplicateAssignments(scope.statements)
+        return linesToRemove.reversed().map { IAstModification.Remove(scope.statements[it], scope) }
+    }
+
+    override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
         val forceOutput = "force_output" in decl.definingBlock().options()
         if(decl !in callgraph.usedSymbols && !forceOutput) {
             if(decl.type == VarDeclType.VAR)
-                errors.warn("removing unused variable ${decl.type} '${decl.name}'", decl.position)
-            optimizationsDone++
-            return NopStatement.insteadOf(decl)
+                errors.warn("removing unused variable '${decl.name}'", decl.position)
+
+            return listOf(IAstModification.Remove(decl, parent))
         }
 
-        return super.visit(decl)
+        return noModifications
+    }
+
+    override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
+        if(functionCallStatement.target.nameInSource.size==1 && functionCallStatement.target.nameInSource[0] in BuiltinFunctions) {
+            val functionName = functionCallStatement.target.nameInSource[0]
+            if (functionName in pureBuiltinFunctions) {
+                errors.warn("statement has no effect (function return value is discarded)", functionCallStatement.position)
+                return listOf(IAstModification.Remove(functionCallStatement, parent))
+            }
+        }
+
+        // printing a literal string of just 2 or 1 characters is replaced by directly outputting those characters
+        // this is a C-64 specific optimization
+        if(functionCallStatement.target.nameInSource==listOf("c64scr", "print")) {
+            val arg = functionCallStatement.args.single()
+            val stringVar: IdentifierReference?
+            stringVar = if(arg is AddressOf) {
+                arg.identifier
+            } else {
+                arg as? IdentifierReference
+            }
+            if(stringVar!=null) {
+                val vardecl = stringVar.targetVarDecl(program.namespace)!!
+                val string = vardecl.value!! as StringLiteralValue
+                val pos = functionCallStatement.position
+                if(string.value.length==1) {
+                    val firstCharEncoded = CompilationTarget.encodeString(string.value, string.altEncoding)[0]
+                    val chrout = FunctionCallStatement(
+                            IdentifierReference(listOf("c64", "CHROUT"), pos),
+                            mutableListOf(NumericLiteralValue(DataType.UBYTE, firstCharEncoded.toInt(), pos)),
+                            functionCallStatement.void, pos
+                    )
+                    return listOf(IAstModification.ReplaceNode(functionCallStatement, chrout, parent))
+                } else if(string.value.length==2) {
+                    val firstTwoCharsEncoded = CompilationTarget.encodeString(string.value.take(2), string.altEncoding)
+                    val chrout1 = FunctionCallStatement(
+                            IdentifierReference(listOf("c64", "CHROUT"), pos),
+                            mutableListOf(NumericLiteralValue(DataType.UBYTE, firstTwoCharsEncoded[0].toInt(), pos)),
+                            functionCallStatement.void, pos
+                    )
+                    val chrout2 = FunctionCallStatement(
+                            IdentifierReference(listOf("c64", "CHROUT"), pos),
+                            mutableListOf(NumericLiteralValue(DataType.UBYTE, firstTwoCharsEncoded[1].toInt(), pos)),
+                            functionCallStatement.void, pos
+                    )
+                    val anonscope = AnonymousScope(mutableListOf(), pos)
+                    anonscope.statements.add(chrout1)
+                    anonscope.statements.add(chrout2)
+                    return listOf(IAstModification.ReplaceNode(functionCallStatement, anonscope, parent))
+                }
+            }
+        }
+
+        // if the first instruction in the called subroutine is a return statement, remove the jump altogeter
+        val subroutine = functionCallStatement.target.targetSubroutine(program.namespace)
+        if(subroutine!=null) {
+            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
+            if(first is ReturnFromIrq || first is Return)
+                return listOf(IAstModification.Remove(functionCallStatement, parent))
+        }
+
+        return noModifications
+    }
+
+    override fun before(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> {
+        // if the first instruction in the called subroutine is a return statement with constant value, replace with the constant value
+        val subroutine = functionCall.target.targetSubroutine(program.namespace)
+        if(subroutine!=null) {
+            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
+            if(first is Return && first.value!=null) {
+                val constval = first.value?.constValue(program)
+                if(constval!=null)
+                    return listOf(IAstModification.ReplaceNode(functionCall, constval, parent))
+            }
+        }
+        return noModifications
+    }
+
+    override fun after(ifStatement: IfStatement, parent: Node): Iterable<IAstModification> {
+        // remove empty if statements
+        if(ifStatement.truepart.containsNoCodeNorVars() && ifStatement.elsepart.containsNoCodeNorVars())
+            return listOf(IAstModification.Remove(ifStatement, parent))
+
+        // empty true part? switch with the else part
+        if(ifStatement.truepart.containsNoCodeNorVars() && ifStatement.elsepart.containsCodeOrVars()) {
+            val invertedCondition = PrefixExpression("not", ifStatement.condition, ifStatement.condition.position)
+            val emptyscope = AnonymousScope(mutableListOf(), ifStatement.elsepart.position)
+            val truepart = AnonymousScope(ifStatement.elsepart.statements, ifStatement.truepart.position)
+            return listOf(
+                    IAstModification.ReplaceNode(ifStatement.condition, invertedCondition, ifStatement),
+                    IAstModification.ReplaceNode(ifStatement.truepart, truepart, ifStatement),
+                    IAstModification.ReplaceNode(ifStatement.elsepart, emptyscope, ifStatement)
+            )
+        }
+
+        val constvalue = ifStatement.condition.constValue(program)
+        if(constvalue!=null) {
+            return if(constvalue.asBooleanValue){
+                // always true -> keep only if-part
+                errors.warn("condition is always true", ifStatement.position)
+                listOf(IAstModification.ReplaceNode(ifStatement, ifStatement.truepart, parent))
+            } else {
+                // always false -> keep only else-part
+                errors.warn("condition is always false", ifStatement.position)
+                listOf(IAstModification.ReplaceNode(ifStatement, ifStatement.elsepart, parent))
+            }
+        }
+
+        return noModifications
+    }
+
+    override fun after(forLoop: ForLoop, parent: Node): Iterable<IAstModification> {
+        if(forLoop.body.containsNoCodeNorVars()) {
+            errors.warn("removing empty for loop", forLoop.position)
+            return listOf(IAstModification.Remove(forLoop, parent))
+        } else if(forLoop.body.statements.size==1) {
+            val loopvar = forLoop.body.statements[0] as? VarDecl
+            if(loopvar!=null && loopvar.name==forLoop.loopVar.nameInSource.singleOrNull()) {
+                // remove empty for loop (only loopvar decl in it)
+                return listOf(IAstModification.Remove(forLoop, parent))
+            }
+        }
+
+        val range = forLoop.iterable as? RangeExpr
+        if(range!=null) {
+            if(range.size()==1) {
+                // for loop over a (constant) range of just a single value-- optimize the loop away
+                // loopvar/reg = range value , follow by block
+                val scope = AnonymousScope(mutableListOf(), forLoop.position)
+                scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), null, range.from, forLoop.position))
+                scope.statements.addAll(forLoop.body.statements)
+                return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
+            }
+        }
+        val iterable = (forLoop.iterable as? IdentifierReference)?.targetVarDecl(program.namespace)
+        if(iterable!=null) {
+            if(iterable.datatype==DataType.STR) {
+                val sv = iterable.value as StringLiteralValue
+                val size = sv.value.length
+                if(size==1) {
+                    // loop over string of length 1 -> just assign the single character
+                    val character = CompilationTarget.encodeString(sv.value, sv.altEncoding)[0]
+                    val byte = NumericLiteralValue(DataType.UBYTE, character, iterable.position)
+                    val scope = AnonymousScope(mutableListOf(), forLoop.position)
+                    scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), null, byte, forLoop.position))
+                    scope.statements.addAll(forLoop.body.statements)
+                    return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
+                }
+            }
+            else if(iterable.datatype in ArrayDatatypes) {
+                val size = iterable.arraysize!!.size()
+                if(size==1) {
+                    // loop over array of length 1 -> just assign the single value
+                    val av = (iterable.value as ArrayLiteralValue).value[0].constValue(program)?.number
+                    if(av!=null) {
+                        val scope = AnonymousScope(mutableListOf(), forLoop.position)
+                        scope.statements.add(Assignment(
+                                AssignTarget(forLoop.loopVar, null, null, forLoop.position), null, NumericLiteralValue.optimalInteger(av.toInt(), iterable.position),
+                                forLoop.position))
+                        scope.statements.addAll(forLoop.body.statements)
+                        return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
+                    }
+                }
+            }
+        }
+
+        return noModifications
+    }
+
+    override fun before(untilLoop: UntilLoop, parent: Node): Iterable<IAstModification> {
+        val constvalue = untilLoop.untilCondition.constValue(program)
+        if(constvalue!=null) {
+            if(constvalue.asBooleanValue) {
+                // always true -> keep only the statement block (if there are no continue and break statements)
+                errors.warn("condition is always true", untilLoop.untilCondition.position)
+                if(!hasContinueOrBreak(untilLoop.body))
+                    return listOf(IAstModification.ReplaceNode(untilLoop, untilLoop.body, parent))
+            } else {
+                // always false
+                val forever = RepeatLoop(null, untilLoop.body, untilLoop.position)
+                return listOf(IAstModification.ReplaceNode(untilLoop, forever, parent))
+            }
+        }
+        return noModifications
+    }
+
+    override fun before(whileLoop: WhileLoop, parent: Node): Iterable<IAstModification> {
+        val constvalue = whileLoop.condition.constValue(program)
+        if(constvalue!=null) {
+            return if(constvalue.asBooleanValue) {
+                // always true
+                val forever = RepeatLoop(null, whileLoop.body, whileLoop.position)
+                listOf(IAstModification.ReplaceNode(whileLoop, forever, parent))
+            } else {
+                // always false -> remove the while statement altogether
+                errors.warn("condition is always false", whileLoop.condition.position)
+                listOf(IAstModification.Remove(whileLoop, parent))
+            }
+        }
+        return noModifications
+    }
+
+    override fun after(repeatLoop: RepeatLoop, parent: Node): Iterable<IAstModification> {
+        val iter = repeatLoop.iterations
+        if(iter!=null) {
+            if(repeatLoop.body.containsNoCodeNorVars()) {
+                errors.warn("empty loop removed", repeatLoop.position)
+                return listOf(IAstModification.Remove(repeatLoop, parent))
+            }
+            val iterations = iter.constValue(program)?.number?.toInt()
+            if (iterations == 0) {
+                errors.warn("iterations is always 0, removed loop", iter.position)
+                return listOf(IAstModification.Remove(repeatLoop, parent))
+            }
+            if (iterations == 1)
+                errors.warn("iterations is always 1", iter.position)
+        }
+        return noModifications
+    }
+
+    override fun after(whenStatement: WhenStatement, parent: Node): Iterable<IAstModification> {
+        // remove empty choices
+        class ChoiceRemover(val choice: WhenChoice) : IAstModification {
+            override fun perform() {
+                whenStatement.choices.remove(choice)
+            }
+        }
+        return whenStatement.choices
+                .filter { !it.statements.containsCodeOrVars() }
+                .map { ChoiceRemover(it) }
+    }
+
+    override fun after(jump: Jump, parent: Node): Iterable<IAstModification> {
+        // if the jump is to the next statement, remove the jump
+        val scope = jump.definingScope()
+        val label = jump.identifier?.targetStatement(scope)
+        if(label!=null && scope.statements.indexOf(label) == scope.statements.indexOf(jump)+1)
+            return listOf(IAstModification.Remove(jump, parent))
+
+        return noModifications
+    }
+
+    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
+        if(assignment.aug_op!=null)
+            throw FatalAstException("augmented assignments should have been converted to normal assignments before this optimizer: $assignment")
+
+        // remove assignments to self
+        if(assignment.target isSameAs assignment.value) {
+            if(assignment.target.isNotMemory(program.namespace))
+                return listOf(IAstModification.Remove(assignment, parent))
+        }
+
+        val targetIDt = assignment.target.inferType(program, assignment)
+        if(!targetIDt.isKnown)
+            throw FatalAstException("can't infer type of assignment target")
+
+
+        // optimize binary expressions a bit
+        val targetDt = targetIDt.typeOrElse(DataType.STRUCT)
+        val bexpr=assignment.value as? BinaryExpression
+        if(bexpr!=null) {
+            val cv = bexpr.right.constValue(program)?.number?.toDouble()
+            if (cv != null && assignment.target isSameAs bexpr.left) {
+                // assignments of the form:  X = X <operator> <expr>
+                // remove assignments that have no effect (such as X=X+0)
+                // optimize/rewrite some other expressions
+                val vardeclDt = (assignment.target.identifier?.targetVarDecl(program.namespace))?.type
+                when (bexpr.operator) {
+                    "+" -> {
+                        if (cv == 0.0) {
+                            return listOf(IAstModification.Remove(assignment, parent))
+                        } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
+                            if ((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt != VarDeclType.MEMORY && cv in 1.0..8.0)) {
+                                // replace by several INCs (a bit less when dealing with memory targets)
+                                val incs = AnonymousScope(mutableListOf(), assignment.position)
+                                repeat(cv.toInt()) {
+                                    incs.statements.add(PostIncrDecr(assignment.target, "++", assignment.position))
+                                }
+                                return listOf(IAstModification.ReplaceNode(assignment, incs, parent))
+                            }
+                        }
+                    }
+                    "-" -> {
+                        if (cv == 0.0) {
+                            return listOf(IAstModification.Remove(assignment, parent))
+                        } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
+                            if ((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt != VarDeclType.MEMORY && cv in 1.0..8.0)) {
+                                // replace by several DECs (a bit less when dealing with memory targets)
+                                val decs = AnonymousScope(mutableListOf(), assignment.position)
+                                repeat(cv.toInt()) {
+                                    decs.statements.add(PostIncrDecr(assignment.target, "--", assignment.position))
+                                }
+                                return listOf(IAstModification.ReplaceNode(assignment, decs, parent))
+                            }
+                        }
+                    }
+                    "*" -> if (cv == 1.0) return listOf(IAstModification.Remove(assignment, parent))
+                    "/" -> if (cv == 1.0) return listOf(IAstModification.Remove(assignment, parent))
+                    "**" -> if (cv == 1.0) return listOf(IAstModification.Remove(assignment, parent))
+                    "|" -> if (cv == 0.0) return listOf(IAstModification.Remove(assignment, parent))
+                    "^" -> if (cv == 0.0) return listOf(IAstModification.Remove(assignment, parent))
+                    "<<" -> {
+                        if (cv == 0.0)
+                            return listOf(IAstModification.Remove(assignment, parent))
+                        // replace by in-place lsl(...) call
+                        val scope = AnonymousScope(mutableListOf(), assignment.position)
+                        var numshifts = cv.toInt()
+                        while (numshifts > 0) {
+                            scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsl"), assignment.position),
+                                    mutableListOf(bexpr.left), true, assignment.position))
+                            numshifts--
+                        }
+                        return listOf(IAstModification.ReplaceNode(assignment, scope, parent))
+                    }
+                    ">>" -> {
+                        if (cv == 0.0)
+                            return listOf(IAstModification.Remove(assignment, parent))
+                        // replace by in-place lsr(...) call
+                        val scope = AnonymousScope(mutableListOf(), assignment.position)
+                        var numshifts = cv.toInt()
+                        while (numshifts > 0) {
+                            scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsr"), assignment.position),
+                                    mutableListOf(bexpr.left), true, assignment.position))
+                            numshifts--
+                        }
+                        return listOf(IAstModification.ReplaceNode(assignment, scope, parent))
+                    }
+                }
+
+            }
+        }
+        return noModifications
     }
 
     private fun deduplicateAssignments(statements: List<Statement>): MutableList<Int> {
@@ -158,223 +441,21 @@ internal class StatementOptimizer(private val program: Program,
         return linesToRemove
     }
 
-    override fun visit(functionCallStatement: FunctionCallStatement): Statement {
-        if(functionCallStatement.target.nameInSource.size==1 && functionCallStatement.target.nameInSource[0] in BuiltinFunctions) {
-            val functionName = functionCallStatement.target.nameInSource[0]
-            if (functionName in pureBuiltinFunctions) {
-                errors.warn("statement has no effect (function return value is discarded)", functionCallStatement.position)
-                optimizationsDone++
-                return NopStatement.insteadOf(functionCallStatement)
-            }
-        }
-
-        if(functionCallStatement.target.nameInSource==listOf("c64scr", "print") ||
-                functionCallStatement.target.nameInSource==listOf("c64scr", "print_p")) {
-            // printing a literal string of just 2 or 1 characters is replaced by directly outputting those characters
-            val arg = functionCallStatement.args.single()
-            val stringVar: IdentifierReference?
-            stringVar = if(arg is AddressOf) {
-                arg.identifier
-            } else {
-                arg as? IdentifierReference
-            }
-            if(stringVar!=null) {
-                val vardecl = stringVar.targetVarDecl(program.namespace)!!
-                val string = vardecl.value!! as StringLiteralValue
-                if(string.value.length==1) {
-                    val firstCharEncoded = CompilationTarget.encodeString(string.value, string.altEncoding)[0]
-                    functionCallStatement.args.clear()
-                    functionCallStatement.args.add(NumericLiteralValue.optimalInteger(firstCharEncoded.toInt(), functionCallStatement.position))
-                    functionCallStatement.target = IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position)
-                    vardeclsToRemove.add(vardecl)
-                    optimizationsDone++
-                    return functionCallStatement
-                } else if(string.value.length==2) {
-                    val firstTwoCharsEncoded = CompilationTarget.encodeString(string.value.take(2), string.altEncoding)
-                    val scope = AnonymousScope(mutableListOf(), functionCallStatement.position)
-                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position),
-                            mutableListOf(NumericLiteralValue.optimalInteger(firstTwoCharsEncoded[0].toInt(), functionCallStatement.position)),
-                            functionCallStatement.void, functionCallStatement.position))
-                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position),
-                            mutableListOf(NumericLiteralValue.optimalInteger(firstTwoCharsEncoded[1].toInt(), functionCallStatement.position)),
-                            functionCallStatement.void, functionCallStatement.position))
-                    vardeclsToRemove.add(vardecl)
-                    optimizationsDone++
-                    return scope
-                }
-            }
-        }
-
-        // if it calls a subroutine,
-        // and the first instruction in the subroutine is a jump, call that jump target instead
-        // if the first instruction in the subroutine is a return statement, replace with a nop instruction
-        val subroutine = functionCallStatement.target.targetSubroutine(program.namespace)
-        if(subroutine!=null) {
-            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
-            if(first is Jump && first.identifier!=null) {
-                optimizationsDone++
-                return FunctionCallStatement(first.identifier, functionCallStatement.args, functionCallStatement.void, functionCallStatement.position)
-            }
-            if(first is ReturnFromIrq || first is Return) {
-                optimizationsDone++
-                return NopStatement.insteadOf(functionCallStatement)
-            }
-        }
-
-        return super.visit(functionCallStatement)
-    }
-
-    override fun visit(functionCall: FunctionCall): Expression {
-        // if it calls a subroutine,
-        // and the first instruction in the subroutine is a jump, call that jump target instead
-        // if the first instruction in the subroutine is a return statement with constant value, replace with the constant value
-        val subroutine = functionCall.target.targetSubroutine(program.namespace)
-        if(subroutine!=null) {
-            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
-            if(first is Jump && first.identifier!=null) {
-                optimizationsDone++
-                return FunctionCall(first.identifier, functionCall.args, functionCall.position)
-            }
-            if(first is Return && first.value!=null) {
-                val constval = first.value?.constValue(program)
-                if(constval!=null)
-                    return constval
-            }
-        }
-        return super.visit(functionCall)
-    }
-
-    override fun visit(ifStatement: IfStatement): Statement {
-        super.visit(ifStatement)
-
-        if(ifStatement.truepart.containsNoCodeNorVars() && ifStatement.elsepart.containsNoCodeNorVars()) {
-            optimizationsDone++
-            return NopStatement.insteadOf(ifStatement)
-        }
-
-        if(ifStatement.truepart.containsNoCodeNorVars() && ifStatement.elsepart.containsCodeOrVars()) {
-            // invert the condition and move else part to true part
-            ifStatement.truepart = ifStatement.elsepart
-            ifStatement.elsepart = AnonymousScope(mutableListOf(), ifStatement.elsepart.position)
-            ifStatement.condition = PrefixExpression("not", ifStatement.condition, ifStatement.condition.position)
-            optimizationsDone++
-            return ifStatement
-        }
-
-        val constvalue = ifStatement.condition.constValue(program)
-        if(constvalue!=null) {
-            return if(constvalue.asBooleanValue){
-                // always true -> keep only if-part
-                errors.warn("condition is always true", ifStatement.position)
-                optimizationsDone++
-                ifStatement.truepart
-            } else {
-                // always false -> keep only else-part
-                errors.warn("condition is always false", ifStatement.position)
-                optimizationsDone++
-                ifStatement.elsepart
-            }
-        }
-        return ifStatement
-    }
-
-    override fun visit(forLoop: ForLoop): Statement {
-        super.visit(forLoop)
-        if(forLoop.body.containsNoCodeNorVars()) {
-            // remove empty for loop
-            optimizationsDone++
-            return NopStatement.insteadOf(forLoop)
-        } else if(forLoop.body.statements.size==1) {
-            val loopvar = forLoop.body.statements[0] as? VarDecl
-            if(loopvar!=null && loopvar.name==forLoop.loopVar?.nameInSource?.singleOrNull()) {
-                // remove empty for loop
-                optimizationsDone++
-                return NopStatement.insteadOf(forLoop)
-            }
-        }
-
-
-        val range = forLoop.iterable as? RangeExpr
-        if(range!=null) {
-            if(range.size()==1) {
-                // for loop over a (constant) range of just a single value-- optimize the loop away
-                // loopvar/reg = range value , follow by block
-                val assignment = Assignment(AssignTarget(forLoop.loopRegister, forLoop.loopVar, null, null, forLoop.position), null, range.from, forLoop.position)
-                forLoop.body.statements.add(0, assignment)
-                optimizationsDone++
-                return forLoop.body
-            }
-        }
-        return forLoop
-    }
-
-    override fun visit(whileLoop: WhileLoop): Statement {
-        super.visit(whileLoop)
-        val constvalue = whileLoop.condition.constValue(program)
-        if(constvalue!=null) {
-            return if(constvalue.asBooleanValue){
-                // always true -> print a warning, and optimize into a forever-loop
-                errors.warn("condition is always true", whileLoop.condition.position)
-                optimizationsDone++
-                ForeverLoop(whileLoop.body, whileLoop.position)
-            } else {
-                // always false -> remove the while statement altogether
-                errors.warn("condition is always false", whileLoop.condition.position)
-                optimizationsDone++
-                NopStatement.insteadOf(whileLoop)
-            }
-        }
-        return whileLoop
-    }
-
-    override fun visit(repeatLoop: RepeatLoop): Statement {
-        super.visit(repeatLoop)
-        val constvalue = repeatLoop.untilCondition.constValue(program)
-        if(constvalue!=null) {
-            return if(constvalue.asBooleanValue){
-                // always true -> keep only the statement block (if there are no continue and break statements)
-                errors.warn("condition is always true", repeatLoop.untilCondition.position)
-                if(hasContinueOrBreak(repeatLoop.body))
-                    repeatLoop
-                else {
-                    optimizationsDone++
-                    repeatLoop.body
-                }
-            } else {
-                // always false -> print a warning, and optimize into a forever loop
-                errors.warn("condition is always false", repeatLoop.untilCondition.position)
-                optimizationsDone++
-                ForeverLoop(repeatLoop.body, repeatLoop.position)
-            }
-        }
-        return repeatLoop
-    }
-
-    override fun visit(whenStatement: WhenStatement): Statement {
-        val choices = whenStatement.choices.toList()
-        for(choice in choices) {
-            if(choice.statements.containsNoCodeNorVars())
-                whenStatement.choices.remove(choice)
-        }
-        return super.visit(whenStatement)
-    }
-
     private fun hasContinueOrBreak(scope: INameScope): Boolean {
 
-        class Searcher: IAstModifyingVisitor
+        class Searcher: IAstVisitor
         {
             var count=0
 
-            override fun visit(breakStmt: Break): Statement {
+            override fun visit(breakStmt: Break) {
                 count++
-                return super.visit(breakStmt)
             }
 
-            override fun visit(contStmt: Continue): Statement {
+            override fun visit(contStmt: Continue) {
                 count++
-                return super.visit(contStmt)
             }
         }
+
         val s=Searcher()
         for(stmt in scope.statements) {
             stmt.accept(s)
@@ -384,237 +465,4 @@ internal class StatementOptimizer(private val program: Program,
         return s.count > 0
     }
 
-    override fun visit(jump: Jump): Statement {
-        val subroutine = jump.identifier?.targetSubroutine(program.namespace)
-        if(subroutine!=null) {
-            // if the first instruction in the subroutine is another jump, shortcut this one
-            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
-            if(first is Jump) {
-                optimizationsDone++
-                return first
-            }
-        }
-
-        // if the jump is to the next statement, remove the jump
-        val scope = jump.definingScope()
-        val label = jump.identifier?.targetStatement(scope)
-        if(label!=null) {
-            if(scope.statements.indexOf(label) == scope.statements.indexOf(jump)+1) {
-                optimizationsDone++
-                return NopStatement.insteadOf(jump)
-            }
-        }
-
-        return jump
-    }
-
-    override fun visit(assignment: Assignment): Statement {
-        if(assignment.aug_op!=null)
-            throw AstException("augmented assignments should have been converted to normal assignments before this optimizer: $assignment")
-
-        if(assignment.target isSameAs assignment.value) {
-            if(assignment.target.isNotMemory(program.namespace)) {
-                optimizationsDone++
-                return NopStatement.insteadOf(assignment)
-            }
-        }
-        val targetIDt = assignment.target.inferType(program, assignment)
-        if(!targetIDt.isKnown)
-            throw FatalAstException("can't infer type of assignment target")
-        val targetDt = targetIDt.typeOrElse(DataType.STRUCT)
-        val bexpr=assignment.value as? BinaryExpression
-        if(bexpr!=null) {
-            val cv = bexpr.right.constValue(program)?.number?.toDouble()
-            if (cv == null) {
-                if (bexpr.operator == "+" && targetDt != DataType.FLOAT) {
-                    if (bexpr.left isSameAs bexpr.right && assignment.target isSameAs bexpr.left) {
-                        bexpr.operator = "*"
-                        bexpr.right = NumericLiteralValue.optimalInteger(2, assignment.value.position)
-                        optimizationsDone++
-                        return assignment
-                    }
-                }
-            } else {
-                if (assignment.target isSameAs bexpr.left) {
-                    // remove assignments that have no effect  X=X , X+=0, X-=0, X*=1, X/=1, X//=1, A |= 0, A ^= 0, A<<=0, etc etc
-                    // A = A <operator> B
-                    val vardeclDt = (assignment.target.identifier?.targetVarDecl(program.namespace))?.type
-
-                    when (bexpr.operator) {
-                        "+" -> {
-                            if (cv == 0.0) {
-                                optimizationsDone++
-                                return NopStatement.insteadOf(assignment)
-                            } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
-                                if ((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt != VarDeclType.MEMORY && cv in 1.0..8.0)) {
-                                    // replace by several INCs (a bit less when dealing with memory targets)
-                                    val decs = AnonymousScope(mutableListOf(), assignment.position)
-                                    repeat(cv.toInt()) {
-                                        decs.statements.add(PostIncrDecr(assignment.target, "++", assignment.position))
-                                    }
-                                    return decs
-                                }
-                            }
-                        }
-                        "-" -> {
-                            if (cv == 0.0) {
-                                optimizationsDone++
-                                return NopStatement.insteadOf(assignment)
-                            } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
-                                if ((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt != VarDeclType.MEMORY && cv in 1.0..8.0)) {
-                                    // replace by several DECs (a bit less when dealing with memory targets)
-                                    val decs = AnonymousScope(mutableListOf(), assignment.position)
-                                    repeat(cv.toInt()) {
-                                        decs.statements.add(PostIncrDecr(assignment.target, "--", assignment.position))
-                                    }
-                                    return decs
-                                }
-                            }
-                        }
-                        "*" -> if (cv == 1.0) {
-                            optimizationsDone++
-                            return NopStatement.insteadOf(assignment)
-                        }
-                        "/" -> if (cv == 1.0) {
-                            optimizationsDone++
-                            return NopStatement.insteadOf(assignment)
-                        }
-                        "**" -> if (cv == 1.0) {
-                            optimizationsDone++
-                            return NopStatement.insteadOf(assignment)
-                        }
-                        "|" -> if (cv == 0.0) {
-                            optimizationsDone++
-                            return NopStatement.insteadOf(assignment)
-                        }
-                        "^" -> if (cv == 0.0) {
-                            optimizationsDone++
-                            return NopStatement.insteadOf(assignment)
-                        }
-                        "<<" -> {
-                            if (cv == 0.0) {
-                                optimizationsDone++
-                                return NopStatement.insteadOf(assignment)
-                            }
-                            if (((targetDt == DataType.UWORD || targetDt == DataType.WORD) && cv > 15.0) ||
-                                    ((targetDt == DataType.UBYTE || targetDt == DataType.BYTE) && cv > 7.0)) {
-                                assignment.value = NumericLiteralValue.optimalInteger(0, assignment.value.position)
-                                assignment.value.linkParents(assignment)
-                                optimizationsDone++
-                            } else {
-                                // replace by in-place lsl(...) call
-                                val scope = AnonymousScope(mutableListOf(), assignment.position)
-                                var numshifts = cv.toInt()
-                                while (numshifts > 0) {
-                                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsl"), assignment.position),
-                                            mutableListOf(bexpr.left), true, assignment.position))
-                                    numshifts--
-                                }
-                                optimizationsDone++
-                                return scope
-                            }
-                        }
-                        ">>" -> {
-                            if (cv == 0.0) {
-                                optimizationsDone++
-                                return NopStatement.insteadOf(assignment)
-                            }
-                            if ((targetDt == DataType.UWORD && cv > 15.0) || (targetDt == DataType.UBYTE && cv > 7.0)) {
-                                assignment.value = NumericLiteralValue.optimalInteger(0, assignment.value.position)
-                                assignment.value.linkParents(assignment)
-                                optimizationsDone++
-                            } else {
-                                // replace by in-place lsr(...) call
-                                val scope = AnonymousScope(mutableListOf(), assignment.position)
-                                var numshifts = cv.toInt()
-                                while (numshifts > 0) {
-                                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsr"), assignment.position),
-                                            mutableListOf(bexpr.left), true, assignment.position))
-                                    numshifts--
-                                }
-                                optimizationsDone++
-                                return scope
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-
-        return super.visit(assignment)
-    }
-
-    override fun visit(scope: AnonymousScope): Statement {
-        val linesToRemove = deduplicateAssignments(scope.statements)
-        if(linesToRemove.isNotEmpty()) {
-            linesToRemove.reversed().forEach{scope.statements.removeAt(it)}
-        }
-        visitStatements(scope.statements)
-        return super.visit(scope)
-    }
-
-    override fun visit(label: Label): Statement {
-        // remove duplicate labels
-        val stmts = label.definingScope().statements
-        val startIdx = stmts.indexOf(label)
-        if(startIdx< stmts.lastIndex && stmts[startIdx+1] == label)
-            return NopStatement.insteadOf(label)
-
-        return super.visit(label)
-    }
-
-
-    private fun visitStatements(statements: MutableList<Statement>) {
-        // TODO remove all unreachable code statements after call to exit() or a return
-        // this is not yet correct because we still have nested subroutines
-//        val exitCallIndex = statements.indexOfFirst { it is FunctionCallStatement && it.target.nameInSource.last()=="exit" }
-//        if(exitCallIndex>=0) {
-//            while(exitCallIndex < statements.lastIndex) {
-//                val stmt  = statements[exitCallIndex+1]
-//                println("after exit() removing: $stmt")
-//                statements.removeAt(exitCallIndex+1)
-//            }
-//        }
-    }
-
-}
-
-
-
-internal class FlattenAnonymousScopesAndRemoveNops: IAstVisitor {
-    private var scopesToFlatten = mutableListOf<INameScope>()
-    private val nopStatements = mutableListOf<NopStatement>()
-
-    override fun visit(program: Program) {
-        super.visit(program)
-        for(scope in scopesToFlatten.reversed()) {
-            val namescope = scope.parent as INameScope
-            val idx = namescope.statements.indexOf(scope as Statement)
-            if(idx>=0) {
-                val nop = NopStatement.insteadOf(namescope.statements[idx])
-                nop.parent = namescope as Node
-                namescope.statements[idx] = nop
-                namescope.statements.addAll(idx, scope.statements)
-                scope.statements.forEach { it.parent = namescope }
-                visit(nop)
-            }
-        }
-
-        this.nopStatements.forEach {
-            it.definingScope().remove(it)
-        }
-    }
-
-    override fun visit(scope: AnonymousScope) {
-        if(scope.parent is INameScope) {
-            scopesToFlatten.add(scope)  // get rid of the anonymous scope
-        }
-
-        return super.visit(scope)
-    }
-
-    override fun visit(nopStatement: NopStatement) {
-        nopStatements.add(nopStatement)
-    }
 }

compiler/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -0,0 +1,38 @@
+package prog8.optimizer
+
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.processing.AstWalker
+import prog8.ast.processing.IAstModification
+import prog8.ast.statements.Block
+
+
+internal class UnusedCodeRemover: AstWalker() {
+
+    override fun before(program: Program, parent: Node): Iterable<IAstModification> {
+        val callgraph = CallGraph(program)
+        val removals = mutableListOf<IAstModification>()
+
+        // remove all subroutines that aren't called, or are empty
+        val entrypoint = program.entrypoint()
+        program.modules.forEach {
+            callgraph.forAllSubroutines(it) { sub ->
+                if (sub !== entrypoint && !sub.keepAlways && (callgraph.calledBy[sub].isNullOrEmpty() || (sub.containsNoCodeNorVars() && !sub.isAsmSubroutine)))
+                    removals.add(IAstModification.Remove(sub, sub.definingScope() as Node))
+            }
+        }
+
+        program.modules.flatMap { it.statements }.filterIsInstance<Block>().forEach { block ->
+            if (block.containsNoCodeNorVars() && "force_output" !in block.options())
+                removals.add(IAstModification.Remove(block, block.definingScope() as Node))
+        }
+
+        // remove modules that are not imported, or are empty (unless it's a library modules)
+        program.modules.forEach {
+            if (!it.isLibraryModule && (it.importedBy.isEmpty() || it.containsNoCodeNorVars()))
+                removals.add(IAstModification.Remove(it, it.parent))
+        }
+
+        return removals
+    }
+}

compiler/src/prog8/parser/ModuleParsing.kt

@@ -140,7 +140,7 @@ internal class ModuleImporter(private val errors: ErrorReporter) {
                     importModule(program, modulePath)
                 }
 
-        importedModule.checkImportedValid(errors)
+        importedModule.checkImportedValid()
         return importedModule
     }
 

compiler/src/prog8/vm/RuntimeValue.kt

@@ -1,658 +0,0 @@
-package prog8.vm
-
-import prog8.ast.base.ByteDatatypes
-import prog8.ast.base.DataType
-import prog8.ast.base.WordDatatypes
-import prog8.ast.expressions.ArrayLiteralValue
-import prog8.ast.expressions.NumericLiteralValue
-import prog8.ast.expressions.StringLiteralValue
-import prog8.vm.astvm.VmExecutionException
-import java.util.*
-import kotlin.math.abs
-import kotlin.math.pow
-
-
-/**
- * Rather than a literal value (NumericLiteralValue) that occurs in the parsed source code,
- * this runtime value can be used to *execute* the parsed Ast (or another intermediary form)
- * It contains a value of a variable during run time of the program and provides arithmetic operations on the value.
- */
-
-abstract class RuntimeValueBase(val type: DataType) {
-    abstract fun numericValue(): Number
-    abstract fun integerValue(): Int
-}
-
-
-class RuntimeValueNumeric(type: DataType, num: Number): RuntimeValueBase(type) {
-
-    val byteval: Short?
-    val wordval: Int?
-    val floatval: Double?
-    val asBoolean: Boolean
-
-    companion object {
-        fun fromLv(literalValue: NumericLiteralValue): RuntimeValueNumeric {
-            return RuntimeValueNumeric(literalValue.type, num = literalValue.number)
-        }
-    }
-
-    init {
-        when (type) {
-            DataType.UBYTE -> {
-                val inum = num.toInt()
-                require(inum in 0..255) { "invalid value for ubyte: $inum" }
-                byteval = inum.toShort()
-                wordval = null
-                floatval = null
-                asBoolean = byteval != 0.toShort()
-            }
-            DataType.BYTE -> {
-                val inum = num.toInt()
-                require(inum in -128..127) { "invalid value for byte: $inum" }
-                byteval = inum.toShort()
-                wordval = null
-                floatval = null
-                asBoolean = byteval != 0.toShort()
-            }
-            DataType.UWORD -> {
-                val inum = num.toInt()
-                require(inum in 0..65535) { "invalid value for uword: $inum" }
-                wordval = inum
-                byteval = null
-                floatval = null
-                asBoolean = wordval != 0
-            }
-            DataType.WORD -> {
-                val inum = num.toInt()
-                require(inum in -32768..32767) { "invalid value for word: $inum" }
-                wordval = inum
-                byteval = null
-                floatval = null
-                asBoolean = wordval != 0
-            }
-            DataType.FLOAT -> {
-                floatval = num.toDouble()
-                byteval = null
-                wordval = null
-                asBoolean = floatval != 0.0
-            }
-            else -> throw VmExecutionException("not a numeric value")
-        }
-    }
-
-    override fun toString(): String {
-        return when (type) {
-            DataType.UBYTE -> "ub:%02x".format(byteval)
-            DataType.BYTE -> {
-                if (byteval!! < 0)
-                    "b:-%02x".format(abs(byteval.toInt()))
-                else
-                    "b:%02x".format(byteval)
-            }
-            DataType.UWORD -> "uw:%04x".format(wordval)
-            DataType.WORD -> {
-                if (wordval!! < 0)
-                    "w:-%04x".format(abs(wordval))
-                else
-                    "w:%04x".format(wordval)
-            }
-            DataType.FLOAT -> "f:$floatval"
-            else -> "???"
-        }
-    }
-
-    override fun numericValue(): Number {
-        return when (type) {
-            in ByteDatatypes -> byteval!!
-            in WordDatatypes -> wordval!!
-            DataType.FLOAT -> floatval!!
-            else -> throw ArithmeticException("invalid datatype for numeric value: $type")
-        }
-    }
-
-    override fun integerValue(): Int {
-        return when (type) {
-            in ByteDatatypes -> byteval!!.toInt()
-            in WordDatatypes -> wordval!!
-            DataType.FLOAT -> throw ArithmeticException("float to integer loss of precision")
-            else -> throw ArithmeticException("invalid datatype for integer value: $type")
-        }
-    }
-
-    override fun hashCode(): Int = Objects.hash(byteval, wordval, floatval, type)
-
-    override fun equals(other: Any?): Boolean {
-        if (other == null || other !is RuntimeValueNumeric)
-            return false
-        return compareTo(other) == 0      // note: datatype doesn't matter
-    }
-
-    operator fun compareTo(other: RuntimeValueNumeric): Int = numericValue().toDouble().compareTo(other.numericValue().toDouble())
-
-    private fun arithResult(leftDt: DataType, result: Number, rightDt: DataType, op: String): RuntimeValueNumeric {
-        if (leftDt != rightDt)
-            throw ArithmeticException("left and right datatypes are not the same")
-        if (result.toDouble() < 0) {
-            return when (leftDt) {
-                DataType.UBYTE, DataType.UWORD -> {
-                    // storing a negative number in an unsigned one is done by storing the 2's complement instead
-                    val number = abs(result.toDouble().toInt())
-                    if (leftDt == DataType.UBYTE)
-                        RuntimeValueNumeric(DataType.UBYTE, (number xor 255) + 1)
-                    else
-                        RuntimeValueNumeric(DataType.UWORD, (number xor 65535) + 1)
-                }
-                DataType.BYTE -> {
-                    val v = result.toInt() and 255
-                    if (v < 128)
-                        RuntimeValueNumeric(DataType.BYTE, v)
-                    else
-                        RuntimeValueNumeric(DataType.BYTE, v - 256)
-                }
-                DataType.WORD -> {
-                    val v = result.toInt() and 65535
-                    if (v < 32768)
-                        RuntimeValueNumeric(DataType.WORD, v)
-                    else
-                        RuntimeValueNumeric(DataType.WORD, v - 65536)
-                }
-                DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, result)
-                else -> throw ArithmeticException("$op on non-numeric type")
-            }
-        }
-
-        return when (leftDt) {
-            DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, result.toInt() and 255)
-            DataType.BYTE -> {
-                val v = result.toInt() and 255
-                if (v < 128)
-                    RuntimeValueNumeric(DataType.BYTE, v)
-                else
-                    RuntimeValueNumeric(DataType.BYTE, v - 256)
-            }
-            DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, result.toInt() and 65535)
-            DataType.WORD -> {
-                val v = result.toInt() and 65535
-                if (v < 32768)
-                    RuntimeValueNumeric(DataType.WORD, v)
-                else
-                    RuntimeValueNumeric(DataType.WORD, v - 65536)
-            }
-            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, result)
-            else -> throw ArithmeticException("$op on non-numeric type")
-        }
-    }
-
-    fun add(other: RuntimeValueNumeric): RuntimeValueNumeric {
-        if (other.type == DataType.FLOAT && (type != DataType.FLOAT))
-            throw ArithmeticException("floating point loss of precision on type $type")
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        val result = v1.toDouble() + v2.toDouble()
-        return arithResult(type, result, other.type, "add")
-    }
-
-    fun sub(other: RuntimeValueNumeric): RuntimeValueNumeric {
-        if (other.type == DataType.FLOAT && (type != DataType.FLOAT))
-            throw ArithmeticException("floating point loss of precision on type $type")
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        val result = v1.toDouble() - v2.toDouble()
-        return arithResult(type, result, other.type, "sub")
-    }
-
-    fun mul(other: RuntimeValueNumeric): RuntimeValueNumeric {
-        if (other.type == DataType.FLOAT && (type != DataType.FLOAT))
-            throw ArithmeticException("floating point loss of precision on type $type")
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        val result = v1.toDouble() * v2.toDouble()
-        return arithResult(type, result, other.type, "mul")
-    }
-
-    fun div(other: RuntimeValueNumeric): RuntimeValueNumeric {
-        if (other.type == DataType.FLOAT && (type != DataType.FLOAT))
-            throw ArithmeticException("floating point loss of precision on type $type")
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        if (v2.toDouble() == 0.0) {
-            when (type) {
-                DataType.UBYTE -> return RuntimeValueNumeric(DataType.UBYTE, 255)
-                DataType.BYTE -> return RuntimeValueNumeric(DataType.BYTE, 127)
-                DataType.UWORD -> return RuntimeValueNumeric(DataType.UWORD, 65535)
-                DataType.WORD -> return RuntimeValueNumeric(DataType.WORD, 32767)
-                else -> {
-                }
-            }
-        }
-        val result = v1.toDouble() / v2.toDouble()
-        // NOTE: integer division returns integer result!
-        return when (type) {
-            DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, result)
-            DataType.BYTE -> RuntimeValueNumeric(DataType.BYTE, result)
-            DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, result)
-            DataType.WORD -> RuntimeValueNumeric(DataType.WORD, result)
-            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, result)
-            else -> throw ArithmeticException("div on non-numeric type")
-        }
-    }
-
-    fun remainder(other: RuntimeValueNumeric): RuntimeValueNumeric {
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        val result = v1.toDouble() % v2.toDouble()
-        return arithResult(type, result, other.type, "remainder")
-    }
-
-    fun pow(other: RuntimeValueNumeric): RuntimeValueNumeric {
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        val result = v1.toDouble().pow(v2.toDouble())
-        return arithResult(type, result, other.type, "pow")
-    }
-
-    fun shl(): RuntimeValueNumeric {
-        val v = integerValue()
-        return when (type) {
-            DataType.UBYTE -> RuntimeValueNumeric(type, (v shl 1) and 255)
-            DataType.UWORD -> RuntimeValueNumeric(type, (v shl 1) and 65535)
-            DataType.BYTE -> {
-                val value = v shl 1
-                if (value < 128)
-                    RuntimeValueNumeric(type, value)
-                else
-                    RuntimeValueNumeric(type, value - 256)
-            }
-            DataType.WORD -> {
-                val value = v shl 1
-                if (value < 32768)
-                    RuntimeValueNumeric(type, value)
-                else
-                    RuntimeValueNumeric(type, value - 65536)
-            }
-            else -> throw ArithmeticException("invalid type for shl: $type")
-        }
-    }
-
-    fun shr(): RuntimeValueNumeric {
-        val v = integerValue()
-        return when (type) {
-            DataType.UBYTE -> RuntimeValueNumeric(type, v ushr 1)
-            DataType.BYTE -> RuntimeValueNumeric(type, v shr 1)
-            DataType.UWORD -> RuntimeValueNumeric(type, v ushr 1)
-            DataType.WORD -> RuntimeValueNumeric(type, v shr 1)
-            else -> throw ArithmeticException("invalid type for shr: $type")
-        }
-    }
-
-    fun rol(carry: Boolean): Pair<RuntimeValueNumeric, Boolean> {
-        // 9 or 17 bit rotate left (with carry))
-        return when (type) {
-            DataType.UBYTE, DataType.BYTE -> {
-                val v = byteval!!.toInt()
-                val newCarry = (v and 0x80) != 0
-                val newval = (v and 0x7f shl 1) or (if (carry) 1 else 0)
-                Pair(RuntimeValueNumeric(DataType.UBYTE, newval), newCarry)
-            }
-            DataType.UWORD, DataType.WORD -> {
-                val v = wordval!!
-                val newCarry = (v and 0x8000) != 0
-                val newval = (v and 0x7fff shl 1) or (if (carry) 1 else 0)
-                Pair(RuntimeValueNumeric(DataType.UWORD, newval), newCarry)
-            }
-            else -> throw ArithmeticException("rol can only work on byte/word")
-        }
-    }
-
-    fun ror(carry: Boolean): Pair<RuntimeValueNumeric, Boolean> {
-        // 9 or 17 bit rotate right (with carry)
-        return when (type) {
-            DataType.UBYTE, DataType.BYTE -> {
-                val v = byteval!!.toInt()
-                val newCarry = v and 1 != 0
-                val newval = (v ushr 1) or (if (carry) 0x80 else 0)
-                Pair(RuntimeValueNumeric(DataType.UBYTE, newval), newCarry)
-            }
-            DataType.UWORD, DataType.WORD -> {
-                val v = wordval!!
-                val newCarry = v and 1 != 0
-                val newval = (v ushr 1) or (if (carry) 0x8000 else 0)
-                Pair(RuntimeValueNumeric(DataType.UWORD, newval), newCarry)
-            }
-            else -> throw ArithmeticException("ror2 can only work on byte/word")
-        }
-    }
-
-    fun rol2(): RuntimeValueNumeric {
-        // 8 or 16 bit rotate left
-        return when (type) {
-            DataType.UBYTE, DataType.BYTE -> {
-                val v = byteval!!.toInt()
-                val carry = (v and 0x80) ushr 7
-                val newval = (v and 0x7f shl 1) or carry
-                RuntimeValueNumeric(DataType.UBYTE, newval)
-            }
-            DataType.UWORD, DataType.WORD -> {
-                val v = wordval!!
-                val carry = (v and 0x8000) ushr 15
-                val newval = (v and 0x7fff shl 1) or carry
-                RuntimeValueNumeric(DataType.UWORD, newval)
-            }
-            else -> throw ArithmeticException("rol2 can only work on byte/word")
-        }
-    }
-
-    fun ror2(): RuntimeValueNumeric {
-        // 8 or 16 bit rotate right
-        return when (type) {
-            DataType.UBYTE, DataType.BYTE -> {
-                val v = byteval!!.toInt()
-                val carry = v and 1 shl 7
-                val newval = (v ushr 1) or carry
-                RuntimeValueNumeric(DataType.UBYTE, newval)
-            }
-            DataType.UWORD, DataType.WORD -> {
-                val v = wordval!!
-                val carry = v and 1 shl 15
-                val newval = (v ushr 1) or carry
-                RuntimeValueNumeric(DataType.UWORD, newval)
-            }
-            else -> throw ArithmeticException("ror2 can only work on byte/word")
-        }
-    }
-
-    fun neg(): RuntimeValueNumeric {
-        return when (type) {
-            DataType.BYTE -> RuntimeValueNumeric(DataType.BYTE, -(byteval!!))
-            DataType.WORD -> RuntimeValueNumeric(DataType.WORD, -(wordval!!))
-            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, -(floatval)!!)
-            else -> throw ArithmeticException("neg can only work on byte/word/float")
-        }
-    }
-
-    fun abs(): RuntimeValueNumeric {
-        return when (type) {
-            DataType.BYTE -> RuntimeValueNumeric(DataType.BYTE, abs(byteval!!.toInt()))
-            DataType.WORD -> RuntimeValueNumeric(DataType.WORD, abs(wordval!!))
-            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, abs(floatval!!))
-            else -> throw ArithmeticException("abs can only work on byte/word/float")
-        }
-    }
-
-    fun bitand(other: RuntimeValueNumeric): RuntimeValueNumeric {
-        val v1 = integerValue()
-        val v2 = other.integerValue()
-        val result = v1 and v2
-        return RuntimeValueNumeric(type, result)
-    }
-
-    fun bitor(other: RuntimeValueNumeric): RuntimeValueNumeric {
-        val v1 = integerValue()
-        val v2 = other.integerValue()
-        val result = v1 or v2
-        return RuntimeValueNumeric(type, result)
-    }
-
-    fun bitxor(other: RuntimeValueNumeric): RuntimeValueNumeric {
-        val v1 = integerValue()
-        val v2 = other.integerValue()
-        val result = v1 xor v2
-        return RuntimeValueNumeric(type, result)
-    }
-
-    fun and(other: RuntimeValueNumeric) = RuntimeValueNumeric(DataType.UBYTE, if (this.asBoolean && other.asBoolean) 1 else 0)
-    fun or(other: RuntimeValueNumeric) = RuntimeValueNumeric(DataType.UBYTE, if (this.asBoolean || other.asBoolean) 1 else 0)
-    fun xor(other: RuntimeValueNumeric) = RuntimeValueNumeric(DataType.UBYTE, if (this.asBoolean xor other.asBoolean) 1 else 0)
-    fun not() = RuntimeValueNumeric(DataType.UBYTE, if (this.asBoolean) 0 else 1)
-
-    fun inv(): RuntimeValueNumeric {
-        return when (type) {
-            DataType.UBYTE -> RuntimeValueNumeric(type, byteval!!.toInt().inv() and 255)
-            DataType.UWORD -> RuntimeValueNumeric(type, wordval!!.inv() and 65535)
-            DataType.BYTE -> RuntimeValueNumeric(type, byteval!!.toInt().inv())
-            DataType.WORD -> RuntimeValueNumeric(type, wordval!!.inv())
-            else -> throw ArithmeticException("inv can only work on byte/word")
-        }
-    }
-
-    fun inc(): RuntimeValueNumeric {
-        return when (type) {
-            DataType.UBYTE -> RuntimeValueNumeric(type, (byteval!! + 1) and 255)
-            DataType.UWORD -> RuntimeValueNumeric(type, (wordval!! + 1) and 65535)
-            DataType.BYTE -> {
-                val newval = byteval!! + 1
-                if (newval == 128)
-                    RuntimeValueNumeric(type, -128)
-                else
-                    RuntimeValueNumeric(type, newval)
-            }
-            DataType.WORD -> {
-                val newval = wordval!! + 1
-                if (newval == 32768)
-                    RuntimeValueNumeric(type, -32768)
-                else
-                    RuntimeValueNumeric(type, newval)
-            }
-            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, floatval!! + 1)
-            else -> throw ArithmeticException("inc can only work on numeric types")
-        }
-    }
-
-    fun dec(): RuntimeValueNumeric {
-        return when (type) {
-            DataType.UBYTE -> RuntimeValueNumeric(type, (byteval!! - 1) and 255)
-            DataType.UWORD -> RuntimeValueNumeric(type, (wordval!! - 1) and 65535)
-            DataType.BYTE -> {
-                val newval = byteval!! - 1
-                if (newval == -129)
-                    RuntimeValueNumeric(type, 127)
-                else
-                    RuntimeValueNumeric(type, newval)
-            }
-            DataType.WORD -> {
-                val newval = wordval!! - 1
-                if (newval == -32769)
-                    RuntimeValueNumeric(type, 32767)
-                else
-                    RuntimeValueNumeric(type, newval)
-            }
-            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, floatval!! - 1)
-            else -> throw ArithmeticException("dec can only work on numeric types")
-        }
-    }
-
-    fun msb(): RuntimeValueNumeric {
-        return when (type) {
-            in ByteDatatypes -> RuntimeValueNumeric(DataType.UBYTE, 0)
-            in WordDatatypes -> RuntimeValueNumeric(DataType.UBYTE, wordval!! ushr 8 and 255)
-            else -> throw ArithmeticException("msb can only work on (u)byte/(u)word")
-        }
-    }
-
-    fun cast(targetType: DataType): RuntimeValueNumeric {
-        return when (type) {
-            DataType.UBYTE -> {
-                when (targetType) {
-                    DataType.UBYTE -> this
-                    DataType.BYTE -> {
-                        val nval = byteval!!.toInt()
-                        if (nval < 128)
-                            RuntimeValueNumeric(DataType.BYTE, nval)
-                        else
-                            RuntimeValueNumeric(DataType.BYTE, nval - 256)
-                    }
-                    DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, numericValue())
-                    DataType.WORD -> {
-                        val nval = numericValue().toInt()
-                        if (nval < 32768)
-                            RuntimeValueNumeric(DataType.WORD, nval)
-                        else
-                            RuntimeValueNumeric(DataType.WORD, nval - 65536)
-                    }
-                    DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, numericValue())
-                    else -> throw ArithmeticException("invalid type cast from $type to $targetType")
-                }
-            }
-            DataType.BYTE -> {
-                when (targetType) {
-                    DataType.BYTE -> this
-                    DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, integerValue() and 255)
-                    DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, integerValue() and 65535)
-                    DataType.WORD -> RuntimeValueNumeric(DataType.WORD, integerValue())
-                    DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, numericValue())
-                    else -> throw ArithmeticException("invalid type cast from $type to $targetType")
-                }
-            }
-            DataType.UWORD -> {
-                when (targetType) {
-                    DataType.BYTE -> {
-                        val v = integerValue()
-                        if (v < 128)
-                            RuntimeValueNumeric(DataType.BYTE, v)
-                        else
-                            RuntimeValueNumeric(DataType.BYTE, v - 256)
-                    }
-                    DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, integerValue() and 255)
-                    DataType.UWORD -> this
-                    DataType.WORD -> {
-                        val v = integerValue()
-                        if (v < 32768)
-                            RuntimeValueNumeric(DataType.WORD, v)
-                        else
-                            RuntimeValueNumeric(DataType.WORD, v - 65536)
-                    }
-                    DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, numericValue())
-                    else -> throw ArithmeticException("invalid type cast from $type to $targetType")
-                }
-            }
-            DataType.WORD -> {
-                when (targetType) {
-                    DataType.BYTE -> {
-                        val v = integerValue() and 255
-                        if (v < 128)
-                            RuntimeValueNumeric(DataType.BYTE, v)
-                        else
-                            RuntimeValueNumeric(DataType.BYTE, v - 256)
-                    }
-                    DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, integerValue() and 65535)
-                    DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, integerValue())
-                    DataType.WORD -> this
-                    DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, numericValue())
-                    else -> throw ArithmeticException("invalid type cast from $type to $targetType")
-                }
-            }
-            DataType.FLOAT -> {
-                when (targetType) {
-                    DataType.BYTE -> {
-                        val integer = numericValue().toInt()
-                        if (integer in -128..127)
-                            RuntimeValueNumeric(DataType.BYTE, integer)
-                        else
-                            throw ArithmeticException("overflow when casting float to byte: $this")
-                    }
-                    DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, numericValue().toInt())
-                    DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, numericValue().toInt())
-                    DataType.WORD -> {
-                        val integer = numericValue().toInt()
-                        if (integer in -32768..32767)
-                            RuntimeValueNumeric(DataType.WORD, integer)
-                        else
-                            throw ArithmeticException("overflow when casting float to word: $this")
-                    }
-                    DataType.FLOAT -> this
-                    else -> throw ArithmeticException("invalid type cast from $type to $targetType")
-                }
-            }
-            else -> throw ArithmeticException("invalid type cast from $type to $targetType")
-        }
-    }
-}
-
-
-class RuntimeValueString(val str: String, val altEncoding: Boolean, val heapId: Int?): RuntimeValueBase(DataType.STR) {
-    companion object {
-        fun fromLv(string: StringLiteralValue): RuntimeValueString {
-            return RuntimeValueString(string.value, string.altEncoding, string.heapId)
-        }
-    }
-
-    override fun toString(): String = if(type==DataType.STR) "str:$str"  else "???"
-
-    override fun hashCode(): Int = Objects.hash(type, str)
-
-    override fun equals(other: Any?): Boolean {
-        if (other == null || other !is RuntimeValueString)
-            return false
-        return type == other.type && str == other.str
-    }
-
-    fun iterator(): Iterator<Number> = str.map { it.toShort() }.iterator()
-
-    override fun numericValue(): Number {
-        throw VmExecutionException("string is not a number")
-    }
-
-    override fun integerValue(): Int {
-        throw VmExecutionException("string is not a number")
-    }
-}
-
-
-open class RuntimeValueArray(type: DataType, val array: Array<Number>, val heapId: Int?): RuntimeValueBase(type) {
-
-    companion object {
-        fun fromLv(array: ArrayLiteralValue): RuntimeValueArray {
-            return if (array.type.istype(DataType.ARRAY_F)) {
-                val doubleArray = array.value.map { (it as NumericLiteralValue).number }.toTypedArray()
-                RuntimeValueArray(DataType.ARRAY_F, doubleArray, array.heapId)
-            } else {
-                val resultArray = mutableListOf<Number>()
-                for (elt in array.value.withIndex()) {
-                    if (elt.value is NumericLiteralValue)
-                        resultArray.add((elt.value as NumericLiteralValue).number.toInt())
-                    else {
-                        resultArray.add((elt.hashCode()))  // ...poor man's implementation of ADDRESSOF(array), it probably won't work very well
-                    }
-                }
-                RuntimeValueArray(array.type.typeOrElse(DataType.STRUCT), resultArray.toTypedArray(), array.heapId)
-            }
-        }
-    }
-
-    override fun toString(): String {
-        return when (type) {
-            DataType.ARRAY_UB -> "array_ub:..."
-            DataType.ARRAY_B -> "array_b:..."
-            DataType.ARRAY_UW -> "array_uw:..."
-            DataType.ARRAY_W -> "array_w:..."
-            DataType.ARRAY_F -> "array_f:..."
-            else -> "???"
-        }
-    }
-
-    override fun hashCode(): Int = Objects.hash(type, array)
-
-    override fun equals(other: Any?): Boolean {
-        if (other == null || other !is RuntimeValueArray)
-            return false
-        return type == other.type && array.contentEquals(other.array)
-    }
-
-    open fun iterator(): Iterator<Number> = array.iterator()
-
-    override fun numericValue(): Number {
-        throw VmExecutionException("array is not a number")
-    }
-
-    override fun integerValue(): Int {
-        throw VmExecutionException("array is not a number")
-    }
-}
-
-
-class RuntimeValueRange(type: DataType, val range: IntProgression): RuntimeValueArray(type, range.toList().toTypedArray(), null) {
-    override fun iterator(): Iterator<Number> {
-        return range.iterator()
-    }
-}

compiler/src/prog8/vm/astvm/Expressions.kt

@@ -1,177 +0,0 @@
-package prog8.vm.astvm
-
-import prog8.ast.Program
-import prog8.ast.base.ArrayElementTypes
-import prog8.ast.base.DataType
-import prog8.ast.base.FatalAstException
-import prog8.ast.base.VarDeclType
-import prog8.ast.expressions.*
-import prog8.ast.statements.BuiltinFunctionStatementPlaceholder
-import prog8.ast.statements.Label
-import prog8.ast.statements.Subroutine
-import prog8.ast.statements.VarDecl
-import prog8.vm.*
-
-
-typealias BuiltinfunctionCaller =  (name: String, args: List<RuntimeValueNumeric>, flags: StatusFlags) -> RuntimeValueNumeric?
-typealias SubroutineCaller =  (sub: Subroutine, args: List<RuntimeValueNumeric>, startAtLabel: Label?) -> RuntimeValueNumeric?
-
-
-class EvalContext(val program: Program, val mem: Memory, val statusflags: StatusFlags,
-                  val runtimeVars: RuntimeVariables,
-                  val performBuiltinFunction: BuiltinfunctionCaller,
-                  val executeSubroutine: SubroutineCaller)
-
-fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValueBase {
-    val constval = expr.constValue(ctx.program)
-    if(constval!=null)
-        return RuntimeValueNumeric.fromLv(constval)
-
-    when(expr) {
-        is NumericLiteralValue -> return RuntimeValueNumeric.fromLv(expr)
-        is StringLiteralValue -> return RuntimeValueString.fromLv(expr)
-        is ArrayLiteralValue -> return RuntimeValueArray.fromLv(expr)
-        is PrefixExpression -> {
-            return when(expr.operator) {
-                "-" -> (evaluate(expr.expression, ctx) as RuntimeValueNumeric).neg()
-                "~" -> (evaluate(expr.expression, ctx) as RuntimeValueNumeric).inv()
-                "not" -> (evaluate(expr.expression, ctx) as RuntimeValueNumeric).not()
-                // unary '+' should have been optimized away
-                else -> throw VmExecutionException("unsupported prefix operator "+expr.operator)
-            }
-        }
-        is BinaryExpression -> {
-            val left = evaluate(expr.left, ctx) as RuntimeValueNumeric
-            val right = evaluate(expr.right, ctx) as RuntimeValueNumeric
-            return when(expr.operator) {
-                "<" -> RuntimeValueNumeric(DataType.UBYTE, if (left < right) 1 else 0)
-                "<=" -> RuntimeValueNumeric(DataType.UBYTE, if (left <= right) 1 else 0)
-                ">" -> RuntimeValueNumeric(DataType.UBYTE, if (left > right) 1 else 0)
-                ">=" -> RuntimeValueNumeric(DataType.UBYTE, if (left >= right) 1 else 0)
-                "==" -> RuntimeValueNumeric(DataType.UBYTE, if (left == right) 1 else 0)
-                "!=" -> RuntimeValueNumeric(DataType.UBYTE, if (left != right) 1 else 0)
-                "+" -> left.add(right)
-                "-" -> left.sub(right)
-                "*" -> left.mul(right)
-                "/" -> left.div(right)
-                "**" -> left.pow(right)
-                "<<" -> {
-                    var result = left
-                    repeat(right.integerValue()) {result = result.shl()}
-                    result
-                }
-                ">>" -> {
-                    var result = left
-                    repeat(right.integerValue()) {result = result.shr()}
-                    result
-                }
-                "%" -> left.remainder(right)
-                "|" -> left.bitor(right)
-                "&" -> left.bitand(right)
-                "^" -> left.bitxor(right)
-                "and" -> left.and(right)
-                "or" -> left.or(right)
-                "xor" -> left.xor(right)
-                else -> throw VmExecutionException("unsupported operator "+expr.operator)
-            }
-        }
-        is ArrayIndexedExpression -> {
-            val array = evaluate(expr.identifier, ctx)
-            val index = evaluate(expr.arrayspec.index, ctx) as RuntimeValueNumeric
-            return when (array) {
-                is RuntimeValueString -> {
-                    val value = array.str[index.integerValue()]
-                    RuntimeValueNumeric(ArrayElementTypes.getValue(array.type), value.toShort())
-                }
-                is RuntimeValueArray -> {
-                    val value = array.array[index.integerValue()]
-                    RuntimeValueNumeric(ArrayElementTypes.getValue(array.type), value)
-                }
-                else -> throw VmExecutionException("weird type")
-            }
-        }
-        is TypecastExpression -> {
-            return (evaluate(expr.expression, ctx) as RuntimeValueNumeric).cast(expr.type)
-        }
-        is AddressOf -> {
-            // we support: address of heap var -> the heap id
-            return try {
-                val heapId = expr.identifier.heapId(ctx.program.namespace)
-                RuntimeValueNumeric(DataType.UWORD, heapId)
-            } catch( f: FatalAstException) {
-                // fallback: use the hash of the name, so we have at least *a* value...
-                val address = expr.identifier.hashCode() and 65535
-                RuntimeValueNumeric(DataType.UWORD, address)
-            }
-        }
-        is DirectMemoryRead -> {
-            val address = (evaluate(expr.addressExpression, ctx) as RuntimeValueNumeric).wordval!!
-            return RuntimeValueNumeric(DataType.UBYTE, ctx.mem.getUByte(address))
-        }
-        is RegisterExpr -> return ctx.runtimeVars.get(ctx.program.namespace, expr.register.name)
-        is IdentifierReference -> {
-            val scope = expr.definingScope()
-            val variable = scope.lookup(expr.nameInSource, expr)
-            if(variable is VarDecl) {
-                when {
-                    variable.type==VarDeclType.VAR -> return ctx.runtimeVars.get(variable.definingScope(), variable.name)
-                    variable.datatype==DataType.STRUCT -> throw VmExecutionException("cannot process structs by-value.  at ${expr.position}")
-                    else -> {
-                        val address = ctx.runtimeVars.getMemoryAddress(variable.definingScope(), variable.name)
-                        return when(variable.datatype) {
-                            DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, ctx.mem.getUByte(address))
-                            DataType.BYTE -> RuntimeValueNumeric(DataType.BYTE, ctx.mem.getSByte(address))
-                            DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, ctx.mem.getUWord(address))
-                            DataType.WORD -> RuntimeValueNumeric(DataType.WORD, ctx.mem.getSWord(address))
-                            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, ctx.mem.getFloat(address))
-                            DataType.STR -> RuntimeValueString(ctx.mem.getString(address, false), false, null)
-                            else -> throw VmExecutionException("unexpected datatype $variable")
-                        }
-                    }
-                }
-            } else
-                throw VmExecutionException("weird identifier reference $variable")
-        }
-        is FunctionCall -> {
-            val sub = expr.target.targetStatement(ctx.program.namespace)
-            val args = expr.args.map { evaluate(it, ctx) as RuntimeValueNumeric }
-            return when(sub) {
-                is Subroutine -> {
-                    val result = ctx.executeSubroutine(sub, args, null)
-                            ?: throw VmExecutionException("expected a result from functioncall $expr")
-                    result
-                }
-                is BuiltinFunctionStatementPlaceholder -> {
-                    val result = ctx.performBuiltinFunction(sub.name, args, ctx.statusflags)
-                            ?: throw VmExecutionException("expected 1 result from functioncall $expr")
-                    result
-                }
-                else -> {
-                    throw VmExecutionException("unimplemented function call target $sub")
-                }
-            }
-        }
-        is RangeExpr -> {
-            val cRange = expr.toConstantIntegerRange()
-            if(cRange!=null) {
-                val dt = expr.inferType(ctx.program)
-                if(dt.isKnown)
-                    return RuntimeValueRange(dt.typeOrElse(DataType.UBYTE), cRange)
-                else
-                    throw VmExecutionException("couldn't determine datatype")
-            }
-            val fromVal = (evaluate(expr.from, ctx) as RuntimeValueNumeric).integerValue()
-            val toVal = (evaluate(expr.to, ctx) as RuntimeValueNumeric).integerValue()
-            val stepVal = (evaluate(expr.step, ctx) as RuntimeValueNumeric).integerValue()
-            val range = makeRange(fromVal, toVal, stepVal)
-            val dt = expr.inferType(ctx.program)
-            if(dt.isKnown)
-                return RuntimeValueRange(dt.typeOrElse(DataType.UBYTE), range)
-            else
-                throw VmExecutionException("couldn't determine datatype")
-        }
-        else -> {
-            throw VmExecutionException("unimplemented expression node $expr")
-        }
-    }
-}

compiler/src/prog8/vm/astvm/Memory.kt

@@ -1,122 +0,0 @@
-package prog8.vm.astvm
-
-import prog8.compiler.target.CompilationTarget
-import prog8.compiler.target.c64.C64MachineDefinition
-import kotlin.math.abs
-
-class Memory(private val readObserver: (address: Int, value: Short) -> Short,
-             private val writeObserver: (address: Int, value: Short) -> Short)
-{
-
-    private val mem = ShortArray(65536)         // shorts because byte is signed and we store values 0..255
-    private val observed = BooleanArray(65536)     // what addresses are observed
-
-
-    fun observe(vararg address: Int) {
-        address.forEach { observed[it]=true }
-    }
-
-    fun getUByte(address: Int): Short {
-        return if(observed[address]) readObserver(address, mem[address])
-        else mem[address]
-    }
-
-    fun getUByteDirectly(address: Int): Short {
-        return mem[address]
-    }
-
-    fun getSByte(address: Int): Short {
-        val ubyte = getUByte(address)
-        return if(ubyte <= 127) ubyte
-        else (-((ubyte.toInt() xor 255)+1)).toShort()   // 2's complement
-    }
-
-    fun setUByte(address: Int, value: Short) {
-        if(value !in 0..255)
-            throw VmExecutionException("ubyte value out of range $value")
-        mem[address] =
-                if(observed[address]) writeObserver(address, value)
-                else value
-    }
-
-    fun setUByteDirectly(address: Int, value: Short) {
-        if(value !in 0..255)
-            throw VmExecutionException("ubyte value out of range $value")
-        mem[address] = value
-    }
-
-    fun setSByte(address: Int, value: Short) {
-        if(value !in -128..127) throw VmExecutionException("byte value out of range $value")
-        val ubyte =
-                if(value>=0) value
-                else ((abs(value.toInt()) xor 255)+1).toShort()        // 2's complement
-        setUByte(address, ubyte)
-    }
-
-    fun getUWord(address: Int): Int {
-        return getUByte(address) + 256*getUByte(address+1)
-    }
-
-    fun getSWord(address: Int): Int {
-        val uword = getUWord(address)
-        if(uword <= 32767)
-            return uword
-        return -((uword xor 65535)+1)   // 2's complement
-    }
-
-    fun setUWord(address: Int, value: Int) {
-        if(value !in 0..65535)
-            throw VmExecutionException("uword value out of range $value")
-        setUByte(address, value.and(255).toShort())
-        setUByte(address+1, (value / 256).toShort())
-    }
-
-    fun setSWord(address: Int, value: Int) {
-        if(value !in -32768..32767) throw VmExecutionException("word value out of range $value")
-        if(value>=0)
-            setUWord(address, value)
-        else
-            setUWord(address, (abs(value) xor 65535)+1)        // 2's complement
-    }
-
-    fun setFloat(address: Int, value: Double) {
-        val mflpt5 = C64MachineDefinition.Mflpt5.fromNumber(value)
-        setUByte(address, mflpt5.b0)
-        setUByte(address+1, mflpt5.b1)
-        setUByte(address+2, mflpt5.b2)
-        setUByte(address+3, mflpt5.b3)
-        setUByte(address+4, mflpt5.b4)
-    }
-
-    fun getFloat(address: Int): Double {
-        return C64MachineDefinition.Mflpt5(getUByte(address), getUByte(address + 1), getUByte(address + 2),
-                getUByte(address + 3), getUByte(address + 4)).toDouble()
-    }
-
-    fun setString(address: Int, str: String, altEncoding: Boolean) {
-        val encoded = CompilationTarget.encodeString(str, altEncoding)
-        var addr = address
-        for (c in encoded) setUByte(addr++, c)
-        setUByte(addr, 0)
-    }
-
-    fun getString(strAddress: Int, altEncoding: Boolean): String {
-        val encoded = mutableListOf<Short>()
-        var addr = strAddress
-        while(true) {
-            val byte = getUByte(addr++)
-            if(byte==0.toShort()) break
-            encoded.add(byte)
-        }
-        return CompilationTarget.decodeString(encoded, altEncoding)
-    }
-
-    fun clear() {
-        for(i in 0..65535) setUByte(i, 0)
-    }
-
-    fun copy(from: Int, to: Int, numbytes: Int) {
-        for(i in 0 until numbytes)
-            setUByte(to+i, getUByte(from+i))
-    }
-}

compiler/src/prog8/vm/astvm/ScreenDialog.kt

@@ -1,184 +0,0 @@
-package prog8.vm.astvm
-
-import prog8.compiler.target.c64.C64MachineDefinition
-import prog8.compiler.target.c64.Petscii
-import java.awt.*
-import java.awt.event.KeyEvent
-import java.awt.event.KeyListener
-import java.awt.image.BufferedImage
-import java.util.*
-import javax.swing.JFrame
-import javax.swing.JPanel
-import javax.swing.Timer
-
-
-class BitmapScreenPanel : KeyListener, JPanel() {
-
-    private val image = BufferedImage(SCREENWIDTH, SCREENHEIGHT, BufferedImage.TYPE_INT_ARGB)
-    private val g2d = image.graphics as Graphics2D
-    private var cursorX: Int=0
-    private var cursorY: Int=0
-    val keyboardBuffer = ArrayDeque<Char>()
-
-    init {
-        val size = Dimension(image.width * SCALING, image.height * SCALING)
-        minimumSize = size
-        maximumSize = size
-        preferredSize = size
-        clearScreen(6)
-        isFocusable = true
-        requestFocusInWindow()
-        addKeyListener(this)
-    }
-
-    override fun keyTyped(p0: KeyEvent) {
-        keyboardBuffer.add(p0.keyChar)
-    }
-
-    override fun keyPressed(p0: KeyEvent) {
-    }
-
-    override fun keyReleased(p0: KeyEvent?) {
-    }
-
-    override fun paint(graphics: Graphics?) {
-        val g2d = graphics as Graphics2D?
-        g2d!!.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF)
-        g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE)
-        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR)
-        g2d.drawImage(image, 0, 0, image.width * 3, image.height * 3, null)
-    }
-
-    fun clearScreen(color: Short) {
-        g2d.background = C64MachineDefinition.colorPalette[color % C64MachineDefinition.colorPalette.size]
-        g2d.clearRect(0, 0, SCREENWIDTH, SCREENHEIGHT)
-        cursorX = 0
-        cursorY = 0
-    }
-    fun setPixel(x: Int, y: Int, color: Short) {
-        image.setRGB(x, y, C64MachineDefinition.colorPalette[color % C64MachineDefinition.colorPalette.size].rgb)
-    }
-    fun drawLine(x1: Int, y1: Int, x2: Int, y2: Int, color: Short) {
-        g2d.color = C64MachineDefinition.colorPalette[color % C64MachineDefinition.colorPalette.size]
-        g2d.drawLine(x1, y1, x2, y2)
-    }
-
-    fun printAsciiText(text: String) {
-        val t2 = text.substringBefore(0.toChar())
-        val petscii = Petscii.encodePetscii(t2, true)
-        petscii.forEach { printPetsciiChar(it) }
-    }
-
-    fun printPetsciiChar(petscii: Short) {
-        if(petscii in listOf(0x0d.toShort(), 0x8d.toShort())) {
-            // Return and shift-Return
-            cursorX=0
-            cursorY++
-        } else {
-            val scr = Petscii.petscii2scr(petscii, false)
-            setScreenChar(cursorX, cursorY, scr, 1)
-            cursorX++
-            if (cursorX >= (SCREENWIDTH / 8)) {
-                cursorY++
-                cursorX = 0
-            }
-        }
-        while(cursorY>=(SCREENHEIGHT/8)) {
-            // scroll the screen up because the cursor went past the last line
-            Thread.sleep(10)
-            val screen = image.copy()
-            val graphics = image.graphics as Graphics2D
-            graphics.drawImage(screen, 0, -8, null)
-            val color = graphics.color
-            graphics.color = C64MachineDefinition.colorPalette[6]
-            graphics.fillRect(0, 24*8, SCREENWIDTH, 25*8)
-            graphics.color=color
-            cursorY--
-        }
-    }
-
-    fun setScreenChar(x: Int, y: Int, screencode: Short, color: Short) {
-        g2d.clearRect(8*x, 8*y, 8, 8)
-        val colorIdx = (color % C64MachineDefinition.colorPalette.size).toShort()
-        val coloredImage = C64MachineDefinition.Charset.getColoredChar(screencode, colorIdx)
-        g2d.drawImage(coloredImage, 8*x, 8*y , null)
-    }
-
-    fun setCursorPos(x: Int, y: Int) {
-        cursorX = x
-        cursorY = y
-    }
-
-    fun getCursorPos(): Pair<Int, Int> {
-        return Pair(cursorX, cursorY)
-    }
-
-    companion object {
-        const val SCREENWIDTH = 320
-        const val SCREENHEIGHT = 200
-        const val SCALING = 3
-    }
-}
-
-
-class ScreenDialog(title: String) : JFrame(title) {
-    val canvas = BitmapScreenPanel()
-    val keyboardBuffer = canvas.keyboardBuffer
-
-    init {
-        val borderWidth = 16
-        layout = GridBagLayout()
-        defaultCloseOperation = EXIT_ON_CLOSE
-        isResizable = false
-
-        // the borders (top, left, right, bottom)
-        val borderTop = JPanel().apply {
-            preferredSize = Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH +2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
-            background = C64MachineDefinition.colorPalette[14]
-        }
-        val borderBottom = JPanel().apply {
-            preferredSize =Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH +2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
-            background = C64MachineDefinition.colorPalette[14]
-        }
-        val borderLeft = JPanel().apply {
-            preferredSize =Dimension(BitmapScreenPanel.SCALING * borderWidth, BitmapScreenPanel.SCALING * BitmapScreenPanel.SCREENHEIGHT)
-            background = C64MachineDefinition.colorPalette[14]
-        }
-        val borderRight = JPanel().apply {
-            preferredSize =Dimension(BitmapScreenPanel.SCALING * borderWidth, BitmapScreenPanel.SCALING * BitmapScreenPanel.SCREENHEIGHT)
-            background = C64MachineDefinition.colorPalette[14]
-        }
-        var c = GridBagConstraints()
-        c.gridx=0; c.gridy=1; c.gridwidth=3
-        add(borderTop, c)
-        c = GridBagConstraints()
-        c.gridx=0; c.gridy=2
-        add(borderLeft, c)
-        c = GridBagConstraints()
-        c.gridx=2; c.gridy=2
-        add(borderRight, c)
-        c = GridBagConstraints()
-        c.gridx=0; c.gridy=3; c.gridwidth=3
-        add(borderBottom, c)
-        // the screen canvas(bitmap)
-        c = GridBagConstraints()
-        c.gridx = 1; c.gridy = 2
-        add(canvas, c)
-
-        canvas.requestFocusInWindow()
-    }
-
-    fun start() {
-        val repaintTimer = Timer(1000 / 60) { repaint() }
-        repaintTimer.start()
-    }
-}
-
-
-private fun BufferedImage.copy(): BufferedImage {
-    val bcopy = BufferedImage(this.width, this.height, this.type)
-    val g = bcopy.graphics
-    g.drawImage(this, 0, 0, null)
-    g.dispose()
-    return bcopy
-}

compiler/src/prog8/vm/astvm/VariablesCreator.kt

@@ -1,80 +0,0 @@
-package prog8.vm.astvm
-
-import prog8.ast.Program
-import prog8.ast.base.DataType
-import prog8.ast.base.Position
-import prog8.ast.base.Register
-import prog8.ast.base.VarDeclType
-import prog8.ast.expressions.ArrayLiteralValue
-import prog8.ast.expressions.NumericLiteralValue
-import prog8.ast.expressions.StringLiteralValue
-import prog8.ast.processing.IAstModifyingVisitor
-import prog8.ast.statements.Statement
-import prog8.ast.statements.StructDecl
-import prog8.ast.statements.VarDecl
-import prog8.ast.statements.ZeropageWish
-import prog8.vm.RuntimeValueArray
-import prog8.vm.RuntimeValueNumeric
-import prog8.vm.RuntimeValueString
-
-class VariablesCreator(private val runtimeVariables: RuntimeVariables) : IAstModifyingVisitor {
-
-    override fun visit(program: Program) {
-        // define the three registers as global variables
-        runtimeVariables.define(program.namespace, Register.A.name, RuntimeValueNumeric(DataType.UBYTE, 0))
-        runtimeVariables.define(program.namespace, Register.X.name, RuntimeValueNumeric(DataType.UBYTE, 255))
-        runtimeVariables.define(program.namespace, Register.Y.name, RuntimeValueNumeric(DataType.UBYTE, 0))
-
-        val globalpos = Position("<<global>>", 0, 0, 0)
-        val vdA = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.DONTCARE, null, Register.A.name, null,
-                NumericLiteralValue.optimalInteger(0, globalpos), isArray = false, autogeneratedDontRemove = true, position = globalpos)
-        val vdX = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.DONTCARE, null, Register.X.name, null,
-                NumericLiteralValue.optimalInteger(255, globalpos), isArray = false, autogeneratedDontRemove = true, position = globalpos)
-        val vdY = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.DONTCARE, null, Register.Y.name, null,
-                NumericLiteralValue.optimalInteger(0, globalpos), isArray = false, autogeneratedDontRemove = true, position = globalpos)
-        vdA.linkParents(program.namespace)
-        vdX.linkParents(program.namespace)
-        vdY.linkParents(program.namespace)
-        program.namespace.statements.add(vdA)
-        program.namespace.statements.add(vdX)
-        program.namespace.statements.add(vdY)
-
-        super.visit(program)
-    }
-
-    override fun visit(decl: VarDecl): Statement {
-        // if the decl is part of a struct, just skip it
-        if(decl.parent !is StructDecl) {
-            when (decl.type) {
-                VarDeclType.VAR -> {
-                    if(decl.datatype!=DataType.STRUCT) {
-                        val numericLv = decl.value as? NumericLiteralValue
-                        val value = if(numericLv!=null) {
-                            RuntimeValueNumeric.fromLv(numericLv)
-                        } else {
-                            val strLv = decl.value as? StringLiteralValue
-                            val arrayLv = decl.value as? ArrayLiteralValue
-                            when {
-                                strLv!=null -> {
-                                    RuntimeValueString.fromLv(strLv)
-                                }
-                                arrayLv!=null -> {
-                                    RuntimeValueArray.fromLv(arrayLv)
-                                }
-                                else -> throw VmExecutionException("weird var type")
-                            }
-                        }
-                        runtimeVariables.define(decl.definingScope(), decl.name, value)
-                    }
-                }
-                VarDeclType.MEMORY -> {
-                    runtimeVariables.defineMemory(decl.definingScope(), decl.name, (decl.value as NumericLiteralValue).number.toInt())
-                }
-                VarDeclType.CONST -> {
-                    // consts should have been const-folded away
-                }
-            }
-        }
-        return super.visit(decl)
-    }
-}

compiler/test/RuntimeValueTests.kt

@@ -1,352 +0,0 @@
-package prog8tests
-
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.TestInstance
-import prog8.ast.base.DataType
-import prog8.vm.RuntimeValueNumeric
-import kotlin.test.*
-
-
-private fun sameValueAndType(v1: RuntimeValueNumeric, v2: RuntimeValueNumeric): Boolean {
-    return v1.type==v2.type && v1==v2
-}
-
-
-@TestInstance(TestInstance.Lifecycle.PER_CLASS)
-class TestRuntimeValueNumeric {
-
-    @Test
-    fun testValueRanges() {
-        assertEquals(0, RuntimeValueNumeric(DataType.UBYTE, 0).integerValue())
-        assertEquals(255, RuntimeValueNumeric(DataType.UBYTE, 255).integerValue())
-        assertFailsWith<IllegalArgumentException> { RuntimeValueNumeric(DataType.UBYTE, -1)}
-        assertFailsWith<IllegalArgumentException> { RuntimeValueNumeric(DataType.UBYTE, 256)}
-
-        assertEquals(0, RuntimeValueNumeric(DataType.BYTE, 0).integerValue())
-        assertEquals(-128, RuntimeValueNumeric(DataType.BYTE, -128).integerValue())
-        assertEquals(127, RuntimeValueNumeric(DataType.BYTE, 127).integerValue())
-        assertFailsWith<IllegalArgumentException> { RuntimeValueNumeric(DataType.BYTE, -129)}
-        assertFailsWith<IllegalArgumentException> { RuntimeValueNumeric(DataType.BYTE, 128)}
-
-        assertEquals(0, RuntimeValueNumeric(DataType.UWORD, 0).integerValue())
-        assertEquals(65535, RuntimeValueNumeric(DataType.UWORD, 65535).integerValue())
-        assertFailsWith<IllegalArgumentException> { RuntimeValueNumeric(DataType.UWORD, -1)}
-        assertFailsWith<IllegalArgumentException> { RuntimeValueNumeric(DataType.UWORD, 65536)}
-
-        assertEquals(0, RuntimeValueNumeric(DataType.WORD, 0).integerValue())
-        assertEquals(-32768, RuntimeValueNumeric(DataType.WORD, -32768).integerValue())
-        assertEquals(32767, RuntimeValueNumeric(DataType.WORD, 32767).integerValue())
-        assertFailsWith<IllegalArgumentException> { RuntimeValueNumeric(DataType.WORD, -32769)}
-        assertFailsWith<IllegalArgumentException> { RuntimeValueNumeric(DataType.WORD, 32768)}
-    }
-
-    @Test
-    fun testTruthiness()
-    {
-        assertFalse(RuntimeValueNumeric(DataType.BYTE, 0).asBoolean)
-        assertFalse(RuntimeValueNumeric(DataType.UBYTE, 0).asBoolean)
-        assertFalse(RuntimeValueNumeric(DataType.WORD, 0).asBoolean)
-        assertFalse(RuntimeValueNumeric(DataType.UWORD, 0).asBoolean)
-        assertFalse(RuntimeValueNumeric(DataType.FLOAT, 0.0).asBoolean)
-
-        assertTrue(RuntimeValueNumeric(DataType.BYTE, 42).asBoolean)
-        assertTrue(RuntimeValueNumeric(DataType.UBYTE, 42).asBoolean)
-        assertTrue(RuntimeValueNumeric(DataType.WORD, 42).asBoolean)
-        assertTrue(RuntimeValueNumeric(DataType.UWORD, 42).asBoolean)
-        assertTrue(RuntimeValueNumeric(DataType.FLOAT, 42.0).asBoolean)
-        assertTrue(RuntimeValueNumeric(DataType.BYTE, -42).asBoolean)
-        assertTrue(RuntimeValueNumeric(DataType.WORD, -42).asBoolean)
-        assertTrue(RuntimeValueNumeric(DataType.FLOAT, -42.0).asBoolean)
-    }
-
-
-    @Test
-    fun testIdentity() {
-        val v = RuntimeValueNumeric(DataType.UWORD, 12345)
-        assertEquals(v, v)
-        assertFalse(v != v)
-        assertTrue(v<=v)
-        assertTrue(v>=v)
-        assertFalse(v<v)
-        assertFalse(v>v)
-
-        assertTrue(sameValueAndType(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.UBYTE, 100)))
-    }
-
-    @Test
-    fun testEqualsAndNotEquals() {
-        assertEquals(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.UBYTE, 100))
-        assertEquals(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.UWORD, 100))
-        assertEquals(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.FLOAT, 100))
-        assertEquals(RuntimeValueNumeric(DataType.UWORD, 254), RuntimeValueNumeric(DataType.UBYTE, 254))
-        assertEquals(RuntimeValueNumeric(DataType.UWORD, 12345), RuntimeValueNumeric(DataType.UWORD, 12345))
-        assertEquals(RuntimeValueNumeric(DataType.UWORD, 12345), RuntimeValueNumeric(DataType.FLOAT, 12345))
-        assertEquals(RuntimeValueNumeric(DataType.FLOAT, 100.0), RuntimeValueNumeric(DataType.UBYTE, 100))
-        assertEquals(RuntimeValueNumeric(DataType.FLOAT, 22239.0), RuntimeValueNumeric(DataType.UWORD, 22239))
-        assertEquals(RuntimeValueNumeric(DataType.FLOAT, 9.99), RuntimeValueNumeric(DataType.FLOAT, 9.99))
-
-        assertTrue(sameValueAndType(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.UBYTE, 100)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.UWORD, 100)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.FLOAT, 100)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.UWORD, 254), RuntimeValueNumeric(DataType.UBYTE, 254)))
-        assertTrue(sameValueAndType(RuntimeValueNumeric(DataType.UWORD, 12345), RuntimeValueNumeric(DataType.UWORD, 12345)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.UWORD, 12345), RuntimeValueNumeric(DataType.FLOAT, 12345)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.FLOAT, 100.0), RuntimeValueNumeric(DataType.UBYTE, 100)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.FLOAT, 22239.0), RuntimeValueNumeric(DataType.UWORD, 22239)))
-        assertTrue(sameValueAndType(RuntimeValueNumeric(DataType.FLOAT, 9.99), RuntimeValueNumeric(DataType.FLOAT, 9.99)))
-
-        assertNotEquals(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.UBYTE, 101))
-        assertNotEquals(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.UWORD, 101))
-        assertNotEquals(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.FLOAT, 101))
-        assertNotEquals(RuntimeValueNumeric(DataType.UWORD, 245), RuntimeValueNumeric(DataType.UBYTE, 246))
-        assertNotEquals(RuntimeValueNumeric(DataType.UWORD, 12345), RuntimeValueNumeric(DataType.UWORD, 12346))
-        assertNotEquals(RuntimeValueNumeric(DataType.UWORD, 12345), RuntimeValueNumeric(DataType.FLOAT, 12346))
-        assertNotEquals(RuntimeValueNumeric(DataType.FLOAT, 9.99), RuntimeValueNumeric(DataType.UBYTE, 9))
-        assertNotEquals(RuntimeValueNumeric(DataType.FLOAT, 9.99), RuntimeValueNumeric(DataType.UWORD, 9))
-        assertNotEquals(RuntimeValueNumeric(DataType.FLOAT, 9.99), RuntimeValueNumeric(DataType.FLOAT, 9.0))
-
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.UBYTE, 101)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.UWORD, 101)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.UBYTE, 100), RuntimeValueNumeric(DataType.FLOAT, 101)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.UWORD, 245), RuntimeValueNumeric(DataType.UBYTE, 246)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.UWORD, 12345), RuntimeValueNumeric(DataType.UWORD, 12346)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.UWORD, 12345), RuntimeValueNumeric(DataType.FLOAT, 12346)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.FLOAT, 9.99), RuntimeValueNumeric(DataType.UBYTE, 9)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.FLOAT, 9.99), RuntimeValueNumeric(DataType.UWORD, 9)))
-        assertFalse(sameValueAndType(RuntimeValueNumeric(DataType.FLOAT, 9.99), RuntimeValueNumeric(DataType.FLOAT, 9.0)))
-    }
-
-    @Test
-    fun testGreaterThan(){
-        assertTrue(RuntimeValueNumeric(DataType.UBYTE, 100) > RuntimeValueNumeric(DataType.UBYTE, 99))
-        assertTrue(RuntimeValueNumeric(DataType.UWORD, 254) > RuntimeValueNumeric(DataType.UWORD, 253))
-        assertTrue(RuntimeValueNumeric(DataType.FLOAT, 100.0) > RuntimeValueNumeric(DataType.FLOAT, 99.9))
-
-        assertTrue(RuntimeValueNumeric(DataType.UBYTE, 100) >= RuntimeValueNumeric(DataType.UBYTE, 100))
-        assertTrue(RuntimeValueNumeric(DataType.UWORD, 254) >= RuntimeValueNumeric(DataType.UWORD, 254))
-        assertTrue(RuntimeValueNumeric(DataType.FLOAT, 100.0) >= RuntimeValueNumeric(DataType.FLOAT, 100.0))
-
-        assertFalse(RuntimeValueNumeric(DataType.UBYTE, 100) > RuntimeValueNumeric(DataType.UBYTE, 100))
-        assertFalse(RuntimeValueNumeric(DataType.UWORD, 254) > RuntimeValueNumeric(DataType.UWORD, 254))
-        assertFalse(RuntimeValueNumeric(DataType.FLOAT, 100.0) > RuntimeValueNumeric(DataType.FLOAT, 100.0))
-
-        assertFalse(RuntimeValueNumeric(DataType.UBYTE, 100) >= RuntimeValueNumeric(DataType.UBYTE, 101))
-        assertFalse(RuntimeValueNumeric(DataType.UWORD, 254) >= RuntimeValueNumeric(DataType.UWORD, 255))
-        assertFalse(RuntimeValueNumeric(DataType.FLOAT, 100.0) >= RuntimeValueNumeric(DataType.FLOAT, 100.1))
-    }
-
-    @Test
-    fun testLessThan() {
-        assertTrue(RuntimeValueNumeric(DataType.UBYTE, 100) < RuntimeValueNumeric(DataType.UBYTE, 101))
-        assertTrue(RuntimeValueNumeric(DataType.UWORD, 254) < RuntimeValueNumeric(DataType.UWORD, 255))
-        assertTrue(RuntimeValueNumeric(DataType.FLOAT, 100.0) < RuntimeValueNumeric(DataType.FLOAT, 100.1))
-
-        assertTrue(RuntimeValueNumeric(DataType.UBYTE, 100) <= RuntimeValueNumeric(DataType.UBYTE, 100))
-        assertTrue(RuntimeValueNumeric(DataType.UWORD, 254) <= RuntimeValueNumeric(DataType.UWORD, 254))
-        assertTrue(RuntimeValueNumeric(DataType.FLOAT, 100.0) <= RuntimeValueNumeric(DataType.FLOAT, 100.0))
-
-        assertFalse(RuntimeValueNumeric(DataType.UBYTE, 100) < RuntimeValueNumeric(DataType.UBYTE, 100))
-        assertFalse(RuntimeValueNumeric(DataType.UWORD, 254) < RuntimeValueNumeric(DataType.UWORD, 254))
-        assertFalse(RuntimeValueNumeric(DataType.FLOAT, 100.0) < RuntimeValueNumeric(DataType.FLOAT, 100.0))
-
-        assertFalse(RuntimeValueNumeric(DataType.UBYTE, 100) <= RuntimeValueNumeric(DataType.UBYTE, 99))
-        assertFalse(RuntimeValueNumeric(DataType.UWORD, 254) <= RuntimeValueNumeric(DataType.UWORD, 253))
-        assertFalse(RuntimeValueNumeric(DataType.FLOAT, 100.0) <= RuntimeValueNumeric(DataType.FLOAT, 99.9))
-    }
-
-    @Test
-    fun testNoDtConversion() {
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.UWORD, 100).add(RuntimeValueNumeric(DataType.UBYTE, 120))
-        }
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.UBYTE, 100).add(RuntimeValueNumeric(DataType.UWORD, 120))
-        }
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.FLOAT, 100.22).add(RuntimeValueNumeric(DataType.UWORD, 120))
-        }
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.UWORD, 1002).add(RuntimeValueNumeric(DataType.FLOAT, 120.22))
-        }
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.FLOAT, 100.22).add(RuntimeValueNumeric(DataType.UBYTE, 120))
-        }
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.UBYTE, 12).add(RuntimeValueNumeric(DataType.FLOAT, 120.22))
-        }
-    }
-
-    @Test
-    fun testNoAutoFloatConversion() {
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.UBYTE, 233).add(RuntimeValueNumeric(DataType.FLOAT, 1.234))
-        }
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.UWORD, 233).add(RuntimeValueNumeric(DataType.FLOAT, 1.234))
-        }
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.UBYTE, 233).mul(RuntimeValueNumeric(DataType.FLOAT, 1.234))
-        }
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.UWORD, 233).mul(RuntimeValueNumeric(DataType.FLOAT, 1.234))
-        }
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.UBYTE, 233).div(RuntimeValueNumeric(DataType.FLOAT, 1.234))
-        }
-        assertFailsWith<ArithmeticException> {
-            RuntimeValueNumeric(DataType.UWORD, 233).div(RuntimeValueNumeric(DataType.FLOAT, 1.234))
-        }
-        val result = RuntimeValueNumeric(DataType.FLOAT, 233.333).add(RuntimeValueNumeric(DataType.FLOAT, 1.234))
-    }
-
-    @Test
-    fun arithmetictestUbyte() {
-        assertEquals(255, RuntimeValueNumeric(DataType.UBYTE, 200).add(RuntimeValueNumeric(DataType.UBYTE, 55)).integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UBYTE, 200).add(RuntimeValueNumeric(DataType.UBYTE, 56)).integerValue())
-        assertEquals(1, RuntimeValueNumeric(DataType.UBYTE, 200).add(RuntimeValueNumeric(DataType.UBYTE, 57)).integerValue())
-
-        assertEquals(1, RuntimeValueNumeric(DataType.UBYTE, 2).sub(RuntimeValueNumeric(DataType.UBYTE, 1)).integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UBYTE, 2).sub(RuntimeValueNumeric(DataType.UBYTE, 2)).integerValue())
-        assertEquals(255, RuntimeValueNumeric(DataType.UBYTE, 2).sub(RuntimeValueNumeric(DataType.UBYTE, 3)).integerValue())
-
-        assertEquals(255, RuntimeValueNumeric(DataType.UBYTE, 254).inc().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UBYTE, 255).inc().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UBYTE, 1).dec().integerValue())
-        assertEquals(255, RuntimeValueNumeric(DataType.UBYTE, 0).dec().integerValue())
-
-        assertEquals(255, RuntimeValueNumeric(DataType.UBYTE, 0).inv().integerValue())
-        assertEquals(0b00110011, RuntimeValueNumeric(DataType.UBYTE, 0b11001100).inv().integerValue())
-//        assertEquals(0, RuntimeValueNumeric(DataType.UBYTE, 0).neg().integerValue())
-//        assertEquals(0, RuntimeValueNumeric(DataType.UBYTE, 0).neg().integerValue())
-        assertEquals(1, RuntimeValueNumeric(DataType.UBYTE, 0).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UBYTE, 1).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UBYTE, 111).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UBYTE, 255).not().integerValue())
-
-        assertEquals(200, RuntimeValueNumeric(DataType.UBYTE, 20).mul(RuntimeValueNumeric(DataType.UBYTE, 10)).integerValue())
-        assertEquals(144, RuntimeValueNumeric(DataType.UBYTE, 20).mul(RuntimeValueNumeric(DataType.UBYTE, 20)).integerValue())
-
-        assertEquals(25, RuntimeValueNumeric(DataType.UBYTE, 5).pow(RuntimeValueNumeric(DataType.UBYTE, 2)).integerValue())
-        assertEquals(125, RuntimeValueNumeric(DataType.UBYTE, 5).pow(RuntimeValueNumeric(DataType.UBYTE, 3)).integerValue())
-        assertEquals(113, RuntimeValueNumeric(DataType.UBYTE, 5).pow(RuntimeValueNumeric(DataType.UBYTE, 4)).integerValue())
-
-        assertEquals(100, RuntimeValueNumeric(DataType.UBYTE, 50).shl().integerValue())
-        assertEquals(200, RuntimeValueNumeric(DataType.UBYTE, 100).shl().integerValue())
-        assertEquals(144, RuntimeValueNumeric(DataType.UBYTE, 200).shl().integerValue())
-    }
-
-    @Test
-    fun arithmetictestUWord() {
-        assertEquals(65535, RuntimeValueNumeric(DataType.UWORD, 60000).add(RuntimeValueNumeric(DataType.UWORD, 5535)).integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UWORD, 60000).add(RuntimeValueNumeric(DataType.UWORD, 5536)).integerValue())
-        assertEquals(1, RuntimeValueNumeric(DataType.UWORD, 60000).add(RuntimeValueNumeric(DataType.UWORD, 5537)).integerValue())
-
-        assertEquals(1, RuntimeValueNumeric(DataType.UWORD, 2).sub(RuntimeValueNumeric(DataType.UWORD, 1)).integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UWORD, 2).sub(RuntimeValueNumeric(DataType.UWORD, 2)).integerValue())
-        assertEquals(65535, RuntimeValueNumeric(DataType.UWORD, 2).sub(RuntimeValueNumeric(DataType.UWORD, 3)).integerValue())
-
-        assertEquals(65535, RuntimeValueNumeric(DataType.UWORD, 65534).inc().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UWORD, 65535).inc().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UWORD, 1).dec().integerValue())
-        assertEquals(65535, RuntimeValueNumeric(DataType.UWORD, 0).dec().integerValue())
-
-        assertEquals(65535, RuntimeValueNumeric(DataType.UWORD, 0).inv().integerValue())
-        assertEquals(0b0011001101010101, RuntimeValueNumeric(DataType.UWORD, 0b1100110010101010).inv().integerValue())
-//        assertEquals(0, RuntimeValueNumeric(DataType.UWORD, 0).neg().integerValue())
-//        assertEquals(0, RuntimeValueNumeric(DataType.UWORD, 0).neg().integerValue())
-        assertEquals(1, RuntimeValueNumeric(DataType.UWORD, 0).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UWORD, 1).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UWORD, 11111).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.UWORD, 65535).not().integerValue())
-
-        assertEquals(2000, RuntimeValueNumeric(DataType.UWORD, 200).mul(RuntimeValueNumeric(DataType.UWORD, 10)).integerValue())
-        assertEquals(40000, RuntimeValueNumeric(DataType.UWORD, 200).mul(RuntimeValueNumeric(DataType.UWORD, 200)).integerValue())
-        assertEquals(14464, RuntimeValueNumeric(DataType.UWORD, 200).mul(RuntimeValueNumeric(DataType.UWORD, 400)).integerValue())
-
-        assertEquals(15625, RuntimeValueNumeric(DataType.UWORD, 5).pow(RuntimeValueNumeric(DataType.UWORD, 6)).integerValue())
-        assertEquals(12589, RuntimeValueNumeric(DataType.UWORD, 5).pow(RuntimeValueNumeric(DataType.UWORD, 7)).integerValue())
-
-        assertEquals(10000, RuntimeValueNumeric(DataType.UWORD, 5000).shl().integerValue())
-        assertEquals(60000, RuntimeValueNumeric(DataType.UWORD, 30000).shl().integerValue())
-        assertEquals(14464, RuntimeValueNumeric(DataType.UWORD, 40000).shl().integerValue())
-    }
-
-    @Test
-    fun arithmetictestByte() {
-        assertEquals(127, RuntimeValueNumeric(DataType.BYTE, 100).add(RuntimeValueNumeric(DataType.BYTE, 27)).integerValue())
-        assertEquals(-128, RuntimeValueNumeric(DataType.BYTE, 100).add(RuntimeValueNumeric(DataType.BYTE, 28)).integerValue())
-        assertEquals(-127, RuntimeValueNumeric(DataType.BYTE, 100).add(RuntimeValueNumeric(DataType.BYTE, 29)).integerValue())
-
-        assertEquals(1, RuntimeValueNumeric(DataType.BYTE, 2).sub(RuntimeValueNumeric(DataType.BYTE, 1)).integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.BYTE, 2).sub(RuntimeValueNumeric(DataType.BYTE, 2)).integerValue())
-        assertEquals(-1, RuntimeValueNumeric(DataType.BYTE, 2).sub(RuntimeValueNumeric(DataType.BYTE, 3)).integerValue())
-        assertEquals(-128, RuntimeValueNumeric(DataType.BYTE, -100).sub(RuntimeValueNumeric(DataType.BYTE, 28)).integerValue())
-        assertEquals(127, RuntimeValueNumeric(DataType.BYTE, -100).sub(RuntimeValueNumeric(DataType.BYTE, 29)).integerValue())
-
-        assertEquals(127, RuntimeValueNumeric(DataType.BYTE, 126).inc().integerValue())
-        assertEquals(-128, RuntimeValueNumeric(DataType.BYTE, 127).inc().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.BYTE, 1).dec().integerValue())
-        assertEquals(-1, RuntimeValueNumeric(DataType.BYTE, 0).dec().integerValue())
-        assertEquals(-128, RuntimeValueNumeric(DataType.BYTE, -127).dec().integerValue())
-        assertEquals(127, RuntimeValueNumeric(DataType.BYTE, -128).dec().integerValue())
-
-        assertEquals(-1, RuntimeValueNumeric(DataType.BYTE, 0).inv().integerValue())
-        assertEquals(-103, RuntimeValueNumeric(DataType.BYTE, 0b01100110).inv().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.BYTE, 0).neg().integerValue())
-        assertEquals(-2, RuntimeValueNumeric(DataType.BYTE, 2).neg().integerValue())
-        assertEquals(1, RuntimeValueNumeric(DataType.BYTE, 0).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.BYTE, 1).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.BYTE, 111).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.BYTE, -33).not().integerValue())
-
-        assertEquals(100, RuntimeValueNumeric(DataType.BYTE, 10).mul(RuntimeValueNumeric(DataType.BYTE, 10)).integerValue())
-        assertEquals(-56, RuntimeValueNumeric(DataType.BYTE, 20).mul(RuntimeValueNumeric(DataType.BYTE, 10)).integerValue())
-
-        assertEquals(25, RuntimeValueNumeric(DataType.BYTE, 5).pow(RuntimeValueNumeric(DataType.BYTE, 2)).integerValue())
-        assertEquals(125, RuntimeValueNumeric(DataType.BYTE, 5).pow(RuntimeValueNumeric(DataType.BYTE, 3)).integerValue())
-        assertEquals(113, RuntimeValueNumeric(DataType.BYTE, 5).pow(RuntimeValueNumeric(DataType.BYTE, 4)).integerValue())
-
-        assertEquals(100, RuntimeValueNumeric(DataType.BYTE, 50).shl().integerValue())
-        assertEquals(-56, RuntimeValueNumeric(DataType.BYTE, 100).shl().integerValue())
-        assertEquals(-2, RuntimeValueNumeric(DataType.BYTE, -1).shl().integerValue())
-    }
-
-    @Test
-    fun arithmetictestWorrd() {
-        assertEquals(32767, RuntimeValueNumeric(DataType.WORD, 32700).add(RuntimeValueNumeric(DataType.WORD, 67)).integerValue())
-        assertEquals(-32768, RuntimeValueNumeric(DataType.WORD, 32700).add(RuntimeValueNumeric(DataType.WORD, 68)).integerValue())
-        assertEquals(-32767, RuntimeValueNumeric(DataType.WORD, 32700).add(RuntimeValueNumeric(DataType.WORD, 69)).integerValue())
-
-        assertEquals(1, RuntimeValueNumeric(DataType.WORD, 2).sub(RuntimeValueNumeric(DataType.WORD, 1)).integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.WORD, 2).sub(RuntimeValueNumeric(DataType.WORD, 2)).integerValue())
-        assertEquals(-1, RuntimeValueNumeric(DataType.WORD, 2).sub(RuntimeValueNumeric(DataType.WORD, 3)).integerValue())
-        assertEquals(-32768, RuntimeValueNumeric(DataType.WORD, -32700).sub(RuntimeValueNumeric(DataType.WORD, 68)).integerValue())
-        assertEquals(32767, RuntimeValueNumeric(DataType.WORD, -32700).sub(RuntimeValueNumeric(DataType.WORD, 69)).integerValue())
-
-        assertEquals(32767, RuntimeValueNumeric(DataType.WORD, 32766).inc().integerValue())
-        assertEquals(-32768, RuntimeValueNumeric(DataType.WORD, 32767).inc().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.WORD, 1).dec().integerValue())
-        assertEquals(-1, RuntimeValueNumeric(DataType.WORD, 0).dec().integerValue())
-        assertEquals(-32768, RuntimeValueNumeric(DataType.WORD, -32767).dec().integerValue())
-        assertEquals(32767, RuntimeValueNumeric(DataType.WORD, -32768).dec().integerValue())
-
-        assertEquals(-1, RuntimeValueNumeric(DataType.WORD, 0).inv().integerValue())
-        assertEquals(-103, RuntimeValueNumeric(DataType.WORD, 0b01100110).inv().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.WORD, 0).neg().integerValue())
-        assertEquals(-2, RuntimeValueNumeric(DataType.WORD, 2).neg().integerValue())
-        assertEquals(1, RuntimeValueNumeric(DataType.WORD, 0).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.WORD, 1).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.WORD, 111).not().integerValue())
-        assertEquals(0, RuntimeValueNumeric(DataType.WORD, -33).not().integerValue())
-
-        assertEquals(10000, RuntimeValueNumeric(DataType.WORD, 100).mul(RuntimeValueNumeric(DataType.WORD, 100)).integerValue())
-        assertEquals(-25536, RuntimeValueNumeric(DataType.WORD, 200).mul(RuntimeValueNumeric(DataType.WORD, 200)).integerValue())
-
-        assertEquals(15625, RuntimeValueNumeric(DataType.WORD, 5).pow(RuntimeValueNumeric(DataType.WORD, 6)).integerValue())
-        assertEquals(-6487, RuntimeValueNumeric(DataType.WORD, 9).pow(RuntimeValueNumeric(DataType.WORD, 5)).integerValue())
-
-        assertEquals(18000, RuntimeValueNumeric(DataType.WORD, 9000).shl().integerValue())
-        assertEquals(-25536, RuntimeValueNumeric(DataType.WORD, 20000).shl().integerValue())
-        assertEquals(-2, RuntimeValueNumeric(DataType.WORD, -1).shl().integerValue())
-    }
-}

compiler/test/UnitTests.kt

@@ -16,7 +16,6 @@ import prog8.compiler.target.c64.C64MachineDefinition.FLOAT_MAX_NEGATIVE
 import prog8.compiler.target.c64.C64MachineDefinition.FLOAT_MAX_POSITIVE
 import prog8.compiler.target.c64.C64MachineDefinition.Mflpt5
 import prog8.compiler.target.c64.Petscii
-import prog8.vm.RuntimeValueNumeric
 import java.io.CharConversionException
 import kotlin.test.*
 
@@ -356,8 +355,8 @@ class TestPetscii {
 
     @Test
     fun testLiteralValueComparisons() {
-        val ten = NumericLiteralValue(DataType.UWORD, 10, Position("", 0, 0, 0))
-        val nine = NumericLiteralValue(DataType.UBYTE, 9, Position("", 0, 0, 0))
+        val ten = NumericLiteralValue(DataType.UWORD, 10, Position.DUMMY)
+        val nine = NumericLiteralValue(DataType.UBYTE, 9, Position.DUMMY)
         assertEquals(ten, ten)
         assertNotEquals(ten, nine)
         assertFalse(ten != ten)
@@ -373,30 +372,10 @@ class TestPetscii {
         assertTrue(ten <= ten)
         assertFalse(ten < ten)
 
-        val abc = StringLiteralValue("abc", false, Position("", 0, 0, 0))
-        val abd = StringLiteralValue("abd", false, Position("", 0, 0, 0))
+        val abc = StringLiteralValue("abc", false, Position.DUMMY)
+        val abd = StringLiteralValue("abd", false, Position.DUMMY)
         assertEquals(abc, abc)
         assertTrue(abc!=abd)
         assertFalse(abc!=abc)
     }
-
-    @Test
-    fun testStackvmValueComparisons() {
-        val ten = RuntimeValueNumeric(DataType.FLOAT, 10)
-        val nine = RuntimeValueNumeric(DataType.UWORD, 9)
-        assertEquals(ten, ten)
-        assertNotEquals(ten, nine)
-        assertFalse(ten != ten)
-        assertTrue(ten != nine)
-
-        assertTrue(ten > nine)
-        assertTrue(ten >= nine)
-        assertTrue(ten >= ten)
-        assertFalse(ten > ten)
-
-        assertFalse(ten < nine)
-        assertFalse(ten <= nine)
-        assertTrue(ten <= ten)
-        assertFalse(ten < ten)
-    }
 }

docs/source/building.rst

@@ -168,18 +168,3 @@ or::
 
     $ ./p8compile.sh -emu examples/rasterbars.p8
 
-
-
-Virtual Machine / Simulator
----------------------------
-
-You may have noticed the ``-sim`` command line option for the compiler:
-
--sim
-    Launches the "AST virtual machine Simulator" that directly executes the parsed program.
-    No compilation steps will be performed.
-    Allows for very fast testing and debugging before actually compiling programs
-    to machine code.
-    It simulates a bare minimum of features from the target platform, so most stuff
-    that calls ROM routines or writes into hardware registers won't work. But basic
-    system routines are emulated.

docs/source/index.rst

@@ -135,31 +135,29 @@ Design principles and features
 
 - It is a cross-compiler running on modern machines (Linux, MacOS, Windows, ...)
   The generated output is a machine code program runnable on actual 8-bit 6502 hardware.
-- Usable on most operating systems.
-- Based on simple and familiar imperative structured programming paradigm.
-- 'One statement per line' code style, resulting in clear readable programs.
+- Based on simple and familiar imperative structured programming (it looks like a mix of C and Python)
+- 'One statement per line' code, resulting in clear readable programs.
 - Modular programming and scoping via modules, code blocks, and subroutines.
-- Provide high level programming constructs but stay close to the metal;
-  still able to directly use memory addresses, CPU registers and ROM subroutines,
-  and inline assembly to have full control when every cycle or byte matters
-- Arbitrary number of subroutine parameters (constrained only by available memory)
-- Nested subroutines can access variables from outer scopes, this avoids the need and overhead to pass everything via parameters
+- Provide high level programming constructs but at the same time stay close to the metal;
+  still able to directly use memory addresses and ROM subroutines,
+  and inline assembly to have full control when every register, cycle or byte matters
+- Arbitrary number of subroutine parameters
 - Complex nested expressions are possible
-- Values are typed. Types supported include signed and unsigned bytes and words, arrays, strings and floats.
+- Nested subroutines can access variables from outer scopes to avoids the overhead to pass everything via parameters
+- Values are typed. Available data types include signed and unsigned bytes and words, arrays, strings and floats.
 - No dynamic memory allocation or sizing! All variables stay fixed size as determined at compile time.
 - Provide various quality of life language features and library subroutines specifically for the target platform.
 - Provide a very convenient edit/compile/run cycle by being able to directly launch
-  the compiled program in an emulator and provide debugging information to the emulator.
-- The compiler outputs a regular 6502 assembly source code file, but doesn't assemble this itself.
-  The (separate) '64tass' cross-assembler tool is used for that.
+  the compiled program in an emulator and provide debugging information to this emulator.
 - Arbitrary control flow jumps and branches are possible,
   and will usually translate directly into the appropriate single 6502 jump/branch instruction.
 - There are no complicated built-in error handling or overflow checks, you'll have to take care
   of this yourself if required. This keeps the language and code simple and efficient.
-- The compiler tries to optimize the program and generated code, but hand-tuning of the
+- The compiler tries to optimize the program and generated code a bit, but hand-tuning of the
   performance or space-critical parts will likely still be required. This is supported by
   the ability to easily write embedded assembly code directly in the program source code.
-- There are many built-in functions, such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``sort`` and ``reverse``
+- There are many built-in functions, such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``substr``, ``sort`` and ``reverse`` (and others)
+- Assembling the generated code into a program wil be done by an external cross-assembler tool.
 
 
 .. _requirements:

docs/source/programming.rst

@@ -50,7 +50,7 @@ Code
     There are different kinds of instructions ('statements' is a better name) such as:
 
     - value assignment
-    - looping  (for, while, repeat, unconditional jumps)
+    - looping  (for, while, do-until, repeat, unconditional jumps)
     - conditional execution (if - then - else, when, and conditional jumps)
     - subroutine calls
     - label definition
@@ -135,14 +135,18 @@ Scopes are created using either of these two statements:
 - blocks  (top-level named scope)
 - subroutines   (nested named scope)
 
-.. note::
-    Unlike many other programming languages, a new scope is *not* created inside
-    for, while and repeat statements, nor for the if statement and branching conditionals.
-    This can be a bit restrictive because as a programmer you have to think harder about what variables you
-    want to use inside a subroutine. But it is done precisely for this reason: memory in prog8's
+.. important::
+    Unlike most other programming languages, a new scope is *not* created inside
+    for, while, repeat, and do-until statements, the if statement, and the branching conditionals.
+    These all share the same scope from the subroutine they're defined in.
+    You can define variables in these blocks, but these will be treated as if they
+    were defined in the subroutine instead.
+    This can seem a bit restrictive because you have to think harder about what variables you
+    want to use inside the subroutine, to avoid clashes.
+    But this decision was made for a good reason: memory in prog8's
     target systems is usually very limited and it would be a waste to allocate a lot of variables.
     The prog8 compiler is not yet advanced enough to be able to share or overlap
-    variables intelligently. So for now that is something the programmer has to think about.
+    variables intelligently. So for now that is something you have to think about yourself.
 
 
 Program Start and Entry Point
@@ -152,13 +156,6 @@ Your program must have a single entry point where code execution begins.
 The compiler expects a ``start`` subroutine in the ``main`` block for this,
 taking no parameters and having no return value.
 
-.. sidebar::
-    60hz IRQ entry point
-
-    When running the generated code on the StackVm virtual machine,
-    it will use the ``irq`` subroutine in the ``irq`` block for the
-    60hz irq routine. This is optional.
-
 As any subroutine, it has to end with a ``return`` statement (or a ``goto`` call)::
 
     main {
@@ -181,7 +178,7 @@ Variables and values
 --------------------
 
 Variables are named values that can change during the execution of the program.
-They can be defined inside any scope (blocks, subroutines, for loops, etc.) See :ref:`Scopes <scopes>`.
+They can be defined inside any scope (blocks, subroutines etc.) See :ref:`Scopes <scopes>`.
 When declaring a numeric variable it is possible to specify the initial value, if you don't want it to be zero.
 For other data types it is required to specify that initial value it should get.
 Values will usually be part of an expression or assignment statement::
@@ -207,13 +204,6 @@ Example::
     byte  @zp  zeropageCounter = 42
 
 
-Variables that represent CPU hardware registers
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The following variables are reserved
-and map directly (read/write) to a CPU hardware register: ``A``, ``X``, ``Y``.
-
-
 Integers
 ^^^^^^^^
 
@@ -282,16 +272,23 @@ This @-prefix can also be used for character byte values.
 
 
 You can concatenate two string literals using '+' (not very useful though) or repeat
-a string literal a given number of times using '*'::
+a string literal a given number of times using '*'. You can also assign a new string
+value to another string. No bounds check is done so be sure the destination string is
+large enough to contain the new value::
 
     str string1 = "first part" + "second part"
     str string2 = "hello!" * 10
 
+    string1 = string2
+    string1 = "new value"
+
 
 .. caution::
-    Avoid changing strings after they've been created.
+    It's probably best to avoid changing strings after they've been created. This
+    includes changing certain letters by index, or by assigning a new value, or by
+    modifying the string via other means for example ``substr`` function and its cousins.
     This is because if your program exits and is restarted (without loading it again),
-    it will then start working with the changed strings instead of the original ones.
+    it will then start working with the changed strings instead of the original ones!
     The same is true for arrays.
 
 
@@ -375,10 +372,8 @@ Initial values across multiple runs of the program
 
 When declaring values with an initial value, this value will be set into the variable each time
 the program reaches the declaration again. This can be in loops, multiple subroutine calls,
-or even multiple invocations of the entire program.  If you omit an initial value, it will
-be set to zero *but only for the first run of the program*. A second run will utilize the last value
-where it left off (but your code will be a bit smaller because no initialization instructions
-are generated)
+or even multiple invocations of the entire program.
+If you omit the initial value, zero will be used instead.
 
 This only works for simple types, *and not for string variables and arrays*.
 It is assumed these are left unchanged by the program; they are not re-initialized on
@@ -387,34 +382,23 @@ If you do modify them in-place, you should take care yourself that they work as
 expected when the program is restarted.
 (This is an optimization choice to avoid having to store two copies of every string and array)
 
-.. caution::
-   variables that get allocated in zero-page will *not* have a zero starting value when you omit
-   the variable's initialization. They'll be whatever the last value in that zero page
-   location was. So it's best to don't depend on the uninitialized starting value!
-
-.. warning::
-    this behavior may change in a future version so that subsequent runs always
-    use the same initial values
-
 
 Loops
 -----
 
-The *for*-loop is used to let a variable (or register) iterate over a range of values. Iteration is done in steps of 1, but you can change this.
+The *for*-loop is used to let a variable iterate over a range of values. Iteration is done in steps of 1, but you can change this.
 The loop variable must be declared as byte or word earlier so you can reuse it for multiple occasions.
 Iterating with a floating point variable is not supported. If you want to loop over a floating-point array, use a loop with an integer index variable instead.
 
 The *while*-loop is used to repeat a piece of code while a certain condition is still true.
-The *repeat--until* loop is used to repeat a piece of code until a certain condition is true.
-
-The *forever*-loop is used to simply run a piece of code in a loop, forever. You can still
-break out of this loop if desired. A "while true" or "until false" loop is equivalent to
-a forever-loop.
+The *do--until* loop is used to repeat a piece of code until a certain condition is true.
+The *repeat* loop is used as a short notation of a for loop where the loop variable doesn't matter and you're only interested in the number of iterations.
+(without iteration count specified it simply loops forever).
 
 You can also create loops by using the ``goto`` statement, but this should usually be avoided.
 
 .. attention::
-    The value of the loop variable or register after executing the loop *is undefined*. Don't use it immediately
+    The value of the loop variable after executing the loop *is undefined*. Don't use it immediately
     after the loop without first assigning a new value to it!
     (this is an optimization issue to avoid having to deal with mostly useless post-loop logic to adjust the loop variable's value)
 
@@ -428,15 +412,15 @@ if statements
 Conditional execution means that the flow of execution changes based on certiain conditions,
 rather than having fixed gotos or subroutine calls::
 
-	if A>4 goto overflow
+	if aa>4 goto overflow
 
-	if X==3  Y = 4
-	if X==3  Y = 4 else  A = 2
+	if xx==3  yy = 4
+	if xx==3  yy = 4 else  aa = 2
 
-	if X==5 {
-		Y = 99
+	if xx==5 {
+		yy = 99
 	} else {
-		A = 3
+		aa = 3
 	}
 
 
@@ -500,16 +484,16 @@ Assignments
 -----------
 
 Assignment statements assign a single value to a target variable or memory location.
-Augmented assignments (such as ``A += X``) are also available, but these are just shorthands
-for normal assignments (``A = A + X``).
+Augmented assignments (such as ``aa += xx``) are also available, but these are just shorthands
+for normal assignments (``aa = aa + xx``).
 
-Only register variables and variables of type byte, word and float can be assigned a new value.
+Only variables of type byte, word and float can be assigned a new value.
 It's not possible to set a new value to string or array variables etc, because they get allocated
-a fixed amount of memory which will not change.
+a fixed amount of memory which will not change.  (You *can* change the value of elements in a string or array though).
 
 .. attention::
     **Data type conversion (in assignments):**
-    When assigning a value with a 'smaller' datatype to a register or variable with a 'larger' datatype,
+    When assigning a value with a 'smaller' datatype to variable with a 'larger' datatype,
     the value will be automatically converted to the target datatype:  byte --> word --> float.
     So assigning a byte to a word variable, or a word to a floating point variable, is fine.
     The reverse is *not* true: it is *not* possible to assign a value of a 'larger' datatype to
@@ -525,7 +509,7 @@ as the memory mapped address $d021.
 If you want to access a memory location directly (by using the address itself), without defining
 a memory mapped location, you can do so by enclosing the address in ``@(...)``::
 
-    A = @($d020)      ; set the A register to the current c64 screen border color ("peek(53280)")
+    color = @($d020)  ; set the variable 'color' to the current c64 screen border color ("peek(53280)")
     @($d020) = 0      ; set the c64 screen border to black ("poke 53280,0")
     @(vic+$20) = 6    ; you can also use expressions to 'calculate' the address
 
@@ -816,6 +800,22 @@ memsetw(address, numwords, wordvalue)
     Efficiently set a part of memory to the given (u)word value.
     But the most efficient will always be to write a specialized fill routine in assembly yourself!
 
+leftstr(source, target, length)
+    Copies the left side of the source string of the given length to target string.
+    It is assumed the target string buffer is large enough to contain the result.
+    Modifies in-place, doesn't return a value (so can't be used in an expression).
+
+rightstr(source, target, length)
+    Copies the right side of the source string of the given length to target string.
+    It is assumed the target string buffer is large enough to contain the result.
+    Modifies in-place, doesn't return a value (so can't be used in an expression).
+
+substr(source, target, start, length)
+    Copies a segment from the source string, starting at the given index,
+    and of the given length to target string.
+    It is assumed the target string buffer is large enough to contain the result.
+    Modifies in-place, doesn't return a value (so can't be used in an expression).
+
 swap(x, y)
     Swap the values of numerical variables (or memory locations) x and y in a fast way.
 

docs/source/syntaxreference.rst

@@ -24,7 +24,7 @@ Everything after a semicolon ``;`` is a comment and is ignored.
 If the whole line is just a comment, it will be copied into the resulting assembly source code.
 This makes it easier to understand and relate the generated code. Examples::
 
-	A = 42    ; set the initial value to 42
+	counter = 42    ; set the initial value to 42
 	; next is the code that...
 
 
@@ -216,7 +216,8 @@ Variable declarations
 
 Variables should be declared with their exact type and size so the compiler can allocate storage
 for them. You can give them an initial value as well. That value can be a simple literal value,
-or an expression. You can add a ``@zp`` zeropage-tag, to tell the compiler to prioritize it
+or an expression. If you don't provide an intial value yourself, zero will be used.
+You can add a ``@zp`` zeropage-tag, to tell the compiler to prioritize it
 when selecting variables to be put into zeropage.
 The syntax is::
 
@@ -312,7 +313,7 @@ Direct access to memory locations
 Instead of defining a memory mapped name for a specific memory location, you can also
 directly access the memory. Enclose a numeric expression or literal with ``@(...)`` to do that::
 
-    A = @($d020)      ; set the A register to the current c64 screen border color ("peek(53280)")
+    color = @($d020)  ; set the variable 'color' to the current c64 screen border color ("peek(53280)")
     @($d020) = 0      ; set the c64 screen border to black ("poke 53280,0")
     @(vic+$20) = 6    ; a dynamic expression to 'calculate' the address
 
@@ -321,7 +322,7 @@ Constants
 ^^^^^^^^^
 
 All variables can be assigned new values unless you use the ``const`` keyword.
-The initial value will now be evaluated at compile time (it must be a compile time constant expression).
+The initial value must be known at compile time (it must be a compile time constant expression).
 This is only valid for the simple numeric types (byte, word, float)::
 
 	const  byte  max_age = 99
@@ -332,8 +333,6 @@ Reserved names
 
 The following names are reserved, they have a special meaning::
 
-	A     X    Y              ; 6502 hardware registers
-	Pc    Pz   Pn  Pv         ; 6502 status register flags
 	true  false              ; boolean values 1 and 0
 
 
@@ -405,10 +404,10 @@ assignment: ``=``
     Note that an assignment sometimes is not possible or supported.
 
 augmented assignment: ``+=``  ``-=``  ``*=``  ``/=``  ``**=``  ``&=``  ``|=``  ``^=``  ``<<=``  ``>>=``
-	Syntactic sugar; ``A += X`` is equivalent to ``A = A + X``
+	Syntactic sugar; ``aa += xx`` is equivalent to ``aa = aa + xx``
 
 postfix increment and decrement: ``++``  ``--``
-	Syntactic sugar; ``A++`` is equivalent to ``A = A + 1``, and ``A--`` is equivalent to ``A = A - 1``.
+	Syntactic sugar; ``aa++`` is equivalent to ``aa = aa + 1``, and ``aa--`` is equivalent to ``aa = aa - 1``.
 	Because these operations are so common, we have these short forms.
 
 comparison: ``!=``  ``<``  ``>``  ``<=``  ``>=``
@@ -426,9 +425,9 @@ range creation:  ``to``
 
 		0 to 7		; range of values 0, 1, 2, 3, 4, 5, 6, 7  (constant)
 
-		A = 5
-		X = 10
-		A to X		; range of 5, 6, 7, 8, 9, 10
+		aa = 5
+		aa = 10
+	    aa to xx		; range of 5, 6, 7, 8, 9, 10
 
 		byte[] array = 10 to 13   ; sets the array to [1, 2, 3, 4]
 
@@ -550,7 +549,7 @@ Loops
 for loop
 ^^^^^^^^
 
-The loop variable must be a register or a byte/word variable,
+The loop variable must be a byte or word variable,
 and must be defined first in the local scope of the for loop.
 The expression that you loop over can be anything that supports iteration (such as ranges like ``0 to 100``,
 array variables and strings) *except* floating-point arrays (because a floating-point loop variable is not supported).
@@ -597,31 +596,33 @@ You can use a single statement, or a statement block like in the example below::
 	}
 
 
-repeat-until loop
-^^^^^^^^^^^^^^^^^
+do-until loop
+^^^^^^^^^^^^^
 
 Until the given condition is true (1), repeat the given statement(s).
 You can use a single statement, or a statement block like in the example below::
 
-	repeat  {
+	do  {
 		; do something...
 		break		; break out of the loop
 		continue	; immediately enter next iteration
 	} until  <condition>
 
 
-forever loop
-^^^^^^^^^^^^
+repeat loop
+^^^^^^^^^^^
 
-Simply run the code in a loop, forever. It's the same as a while true or until false loop,
-or just a jump back to a previous label. You can still break out of this loop as well, if you want::
+When you're only interested in repeating something a given number of times.
+It's a short hand for a for loop without an explicit loop variable::
 
-    forever {
-        ; .. do stuff
-        if something
-            break        ; you can exit the loop if you want
+    repeat 15 {
+        ; do something...
+        break		; you can break out of the loop
     }
 
+If you omit the iteration count, it simply loops forever.
+You can still ``break`` out of such a loop if you want though.
+
 
 Conditional Execution and Jumps
 -------------------------------
@@ -701,3 +702,4 @@ case you have to use { } to enclose them::
         }
         else -> c64scr.print("don't know")
     }
+

docs/source/targetsystem.rst

@@ -113,22 +113,14 @@ CPU
 Directly Usable Registers
 -------------------------
 
-The following 6502 CPU hardware registers are directly usable in program code (and are reserved symbols):
+The hardware CPU registers are not directly accessible from regular Prog8 code.
+If you need to mess with them, you'll have to use inline assembly.
+Be extra wary of the ``X`` register because it is used as an evaluation stack pointer and
+changing its value you will destroy the evaluation stack and likely crash the program.
 
-- ``A``, ``X``, ``Y``  the three main cpu registers (8 bits)
-- the status register (P) carry flag and interrupt disable flag can be written via a couple of special
-  builtin functions (``set_carry()``, ``clear_carry()``, ``set_irqd()``,  ``clear_irqd()``),
-  and read via the ``read_flags()`` function.
-
-However, you must assume that the 3 hardware registers ``A``, ``X`` and ``Y``
-are volatile. Their values cannot be depended upon, the compiler will use them as required.
-Even simple assignments may require modification of one or more of the registers (for instance, when using arrays).
-
-Even more important, the ``X`` register is used as an evaluation stack pointer.
-If you mess with it, you will destroy the evaluation stack and likely crash your program.
-In some cases the compiler will warn you about this, but you should really avoid to use
-this register. It's possible to store/restore the register's value (using special built in functions)
-for the cases you really really need to use it directly.
+The status register (P) carry flag and interrupt disable flag can be written via a couple of special
+builtin functions (``set_carry()``, ``clear_carry()``, ``set_irqd()``,  ``clear_irqd()``),
+and read via the ``read_flags()`` function.
 
 
 Subroutine Calling Conventions
@@ -173,3 +165,4 @@ as a subroutine ``irq`` in the module ``irq`` so like this::
             ; ... irq handling here ...
         }
     }
+

docs/source/todo.rst

@@ -2,29 +2,11 @@
 TODO
 ====
 
-- remove statements after an exit() or return
-- fix warnings about that unreachable code?
-
-- option to load library files from a directory instead of the embedded ones
-
-
-Memory Block Operations integrated in language?
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-array/string memory block operations?
-
-- vector inc/dec/add/sub/mul/div...?  (on array or string):
-  ``arrayvar++ / arrayvar-- / arrayvar += 2 / arrayvar -= 2 / arrayvar *= 3 / arrayvar /= 3``
-
-- array operations
-  copy (from another array with the same length), shift-N(left,right), rotate-N(left,right)
-  clear (set whole array to the given value, default 0)
-
-- array operations ofcourse work identical on vars and on memory mapped vars of these types.
-
-- strings: identical operations as on array.
-
-For now, we have the ``memcopy`` and ``memset`` builtin functions.
+- finalize (most) of the still missing "new" assignment asm code generation
+- aliases for imported symbols for example perhaps '%alias print = c64scr.print'
+- option to load library files from a directory instead of the embedded ones (easier library development/debugging)
+- investigate support for 8bitguy's Commander X16 platform https://www.commanderx16.com  and https://github.com/commanderx16/x16-docs
+- see if we can group some errors together for instance the (now single) errors about unidentified symbols
 
 
 More optimizations
@@ -32,12 +14,16 @@ More optimizations
 
 Add more compiler optimizations to the existing ones.
 
-- on the language AST level
-- on the final assembly source level
+- more targeted optimizations for assigment asm code, such as the following:
+- subroutine calling convention? like: 1 byte arg -> pass in A, 2 bytes -> pass in A+Y, return value likewise.
+- remove unreachable code after an exit(), return or goto
+- add a compiler option to not include variable initialization code (useful if the program is expected to run only once, such as a game)
+  the program will then rely solely on the values as they are in memory at the time of program startup.
+- Also some library routines and code patterns could perhaps be optimized further
 - can the parameter passing to subroutines be optimized to avoid copying?
-- working subroutine inlining (taking care of vars and identifier refs to them)
-
-Also some library routines and code patterns could perhaps be optimized further
+- more optimizations on the language AST level
+- more optimizations on the final assembly source level
+- note: abandoned subroutine inlining because of problems referencing non-local stuff. Can't move everything around.
 
 
 Eval stack redesign? (lot of work)
@@ -45,17 +31,18 @@ Eval stack redesign? (lot of work)
 
 The eval stack is now a split lsb/msb stack using X as the stackpointer.
 Is it easier/faster to just use a single page unsplit stack?
-It could then even be moved into the zeropage to greatly reduce code size and slowness.
+It could then even be moved into the zeropage to reduce code size and slowness.
 
 Or just move the LSB portion into a slab of the zeropage.
 
-Allocate a fixed word in ZP that is the TOS so we can always operate on TOS directly
-without having to to index into the stack?
+Allocate a fixed word in ZP that is the Top Of Stack value so we can always operate on TOS directly
+without having to index with X into the eval stack all the time?
+This could GREATLY improve code size and speed for operations that work on just a single value.
 
 
-Bugs
-^^^^
-Ofcourse there are still bugs to fix ;)
+Bug Fixing
+^^^^^^^^^^
+Ofcourse there are always bugs to fix ;)
 
 
 Misc
@@ -63,4 +50,3 @@ Misc
 
 Several ideas were discussed on my reddit post
 https://www.reddit.com/r/programming/comments/alhj59/creating_a_programming_language_and_cross/
-

examples/arithmetic/aggregates.p8

@@ -104,18 +104,6 @@ main {
         ub = all(farr)
         if ub==0 c64scr.print("error all10\n")
 
-        check_eval_stack()
-
-        c64scr.print("\nyou should see no errors above.")
+        c64scr.print("\nyou should see no errors printed above (only at first run).")
     }
-
-    sub check_eval_stack() {
-        c64scr.print("x=")
-        c64scr.print_ub(X)
-        if X==255
-            c64scr.print(" ok\n")
-        else
-            c64scr.print(" error!\n")
-    }
-
 }

examples/arithmetic/div.p8

@@ -24,8 +24,6 @@ main {
 
         div_float(0,1,0)
         div_float(999.9,111.0,9.008108108108107)
-
-        check_eval_stack()
     }
 
     sub div_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -103,12 +101,4 @@ main {
         c64flt.print_f(r)
         c64.CHROUT('\n')
     }
-
-    sub check_eval_stack() {
-        if X!=255 {
-            c64scr.print("x=")
-            c64scr.print_ub(X)
-            c64scr.print(" error!\n")
-        }
-    }
 }

examples/arithmetic/minus.p8

@@ -32,8 +32,6 @@ main {
         minus_float(0,0,0)
         minus_float(2.5,1.5,1.0)
         minus_float(-1.5,3.5,-5.0)
-
-        check_eval_stack()
     }
 
     sub minus_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -111,13 +109,4 @@ main {
         c64flt.print_f(r)
         c64.CHROUT('\n')
     }
-
-    sub check_eval_stack() {
-        if X!=255 {
-            c64scr.print("x=")
-            c64scr.print_ub(X)
-            c64scr.print(" error!\n")
-        }
-    }
-
 }

examples/arithmetic/mult.p8

@@ -26,8 +26,6 @@ main {
         mul_float(0,0,0)
         mul_float(2.5,10,25)
         mul_float(-1.5,10,-15)
-
-        check_eval_stack()
     }
 
     sub mul_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -105,12 +103,4 @@ main {
         c64flt.print_f(r)
         c64.CHROUT('\n')
     }
-
-    sub check_eval_stack() {
-        if X!=255 {
-            c64scr.print("x=")
-            c64scr.print_ub(X)
-            c64scr.print(" error!\n")
-        }
-    }
 }

examples/arithmetic/plus.p8

@@ -30,8 +30,6 @@ main {
         plus_float(1.5,2.5,4.0)
         plus_float(-1.5,3.5,2.0)
         plus_float(-1.1,3.3,2.2)
-
-        check_eval_stack()
     }
 
     sub plus_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -109,13 +107,4 @@ main {
         c64flt.print_f(r)
         c64.CHROUT('\n')
     }
-
-    sub check_eval_stack() {
-        if X!=255 {
-            c64scr.print("x=")
-            c64scr.print_ub(X)
-            c64scr.print(" error!\n")
-        }
-    }
-
 }

examples/arithmetic/postincrdecr.p8

@@ -9,6 +9,7 @@ main {
 
         c64scr.plot(0,24)
 
+        ubyte Y
         ubyte ub=200
         byte bb=-100
         uword uw = 2000
@@ -76,8 +77,6 @@ main {
         check_b(barr[1], -100)
         check_uw(uwarr[1], 2000)
         check_w(warr[1], -1000)
-
-        check_eval_stack()
     }
 
     sub check_ub(ubyte value, ubyte expected) {
@@ -139,13 +138,4 @@ main {
         c64flt.print_f(expected)
         c64.CHROUT('\n')
     }
-
-
-    sub check_eval_stack() {
-        if X!=255 {
-            c64scr.print("x=")
-            c64scr.print_ub(X)
-            c64scr.print(" error!\n")
-        }
-    }
 }

examples/arithmetic/remainder.p8

@@ -15,8 +15,6 @@ main {
         remainder_uword(40000,511,142)
         remainder_uword(40000,500,0)
         remainder_uword(43211,12,11)
-
-        check_eval_stack()
     }
 
     sub remainder_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -48,12 +46,4 @@ main {
         c64scr.print_uw(r)
         c64.CHROUT('\n')
     }
-
-    sub check_eval_stack() {
-        if X!=255 {
-            c64scr.print("x=")
-            c64scr.print_ub(X)
-            c64scr.print(" error!\n")
-        }
-    }
 }

examples/arithmetic/sgn.p8

@@ -79,10 +79,10 @@ main {
 
         uw1 = 2222
         uw2 = 999
-        if sgn(uw2 as word - uw1 as word) != -1
-            c64scr.print("sgn2 error6\n")
-        if sgn(uw2 - uw1) != -1
-            c64scr.print("sgn2 error6\n")
+        if sgn((uw2 as word) - (uw1 as word)) != -1
+            c64scr.print("sgn2 error6a\n")
+        if sgn(uw2 - uw1) != 1      ; always 0 or 1 if unsigned
+            c64scr.print("sgn2 error6b\n")
 
         f1 = 3.45
         f2 = 1.11

examples/balloonflight.p8

@@ -0,0 +1,126 @@
+%import c64lib
+%import c64utils
+%zeropage basicsafe
+
+main {
+
+    ubyte perform_scroll = false
+
+    sub start() {
+        c64.SPRPTR[0] = $0f00 / 64
+        c64.SPENA = 1
+        c64.SP0COL = 14
+        c64.SPXY[0] = 80
+        c64.SPXY[1] = 100
+
+        c64.SCROLX &= %11110111     ; 38 column mode
+
+        c64utils.set_rasterirq(1)     ; enable animation
+
+        ubyte target_height = 10
+        ubyte active_height = 24
+        ubyte upwards = true
+
+        repeat {
+            ubyte mountain = 223        ; slope upwards
+            if active_height < target_height {
+                active_height++
+                upwards = true
+            } else if active_height > target_height {
+                mountain = 233          ; slope downwards
+                active_height--
+                upwards = false
+            } else {
+                target_height = 8 + rnd() % 16
+                if upwards
+                    mountain = 233
+                else
+                    mountain = 223
+            }
+
+            while not perform_scroll {
+                ; let the raster irq do its timing job
+            }
+
+            perform_scroll = false
+            c64scr.scroll_left_full(true)
+            if c64.RASTER & 1
+                c64.SPXY[1] ++
+            else
+                c64.SPXY[1] --
+
+            ubyte yy
+            for yy in 0 to active_height-1 {
+                c64scr.setcc(39, yy, 32, 2)         ; clear top of screen
+            }
+            c64scr.setcc(39, active_height, mountain, 8)    ; mountain edge
+            for yy in active_height+1 to 24 {
+                c64scr.setcc(39, yy, 160, 8)        ; draw mountain
+            }
+
+            yy = rnd()
+            if yy > 100 {
+                ; draw a star
+                c64scr.setcc(39, yy % (active_height-1), '.', rnd())
+            }
+
+            if yy > 200 {
+                ; draw a tree
+                ubyte tree = 30
+                ubyte treecolor = 5
+                if yy & %01000000 != 0
+                    tree = 88
+                else if yy & %00100000 != 0
+                    tree = 65
+                if rnd() > 130
+                    treecolor = 13
+                c64scr.setcc(39, active_height, tree, treecolor)
+            }
+
+            if yy > 235 {
+                ; draw a camel
+                c64scr.setcc(39, active_height, 94, 9)
+            }
+        }
+    }
+}
+
+
+spritedata $0f00 {
+    ; this memory block contains the sprite data
+    ; it must start on an address aligned to 64 bytes.
+    %option force_output    ; make sure the data in this block appears in the resulting program
+
+    ubyte[] balloonsprite = [ %00000000,%01111111,%00000000,
+                              %00000001,%11111111,%11000000,
+                              %00000011,%11111111,%11100000,
+                              %00000011,%11100011,%11100000,
+                              %00000111,%11011100,%11110000,
+                              %00000111,%11011101,%11110000,
+                              %00000111,%11011100,%11110000,
+                              %00000011,%11100011,%11100000,
+                              %00000011,%11111111,%11100000,
+                              %00000011,%11111111,%11100000,
+                              %00000010,%11111111,%10100000,
+                              %00000001,%01111111,%01000000,
+                              %00000001,%00111110,%01000000,
+                              %00000000,%10011100,%10000000,
+                              %00000000,%10011100,%10000000,
+                              %00000000,%01001001,%00000000,
+                              %00000000,%01001001,%00000000,
+                              %00000000,%00111110,%00000000,
+                              %00000000,%00111110,%00000000,
+                              %00000000,%00111110,%00000000,
+                              %00000000,%00011100,%00000000   ]
+}
+
+
+irq {
+    ubyte smoothx=7
+    sub irq() {
+        smoothx = (smoothx-1) & 7
+        main.perform_scroll = smoothx==0
+        c64.SCROLX = (c64.SCROLX & %11111000) | smoothx
+    }
+}
+

examples/bdmusic.p8

@@ -16,7 +16,7 @@ sub start() {
     void c64.CHRIN()
     c64.CLEARSCR()
 
-    forever {
+    repeat {
         uword note
         for note in notes {
             ubyte note1 = lsb(note)
@@ -37,10 +37,8 @@ sub start() {
 }
 
 sub delay() {
-    ubyte d
-    for d in 0 to 12 {
-        while c64.RASTER!=0 {
-            ; tempo delay synced to screen refresh
+    repeat 32 {
+        while c64.RASTER {
         }
     }
 }

examples/c64graphics.p8

@@ -0,0 +1,252 @@
+%import c64lib
+
+; bitmap pixel graphics module for the C64
+; only black/white monchrome for now
+
+; you could put this code at $4000 which is after the bitmap screen in memory ($2000-$3fff),
+; this leaves more space for user program code.
+
+graphics {
+    const uword bitmap_address = $2000
+
+    sub enable_bitmap_mode() {
+        ; enable bitmap screen, erase it and set colors to black/white.
+        c64.SCROLY |= %00100000
+        c64.VMCSB = (c64.VMCSB & %11110000) | %00001000   ; $2000-$3fff
+        memset(bitmap_address, 320*200/8, 0)
+        c64scr.clear_screen($10, 0)         ; pixel color $1 (white) backround $0 (black)
+    }
+
+    sub line(uword x1, ubyte y1, uword x2, ubyte y2) {
+        ; Bresenham algorithm.
+        ; This code special cases various quadrant loops to allow simple ++ and -- operations.
+        if y1>y2 {
+            ; make sure dy is always positive to avoid 8 instead of just 4 special cases
+            swap(x1, x2)
+            swap(y1, y2)
+        }
+        word d = 0
+        ubyte positive_ix = true
+        word dx = x2 - x1 as word
+        word dy = y2 as word - y1 as word
+        if dx < 0 {
+            dx = -dx
+            positive_ix = false
+        }
+        dx *= 2
+        dy *= 2
+        plotx = x1
+
+        if dx >= dy {
+            if positive_ix {
+                repeat {
+                    plot(y1)
+                    if plotx==x2
+                        return
+                    plotx++
+                    d += dy
+                    if d > dx {
+                        y1++
+                        d -= dx
+                    }
+                }
+            } else {
+                repeat {
+                    plot(y1)
+                    if plotx==x2
+                        return
+                    plotx--
+                    d += dy
+                    if d > dx {
+                        y1++
+                        d -= dx
+                    }
+                }
+            }
+        }
+        else {
+            if positive_ix {
+                repeat {
+                    plot(y1)
+                    if y1 == y2
+                        return
+                    y1++
+                    d += dx
+                    if d > dy {
+                        plotx++
+                        d -= dy
+                    }
+                }
+            } else {
+                repeat {
+                    plot(y1)
+                    if y1 == y2
+                        return
+                    y1++
+                    d += dx
+                    if d > dy {
+                        plotx--
+                        d -= dy
+                    }
+                }
+            }
+        }
+    }
+
+    sub circle(uword xcenter, ubyte ycenter, ubyte radius) {
+        ; Midpoint algorithm
+        ubyte ploty
+        ubyte xx = radius
+        ubyte yy = 0
+        byte decisionOver2 = 1-xx as byte
+
+        while xx>=yy {
+            plotx = xcenter + xx
+            ploty = ycenter + yy
+            plot(ploty)
+            plotx = xcenter - xx
+            plot(ploty)
+            plotx = xcenter + xx
+            ploty = ycenter - yy
+            plot(ploty)
+            plotx = xcenter - xx
+            plot(ploty)
+            plotx = xcenter + yy
+            ploty = ycenter + xx
+            plot(ploty)
+            plotx = xcenter - yy
+            plot(ploty)
+            plotx = xcenter + yy
+            ploty = ycenter - xx
+            plot(ploty)
+            plotx = xcenter - yy
+            plot(ploty)
+            yy++
+            if decisionOver2<=0
+                decisionOver2 += 2*yy+1
+            else {
+                xx--
+                decisionOver2 += 2*(yy-xx)+1
+            }
+        }
+    }
+
+    sub disc(uword cx, ubyte cy, ubyte radius) {
+        ; Midpoint algorithm, filled
+        ubyte xx = radius
+        ubyte yy = 0
+        byte decisionOver2 = 1-xx as byte
+
+        while xx>=yy {
+            ubyte cy_plus_yy = cy + yy
+            ubyte cy_min_yy = cy - yy
+            ubyte cy_plus_xx = cy + xx
+            ubyte cy_min_xx = cy - xx
+
+            for plotx in cx to cx+xx {
+                plot(cy_plus_yy)
+                plot(cy_min_yy)
+            }
+            for plotx in cx-xx to cx-1 {
+                plot(cy_plus_yy)
+                plot(cy_min_yy)
+            }
+            for plotx in cx to cx+yy {
+                plot(cy_plus_xx)
+                plot(cy_min_xx)
+            }
+            for plotx in cx-yy to cx {
+                plot(cy_plus_xx)
+                plot(cy_min_xx)
+            }
+            yy++
+            if decisionOver2<=0
+                decisionOver2 += 2*yy+1
+            else {
+                xx--
+                decisionOver2 += 2*(yy-xx)+1
+            }
+        }
+    }
+
+
+; here is the non-asm code for the plot routine below:
+;    sub plot_nonasm(uword px, ubyte py) {
+;        ubyte[] ormask = [128, 64, 32, 16, 8, 4, 2, 1]
+;        uword addr = bitmap_address + 320*(py>>3) + (py & 7) + (px & %0000000111111000)
+;        @(addr) |= ormask[lsb(px) & 7]
+;    }
+
+    uword plotx     ; 0..319        ; separate 'parameter' for plot()
+
+    asmsub plot(ubyte ploty @A) {           ; plotx is 16 bits 0 to 319... doesn't fit in a register
+        %asm {{
+        tay
+        stx  c64.SCRATCH_ZPREGX
+        lda  plotx+1
+        sta  c64.SCRATCH_ZPWORD2+1
+        lsr  a            ; 0
+        sta  c64.SCRATCH_ZPWORD2
+        lda  plotx
+        pha
+        and  #7
+        tax
+
+        lda  _y_lookup_lo,y
+        clc
+        adc  c64.SCRATCH_ZPWORD2
+        sta  c64.SCRATCH_ZPWORD2
+        lda  _y_lookup_hi,y
+        adc  c64.SCRATCH_ZPWORD2+1
+        sta  c64.SCRATCH_ZPWORD2+1
+
+        pla     ; plotx
+        and  #%11111000
+        tay
+        lda  (c64.SCRATCH_ZPWORD2),y
+        ora  _ormask,x
+        sta  (c64.SCRATCH_ZPWORD2),y
+
+        ldx  c64.SCRATCH_ZPREGX
+        rts
+
+_ormask     .byte 128, 64, 32, 16, 8, 4, 2, 1
+
+; note: this can be even faster if we also have a 256 byte x-lookup table, but hey.
+; see http://codebase64.org/doku.php?id=base:various_techniques_to_calculate_adresses_fast_common_screen_formats_for_pixel_graphics
+; the y lookup tables encodes this formula:  bitmap_address + 320*(py>>3) + (py & 7)    (y from 0..199)
+_y_lookup_hi
+            .byte  $20, $20, $20, $20, $20, $20, $20, $20, $21, $21, $21, $21, $21, $21, $21, $21
+            .byte  $22, $22, $22, $22, $22, $22, $22, $22, $23, $23, $23, $23, $23, $23, $23, $23
+            .byte  $25, $25, $25, $25, $25, $25, $25, $25, $26, $26, $26, $26, $26, $26, $26, $26
+            .byte  $27, $27, $27, $27, $27, $27, $27, $27, $28, $28, $28, $28, $28, $28, $28, $28
+            .byte  $2a, $2a, $2a, $2a, $2a, $2a, $2a, $2a, $2b, $2b, $2b, $2b, $2b, $2b, $2b, $2b
+            .byte  $2c, $2c, $2c, $2c, $2c, $2c, $2c, $2c, $2d, $2d, $2d, $2d, $2d, $2d, $2d, $2d
+            .byte  $2f, $2f, $2f, $2f, $2f, $2f, $2f, $2f, $30, $30, $30, $30, $30, $30, $30, $30
+            .byte  $31, $31, $31, $31, $31, $31, $31, $31, $32, $32, $32, $32, $32, $32, $32, $32
+            .byte  $34, $34, $34, $34, $34, $34, $34, $34, $35, $35, $35, $35, $35, $35, $35, $35
+            .byte  $36, $36, $36, $36, $36, $36, $36, $36, $37, $37, $37, $37, $37, $37, $37, $37
+            .byte  $39, $39, $39, $39, $39, $39, $39, $39, $3a, $3a, $3a, $3a, $3a, $3a, $3a, $3a
+            .byte  $3b, $3b, $3b, $3b, $3b, $3b, $3b, $3b, $3c, $3c, $3c, $3c, $3c, $3c, $3c, $3c
+            .byte  $3e, $3e, $3e, $3e, $3e, $3e, $3e, $3e
+
+_y_lookup_lo
+            .byte $00, $01, $02, $03, $04, $05, $06, $07, $40, $41, $42, $43, $44, $45, $46, $47
+            .byte $80, $81, $82, $83, $84, $85, $86, $87, $c0, $c1, $c2, $c3, $c4, $c5, $c6, $c7
+            .byte $00, $01, $02, $03, $04, $05, $06, $07, $40, $41, $42, $43, $44, $45, $46, $47
+            .byte $80, $81, $82, $83, $84, $85, $86, $87, $c0, $c1, $c2, $c3, $c4, $c5, $c6, $c7
+            .byte $00, $01, $02, $03, $04, $05, $06, $07, $40, $41, $42, $43, $44, $45, $46, $47
+            .byte $80, $81, $82, $83, $84, $85, $86, $87, $c0, $c1, $c2, $c3, $c4, $c5, $c6, $c7
+            .byte $00, $01, $02, $03, $04, $05, $06, $07, $40, $41, $42, $43, $44, $45, $46, $47
+            .byte $80, $81, $82, $83, $84, $85, $86, $87, $c0, $c1, $c2, $c3, $c4, $c5, $c6, $c7
+            .byte $00, $01, $02, $03, $04, $05, $06, $07, $40, $41, $42, $43, $44, $45, $46, $47
+            .byte $80, $81, $82, $83, $84, $85, $86, $87, $c0, $c1, $c2, $c3, $c4, $c5, $c6, $c7
+            .byte $00, $01, $02, $03, $04, $05, $06, $07, $40, $41, $42, $43, $44, $45, $46, $47
+            .byte $80, $81, $82, $83, $84, $85, $86, $87, $c0, $c1, $c2, $c3, $c4, $c5, $c6, $c7
+            .byte $00, $01, $02, $03, $04, $05, $06, $07
+        }}
+    }
+
+}
+
+

examples/comparison_ifs_byte.p8

@@ -105,17 +105,5 @@ main {
             c64scr.print("ok: 22 >= 22\n")
         else
             c64scr.print("error in 22>=22!\n")
-
-        check_eval_stack()
-    }
-
-
-    sub check_eval_stack() {
-        c64scr.print("stack x=")
-        c64scr.print_ub(X)
-        if X==255
-            c64scr.print(" ok\n")
-        else
-            c64scr.print(" error!\n")
     }
 }

examples/comparison_ifs_float.p8

@@ -105,17 +105,5 @@ main {
             c64scr.print("ok: -22.2 >= -22.2\n")
         else
             c64scr.print("error in -22.2>=-22.2!\n")
-
-        check_eval_stack()
     }
-
-    sub check_eval_stack() {
-        c64scr.print("stack x=")
-        c64scr.print_ub(X)
-        if X==255
-            c64scr.print(" ok\n")
-        else
-            c64scr.print(" error!\n")
-    }
-
 }

examples/comparison_ifs_ubyte.p8

@@ -105,17 +105,5 @@ main {
             c64scr.print("ok: 22 >= 22\n")
         else
             c64scr.print("error in 22>=22!\n")
-
-        check_eval_stack()
     }
-
-    sub check_eval_stack() {
-        c64scr.print("stack x=")
-        c64scr.print_ub(X)
-        if X==255
-            c64scr.print(" ok\n")
-        else
-            c64scr.print(" error!\n")
-    }
-
 }

examples/comparison_ifs_uword.p8

@@ -105,17 +105,5 @@ main {
             c64scr.print("ok: 322 >= 322\n")
         else
             c64scr.print("error in 322>=322!\n")
-
-        check_eval_stack()
     }
-
-    sub check_eval_stack() {
-        c64scr.print("stack x=")
-        c64scr.print_ub(X)
-        if X==255
-            c64scr.print(" ok\n")
-        else
-            c64scr.print(" error!\n")
-    }
-
 }

examples/comparison_ifs_word.p8

@@ -137,17 +137,5 @@ main {
             c64scr.print("ok: 1000 >= 1000\n")
         else
             c64scr.print("error in 1000>=1000!\n")
-
-        check_eval_stack()
     }
-
-    sub check_eval_stack() {
-        c64scr.print("stack x=")
-        c64scr.print_ub(X)
-        if X==255
-            c64scr.print(" ok\n")
-        else
-            c64scr.print(" error!\n")
-    }
-
 }

examples/comparisons_byte.p8

@@ -52,7 +52,6 @@ main {
         c64scr.print("v1=20, v2=-111\n")
         compare()
 
-        check_eval_stack()
         return
 
         sub compare() {
@@ -91,14 +90,4 @@ main {
     }
 
     }
-
-    sub check_eval_stack() {
-        c64scr.print("stack x=")
-        c64scr.print_ub(X)
-        if X==255
-            c64scr.print(" ok\n")
-        else
-            c64scr.print(" error!\n")
-    }
-
 }

examples/comparisons_float.p8

@@ -68,7 +68,6 @@ main {
         c64scr.print("v1 = v2 = 0\n")
         compare()
 
-        check_eval_stack()
         return
 
         sub compare() {
@@ -108,12 +107,4 @@ main {
 
     }
 
-    sub check_eval_stack() {
-        c64scr.print("stack x=")
-        c64scr.print_ub(X)
-        if X==255
-            c64scr.print(" ok\n")
-        else
-            c64scr.print(" error!\n")
-    }
 }

examples/comparisons_ubyte.p8

@@ -52,7 +52,6 @@ main {
         c64scr.print("v1=220, v2=10\n")
         compare()
 
-        check_eval_stack()
         return
 
         sub compare() {
@@ -92,13 +91,4 @@ main {
 
     }
 
-    sub check_eval_stack() {
-        c64scr.print("stack x=")
-        c64scr.print_ub(X)
-        if X==255
-            c64scr.print(" ok\n")
-        else
-            c64scr.print(" error!\n")
-    }
-
 }

examples/comparisons_uword.p8

@@ -82,7 +82,6 @@ main {
         c64scr.print("v1 = v2 = aa\n")
         compare()
 
-        check_eval_stack()
         return
 
         sub compare() {
@@ -121,14 +120,4 @@ main {
     }
 
     }
-
-    sub check_eval_stack() {
-        c64scr.print("stack x=")
-        c64scr.print_ub(X)
-        if X==255
-            c64scr.print(" ok\n")
-        else
-            c64scr.print(" error!\n")
-    }
-
 }

examples/comparisons_word.p8

@@ -118,7 +118,6 @@ main {
         c64scr.print("v1 = v2 = aa\n")
         compare()
 
-        check_eval_stack()
         return
 
         sub compare() {
@@ -157,14 +156,4 @@ main {
     }
 
     }
-
-    sub check_eval_stack() {
-        c64scr.print("stack x=")
-        c64scr.print_ub(X)
-        if X==255
-            c64scr.print(" ok\n")
-        else
-            c64scr.print(" error!\n")
-    }
-
 }