v2.2

This may change later by introducing a compiler option to choose a strategy, perhaps.

.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
 ===========================================================================
@@ -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'
@@ -34,6 +34,7 @@ dependencies {
     implementation 'org.antlr:antlr4-runtime:4.8'
     implementation 'org.jetbrains.kotlinx:kotlinx-cli-jvm:0.1.0-dev-5'
     // implementation 'net.razorvine:ksim65:1.6'
+    // implementation "com.github.hypfvieh:dbus-java:3.2.0"
     implementation project(':parser')
 
     testImplementation "org.jetbrains.kotlin:kotlin-test-junit5"
@@ -100,7 +101,7 @@ test {
 
     // Show test results.
     testLogging {
-        events "passed", "skipped", "failed"
+        events "skipped", "failed"
     }
 }
 

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,45 @@ 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

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
@@ -975,6 +893,7 @@ asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
 	%asm {{
 	    stx  c64.SCRATCH_ZPREGX
 		jsr  c64utils.uword2decimal
+		ldx  c64.SCRATCH_ZPREGX
 		ldy  #0
 -		lda  c64utils.uword2decimal.decTenThousands,y
 		beq  _allzero

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

@@ -651,6 +651,18 @@ greatereq_w	.proc
 		bmi  equal_b._equal_b_false
 		.pend
 
+
+orig_stackpointer	.byte  0	; stores the Stack pointer register at program start
+
+func_exit	.proc
+		; -- immediately exit the program with a return code in the A register
+		lda  c64.ESTACK_LO+1,x
+		ldx  orig_stackpointer
+		txs
+		rts		; return to original caller
+		.pend
+
+
 func_read_flags	.proc
 		; -- put the processor status register on the stack
 		php
@@ -1776,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
@@ -1791,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.80
+2.2

compiler/src/prog8/CompilerMain.kt

@@ -2,13 +2,13 @@ package prog8
 
 import kotlinx.cli.*
 import prog8.ast.base.AstException
-import prog8.compiler.*
+import prog8.compiler.CompilationResult
+import prog8.compiler.compileProgram
 import prog8.compiler.target.CompilationTarget
 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
@@ -39,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)
@@ -118,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(" = ")
@@ -331,6 +327,11 @@ 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.body.accept(this)

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 RepeatLoop -> 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
@@ -158,6 +161,31 @@ interface INameScope {
         if(!statements.remove(stmt))
             throw FatalAstException("stmt to remove wasn't found in scope")
     }
+
+    fun getAllLabels(label: String): List<Label> {
+        val result = mutableListOf<Label>()
+
+        fun find(scope: INameScope) {
+            scope.statements.forEach {
+                when(it) {
+                    is Label -> result.add(it)
+                    is INameScope -> find(it)
+                    is IfStatement -> {
+                        find(it.truepart)
+                        find(it.elsepart)
+                    }
+                    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 */ }
+                }
+            }
+        }
+
+        find(this)
+        return result
+    }
 }
 
 interface IAssignable {
@@ -167,7 +195,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
@@ -182,11 +210,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.indexOf(node)
+        modules[idx] = replacement
+        replacement.parent = this
+    }
 }
 
 class Module(override val name: String,
@@ -194,6 +240,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>()
@@ -207,10 +254,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.indexOf(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)
@@ -221,6 +278,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
@@ -246,7 +307,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 NameError("wrong identifier target: $stmt", stmt.position)
+            else -> throw SyntaxError("wrong identifier target for $scopedName: $stmt", stmt.position)
         }
     }
 }

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

@@ -19,13 +19,13 @@ import java.nio.file.Path
 
 private data class NumericLiteral(val number: Number, val datatype: DataType)
 
-
-fun prog8Parser.ModuleContext.toAst(name: String, isLibrary: Boolean, source: Path) : Module {
+internal fun prog8Parser.ModuleContext.toAst(name: String, isLibrary: Boolean, source: Path) : Module {
     val nameWithoutSuffix = if(name.endsWith(".p8")) name.substringBeforeLast('.') else name
-    return Module(nameWithoutSuffix, modulestatement().asSequence().map { it.toAst(isLibrary) }.toMutableList(), toPosition(), isLibrary, source)
+    val directives = this.directive().map { it.toAst() }
+    val blocks = this.block().map { it.toAst(isLibrary) }
+    return Module(nameWithoutSuffix, (directives + blocks).toMutableList(), toPosition(), isLibrary, source)
 }
 
-
 private fun ParserRuleContext.toPosition() : Position {
     val customTokensource = this.start.tokenSource as? CustomLexer
     val filename =
@@ -38,27 +38,23 @@ private fun ParserRuleContext.toPosition() : Position {
     return Position(filename, start.line, start.charPositionInLine, stop.charPositionInLine + stop.text.length)
 }
 
-
-private fun prog8Parser.ModulestatementContext.toAst(isInLibrary: Boolean) : Statement {
-    val directive = directive()?.toAst()
-    if(directive!=null) return directive
-
-    val block = block()?.toAst(isInLibrary)
-    if(block!=null) return block
-
-    throw FatalAstException(text)
+private fun prog8Parser.BlockContext.toAst(isInLibrary: Boolean) : Statement {
+    val blockstatements = block_statement().map {
+        when {
+            it.variabledeclaration()!=null -> it.variabledeclaration().toAst()
+            it.subroutinedeclaration()!=null -> it.subroutinedeclaration().toAst()
+            it.directive()!=null -> it.directive().toAst()
+            it.inlineasm()!=null -> it.inlineasm().toAst()
+            else -> throw FatalAstException("weird block statement $it")
+        }
+    }
+    return Block(identifier().text, integerliteral()?.toAst()?.number?.toInt(), blockstatements.toMutableList(), isInLibrary, toPosition())
 }
 
-
-private fun prog8Parser.BlockContext.toAst(isInLibrary: Boolean) : Statement =
-        Block(identifier().text, integerliteral()?.toAst()?.number?.toInt(), statement_block().toAst(), isInLibrary, toPosition())
-
-
 private fun prog8Parser.Statement_blockContext.toAst(): MutableList<Statement> =
         statement().asSequence().map { it.toAst() }.toMutableList()
 
-
-private fun prog8Parser.StatementContext.toAst() : Statement {
+private fun prog8Parser.VariabledeclarationContext.toAst() : Statement {
     vardecl()?.let { return it.toAst() }
 
     varinitializer()?.let {
@@ -66,7 +62,7 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
         return VarDecl(
                 VarDeclType.VAR,
                 vd.datatype()?.toAst() ?: DataType.STRUCT,
-                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                if (vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
                 vd.arrayindex()?.toAst(),
                 vd.varname.text,
                 null,
@@ -114,7 +110,7 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
         return VarDecl(
                 VarDeclType.CONST,
                 vd.datatype()?.toAst() ?: DataType.STRUCT,
-                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                if (vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
                 vd.arrayindex()?.toAst(),
                 vd.varname.text,
                 null,
@@ -131,7 +127,7 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
         return VarDecl(
                 VarDeclType.MEMORY,
                 vd.datatype()?.toAst() ?: DataType.STRUCT,
-                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                if (vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
                 vd.arrayindex()?.toAst(),
                 vd.varname.text,
                 null,
@@ -142,6 +138,28 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
         )
     }
 
+    structdecl()?.let {
+        return StructDecl(it.identifier().text,
+                it.vardecl().map { vd->vd.toAst() }.toMutableList(),
+                toPosition())
+    }
+
+    throw FatalAstException("weird variable decl $this")
+}
+
+private fun prog8Parser.SubroutinedeclarationContext.toAst() : Subroutine {
+    return when {
+        subroutine()!=null -> subroutine().toAst()
+        asmsubroutine()!=null -> asmsubroutine().toAst()
+        romsubroutine()!=null -> romsubroutine().toAst()
+        else -> throw FatalAstException("weird subroutine decl $this")
+    }
+}
+
+private fun prog8Parser.StatementContext.toAst() : Statement {
+    val vardecl = variabledeclaration()?.toAst()
+    if(vardecl!=null) return vardecl
+
     assignment()?.let {
         return Assignment(it.assign_target().toAst(), null, it.expression().toAst(), it.toPosition())
     }
@@ -175,8 +193,8 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
     val returnstmt = returnstmt()?.toAst()
     if(returnstmt!=null) return returnstmt
 
-    val sub = subroutine()?.toAst()
-    if(sub!=null) return sub
+    val subroutine = subroutinedeclaration()?.toAst()
+    if(subroutine!=null) return subroutine
 
     val asm = inlineasm()?.toAst()
     if(asm!=null) return asm
@@ -193,31 +211,22 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
     val whileloop = whileloop()?.toAst()
     if(whileloop!=null) return whileloop
 
+    val foreverloop = foreverloop()?.toAst()
+    if(foreverloop!=null) return foreverloop
+
     val breakstmt = breakstmt()?.toAst()
     if(breakstmt!=null) return breakstmt
 
     val continuestmt = continuestmt()?.toAst()
     if(continuestmt!=null) return continuestmt
 
-    val asmsubstmt = asmsubroutine()?.toAst()
-    if(asmsubstmt!=null) return asmsubstmt
-
-    val romsubstmt = romsubroutine()?.toAst()
-    if(romsubstmt!=null) return romsubstmt
-
     val whenstmt = whenstmt()?.toAst()
     if(whenstmt!=null) return whenstmt
 
-    structdecl()?.let {
-        return StructDecl(it.identifier().text,
-                it.vardecl().map { vd->vd.toAst() }.toMutableList(),
-                toPosition())
-    }
-
     throw FatalAstException("unprocessed source text (are we missing ast conversion rules for parser elements?): $text")
 }
 
-private fun prog8Parser.AsmsubroutineContext.toAst(): Statement {
+private fun prog8Parser.AsmsubroutineContext.toAst(): Subroutine {
     val subdecl = asmsub_decl().toAst()
     val statements = statement_block()?.toAst() ?: mutableListOf()
     return Subroutine(subdecl.name, subdecl.parameters, subdecl.returntypes,
@@ -225,7 +234,7 @@ private fun prog8Parser.AsmsubroutineContext.toAst(): Statement {
             subdecl.asmClobbers, null, true, statements, toPosition())
 }
 
-private fun prog8Parser.RomsubroutineContext.toAst(): Statement {
+private fun prog8Parser.RomsubroutineContext.toAst(): Subroutine {
     val subdecl = asmsub_decl().toAst()
     val address = integerliteral().toAst().number.toInt()
     return Subroutine(subdecl.name, subdecl.parameters, subdecl.returntypes,
@@ -233,7 +242,6 @@ private fun prog8Parser.RomsubroutineContext.toAst(): Statement {
             subdecl.asmClobbers, address, true, mutableListOf(), toPosition())
 }
 
-
 private class AsmsubDecl(val name: String,
                          val parameters: List<SubroutineParameter>,
                          val returntypes: List<DataType>,
@@ -241,7 +249,6 @@ private class AsmsubDecl(val name: String,
                          val asmReturnvaluesRegisters: List<RegisterOrStatusflag>,
                          val asmClobbers: Set<Register>)
 
-
 private fun prog8Parser.Asmsub_declContext.toAst(): AsmsubDecl {
     val name = identifier().text
     val params = asmsub_params()?.toAst() ?: emptyList()
@@ -254,7 +261,6 @@ private fun prog8Parser.Asmsub_declContext.toAst(): AsmsubDecl {
     return AsmsubDecl(name, normalParameters, normalReturntypes, paramRegisters, returnRegisters, clobbers)
 }
 
-
 private class AsmSubroutineParameter(name: String,
                                      type: DataType,
                                      val registerOrPair: RegisterOrPair?,
@@ -271,7 +277,6 @@ private class AsmSubroutineReturn(val type: DataType,
 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()) }
 
@@ -285,10 +290,8 @@ private fun prog8Parser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParamete
             !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()
@@ -298,7 +301,6 @@ private fun prog8Parser.Functioncall_stmtContext.toAst(): Statement {
         FunctionCallStatement(location, expression_list().toAst().toMutableList(), void, toPosition())
 }
 
-
 private fun prog8Parser.FunctioncallContext.toAst(): FunctionCall {
     val location = scoped_identifier().toAst()
     return if(expression_list() == null)
@@ -307,11 +309,9 @@ private fun prog8Parser.FunctioncallContext.toAst(): FunctionCall {
         FunctionCall(location, expression_list().toAst().toMutableList(), toPosition())
 }
 
-
 private fun prog8Parser.InlineasmContext.toAst() =
         InlineAssembly(INLINEASMBLOCK().text, toPosition())
 
-
 private fun prog8Parser.ReturnstmtContext.toAst() : Return {
     return Return(expression()?.toAst(), toPosition())
 }
@@ -322,11 +322,9 @@ private fun prog8Parser.UnconditionaljumpContext.toAst(): Jump {
     return Jump(address, identifier, null, toPosition())
 }
 
-
 private fun prog8Parser.LabeldefContext.toAst(): Statement =
         Label(children[0].text, toPosition())
 
-
 private fun prog8Parser.SubroutineContext.toAst() : Subroutine {
     return Subroutine(identifier().text,
             sub_params()?.toAst() ?: emptyList(),
@@ -345,14 +343,12 @@ private fun prog8Parser.Sub_return_partContext.toAst(): List<DataType> {
     return returns.datatype().map { it.toAst() }
 }
 
-
 private fun prog8Parser.Sub_paramsContext.toAst(): List<SubroutineParameter> =
         vardecl().map {
             val datatype = it.datatype()?.toAst() ?: DataType.STRUCT
             SubroutineParameter(it.varname.text, datatype, it.toPosition())
         }
 
-
 private fun prog8Parser.Assign_targetContext.toAst() : AssignTarget {
     val register = register()?.toAst()
     val identifier = scoped_identifier()
@@ -371,15 +367,12 @@ private fun prog8Parser.DatatypeContext.toAst() = DataType.valueOf(text.toUpperC
 
 private fun prog8Parser.RegisterorpairContext.toAst() = RegisterOrPair.valueOf(text.toUpperCase())
 
-
 private fun prog8Parser.ArrayindexContext.toAst() : ArrayIndex =
         ArrayIndex(expression().toAst(), toPosition())
 
-
 private fun prog8Parser.DirectiveContext.toAst() : Directive =
         Directive(directivename.text, directivearg().map { it.toAst() }, toPosition())
 
-
 private fun prog8Parser.DirectiveargContext.toAst() : DirectiveArg {
     val str = stringliteral()
     if(str?.ALT_STRING_ENCODING() != null)
@@ -388,7 +381,6 @@ private fun prog8Parser.DirectiveargContext.toAst() : DirectiveArg {
     return DirectiveArg(stringliteral()?.text, identifier()?.text, integerliteral()?.toAst()?.number?.toInt(), toPosition())
 }
 
-
 private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
     fun makeLiteral(text: String, radix: Int, forceWord: Boolean): NumericLiteral {
         val integer: Int
@@ -440,7 +432,6 @@ private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
     }
 }
 
-
 private fun prog8Parser.ExpressionContext.toAst() : Expression {
 
     val litval = literalvalue()
@@ -526,39 +517,31 @@ private fun prog8Parser.ExpressionContext.toAst() : Expression {
     throw FatalAstException(text)
 }
 
-
 private fun prog8Parser.StringliteralContext.toAst(): StringLiteralValue =
     StringLiteralValue(unescape(this.STRING().text, toPosition()), ALT_STRING_ENCODING()!=null, toPosition())
 
-
 private fun prog8Parser.ArrayindexedContext.toAst(): ArrayIndexedExpression {
     return ArrayIndexedExpression(scoped_identifier().toAst(),
             arrayindex().toAst(),
             toPosition())
 }
 
-
 private fun prog8Parser.Expression_listContext.toAst() = expression().map{ it.toAst() }
 
-
 private fun prog8Parser.IdentifierContext.toAst() : IdentifierReference =
         IdentifierReference(listOf(text), toPosition())
 
-
 private fun prog8Parser.Scoped_identifierContext.toAst() : IdentifierReference =
         IdentifierReference(NAME().map { it.text }, toPosition())
 
-
 private fun prog8Parser.FloatliteralContext.toAst() = text.toDouble()
 
-
 private fun prog8Parser.BooleanliteralContext.toAst() = when(text) {
     "true" -> true
     "false" -> false
     else -> throw FatalAstException(text)
 }
 
-
 private fun prog8Parser.ArrayliteralContext.toAst() : Array<Expression> =
         expression().map { it.toAst() }.toTypedArray()
 
@@ -576,7 +559,6 @@ private fun prog8Parser.Else_partContext.toAst(): MutableList<Statement> {
     return statement_block()?.toAst() ?: mutableListOf(statement().toAst())
 }
 
-
 private fun prog8Parser.Branch_stmtContext.toAst(): BranchStatement {
     val branchcondition = branchcondition().toAst()
     val trueStatements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
@@ -589,7 +571,6 @@ 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()
@@ -602,12 +583,10 @@ private fun prog8Parser.ForloopContext.toAst(): ForLoop {
     return ForLoop(loopregister, loopvar, iterable, scope, toPosition())
 }
 
-
 private fun prog8Parser.ContinuestmtContext.toAst() = Continue(toPosition())
 
 private fun prog8Parser.BreakstmtContext.toAst() = Break(toPosition())
 
-
 private fun prog8Parser.WhileloopContext.toAst(): WhileLoop {
     val condition = expression().toAst()
     val statements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
@@ -616,6 +595,12 @@ private fun prog8Parser.WhileloopContext.toAst(): WhileLoop {
     return WhileLoop(condition, scope, toPosition())
 }
 
+private fun prog8Parser.ForeverloopContext.toAst(): ForeverLoop {
+    val statements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+    val scope = AnonymousScope(statements, statement_block()?.toPosition()
+            ?: statement().toPosition())
+    return ForeverLoop(scope, toPosition())
+}
 
 private fun prog8Parser.RepeatloopContext.toAst(): RepeatLoop {
     val untilCondition = expression().toAst()
@@ -681,4 +666,3 @@ internal fun unescape(str: String, position: Position): String {
     }
     return result.joinToString("")
 }
-

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)
@@ -150,8 +150,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

@@ -3,35 +3,42 @@ package prog8.ast.base
 import prog8.parser.ParsingFailedError
 
 
-fun printErrors(errors: List<Any>, moduleName: String) {
-    val reportedMessages = mutableSetOf<String>()
-    System.err.print("\u001b[91m")  // bright red
-    errors.forEach {
-        val msg = it.toString()
-        if(msg !in reportedMessages) {
-            System.err.println(msg)
-            reportedMessages.add(msg)
-        }
+class ErrorReporter {
+    private enum class MessageSeverity {
+        WARNING,
+        ERROR
     }
-    System.err.print("\u001b[0m")  // reset color
-    if(reportedMessages.isNotEmpty())
-        throw ParsingFailedError("There are ${reportedMessages.size} errors in module '$moduleName'.")
-}
-
-
-fun printWarning(msg: String, position: Position, detailInfo: String?=null) {
-    print("\u001b[93m")  // bright yellow
-    print("$position Warning: $msg")
-    if(detailInfo==null)
-        print("\n")
-    else
-        println(": $detailInfo\n")
-    print("\u001b[0m")  // normal
-}
-
-
-fun printWarning(msg: String) {
-    print("\u001b[93m")  // bright yellow
-    print("Warning: $msg")
-    print("\u001b[0m\n")  // normal
+    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 handle() {
+        var numErrors = 0
+        var numWarnings = 0
+        messages.forEach {
+            when(it.severity) {
+                MessageSeverity.ERROR -> System.err.print("\u001b[91m")  // bright red
+                MessageSeverity.WARNING -> System.err.print("\u001b[93m")  // bright yellow
+            }
+            val msg = "${it.position} ${it.severity} ${it.message}".trim()
+            if(msg !in alreadyReportedMessages) {
+                System.err.println(msg)
+                alreadyReportedMessages.add(msg)
+                when(it.severity) {
+                    MessageSeverity.WARNING -> numWarnings++
+                    MessageSeverity.ERROR -> numErrors++
+                }
+            }
+            System.err.print("\u001b[0m")  // reset color
+        }
+        messages.clear()
+        if(numErrors>0)
+            throw ParsingFailedError("There are $numErrors errors and $numWarnings warnings.")
+    }
+
+    fun isEmpty() = messages.isEmpty()
 }

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

@@ -2,21 +2,17 @@ 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)
 
-class SyntaxError(override var message: String, val position: Position) : AstException(message) {
+open class SyntaxError(override var message: String, val position: Position) : AstException(message) {
     override fun toString() = "$position Syntax error: $message"
 }
 
-open class NameError(override var message: String, val position: Position) : AstException(message) {
-    override fun toString() = "$position Name error: $message"
-}
-
 class ExpressionError(message: String, val position: Position) : AstException(message) {
     override fun toString() = "$position Error: $message"
 }
 
 class UndefinedSymbolError(symbol: IdentifierReference)
-    : NameError("undefined symbol: ${symbol.nameInSource.joinToString(".")}", symbol.position)
+    : SyntaxError("undefined symbol: ${symbol.nameInSource.joinToString(".")}", symbol.position)

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

@@ -4,66 +4,74 @@ import prog8.ast.Module
 import prog8.ast.Program
 import prog8.ast.processing.*
 import prog8.compiler.CompilationOptions
-import prog8.optimizer.FlattenAnonymousScopesAndRemoveNops
+import prog8.compiler.BeforeAsmGenerationAstChanger
+import prog8.optimizer.AssignmentTransformer
+import prog8.optimizer.FlattenAnonymousScopesAndNopRemover
 
 
-// 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)
-}
-
-
-internal fun Program.checkValid(compilerOptions: CompilationOptions) {
-    val checker = AstChecker(this, compilerOptions)
+internal fun Program.checkValid(compilerOptions: CompilationOptions, errors: ErrorReporter) {
+    val checker = AstChecker(this, compilerOptions, errors)
     checker.visit(this)
-    printErrors(checker.result(), name)
 }
 
-
-internal fun Program.anonscopeVarsCleanup() {
-    val mover = AnonymousScopeVarsCleanup(this)
-    mover.visit(this)
-    printErrors(mover.result(), name)
+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() {
-    val caster = TypecastsAdder(this)
+internal fun Program.addTypecasts(errors: ErrorReporter) {
+    val caster = TypecastsAdder(this, errors)
     caster.visit(this)
+    caster.applyModifications()
+}
+
+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 checker = ImportedModuleDirectiveRemover()
-    checker.visit(this)
-    printErrors(checker.result(), name)
+    val imr = ImportedModuleDirectiveRemover()
+    imr.visit(this, this.parent)
+    imr.applyModifications()
 }
 
-internal fun Program.checkRecursion() {
-    val checker = AstRecursionChecker(namespace)
+internal fun Program.checkRecursion(errors: ErrorReporter) {
+    val checker = AstRecursionChecker(namespace, errors)
     checker.visit(this)
-    printErrors(checker.result(), name)
+    checker.processMessages(name)
 }
 
+internal fun Program.checkIdentifiers(errors: ErrorReporter) {
 
-internal fun Program.checkIdentifiers() {
-    val checker = AstIdentifiersChecker(this)
-    checker.visit(this)
+    val checker2 = AstIdentifiersChecker(this, errors)
+    checker2.visit(this)
 
-    if(modules.map {it.name}.toSet().size != modules.size) {
-        throw FatalAstException("modules should all be unique")
+    if(errors.isEmpty()) {
+        val transforms = AstVariousTransforms(this)
+        transforms.visit(this)
+        transforms.applyModifications()
     }
 
-    printErrors(checker.result(), name)
+    if (modules.map { it.name }.toSet().size != modules.size) {
+        throw FatalAstException("modules should all be unique")
+    }
+}
+
+internal fun Program.removeNopsFlattenAnonScopes() {
+    val flattener = FlattenAnonymousScopesAndNopRemover()
+    flattener.visit(this)
 }

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

@@ -3,14 +3,15 @@ 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.Objects
+import java.util.*
 import kotlin.math.abs
 
 
@@ -19,8 +20,8 @@ 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 accept(visitor: AstWalker, parent: Node)
     abstract fun referencesIdentifiers(vararg name: String): Boolean     // todo: remove this and add identifier usage tracking into CallGraph instead
     abstract fun inferType(program: Program): InferredTypes.InferredType
 
@@ -56,9 +57,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 +104,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 +121,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 +224,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 +264,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 +295,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 +316,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 +374,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)"
 
@@ -413,9 +466,14 @@ class StructLiteralValue(var values: List<Expression>,
         values.forEach { it.linkParents(this) }
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        throw FatalAstException("can't replace here")
+    }
+
     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) = values.any { it.referencesIdentifiers(*name) }
     override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.STRUCT)
 
@@ -436,10 +494,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 +526,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.indexOf(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 +617,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)
@@ -618,9 +703,14 @@ class RegisterExpr(val register: Register, override val position: Position) : Ex
         this.parent = parent
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        throw FatalAstException("can't replace here")
+    }
+
     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 = register.name in name
     override fun toString(): String {
         return "RegisterExpr(register=$register, pos=$position)"
@@ -645,6 +735,10 @@ data class IdentifierReference(val nameInSource: List<String>, override val posi
         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 +755,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 +794,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.indexOf(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 +834,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/expressions/InferredTypes.kt

@@ -1,7 +1,7 @@
 package prog8.ast.expressions
 
-import java.util.Objects
 import prog8.ast.base.DataType
+import java.util.*
 
 
 object InferredTypes {

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

@@ -1,47 +0,0 @@
-package prog8.ast.processing
-
-import prog8.ast.Program
-import prog8.ast.base.AstException
-import prog8.ast.base.NameError
-import prog8.ast.statements.AnonymousScope
-import prog8.ast.statements.Statement
-import prog8.ast.statements.VarDecl
-
-class AnonymousScopeVarsCleanup(val program: Program): IAstModifyingVisitor {
-    private val checkResult: MutableList<AstException> = mutableListOf()
-    private val varsToMove: MutableMap<AnonymousScope, List<VarDecl>> = mutableMapOf()
-
-    fun result(): List<AstException> {
-        return checkResult
-    }
-
-    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) {
-                    checkResult.add(NameError("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/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,104 +8,74 @@ import prog8.ast.statements.*
 import prog8.compiler.target.CompilationTarget
 import prog8.functions.BuiltinFunctions
 
-
-internal class AstIdentifiersChecker(private val program: Program) : IAstModifyingVisitor {
-
-    private val checkResult: MutableList<AstException> = mutableListOf()
-
+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>>()
-
-    internal fun result(): List<AstException> {
-        return checkResult
-    }
 
     private fun nameError(name: String, position: Position, existing: Statement) {
-        checkResult.add(NameError("name conflict '$name', also defined in ${existing.position.file} line ${existing.position.line}", position))
+        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) {
+        decl.datatypeErrors.forEach { errors.err(it.message, it.position) }
 
-    override fun visit(decl: VarDecl): Statement {
-        // first, check if there are datatype errors on the vardecl
-        decl.datatypeErrors.forEach { checkResult.add(it) }
-
-        // now check the identifier
         if(decl.name in BuiltinFunctions)
-            // the builtin functions can't be redefined
-            checkResult.add(NameError("builtin function cannot be redefined", decl.position))
+            errors.err("builtin function cannot be redefined", decl.position)
 
         if(decl.name in CompilationTarget.machine.opcodeNames)
-            checkResult.add(NameError("can't use a cpu opcode name as a symbol: '${decl.name}'", decl.position))
+            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) {
-                checkResult.add(NameError("undefined struct type", decl.position))
+            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) {
-                checkResult.add(ExpressionError("you cannot initialize a struct using a single value", decl.position))
+            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 StructLiteralValue) {
+                errors.err("initializing requires struct 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) {
-            checkResult.add(NameError("can't use a cpu opcode name as a symbol: '${subroutine.name}'", subroutine.position))
+            errors.err("can't use a cpu opcode name as a symbol: '${subroutine.name}'", subroutine.position)
         } else if(subroutine.name in BuiltinFunctions) {
             // the builtin functions can't be redefined
-            checkResult.add(NameError("builtin function cannot be redefined", subroutine.position))
+            errors.err("builtin function cannot be redefined", subroutine.position)
         } else {
             // already reported elsewhere:
             // if (subroutine.parameters.any { it.name in BuiltinFunctions })
@@ -139,212 +107,65 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
                     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}) {
-                checkResult.add(SyntaxError("asmsub can only contain inline assembly (%asm)", subroutine.position))
+                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)
-            checkResult.add(NameError("can't use a cpu opcode name as a symbol: '${label.name}'", label.position))
+            errors.err("can't use a cpu opcode name as a symbol: '${label.name}'", label.position)
 
         if(label.name in BuiltinFunctions) {
             // the builtin functions can't be redefined
-            checkResult.add(NameError("builtin function cannot be redefined", label.position))
+            errors.err("builtin function cannot be redefined", label.position)
         } else {
-            val existing = program.namespace.lookup(listOf(label.name), label)
-            if (existing != null && existing !== label)
-                nameError(label.name, label.position, existing)
-        }
-        return 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)
-                printWarning("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'
-                    }
+            val existing = label.definingSubroutine()?.getAllLabels(label.name) ?: emptyList()
+            for(el in existing) {
+                if(el === label || el.name != label.name)
+                    continue
+                else {
+                    nameError(label.name, label.position, el)
+                    break
                 }
             }
         }
-        return super.visit(forLoop)
+
+        super.visit(label)
     }
 
-    override fun visit(assignTarget: AssignTarget): AssignTarget {
+    override fun visit(forLoop: ForLoop) {
+        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)
+        }
+
+        super.visit(forLoop)
+    }
+
+    override fun visit(assignTarget: AssignTarget) {
         if(assignTarget.register== Register.X)
-            printWarning("writing to the X register is dangerous, because it's used as an internal pointer", assignTarget.position)
-        return super.visit(assignTarget)
+            errors.warn("writing to the X register is dangerous, because it's used as an internal pointer", assignTarget.position)
+        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(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(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)
-                checkResult.add(ExpressionError("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)
-                checkResult.add(SyntaxError("structs can only contain numerical types", decl.position))
+                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

@@ -1,21 +1,23 @@
 package prog8.ast.processing
 
 import prog8.ast.INameScope
-import prog8.ast.base.AstException
+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
 
 
-internal class AstRecursionChecker(private val namespace: INameScope) : IAstVisitor {
+internal class AstRecursionChecker(private val namespace: INameScope,
+                                   private val errors: ErrorReporter) : IAstVisitor {
     private val callGraph = DirectedGraph<INameScope>()
 
-    internal fun result(): List<AstException> {
+    fun processMessages(modulename: String) {
         val cycle = callGraph.checkForCycle()
         if(cycle.isEmpty())
-            return emptyList()
+            return
         val chain = cycle.joinToString(" <-- ") { "${it.name} at ${it.position}" }
-        return listOf(AstException("Program contains recursive subroutine calls, this is not supported. Recursive chain:\n (a subroutine call in) $chain"))
+        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) {
@@ -44,7 +46,6 @@ internal class AstRecursionChecker(private val namespace: INameScope) : IAstVisi
         super.visit(functionCall)
     }
 
-
     private class DirectedGraph<VT> {
         private val graph = mutableMapOf<VT, MutableSet<VT>>()
         private var uniqueVertices = mutableSetOf<VT>()

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

@@ -0,0 +1,133 @@
+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 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()) {
+                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 vardecl = VarDecl.createAuto(litval2)
+                    val identifier = IdentifierReference(listOf(vardecl.name), vardecl.position)
+                    return listOf(
+                            IAstModification.ReplaceNode(array, identifier, parent),
+                            IAstModification.InsertFirst(vardecl, 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,451 @@
+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.indexOf(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(foreverLoop: ForeverLoop, 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(registerExpr: RegisterExpr, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun before(repeatLoop: RepeatLoop, 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(structLv: StructLiteralValue, 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(foreverLoop: ForeverLoop, 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(registerExpr: RegisterExpr, parent: Node): Iterable<IAstModification> = emptyList()
+    open fun after(repeatLoop: RepeatLoop, 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(structLv: StructLiteralValue, 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(foreverLoop: ForeverLoop, parent: Node) {
+        track(before(foreverLoop, parent), foreverLoop, parent)
+        foreverLoop.body.accept(this, foreverLoop)
+        track(after(foreverLoop, parent), foreverLoop, parent)
+    }
+
+    fun visit(repeatLoop: RepeatLoop, parent: Node) {
+        track(before(repeatLoop, parent), repeatLoop, parent)
+        repeatLoop.untilCondition.accept(this, repeatLoop)
+        repeatLoop.body.accept(this, repeatLoop)
+        track(after(repeatLoop, parent), repeatLoop, 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(registerExpr: RegisterExpr, parent: Node) {
+        track(before(registerExpr, parent), registerExpr, parent)
+        track(after(registerExpr, parent), registerExpr, 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)
+    }
+
+    fun visit(structLv: StructLiteralValue, parent: Node) {
+        track(before(structLv, parent), structLv, parent)
+        structLv.values.forEach { it.accept(this, structLv) }
+        track(after(structLv, parent), structLv, parent)
+    }
+}
+

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

@@ -1,261 +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(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) {
@@ -112,6 +112,10 @@ interface IAstVisitor {
         whileLoop.body.accept(this)
     }
 
+    fun visit(foreverLoop: ForeverLoop) {
+        foreverLoop.body.accept(this)
+    }
+
     fun visit(repeatLoop: RepeatLoop) {
         repeatLoop.untilCondition.accept(this)
         repeatLoop.body.accept(this)

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

@@ -1,36 +1,21 @@
 package prog8.ast.processing
 
-import prog8.ast.Module
-import prog8.ast.base.SyntaxError
-import prog8.ast.base.printWarning
+import prog8.ast.Node
 import prog8.ast.statements.Directive
-import prog8.ast.statements.Statement
 
-internal class ImportedModuleDirectiveRemover : IAstModifyingVisitor {
-    private val checkResult: MutableList<SyntaxError> = mutableListOf()
-
-    internal fun result(): List<SyntaxError> {
-        return checkResult
-    }
 
+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) {
-                    printWarning("ignoring module directive because it was imported", stmt.position, stmt.directive)
-                    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/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,258 +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) {
-            println(pos)
-            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(null, 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 StructLiteralValue) {
+                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? StructLiteralValue
+        if(slv==null || slv.values.size != struct.numberOfElements)
+            throw FatalAstException("element count mismatch")
+
+        return struct.statements.zip(slv.values).map { (targetDecl, sourceValue) ->
+            targetDecl as VarDecl
+            val mangled = mangledStructMemberName(identifierName, targetDecl.name)
+            val idref = IdentifierReference(listOf(mangled), structAssignment.position)
+            val assign = Assignment(AssignTarget(null, 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(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")
         }
-
-        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,92 @@ 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.FatalAstException
-import prog8.ast.base.printWarning
+import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.functions.BuiltinFunctions
 
 
-internal class TypecastsAdder(private val program: Program): 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
-        when(val sub = call.target.targetStatement(scope)) {
+        return when(val sub = call.target.targetStatement(scope)) {
             is Subroutine -> {
                 for(arg in sub.parameters.zip(call.args.withIndex())) {
                     val argItype = arg.second.value.inferType(program)
@@ -85,14 +96,21 @@ internal class TypecastsAdder(private val program: Program): IAstModifyingVisito
                         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
+                                return listOf(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.
+                                return listOf(IAstModification.ReplaceNode(
+                                        call.args[arg.second.index],
+                                        AddressOf(arg.second.value as IdentifierReference, arg.second.value.position),
+                                        call as Node))
                             }
-                            // if they're not assignable, we'll get a proper error later from the AstChecker
                         }
                     }
                 }
+                emptyList()
             }
             is BuiltinFunctionStatementPlaceholder -> {
                 val func = BuiltinFunctions.getValue(sub.name)
@@ -106,93 +124,116 @@ internal class TypecastsAdder(private val program: Program): IAstModifyingVisito
                                 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
+                                    return listOf(IAstModification.ReplaceNode(
+                                            call.args[arg.second.index],
+                                            TypecastExpression(arg.second.value, possibleType, true, arg.second.value.position),
+                                            call as Node))
                                 }
                             }
                         }
                     }
                 }
+                emptyList()
             }
-            null -> {}
+            null -> emptyList()
             else -> throw FatalAstException("call to something weird $sub   ${call.target}")
         }
     }
 
-    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)) {
-            printWarning("byte or word value implicitly converted to float. Suggestion: use explicit cast as float, a float number, or revert to integer arithmetic", typecast.position)
+            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
+    override fun after(structLv: StructLiteralValue, parent: Node): Iterable<IAstModification> {
+        // assignment of a struct literal value, some member values may need proper typecast
 
-        val decl = litval.parent as? VarDecl
+        fun addTypecastsIfNeeded(struct: StructDecl): Iterable<IAstModification> {
+            val newValues = struct.statements.zip(structLv.values).map { (structMemberDecl, memberValue) ->
+                val memberDt = (structMemberDecl as VarDecl).datatype
+                val valueDt = memberValue.inferType(program)
+                if (valueDt.typeOrElse(memberDt) != memberDt)
+                    TypecastExpression(memberValue, memberDt, true, memberValue.position)
+                else
+                    memberValue
+            }
+
+            class StructLvValueReplacer(val targetStructLv: StructLiteralValue, val typecastValues: List<Expression>) : IAstModification {
+                override fun perform() {
+                    targetStructLv.values = typecastValues
+                    typecastValues.forEach { it.linkParents(targetStructLv) }
+                }
+            }
+
+            return if(structLv.values.zip(newValues).any { (v1, v2) -> v1 !== v2})
+                listOf(StructLvValueReplacer(structLv, newValues))
+            else
+                emptyList()
+        }
+
+        val decl = structLv.parent as? VarDecl
         if(decl != null) {
             val struct = decl.struct
-            if(struct != null) {
-                addTypecastsIfNeeded(litval, struct)
-            }
+            if(struct != null)
+                return addTypecastsIfNeeded(struct)
         } else {
-            val assign = litval.parent as? Assignment
+            val assign = structLv.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)
-                    }
+                    if(struct != null)
+                        return addTypecastsIfNeeded(struct)
                 }
             }
         }
-
-        return litval
+        return noModifications
     }
 
-    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
+    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 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.FunctionSignature
-
-
-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: FunctionSignature, 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/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.
@@ -37,12 +38,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 fun replaceChildNode(node: Node, replacement: Node) {
+        replacement.parent = this
+    }
     override val expensiveToInline = false
 }
 
@@ -62,8 +67,15 @@ class Block(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.indexOf(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)"
@@ -81,8 +93,9 @@ data class Directive(val directive: String, val args: List<DirectiveArg>, overri
         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,6 +104,7 @@ 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() {
@@ -101,8 +115,9 @@ data class Label(val name: String, override val position: Position) : Statement(
         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)"
@@ -118,8 +133,14 @@ open class Return(var value: Expression?, override val position: Position) : Sta
         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,12 +148,12 @@ 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() {
@@ -143,8 +164,9 @@ class Continue(override val position: Position) : Statement() {
         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() {
@@ -155,8 +177,9 @@ class Break(override val position: Position) : Statement() {
         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 +190,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?,
@@ -204,6 +228,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,29 +265,20 @@ 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 {
@@ -278,6 +302,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 +315,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,7 +337,7 @@ 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
@@ -318,18 +348,46 @@ 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)")
     }
-}
 
-// 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)
+    fun asDesugaredNonaugmented(): Assignment {
+        val augmented = aug_op ?: return this
+
+        val leftOperand: Expression =
+                when {
+                    target.register != null -> RegisterExpr(target.register!!, target.position)
+                    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
+    }
+}
 
 data class AssignTarget(val register: Register?,
                         var identifier: IdentifierReference?,
@@ -345,8 +403,17 @@ 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 {
@@ -381,7 +448,13 @@ data class AssignTarget(val register: Register?,
 
     infix fun isSameAs(value: Expression): Boolean {
         return when {
-            this.memoryAddress!=null -> false
+            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.register!=null -> value is RegisterExpr && value.register==register
             this.identifier!=null -> value is IdentifierReference && value.nameInSource==identifier!!.nameInSource
             this.arrayindexed!=null -> value is ArrayIndexedExpression &&
@@ -443,8 +516,14 @@ class PostIncrDecr(var target: AssignTarget, val operator: String, override val
         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)"
@@ -463,8 +542,9 @@ class Jump(val address: Int?,
         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)"
@@ -485,8 +565,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.indexOf(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)"
@@ -501,8 +591,9 @@ class InlineAssembly(val assembly: String, override val position: Position) : St
         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>,
@@ -526,8 +617,15 @@ 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.indexOf(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() {
@@ -538,8 +636,9 @@ class NopStatement(override val position: Position): Statement() {
         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)
 
     companion object {
         fun insteadOf(stmt: Statement): NopStatement {
@@ -580,13 +679,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.indexOf(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 +711,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,
@@ -620,8 +732,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,
@@ -638,8 +761,18 @@ 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?,
@@ -657,8 +790,18 @@ class ForLoop(val loopRegister: Register?,
         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)"
@@ -683,8 +826,36 @@ 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() {
+    override lateinit var parent: Node
+    override val expensiveToInline = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        body.linkParents(this)
+    }
+
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is AnonymousScope && node===body)
+        body = replacement
+        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,
@@ -699,8 +870,17 @@ 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,
@@ -715,6 +895,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.indexOf(node)
+            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>>()
@@ -733,7 +923,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
@@ -747,12 +937,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)
 }
 
 
@@ -768,11 +964,18 @@ class StructDecl(override val name: String,
         this.statements.forEach { it.linkParents(this) }
     }
 
+    override fun replaceChildNode(node: Node, replacement: Node) {
+        require(replacement is Statement)
+        val idx = statements.indexOf(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
 }
@@ -785,10 +988,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(null, 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,12 +5,12 @@ 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
+import prog8.parser.ModuleImporter
 import prog8.parser.ParsingFailedError
-import prog8.parser.importLibraryModule
-import prog8.parser.importModule
 import prog8.parser.moduleName
 import java.nio.file.Path
 import kotlin.system.measureTimeMillis
@@ -26,89 +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
-            println("Parsing...")
-            programAst = Program(moduleName(filepath.fileName), mutableListOf())
-            importModule(programAst, filepath)
+            val (ast, compilationOptions, imported) = parseImports(filepath, errors)
+            programAst = ast
+            importedFiles = imported
+            processAst(programAst, errors, compilationOptions)
+            if (optimize)
+                optimizeAst(programAst, errors)
+            postprocessAst(programAst, errors, compilationOptions)
 
-            importedFiles = programAst.modules.filter { !it.source.startsWith("@embedded@") }.map{ it.source }
+            // printAst(programAst) // TODO
 
-            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) {
-                importLibraryModule(programAst, "c64lib")
-                importLibraryModule(programAst, "c64utils")
-            }
-
-            // always import prog8lib and math
-            importLibraryModule(programAst, "math")
-            importLibraryModule(programAst, "prog8lib")
-
-
-            // perform initial syntax checks and constant folding
-            println("Syntax check...")
-            val time1 = measureTimeMillis {
-                programAst.checkIdentifiers()
-            }
-
-            //println(" time1: $time1")
-            val time2 = measureTimeMillis {
-                programAst.constantFold()
-            }
-            //println(" time2: $time2")
-            val time3 = measureTimeMillis {
-                programAst.removeNopsFlattenAnonScopes()
-                programAst.reorderStatements()
-                programAst.addTypecasts()
-            }
-            //println(" time3: $time3")
-            val time4 = measureTimeMillis {
-                programAst.checkValid(compilerOptions)          // check if tree is valid
-            }
-            //println(" time4: $time4")
-
-            programAst.checkIdentifiers()
-            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()
-                    if (optsDone1 + optsDone2 == 0)
-                        break
-                }
-            }
-
-            programAst.addTypecasts()
-            programAst.removeNopsFlattenAnonScopes()
-            programAst.checkValid(compilerOptions)          // check if final tree is valid
-            programAst.checkRecursion()         // check if there are recursive subroutine calls
-
-            // printAst(programAst)
-
-            if(writeAssembly) {
-                // asm generation directly from the Ast, no need for intermediate code
-                val zeropage = CompilationTarget.machine.getZeropage(compilerOptions)
-                programAst.anonscopeVarsCleanup()
-                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
@@ -131,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()
@@ -177,3 +138,78 @@ 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.removeNopsFlattenAnonScopes()
+    programAst.reorderStatements()
+    programAst.addTypecasts(errors)
+    errors.handle()
+    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.removeNopsFlattenAnonScopes()
+    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()
+}
+
+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

@@ -15,7 +15,7 @@ abstract class Zeropage(protected val options: CompilationOptions) {
 
     fun available() = if(options.zeropage==ZeropageType.DONTUSE) 0 else free.size
 
-    fun allocate(scopedname: String, datatype: DataType, position: Position?): Int {
+    fun allocate(scopedname: String, datatype: DataType, position: Position?, errors: ErrorReporter): Int {
         assert(scopedname.isEmpty() || !allocations.values.any { it.first==scopedname } ) {"isSameAs scopedname can't be allocated twice"}
 
         if(options.zeropage==ZeropageType.DONTUSE)
@@ -28,9 +28,9 @@ abstract class Zeropage(protected val options: CompilationOptions) {
                     DataType.FLOAT -> {
                         if (options.floats) {
                             if(position!=null)
-                                printWarning("allocated a large value (float) in zeropage", position)
+                                errors.warn("allocated a large value (float) in zeropage", position)
                             else
-                                printWarning("$scopedname: allocated a large value (float) in zeropage")
+                                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/IAssemblyGenerator.kt

@@ -6,6 +6,8 @@ internal interface IAssemblyGenerator {
     fun compileToAssembly(optimize: Boolean): IAssemblyProgram
 }
 
+internal const val generatedLabelPrefix = "_prog8_label_"
+
 internal interface IAssemblyProgram {
     val name: String
     fun assemble(options: CompilationOptions)

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

@@ -3,10 +3,11 @@ package prog8.compiler.target.c64
 import prog8.compiler.CompilationOptions
 import prog8.compiler.OutputType
 import prog8.compiler.target.IAssemblyProgram
+import prog8.compiler.target.generatedLabelPrefix
 import java.nio.file.Path
 import kotlin.system.exitProcess
 
-class AssemblyProgram(override val name: String, outputDir: Path): IAssemblyProgram {
+class AssemblyProgram(override val name: String, outputDir: Path) : IAssemblyProgram {
     private val assemblyFile = outputDir.resolve("$name.asm")
     private val prgFile = outputDir.resolve("$name.prg")
     private val binFile = outputDir.resolve("$name.bin")
@@ -18,7 +19,7 @@ class AssemblyProgram(override val name: String, outputDir: Path): IAssemblyProg
                 "-Wall", "-Wno-strict-bool", "-Wno-shadow", "-Werror", "-Wno-error=long-branch",
                 "--dump-labels", "--vice-labels", "-l", viceMonListFile.toString(), "--no-monitor")
 
-        val outFile = when(options.output) {
+        val outFile = when (options.output) {
             OutputType.PRG -> {
                 command.add("--cbm-prg")
                 println("\nCreating C-64 prg.")
@@ -34,27 +35,39 @@ class AssemblyProgram(override val name: String, outputDir: Path): IAssemblyProg
 
         val proc = ProcessBuilder(command).inheritIO().start()
         val result = proc.waitFor()
-        if(result!=0) {
+        if (result != 0) {
             System.err.println("assembler failed with returncode $result")
             exitProcess(result)
         }
 
+        removeGeneratedLabelsFromMonlist()
         generateBreakpointList()
     }
 
+    private fun removeGeneratedLabelsFromMonlist() {
+        val pattern = Regex("""al (\w+) \S+${generatedLabelPrefix}.+?""")
+        val lines = viceMonListFile.toFile().readLines()
+        viceMonListFile.toFile().outputStream().bufferedWriter().use {
+            for (line in lines) {
+                if(pattern.matchEntire(line)==null)
+                    it.write(line+"\n")
+            }
+        }
+    }
+
     private fun generateBreakpointList() {
         // builds list of breakpoints, appends to monitor list file
         val breakpoints = mutableListOf<String>()
-        val pattern = Regex("""al (\w+) \S+_prog8_breakpoint_\d+.?""")      // gather breakpoints by the source label that"s generated for them
-        for(line in viceMonListFile.toFile().readLines()) {
+        val pattern = Regex("""al (\w+) \S+_prog8_breakpoint_\d+.?""")      // gather breakpoints by the source label that's generated for them
+        for (line in viceMonListFile.toFile().readLines()) {
             val match = pattern.matchEntire(line)
-            if(match!=null)
-            breakpoints.add("break \$" + match.groupValues[1])
+            if (match != null)
+                breakpoints.add("break \$" + match.groupValues[1])
         }
         val num = breakpoints.size
         breakpoints.add(0, "; vice monitor breakpoint list now follows")
         breakpoints.add(1, "; $num breakpoints have been defined")
         breakpoints.add(2, "del")
-        viceMonListFile.toFile().appendText(breakpoints.joinToString("\n")+"\n")
+        viceMonListFile.toFile().appendText(breakpoints.joinToString("\n") + "\n")
     }
 }

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

@@ -11,23 +11,25 @@ import prog8.compiler.target.IAssemblyGenerator
 import prog8.compiler.target.IAssemblyProgram
 import prog8.compiler.target.c64.AssemblyProgram
 import prog8.compiler.target.c64.C64MachineDefinition
-import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_HEX
+import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
 import prog8.compiler.target.c64.Petscii
+import prog8.compiler.target.generatedLabelPrefix
 import prog8.functions.BuiltinFunctions
-import prog8.functions.FunctionSignature
+import prog8.functions.FSignature
 import java.math.RoundingMode
 import java.nio.file.Path
 import java.time.LocalDate
 import java.time.LocalDateTime
-import java.util.ArrayDeque
+import java.util.*
 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)
@@ -37,10 +39,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()
@@ -96,11 +99,15 @@ internal class AsmGen(private val program: Program,
                 out("  .null  $9e, format(' %d ', _prog8_entrypoint), $3a, $8f, ' prog8 by idj'")
                 out("+\t.word  0")
                 out("_prog8_entrypoint\t; assembly code starts here\n")
+                out("  tsx")
+                out("  stx  prog8_lib.orig_stackpointer")
                 out("  jsr  prog8_lib.init_system")
             }
             options.output == OutputType.PRG -> {
                 out("; ---- program without basic sys call ----")
                 out("* = ${program.actualLoadAddress.toHex()}\n")
+                out("  tsx")
+                out("  stx  prog8_lib.orig_stackpointer")
                 out("  jsr  prog8_lib.init_system")
             }
             options.output == OutputType.RAW -> {
@@ -120,11 +127,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")
@@ -137,7 +143,6 @@ internal class AsmGen(private val program: Program,
                 out("  jmp  (c64.RESET_VEC)\t; cold reset")
             }
         }
-        out("")
     }
 
     private fun footer() {
@@ -171,6 +176,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(null, 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")
     }
 
@@ -178,7 +198,7 @@ internal class AsmGen(private val program: Program,
 
     internal fun makeLabel(postfix: String): String {
         generatedLabelSequenceNumber++
-        return "_prog8_label_${generatedLabelSequenceNumber}_$postfix"
+        return "${generatedLabelPrefix}${generatedLabelSequenceNumber}_$postfix"
     }
 
     private fun outputSourceLine(node: Node) {
@@ -216,7 +236,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)
@@ -225,7 +245,9 @@ internal class AsmGen(private val program: Program,
                         && variable.datatype != DataType.FLOAT
                         && options.zeropage != ZeropageType.DONTUSE) {
                     try {
-                        val address = zeropage.allocate(fullName, variable.datatype, null)
+                        val errors = ErrorReporter()
+                        val address = zeropage.allocate(fullName, variable.datatype, null, errors)
+                        errors.handle()
                         out("${variable.name} = $address\t; auto zp ${variable.datatype}")
                         // make sure we add the var to the set of zpvars for this block
                         allocatedZeropageVariables[fullName] = Pair(address, variable.datatype)
@@ -290,7 +312,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))
@@ -344,7 +373,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)
         }
     }
@@ -358,7 +387,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
@@ -378,17 +414,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()
@@ -398,12 +439,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)
@@ -565,7 +605,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)
@@ -598,11 +640,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 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 -> throw AssemblyError("missing asm translation for $stmt")
         }
     }
 
@@ -628,6 +672,19 @@ internal class AsmGen(private val program: Program,
         }
     }
 
+    private fun translate(stmt: ForeverLoop) {
+        val foreverLabel = makeLabel("forever")
+        val endLabel = makeLabel("foreverend")
+        loopEndLabels.push(endLabel)
+        loopContinueLabels.push(foreverLabel)
+        out(foreverLabel)
+        translate(stmt.body)
+        out("  jmp  $foreverLabel")
+        out(endLabel)
+        loopEndLabels.pop()
+        loopContinueLabels.pop()
+    }
+
     private fun translate(stmt: WhileLoop) {
         val whileLabel = makeLabel("while")
         val endLabel = makeLabel("whileend")
@@ -729,7 +786,7 @@ internal class AsmGen(private val program: Program,
     }
 
     private fun translate(stmt: Label) {
-        out(stmt.name)
+        out("_${stmt.name}")        // underscore prefix to make sure it's a local label
     }
 
     private fun translate(scope: AnonymousScope) {
@@ -768,6 +825,27 @@ 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 target = AssignTarget(null, 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" -> {
@@ -798,7 +876,14 @@ internal class AsmGen(private val program: Program,
 
     private fun getJumpTarget(jmp: Jump): String {
         return when {
-            jmp.identifier!=null -> asmIdentifierName(jmp.identifier)
+            jmp.identifier!=null -> {
+                val target = jmp.identifier.targetStatement(program.namespace)
+                val asmName = asmIdentifierName(jmp.identifier)
+                if(target is Label)
+                    "_$asmName"  // prefix with underscore to jump to local label
+                else
+                    asmName
+            }
             jmp.generatedLabel!=null -> jmp.generatedLabel
             jmp.address!=null -> jmp.address.toHex()
             else -> "????"
@@ -829,6 +914,7 @@ internal class AsmGen(private val program: Program,
                 val indexName = asmIdentifierName(index)
                 out("  lda  $indexName")
             }
+            // TODO optimize more cases
             else -> {
                 expressionsAsmGen.translateExpression(index)
                 out("  inx |  lda  $ESTACK_LO_HEX,x")
@@ -836,10 +922,32 @@ 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 RegisterExpr -> {
+                when (index.register) {
+                    Register.A -> out("  tay")
+                    Register.X -> out("  txa |  tay")
+                    Register.Y -> {}
+                }
+            }
+            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)
 
-    internal fun translateFunctioncallExpression(functionCall: FunctionCall, signature: FunctionSignature) =
+    internal fun translateFunctioncallExpression(functionCall: FunctionCall, signature: FSignature) =
             builtinFunctionsAsmGen.translateFunctioncallExpression(functionCall, signature)
 
     internal fun translateFunctionCall(functionCall: FunctionCall) =

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

@@ -3,13 +3,14 @@ package prog8.compiler.target.c64.codegen
 import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
-import prog8.compiler.toHex
 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
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_PLUS1_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_PLUS2_HEX
+import prog8.compiler.toHex
 import prog8.functions.BuiltinFunctions
 import kotlin.math.absoluteValue
 
@@ -27,7 +28,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
             is RegisterExpr -> translateExpression(expression)
             is IdentifierReference -> translateExpression(expression)
             is FunctionCall -> translateExpression(expression)
-            is ArrayLiteralValue, is StringLiteralValue -> TODO("string/array/struct assignment?")
+            is ArrayLiteralValue, is StringLiteralValue -> throw AssemblyError("no asm gen for string/array literal value assignment - should have been replaced by a variable")
             is StructLiteralValue -> throw AssemblyError("struct literal value assignment should have been flattened")
             is RangeExpr -> throw AssemblyError("range expression should have been changed into array values")
         }
@@ -39,8 +40,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 +51,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 +121,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 +138,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)
@@ -158,7 +178,7 @@ 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 -> throw AssemblyError("cannot push X - use a variable instead of the X register")
+            Register.X -> asmgen.out(" txa |  sta  $ESTACK_LO_HEX,x | dex")
             Register.Y -> asmgen.out(" tya |  sta  $ESTACK_LO_HEX,x | dex")
         }
     }
@@ -201,10 +221,36 @@ 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 -> {
+                        if(amount<=2)
+                            repeat(amount) { asmgen.out(" lsr  $ESTACK_HI_PLUS1_HEX,x |  ror  $ESTACK_LO_PLUS1_HEX,x") }
+                        else
+                            asmgen.out(" jsr  math.shift_right_uw_$amount")    // 3-7 (8+ is done via other optimizations)
+                    }
+                    DataType.WORD -> {
+                        if(amount<=2)
+                            repeat(amount) { 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_$amount")  // 3-7 (8+ is done via other optimizations)
+                    }
                     else -> throw AssemblyError("weird type")
                 }
                 return
@@ -213,10 +259,22 @@ 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 {
+                    if(amount<=2) {
+                        repeat(amount) { asmgen.out("  asl  $ESTACK_LO_PLUS1_HEX,x |  rol  $ESTACK_HI_PLUS1_HEX,x") }
+                    } else {
+                        asmgen.out(" jsr  math.shift_left_w_$amount")      // 3-7 (8+ is done via other optimizations)
+                    }
+                }
                 return
             }
             "*" -> {
@@ -224,8 +282,6 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 if(value!=null) {
                     if(rightDt in IntegerDatatypes) {
                         val amount = value.number.toInt()
-                        if(amount in powersOfTwo)
-                            printWarning("${expr.right.position} multiplication by power of 2 should have been optimized into a left shift instruction: $amount")
                         when(rightDt) {
                             DataType.UBYTE -> {
                                 if(amount in optimizedByteMultiplications) {
@@ -275,8 +331,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

@@ -8,11 +8,11 @@ import prog8.ast.expressions.RangeExpr
 import prog8.ast.statements.AssignTarget
 import prog8.ast.statements.Assignment
 import prog8.ast.statements.ForLoop
+import prog8.compiler.AssemblyError
+import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_PLUS1_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_PLUS1_HEX
-import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_PLUS1_HEX
 import prog8.compiler.toHex
-import prog8.compiler.AssemblyError
 import kotlin.math.absoluteValue
 
 // todo choose more efficient comparisons to avoid needless lda's
@@ -37,7 +37,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")
         }
     }
 

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

@@ -7,10 +7,10 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.AssignTarget
 import prog8.ast.statements.Subroutine
 import prog8.ast.statements.SubroutineParameter
-import prog8.compiler.toHex
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
+import prog8.compiler.toHex
 
 
 internal class FunctionCallAsmGen(private val program: Program, private val asmgen: AsmGen) {
@@ -19,7 +19,8 @@ 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 = Register.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)
@@ -30,7 +31,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         }
         asmgen.out("  jsr  $subName")
 
-        if(Register.X in sub.asmClobbers)
+        if(saveX)
             asmgen.out("  ldx  c64.SCRATCH_ZPREGX")        // restore X again
     }
 
@@ -42,7 +43,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         if(!argumentTypeCompatible(sourceDt, parameter.value.type))
             throw AssemblyError("argument type incompatible")
         if(sub.asmParameterRegisters.isEmpty()) {
-            // pass parameter via a variable
+            // pass parameter via a regular variable (not via registers)
             val paramVar = parameter.value
             val scopedParamVar = (sub.scopedname+"."+paramVar.name).split(".")
             val target = AssignTarget(null, IdentifierReference(scopedParamVar, sub.position), null, null, sub.position)
@@ -54,7 +55,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                         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?")
+                        in PassByReferenceDatatypes -> throw AssemblyError("can't pass string/array as argument via a variable?")    // TODO huh
                         else -> throw AssemblyError("weird parameter datatype")
                     }
                 }
@@ -64,7 +65,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                         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?")
+                        in PassByReferenceDatatypes -> throw AssemblyError("can't pass string/array as argument via a variable?")     // TODO huh
                         else -> throw AssemblyError("weird parameter datatype")
                     }
                 }
@@ -202,11 +203,20 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                         }
                         is IdentifierReference -> {
                             val sourceName = asmgen.asmIdentifierName(value)
-                            when (register) {
-                                RegisterOrPair.AX -> asmgen.out("  lda  $sourceName  |  ldx  $sourceName+1")
-                                RegisterOrPair.AY -> asmgen.out("  lda  $sourceName  |  ldy  $sourceName+1")
-                                RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName  |  ldy  $sourceName+1")
-                                else -> {}
+                            if(sourceDt 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 -> {}
+                                }
+                            } else {
+                                when (register) {
+                                    RegisterOrPair.AX -> asmgen.out("  lda  $sourceName  |  ldx  $sourceName+1")
+                                    RegisterOrPair.AY -> asmgen.out("  lda  $sourceName  |  ldy  $sourceName+1")
+                                    RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName  |  ldy  $sourceName+1")
+                                    else -> {}
+                                }
                             }
                         }
                         else -> {
@@ -225,6 +235,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

@@ -6,9 +6,9 @@ import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.expressions.RegisterExpr
 import prog8.ast.statements.PostIncrDecr
-import prog8.compiler.toHex
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.c64.C64MachineDefinition.C64Zeropage
+import prog8.compiler.toHex
 
 
 internal class PostIncrDecrAsmGen(private val program: Program, private val asmgen: AsmGen) {
@@ -66,7 +66,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")
                 }
@@ -100,17 +104,14 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                         }
                     }
                     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

@@ -7,88 +7,100 @@ import prog8.compiler.CompilerException
 import kotlin.math.*
 
 
-class BuiltinFunctionParam(val name: String, val possibleDatatypes: Set<DataType>)
+class FParam(val name: String, val possibleDatatypes: Set<DataType>)
 
 
 typealias ConstExpressionCaller = (args: List<Expression>, position: Position, program: Program) -> NumericLiteralValue
 
 
-class FunctionSignature(val pure: Boolean,      // does it have side effects?
-                        val parameters: List<BuiltinFunctionParam>,
-                        val returntype: DataType?,
-                        val constExpressionFunc: ConstExpressionCaller? = null)
+class FSignature(val pure: Boolean,      // does it have side effects?
+                 val parameters: List<FParam>,
+                 val returntype: DataType?,
+                 val constExpressionFunc: ConstExpressionCaller? = null)
 
 
 val BuiltinFunctions = mapOf(
         // this set of function have no return value and operate in-place:
-    "rol"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
-    "ror"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
-    "rol2"        to FunctionSignature(false, listOf(BuiltinFunctionParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
-    "ror2"        to FunctionSignature(false, listOf(BuiltinFunctionParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
-    "lsl"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", IntegerDatatypes)), null),
-    "lsr"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", IntegerDatatypes)), null),
-    "sort"        to FunctionSignature(false, listOf(BuiltinFunctionParam("array", ArrayDatatypes)), null),
-    "reverse"     to FunctionSignature(false, listOf(BuiltinFunctionParam("array", ArrayDatatypes)), null),
+    "rol"         to FSignature(false, listOf(FParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
+    "ror"         to FSignature(false, listOf(FParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
+    "rol2"        to FSignature(false, listOf(FParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
+    "ror2"        to FSignature(false, listOf(FParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
+    "lsl"         to FSignature(false, listOf(FParam("item", IntegerDatatypes)), null),
+    "lsr"         to FSignature(false, listOf(FParam("item", IntegerDatatypes)), null),
+    "sort"        to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
+    "reverse"     to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
         // these few have a return value depending on the argument(s):
-    "max"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinMax) },    // type depends on args
-    "min"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinMin) },    // type depends on args
-    "sum"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinSum) },      // type depends on args
-    "abs"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", NumericDatatypes)), null, ::builtinAbs),      // type depends on argument
-    "len"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", IterableDatatypes)), null, ::builtinLen),    // type is UBYTE or UWORD depending on actual length
+    "max"         to FSignature(true, listOf(FParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinMax) },    // type depends on args
+    "min"         to FSignature(true, listOf(FParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinMin) },    // type depends on args
+    "sum"         to FSignature(true, listOf(FParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinSum) },      // type depends on args
+    "abs"         to FSignature(true, listOf(FParam("value", NumericDatatypes)), null, ::builtinAbs),      // type depends on argument
+    "len"         to FSignature(true, listOf(FParam("values", IterableDatatypes)), null, ::builtinLen),    // type is UBYTE or UWORD depending on actual length
         // normal functions follow:
-    "sgn"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", NumericDatatypes)), DataType.BYTE, ::builtinSgn ),
-    "sin"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sin) },
-    "sin8"        to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.BYTE, ::builtinSin8 ),
-    "sin8u"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UBYTE, ::builtinSin8u ),
-    "sin16"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.WORD, ::builtinSin16 ),
-    "sin16u"      to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinSin16u ),
-    "cos"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::cos) },
-    "cos8"        to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.BYTE, ::builtinCos8 ),
-    "cos8u"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UBYTE, ::builtinCos8u ),
-    "cos16"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.WORD, ::builtinCos16 ),
-    "cos16u"      to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinCos16u ),
-    "tan"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::tan) },
-    "atan"        to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::atan) },
-    "ln"          to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::log) },
-    "log2"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, ::log2) },
-    "sqrt16"      to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { sqrt(it.toDouble()).toInt() } },
-    "sqrt"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sqrt) },
-    "rad"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::toRadians) },
-    "deg"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::toDegrees) },
-    "round"       to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::round) },
-    "floor"       to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::floor) },
-    "ceil"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::ceil) },
-    "any"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAny) },
-    "all"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAll) },
-    "lsb"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> x and 255 }},
-    "msb"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> x ushr 8 and 255}},
-    "mkword"      to FunctionSignature(true, listOf(
-                                                        BuiltinFunctionParam("lsb", setOf(DataType.UBYTE)),
-                                                        BuiltinFunctionParam("msb", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinMkword),
-    "rnd"         to FunctionSignature(true, emptyList(), DataType.UBYTE),
-    "rndw"        to FunctionSignature(true, emptyList(), DataType.UWORD),
-    "rndf"        to FunctionSignature(true, emptyList(), DataType.FLOAT),
-    "rsave"       to FunctionSignature(false, emptyList(), null),
-    "rrestore"    to FunctionSignature(false, emptyList(), null),
-    "set_carry"   to FunctionSignature(false, emptyList(), null),
-    "clear_carry" to FunctionSignature(false, emptyList(), null),
-    "set_irqd"    to FunctionSignature(false, emptyList(), null),
-    "clear_irqd"  to FunctionSignature(false, emptyList(), null),
-    "read_flags"  to FunctionSignature(false, emptyList(), DataType.UBYTE),
-    "swap"        to FunctionSignature(false, listOf(BuiltinFunctionParam("first", NumericDatatypes), BuiltinFunctionParam("second", NumericDatatypes)), null),
-    "memcopy"     to FunctionSignature(false, listOf(
-                                                        BuiltinFunctionParam("from", IterableDatatypes + DataType.UWORD),
-                                                        BuiltinFunctionParam("to", IterableDatatypes + DataType.UWORD),
-                                                        BuiltinFunctionParam("numbytes", setOf(DataType.UBYTE))), null),
-    "memset"      to FunctionSignature(false, listOf(
-                                                        BuiltinFunctionParam("address", IterableDatatypes + DataType.UWORD),
-                                                        BuiltinFunctionParam("numbytes", setOf(DataType.UWORD)),
-                                                        BuiltinFunctionParam("bytevalue", ByteDatatypes)), null),
-    "memsetw"     to FunctionSignature(false, listOf(
-                                                        BuiltinFunctionParam("address", IterableDatatypes + DataType.UWORD),
-                                                        BuiltinFunctionParam("numwords", setOf(DataType.UWORD)),
-                                                        BuiltinFunctionParam("wordvalue", setOf(DataType.UWORD, DataType.WORD))), null),
-    "strlen"      to FunctionSignature(true, listOf(BuiltinFunctionParam("string", setOf(DataType.STR))), DataType.UBYTE, ::builtinStrlen)
+    "sgn"         to FSignature(true, listOf(FParam("value", NumericDatatypes)), DataType.BYTE, ::builtinSgn ),
+    "sin"         to FSignature(true, listOf(FParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sin) },
+    "sin8"        to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.BYTE, ::builtinSin8 ),
+    "sin8u"       to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.UBYTE, ::builtinSin8u ),
+    "sin16"       to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.WORD, ::builtinSin16 ),
+    "sin16u"      to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinSin16u ),
+    "cos"         to FSignature(true, listOf(FParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::cos) },
+    "cos8"        to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.BYTE, ::builtinCos8 ),
+    "cos8u"       to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.UBYTE, ::builtinCos8u ),
+    "cos16"       to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.WORD, ::builtinCos16 ),
+    "cos16u"      to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinCos16u ),
+    "tan"         to FSignature(true, listOf(FParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::tan) },
+    "atan"        to FSignature(true, listOf(FParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::atan) },
+    "ln"          to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::log) },
+    "log2"        to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, ::log2) },
+    "sqrt16"      to FSignature(true, listOf(FParam("value", setOf(DataType.UWORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { sqrt(it.toDouble()).toInt() } },
+    "sqrt"        to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sqrt) },
+    "rad"         to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::toRadians) },
+    "deg"         to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::toDegrees) },
+    "round"       to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::round) },
+    "floor"       to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::floor) },
+    "ceil"        to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::ceil) },
+    "any"         to FSignature(true, listOf(FParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAny) },
+    "all"         to FSignature(true, listOf(FParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAll) },
+    "lsb"         to FSignature(true, listOf(FParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> x and 255 }},
+    "msb"         to FSignature(true, listOf(FParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> x ushr 8 and 255}},
+    "mkword"      to FSignature(true, listOf(FParam("lsb", setOf(DataType.UBYTE)), FParam("msb", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinMkword),
+    "rnd"         to FSignature(true, emptyList(), DataType.UBYTE),
+    "rndw"        to FSignature(true, emptyList(), DataType.UWORD),
+    "rndf"        to FSignature(true, emptyList(), DataType.FLOAT),
+    "exit"        to FSignature(false, listOf(FParam("returnvalue", setOf(DataType.UBYTE))), null),
+    "rsave"       to FSignature(false, emptyList(), null),
+    "rrestore"    to FSignature(false, emptyList(), null),
+    "set_carry"   to FSignature(false, emptyList(), null),
+    "clear_carry" to FSignature(false, emptyList(), null),
+    "set_irqd"    to FSignature(false, emptyList(), null),
+    "clear_irqd"  to FSignature(false, emptyList(), null),
+    "read_flags"  to FSignature(false, emptyList(), DataType.UBYTE),
+    "swap"        to FSignature(false, listOf(FParam("first", NumericDatatypes), FParam("second", NumericDatatypes)), null),
+    "memcopy"     to FSignature(false, listOf(
+                            FParam("from", IterableDatatypes + DataType.UWORD),
+                            FParam("to", IterableDatatypes + DataType.UWORD),
+                            FParam("numbytes", setOf(DataType.UBYTE))), null),
+    "memset"      to FSignature(false, listOf(
+                            FParam("address", IterableDatatypes + DataType.UWORD),
+                            FParam("numbytes", setOf(DataType.UWORD)),
+                            FParam("bytevalue", ByteDatatypes)), null),
+    "memsetw"     to FSignature(false, listOf(
+                            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),
+    "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() }!!
@@ -173,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 {
@@ -253,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
@@ -31,7 +29,7 @@ class CallGraph(private val program: Program) : IAstVisitor {
     val subroutinesCalling = mutableMapOf<INameScope, List<Subroutine>>().withDefault { mutableListOf() }
     val subroutinesCalledBy = 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 {
@@ -120,7 +118,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 +126,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)
         }
 

compiler/src/prog8/optimizer/ConstantFolding.kt

@@ -1,714 +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) : IAstModifyingVisitor {
-    var optimizationsDone: Int = 0
-    var errors : MutableList<AstException> = mutableListOf()
-    private val reportedErrorMessages = mutableSetOf<String>()
-
-    fun addError(x: AstException) {
-        // check that we don't add the isSameAs error more than once
-        if(x.toString() !in reportedErrorMessages) {
-            reportedErrorMessages.add(x.toString())
-            errors.add(x)
-        }
-    }
-
-    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.add(ExpressionError("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.add(ExpressionError("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.add(ExpressionError("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.add(ExpressionError("ubyte value overflow", numericLv.position))
-                            }
-                            DataType.ARRAY_B -> {
-                                if(fillvalue !in -128..127)
-                                    errors.add(ExpressionError("byte value overflow", numericLv.position))
-                            }
-                            DataType.ARRAY_UW -> {
-                                if(fillvalue !in 0..65535)
-                                    errors.add(ExpressionError("uword value overflow", numericLv.position))
-                            }
-                            DataType.ARRAY_W -> {
-                                if(fillvalue !in -32768..32767)
-                                    errors.add(ExpressionError("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.add(ExpressionError("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) {
-            addError(ax)
-            identifier
-        }
-    }
-
-    override fun visit(functionCall: FunctionCall): Expression {
-        super.visit(functionCall)
-        typeCastConstArguments(functionCall)
-        return try {
-            functionCall.constValue(program) ?: functionCall
-        } catch (ax: AstException) {
-            addError(ax)
-            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) {
-            addError(ax)
-            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) {
-            addError(ax)
-            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,594 @@
+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)
+        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
+                        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,669 @@
+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
+        }
+        val targetDt = expr.left.inferType(program).typeOrElse(DataType.STRUCT)
+        when (targetDt) {
+            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

@@ -1,42 +1,44 @@
 package prog8.optimizer
 
 import prog8.ast.Program
-import prog8.ast.base.AstException
-import prog8.parser.ParsingFailedError
+import prog8.ast.base.ErrorReporter
 
 
-internal fun Program.constantFold() {
-    val optimizer = ConstantFolding(this)
-    try {
+internal fun Program.constantFold(errors: ErrorReporter) {
+    val replacer = ConstantIdentifierReplacer(this, errors)
+    replacer.visit(this)
+    if(errors.isEmpty()) {
+        replacer.applyModifications()
+
+        val optimizer = ConstantFoldingOptimizer(this, errors)
         optimizer.visit(this)
-    } catch (ax: AstException) {
-        optimizer.addError(ax)
+        while (errors.isEmpty() && optimizer.applyModifications() > 0) {
+            optimizer.visit(this)
+        }
+
+        if(errors.isEmpty()) {
+            replacer.visit(this)
+            replacer.applyModifications()
+        }
     }
 
-    while(optimizer.errors.isEmpty() && optimizer.optimizationsDone>0) {
-        optimizer.optimizationsDone = 0
-        optimizer.visit(this)
-    }
-
-    if(optimizer.errors.isNotEmpty()) {
-        optimizer.errors.forEach { System.err.println(it) }
-        throw ParsingFailedError("There are ${optimizer.errors.size} errors.")
-    } else {
+    if(errors.isEmpty())
         modules.forEach { it.linkParents(namespace) }   // re-link in final configuration
-    }
 }
 
 
-internal fun Program.optimizeStatements(): Int {
-    val optimizer = StatementOptimizer(this)
+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/FlattenAnonymousScopesAndNopRemover.kt

@@ -0,0 +1,46 @@
+package prog8.optimizer
+
+import prog8.ast.INameScope
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.processing.IAstVisitor
+import prog8.ast.statements.AnonymousScope
+import prog8.ast.statements.NopStatement
+import prog8.ast.statements.Statement
+
+internal class FlattenAnonymousScopesAndNopRemover: 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/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
@@ -15,93 +15,39 @@ import kotlin.math.floor
 
 
 /*
-    TODO: remove unreachable code?
+    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) : IAstModifyingVisitor {
-    var optimizationsDone: Int = 0
-        private set
+internal class StatementOptimizer(private val program: Program,
+                                  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++
-                printWarning("removing empty block '${block.name}'", block.position)
-                return NopStatement.insteadOf(block)
+                errors.warn("removing empty block '${block.name}'", block.position)
+                return listOf(IAstModification.Remove(block, parent))
             }
 
             if (block !in callgraph.usedSymbols) {
-                optimizationsDone++
-                printWarning("removing unused block '${block.name}'", block.position)
-                return NopStatement.insteadOf(block)  // remove unused block
+                errors.warn("removing unused block '${block.name}'", block.position)
+                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()) {
-                printWarning("removing empty subroutine '${subroutine.name}'", subroutine.position)
-                optimizationsDone++
-                return NopStatement.insteadOf(subroutine)
+                errors.warn("removing empty subroutine '${subroutine.name}'", subroutine.position)
+                return listOf(IAstModification.Remove(subroutine, parent))
             }
         }
 
@@ -111,24 +57,342 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         }
 
         if(subroutine !in callgraph.usedSymbols && !forceOutput) {
-            printWarning("removing unused subroutine '${subroutine.name}'", subroutine.position)
-            optimizationsDone++
-            return NopStatement.insteadOf(subroutine)
+            errors.warn("removing unused subroutine '${subroutine.name}'", subroutine.position)
+            return listOf(IAstModification.Remove(subroutine, parent))
         }
 
-        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)
-                printWarning("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()) {
+            // remove empty for loop
+            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.loopRegister, 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.loopRegister, 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.loopRegister, 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(repeatLoop: RepeatLoop, parent: Node): Iterable<IAstModification> {
+        val constvalue = repeatLoop.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", repeatLoop.untilCondition.position)
+                if(!hasContinueOrBreak(repeatLoop.body))
+                    return listOf(IAstModification.ReplaceNode(repeatLoop, repeatLoop.body, parent))
+            } else {
+                // always false
+                val forever = ForeverLoop(repeatLoop.body, repeatLoop.position)
+                return listOf(IAstModification.ReplaceNode(repeatLoop, 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 = ForeverLoop(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(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> {
@@ -156,239 +420,21 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         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) {
-                printWarning("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
-                printWarning("condition is always true", ifStatement.position)
-                optimizationsDone++
-                ifStatement.truepart
-            } else {
-                // always false -> keep only else-part
-                printWarning("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 body + jump (if there are no continue and break statements)
-                printWarning("condition is always true", whileLoop.condition.position)
-                if(hasContinueOrBreak(whileLoop.body))
-                    return whileLoop
-                val backLabelName = "_prog8_back${whileLoop.position.line}"
-                val label = Label(backLabelName, whileLoop.condition.position)
-                whileLoop.body.statements.add(0, label)
-                whileLoop.body.statements.add(Jump(null,
-                        IdentifierReference(listOf(backLabelName), whileLoop.condition.position),
-                        null, whileLoop.condition.position))
-                optimizationsDone++
-                return whileLoop.body
-            } else {
-                // always false -> ditch whole statement
-                printWarning("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)
-                printWarning("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 body + jump (if there are no continue and break statements)
-                printWarning("condition is always false", repeatLoop.untilCondition.position)
-                if(hasContinueOrBreak(repeatLoop.body))
-                    return repeatLoop
-                val backLabelName = "_prog8_back${repeatLoop.position.line}"
-                val label = Label(backLabelName, repeatLoop.untilCondition.position)
-                repeatLoop.body.statements.add(0, label)
-                repeatLoop.body.statements.add(Jump(null,
-                        IdentifierReference(listOf(backLabelName), repeatLoop.untilCondition.position),
-                        null, repeatLoop.untilCondition.position))
-                optimizationsDone++
-                return repeatLoop.body
-            }
-        }
-        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)
@@ -398,221 +444,4 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         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)}
-        }
-        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.size-1) && stmts[startIdx+1] == label)
-            return NopStatement.insteadOf(label)
-
-        return super.visit(label)
-    }
-}
-
-
-
-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 && (sub.calledBy.isEmpty() || (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

@@ -4,6 +4,7 @@ import org.antlr.v4.runtime.*
 import prog8.ast.Module
 import prog8.ast.Program
 import prog8.ast.antlr.toAst
+import prog8.ast.base.ErrorReporter
 import prog8.ast.base.Position
 import prog8.ast.base.SyntaxError
 import prog8.ast.base.checkImportedValid
@@ -33,114 +34,117 @@ internal class CustomLexer(val modulePath: Path, input: CharStream?) : prog8Lexe
 internal fun moduleName(fileName: Path) = fileName.toString().substringBeforeLast('.')
 
 
-internal fun importModule(program: Program, filePath: Path): Module {
-    print("importing '${moduleName(filePath.fileName)}'")
-    if(filePath.parent!=null) {
-        var importloc = filePath.toString()
-        val curdir = Paths.get("").toAbsolutePath().toString()
-        if(importloc.startsWith(curdir))
-            importloc = "." + importloc.substring(curdir.length)
-        println(" (from '$importloc')")
-    }
-    else
-        println("")
-    if(!Files.isReadable(filePath))
-        throw ParsingFailedError("No such file: $filePath")
+internal class ModuleImporter(private val errors: ErrorReporter) {
 
-    val input = CharStreams.fromPath(filePath)
-    return importModule(program, input, filePath, false)
-}
+    internal fun importModule(program: Program, filePath: Path): Module {
+        print("importing '${moduleName(filePath.fileName)}'")
+        if(filePath.parent!=null) {
+            var importloc = filePath.toString()
+            val curdir = Paths.get("").toAbsolutePath().toString()
+            if(importloc.startsWith(curdir))
+                importloc = "." + importloc.substring(curdir.length)
+            println(" (from '$importloc')")
+        }
+        else
+            println("")
+        if(!Files.isReadable(filePath))
+            throw ParsingFailedError("No such file: $filePath")
 
-internal fun importLibraryModule(program: Program, name: String): Module? {
-    val import = Directive("%import", listOf(
-            DirectiveArg("", name, 42, position = Position("<<<implicit-import>>>", 0, 0, 0))
-    ), Position("<<<implicit-import>>>", 0, 0, 0))
-    return executeImportDirective(program, import, Paths.get(""))
-}
-
-internal fun importModule(program: Program, stream: CharStream, modulePath: Path, isLibrary: Boolean): Module {
-    val moduleName = moduleName(modulePath.fileName)
-    val lexer = CustomLexer(modulePath, stream)
-    val lexerErrors = LexerErrorListener()
-    lexer.addErrorListener(lexerErrors)
-    val tokens = CommentHandlingTokenStream(lexer)
-    val parser = prog8Parser(tokens)
-    val parseTree = parser.module()
-    val numberOfErrors = parser.numberOfSyntaxErrors + lexerErrors.numberOfErrors
-    if(numberOfErrors > 0)
-        throw ParsingFailedError("There are $numberOfErrors errors in '$moduleName'.")
-
-    // You can do something with the parsed comments:
-    // tokens.commentTokens().forEach { println(it) }
-
-    // convert to Ast
-    val moduleAst = parseTree.toAst(moduleName, isLibrary, modulePath)
-    moduleAst.program = program
-    moduleAst.linkParents(program.namespace)
-    program.modules.add(moduleAst)
-
-    // accept additional imports
-    val lines = moduleAst.statements.toMutableList()
-    lines.asSequence()
-         .mapIndexed { i, it -> Pair(i, it) }
-         .filter { (it.second as? Directive)?.directive == "%import" }
-         .forEach { executeImportDirective(program, it.second as Directive, modulePath) }
-
-    moduleAst.statements = lines
-    return moduleAst
-}
-
-private fun discoverImportedModuleFile(name: String, source: Path, position: Position?): Path {
-    val fileName = "$name.p8"
-    val locations = mutableListOf(source.parent)
-
-    val propPath = System.getProperty("prog8.libdir")
-    if(propPath!=null)
-        locations.add(pathFrom(propPath))
-    val envPath = System.getenv("PROG8_LIBDIR")
-    if(envPath!=null)
-        locations.add(pathFrom(envPath))
-    locations.add(Paths.get(Paths.get("").toAbsolutePath().toString(), "prog8lib"))
-
-    locations.forEach {
-        val file = pathFrom(it.toString(), fileName)
-        if (Files.isReadable(file)) return file
+        val input = CharStreams.fromPath(filePath)
+        return importModule(program, input, filePath, false)
     }
 
-    throw ParsingFailedError("$position Import: no module source file '$fileName' found  (I've looked in: $locations)")
-}
+    internal fun importLibraryModule(program: Program, name: String): Module? {
+        val import = Directive("%import", listOf(
+                DirectiveArg("", name, 42, position = Position("<<<implicit-import>>>", 0, 0, 0))
+        ), Position("<<<implicit-import>>>", 0, 0, 0))
+        return executeImportDirective(program, import, Paths.get(""))
+    }
 
-private fun executeImportDirective(program: Program, import: Directive, source: Path): Module? {
-    if(import.directive!="%import" || import.args.size!=1 || import.args[0].name==null)
-        throw SyntaxError("invalid import directive", import.position)
-    val moduleName = import.args[0].name!!
-    if("$moduleName.p8" == import.position.file)
-        throw SyntaxError("cannot import self", import.position)
+    private fun importModule(program: Program, stream: CharStream, modulePath: Path, isLibrary: Boolean): Module {
+        val moduleName = moduleName(modulePath.fileName)
+        val lexer = CustomLexer(modulePath, stream)
+        val lexerErrors = LexerErrorListener()
+        lexer.addErrorListener(lexerErrors)
+        val tokens = CommentHandlingTokenStream(lexer)
+        val parser = prog8Parser(tokens)
+        val parseTree = parser.module()
+        val numberOfErrors = parser.numberOfSyntaxErrors + lexerErrors.numberOfErrors
+        if(numberOfErrors > 0)
+            throw ParsingFailedError("There are $numberOfErrors errors in '$moduleName'.")
 
-    val existing = program.modules.singleOrNull { it.name == moduleName }
-    if(existing!=null)
-        return null
+        // You can do something with the parsed comments:
+        // tokens.commentTokens().forEach { println(it) }
 
-    val resource = tryGetEmbeddedResource("$moduleName.p8")
-    val importedModule =
-        if(resource!=null) {
-            // load the module from the embedded resource
-            resource.use {
-                if(import.args[0].int==42)
-                    println("importing '$moduleName' (library, auto)")
-                else
-                    println("importing '$moduleName' (library)")
-                importModule(program, CharStreams.fromStream(it), Paths.get("@embedded@/$moduleName"), true)
-            }
-        } else {
-            val modulePath = discoverImportedModuleFile(moduleName, source, import.position)
-            importModule(program, modulePath)
+        // convert to Ast
+        val moduleAst = parseTree.toAst(moduleName, isLibrary, modulePath)
+        moduleAst.program = program
+        moduleAst.linkParents(program.namespace)
+        program.modules.add(moduleAst)
+
+        // accept additional imports
+        val lines = moduleAst.statements.toMutableList()
+        lines.asSequence()
+                .mapIndexed { i, it -> Pair(i, it) }
+                .filter { (it.second as? Directive)?.directive == "%import" }
+                .forEach { executeImportDirective(program, it.second as Directive, modulePath) }
+
+        moduleAst.statements = lines
+        return moduleAst
+    }
+
+    private fun discoverImportedModuleFile(name: String, source: Path, position: Position?): Path {
+        val fileName = "$name.p8"
+        val locations = mutableListOf(source.parent)
+
+        val propPath = System.getProperty("prog8.libdir")
+        if(propPath!=null)
+            locations.add(pathFrom(propPath))
+        val envPath = System.getenv("PROG8_LIBDIR")
+        if(envPath!=null)
+            locations.add(pathFrom(envPath))
+        locations.add(Paths.get(Paths.get("").toAbsolutePath().toString(), "prog8lib"))
+
+        locations.forEach {
+            val file = pathFrom(it.toString(), fileName)
+            if (Files.isReadable(file)) return file
         }
 
-    importedModule.checkImportedValid()
-    return importedModule
-}
+        throw ParsingFailedError("$position Import: no module source file '$fileName' found  (I've looked in: $locations)")
+    }
 
-internal fun tryGetEmbeddedResource(name: String): InputStream? {
-    return object{}.javaClass.getResourceAsStream("/prog8lib/$name")
+    private fun executeImportDirective(program: Program, import: Directive, source: Path): Module? {
+        if(import.directive!="%import" || import.args.size!=1 || import.args[0].name==null)
+            throw SyntaxError("invalid import directive", import.position)
+        val moduleName = import.args[0].name!!
+        if("$moduleName.p8" == import.position.file)
+            throw SyntaxError("cannot import self", import.position)
+
+        val existing = program.modules.singleOrNull { it.name == moduleName }
+        if(existing!=null)
+            return null
+
+        val resource = tryGetEmbeddedResource("$moduleName.p8")
+        val importedModule =
+                if(resource!=null) {
+                    // load the module from the embedded resource
+                    resource.use {
+                        if(import.args[0].int==42)
+                            println("importing '$moduleName' (library, auto)")
+                        else
+                            println("importing '$moduleName' (library)")
+                        importModule(program, CharStreams.fromStream(it), Paths.get("@embedded@/$moduleName"), true)
+                    }
+                } else {
+                    val modulePath = discoverImportedModuleFile(moduleName, source, import.position)
+                    importModule(program, modulePath)
+                }
+
+        importedModule.checkImportedValid()
+        return importedModule
+    }
+
+    private fun tryGetEmbeddedResource(name: String): InputStream? {
+        return object{}.javaClass.getResourceAsStream("/prog8lib/$name")
+    }
 }

compiler/src/prog8/server/dbus/IrmenDbusTest.kt

@@ -0,0 +1,22 @@
+package prog8.server.dbus
+
+//import org.freedesktop.dbus.interfaces.DBusInterface
+//
+//
+//interface IrmenDbusTest: DBusInterface
+//{
+//    fun Status(address: String): Map<Int, String>
+//}
+//
+//
+//internal class TestService: IrmenDbusTest {
+//    override fun Status(address: String): Map<Int, String> {
+//        return mapOf(
+//            5 to "hello",
+//            42 to address
+//        )
+//    }
+//
+//    override fun isRemote() = true
+//    override fun getObjectPath() = "/razorvine/TestService"
+//}

compiler/src/prog8/server/dbus/clientmain.kt

@@ -0,0 +1,17 @@
+package prog8.server.dbus
+
+
+//import org.freedesktop.dbus.connections.impl.DBusConnection
+//
+//
+//fun main() {
+//    DBusConnection.getConnection(DBusConnection.DBusBusType.SESSION).use {
+//        println(it.names.toList())
+//        println(it.uniqueName)
+//        println(it.address)
+//        println(it.machineId)
+//        val obj = it.getRemoteObject("local.net.razorvine.dbus.test", "/razorvine/TestService", IrmenDbusTest::class.java)
+//        println(obj.Status("irmen"))
+//    }
+//}
+//

compiler/src/prog8/server/dbus/testdbus.kt

@@ -0,0 +1,18 @@
+package prog8.server.dbus
+
+//import org.freedesktop.dbus.connections.impl.DBusConnection
+//
+//
+//fun main() {
+//    DBusConnection.getConnection(DBusConnection.DBusBusType.SESSION).use {
+//        it.requestBusName("local.net.razorvine.dbus.test")
+//        println(it.names.toList())
+//        println(it.uniqueName)
+//        println(it.address)
+//        println(it.machineId)
+//        val service = TestService()
+//        it.exportObject(service.objectPath, service)
+//
+//        Thread.sleep(100000)
+//    }
+//}

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.Objects
-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.ArrayDeque
-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

@@ -6,6 +6,7 @@ import org.hamcrest.Matchers.equalTo
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import prog8.ast.base.DataType
+import prog8.ast.base.ErrorReporter
 import prog8.ast.base.Position
 import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.expressions.StringLiteralValue
@@ -15,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.*
 
@@ -124,31 +124,34 @@ class TestCompiler {
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class TestZeropage {
+
+    private val errors = ErrorReporter()
+
     @Test
     fun testNames() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false))
 
-        zp.allocate("", DataType.UBYTE, null)
-        zp.allocate("", DataType.UBYTE, null)
-        zp.allocate("varname", DataType.UBYTE, null)
+        zp.allocate("", DataType.UBYTE, null, errors)
+        zp.allocate("", DataType.UBYTE, null, errors)
+        zp.allocate("varname", DataType.UBYTE, null, errors)
         assertFailsWith<AssertionError> {
-            zp.allocate("varname", DataType.UBYTE, null)
+            zp.allocate("varname", DataType.UBYTE, null, errors)
         }
-        zp.allocate("varname2", DataType.UBYTE, null)
+        zp.allocate("varname2", DataType.UBYTE, null, errors)
     }
 
     @Test
     fun testZpFloatEnable() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
         assertFailsWith<CompilerException> {
-            zp.allocate("", DataType.FLOAT, null)
+            zp.allocate("", DataType.FLOAT, null, errors)
         }
         val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), true))
         assertFailsWith<CompilerException> {
-            zp2.allocate("", DataType.FLOAT, null)
+            zp2.allocate("", DataType.FLOAT, null, errors)
         }
         val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true))
-        zp3.allocate("", DataType.FLOAT, null)
+        zp3.allocate("", DataType.FLOAT, null, errors)
     }
 
     @Test
@@ -173,7 +176,7 @@ class TestZeropage {
         println(zp.free)
         assertEquals(0, zp.available())
         assertFailsWith<CompilerException> {
-            zp.allocate("", DataType.BYTE, null)
+            zp.allocate("", DataType.BYTE, null, errors)
         }
     }
 
@@ -218,19 +221,19 @@ class TestZeropage {
 
         assertFailsWith<ZeropageDepletedError> {
             // in regular zp there aren't 5 sequential bytes free
-            zp.allocate("", DataType.FLOAT, null)
+            zp.allocate("", DataType.FLOAT, null, errors)
         }
 
         for (i in 0 until zp.available()) {
-            val loc = zp.allocate("", DataType.UBYTE, null)
+            val loc = zp.allocate("", DataType.UBYTE, null, errors)
             assertTrue(loc > 0)
         }
         assertEquals(0, zp.available())
         assertFailsWith<ZeropageDepletedError> {
-            zp.allocate("", DataType.UBYTE, null)
+            zp.allocate("", DataType.UBYTE, null, errors)
         }
         assertFailsWith<ZeropageDepletedError> {
-            zp.allocate("", DataType.UWORD, null)
+            zp.allocate("", DataType.UWORD, null, errors)
         }
     }
 
@@ -238,29 +241,29 @@ class TestZeropage {
     fun testFullAllocation() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
         assertEquals(238, zp.available())
-        val loc = zp.allocate("", DataType.UWORD, null)
+        val loc = zp.allocate("", DataType.UWORD, null, errors)
         assertTrue(loc > 3)
         assertFalse(loc in zp.free)
         val num = zp.available() / 2
 
         for(i in 0..num-4) {
-            zp.allocate("", DataType.UWORD, null)
+            zp.allocate("", DataType.UWORD, null, errors)
         }
         assertEquals(6,zp.available())
 
         assertFailsWith<ZeropageDepletedError> {
             // can't allocate because no more sequential bytes, only fragmented
-            zp.allocate("", DataType.UWORD, null)
+            zp.allocate("", DataType.UWORD, null, errors)
         }
 
         for(i in 0..5) {
-            zp.allocate("", DataType.UBYTE, null)
+            zp.allocate("", DataType.UBYTE, null, errors)
         }
 
         assertEquals(0, zp.available())
         assertFailsWith<ZeropageDepletedError> {
             // no more space
-            zp.allocate("", DataType.UBYTE, null)
+            zp.allocate("", DataType.UBYTE, null, errors)
         }
     }
 
@@ -268,16 +271,16 @@ class TestZeropage {
     fun testEfficientAllocation() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(),  true))
         assertEquals(16, zp.available())
-        assertEquals(0x04, zp.allocate("", DataType.WORD, null))
-        assertEquals(0x06, zp.allocate("", DataType.UBYTE, null))
-        assertEquals(0x0a, zp.allocate("", DataType.UBYTE, null))
-        assertEquals(0x94, zp.allocate("", DataType.UWORD, null))
-        assertEquals(0xa7, zp.allocate("", DataType.UWORD, null))
-        assertEquals(0xa9, zp.allocate("", DataType.UWORD, null))
-        assertEquals(0xb5, zp.allocate("", DataType.UWORD, null))
-        assertEquals(0xf7, zp.allocate("", DataType.UWORD, null))
-        assertEquals(0x0e, zp.allocate("", DataType.UBYTE, null))
-        assertEquals(0xf9, zp.allocate("", DataType.UBYTE, null))
+        assertEquals(0x04, zp.allocate("", DataType.WORD, null, errors))
+        assertEquals(0x06, zp.allocate("", DataType.UBYTE, null, errors))
+        assertEquals(0x0a, zp.allocate("", DataType.UBYTE, null, errors))
+        assertEquals(0x94, zp.allocate("", DataType.UWORD, null, errors))
+        assertEquals(0xa7, zp.allocate("", DataType.UWORD, null, errors))
+        assertEquals(0xa9, zp.allocate("", DataType.UWORD, null, errors))
+        assertEquals(0xb5, zp.allocate("", DataType.UWORD, null, errors))
+        assertEquals(0xf7, zp.allocate("", DataType.UWORD, null, errors))
+        assertEquals(0x0e, zp.allocate("", DataType.UBYTE, null, errors))
+        assertEquals(0xf9, zp.allocate("", DataType.UBYTE, null, errors))
         assertEquals(0, zp.available())
     }
 }
@@ -352,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)
@@ -369,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,30 +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;
+- Provide high level programming constructs but at the same time 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)
+- 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:
@@ -167,26 +166,25 @@ Required tools
 --------------
 
 `64tass <https://sourceforge.net/projects/tass64/>`_ - cross assembler. Install this on your shell path.
-A recent .exe version of this tool for Windows can be obtained from my `clone <https://github.com/irmen/64tass/releases>`_ of this project.
-For other platforms it is very easy to compile it yourself (make ; make install).
+It's very easy to compile yourself.
+A recent precompiled .exe for Windows can be obtained from my `clone <https://github.com/irmen/64tass/releases>`_ of this project.
 
-A **Java runtime (jre or jdk), version 8 or newer**  is required to run the packaged compiler.
-If you're scared of Oracle's licensing terms, most Linux distributions ship OpenJDK instead
-and for Windows it's possible to get that as well. Check out `AdoptOpenJDK <https://adoptopenjdk.net/>`_ for
-downloads.
+A **Java runtime (jre or jdk), version 8 or newer**  is required to run the prog8 compiler itself.
+If you're scared of Oracle's licensing terms, most Linux distributions ship OpenJDK instead.
+Fnd for Windows it's possible to get that as well. Check out `AdoptOpenJDK <https://adoptopenjdk.net/>`_ .
 
-Finally: a **C-64 emulator** (or a real C-64 ofcourse) to run the programs on. The compiler assumes the presence
-of the `Vice emulator <http://vice-emu.sourceforge.net/>`_.
+Finally: a **C-64 emulator** (or a real C-64 ofcourse) can be nice to test and run your programs on.
+The compiler assumes the presence of the `Vice emulator <http://vice-emu.sourceforge.net/>`_.
 
 .. important::
     **Building the compiler itself:** (*Only needed if you have not downloaded a pre-built 'fat-jar'*)
 
-    (re)building the compiler itself requires a recent Kotlin SDK.
-    The compiler is developed using the `IntelliJ IDEA <https://www.jetbrains.com/idea/>`_
-    IDE from Jetbrains, with the Kotlin plugin (free community edition of this IDE is available).
-    But a bare Kotlin SDK installation should work just as well.
+    (Re)building the compiler itself requires a recent Kotlin SDK.
+    The compiler is developed using `IntelliJ IDEA <https://www.jetbrains.com/idea/>`_ ,
+    but only a Kotlin SDK installation should work as well, because the gradle tool is
+    used to compile everything from the commandline.
 
-    Instructions on how to obtain a working compiler are in :ref:`building_compiler`.
+    Instructions on how to obtain a prebuilt compiler are in :ref:`building_compiler`.
 
 
 .. toctree::

docs/source/programming.rst

@@ -12,57 +12,56 @@ Elements of a program
 ---------------------
 
 Program
-	Consists of one or more *modules*.
+    Consists of one or more *modules*.
 
 Module
-	A file on disk with the ``.p8`` suffix. It contains *directives* and *code blocks*.
-	Whitespace and indentation in the source code are arbitrary and can be tabs or spaces or both.
-	You can also add *comments* to the source code.
-	One moudule file can *import* others, and also import *library modules*.
+    A file on disk with the ``.p8`` suffix. It can contain *directives* and *code blocks*.
+    Whitespace and indentation in the source code are arbitrary and can be mixed tabs or spaces.
+    A module file can *import* other modules, including *library modules*.
 
 Comments
-	Everything after a semicolon ``;`` is a comment and is ignored by the compiler.
-	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
-		; next is the code that...
+    Everything after a semicolon ``;`` is a comment and is ignored by the compiler.
+    If the whole line is just a comment, this line will be copied into the resulting assembly source code for reference.
 
 Directive
-	These are special instructions for the compiler, to change how it processes the code
-	and what kind of program it creates. A directive is on its own line in the file, and
-	starts with ``%``, optionally followed by some arguments.
+    These are special instructions for the compiler, to change how it processes the code
+    and what kind of program it creates. A directive is on its own line in the file, and
+    starts with ``%``, optionally followed by some arguments.
 
 Code block
-	A block of actual program code. It defines a *scope* (also known as 'namespace') and
-	can contain Prog8 *code*, *variable declarations* and *subroutines*.
-	More details about this below: :ref:`blocks`.
+    A block of actual program code. It has a starting address in memory,
+    and defines a *scope* (also known as 'namespace').
+    It contains variables and subroutines.
+    More details about this below: :ref:`blocks`.
 
 Variable declarations
-	The data that the code works on is stored in variables ('named values that can change').
-	The compiler allocates the required memory for them.
-	There is *no dynamic memory allocation*. The storage size of all variables
-	is fixed and is determined at compile time.
-	Variable declarations tend to appear at the top of the code block that uses them.
-	They define the name and type of the variable, and its initial value.
-	Prog8 supports a small list of data types, including special 'memory mapped' types
-	that don't allocate storage but instead point to a fixed location in the address space.
+    The data that the code works on is stored in variables ('named values that can change').
+    The compiler allocates the required memory for them.
+    There is *no dynamic memory allocation*. The storage size of all variables
+    is fixed and is determined at compile time.
+    Variable declarations tend to appear at the top of the code block that uses them.
+    They define the name and type of the variable, and its initial value.
+    Prog8 supports a small list of data types, including special 'memory mapped' types
+    that don't allocate storage but instead point to a fixed location in the address space.
 
 Code
-	These are the instructions that make up the program's logic. There are different kinds of instructions
-	('statements' is a better name):
+    These are the instructions that make up the program's logic.
+    Code can only occur inside a subroutine.
+    There are different kinds of instructions ('statements' is a better name) such as:
 
-	- value assignment
-	- looping  (for, while, repeat, unconditional jumps)
-	- conditional execution (if - then - else, when, and conditional jumps)
-	- subroutine calls
-	- label definition
+    - value assignment
+    - looping  (for, while, repeat, unconditional jumps)
+    - conditional execution (if - then - else, when, and conditional jumps)
+    - subroutine calls
+    - label definition
 
 Subroutine
     Defines a piece of code that can be called by its name from different locations in your code.
     It accepts parameters and can return a value (optional).
     It can define its own variables, and it is even possible to define subroutines nested inside other subroutines.
     Their contents is scoped accordingly.
+    Nested subroutines can access the variables from outer scopes.
+    This removes the need and overhead to pass everything via parameters.
 
 Label
     This is a named position in your code where you can jump to from another place.
@@ -90,16 +89,20 @@ Scope
 Blocks, Scopes, and accessing Symbols
 -------------------------------------
 
-**Blocks** are the top level separate pieces of code and data of your program. They are combined
-into a single output program.  No code or data can occur outside a block. Here's an example::
+**Blocks** are the top level separate pieces of code and data of your program. They have a
+starting address in memory and will be combined together into a single output program.
+They can only contain *directives*, *variable declarations*, *subroutines* and *inline assembly code*.
+Your actual program code can only exist inside these subroutines.
+(except the occasional inline assembly)
 
-	main $c000 {
-		; this is code inside the block...
-	}
+Here's an example::
 
+    main $c000 {
+        ; this is code inside the block...
+    }
 
 The name of a block must be unique in your entire program.
-Also be careful when importing other modules; blocks in your own code cannot have
+Be careful when importing other modules; blocks in your own code cannot have
 the same name as a block defined in an imported module or library.
 
 If you omit both the name and address, the entire block is *ignored* by the compiler (and a warning is displayed).
@@ -109,7 +112,7 @@ want to work on later, because the contents of the ignored block are not fully p
 The address can be used to place a block at a specific location in memory.
 Usually it is omitted, and the compiler will automatically choose the location (usually immediately after
 the previous block in memory).
-The address must be >= ``$0200`` (because ``$00``--``$ff`` is the ZP and ``$100``--``$200`` is the cpu stack).
+It must be >= ``$0200`` (because ``$00``--``$ff`` is the ZP and ``$100``--``$1ff`` is the cpu stack).
 
 
 .. _scopes:
@@ -132,15 +135,18 @@ Scopes are created using either of these two statements:
 - blocks  (top-level named scope)
 - subroutines   (nested named scope)
 
-.. note::
-    In contrast to 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 is a bit restrictive because 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 the
-    target system is very limited and it would be a waste to allocate a lot of variables.
-
-    Right now the prog8 compiler is not advanced enough to be able to 'share' or 'overlap'
-    variables intelligently by itself. So for now, it's something the programmer has to think about.
+.. important::
+    Unlike most other programming languages, a new scope is *not* created inside
+    for, while and repeat 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 you have to think about yourself.
 
 
 Program Start and Entry Point
@@ -150,21 +156,14 @@ 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 {
-	    sub start ()  {
-	        ; program entrypoint code here
-	        return
-	    }
-	}
+    main {
+        sub start ()  {
+            ; program entrypoint code here
+            return
+        }
+    }
 
 
 The ``main`` module is always relocated to the start of your programs
@@ -175,12 +174,11 @@ calls with the SYS statement.
 
 
 
-
 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::
@@ -281,16 +279,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.
 
 
@@ -374,10 +379,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
@@ -386,15 +389,6 @@ 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
 -----
@@ -406,6 +400,10 @@ Iterating with a floating point variable is not supported. If you want to loop o
 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.
+
 You can also create loops by using the ``goto`` statement, but this should usually be avoided.
 
 .. attention::
@@ -811,6 +809,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.
 
@@ -836,6 +850,10 @@ rrestore()
 read_flags()
     Returns the current value of the CPU status register.
 
+exit(returncode)
+    Immediately stops the program and exits it, with the returncode in the A register.
+    Note: custom interrupt handlers remain active unless manually cleared first!
+
 
 
 Library routines

docs/source/syntaxreference.rst

@@ -172,13 +172,13 @@ Code blocks
 -----------
 
 A named block of actual program code. Itefines a *scope* (also known as 'namespace') and
-can contain Prog8 *code*, *directives*, *variable declarations* and *subroutines*::
+can only contain *directives*, *variable declarations*, *subroutines* or *inline assembly*::
 
     <blockname> [<address>] {
         <directives>
         <variables>
-        <statements>
         <subroutines>
+        <inline asm>
     }
 
 The <blockname> must be a valid identifier.
@@ -191,7 +191,6 @@ Also read :ref:`blocks`.  Here is an example of a code block, to be loaded at ``
 	}
 
 
-
 Labels
 ------
 
@@ -217,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::
 
@@ -322,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
@@ -598,8 +598,8 @@ You can use a single statement, or a statement block like in the example below::
 	}
 
 
-repeat--until loop
-^^^^^^^^^^^^^^^^^^
+repeat-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::
@@ -611,6 +611,19 @@ You can use a single statement, or a statement block like in the example below::
 	} until  <condition>
 
 
+forever 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::
+
+    forever {
+        ; .. do stuff
+        if something
+            break        ; you can exit the loop if you want
+    }
+
+
 Conditional Execution and Jumps
 -------------------------------
 

docs/source/todo.rst

@@ -2,23 +2,11 @@
 TODO
 ====
 
-- option to load library files from a directory instead of the embedded ones
-
-
-Memory Block Operations integrated in language?
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-array/string memory block operations?
-
-- 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://murray2.com/forums/commander-x16.9/  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
@@ -26,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
+- working subroutine inlining (start with trivial routines, grow to taking care of vars and identifier refs to them)
+- 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
 
 
 Eval stack redesign? (lot of work)
@@ -39,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
@@ -57,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,7 +104,17 @@ 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() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
+
 }

examples/arithmetic/div.p8

@@ -25,6 +25,7 @@ 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) {
@@ -102,4 +103,12 @@ 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

@@ -33,6 +33,7 @@ main {
         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) {
@@ -110,4 +111,13 @@ 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

@@ -27,6 +27,7 @@ main {
         mul_float(2.5,10,25)
         mul_float(-1.5,10,-15)
 
+        check_eval_stack()
     }
 
     sub mul_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -104,4 +105,12 @@ 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

@@ -31,6 +31,7 @@ main {
         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) {
@@ -108,4 +109,13 @@ 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

@@ -5,7 +5,6 @@
 
 main {
 
-
     sub start()  {
 
         c64scr.plot(0,24)
@@ -64,6 +63,7 @@ main {
         warr[1]--
         flarr[1] --
         check_ub(ub, 200)
+
         Y=100
         Y--
         check_ub(Y, 99)
@@ -77,7 +77,7 @@ main {
         check_uw(uwarr[1], 2000)
         check_w(warr[1], -1000)
 
-        @($0400+400-1) = X
+        check_eval_stack()
     }
 
     sub check_ub(ubyte value, ubyte expected) {
@@ -139,4 +139,13 @@ 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,6 +15,8 @@ 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) {
@@ -46,4 +48,12 @@ 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

@@ -0,0 +1,130 @@
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        byte b1
+        byte b2
+        ubyte ub1
+        ubyte ub2
+        word w1
+        word w2
+        uword uw1
+        uword uw2
+        float f1
+        float f2
+
+        b1 = 10
+        b2 = 10
+        if sgn(b2-b1) != 0
+            c64scr.print("sgn1 error1\n")
+
+        b1 = -100
+        b2 = -100
+        if sgn(b2-b1) != 0
+            c64scr.print("sgn1 error2\n")
+
+        ub1 = 200
+        ub2 = 200
+        if sgn(ub2-ub1) != 0
+            c64scr.print("sgn1 error3\n")
+
+        w1 = 100
+        w2 = 100
+        if sgn(w2-w1) != 0
+            c64scr.print("sgn1 error4\n")
+
+        w1 = -2000
+        w2 = -2000
+        if sgn(w2-w1) != 0
+            c64scr.print("sgn1 error5\n")
+
+        uw1 = 999
+        uw2 = 999
+        if sgn(uw2-uw1) != 0
+            c64scr.print("sgn1 error6\n")
+
+        f1 = 3.45
+        f2 = 3.45
+        if sgn(f2-f1) != 0
+            c64scr.print("sgn1 error7\n")
+
+
+        ; -1
+        b1 = 11
+        b2 = 10
+        if sgn(b2-b1) != -1
+            c64scr.print("sgn2 error1\n")
+
+        b1 = -10
+        b2 = -100
+        if sgn(b2-b1) != -1
+            c64scr.print("sgn2 error2\n")
+
+        ub1 = 202
+        ub2 = 200
+        if sgn(ub2 as byte - ub1 as byte) != -1
+            c64scr.print("sgn2 error3\n")
+
+        w1 = 101
+        w2 = 100
+        if sgn(w2-w1) != -1
+            c64scr.print("sgn2 error4\n")
+
+        w1 = -200
+        w2 = -2000
+        if sgn(w2-w1) != -1
+            c64scr.print("sgn2 error5\n")
+
+        uw1 = 2222
+        uw2 = 999
+        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
+        if sgn(f2-f1) != -1
+            c64scr.print("sgn2 error7\n")
+
+        ; +1
+        b1 = 11
+        b2 = 20
+        if sgn(b2-b1) != 1
+            c64scr.print("sgn3 error1\n")
+
+        b1 = -10
+        b2 = -1
+        if sgn(b2-b1) != 1
+            c64scr.print("sgn3 error2\n")
+
+        ub1 = 202
+        ub2 = 205
+        if sgn(ub2-ub1) != 1
+            c64scr.print("sgn3 error3\n")
+
+        w1 = 101
+        w2 = 200
+        if sgn(w2-w1) != 1
+            c64scr.print("sgn3 error4\n")
+
+        w1 = -200
+        w2 = -20
+        if sgn(w2-w1) != 1
+            c64scr.print("sgn3 error5\n")
+
+        uw1 = 2222
+        uw2 = 9999
+        if sgn(uw2-uw1) != 1
+            c64scr.print("sgn3 error6\n")
+
+        f1 = 3.45
+        f2 = 5.11
+        if sgn(f2-f1) != 1
+            c64scr.print("sgn3 error7\n")
+
+        c64scr.print("should see no sgn errors\n")
+    }
+ }

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
+
+        forever {
+            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()
 
-    while(true) {
+    forever {
         uword note
         for note in notes {
             ubyte note1 = lsb(note)
@@ -34,27 +34,28 @@ sub start() {
             delay()
         }
     }
+}
 
-    sub delay() {
-        ubyte d
-        for d in 0 to 12 {
-            while(c64.RASTER!=0) {
-                ; tempo delay synced to screen refresh
-            }
+sub delay() {
+    ubyte d
+    for d in 0 to 12 {
+        while c64.RASTER!=0 {
+            ; tempo delay synced to screen refresh
         }
     }
-
-    sub print_notes(ubyte n1, ubyte n2) {
-        c64.CHROUT('\n')
-        c64scr.plot(n1/2, 24)
-        c64.COLOR=7
-        c64.CHROUT('Q')
-        c64scr.plot(n2/2, 24)
-        c64.COLOR=4
-        c64.CHROUT('Q')
-    }
 }
 
+sub print_notes(ubyte n1, ubyte n2) {
+    c64.CHROUT('\n')
+    c64scr.plot(n1/2, 24)
+    c64.COLOR=7
+    c64.CHROUT('Q')
+    c64scr.plot(n2/2, 24)
+    c64.COLOR=4
+    c64.CHROUT('Q')
+}
+
+
     ; details about the boulderdash music can be found here:
     ; https://www.elmerproductions.com/sp/peterb/sounds.html#Theme%20tune
 

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 {
+                forever {
+                    plot(y1)
+                    if plotx==x2
+                        return
+                    plotx++
+                    d += dy
+                    if d > dx {
+                        y1++
+                        d -= dx
+                    }
+                }
+            } else {
+                forever {
+                    plot(y1)
+                    if plotx==x2
+                        return
+                    plotx--
+                    d += dy
+                    if d > dx {
+                        y1++
+                        d -= dx
+                    }
+                }
+            }
+        }
+        else {
+            if positive_ix {
+                forever {
+                    plot(y1)
+                    if y1 == y2
+                        return
+                    y1++
+                    d += dx
+                    if d > dy {
+                        plotx++
+                        d -= dy
+                    }
+                }
+            } else {
+                forever {
+                    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

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

examples/comparison_ifs_float.p8

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

examples/comparison_ifs_ubyte.p8

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

examples/comparison_ifs_uword.p8

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

examples/comparison_ifs_word.p8

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

examples/comparisons_byte.p8

@@ -52,16 +52,10 @@ main {
         c64scr.print("v1=20, v2=-111\n")
         compare()
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("\nstack x ok!\n")
-        else
-            c64scr.print("\nerror: stack x != 255 !\n")
-
+        check_eval_stack()
         return
 
-
-    sub compare() {
+        sub compare() {
         c64scr.print("  ==  !=  <   >   <=  >=\n")
 
         if v1==v2
@@ -98,4 +92,12 @@ main {
 
     }
 
+    sub check_eval_stack() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
+
 }

examples/comparisons_float.p8

@@ -68,16 +68,10 @@ main {
         c64scr.print("v1 = v2 = 0\n")
         compare()
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("\nstack x ok!\n")
-        else
-            c64scr.print("\nerror: stack x != 255 !\n")
-
-
+        check_eval_stack()
         return
 
-    sub compare() {
+        sub compare() {
         c64scr.print("  ==  !=  <   >   <=  >=\n")
 
         if v1==v2
@@ -112,7 +106,13 @@ main {
 
     }
 
-
     }
 
+    sub check_eval_stack() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
 }

examples/comparisons_ubyte.p8

@@ -52,15 +52,10 @@ main {
         c64scr.print("v1=220, v2=10\n")
         compare()
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("\nstack x ok!\n")
-        else
-            c64scr.print("\nerror: stack x != 255 !\n")
-
+        check_eval_stack()
         return
 
-    sub compare() {
+        sub compare() {
         c64scr.print("  ==  !=  <   >   <=  >=\n")
 
         if v1==v2
@@ -97,4 +92,12 @@ main {
 
     }
 
+    sub check_eval_stack() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
+
 }

examples/comparisons_uword.p8

@@ -82,16 +82,10 @@ main {
         c64scr.print("v1 = v2 = aa\n")
         compare()
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("\nstack x ok!\n")
-        else
-            c64scr.print("\nerror: stack x != 255 !\n")
-
-
+        check_eval_stack()
         return
 
-    sub compare() {
+        sub compare() {
         c64scr.print("  ==  !=  <   >   <=  >=\n")
 
         if v1==v2
@@ -128,4 +122,12 @@ main {
 
     }
 
+    sub check_eval_stack() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
+
 }

examples/comparisons_word.p8

@@ -118,15 +118,10 @@ main {
         c64scr.print("v1 = v2 = aa\n")
         compare()
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("\nstack x ok!\n")
-        else
-            c64scr.print("\nerror: stack x != 255 !\n")
-
+        check_eval_stack()
         return
 
-    sub compare() {
+        sub compare() {
         c64scr.print("  ==  !=  <   >   <=  >=\n")
 
         if v1==v2
@@ -163,4 +158,12 @@ main {
 
     }
 
+    sub check_eval_stack() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
+
 }