regenerated example disk , version 5.3

now allows taking the address of a subroutine &routine

.idea/misc.xml

@@ -16,7 +16,7 @@
       </list>
     </option>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="Kotlin SDK" project-jdk-type="KotlinSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="false" project-jdk-name="Kotlin SDK" project-jdk-type="KotlinSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

README.md

@@ -20,36 +20,36 @@ Full documentation (syntax reference, how to use the language and the compiler,
 https://prog8.readthedocs.io/
 
 
-What use Prog8 provide?
------------------------
+What does Prog8 provide?
+------------------------
 
-- reduction of source code length over raw assembly
+- big reduction of source code length over raw assembly
 - modularity, symbol scoping, subroutines
 - various data types other than just bytes (16-bit words, floats, strings)
 - automatic variable allocations, automatic string and array variables and string sharing
 - subroutines with an input- and output parameter signature
-- constant folding in expressions
+- no stack frame allocations because parameters and local variables are automatically allocated statically
+- constant folding in expressions and other high-level program optimizations
 - conditional branches
-- 'when' statement to provide a concise jump table alternative to if/elseif chains
-- structs to group together sets of variables and manipulate them at once
 - floating point operations  (requires the C64 Basic ROM routines for this)
-- abstracting away low level aspects such as ZeroPage handling, program startup, explicit memory addresses
-- various code optimizations (code structure, logical and numerical expressions, unused code removal...)
-- inline assembly allows you to have full control when every cycle or byte matters
+- 'when' statement to provide a concise jump table alternative to if/elseif chains
 - many built-in functions such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``sort`` and ``reverse``
+- structs to group together sets of variables and manipulate them at once
+- convenience abstractions for low level aspects such as ZeroPage handling, program startup, explicit memory addresses
+- fast execution speed due to compilation to native assembly code
+- inline assembly allows you to have full control when every cycle or byte matters
 
 *Rapid edit-compile-run-debug cycle:*
 
-- use a modern PC to do the work on
-- very quick compilation times
+- use a modern PC to do the work on, use nice editors and enjoy 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
 
 *Two supported compiler targets* (contributions to improve these or to add support for other machines are welcome!):
 
-- "c64": Commodore-64  (6510 CPU = almost a 6502)  premium support.
-- "cx16": [CommanderX16](https://www.commanderx16.com)  (65c02 CPU)  experimental support.
+- "c64": Commodore-64  (6510 CPU = almost a 6502), the main target.
+- "cx16": [CommanderX16](https://www.commanderx16.com)  (65c02 CPU) .
 - If you only use standard kernel and prog8 library routines, it is possible to compile the *exact same program* for both machines (just change the compiler target flag)!
 
 
@@ -61,7 +61,7 @@ Additional required tools
 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).
 
-A **Java runtime (jre or jdk), version 8 or newer**  is required to run a prepackaged version of the compiler.
+A **Java runtime (jre or jdk), version 11 or newer**  is required to run a prepackaged version of the compiler.
 If you want to build it from source, you'll need a Java SDK + Kotlin 1.3.x SDK (or for instance,
 IntelliJ IDEA with the Kotlin plugin).
 

compiler/build.gradle

@@ -1,11 +1,11 @@
 buildscript {
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.10"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.20"
     }
 }
 
 plugins {
-    // id "org.jetbrains.kotlin.jvm" version "1.4.10"
+    // id "org.jetbrains.kotlin.jvm" version "1.4.20"
     id 'application'
     id 'org.jetbrains.dokka' version "0.9.18"
     id 'com.github.johnrengelman.shadow' version '5.2.0'
@@ -15,8 +15,8 @@ plugins {
 apply plugin: "kotlin"
 apply plugin: "java"
 
-targetCompatibility = 1.8
-sourceCompatibility = 1.8
+targetCompatibility = 11
+sourceCompatibility = 11
 
 repositories {
     mavenLocal()
@@ -45,7 +45,7 @@ dependencies {
 
 compileKotlin {
     kotlinOptions {
-        jvmTarget = "1.8"
+        jvmTarget = "11"
         // verbose = true
         // freeCompilerArgs += "-XXLanguage:+NewInference"
     }
@@ -53,7 +53,7 @@ compileKotlin {
 
 compileTestKotlin {
     kotlinOptions {
-        jvmTarget = "1.8"
+        jvmTarget = "11"
     }
 }
 

compiler/res/prog8lib/c64/floats.asm

@@ -55,6 +55,69 @@ w2float		.proc
 		jmp  ub2float._fac_to_mem
 		.pend
 
+
+cast_from_uw	.proc
+		; -- uword in A/Y into float var at (P8ZP_SCRATCH_W2)
+		stx  P8ZP_SCRATCH_REG
+		jsr  GIVUAYFAY
+		jmp  ub2float._fac_to_mem
+		.pend
+
+
+cast_from_w	.proc
+		; -- word in A/Y into float var at (P8ZP_SCRATCH_W2)
+		stx  P8ZP_SCRATCH_REG
+		jsr  GIVAYFAY
+		jmp  ub2float._fac_to_mem
+		.pend
+
+
+cast_from_ub	.proc
+		; -- ubyte in Y into float var at (P8ZP_SCRATCH_W2)
+		stx  P8ZP_SCRATCH_REG
+		jsr  FREADUY
+		jmp  ub2float._fac_to_mem
+		.pend
+
+
+cast_from_b	.proc
+		; -- byte in A into float var at (P8ZP_SCRATCH_W2)
+		stx  P8ZP_SCRATCH_REG
+		jsr  FREADSA
+		jmp  ub2float._fac_to_mem
+		.pend
+
+cast_as_uw_into_ya	.proc               ; also used for float 2 ub
+		; -- cast float at A/Y to uword into Y/A
+		jsr  MOVFM
+		jmp  cast_FAC1_as_uw_into_ya
+		.pend
+
+cast_as_w_into_ay	.proc               ; also used for float 2 b
+		; -- cast float at A/Y to word into A/Y
+		jsr  MOVFM
+		jmp  cast_FAC1_as_w_into_ay
+		.pend
+
+cast_FAC1_as_uw_into_ya	.proc               ; also used for float 2 ub
+		; -- cast fac1 to uword into Y/A
+		stx  P8ZP_SCRATCH_REG
+		jsr  GETADR     ; into Y/A
+		ldx  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+cast_FAC1_as_w_into_ay	.proc               ; also used for float 2 b
+		; -- cast fac1 to word into A/Y
+		stx  P8ZP_SCRATCH_REG
+		jsr  AYINT
+		ldy  $64
+		lda  $65
+		ldx  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+
 stack_b2float	.proc
 		; -- b2float operating on the stack
 		inx
@@ -96,8 +159,8 @@ stack_uw2float	.proc
 		.pend
 
 stack_float2w	.proc               ; also used for float2b
-		stx  P8ZP_SCRATCH_REG
 		jsr  pop_float_fac1
+		stx  P8ZP_SCRATCH_REG
 		jsr  AYINT
 		ldx  P8ZP_SCRATCH_REG
 		lda  $64
@@ -109,8 +172,8 @@ stack_float2w	.proc               ; also used for float2b
 		.pend
 
 stack_float2uw	.proc               ; also used for float2ub
-		stx  P8ZP_SCRATCH_REG
 		jsr  pop_float_fac1
+		stx  P8ZP_SCRATCH_REG
 		jsr  GETADR
 		ldx  P8ZP_SCRATCH_REG
 		sta  P8ESTACK_HI,x
@@ -327,6 +390,99 @@ neg_f		.proc
 		rts
 		.pend
 
+var_fac1_less_f	.proc
+		; -- is the float in FAC1 < the variable AY?
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		cmp  #255
+		beq  +
+		lda  #0
+		rts
++		lda  #1
+		rts
+		.pend
+
+var_fac1_lesseq_f	.proc
+		; -- is the float in FAC1 <= the variable AY?
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		cmp  #0
+		beq  +
+		cmp  #255
+		beq  +
+		lda  #0
+		rts
++		lda  #1
+		rts
+		.pend
+
+var_fac1_greater_f	.proc
+		; -- is the float in FAC1 > the variable AY?
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		cmp  #1
+		beq  +
+		lda  #0
++		rts
+		.pend
+
+var_fac1_greatereq_f	.proc
+		; -- is the float in FAC1 >= the variable AY?
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		cmp  #0
+		beq  +
+		cmp  #1
+		beq  +
+		lda  #0
+		rts
++		lda  #1
+		rts
+		.pend
+
+var_fac1_notequal_f	.proc
+		; -- are the floats numbers in FAC1 and the variable AY *not* identical?
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		and  #1
+		rts
+		.pend
+
+vars_equal_f	.proc
+		; -- are the mflpt5 numbers in P8ZP_SCRATCH_W1 and AY identical?
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		ldy  #0
+		lda  (P8ZP_SCRATCH_W1),y
+		cmp  (P8ZP_SCRATCH_W2),y
+		bne  _false
+		iny
+		lda  (P8ZP_SCRATCH_W1),y
+		cmp  (P8ZP_SCRATCH_W2),y
+		bne  _false
+		iny
+		lda  (P8ZP_SCRATCH_W1),y
+		cmp  (P8ZP_SCRATCH_W2),y
+		bne  _false
+		iny
+		lda  (P8ZP_SCRATCH_W1),y
+		cmp  (P8ZP_SCRATCH_W2),y
+		bne  _false
+		iny
+		lda  (P8ZP_SCRATCH_W1),y
+		cmp  (P8ZP_SCRATCH_W2),y
+		bne  _false
+		lda  #1
+		rts
+_false		lda  #0
+		rts
+		.pend
+
 equal_f		.proc
 		; -- are the two mflpt5 numbers on the stack identical?
 		inx
@@ -364,6 +520,40 @@ notequal_f	.proc
 		rts
 		.pend
 
+vars_less_f	.proc
+		; -- is float in AY < float in P8ZP_SCRATCH_W2 ?
+		jsr  MOVFM
+		lda  P8ZP_SCRATCH_W2
+		ldy  P8ZP_SCRATCH_W2+1
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		cmp  #255
+		bne  +
+		lda  #1
+		rts
++		lda  #0
+		rts
+		.pend
+
+vars_lesseq_f	.proc
+		; -- is float in AY <= float in P8ZP_SCRATCH_W2 ?
+		jsr  MOVFM
+		lda  P8ZP_SCRATCH_W2
+		ldy  P8ZP_SCRATCH_W2+1
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		cmp  #255
+		bne  +
+-		lda  #1
+		rts
++		cmp  #0
+		beq  -
+		lda  #0
+		rts
+		.pend
+
 less_f		.proc
 		; -- is f1 < f2?
 		jsr  compare_floats

compiler/res/prog8lib/c64/graphics.p8

@@ -12,11 +12,20 @@ graphics {
 
     sub enable_bitmap_mode() {
         ; enable bitmap screen, erase it and set colors to black/white.
-        c64.SCROLY |= %00100000
+        c64.SCROLY = %00111011
+        c64.SCROLX = %00001000
         c64.VMCSB = (c64.VMCSB & %11110000) | %00001000   ; $2000-$3fff
         clear_screen(1, 0)
     }
 
+    sub disable_bitmap_mode() {
+        ; enables text mode, erase the text screen, color white
+        c64.SCROLY = %00011011
+        c64.SCROLX = %00001000
+        c64.VMCSB = (c64.VMCSB & %11110000) | %00000100   ; $1000-$2fff
+        txt.fill_screen(' ', 1)
+    }
+
     sub clear_screen(ubyte pixelcolor, ubyte bgcolor) {
         memset(BITMAP_ADDRESS, 320*200/8, 0)
         txt.fill_screen(pixelcolor << 4 | bgcolor, 0)
@@ -149,21 +158,17 @@ graphics {
             ubyte ycenter_plus_xx = ycenter + xx
             ubyte ycenter_min_xx = ycenter - xx
 
-            for internal_plotx in xcenter to xcenter+xx {
+            internal_plotx = xcenter-xx
+            repeat xx*2+1 {
                 internal_plot(ycenter_plus_yy)
                 internal_plot(ycenter_min_yy)
+                internal_plotx++
             }
-            for internal_plotx in xcenter-xx to xcenter-1 {
-                internal_plot(ycenter_plus_yy)
-                internal_plot(ycenter_min_yy)
-            }
-            for internal_plotx in xcenter to xcenter+yy {
-                internal_plot(ycenter_plus_xx)
-                internal_plot(ycenter_min_xx)
-            }
-            for internal_plotx in xcenter-yy to xcenter {
+            internal_plotx = xcenter-yy
+            repeat yy*2+1 {
                 internal_plot(ycenter_plus_xx)
                 internal_plot(ycenter_min_xx)
+                internal_plotx++
             }
             yy++
             if decisionOver2<=0

compiler/res/prog8lib/c64/textio.p8

@@ -38,13 +38,13 @@ asmsub  clear_screenchars (ubyte char @ A) clobbers(Y)  {
 	; ---- clear the character screen with the given fill character (leaves colors)
 	;      (assumes screen matrix is at the default address)
 	%asm {{
-		ldy  #0
-_loop		sta  c64.Screen,y
-		sta  c64.Screen+$0100,y
-		sta  c64.Screen+$0200,y
-		sta  c64.Screen+$02e8,y
-		iny
-		bne  _loop
+		ldy  #250
+-		sta  c64.Screen+250*0-1,y
+		sta  c64.Screen+250*1-1,y
+		sta  c64.Screen+250*2-1,y
+		sta  c64.Screen+250*3-1,y
+		dey
+		bne  -
 		rts
         }}
 }
@@ -53,13 +53,13 @@ asmsub  clear_screencolors (ubyte color @ A) clobbers(Y)  {
 	; ---- clear the character screen colors with the given color (leaves characters).
 	;      (assumes color matrix is at the default address)
 	%asm {{
-		ldy  #0
-_loop		sta  c64.Colors,y
-		sta  c64.Colors+$0100,y
-		sta  c64.Colors+$0200,y
-		sta  c64.Colors+$02e8,y
-		iny
-		bne  _loop
+		ldy  #250
+-		sta  c64.Colors+250*0-1,y
+		sta  c64.Colors+250*1-1,y
+		sta  c64.Colors+250*2-1,y
+		sta  c64.Colors+250*3-1,y
+		dey
+		bne  -
 		rts
         }}
 }
@@ -83,29 +83,31 @@ asmsub  scroll_left  (ubyte alsocolors @ Pc) clobbers(A, Y)  {
 
 	%asm {{
 		stx  P8ZP_SCRATCH_REG
-		bcs  +
-		jmp  _scroll_screen
+		bcc _scroll_screen
 
-+               ; scroll the color memory
++               ; scroll the screen and the color memory
 		ldx  #0
 		ldy  #38
 -
-	.for row=0, row<=24, row+=1
-		lda  c64.Colors + 40*row + 1,x
-		sta  c64.Colors + 40*row,x
-	.next
+        .for row=0, row<=24, row+=1
+            lda  c64.Screen + 40*row + 1,x
+            sta  c64.Screen + 40*row + 0,x
+            lda  c64.Colors + 40*row + 1,x
+            sta  c64.Colors + 40*row + 0,x
+        .next
 		inx
 		dey
 		bpl  -
+		rts
 
-_scroll_screen  ; scroll the screen memory
+_scroll_screen  ; scroll only the screen memory
 		ldx  #0
 		ldy  #38
 -
-	.for row=0, row<=24, row+=1
-		lda  c64.Screen + 40*row + 1,x
-		sta  c64.Screen + 40*row,x
-	.next
+        .for row=0, row<=24, row+=1
+            lda  c64.Screen + 40*row + 1,x
+            sta  c64.Screen + 40*row + 0,x
+        .next
 		inx
 		dey
 		bpl  -
@@ -121,26 +123,28 @@ asmsub  scroll_right  (ubyte alsocolors @ Pc) clobbers(A)  {
 	;      Carry flag determines if screen color data must be scrolled too
 	%asm {{
 		stx  P8ZP_SCRATCH_REG
-		bcs  +
-		jmp  _scroll_screen
+		bcc  _scroll_screen
 
-+               ; scroll the color memory
++               ; scroll the screen and the color memory
 		ldx  #38
 -
-	.for row=0, row<=24, row+=1
-		lda  c64.Colors + 40*row + 0,x
-		sta  c64.Colors + 40*row + 1,x
-	.next
+        .for row=0, row<=24, row+=1
+            lda  c64.Screen + 40*row + 0,x
+            sta  c64.Screen + 40*row + 1,x
+            lda  c64.Colors + 40*row + 0,x
+            sta  c64.Colors + 40*row + 1,x
+        .next
 		dex
 		bpl  -
+		rts
 
-_scroll_screen  ; scroll the screen memory
+_scroll_screen  ; scroll only the screen memory
 		ldx  #38
 -
-	.for row=0, row<=24, row+=1
-		lda  c64.Screen + 40*row + 0,x
-		sta  c64.Screen + 40*row + 1,x
-	.next
+        .for row=0, row<=24, row+=1
+            lda  c64.Screen + 40*row + 0,x
+            sta  c64.Screen + 40*row + 1,x
+        .next
 		dex
 		bpl  -
 
@@ -155,26 +159,28 @@ asmsub  scroll_up  (ubyte alsocolors @ Pc) clobbers(A)  {
 	;      Carry flag determines if screen color data must be scrolled too
 	%asm {{
 		stx  P8ZP_SCRATCH_REG
-		bcs  +
-		jmp  _scroll_screen
+		bcc  _scroll_screen
 
-+               ; scroll the color memory
++               ; scroll the screen and the color memory
 		ldx #39
 -
-	.for row=1, row<=24, row+=1
-		lda  c64.Colors + 40*row,x
-		sta  c64.Colors + 40*(row-1),x
-	.next
+        .for row=1, row<=24, row+=1
+            lda  c64.Screen + 40*row,x
+            sta  c64.Screen + 40*(row-1),x
+            lda  c64.Colors + 40*row,x
+            sta  c64.Colors + 40*(row-1),x
+        .next
 		dex
 		bpl  -
+		rts
 
-_scroll_screen  ; scroll the screen memory
+_scroll_screen  ; scroll only the screen memory
 		ldx #39
 -
-	.for row=1, row<=24, row+=1
-		lda  c64.Screen + 40*row,x
-		sta  c64.Screen + 40*(row-1),x
-	.next
+        .for row=1, row<=24, row+=1
+            lda  c64.Screen + 40*row,x
+            sta  c64.Screen + 40*(row-1),x
+        .next
 		dex
 		bpl  -
 
@@ -189,26 +195,28 @@ asmsub  scroll_down  (ubyte alsocolors @ Pc) clobbers(A)  {
 	;      Carry flag determines if screen color data must be scrolled too
 	%asm {{
 		stx  P8ZP_SCRATCH_REG
-		bcs  +
-		jmp  _scroll_screen
+		bcc  _scroll_screen
 
-+               ; scroll the color memory
++               ; scroll the screen and the color memory
 		ldx #39
 -
-	.for row=23, row>=0, row-=1
-		lda  c64.Colors + 40*row,x
-		sta  c64.Colors + 40*(row+1),x
-	.next
+        .for row=23, row>=0, row-=1
+            lda  c64.Colors + 40*row,x
+            sta  c64.Colors + 40*(row+1),x
+            lda  c64.Screen + 40*row,x
+            sta  c64.Screen + 40*(row+1),x
+        .next
 		dex
 		bpl  -
+		rts
 
-_scroll_screen  ; scroll the screen memory
+_scroll_screen  ; scroll only the screen memory
 		ldx #39
 -
-	.for row=23, row>=0, row-=1
-		lda  c64.Screen + 40*row,x
-		sta  c64.Screen + 40*(row+1),x
-	.next
+        .for row=23, row>=0, row-=1
+            lda  c64.Screen + 40*row,x
+            sta  c64.Screen + 40*(row+1),x
+        .next
 		dex
 		bpl  -
 

compiler/res/prog8lib/conv.p8

@@ -254,7 +254,6 @@ asmsub  str2ubyte(str string @ AY) clobbers(Y) -> ubyte @A {
 	; -- returns the unsigned byte value of the string number argument in AY
 	;    the number may NOT be preceded by a + sign and may NOT contain spaces
 	;    (any non-digit character will terminate the number string that is parsed)
-	; TODO implement optimized custom version of this instead of simply reusing str2uword
 	%asm {{
     	jmp  str2uword
 	}}
@@ -264,7 +263,6 @@ asmsub  str2byte(str string @ AY) clobbers(Y) -> ubyte @A {
 	; -- returns the signed byte value of the string number argument in AY
 	;    the number may be preceded by a + or - sign but may NOT contain spaces
 	;    (any non-digit character will terminate the number string that is parsed)
-	; TODO implement optimized custom version of this instead of simply reusing str2word
 	%asm {{
     	jmp  str2word
 	}}

compiler/res/prog8lib/cx16/c64colors.p8

@@ -0,0 +1,87 @@
+%target cx16
+
+c64colors {
+    uword[] colorpalette_dark = [   ; this is a darker palette with more contrast
+        $000,  ; 0 = black
+        $FFF,  ; 1 = white
+        $632,  ; 2 = red
+        $7AB,  ; 3 = cyan
+        $638,  ; 4 = purple
+        $584,  ; 5 = green
+        $327,  ; 6 = blue
+        $BC6,  ; 7 = yellow
+        $642,  ; 8 = orange
+        $430,  ; 9 = brown
+        $965,  ; 10 = light red
+        $444,  ; 11 = dark grey
+        $666,  ; 12 = medium grey
+        $9D8,  ; 13 = light green
+        $65B,  ; 14 = light blue
+        $999  ; 15 = light grey
+    ]
+
+    uword[] colorpalette_pepto = [  ; # this is Pepto's Commodore-64 palette  http://www.pepto.de/projects/colorvic/
+        $000,  ; 0 = black
+        $FFF,  ; 1 = white
+        $833,  ; 2 = red
+        $7cc,  ; 3 = cyan
+        $839,  ; 4 = purple
+        $5a4,  ; 5 = green
+        $229,  ; 6 = blue
+        $ef7,  ; 7 = yellow
+        $852,  ; 8 = orange
+        $530,  ; 9 = brown
+        $c67,  ; 10 = light red
+        $444,  ; 11 = dark grey
+        $777,  ; 12 = medium grey
+        $af9,  ; 13 = light green
+        $76e,  ; 14 = light blue
+        $bbb  ; 15 = light grey
+    ]
+
+    uword[] colorpalette_light = [  ; this is a lighter palette
+        $000,  ; 0 = black
+        $FFF,  ; 1 = white
+        $944,  ; 2 = red
+        $7CC,  ; 3 = cyan
+        $95A,  ; 4 = purple
+        $6A5,  ; 5 = green
+        $549,  ; 6 = blue
+        $CD8,  ; 7 = yellow
+        $963,  ; 8 = orange
+        $650,  ; 9 = brown
+        $C77,  ; 10 = light red
+        $666,  ; 11 = dark grey
+        $888,  ; 12 = medium grey
+        $AE9,  ; 13 = light green
+        $87C,  ; 14 = light blue
+        $AAA   ; 15 = light grey
+    ]
+
+    ubyte color
+
+    sub set_palette_pepto() {
+        for color in 0 to 15 {
+            uword cc = colorpalette_pepto[color]
+            cx16.vpoke(1, $fa00 + color*2, lsb(cc))     ; G, B
+            cx16.vpoke(1, $fa01 + color*2, msb(cc))     ; R
+        }
+    }
+
+    sub set_palette_light() {
+        for color in 0 to 15 {
+            uword cc = colorpalette_light[color]
+            cx16.vpoke(1, $fa00 + color*2, lsb(cc))     ; G, B
+            cx16.vpoke(1, $fa01 + color*2, msb(cc))     ; R
+        }
+    }
+
+    sub set_palette_dark() {
+        for color in 0 to 15 {
+            uword cc = colorpalette_dark[color]
+            cx16.vpoke(1, $fa00 + color*2, lsb(cc))     ; G, B
+            cx16.vpoke(1, $fa01 + color*2, msb(cc))     ; R
+        }
+    }
+
+}

compiler/res/prog8lib/cx16/graphics.p8

@@ -1,5 +1,6 @@
 %target cx16
 %import syslib
+%import textio
 
 ; bitmap pixel graphics module for the CommanderX16
 ; wraps the graphics functions that are in ROM.
@@ -17,6 +18,13 @@ graphics {
         clear_screen(1, 0)
     }
 
+    sub disable_bitmap_mode() {
+        ; enables text mode, erase the text screen, color white
+        void cx16.screen_set_mode(2)
+        txt.fill_screen(' ', 1)     ; doesn't seem to fully clear the text screen after returning from gfx mode
+    }
+
+
     sub clear_screen(ubyte pixelcolor, ubyte bgcolor) {
         cx16.GRAPH_set_colors(pixelcolor, pixelcolor, bgcolor)
         cx16.GRAPH_clear()
@@ -35,7 +43,7 @@ graphics {
         ;cx16.r1 = ycenter - radius/2
         ;cx16.r2 = radius*2
         ;cx16.r3 = radius*2
-        ;cx16.GRAPH_draw_oval(false)          ; TODO  currently is not implemented on cx16, does a BRK
+        ;cx16.GRAPH_draw_oval(false)          ; currently this call is not implemented on cx16, does a BRK
 
         ; Midpoint algorithm
         ubyte @zp xx = radius
@@ -86,7 +94,7 @@ graphics {
 ;        cx16.r1 = ycenter - radius/2
 ;        cx16.r2 = radius*2
 ;        cx16.r3 = radius*2
-;        cx16.GRAPH_draw_oval(true)          ; TODO  currently is not implemented on cx16, does a BRK
+;        cx16.GRAPH_draw_oval(true)          ; currently this call is not implemented on cx16, does a BRK
 
         ubyte xx = radius
         ubyte yy = 0
@@ -99,42 +107,30 @@ graphics {
             ubyte ycenter_min_xx = ycenter - xx
             uword @zp plotx
 
-            for plotx in xcenter to xcenter+xx {
-                cx16.r0 = plotx
-                cx16.r1 = ycenter_plus_yy
-                cx16.FB_cursor_position()
+            cx16.r0 = xcenter-xx
+            cx16.r1 = ycenter_plus_yy
+            cx16.FB_cursor_position()
+            repeat xx*2+1
                 cx16.FB_set_pixel(1)
-                cx16.r1 = ycenter_min_yy
-                cx16.FB_cursor_position()
+
+            cx16.r0 = xcenter-xx
+            cx16.r1 = ycenter_min_yy
+            cx16.FB_cursor_position()
+            repeat xx*2+1
                 cx16.FB_set_pixel(1)
-            }
-            for plotx in xcenter-xx to xcenter-1 {
-                cx16.r0 = plotx
-                cx16.r1 = ycenter_plus_yy
-                cx16.FB_cursor_position()
+
+            cx16.r0 = xcenter-yy
+            cx16.r1 = ycenter_plus_xx
+            cx16.FB_cursor_position()
+            repeat yy*2+1
                 cx16.FB_set_pixel(1)
-                cx16.r1 = ycenter_min_yy
-                cx16.FB_cursor_position()
+
+            cx16.r0 = xcenter-yy
+            cx16.r1 = ycenter_min_xx
+            cx16.FB_cursor_position()
+            repeat yy*2+1
                 cx16.FB_set_pixel(1)
-            }
-            for plotx in xcenter to xcenter+yy {
-                cx16.r0 = plotx
-                cx16.r1 = ycenter_plus_xx
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-                cx16.r1 = ycenter_min_xx
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-            }
-            for plotx in xcenter-yy to xcenter {
-                cx16.r0 = plotx
-                cx16.r1 = ycenter_plus_xx
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-                cx16.r1 = ycenter_min_xx
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-            }
+
             yy++
             if decisionOver2<=0
                 decisionOver2 += 2*yy+1

compiler/res/prog8lib/cx16/syslib.p8

@@ -242,9 +242,44 @@ romsub $fecf = entropy_get() -> ubyte @A, ubyte @X, ubyte @Y
 romsub $fecc = monitor()  clobbers(A,X,Y)
 
 
-
 ; ---- end of kernal routines ----
 
+; ---- utilities -----
+    asmsub vpeek(ubyte bank @A, uword address @XY) -> ubyte @A {
+        ; -- get a byte from VERA's video memory
+        ;    note: inefficient when reading multiple sequential bytes!
+        %asm {{
+                stz  cx16.VERA_CTRL
+                and  #1
+                sta  cx16.VERA_ADDR_H
+                sty  cx16.VERA_ADDR_M
+                stx  cx16.VERA_ADDR_L
+                lda  cx16.VERA_DATA0
+                rts
+            }}
+    }
+
+    sub vpoke(ubyte bank, uword address, ubyte value) {
+        ; -- write a single byte to VERA's video memory
+        ;    note: inefficient when writing multiple sequential bytes!
+        %asm {{
+            stz  cx16.VERA_CTRL
+            lda  bank
+            and  #1
+            sta  cx16.VERA_ADDR_H
+            lda  address
+            sta  cx16.VERA_ADDR_L
+            lda  address+1
+            sta  cx16.VERA_ADDR_M
+            lda  value
+            sta  cx16.VERA_DATA0
+            rts
+        }}
+    }
+
+
+; ---- system stuff -----
+
 asmsub init_system()  {
     ; Initializes the machine to a sane starting state.
     ; Called automatically by the loader program logic.

compiler/res/prog8lib/cx16/textio.p8

@@ -154,10 +154,9 @@ sub uppercase() {
     cx16.screen_set_charset(2, 0)  ; uppercase charset
 }
 
-asmsub  scroll_left  (ubyte dummy @ Pc) clobbers(A, Y)  {
+asmsub  scroll_left() 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 is a dummy on the cx16
 	%asm {{
 	    phx
 	    jsr  c64.SCREEN
@@ -198,10 +197,9 @@ _lx     ldx  #0                ; modified
 	}}
 }
 
-asmsub  scroll_right  (ubyte dummy @ Pc) clobbers(A)  {
+asmsub  scroll_right() clobbers(A)  {
 	; ---- scroll the whole screen 1 character to the right
 	;      contents of the leftmost column are unchanged, you should clear/refill this yourself
-	;      Carry flag is a dummy on the cx16
 	%asm {{
 	    phx
 	    jsr  c64.SCREEN
@@ -250,10 +248,9 @@ _lx     ldx  #0                 ; modified
 	}}
 }
 
-asmsub  scroll_up  (ubyte dummy @ Pc) clobbers(A, Y)  {
+asmsub  scroll_up() clobbers(A, Y)  {
 	; ---- scroll the whole screen 1 character up
 	;      contents of the bottom row are unchanged, you should refill/clear this yourself
-	;      Carry flag is a dummy on the cx16
 	%asm {{
 	    phx
 	    jsr  c64.SCREEN
@@ -300,10 +297,9 @@ _nextline
 	}}
 }
 
-asmsub  scroll_down  (ubyte dummy @ Pc) clobbers(A, Y)  {
+asmsub  scroll_down() clobbers(A, Y)  {
 	; ---- scroll the whole screen 1 character down
 	;      contents of the top row are unchanged, you should refill/clear this yourself
-	;      Carry flag is a dummy on the cx16
 	%asm {{
 	    phx
 	    jsr  c64.SCREEN

compiler/res/prog8lib/diskio.p8

@@ -6,8 +6,8 @@
 diskio {
 
 
-    sub directory(ubyte drivenumber) -> byte {
-        ; -- Shows the directory contents of disk drive 8-11 (provide as argument).
+    sub directory(ubyte drivenumber) -> ubyte {
+        ; -- Shows the directory contents of disk drive 8-11 (provide as argument). Returns success flag.
 
         c64.SETNAM(1, "$")
         c64.SETLFS(1, drivenumber, 0)
@@ -25,7 +25,9 @@ diskio {
         ; while not key pressed / EOF encountered, read data.
         ubyte status = c64.READST()
         while not status {
-            txt.print_uw(mkword(c64.CHRIN(), c64.CHRIN()))
+            ubyte low = c64.CHRIN()
+            ubyte high = c64.CHRIN()
+            txt.print_uw(mkword(high, low))
             txt.chrout(' ')
             ubyte @zp char
             do {
@@ -57,9 +59,121 @@ io_error:
     }
 
 
+    ; internal variables for the iterative file lister
+    ubyte list_suffixmatch
+    ubyte list_in_progress = false
+    ubyte list_pattern_size
+    ubyte list_skip_disk_name
+    uword list_pattern
+    uword list_blocks
+    str   list_filename = "????????????????"
+
+    sub lf_start_list(ubyte drivenumber, uword pattern, ubyte suffixmatch) -> ubyte {
+        ; -- start an iterative file listing with optional prefix or suffix name matching.
+        lf_end_list()
+        list_pattern = pattern
+        list_suffixmatch = suffixmatch
+        list_skip_disk_name = true
+        list_in_progress = true
+        if pattern==0
+            list_pattern_size = 0
+        else
+            list_pattern_size = strlen(pattern)
+
+        c64.SETNAM(1, "$")
+        c64.SETLFS(1, drivenumber, 0)
+        void c64.OPEN()          ; open 1,8,0,"$"
+        if_cs
+            goto io_error
+        void c64.CHKIN(1)        ; use #1 as input channel
+        if_cs
+            goto io_error
+
+        repeat 4 {
+            void c64.CHRIN()     ; skip the 4 prologue bytes
+        }
+
+        if c64.READST()==0
+            return true
+
+io_error:
+        lf_end_list()
+        return false
+    }
+
+    sub lf_next_entry() -> ubyte {
+        ; -- retrieve the next entry from an iterative file listing session.
+        ;    results will be found in list_blocks and list_filename.
+        ;    if it returns false though, there are no more entries (or an error occurred).
+
+        if not list_in_progress
+            return false
+
+        while not c64.READST() {
+            uword nameptr = &list_filename
+            ubyte blocks_lsb = c64.CHRIN()
+            ubyte blocks_msb = c64.CHRIN()
+            list_blocks = mkword(blocks_msb, blocks_lsb)
+
+            ; read until the filename starts after the first "
+            while c64.CHRIN()!='\"'  {
+                if c64.READST()
+                    goto close_end
+            }
+
+            ; read the filename
+            repeat {
+                ubyte char = c64.CHRIN()
+                if_z
+                    break
+                if char=='\"'
+                    break
+                @(nameptr) = char
+                nameptr++
+            }
+
+            @(nameptr) = 0
+
+            while c64.CHRIN() {
+                ; read the rest of the entry until the end
+            }
+
+            void c64.CHRIN()     ; skip 2 bytes
+            void c64.CHRIN()
+
+            if not list_skip_disk_name {
+                if list_pattern_size {
+                    ; do filename matching
+                    if list_suffixmatch
+                        rightstr(list_filename, filename, list_pattern_size)
+                    else
+                        leftstr(list_filename, filename, list_pattern_size)
+                    if strcmp(filename, list_pattern)==0
+                        return true
+                } else
+                    return true
+            }
+            list_skip_disk_name = false
+        }
+
+close_end:
+        lf_end_list()
+        return false
+    }
+
+    sub lf_end_list() {
+        ; -- end an iterative file listing session (close channels).
+        if list_in_progress {
+            c64.CLRCHN()
+            c64.CLOSE(1)
+            list_in_progress = false
+        }
+    }
+
+
     sub status(ubyte drivenumber) {
         ; -- display the disk drive's current status message
-        c64.SETNAM(0, $0000)
+        c64.SETNAM(0, filename)
         c64.SETLFS(15, drivenumber, 15)
         void c64.OPEN()          ; open 15,8,15
         if_cs
@@ -77,7 +191,7 @@ io_error:
     }
 
 
-    sub save(ubyte drivenumber, uword filenameptr, uword address, uword size) -> byte {
+    sub save(ubyte drivenumber, uword filenameptr, uword address, uword size) -> ubyte {
         c64.SETNAM(strlen(filenameptr), filenameptr)
         c64.SETLFS(1, drivenumber, 0)
         uword end_address = address + size
@@ -97,10 +211,14 @@ io_error:
             plp
         }}
 
+        ubyte result=0
         if_cc
-            return c64.READST()==0
+            result = c64.READST()==0
 
-        return false
+        c64.CLRCHN()
+        c64.CLOSE(1)
+
+        return result
     }
 
     sub load(ubyte drivenumber, uword filenameptr, uword address_override) -> uword {
@@ -122,6 +240,9 @@ io_error:
 +           ldx  P8ZP_SCRATCH_REG
         }}
 
+        c64.CLRCHN()
+        c64.CLOSE(1)
+
         if end_of_load
             return end_of_load - address_override
 

compiler/res/prog8lib/math.asm

@@ -774,6 +774,31 @@ stack_mul_word_100	.proc
 		rts
 		.pend
 
+stack_mul_word_320	.proc
+		; stackW = stackLo * 256 + stackLo * 64	 (stackHi doesn't matter)
+		ldy  P8ESTACK_LO+1,x
+		lda  #0
+		sta  P8ESTACK_HI+1,x
+		tya
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		sta  P8ESTACK_LO+1,x
+		tya
+		clc
+		adc  P8ESTACK_HI+1,x
+		sta  P8ESTACK_HI+1,x
+		rts
+		.pend
 
 ; ----------- optimized multiplications (in-place A (byte) and ?? (word)) : ---------
 mul_byte_3	.proc
@@ -1241,6 +1266,32 @@ mul_word_100	.proc
 		rts
 		.pend
 
+mul_word_320	.proc
+		; AY = A * 256 + A * 64	 (msb doesn't matter)
+		sta  P8ZP_SCRATCH_B1
+		ldy  #0
+		sty  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		pha
+		clc
+		lda  P8ZP_SCRATCH_B1
+		adc  P8ZP_SCRATCH_REG
+		tay
+		pla
+		rts
+		.pend
+
 ; ----------- end optimized multiplications -----------
 
 

compiler/res/prog8lib/prog8_lib.asm

@@ -30,6 +30,7 @@ write_byte_to_address_on_stack	.proc
 		.pend
 
 
+
 neg_b		.proc
 		lda  #0
 		sec
@@ -443,6 +444,19 @@ less_b		.proc
 		bpl  equal_b._equal_b_false
 		.pend
 
+reg_less_uw	.proc
+		;  AY < P8ZP_SCRATCH_W2?
+		cpy  P8ZP_SCRATCH_W2+1
+		bcc  _true
+		bne  _false
+		cmp  P8ZP_SCRATCH_W2
+		bcc  _true
+_false		lda  #0
+		rts
+_true		lda  #1
+		rts
+		.pend
+
 less_uw		.proc
 		lda  P8ESTACK_HI+2,x
 		cmp  P8ESTACK_HI+1,x
@@ -454,6 +468,20 @@ less_uw		.proc
 		bcs  equal_b._equal_b_false
 		.pend
 
+reg_less_w	.proc
+		; -- AY < P8ZP_SCRATCH_W2?
+		cmp  P8ZP_SCRATCH_W2
+		tya
+		sbc  P8ZP_SCRATCH_W2+1
+		bvc  +
+		eor  #$80
++		bmi  _true
+		lda  #0
+		rts
+_true		lda  #1
+		rts
+		.pend
+
 less_w		.proc
 		lda  P8ESTACK_LO+2,x
 		cmp  P8ESTACK_LO+1,x
@@ -496,6 +524,22 @@ lesseq_b	.proc
 		bpl  equal_b._equal_b_false
 		.pend
 
+reg_lesseq_uw	.proc
+		; AY <= P8ZP_SCRATCH_W2?
+		cpy  P8ZP_SCRATCH_W2+1
+		beq  +
+		bcc  _true
+		lda  #0
+		rts
++		cmp  P8ZP_SCRATCH_W2
+		bcc  _true
+		beq  _true
+		lda  #0
+		rts
+_true		lda  #1
+		rts
+		.pend
+
 lesseq_uw	.proc
 		lda  P8ESTACK_HI+1,x
 		cmp  P8ESTACK_HI+2,x
@@ -507,6 +551,20 @@ lesseq_uw	.proc
 		bcc  equal_b._equal_b_false
 		.pend
 
+reg_lesseq_w	.proc
+		; -- P8ZP_SCRATCH_W2 <= AY ?   (note: order different from other routines)
+		cmp  P8ZP_SCRATCH_W2
+		tya
+		sbc  P8ZP_SCRATCH_W2+1
+		bvc  +
+		eor  #$80
++		bpl  +
+		lda  #0
+		rts
++		lda  #1
+		rts
+		.pend
+
 lesseq_w	.proc
 		lda  P8ESTACK_LO+1,x
 		cmp  P8ESTACK_LO+2,x
@@ -595,8 +653,8 @@ greatereq_w	.proc
 		sbc  P8ESTACK_HI+1,x
 		bvc  +
 		eor  #$80
-+		bpl  equal_b._equal_b_true
-		bmi  equal_b._equal_b_false
++		bmi  equal_b._equal_b_false
+		bpl  equal_b._equal_b_true
 		.pend
 
 
@@ -989,3 +1047,28 @@ _return_minusone
             lda  #-1
             rts
             .pend
+
+
+sign_extend_stack_byte	.proc
+	; -- sign extend the (signed) byte on the stack to full 16 bits
+		lda  P8ESTACK_LO+1,x
+		ora  #$7f
+		bmi  +
+		lda  #0
++		sta  P8ESTACK_HI+1,x
+		rts
+		.pend
+
+
+sign_extend_AY_byte	.proc
+	; -- sign extend the (signed) byte in AY to full 16 bits
+		pha
+		and  #$80
+		beq  +
+		ldy  #$ff
+		pla
+		rts
++		ldy  #0
+		pla
+		rts
+		.pend

compiler/res/prog8lib/test_stack.p8

@@ -0,0 +1,48 @@
+%import textio
+
+test_stack {
+
+    asmsub test() {
+        %asm {{
+            stx  _saveX
+            lda  #13
+            jsr  txt.chrout
+            lda  #'-'
+            ldy  #12
+-           jsr  txt.chrout
+            dey
+            bne  -
+            lda  #13
+            jsr  txt.chrout
+            lda  #'x'
+            jsr  txt.chrout
+            lda  #'='
+            jsr  txt.chrout
+            lda  _saveX
+            jsr  txt.print_ub
+            lda  #' '
+            jsr  txt.chrout
+            lda  #'s'
+            jsr  txt.chrout
+            lda  #'p'
+            jsr  txt.chrout
+            lda  #'='
+            jsr  txt.chrout
+            tsx
+            txa
+            jsr  txt.print_ub
+            lda  #13
+            jsr  txt.chrout
+            lda  #'-'
+            ldy  #12
+-           jsr  txt.chrout
+            dey
+            bne  -
+            lda  #13
+            jsr  txt.chrout
+            ldx  _saveX
+            rts
+_saveX   .byte 0
+        }}
+    }
+}

compiler/res/version.txt

@@ -1 +1 @@
-5.0
+5.3

compiler/src/prog8/CompilerMain.kt

@@ -55,32 +55,42 @@ private fun compileMain(args: Array<String>) {
         exitProcess(1)
     }
 
-    if(watchMode && moduleFiles.size<=1) {
+    if(watchMode) {
         val watchservice = FileSystems.getDefault().newWatchService()
 
         while(true) {
-            val filepath = pathFrom(moduleFiles.single()).normalize()
-            println("Continuous watch mode active. Main module: $filepath")
-
-            try {
+            println("Continuous watch mode active. Modules: $moduleFiles")
+            val results = mutableListOf<CompilationResult>()
+            for(filepathRaw in moduleFiles) {
+                val filepath = pathFrom(filepathRaw).normalize()
                 val compilationResult = compileProgram(filepath, !dontOptimize, !dontWriteAssembly, slowCodegenWarnings, compilationTarget, outputPath)
-                println("Imported files (now watching:)")
-                for (importedFile in compilationResult.importedFiles) {
-                    print("  ")
-                    println(importedFile)
-                    importedFile.parent.register(watchservice, StandardWatchEventKinds.ENTRY_MODIFY)
-                }
-                println("[${LocalDateTime.now().withNano(0)}]  Waiting for file changes.")
+                results.add(compilationResult)
+            }
+
+            val allImportedFiles = results.flatMap { it.importedFiles }
+            println("Imported files (now watching:)")
+            for (importedFile in allImportedFiles) {
+                print("  ")
+                println(importedFile)
+                val watchDir = importedFile.parent ?: Path.of(".")
+                watchDir.register(watchservice, StandardWatchEventKinds.ENTRY_MODIFY)
+            }
+            println("[${LocalDateTime.now().withNano(0)}]  Waiting for file changes.")
+
+            var recompile=false
+            while(!recompile) {
                 val event = watchservice.take()
-                for(changed in event.pollEvents()) {
+                for (changed in event.pollEvents()) {
                     val changedPath = changed.context() as Path
-                    println("  change detected: $changedPath")
+                    if(allImportedFiles.any { it.fileName == changedPath.fileName }) {
+                        println("  change detected: $changedPath")
+                        recompile = true
+                    }
                 }
                 event.reset()
-                println("\u001b[H\u001b[2J")      // clear the screen
-            } catch (x: Exception) {
-                throw x
             }
+
+            println("\u001b[H\u001b[2J")      // clear the screen
         }
 
     } else {

compiler/src/prog8/ast/AstToplevel.kt

@@ -216,6 +216,14 @@ interface INameScope {
             null
     }
 
+    fun previousSibling(stmt: Statement): Statement? {
+        val previousIdx = statements.indexOfFirst { it===stmt } - 1
+        return if(previousIdx>=0)
+            statements[previousIdx]
+        else
+            null
+    }
+
     fun indexOfChild(stmt: Statement): Int {
         val idx = statements.indexOfFirst { it===stmt }
         if(idx>=0)

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

@@ -30,8 +30,8 @@ enum class DataType {
                 UWORD -> targetType in setOf(UWORD, FLOAT)
                 WORD -> targetType in setOf(WORD, FLOAT)
                 FLOAT -> targetType == FLOAT
-                STR -> targetType == STR || targetType == UWORD
-                in ArrayDatatypes -> targetType == this || targetType == UWORD
+                STR -> targetType == STR
+                in ArrayDatatypes -> targetType == this
                 else -> false
             }
 
@@ -80,7 +80,9 @@ enum class RegisterOrPair {
     Y,
     AX,
     AY,
-    XY;
+    XY,
+    FAC1,
+    FAC2;
 
     companion object {
         val names by lazy { values().map { it.toString()} }

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

@@ -17,7 +17,7 @@ import kotlin.math.abs
 
 val associativeOperators = setOf("+", "*", "&", "|", "^", "or", "and", "xor", "==", "!=")
 val comparisonOperators = setOf("==", "!=", "<", ">", "<=", ">=")
-val augmentAssignmentOperators = setOf("+", "-", "/", "*", "**", "&", "|", "^", "<<", ">>")
+val augmentAssignmentOperators = setOf("+", "-", "/", "*", "**", "&", "|", "^", "<<", ">>", "%", "and", "or", "xor")
 
 sealed class Expression: Node {
     abstract fun constValue(program: Program): NumericLiteralValue?

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

@@ -288,6 +288,7 @@ internal class AstChecker(private val program: Program,
                             regCounts[CpuRegister.X]=regCounts.getValue(CpuRegister.X)+1
                             regCounts[CpuRegister.Y]=regCounts.getValue(CpuRegister.Y)+1
                         }
+                        RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> { /* no sensible way to count this */ }
                         null ->
                             if(p.statusflag!=null)
                                 statusflagCounts[p.statusflag] = statusflagCounts.getValue(p.statusflag) + 1
@@ -383,7 +384,7 @@ internal class AstChecker(private val program: Program,
         if(valueDt.isKnown && !(valueDt isAssignableTo targetDt)) {
             if(targetDt.typeOrElse(DataType.STRUCT) in IterableDatatypes)
                 errors.err("cannot assign value to string or array", assignment.value.position)
-            else
+            else if(!(valueDt.istype(DataType.STR) && targetDt.istype(DataType.UWORD)))
                 errors.err("value's type doesn't match target", assignment.value.position)
         }
 
@@ -454,15 +455,12 @@ internal class AstChecker(private val program: Program,
 
     override fun visit(addressOf: AddressOf) {
         val variable=addressOf.identifier.targetVarDecl(program.namespace)
-        if(variable==null)
-            errors.err("pointer-of operand must be the name of a heap variable", addressOf.position)
-        else {
-            if(variable.datatype !in ArrayDatatypes
-                    && variable.type!=VarDeclType.MEMORY
-                    && variable.struct == null
-                    && variable.datatype != DataType.STR && variable.datatype!=DataType.STRUCT)
+        if(variable!=null
+            && variable.datatype !in ArrayDatatypes
+            && variable.type!=VarDeclType.MEMORY
+            && variable.struct == null
+            && variable.datatype != DataType.STR && variable.datatype!=DataType.STRUCT)
                 errors.err("invalid pointer-of operand type", addressOf.position)
-        }
         super.visit(addressOf)
     }
 
@@ -603,23 +601,28 @@ internal class AstChecker(private val program: Program,
             }
         }
 
-        // array length limits
+        // array length limits and constant lenghts
         if(decl.isArray) {
-            val length = decl.arraysize!!.constIndex() ?: 1
-            when (decl.datatype) {
-                DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B -> {
-                    if(length==0 || length>256)
-                        err("string and byte array length must be 1-256")
+            val length = decl.arraysize!!.constIndex()
+            if(length==null)
+                err("array length must be a constant")
+            else {
+                when (decl.datatype) {
+                    DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                        if (length == 0 || length > 256)
+                            err("string and byte array length must be 1-256")
+                    }
+                    DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                        if (length == 0 || length > 128)
+                            err("word array length must be 1-128")
+                    }
+                    DataType.ARRAY_F -> {
+                        if (length == 0 || length > 51)
+                            err("float array length must be 1-51")
+                    }
+                    else -> {
+                    }
                 }
-                DataType.ARRAY_UW, DataType.ARRAY_W -> {
-                    if(length==0 || length>128)
-                        err("word array length must be 1-128")
-                }
-                DataType.ARRAY_F -> {
-                    if(length==0 || length>51)
-                        err("float array length must be 1-51")
-                }
-                else -> {}
             }
         }
 

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

@@ -96,36 +96,30 @@ internal class StatementReorderer(val program: Program, val errors: ErrorReporte
         val subroutine = expr.definingSubroutine()!!
         val statement = expr.containingStatement()
         val indexerVarPrefix = "prog8_autovar_index_"
-        val indexerVarName: String
         val repo = subroutine.asmGenInfo.usedAutoArrayIndexerForStatements
 
-        val freeVar = repo.filter { statement !in it.value }.map { it.key }.firstOrNull()
-        if(freeVar==null) {
+        // TODO make this even smarter so that an indexerVar can be reused for a different following statement...  requires updating the partOfStatement?
+        var indexerVar = repo.firstOrNull { it.replaces isSameAs expr.indexer }
+        if(indexerVar==null) {
             // add another loop index var to be used for this expression
-            val statementId = expr.hashCode()
-            indexerVarName = "$indexerVarPrefix$statementId"
+            val indexerVarName = "$indexerVarPrefix${expr.indexer.hashCode()}"
+            indexerVar = AsmGenInfo.ArrayIndexerInfo(indexerVarName, expr.indexer, statement)
+            repo.add(indexerVar)
             // create the indexer var at block level scope
             val vardecl = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.PREFER_ZEROPAGE,
                     null, indexerVarName, null, null, isArray = false, autogeneratedDontRemove = true, position = expr.position)
             modifications.add(IAstModification.InsertFirst(vardecl, subroutine))
-            var statements = repo[indexerVarName]
-            if(statements==null) {
-                statements = mutableSetOf()
-                repo[indexerVarName] = statements
-            }
-            statements.add(statement)
-        } else {
-            // reuse an already created indexer autovar
-            repo.getValue(freeVar).add(statement)
-            indexerVarName = freeVar
         }
+        indexerVar.used++       // keep track of how many times it it used, to avoid assigning it multiple times
 
-        // assign the indexing expression to the helper variable, and replace the indexer with just the variable
+        // replace the indexer with just the variable
+        // assign the indexing expression to the helper variable, but only if that hasn't been done already
         val indexerExpression = expr.indexer.origExpression!!
-        val target = AssignTarget(IdentifierReference(listOf(indexerVarName), indexerExpression.position), null, null, indexerExpression.position)
-        val assign = Assignment(target, indexerExpression, indexerExpression.position)
-        val beforeWhat = expr.containingStatement()
-        modifications.add(IAstModification.InsertBefore(beforeWhat, assign, beforeWhat.definingScope()))
+        val target = AssignTarget(IdentifierReference(listOf(indexerVar.name), indexerExpression.position), null, null, indexerExpression.position)
+        if(indexerVar.used==1) {
+            val assign = Assignment(target, indexerExpression, indexerExpression.position)
+            modifications.add(IAstModification.InsertBefore(statement, assign, statement.definingScope()))
+        }
         modifications.add(IAstModification.SetExpression( {
             expr.indexer.indexVar = it as IdentifierReference
             expr.indexer.indexNum = null

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

@@ -41,8 +41,9 @@ class VerifyFunctionArgTypes(val program: Program) : IAstVisitor {
 
         fun checkTypes(call: IFunctionCall, scope: INameScope, program: Program): String? {
             val argITypes = call.args.map { it.inferType(program) }
-            if(argITypes.any { !it.isKnown })
-                throw FatalAstException("unknown dt")
+            val firstUnknownDt = argITypes.indexOfFirst { it.isUnknown }
+            if(firstUnknownDt>=0)
+                return "argument ${firstUnknownDt+1} invalid argument type"
             val argtypes = argITypes.map { it.typeOrElse(DataType.STRUCT) }
             val target = call.target.targetStatement(scope)
             if (target is Subroutine) {

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

@@ -200,7 +200,7 @@ open class VarDecl(val type: VarDeclType,
         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.UWORD, DataType.STR -> 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")
@@ -313,6 +313,7 @@ class ArrayIndex(var origExpression: Expression?,            // will be replaced
                     }
                     is IdentifierReference -> {
                         indexVar = replacement
+                        indexNum = null
                     }
                     else -> {
                         throw FatalAstException("invalid replace")
@@ -347,7 +348,12 @@ class ArrayIndex(var origExpression: Expression?,            // will be replaced
 
     fun constIndex() = indexNum?.number?.toInt()
 
-    infix fun isSameAs(other: ArrayIndex) = indexNum==other.indexNum && indexVar == other.indexVar
+    infix fun isSameAs(other: ArrayIndex): Boolean {
+        return if(indexNum!=null || indexVar!=null)
+            indexNum==other.indexNum && indexVar == other.indexVar
+        else
+            other.origExpression!=null && origExpression!! isSameAs other.origExpression!!
+    }
 }
 
 open class Assignment(var target: AssignTarget, var value: Expression, override val position: Position) : Statement() {
@@ -679,16 +685,20 @@ class NopStatement(override val position: Position): Statement() {
     override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
+
 class AsmGenInfo {
     // This class contains various attributes that influence the assembly code generator.
     // Conceptually it should be part of any INameScope.
     // But because the resulting code only creates "real" scopes on a subroutine level,
     // it's more consistent to only define these attributes on a Subroutine node.
-    var usedAutoArrayIndexerForStatements = mutableMapOf<String, MutableSet<Statement>>()
+    var usedAutoArrayIndexerForStatements = mutableListOf<ArrayIndexerInfo>()
     var usedRegsaveA = false
     var usedRegsaveX = false
     var usedRegsaveY = false
-    var usedFloatEvalResultVar = false
+    var usedFloatEvalResultVar1 = false
+    var usedFloatEvalResultVar2 = false
+
+    class ArrayIndexerInfo(val name: String, val replaces: ArrayIndex, val partOfStatement: Statement, var used: Int=0)
 }
 
 // the subroutine class covers both the normal user-defined subroutines,
@@ -747,6 +757,8 @@ class Subroutine(override val name: String,
 
     fun regXasResult() = asmReturnvaluesRegisters.any { it.registerOrPair in setOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
     fun regXasParam() = asmParameterRegisters.any { it.registerOrPair in setOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
+    fun shouldPreserveStatusRegisterAfterCall() = asmReturnvaluesRegisters.any { it.statusflag != null } || shouldSaveX()
+    fun shouldSaveX() = CpuRegister.X in asmClobbers || regXasResult() || regXasParam()
 
     fun amountOfRtsInAsm(): Int = statements
             .asSequence()

compiler/src/prog8/compiler/BeforeAsmGenerationAstChanger.kt

@@ -170,6 +170,12 @@ internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: E
                             AddressOf(typecast.expression as IdentifierReference, typecast.position),
                             parent
                     ))
+                } else if(typecast.expression is IFunctionCall) {
+                    return listOf(IAstModification.ReplaceNode(
+                            typecast,
+                            typecast.expression,
+                            parent
+                    ))
                 }
             } else {
                 errors.err("cannot cast pass-by-reference value to type ${typecast.type} (only to UWORD)", typecast.position)

compiler/src/prog8/compiler/target/IAssemblyGenerator.kt

@@ -7,6 +7,8 @@ internal interface IAssemblyGenerator {
 }
 
 internal const val generatedLabelPrefix = "_prog8_label_"
+internal const val subroutineFloatEvalResultVar1 = "_prog8_float_eval_result1"
+internal const val subroutineFloatEvalResultVar2 = "_prog8_float_eval_result2"
 
 internal interface IAssemblyProgram {
     val name: String

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

@@ -8,17 +8,15 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.compiler.*
+import prog8.compiler.target.*
 import prog8.compiler.target.CompilationTarget
 import prog8.compiler.target.CpuType
 import prog8.compiler.target.IAssemblyGenerator
 import prog8.compiler.target.IAssemblyProgram
 import prog8.compiler.target.c64.AssemblyProgram
 import prog8.compiler.target.c64.Petscii
-import prog8.compiler.target.c64.codegen.assignment.AsmAssignSource
-import prog8.compiler.target.c64.codegen.assignment.AsmAssignTarget
 import prog8.compiler.target.c64.codegen.assignment.AsmAssignment
 import prog8.compiler.target.c64.codegen.assignment.AssignmentAsmGen
-import prog8.compiler.target.c64.codegen.assignment.TargetStorageKind
 import prog8.compiler.target.generatedLabelPrefix
 import prog8.functions.BuiltinFunctions
 import prog8.functions.FSignature
@@ -38,7 +36,7 @@ internal class AsmGen(private val program: Program,
 
     // for expressions and augmented assignments:
     val optimizedByteMultiplications = setOf(3,5,6,7,9,10,11,12,13,14,15,20,25,40,50,80,100)
-    val optimizedWordMultiplications = setOf(3,5,6,7,9,10,12,15,20,25,40,50,80,100)
+    val optimizedWordMultiplications = setOf(3,5,6,7,9,10,12,15,20,25,40,50,80,100,320)
 
     private val assemblyLines = mutableListOf<String>()
     private val globalFloatConsts = mutableMapOf<Double, String>()     // all float values in the entire program (value -> varname)
@@ -201,11 +199,7 @@ internal class AsmGen(private val program: Program,
 
     private fun assignInitialValueToVar(decl: VarDecl, variableName: List<String>) {
         val asmName = asmVariableName(variableName)
-        val asgn = AsmAssignment(
-                AsmAssignSource.fromAstSource(decl.value!!, program, this),
-                AsmAssignTarget(TargetStorageKind.VARIABLE, program, this, decl.datatype, decl.definingSubroutine(), variableAsmName = asmName),
-                false, decl.position)
-        assignmentAsmGen.translateNormalAssignment(asgn)
+        assignmentAsmGen.assignExpressionToVariable(decl.value!!, asmName, decl.datatype, decl.definingSubroutine())
     }
 
     private var generatedLabelSequenceNumber: Int = 0
@@ -752,6 +746,16 @@ internal class AsmGen(private val program: Program,
     internal fun translateNormalAssignment(assign: AsmAssignment) =
             assignmentAsmGen.translateNormalAssignment(assign)
 
+    internal fun assignExpressionToRegister(expr: Expression, register: RegisterOrPair) =
+            assignmentAsmGen.assignExpressionToRegister(expr, register)
+
+    internal fun assignExpressionToVariable(expr: Expression, asmVarName: String, dt: DataType, scope: Subroutine?) =
+            assignmentAsmGen.assignExpressionToVariable(expr, asmVarName, dt, scope)
+
+    internal fun assignVariableToRegister(asmVarName: String, register: RegisterOrPair) =
+            assignmentAsmGen.assignVariableToRegister(asmVarName, register)
+
+
     private fun translateSubroutine(sub: Subroutine) {
         out("")
         outputSourceLine(sub)
@@ -796,8 +800,10 @@ internal class AsmGen(private val program: Program,
                 out("_prog8_regsaveX     .byte  0")
             if(sub.asmGenInfo.usedRegsaveY)
                 out("_prog8_regsaveY     .byte  0")
-            if(sub.asmGenInfo.usedFloatEvalResultVar)
-                out("_prog8_float_eval_result    .byte 0,0,0,0,0")
+            if(sub.asmGenInfo.usedFloatEvalResultVar1)
+                out("$subroutineFloatEvalResultVar1    .byte 0,0,0,0,0")
+            if(sub.asmGenInfo.usedFloatEvalResultVar2)
+                out("$subroutineFloatEvalResultVar2    .byte 0,0,0,0,0")
             vardecls2asm(sub.statements)
             out("  .pend\n")
         }
@@ -808,12 +814,12 @@ internal class AsmGen(private val program: Program,
                 when (condition) {
                     BranchCondition.CS -> "bcc"
                     BranchCondition.CC -> "bcs"
-                    BranchCondition.EQ, BranchCondition.Z -> "beq"
-                    BranchCondition.NE, BranchCondition.NZ -> "bne"
+                    BranchCondition.EQ, BranchCondition.Z -> "bne"
+                    BranchCondition.NE, BranchCondition.NZ -> "beq"
                     BranchCondition.VS -> "bvc"
                     BranchCondition.VC -> "bvs"
-                    BranchCondition.MI, BranchCondition.NEG -> "bmi"
-                    BranchCondition.PL, BranchCondition.POS -> "bpl"
+                    BranchCondition.MI, BranchCondition.NEG -> "bpl"
+                    BranchCondition.PL, BranchCondition.POS -> "bmi"
                 }
             } else {
                 when (condition) {
@@ -902,17 +908,16 @@ internal class AsmGen(private val program: Program,
                 }
             }
             else -> {
-                translateExpression(stmt.iterations!!)      // todo directly into AY?
                 val dt = stmt.iterations!!.inferType(program)
                 if(!dt.isKnown)
                     throw AssemblyError("unknown dt")
                 when (dt.typeOrElse(DataType.STRUCT)) {
                     in ByteDatatypes -> {
-                        out("  inx |  lda  P8ESTACK_LO,x")
+                        assignExpressionToRegister(stmt.iterations!!, RegisterOrPair.A)
                         repeatByteCountInA(null, repeatLabel, endLabel, stmt.body)
                     }
                     in WordDatatypes -> {
-                        out("  inx |  lda  P8ESTACK_LO,x |  ldy  P8ESTACK_HI,x")
+                        assignExpressionToRegister(stmt.iterations!!, RegisterOrPair.AY)
                         repeatWordCountInAY(null, repeatLabel, endLabel, stmt.body)
                     }
                     else -> throw AssemblyError("invalid loop expression datatype $dt")
@@ -1008,16 +1013,16 @@ $counterVar    .byte  0""")
     }
 
     private fun translate(stmt: WhenStatement) {
-        expressionsAsmGen.translateExpression(stmt.condition)       // TODO directly into AY?
         val endLabel = makeLabel("choice_end")
         val choiceBlocks = mutableListOf<Pair<String, AnonymousScope>>()
         val conditionDt = stmt.condition.inferType(program)
         if(!conditionDt.isKnown)
             throw AssemblyError("unknown condition dt")
         if(conditionDt.typeOrElse(DataType.BYTE) in ByteDatatypes)
-            out("  inx |  lda  P8ESTACK_LO,x")
+            assignExpressionToRegister(stmt.condition, RegisterOrPair.A)
         else
-            out("  inx |  lda  P8ESTACK_LO,x |  ldy  P8ESTACK_HI,x")
+            assignExpressionToRegister(stmt.condition, RegisterOrPair.AY)
+
         for(choice in stmt.choices) {
             val choiceLabel = makeLabel("choice")
             if(choice.values==null) {
@@ -1066,26 +1071,48 @@ $counterVar    .byte  0""")
 
         val jump = stmt.truepart.statements.first() as? Jump
         if(jump!=null) {
-            // branch with only a jump
+            // branch with only a jump (goto)
             val instruction = branchInstruction(stmt.condition, false)
             out("  $instruction  ${getJumpTarget(jump)}")
             translate(stmt.elsepart)
         } else {
+            val truePartIsJustBreak = stmt.truepart.statements.firstOrNull() is Break
+            val elsePartIsJustBreak = stmt.elsepart.statements.firstOrNull() is Break
             if(stmt.elsepart.containsNoCodeNorVars()) {
+                if(truePartIsJustBreak) {
+                    // branch with just a break (jump out of loop)
+                    val instruction = branchInstruction(stmt.condition, false)
+                    val loopEndLabel = loopEndLabels.peek()
+                    out("  $instruction  $loopEndLabel")
+                } else {
+                    val instruction = branchInstruction(stmt.condition, true)
+                    val elseLabel = makeLabel("branch_else")
+                    out("  $instruction  $elseLabel")
+                    translate(stmt.truepart)
+                    out(elseLabel)
+                }
+            }
+            else if(truePartIsJustBreak) {
+                // branch with just a break (jump out of loop)
+                val instruction = branchInstruction(stmt.condition, false)
+                val loopEndLabel = loopEndLabels.peek()
+                out("  $instruction  $loopEndLabel")
+                translate(stmt.elsepart)
+            } else if(elsePartIsJustBreak) {
+                // branch with just a break (jump out of loop) but true/false inverted
+                val instruction = branchInstruction(stmt.condition, true)
+                val loopEndLabel = loopEndLabels.peek()
+                out("  $instruction  $loopEndLabel")
+                translate(stmt.truepart)
+            } else {
                 val instruction = branchInstruction(stmt.condition, true)
                 val elseLabel = makeLabel("branch_else")
+                val endLabel = makeLabel("branch_end")
                 out("  $instruction  $elseLabel")
                 translate(stmt.truepart)
-                out(elseLabel)
-            } else {
-                val instruction = branchInstruction(stmt.condition, false)
-                val trueLabel = makeLabel("branch_true")
-                val endLabel = makeLabel("branch_end")
-                out("  $instruction  $trueLabel")
-                translate(stmt.elsepart)
                 out("  jmp  $endLabel")
-                out(trueLabel)
-                translate(stmt.truepart)
+                out(elseLabel)
+                translate(stmt.elsepart)
                 out(endLabel)
             }
         }
@@ -1131,7 +1158,9 @@ $counterVar    .byte  0""")
             "%breakpoint" -> {
                 val label = "_prog8_breakpoint_${breakpointLabels.size+1}"
                 breakpointLabels.add(label)
-                out("$label\tnop")
+                out("""
+                    nop
+$label              nop""")
             }
         }
     }
@@ -1161,37 +1190,21 @@ $counterVar    .byte  0""")
             val sub = ret.definingSubroutine()!!
             val returnType = sub.returntypes.single()
             val returnReg = sub.asmReturnvaluesRegisters.single()
-            val returnValueTarget =
-                    when {
-                        returnReg.registerOrPair!=null -> AsmAssignTarget.fromRegisters(returnReg.registerOrPair, sub, program, this)
-                        else -> throw AssemblyError("normal subroutines can't return value in status register directly")
-                    }
+            if(returnReg.registerOrPair==null)
+                throw AssemblyError("normal subroutines can't return value in status register directly")
 
             when (returnType) {
                 in IntegerDatatypes -> {
-                    val src = AsmAssignSource.fromAstSource(returnvalue, program, this)
-                    assignmentAsmGen.translateNormalAssignment(AsmAssignment(src, returnValueTarget, false, ret.position))
+                    assignmentAsmGen.assignExpressionToRegister(returnvalue, returnReg.registerOrPair)
                 }
                 DataType.FLOAT -> {
                     // return the float value via FAC1
-                    when (returnvalue) {
-                        is NumericLiteralValue -> throw AssemblyError("float literal should have been changed to auto var")
-                        is IdentifierReference -> {
-                            val asmVar = asmVariableName(returnvalue)
-                            out("  lda  #<${asmVar} |  ldy  #>${asmVar} |  jsr  floats.MOVFM")
-                        }
-                        else -> {
-                            // todo evaluate directly into fac1 instead of via stack intermediate
-                            translateExpression(returnvalue)
-                            out("  jsr  floats.pop_float_fac1")
-                        }
-                    }
+                    assignExpressionToRegister(returnvalue, RegisterOrPair.FAC1)
                 }
                 else -> {
                     // all else take its address and assign that also to AY register pair
                     val addrofValue = AddressOf(returnvalue as IdentifierReference, returnvalue.position)
-                    val src = AsmAssignSource.fromAstSource(addrofValue, program, this)
-                    assignmentAsmGen.translateNormalAssignment(AsmAssignment(src, returnValueTarget, false, ret.position))
+                    assignmentAsmGen.assignExpressionToRegister(addrofValue, returnReg.registerOrPair)
                 }
             }
         }
@@ -1203,33 +1216,41 @@ $counterVar    .byte  0""")
         assemblyLines.add(assembly)
     }
 
+    internal fun signExtendAYlsb(valueDt: DataType) {
+        // sign extend signed byte in A to full word in AY
+        when(valueDt) {
+            DataType.UBYTE -> out("  ldy  #0")
+            DataType.BYTE -> out("  jsr  prog8_lib.sign_extend_AY_byte")
+            else -> throw AssemblyError("need byte type")
+        }
+    }
+
     internal fun signExtendStackLsb(valueDt: DataType) {
-        // sign extend signed byte on stack to signed word
+        // sign extend signed byte on stack to signed word on stack
         when(valueDt) {
             DataType.UBYTE -> {
-                out("  lda  #0 |  sta  P8ESTACK_HI+1,x")
-            }
-            DataType.BYTE -> {
-                out("""
-                    lda  P8ESTACK_LO+1,x
-                    ora  #$7f
-                    bmi  +
-                    lda  #0
-+                   sta  P8ESTACK_HI+1,x""")
+                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    out("  stz  P8ESTACK_HI+1,x")
+                else
+                    out("  lda  #0 |  sta  P8ESTACK_HI+1,x")
             }
+            DataType.BYTE -> out("  jsr  prog8_lib.sign_extend_stack_byte")
             else -> throw AssemblyError("need byte type")
         }
     }
 
     internal fun signExtendVariableLsb(asmvar: String, valueDt: DataType) {
-        // sign extend signed byte in a word variable
+        // sign extend signed byte in a var to a full word in that variable
         when(valueDt) {
             DataType.UBYTE -> {
-                out("  lda  #0 |  sta  $asmvar+1")
+                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    out("  stz  $asmvar+1")
+                else
+                    out("  lda  #0 |  sta  $asmvar+1")
             }
             DataType.BYTE -> {
                 out("""
-                    lda  $asmvar+1
+                    lda  $asmvar
                     ora  #$7f
                     bmi  +
                     lda  #0

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

@@ -75,11 +75,11 @@ private fun getLinesBy(lines: MutableList<String>, windowSize: Int) =
 
 private fun optimizeCmpSequence(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
     // the when statement (on bytes) generates a sequence of:
-    //	 lda $ce01,x
-    //	 cmp #$20
+    //	 lda  $ce01,x
+    //	 cmp  #$20
     //	 beq  check_prog8_s72choice_32
-    //	 lda $ce01,x
-    //	 cmp #$21
+    //	 lda  $ce01,x
+    //	 cmp  #$21
     //	 beq  check_prog8_s73choice_33
     // the repeated lda can be removed
     val mods = mutableListOf<Modification>()
@@ -179,8 +179,8 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
 }
 
 private fun optimizeStoreLoadSame(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
-    // TODO not sure if this is correct in all situations....:
     // sta X + lda X,  sty X + ldy X,   stx X + ldx X  -> the second instruction can be eliminated
+    // TODO this is not true if X is not a regular RAM memory address (but instead mapped I/O or ROM)
     val mods = mutableListOf<Modification>()
     for (pair in linesByFour) {
         val first = pair[0].value.trimStart()

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

@@ -17,6 +17,7 @@ import prog8.compiler.target.c64.codegen.assignment.AsmAssignTarget
 import prog8.compiler.target.c64.codegen.assignment.AsmAssignment
 import prog8.compiler.target.c64.codegen.assignment.SourceStorageKind
 import prog8.compiler.target.c64.codegen.assignment.TargetStorageKind
+import prog8.compiler.target.subroutineFloatEvalResultVar2
 import prog8.compiler.toHex
 import prog8.functions.FSignature
 
@@ -101,18 +102,9 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             when(func.name) {
                 "memset" -> {
                     // use the ROM function of the Cx16
-                    var src = AsmAssignSource.fromAstSource(fcall.args[0], program, asmgen)
-                    var tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "cx16.r0")
-                    var assign = AsmAssignment(src, tgt, false, Position.DUMMY)
-                    asmgen.translateNormalAssignment(assign)
-                    src = AsmAssignSource.fromAstSource(fcall.args[1], program, asmgen)
-                    tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "cx16.r1")
-                    assign = AsmAssignment(src, tgt, false, Position.DUMMY)
-                    asmgen.translateNormalAssignment(assign)
-                    src = AsmAssignSource.fromAstSource(fcall.args[2], program, asmgen)
-                    tgt = AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.UBYTE, null, register = RegisterOrPair.A)
-                    assign = AsmAssignment(src, tgt, false, Position.DUMMY)
-                    asmgen.translateNormalAssignment(assign)
+                    asmgen.assignExpressionToVariable(fcall.args[0], "cx16.r0", DataType.UWORD, scope)
+                    asmgen.assignExpressionToVariable(fcall.args[1], "cx16.r1", DataType.UWORD, scope)
+                    asmgen.assignExpressionToRegister(fcall.args[2], RegisterOrPair.A)
                     val sub = (fcall as FunctionCallStatement).definingSubroutine()!!
                     asmgen.saveRegister(CpuRegister.X, false, sub)
                     asmgen.out("  jsr  cx16.memory_fill")
@@ -129,18 +121,9 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     }
 
                     // use the ROM function of the Cx16
-                    var src = AsmAssignSource.fromAstSource(fcall.args[0], program, asmgen)
-                    var tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "cx16.r0")
-                    var assign = AsmAssignment(src, tgt, false, Position.DUMMY)
-                    asmgen.translateNormalAssignment(assign)
-                    src = AsmAssignSource.fromAstSource(fcall.args[1], program, asmgen)
-                    tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "cx16.r1")
-                    assign = AsmAssignment(src, tgt, false, Position.DUMMY)
-                    asmgen.translateNormalAssignment(assign)
-                    src = AsmAssignSource.fromAstSource(fcall.args[2], program, asmgen)
-                    tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "cx16.r2")
-                    assign = AsmAssignment(src, tgt, false, Position.DUMMY)
-                    asmgen.translateNormalAssignment(assign)
+                    asmgen.assignExpressionToVariable(fcall.args[0], "cx16.r0", DataType.UWORD, scope)
+                    asmgen.assignExpressionToVariable(fcall.args[1], "cx16.r1", DataType.UWORD, scope)
+                    asmgen.assignExpressionToVariable(fcall.args[2], "cx16.r2", DataType.UWORD, scope)
                     val sub = (fcall as FunctionCallStatement).definingSubroutine()!!
                     asmgen.saveRegister(CpuRegister.X, false, sub)
                     asmgen.out("  jsr  cx16.memory_copy")
@@ -271,7 +254,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             DataType.UBYTE -> {
                 when (what) {
                     is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "ror2", 'b')
+                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "ror2", 'b')
                         asmgen.out("  jsr  prog8_lib.ror2_array_ub")
                     }
                     is DirectMemoryRead -> {
@@ -279,7 +262,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                             val number = (what.addressExpression as NumericLiteralValue).number
                             asmgen.out("  lda  ${number.toHex()} |  lsr  a |  bcc  + |  ora  #\$80 |+  |  sta  ${number.toHex()}")
                         } else {
-                            translateRolRorMemoryArgs(what.addressExpression, fcall)
+                            asmgen.assignExpressionToRegister(what.addressExpression, RegisterOrPair.AY)
                             asmgen.out("  jsr  prog8_lib.ror2_mem_ub")
                         }
                     }
@@ -293,7 +276,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             DataType.UWORD -> {
                 when (what) {
                     is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "ror2", 'w')
+                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "ror2", 'w')
                         asmgen.out("  jsr  prog8_lib.ror2_array_uw")
                     }
                     is IdentifierReference -> {
@@ -314,7 +297,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             DataType.UBYTE -> {
                 when (what) {
                     is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "ror", 'b')
+                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "ror", 'b')
                         asmgen.out("  jsr  prog8_lib.ror_array_ub")
                     }
                     is DirectMemoryRead -> {
@@ -322,7 +305,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                             val number = (what.addressExpression as NumericLiteralValue).number
                             asmgen.out("  ror  ${number.toHex()}")
                         } else {
-                            translateRolRorMemoryArgs(what.addressExpression, fcall)
+                            asmgen.assignExpressionToRegister(what.addressExpression, RegisterOrPair.AY)
                             asmgen.out("""
                                 sta  (+) + 1
                                 sty  (+) + 2
@@ -339,7 +322,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             DataType.UWORD -> {
                 when (what) {
                     is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "ror", 'w')
+                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "ror", 'w')
                         asmgen.out("  jsr  prog8_lib.ror_array_uw")
                     }
                     is IdentifierReference -> {
@@ -360,7 +343,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             DataType.UBYTE -> {
                 when (what) {
                     is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "rol2", 'b')
+                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "rol2", 'b')
                         asmgen.out("  jsr  prog8_lib.rol2_array_ub")
                     }
                     is DirectMemoryRead -> {
@@ -368,7 +351,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                             val number = (what.addressExpression as NumericLiteralValue).number
                             asmgen.out("  lda  ${number.toHex()} |  cmp  #\$80 |  rol  a |  sta  ${number.toHex()}")
                         } else {
-                            translateRolRorMemoryArgs(what.addressExpression, fcall)
+                            asmgen.assignExpressionToRegister(what.addressExpression, RegisterOrPair.AY)
                             asmgen.out("  jsr  prog8_lib.rol2_mem_ub")
                         }
                     }
@@ -382,7 +365,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             DataType.UWORD -> {
                 when (what) {
                     is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "rol2", 'w')
+                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "rol2", 'w')
                         asmgen.out("  jsr  prog8_lib.rol2_array_uw")
                     }
                     is IdentifierReference -> {
@@ -403,7 +386,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             DataType.UBYTE -> {
                 when (what) {
                     is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "rol", 'b')
+                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "rol", 'b')
                         asmgen.out("  jsr  prog8_lib.rol_array_ub")
                     }
                     is DirectMemoryRead -> {
@@ -411,7 +394,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                             val number = (what.addressExpression as NumericLiteralValue).number
                             asmgen.out("  rol  ${number.toHex()}")
                         } else {
-                            translateRolRorMemoryArgs(what.addressExpression, fcall)
+                            asmgen.assignExpressionToRegister(what.addressExpression, RegisterOrPair.AY)
                             asmgen.out("""
                                 sta  (+) + 1
                                 sty  (+) + 2
@@ -428,7 +411,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             DataType.UWORD -> {
                 when (what) {
                     is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "rol", 'w')
+                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "rol", 'w')
                         asmgen.out("  jsr  prog8_lib.rol_array_uw")
                     }
                     is IdentifierReference -> {
@@ -442,22 +425,10 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
         }
     }
 
-    private fun translateRolRorMemoryArgs(addressExpression: Expression, fcall: IFunctionCall) {
-        val src = AsmAssignSource.fromAstSource(addressExpression, program, asmgen)
-        val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.AY, null, program, asmgen)
-        val assign = AsmAssignment(src, tgt, false, (fcall as Node).position)
-        asmgen.translateNormalAssignment(assign)
-    }
-
-    private fun translateRolRorArrayArgs(arrayvar: IdentifierReference, indexer: ArrayIndex, fcall: IFunctionCall, operation: String, dt: Char) {
-        var src = AsmAssignSource.fromAstSource(AddressOf(arrayvar, (fcall as Node).position), program, asmgen)
-        var tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "prog8_lib.${operation}_array_u${dt}._arg_target")
-        var assign = AsmAssignment(src, tgt, false, (fcall as Node).position)
-        asmgen.translateNormalAssignment(assign)
-        src = AsmAssignSource.fromAstSource(indexer, program, asmgen)
-        tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UBYTE, null, variableAsmName = "prog8_lib.${operation}_array_u${dt}._arg_index")
-        assign = AsmAssignment(src, tgt, false, (fcall as Node).position)
-        asmgen.translateNormalAssignment(assign)
+    private fun translateRolRorArrayArgs(arrayvar: IdentifierReference, indexer: ArrayIndex, operation: String, dt: Char) {
+        asmgen.assignExpressionToVariable(AddressOf(arrayvar, arrayvar.position), "prog8_lib.${operation}_array_u${dt}._arg_target", DataType.UWORD, null)
+        val indexerExpr = if(indexer.indexVar!=null) indexer.indexVar!! else indexer.indexNum!!
+        asmgen.assignExpressionToVariable(indexerExpr, "prog8_lib.${operation}_array_u${dt}._arg_index", DataType.UBYTE, null)
     }
 
     private fun funcVariousFloatFuncs(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine) {
@@ -671,7 +642,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             }
         }
 
-        // all other types of swap() calls are done via the evaluation stack
+        // all other types of swap() calls are done via a temporary variable
+
         fun targetFromExpr(expr: Expression, datatype: DataType): AsmAssignTarget {
             return when (expr) {
                 is IdentifierReference -> AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, datatype, expr.definingSubroutine(), variableAsmName = asmgen.asmVariableName(expr))
@@ -681,25 +653,43 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             }
         }
 
-        // TODO find alternative way to swap here without using estack
-        asmgen.translateExpression(first)
-        asmgen.translateExpression(second)
-        val idatatype = first.inferType(program)
-        if(!idatatype.isKnown)
-            throw AssemblyError("unknown dt")
-        val datatype = idatatype.typeOrElse(DataType.STRUCT)
-        val assignFirst = AsmAssignment(
-                AsmAssignSource(SourceStorageKind.STACK, program, asmgen, datatype),
-                targetFromExpr(first, datatype),
-                false, first.position
-        )
-        val assignSecond = AsmAssignment(
-                AsmAssignSource(SourceStorageKind.STACK, program, asmgen, datatype),
-                targetFromExpr(second, datatype),
-                false, second.position
-        )
-        asmgen.translateNormalAssignment(assignFirst)
-        asmgen.translateNormalAssignment(assignSecond)
+        val datatype = first.inferType(program).typeOrElse(DataType.STRUCT)
+        when(datatype) {
+            in ByteDatatypes, in WordDatatypes -> {
+                asmgen.assignExpressionToVariable(first, "P8ZP_SCRATCH_W1", datatype, null)
+                asmgen.assignExpressionToVariable(second, "P8ZP_SCRATCH_W2", datatype, null)
+                val assignFirst = AsmAssignment(
+                        AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, datatype, variableAsmName = "P8ZP_SCRATCH_W2"),
+                        targetFromExpr(first, datatype),
+                        false, first.position
+                )
+                val assignSecond = AsmAssignment(
+                        AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, datatype, variableAsmName = "P8ZP_SCRATCH_W1"),
+                        targetFromExpr(second, datatype),
+                        false, second.position
+                )
+                asmgen.translateNormalAssignment(assignFirst)
+                asmgen.translateNormalAssignment(assignSecond)
+            }
+            DataType.FLOAT -> {
+                // via evaluation stack
+                asmgen.translateExpression(first)
+                asmgen.translateExpression(second)
+                val assignFirst = AsmAssignment(
+                        AsmAssignSource(SourceStorageKind.STACK, program, asmgen, DataType.FLOAT),
+                        targetFromExpr(first, datatype),
+                        false, first.position
+                )
+                val assignSecond = AsmAssignment(
+                        AsmAssignSource(SourceStorageKind.STACK, program, asmgen, DataType.FLOAT),
+                        targetFromExpr(second, datatype),
+                        false, second.position
+                )
+                asmgen.translateNormalAssignment(assignFirst)
+                asmgen.translateNormalAssignment(assignSecond)
+            }
+            else -> throw AssemblyError("weird swap dt")
+        }
     }
 
     private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexValue1: NumericLiteralValue, arrayVarName2: String, indexValue2: NumericLiteralValue) {
@@ -971,14 +961,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
     }
 
     private fun funcMkword(fcall: IFunctionCall, resultToStack: Boolean) {
-        var src = AsmAssignSource.fromAstSource(fcall.args[0], program, asmgen)  // msb
-        var tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.Y, null, program, asmgen)
-        var assign = AsmAssignment(src, tgt, false, (fcall as Node).position)
-        asmgen.translateNormalAssignment(assign)
-        src = AsmAssignSource.fromAstSource(fcall.args[1], program, asmgen)  // lsb
-        tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.A, null, program, asmgen)
-        assign = AsmAssignment(src, tgt, false, (fcall as Node).position)
-        asmgen.translateNormalAssignment(assign)
+        asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.Y)      // msb
+        asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
         if(resultToStack)
             asmgen.out("  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
     }
@@ -995,10 +979,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             if (resultToStack)
                 asmgen.out("  sta  P8ESTACK_LO,x |  dex")
         } else {
-            val src = AsmAssignSource.fromAstSource(fcall.args.single(), program, asmgen)
-            val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.AY, null, program, asmgen)
-            val assign = AsmAssignment(src, tgt, false, (fcall as Node).position)
-            asmgen.translateNormalAssignment(assign)
+            asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
             if (resultToStack)
                 asmgen.out("  tya |  sta  P8ESTACK_LO,x |  dex")
             else
@@ -1019,10 +1000,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             if (resultToStack)
                 asmgen.out("  sta  P8ESTACK_LO,x |  dex")
         } else {
-            val src = AsmAssignSource.fromAstSource(fcall.args.single(), program, asmgen)
-            val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.AY, null, program, asmgen)
-            val assign = AsmAssignment(src, tgt, false, (fcall as Node).position)
-            asmgen.translateNormalAssignment(assign)
+            asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
             if (resultToStack)
                 asmgen.out("  sta  P8ESTACK_LO,x |  dex")
         }
@@ -1055,14 +1033,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     throw AssemblyError("float literals should have been converted into autovar")
                 }
                 else -> {
-                    scope.asmGenInfo.usedFloatEvalResultVar = true
-                    val variable = IdentifierReference(listOf("_prog8_float_eval_result"), value.position)
-                    variable.linkParents(value)
-                    val assign = AsmAssignment(AsmAssignSource.fromAstSource(value, program, asmgen),
-                            AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.FLOAT, null, variableAsmName = asmgen.asmVariableName(variable)),
-                            false, Position.DUMMY)
-                    asmgen.translateNormalAssignment(assign)
+                    scope.asmGenInfo.usedFloatEvalResultVar2 = true
+                    val variable = IdentifierReference(listOf(subroutineFloatEvalResultVar2), value.position)
                     val addr = AddressOf(variable, value.position)
+                    addr.linkParents(value)
+                    asmgen.assignExpressionToVariable(value, asmgen.asmVariableName(variable), DataType.FLOAT, scope)
                     AsmAssignSource.fromAstSource(addr, program, asmgen)
                 }
             }

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

@@ -1,20 +1,16 @@
 package prog8.compiler.target.c64.codegen
 
 import prog8.ast.Program
+import prog8.ast.base.ArrayElementTypes
 import prog8.ast.base.DataType
+import prog8.ast.base.RegisterOrPair
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.RangeExpr
 import prog8.ast.statements.ForLoop
 import prog8.compiler.AssemblyError
-import prog8.compiler.target.c64.codegen.assignment.AsmAssignSource
-import prog8.compiler.target.c64.codegen.assignment.AsmAssignTarget
-import prog8.compiler.target.c64.codegen.assignment.AsmAssignment
-import prog8.compiler.target.c64.codegen.assignment.TargetStorageKind
 import prog8.compiler.toHex
 import kotlin.math.absoluteValue
 
-// todo reduce use of stack eval translateExpression()
-
 internal class ForLoopsAsmGen(private val program: Program, private val asmgen: AsmGen) {
 
     internal fun translate(stmt: ForLoop) {
@@ -53,23 +49,17 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen:
                     val incdec = if(stepsize==1) "inc" else "dec"
                     // loop over byte range via loopvar
                     val varname = asmgen.asmVariableName(stmt.loopVar)
-                    asmgen.translateExpression(range.to)
-                    asmgen.translateExpression(range.from)
+                    asmgen.assignExpressionToVariable(range.from, varname, ArrayElementTypes.getValue(iterableDt), null)
+                    asmgen.assignExpressionToVariable(range.to, "$modifiedLabel+1", ArrayElementTypes.getValue(iterableDt), null)
+                    asmgen.out(loopLabel)
+                    asmgen.translate(stmt.body)
                     asmgen.out("""
-                inx
-                lda  P8ESTACK_LO,x
-                sta  $varname
-                lda  P8ESTACK_LO+1,x
-                sta  $modifiedLabel+1
-$loopLabel""")
-                        asmgen.translate(stmt.body)
-                        asmgen.out("""
-                lda  $varname
-$modifiedLabel  cmp  #0         ; modified 
-                beq  $endLabel
-                $incdec  $varname
-                jmp  $loopLabel
-$endLabel       inx""")
+                        lda  $varname
+$modifiedLabel          cmp  #0         ; modified 
+                        beq  $endLabel
+                        $incdec  $varname
+                        jmp  $loopLabel
+$endLabel""")
 
                 } else {
 
@@ -77,36 +67,29 @@ $endLabel       inx""")
 
                     // loop over byte range via loopvar
                     val varname = asmgen.asmVariableName(stmt.loopVar)
-                    asmgen.translateExpression(range.to)
-                    asmgen.translateExpression(range.from)
-                    asmgen.out("""
-                inx
-                lda  P8ESTACK_LO,x
-                sta  $varname
-                lda  P8ESTACK_LO+1,x
-                sta  $modifiedLabel+1
-$loopLabel""")
+                    asmgen.assignExpressionToVariable(range.from, varname, ArrayElementTypes.getValue(iterableDt), null)
+                    asmgen.assignExpressionToVariable(range.to, "$modifiedLabel+1", ArrayElementTypes.getValue(iterableDt), null)
+                    asmgen.out(loopLabel)
                     asmgen.translate(stmt.body)
-                    asmgen.out("""
-                lda  $varname""")
                     if(stepsize>0) {
                         asmgen.out("""
-                clc
-                adc  #$stepsize
-                sta  $varname
-$modifiedLabel  cmp  #0    ; modified
-                bcc  $loopLabel
-                beq  $loopLabel""")
+                            lda  $varname
+                            clc
+                            adc  #$stepsize
+                            sta  $varname
+$modifiedLabel              cmp  #0    ; modified
+                            bmi  $loopLabel
+                            beq  $loopLabel""")
                     } else {
                         asmgen.out("""
-                sec
-                sbc  #${stepsize.absoluteValue}
-                sta  $varname
-$modifiedLabel  cmp  #0     ; modified 
-                bcs  $loopLabel""")
+                            lda  $varname
+                            sec
+                            sbc  #${stepsize.absoluteValue}
+                            sta  $varname
+$modifiedLabel              cmp  #0     ; modified
+                            bpl  $loopLabel""")
                     }
-                    asmgen.out("""
-$endLabel       inx""")
+                    asmgen.out(endLabel)
                 }
             }
             DataType.ARRAY_W, DataType.ARRAY_UW -> {
@@ -115,13 +98,11 @@ $endLabel       inx""")
                     // words, step 1 or -1
 
                     stepsize == 1 || stepsize == -1 -> {
-                        asmgen.translateExpression(range.to)
-                        assignLoopvar(stmt, range)
                         val varname = asmgen.asmVariableName(stmt.loopVar)
+                        assignLoopvar(stmt, range)
+                        asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
                         asmgen.out("""
-                            lda  P8ESTACK_HI+1,x
-                            sta  $modifiedLabel+1
-                            lda  P8ESTACK_LO+1,x
+                            sty  $modifiedLabel+1
                             sta  $modifiedLabel2+1
 $loopLabel""")
                         asmgen.translate(stmt.body)
@@ -148,21 +129,17 @@ $modifiedLabel2 cmp  #0    ; modified
                 jmp  $loopLabel""")
                         }
                         asmgen.out(endLabel)
-                        asmgen.out(" inx")
                     }
                     stepsize > 0 -> {
 
                         // (u)words, step >= 2
-                        asmgen.translateExpression(range.to)
-                        asmgen.out("""
-                            lda  P8ESTACK_HI+1,x
-                            sta  $modifiedLabel+1
-                            lda  P8ESTACK_LO+1,x
-                            sta  $modifiedLabel2+1
-                        """)
-                        assignLoopvar(stmt, range)
                         val varname = asmgen.asmVariableName(stmt.loopVar)
-                        asmgen.out(loopLabel)
+                        assignLoopvar(stmt, range)
+                        asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
+                        asmgen.out("""
+                            sty  $modifiedLabel+1
+                            sta  $modifiedLabel2+1
+$loopLabel""")
                         asmgen.translate(stmt.body)
 
                         if (iterableDt == DataType.ARRAY_UW) {
@@ -181,7 +158,7 @@ $modifiedLabel2 lda  #0     ; modified
                 cmp  $varname
                 bcc  $endLabel
                 bcs  $loopLabel
-$endLabel       inx""")
+$endLabel""")
                         } else {
                             asmgen.out("""
                 lda  $varname
@@ -198,22 +175,19 @@ $modifiedLabel  lda  #0   ; modified
                 bvc  +
                 eor  #$80
 +               bpl  $loopLabel                
-$endLabel       inx""")
+$endLabel""")
                         }
                     }
                     else -> {
 
                         // (u)words, step <= -2
-                        asmgen.translateExpression(range.to)
-                        asmgen.out("""
-                            lda  P8ESTACK_HI+1,x
-                            sta  $modifiedLabel+1
-                            lda  P8ESTACK_LO+1,x
-                            sta  $modifiedLabel2+1
-                        """)
-                        assignLoopvar(stmt, range)
                         val varname = asmgen.asmVariableName(stmt.loopVar)
-                        asmgen.out(loopLabel)
+                        assignLoopvar(stmt, range)
+                        asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
+                        asmgen.out("""
+                            sty  $modifiedLabel+1
+                            sta  $modifiedLabel2+1
+$loopLabel""")
                         asmgen.translate(stmt.body)
 
                         if(iterableDt==DataType.ARRAY_UW) {
@@ -231,7 +205,7 @@ $modifiedLabel  cmp  #0    ; modified
                 lda  $varname
 $modifiedLabel2 cmp  #0    ; modified 
                 bcs  $loopLabel
-$endLabel       inx""")
+$endLabel""")
                         } else {
                             asmgen.out("""
                 lda  $varname
@@ -249,7 +223,7 @@ $modifiedLabel  sbc  #0    ; modified
                 bvc  +
                 eor  #$80
 +               bpl  $loopLabel                
-$endLabel       inx""")
+$endLabel""")
                         }
                     }
                 }
@@ -611,10 +585,6 @@ $endLabel""")
         asmgen.loopEndLabels.pop()
     }
 
-    private fun assignLoopvar(stmt: ForLoop, range: RangeExpr) {
-        val target = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, stmt.loopVarDt(program).typeOrElse(DataType.STRUCT), stmt.definingSubroutine(), variableAsmName=asmgen.asmVariableName(stmt.loopVar))
-        val src = AsmAssignSource.fromAstSource(range.from, program, asmgen).adjustSignedUnsigned(target)
-        val assign = AsmAssignment(src, target, false, range.position)
-        asmgen.translateNormalAssignment(assign)
-    }
+    private fun assignLoopvar(stmt: ForLoop, range: RangeExpr) =
+        asmgen.assignExpressionToVariable(range.from, asmgen.asmVariableName(stmt.loopVar), stmt.loopVarDt(program).typeOrElse(DataType.STRUCT), stmt.definingSubroutine())
 }

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

@@ -16,7 +16,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
 
     internal fun translateFunctionCallStatement(stmt: IFunctionCall) {
         val sub = stmt.target.targetSubroutine(program.namespace)!!
-        val preserveStatusRegisterAfterCall = sub.asmReturnvaluesRegisters.any {it.statusflag!=null}
+        val preserveStatusRegisterAfterCall = sub.shouldPreserveStatusRegisterAfterCall()
         translateFunctionCall(stmt, preserveStatusRegisterAfterCall)
         // functioncalls no longer return results on the stack, so simply ignore the results in the registers
         if(preserveStatusRegisterAfterCall)
@@ -28,7 +28,7 @@ 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}")
-        val saveX = CpuRegister.X in sub.asmClobbers || sub.regXasResult() || sub.regXasParam()
+        val saveX = sub.shouldSaveX()
         if(saveX)
             asmgen.saveRegister(CpuRegister.X, preserveStatusRegisterAfterCall, (stmt as Node).definingSubroutine()!!)
 
@@ -165,10 +165,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
             throw AssemblyError("argument type incompatible")
 
         val varName = asmgen.asmVariableName(sub.scopedname+"."+parameter.value.name)
-        val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, parameter.value.type, sub, variableAsmName = varName)
-        val source = AsmAssignSource.fromAstSource(value, program, asmgen).adjustSignedUnsigned(tgt)
-        val asgn = AsmAssignment(source, tgt, false, Position.DUMMY)
-        asmgen.translateNormalAssignment(asgn)
+        asmgen.assignExpressionToVariable(value, varName, parameter.value.type, sub)
     }
 
     private fun argumentViaRegister(sub: Subroutine, parameter: IndexedValue<SubroutineParameter>, value: Expression) {
@@ -213,17 +210,13 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
 """)
                         }
                         else -> {
-                            asmgen.translateExpression(value)   // todo directly into A
+                            asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                             asmgen.out("""
-            inx
-            pha
-            lda  P8ESTACK_LO,x
-            beq  +
-            sec  
-            bcs  ++
-+           clc
-+           pla
-""")
+                                beq  +
+                                sec
+                                bcs  ++
++                               clc
++""")
                         }
                     }
                 }
@@ -231,18 +224,16 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
             }
             else -> {
                 // via register or register pair
-                val target = AsmAssignTarget.fromRegisters(register!!, sub, program, asmgen)
+                register!!
                 if(requiredDt largerThan valueDt) {
                     // we need to sign extend the source, do this via temporary word variable
                     val scratchVar = asmgen.asmVariableName("P8ZP_SCRATCH_W1")
-                    val scratchTarget = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UBYTE, sub, scratchVar)
-                    val source = AsmAssignSource.fromAstSource(value, program, asmgen)
-                    asmgen.translateNormalAssignment(AsmAssignment(source, scratchTarget, false, value.position))
+                    asmgen.assignExpressionToVariable(value, scratchVar, DataType.UBYTE, sub)
                     asmgen.signExtendVariableLsb(scratchVar, valueDt)
-                    val src = AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, DataType.UWORD, scratchVar)
-                    asmgen.translateNormalAssignment(AsmAssignment(src, target, false, Position.DUMMY))
+                    asmgen.assignVariableToRegister(scratchVar, register)
                 }
                 else {
+                    val target = AsmAssignTarget.fromRegisters(register, sub, program, asmgen)
                     val src = if(valueDt in PassByReferenceDatatypes) {
                         if(value is IdentifierReference) {
                             val addr = AddressOf(value, Position.DUMMY)

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

@@ -54,14 +54,8 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                             asmgen.out("+\tdec  ${'$'}ffff\t; modified")
                     }
                     else -> {
-                        asmgen.translateExpression(addressExpr)    // todo directly into AY?
-                        asmgen.out("""
-                            inx
-                            lda  P8ESTACK_LO,x
-                            sta  (+) + 1
-                            lda  P8ESTACK_HI,x
-                            sta  (+) + 2
-                        """)
+                        asmgen.assignExpressionToRegister(addressExpr, RegisterOrPair.AY)
+                        asmgen.out("  sta  (+) + 1 |  sty  (+) + 2")
                         if(incr)
                             asmgen.out("+\tinc  ${'$'}ffff\t; modified")
                         else

compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt

@@ -49,8 +49,8 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
     lateinit var origAssign: AsmAssignment
 
     init {
-        if(register!=null && datatype !in IntegerDatatypes)
-            throw AssemblyError("register must be integer type")
+        if(register!=null && datatype !in NumericDatatypes)
+            throw AssemblyError("register must be integer or float type")
     }
 
     companion object {
@@ -75,6 +75,8 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
                     RegisterOrPair.AX,
                     RegisterOrPair.AY,
                     RegisterOrPair.XY -> AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.UWORD, scope, register = registers)
+                    RegisterOrPair.FAC1,
+                    RegisterOrPair.FAC2 -> AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.FLOAT, scope, register = registers)
                 }
     }
 }

compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt

@@ -68,12 +68,18 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     // constant array index value
                     val indexValue = value.indexer.constIndex()!! * elementDt.memorySize()
                     when (elementDt) {
-                        in ByteDatatypes ->
-                            asmgen.out("  lda  $arrayVarName+$indexValue |  sta  P8ESTACK_LO,x |  dex")
-                        in WordDatatypes ->
-                            asmgen.out("  lda  $arrayVarName+$indexValue |  sta  P8ESTACK_LO,x |  lda  $arrayVarName+$indexValue+1 |  sta  P8ESTACK_HI,x | dex")
-                        DataType.FLOAT ->
-                            asmgen.out("  lda  #<$arrayVarName+$indexValue |  ldy  #>$arrayVarName+$indexValue |  jsr  floats.push_float")
+                        in ByteDatatypes -> {
+                            asmgen.out("  lda  $arrayVarName+$indexValue")
+                            assignRegisterByte(assign.target, CpuRegister.A)
+                        }
+                        in WordDatatypes -> {
+                            asmgen.out("  lda  $arrayVarName+$indexValue |  ldy  $arrayVarName+$indexValue+1")
+                            assignRegisterpairWord(assign.target, RegisterOrPair.AY)
+                        }
+                        DataType.FLOAT -> {
+                            asmgen.out("  lda  #<$arrayVarName+$indexValue |  ldy  #>$arrayVarName+$indexValue")
+                            assignFloatFromAY(assign.target)
+                        }
                         else ->
                             throw AssemblyError("weird array type")
                     }
@@ -81,11 +87,13 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     when (elementDt) {
                         in ByteDatatypes -> {
                             asmgen.loadScaledArrayIndexIntoRegister(value, elementDt, CpuRegister.Y)
-                            asmgen.out("  lda  $arrayVarName,y |  sta  P8ESTACK_LO,x |  dex")
+                            asmgen.out("  lda  $arrayVarName,y")
+                            assignRegisterByte(assign.target, CpuRegister.A)
                         }
                         in WordDatatypes  -> {
                             asmgen.loadScaledArrayIndexIntoRegister(value, elementDt, CpuRegister.Y)
-                            asmgen.out("  lda  $arrayVarName,y |  sta  P8ESTACK_LO,x |  lda  $arrayVarName+1,y |  sta  P8ESTACK_HI,x |  dex")
+                            asmgen.out("  lda  $arrayVarName,y |  pha |  lda  $arrayVarName+1,y |  tay |  pla")
+                            assignRegisterpairWord(assign.target, RegisterOrPair.AY)
                         }
                         DataType.FLOAT -> {
                             asmgen.loadScaledArrayIndexIntoRegister(value, elementDt, CpuRegister.A)
@@ -95,13 +103,13 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                                 adc  #<$arrayVarName
                                 bcc  +
                                 iny
-+                               jsr  floats.push_float""")
++""")
+                            assignFloatFromAY(assign.target)
                         }
                         else ->
                             throw AssemblyError("weird array elt type")
                     }
                 }
-                assignStackValue(assign.target)
             }
             SourceStorageKind.MEMORY -> {
                 val value = assign.source.memory!!
@@ -114,8 +122,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         assignMemoryByte(assign.target, null, value.addressExpression as IdentifierReference)
                     }
                     else -> {
-                        asmgen.translateExpression(value.addressExpression) // TODO directly into AY
-                        asmgen.out("  jsr  prog8_lib.read_byte_from_address_on_stack |  inx")
+                        assignExpressionToVariable(value.addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, assign.target.scope)
+                        asmgen.out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W2),y")
                         assignRegisterByte(assign.target, CpuRegister.A)
                     }
                 }
@@ -130,11 +138,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     is IdentifierReference -> throw AssemblyError("source kind should have been variable")
                     is ArrayIndexedExpression -> throw AssemblyError("source kind should have been array")
                     is DirectMemoryRead -> throw AssemblyError("source kind should have been memory")
-                    is TypecastExpression -> assignTypeCastedValue(assign.target, value.type, value.expression, assign)
+                    is TypecastExpression -> assignTypeCastedValue(assign.target, value.type, value.expression, value)
                     is FunctionCall -> {
                         when (val sub = value.target.targetStatement(program.namespace)) {
                             is Subroutine -> {
-                                val preserveStatusRegisterAfterCall = sub.asmReturnvaluesRegisters.any { it.statusflag != null }
+                                val preserveStatusRegisterAfterCall = sub.shouldPreserveStatusRegisterAfterCall()
                                 asmgen.translateFunctionCall(value, preserveStatusRegisterAfterCall)
                                 val returnValue = sub.returntypes.zip(sub.asmReturnvaluesRegisters).single { it.second.registerOrPair!=null }
                                 when (returnValue.first) {
@@ -200,8 +208,13 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         }
                     }
                     else -> {
-                        // everything else just evaluate via the stack.
-                        // TODO byte and word values not via stack but via A / AY registers?
+                        // Everything else just evaluate via the stack.
+                        // (we can't use the assignment helper functions to do it via registers here,
+                        // because the code here is the implementation of exactly that...)
+                        if(value.parent is Return) {
+                            if (this.asmgen.options.slowCodegenWarnings)
+                                println("warning: slow stack evaluation used for return: $value  target=${assign.target.kind} at ${value.position}")
+                        }
                         asmgen.translateExpression(value)
                         if(assign.target.datatype in WordDatatypes && assign.source.datatype in ByteDatatypes)
                             asmgen.signExtendStackLsb(assign.source.datatype)
@@ -218,11 +231,14 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
-    private fun assignTypeCastedValue(target: AsmAssignTarget, targetDt: DataType, value: Expression, origAssign: AsmAssignment) {
+    private fun assignTypeCastedValue(target: AsmAssignTarget, targetDt: DataType, value: Expression, origTypeCastExpression: TypecastExpression) {
         val valueIDt = value.inferType(program)
         if(!valueIDt.isKnown)
             throw AssemblyError("unknown dt")
         val valueDt = valueIDt.typeOrElse(DataType.STRUCT)
+        if(valueDt==targetDt)
+            throw AssemblyError("type cast to identical dt should have been removed")
+
         when(value) {
             is IdentifierReference -> {
                 if(targetDt in WordDatatypes) {
@@ -253,26 +269,316 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             else -> {}
         }
 
-        when(value) {
-            is PrefixExpression -> {}
-            is BinaryExpression -> {}
-            is ArrayIndexedExpression -> {}
-            is TypecastExpression -> {}
-            is RangeExpr -> {}
-            is FunctionCall -> {}
-            else -> {
-                // TODO optimize the others further?
-                if(this.asmgen.options.slowCodegenWarnings)
-                    println("warning: slow stack evaluation used for typecast: into $targetDt at ${value.position}")
+
+        // special case optimizations
+        if(target.kind==TargetStorageKind.VARIABLE) {
+            if(value is IdentifierReference && valueDt != DataType.STRUCT)
+                return assignTypeCastedIdentifier(target.asmVarname, targetDt, asmgen.asmVariableName(value), valueDt)
+
+            when (valueDt) {
+                in ByteDatatypes -> {
+                    assignExpressionToRegister(value, RegisterOrPair.A)
+                    assignTypeCastedRegisters(target.asmVarname, targetDt, RegisterOrPair.A, valueDt)
+                }
+                in WordDatatypes -> {
+                    assignExpressionToRegister(value, RegisterOrPair.AY)
+                    assignTypeCastedRegisters(target.asmVarname, targetDt, RegisterOrPair.AY, valueDt)
+                }
+                DataType.FLOAT -> {
+                    assignExpressionToRegister(value, RegisterOrPair.FAC1)
+                    assignTypecastedFloatFAC1(target.asmVarname, targetDt)
+                }
+                in PassByReferenceDatatypes -> {
+                    // str/array value cast (most likely to UWORD, take address-of)
+                    assignExpressionToVariable(value, target.asmVarname, targetDt, null)
+                }
+                else -> throw AssemblyError("strange dt in typecast assign to var: $valueDt  -->  $targetDt")
             }
+            return
         }
 
         // give up, do it via eval stack
-        // TODO byte and word values not via stack but directly via A or AY registers?
-        asmgen.translateExpression(origAssign.source.expression!!)
+        // TODO optimize typecasts for more special cases?
+        // note: cannot use assignTypeCastedValue because that is ourselves :P
+        if(this.asmgen.options.slowCodegenWarnings)
+            println("warning: slow stack evaluation used for typecast: $value into $targetDt (target=${target.kind} at ${value.position}")
+        asmgen.translateExpression(origTypeCastExpression)      // this performs the actual type cast in translateExpression(Typecast)
         assignStackValue(target)
     }
 
+    private fun assignTypecastedFloatFAC1(targetAsmVarName: String, targetDt: DataType) {
+
+        if(targetDt==DataType.FLOAT)
+            throw AssemblyError("typecast to identical type")
+
+        when(targetDt) {
+            DataType.UBYTE -> asmgen.out("  jsr  floats.cast_FAC1_as_uw_into_ya |  sty  $targetAsmVarName")
+            DataType.BYTE -> asmgen.out("  jsr  floats.cast_FAC1_as_w_into_ay |  sta  $targetAsmVarName")
+            DataType.UWORD -> asmgen.out("  jsr  floats.cast_FAC1_as_uw_into_ya |  sty  $targetAsmVarName |  sta  $targetAsmVarName+1")
+            DataType.WORD -> asmgen.out("  jsr  floats.cast_FAC1_as_w_into_ay |  sta  $targetAsmVarName |  sty  $targetAsmVarName+1")
+            else -> throw AssemblyError("weird type")
+        }
+    }
+
+
+    private fun assignTypeCastedIdentifier(targetAsmVarName: String, targetDt: DataType,
+                                           sourceAsmVarName: String, sourceDt: DataType) {
+        if(sourceDt == targetDt)
+            throw AssemblyError("typecast to identical type")
+
+        // also see: ExpressionAsmGen,   fun translateExpression(typecast: TypecastExpression)
+        when(sourceDt) {
+            DataType.UBYTE -> {
+                when(targetDt) {
+                    DataType.UBYTE, DataType.BYTE -> {
+                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
+                    }
+                    DataType.UWORD, DataType.WORD -> {
+                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                            asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  stz  $targetAsmVarName+1")
+                        else
+                            asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
+                    }
+                    DataType.FLOAT -> {
+                        asmgen.out("""
+                            lda  #<$targetAsmVarName
+                            ldy  #>$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2
+                            sty  P8ZP_SCRATCH_W2+1
+                            ldy  $sourceAsmVarName
+                            jsr  floats.cast_from_ub""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.BYTE -> {
+                when(targetDt) {
+                    DataType.UBYTE, DataType.BYTE -> {
+                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
+                    }
+                    DataType.UWORD -> {
+                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                            asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  stz  $targetAsmVarName+1")
+                        else
+                            asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
+                    }
+                    DataType.WORD -> {
+                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
+                        asmgen.signExtendVariableLsb(targetAsmVarName, DataType.BYTE)
+                    }
+                    DataType.FLOAT -> {
+                        asmgen.out("""
+                            lda  #<$targetAsmVarName
+                            ldy  #>$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2
+                            sty  P8ZP_SCRATCH_W2+1
+                            lda  $sourceAsmVarName
+                            jsr  floats.cast_from_b""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.UWORD -> {
+                when(targetDt) {
+                    DataType.BYTE, DataType.UBYTE -> {
+                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
+                    }
+                    DataType.WORD, DataType.UWORD -> {
+                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  lda  $sourceAsmVarName+1 |  sta  $targetAsmVarName+1")
+                    }
+                    DataType.FLOAT -> {
+                        asmgen.out("""
+                            lda  #<$targetAsmVarName
+                            ldy  #>$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2
+                            sty  P8ZP_SCRATCH_W2+1
+                            lda  $sourceAsmVarName
+                            ldy  $sourceAsmVarName+1
+                            jsr  floats.cast_from_uw""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.WORD -> {
+                when(targetDt) {
+                    DataType.BYTE, DataType.UBYTE -> {
+                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
+                    }
+                    DataType.WORD, DataType.UWORD -> {
+                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  lda  $sourceAsmVarName+1 |  sta  $targetAsmVarName+1")
+                    }
+                    DataType.FLOAT -> {
+                        asmgen.out("""
+                            lda  #<$targetAsmVarName
+                            ldy  #>$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2
+                            sty  P8ZP_SCRATCH_W2+1
+                            lda  $sourceAsmVarName
+                            ldy  $sourceAsmVarName+1
+                            jsr  floats.cast_from_w""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.FLOAT -> {
+                asmgen.out("  lda  #<$sourceAsmVarName |  ldy  #>$sourceAsmVarName")
+                when(targetDt) {
+                    DataType.UBYTE -> asmgen.out("  jsr  floats.cast_as_uw_into_ya |  sty  $targetAsmVarName")
+                    DataType.BYTE -> asmgen.out("  jsr  floats.cast_as_w_into_ay |  sta  $targetAsmVarName")
+                    DataType.UWORD -> asmgen.out("  jsr  floats.cast_as_uw_into_ya |  sty  $targetAsmVarName |  sta  $targetAsmVarName+1")
+                    DataType.WORD -> asmgen.out("  jsr  floats.cast_as_w_into_ay |  sta  $targetAsmVarName |  sty  $targetAsmVarName+1")
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.STR -> {
+                if (targetDt != DataType.UWORD && targetDt == DataType.STR)
+                    throw AssemblyError("cannot typecast a string into another incompatitble type")
+                TODO("assign typecasted string into target var")
+            }
+            else -> throw AssemblyError("weird type")
+        }
+    }
+
+
+    private fun assignTypeCastedRegisters(targetAsmVarName: String, targetDt: DataType,
+                                          regs: RegisterOrPair, sourceDt: DataType) {
+        if(sourceDt == targetDt)
+            throw AssemblyError("typecast to identical type")
+
+        // also see: ExpressionAsmGen,   fun translateExpression(typecast: TypecastExpression)
+        when(sourceDt) {
+            DataType.UBYTE -> {
+                when(targetDt) {
+                    DataType.UBYTE, DataType.BYTE -> {
+                        asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName")
+                    }
+                    DataType.UWORD, DataType.WORD -> {
+                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                            asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  stz  $targetAsmVarName+1")
+                        else
+                            asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
+                    }
+                    DataType.FLOAT -> {
+                        when(regs) {
+                            RegisterOrPair.A -> asmgen.out("  tay")
+                            RegisterOrPair.X -> asmgen.out("  txa |  tay")
+                            RegisterOrPair.Y -> {}
+                            else -> throw AssemblyError("non-byte regs")
+                        }
+                        asmgen.out("""
+                            lda  #<$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2
+                            lda  #>$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2+1
+                            jsr  floats.cast_from_ub""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.BYTE -> {
+                when(targetDt) {
+                    DataType.UBYTE, DataType.BYTE -> {
+                        asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName")
+                    }
+                    DataType.UWORD -> {
+                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                            asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  stz  $targetAsmVarName+1")
+                        else
+                            asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
+                    }
+                    DataType.WORD -> {
+                        when(regs) {
+                            RegisterOrPair.A -> {}
+                            RegisterOrPair.X -> asmgen.out("  txa")
+                            RegisterOrPair.Y -> asmgen.out("  tya")
+                            else -> throw AssemblyError("non-byte regs")
+                        }
+                        asmgen.signExtendAYlsb(sourceDt)
+                        asmgen.out("  sta  $targetAsmVarName |  sty  $targetAsmVarName+1")
+                    }
+                    DataType.FLOAT -> {
+                        when(regs) {
+                            RegisterOrPair.A -> {}
+                            RegisterOrPair.X -> asmgen.out("  txa")
+                            RegisterOrPair.Y -> asmgen.out("  tya")
+                            else -> throw AssemblyError("non-byte regs")
+                        }
+                        asmgen.out("""
+                            ldy  #<$targetAsmVarName
+                            sty  P8ZP_SCRATCH_W2
+                            ldy  #>$targetAsmVarName
+                            sty  P8ZP_SCRATCH_W2+1
+                            jsr  floats.cast_from_b""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.UWORD -> {
+                when(targetDt) {
+                    DataType.BYTE, DataType.UBYTE -> {
+                        asmgen.out("  st${regs.toString().toLowerCase().first()}  $targetAsmVarName")
+                    }
+                    DataType.WORD, DataType.UWORD -> {
+                        when(regs) {
+                            RegisterOrPair.AX -> asmgen.out("  sta  $targetAsmVarName |  stx  $targetAsmVarName+1")
+                            RegisterOrPair.AY -> asmgen.out("  sta  $targetAsmVarName |  sty  $targetAsmVarName+1")
+                            RegisterOrPair.XY -> asmgen.out("  stx  $targetAsmVarName |  sty  $targetAsmVarName+1")
+                            else -> throw AssemblyError("non-word regs")
+                        }
+                    }
+                    DataType.FLOAT -> {
+                        if(regs!=RegisterOrPair.AY)
+                            throw AssemblyError("only supports AY here")
+                        asmgen.out("""
+                            pha
+                            lda  #<$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2
+                            lda  #>$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2+1
+                            pla
+                            jsr  floats.cast_from_uw""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.WORD -> {
+                when(targetDt) {
+                    DataType.BYTE, DataType.UBYTE -> {
+                        asmgen.out("  st${regs.toString().toLowerCase().first()}  $targetAsmVarName")
+                    }
+                    DataType.WORD, DataType.UWORD -> {
+                        when(regs) {
+                            RegisterOrPair.AX -> asmgen.out("  sta  $targetAsmVarName |  stx  $targetAsmVarName+1")
+                            RegisterOrPair.AY -> asmgen.out("  sta  $targetAsmVarName |  sty  $targetAsmVarName+1")
+                            RegisterOrPair.XY -> asmgen.out("  stx  $targetAsmVarName |  sty  $targetAsmVarName+1")
+                            else -> throw AssemblyError("non-word regs")
+                        }
+                    }
+                    DataType.FLOAT -> {
+                        if(regs!=RegisterOrPair.AY)
+                            throw AssemblyError("only supports AY here")
+                        asmgen.out("""
+                            pha
+                            lda  #<$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2
+                            lda  #>$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2+1
+                            pla
+                            jsr  floats.cast_from_w""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.STR -> {
+                if (targetDt != DataType.UWORD && targetDt == DataType.STR)
+                    throw AssemblyError("cannot typecast a string into another incompatitble type")
+                TODO("assign typecasted string into target var")
+            }
+            else -> throw AssemblyError("weird type")
+        }
+    }
+
+
     private fun assignStackValue(target: AsmAssignTarget) {
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
@@ -393,6 +699,14 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                             else -> throw AssemblyError("can't assign word to single byte register")
                         }
                     }
+                    DataType.FLOAT -> {
+                        when(target.register!!) {
+                            RegisterOrPair.FAC1 -> asmgen.out("  jsr  floats.pop_float_fac1")
+                            RegisterOrPair.FAC2 -> asmgen.out("  jsr  floats.pop_float_fac2")
+                            else -> throw AssemblyError("can only assign float to Fac1 or 2")
+                        }
+                    }
+
                     else -> throw AssemblyError("weird dt")
                 }
             }
@@ -411,10 +725,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     """)
             }
             TargetStorageKind.MEMORY -> {
-                throw AssemblyError("no asm gen for assign address $sourceName to memory word $target")
+                throw AssemblyError("can't store word into memory byte")
             }
             TargetStorageKind.ARRAY -> {
-                throw AssemblyError("no asm gen for assign address $sourceName to array ${target.asmVarname}")
+                asmgen.out("  lda  #<$sourceName |  ldy #>$sourceName")
+                assignRegisterpairWord(target, RegisterOrPair.AY)
             }
             TargetStorageKind.REGISTER -> {
                 when(target.register!!) {
@@ -441,10 +756,10 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 when(target.datatype) {
                     DataType.UWORD -> {
                         asmgen.out("""
-                            lda #<$sourceName
-                            ldy #>$sourceName
-                            sta ${target.asmVarname}
-                            sty ${target.asmVarname}+1
+                            lda  #<$sourceName
+                            ldy  #>$sourceName
+                            sta  ${target.asmVarname}
+                            sty  ${target.asmVarname}+1
                         """)
                     }
                     DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B -> {
@@ -568,7 +883,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
-    private fun assignFAC1float(target: AsmAssignTarget) {
+    internal fun assignFAC1float(target: AsmAssignTarget) {
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
                 asmgen.out("""
@@ -595,11 +910,53 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 asmgen.out("  jsr  floats.set_array_float_from_fac1")
             }
             TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to mem byte")
-            TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
+            TargetStorageKind.REGISTER -> {
+                if (target.register!! != RegisterOrPair.FAC1)
+                    throw AssemblyError("can't assign Fac1 float to another fac register")
+            }
             TargetStorageKind.STACK -> asmgen.out("  jsr  floats.push_fac1")
         }
     }
 
+    private fun assignFloatFromAY(target: AsmAssignTarget) {
+        when(target.kind) {
+            TargetStorageKind.VARIABLE -> {
+                asmgen.out("""
+                    sta  P8ZP_SCRATCH_W1                    
+                    sty  P8ZP_SCRATCH_W1+1
+                    lda  #<${target.asmVarname} 
+                    ldy  #>${target.asmVarname}
+                    jsr  floats.copy_float""")
+            }
+            TargetStorageKind.ARRAY -> {
+                asmgen.out("""
+                    sta  P8ZP_SCRATCH_W1
+                    sty  P8ZP_SCRATCH_W1+1
+                    lda  #<${target.asmVarname} 
+                    ldy  #>${target.asmVarname}
+                    sta  P8ZP_SCRATCH_W2
+                    sty  P8ZP_SCRATCH_W2+1""")
+                if(target.array!!.indexer.indexNum!=null) {
+                    val index = target.array.indexer.constIndex()!!
+                    asmgen.out(" lda  #$index")
+                } else {
+                    val asmvarname = asmgen.asmVariableName(target.array.indexer.indexVar!!)
+                    asmgen.out(" lda  $asmvarname")
+                }
+                asmgen.out(" jsr  floats.set_array_float")
+            }
+            TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to mem byte")
+            TargetStorageKind.REGISTER -> {
+                when(target.register!!) {
+                    RegisterOrPair.FAC1 -> asmgen.out("  jsr  floats.MOVFM")
+                    RegisterOrPair.FAC2 -> asmgen.out("  jsr  floats.CONUPK")
+                    else -> throw AssemblyError("can only assign float to Fac1 or 2")
+                }
+            }
+            TargetStorageKind.STACK -> asmgen.out("  jsr  floats.push_float")
+        }
+    }
+
     private fun assignVariableFloat(target: AsmAssignTarget, sourceName: String) {
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
@@ -636,7 +993,13 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 asmgen.out(" jsr  floats.set_array_float")
             }
             TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to mem byte")
-            TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
+            TargetStorageKind.REGISTER -> {
+                when(target.register!!) {
+                    RegisterOrPair.FAC1 -> asmgen.out("  lda  #<$sourceName  | ldy  #>$sourceName |  jsr  floats.MOVFM")
+                    RegisterOrPair.FAC2 -> asmgen.out("  lda  #<$sourceName  | ldy  #>$sourceName |  jsr  floats.CONUPK")
+                    else -> throw AssemblyError("can only assign float to Fac1 or 2")
+                }
+            }
             TargetStorageKind.STACK -> asmgen.out("  lda  #<$sourceName |  ldy  #>$sourceName |  jsr  floats.push_float")
         }
     }
@@ -670,6 +1033,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     RegisterOrPair.AX -> asmgen.out("  lda  $sourceName |  ldx  #0")
                     RegisterOrPair.AY -> asmgen.out("  lda  $sourceName |  ldy  #0")
                     RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName |  ldy  #0")
+                    RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
                 }
             }
             TargetStorageKind.STACK -> {
@@ -747,21 +1111,28 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         val sourceName = asmgen.asmVariableName(bytevar)
         when(wordtarget.kind) {
             TargetStorageKind.VARIABLE -> {
-                asmgen.out("""
-                    lda  $sourceName
-                    sta  ${wordtarget.asmVarname}
-                    lda  #0
-                    sta  ${wordtarget.asmVarname}+1
-                    """)
+                asmgen.out("  lda  $sourceName |  sta  ${wordtarget.asmVarname}")
+                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    asmgen.out("  stz  ${wordtarget.asmVarname}+1")
+                else
+                    asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
             }
             TargetStorageKind.ARRAY -> {
                 if (wordtarget.constArrayIndexValue!=null) {
                     val scaledIdx = wordtarget.constArrayIndexValue!! * 2
-                    asmgen.out(" lda  $sourceName  | sta  ${wordtarget.asmVarname}+$scaledIdx |  lda  #0  | sta  ${wordtarget.asmVarname}+$scaledIdx+1")
+                    asmgen.out("  lda  $sourceName  | sta  ${wordtarget.asmVarname}+$scaledIdx")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  ${wordtarget.asmVarname}+$scaledIdx+1")
+                    else
+                        asmgen.out("  lda  #0  | sta  ${wordtarget.asmVarname}+$scaledIdx+1")
                 }
                 else {
                     asmgen.loadScaledArrayIndexIntoRegister(wordtarget.array!!, wordtarget.datatype, CpuRegister.Y)
-                    asmgen.out(" lda  $sourceName |  sta  ${wordtarget.asmVarname},y |  lda  #0 |  iny |  sta  ${wordtarget.asmVarname},y")
+                    asmgen.out("  lda  $sourceName |  sta  ${wordtarget.asmVarname},y |  iny")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  ${wordtarget.asmVarname},y")
+                    else
+                        asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname},y")
                 }
             }
             TargetStorageKind.REGISTER -> {
@@ -773,18 +1144,17 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 }
             }
             TargetStorageKind.STACK -> {
-                asmgen.out("""
-                    lda  $sourceName
-                    sta  P8ESTACK_LO,x
-                    lda  #0
-                    sta  P8ESTACK_HI,x
-                    dex""")
+                asmgen.out("  lda  $sourceName |  sta  P8ESTACK_LO,x")
+                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    asmgen.out("  stz  P8ESTACK_HI,x |  dex")
+                else
+                    asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
             }
             else -> throw AssemblyError("target type isn't word")
         }
     }
 
-    private fun assignRegisterByte(target: AsmAssignTarget, register: CpuRegister) {
+    internal fun assignRegisterByte(target: AsmAssignTarget, register: CpuRegister) {
         require(target.datatype in ByteDatatypes)
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
@@ -794,22 +1164,20 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 storeRegisterInMemoryAddress(register, target.memory!!)
             }
             TargetStorageKind.ARRAY -> {
-                when {
-                    target.constArrayIndexValue!=null -> {
-                        when (register) {
-                            CpuRegister.A -> asmgen.out("  sta  ${target.asmVarname}+${target.constArrayIndexValue}")
-                            CpuRegister.X -> asmgen.out("  stx  ${target.asmVarname}+${target.constArrayIndexValue}")
-                            CpuRegister.Y -> asmgen.out("  sty  ${target.asmVarname}+${target.constArrayIndexValue}")
-                        }
+                if (target.constArrayIndexValue!=null) {
+                    when (register) {
+                        CpuRegister.A -> asmgen.out("  sta  ${target.asmVarname}+${target.constArrayIndexValue}")
+                        CpuRegister.X -> asmgen.out("  stx  ${target.asmVarname}+${target.constArrayIndexValue}")
+                        CpuRegister.Y -> asmgen.out("  sty  ${target.asmVarname}+${target.constArrayIndexValue}")
                     }
-                    else -> {
-                        when (register) {
-                            CpuRegister.A -> {}
-                            CpuRegister.X -> asmgen.out(" txa")
-                            CpuRegister.Y -> asmgen.out(" tya")
-                        }
-                        asmgen.out(" ldy  ${asmgen.asmVariableName(target.array!!.indexer.indexVar!!)} |  sta  ${target.asmVarname},y")
+                }
+                else {
+                    when (register) {
+                        CpuRegister.A -> {}
+                        CpuRegister.X -> asmgen.out(" txa")
+                        CpuRegister.Y -> asmgen.out(" tya")
                     }
+                    asmgen.out(" ldy  ${asmgen.asmVariableName(target.array!!.indexer.indexVar!!)} |  sta  ${target.asmVarname},y")
                 }
             }
             TargetStorageKind.REGISTER -> {
@@ -821,6 +1189,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AY -> { asmgen.out("  ldy  #0") }
                         RegisterOrPair.AX -> { asmgen.out("  ldx  #0") }
                         RegisterOrPair.XY -> { asmgen.out("  tax |  ldy  #0") }
+                        RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected type cast to float")
                     }
                     CpuRegister.X -> when(target.register!!) {
                         RegisterOrPair.A -> { asmgen.out("  txa") }
@@ -829,6 +1198,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AY -> { asmgen.out("  txa |  ldy  #0") }
                         RegisterOrPair.AX -> { asmgen.out("  txa |  ldx  #0") }
                         RegisterOrPair.XY -> { asmgen.out("  ldy  #0") }
+                        RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected type cast to float")
                     }
                     CpuRegister.Y -> when(target.register!!) {
                         RegisterOrPair.A -> { asmgen.out("  tya") }
@@ -837,6 +1207,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AY -> { asmgen.out("  tya |  ldy  #0") }
                         RegisterOrPair.AX -> { asmgen.out("  tya |  ldx  #0") }
                         RegisterOrPair.XY -> { asmgen.out("  tya |  tax |  ldy  #0") }
+                        RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected type cast to float")
                     }
                 }
             }
@@ -850,7 +1221,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
-    private fun assignRegisterpairWord(target: AsmAssignTarget, regs: RegisterOrPair) {
+    internal fun assignRegisterpairWord(target: AsmAssignTarget, regs: RegisterOrPair) {
         require(target.datatype in NumericDatatypes)
         if(target.datatype==DataType.FLOAT)
             throw AssemblyError("float value should be from FAC1 not from registerpair memory pointer")
@@ -865,20 +1236,30 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 }
             }
             TargetStorageKind.ARRAY -> {
-                // TODO can be a bit more optimized if the array indexer is a number
-                when(regs) {
-                    RegisterOrPair.AX -> asmgen.out("  pha |  txa |  pha")
-                    RegisterOrPair.AY -> asmgen.out("  pha |  tya |  pha")
-                    RegisterOrPair.XY -> asmgen.out("  txa |  pha |  tya |  pha")
-                    else -> throw AssemblyError("expected reg pair")
+                if (target.constArrayIndexValue!=null) {
+                    val idx = target.constArrayIndexValue!! * 2
+                    when (regs) {
+                        RegisterOrPair.AX -> asmgen.out("  sta  ${target.asmVarname}+$idx |  stx  ${target.asmVarname}+$idx+1")
+                        RegisterOrPair.AY -> asmgen.out("  sta  ${target.asmVarname}+$idx |  sty  ${target.asmVarname}+$idx+1")
+                        RegisterOrPair.XY -> asmgen.out("  stx  ${target.asmVarname}+$idx |  sty  ${target.asmVarname}+$idx+1")
+                        else -> throw AssemblyError("expected reg pair")
+                    }
                 }
-                asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UWORD, CpuRegister.Y, true)
-                asmgen.out("""
-                    pla
-                    sta  ${target.asmVarname},y
-                    dey
-                    pla
-                    sta  ${target.asmVarname},y""")
+                else {
+                    when(regs) {
+                        RegisterOrPair.AX -> asmgen.out("  pha |  txa |  pha")
+                        RegisterOrPair.AY -> asmgen.out("  pha |  tya |  pha")
+                        RegisterOrPair.XY -> asmgen.out("  txa |  pha |  tya |  pha")
+                        else -> throw AssemblyError("expected reg pair")
+                    }
+                    asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UWORD, CpuRegister.Y, true)
+                    asmgen.out("""
+                        pla
+                        sta  ${target.asmVarname},y
+                        dey
+                        pla
+                        sta  ${target.asmVarname},y""")
+                    }
             }
             TargetStorageKind.REGISTER -> {
                 when(regs) {
@@ -989,6 +1370,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 RegisterOrPair.AX -> asmgen.out("  lda  #${byte.toHex()} |  ldx  #0")
                 RegisterOrPair.AY -> asmgen.out("  lda  #${byte.toHex()} |  ldy  #0")
                 RegisterOrPair.XY -> asmgen.out("  ldx  #${byte.toHex()} |  ldy  #0")
+                RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
             }
             TargetStorageKind.STACK -> {
                 asmgen.out("""
@@ -1025,14 +1407,23 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 TargetStorageKind.ARRAY -> {
                     if (target.array!!.indexer.indexNum!=null) {
                         val indexValue = target.array.indexer.constIndex()!! * DataType.FLOAT.memorySize()
-                        asmgen.out("""
-                            lda  #0
-                            sta  ${target.asmVarname}+$indexValue
-                            sta  ${target.asmVarname}+$indexValue+1
-                            sta  ${target.asmVarname}+$indexValue+2
-                            sta  ${target.asmVarname}+$indexValue+3
-                            sta  ${target.asmVarname}+$indexValue+4
-                        """)
+                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            asmgen.out("""
+                                stz  ${target.asmVarname}+$indexValue
+                                stz  ${target.asmVarname}+$indexValue+1
+                                stz  ${target.asmVarname}+$indexValue+2
+                                stz  ${target.asmVarname}+$indexValue+3
+                                stz  ${target.asmVarname}+$indexValue+4
+                            """)
+                        else
+                            asmgen.out("""
+                                lda  #0
+                                sta  ${target.asmVarname}+$indexValue
+                                sta  ${target.asmVarname}+$indexValue+1
+                                sta  ${target.asmVarname}+$indexValue+2
+                                sta  ${target.asmVarname}+$indexValue+3
+                                sta  ${target.asmVarname}+$indexValue+4
+                            """)
                     } else {
                         val asmvarname = asmgen.asmVariableName(target.array.indexer.indexVar!!)
                         asmgen.out("""
@@ -1046,7 +1437,14 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     }
                 }
                 TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to memory byte")
-                TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
+                TargetStorageKind.REGISTER -> {
+                    val floatConst = asmgen.getFloatAsmConst(float)
+                    when(target.register!!) {
+                        RegisterOrPair.FAC1 -> asmgen.out("  lda  #<$floatConst  | ldy  #>$floatConst |  jsr  floats.MOVFM")
+                        RegisterOrPair.FAC2 -> asmgen.out("  lda  #<$floatConst  | ldy  #>$floatConst |  jsr  floats.CONUPK")
+                        else -> throw AssemblyError("can only assign float to Fac1 or 2")
+                    }
+                }
                 TargetStorageKind.STACK -> {
                     val floatConst = asmgen.getFloatAsmConst(float)
                     asmgen.out(" lda  #<$floatConst |  ldy  #>$floatConst |  jsr  floats.push_float")
@@ -1103,7 +1501,14 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     }
                 }
                 TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to memory byte")
-                TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
+                TargetStorageKind.REGISTER -> {
+                    val floatConst = asmgen.getFloatAsmConst(float)
+                    when(target.register!!) {
+                        RegisterOrPair.FAC1 -> asmgen.out("  lda  #<$floatConst  | ldy  #>$floatConst |  jsr  floats.MOVFM")
+                        RegisterOrPair.FAC2 -> asmgen.out("  lda  #<$floatConst  | ldy  #>$floatConst |  jsr  floats.CONUPK")
+                        else -> throw AssemblyError("can only assign float to Fac1 or 2")
+                    }
+                }
                 TargetStorageKind.STACK -> {
                     val floatConst = asmgen.getFloatAsmConst(float)
                     asmgen.out(" lda  #<$floatConst |  ldy  #>$floatConst |  jsr  floats.push_float")
@@ -1134,6 +1539,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     RegisterOrPair.AX -> asmgen.out("  lda  ${address.toHex()} |  ldx  #0")
                     RegisterOrPair.AY -> asmgen.out("  lda  ${address.toHex()} |  ldy  #0")
                     RegisterOrPair.XY -> asmgen.out("  ldy  ${address.toHex()} |  ldy  #0")
+                    RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
                 }
                 TargetStorageKind.STACK -> {
                     asmgen.out("""
@@ -1164,6 +1570,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AX -> asmgen.out("  ldx  #0")
                         RegisterOrPair.AY -> asmgen.out("  ldy  #0")
                         RegisterOrPair.XY -> asmgen.out("  tax |  ldy  #0")
+                        RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
                     }
                 }
                 TargetStorageKind.STACK -> {
@@ -1178,12 +1585,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         if (address != null) {
             when(wordtarget.kind) {
                 TargetStorageKind.VARIABLE -> {
-                    asmgen.out("""
-                        lda  ${address.toHex()}
-                        sta  ${wordtarget.asmVarname}
-                        lda  #0
-                        sta  ${wordtarget.asmVarname}+1
-                        """)
+                    asmgen.out("  lda  ${address.toHex()} |  sta  ${wordtarget.asmVarname}")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  ${wordtarget.asmVarname}+1")
+                    else
+                        asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
                 }
                 TargetStorageKind.ARRAY -> {
                     throw AssemblyError("no asm gen for assign memory byte at $address to array ${wordtarget.asmVarname}")
@@ -1195,12 +1601,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     else -> throw AssemblyError("word regs can only be pair")
                 }
                 TargetStorageKind.STACK -> {
-                    asmgen.out("""
-                        lda  ${address.toHex()}
-                        sta  P8ESTACK_LO,x
-                        lda  #0
-                        sta  P8ESTACK_HI,x
-                        dex""")
+                    asmgen.out("  lda  ${address.toHex()} |  sta  P8ESTACK_LO,x")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  P8ESTACK_HI,x |  dex")
+                    else
+                        asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
                 }
                 else -> throw AssemblyError("other types aren't word")
             }
@@ -1208,7 +1613,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             when(wordtarget.kind) {
                 TargetStorageKind.VARIABLE -> {
                     asmgen.loadByteFromPointerIntoA(identifier)
-                    asmgen.out(" sta  ${wordtarget.asmVarname} |  lda  #0 |  sta ${wordtarget.asmVarname}+1")
+                    asmgen.out(" sta  ${wordtarget.asmVarname}")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  ${wordtarget.asmVarname}+1")
+                    else
+                        asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
                 }
                 TargetStorageKind.ARRAY -> {
                     throw AssemblyError("no asm gen for assign memory byte $identifier to array ${wordtarget.asmVarname} ")
@@ -1224,7 +1633,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 }
                 TargetStorageKind.STACK -> {
                     asmgen.loadByteFromPointerIntoA(identifier)
-                    asmgen.out(" sta  P8ESTACK_LO,x |  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
+                    asmgen.out("  sta  P8ESTACK_LO,x")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  P8ESTACK_HI,x |  dex")
+                    else
+                        asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
                 }
                 else -> throw AssemblyError("other types aren't word")
             }
@@ -1236,23 +1649,14 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         val addressLv = addressExpr as? NumericLiteralValue
         when {
             addressLv != null -> {
-                asmgen.out("  lda $ldaInstructionArg |  sta  ${addressLv.number.toHex()}")
+                asmgen.out("  lda  $ldaInstructionArg |  sta  ${addressLv.number.toHex()}")
             }
             addressExpr is IdentifierReference -> {
                 asmgen.storeByteIntoPointer(addressExpr, ldaInstructionArg)
             }
             else -> {
-                asmgen.out(" lda  $ldaInstructionArg |  pha")
-                asmgen.translateExpression(addressExpr)     // TODO directly into AY
-                asmgen.out("""
-                    inx
-                    lda  P8ESTACK_LO,x
-                    sta  P8ZP_SCRATCH_W2
-                    lda  P8ESTACK_HI,x
-                    sta  P8ZP_SCRATCH_W2+1
-                    ldy  #0
-                    pla
-                    sta  (P8ZP_SCRATCH_W2),y""")
+                assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
+                asmgen.out("  ldy  #0 |  lda  $ldaInstructionArg |  sta  (P8ZP_SCRATCH_W2),y")
             }
         }
     }
@@ -1276,17 +1680,31 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             }
             else -> {
                 asmgen.saveRegister(register, false, memoryAddress.definingSubroutine()!!)
-                asmgen.translateExpression(addressExpr) // TODO directly into AY
+                assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
                 asmgen.restoreRegister(CpuRegister.A, false)
-                asmgen.out("""
-                    inx
-                    ldy  P8ESTACK_LO,x
-                    sty  P8ZP_SCRATCH_W2
-                    ldy  P8ESTACK_HI,x
-                    sty  P8ZP_SCRATCH_W2+1
-                    ldy  #0
-                    sta  (P8ZP_SCRATCH_W2),y""")
+                asmgen.out("  ldy  #0 |  sta  (P8ZP_SCRATCH_W2),y")
             }
         }
     }
+
+    internal fun assignExpressionToRegister(expr: Expression, register: RegisterOrPair) {
+        val src = AsmAssignSource.fromAstSource(expr, program, asmgen)
+        val tgt = AsmAssignTarget.fromRegisters(register, null, program, asmgen)
+        val assign = AsmAssignment(src, tgt, false, expr.position)
+        translateNormalAssignment(assign)
+    }
+
+    internal fun assignExpressionToVariable(expr: Expression, asmVarName: String, dt: DataType, scope: Subroutine?) {
+        val src = AsmAssignSource.fromAstSource(expr, program, asmgen)
+        val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, dt, scope, variableAsmName = asmVarName)
+        val assign = AsmAssignment(src, tgt, false, expr.position)
+        translateNormalAssignment(assign)
+    }
+
+    internal fun assignVariableToRegister(asmVarName: String, register: RegisterOrPair) {
+        val tgt = AsmAssignTarget.fromRegisters(register, null, program, asmgen)
+        val src = AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, tgt.datatype, variableAsmName = asmVarName)
+        val assign = AsmAssignment(src, tgt, false, Position.DUMMY)
+        translateNormalAssignment(assign)
+    }
 }

compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt

@@ -160,7 +160,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         when {
                             valueLv != null -> inplaceModification_byte_litval_to_variable(addr.toHex(), DataType.UBYTE, operator, valueLv.toInt())
                             ident != null -> inplaceModification_byte_variable_to_variable(addr.toHex(), DataType.UBYTE, operator, ident)
-                            // TODO more specialized code for types such as memory read etc.
+                            // TODO more specialized code for types such as memory read etc.  -> inplaceModification_byte_memread_to_variable()
                             value is TypecastExpression -> {
                                 if (tryRemoveRedundantCast(value, target, operator)) return
                                 inplaceModification_byte_value_to_variable(addr.toHex(), DataType.UBYTE, operator, value)
@@ -171,40 +171,102 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     is IdentifierReference -> {
                         val pointer = memory.addressExpression as IdentifierReference
                         when {
-                            valueLv != null -> inplaceModification_byte_litval_to_memory(pointer, operator, valueLv.toInt())
-                            ident != null -> inplaceModification_byte_variable_to_memory(pointer, operator, ident)
-                            // TODO more specialized code for types such as memory read etc.
+                            valueLv != null -> inplaceModification_byte_litval_to_pointer(pointer, operator, valueLv.toInt())
+                            ident != null -> inplaceModification_byte_variable_to_pointer(pointer, operator, ident)
                             value is TypecastExpression -> {
                                 if (tryRemoveRedundantCast(value, target, operator)) return
-                                inplaceModification_byte_value_to_memory(pointer, operator, value)
+                                inplaceModification_byte_value_to_pointer(pointer, operator, value)
                             }
-                            else -> inplaceModification_byte_value_to_memory(pointer, operator, value)
+                            else -> inplaceModification_byte_value_to_pointer(pointer, operator, value)
                         }
                     }
                     else -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (1): ${memory.addressExpression::class.simpleName} at ${memory.addressExpression.position}") // TODO optimize...
                         asmgen.translateExpression(memory.addressExpression)
                         asmgen.out("  jsr  prog8_lib.read_byte_from_address_on_stack |  sta  P8ZP_SCRATCH_B1")
-                        val zp = CompilationTarget.instance.machine.zeropage
                         when {
-                            valueLv != null -> inplaceModification_byte_litval_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, valueLv.toInt())
-                            ident != null -> inplaceModification_byte_variable_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, ident)
-                            memread != null -> inplaceModification_byte_memread_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, memread)
+                            valueLv != null -> inplaceModification_byte_litval_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, valueLv.toInt())
+                            ident != null -> inplaceModification_byte_variable_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, ident)
+                            memread != null -> inplaceModification_byte_memread_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, memread)
                             value is TypecastExpression -> {
                                 if (tryRemoveRedundantCast(value, target, operator)) return
-                                inplaceModification_byte_value_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, value)
+                                inplaceModification_byte_value_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, value)
                             }
-                            else -> inplaceModification_byte_value_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, value)
+                            else -> inplaceModification_byte_value_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, value)
                         }
                         asmgen.out("  lda  P8ZP_SCRATCH_B1 |  jsr  prog8_lib.write_byte_to_address_on_stack | inx")
                     }
                 }
             }
             TargetStorageKind.ARRAY -> {
-                if(asmgen.options.slowCodegenWarnings)
-                    println("*** TODO optimize simple inplace array assignment ${target.array}  $operator=  $value")
-                assignmentAsmGen.translateNormalAssignment(target.origAssign) // TODO get rid of this fallback for the most common cases here
+                with(target.array!!.indexer) {
+                    when {
+                        indexNum!=null -> {
+                            val targetVarName = "${target.asmVarname} + ${indexNum!!.number.toInt()*target.datatype.memorySize()}"
+                            when(target.datatype) {
+                                in ByteDatatypes -> {
+                                    when {
+                                        valueLv != null -> inplaceModification_byte_litval_to_variable(targetVarName, target.datatype, operator, valueLv.toInt())
+                                        ident != null -> inplaceModification_byte_variable_to_variable(targetVarName, target.datatype, operator, ident)
+                                        memread != null -> inplaceModification_byte_memread_to_variable(targetVarName, target.datatype, operator, memread)
+                                        value is TypecastExpression -> {
+                                            if (tryRemoveRedundantCast(value, target, operator)) return
+                                            inplaceModification_byte_value_to_variable(targetVarName, target.datatype, operator, value)
+                                        }
+                                        else -> inplaceModification_byte_value_to_variable(targetVarName, target.datatype, operator, value)
+                                    }
+                                }
+                                in WordDatatypes -> {
+                                    when {
+                                        valueLv != null -> inplaceModification_word_litval_to_variable(targetVarName, target.datatype, operator, valueLv.toInt())
+                                        ident != null -> inplaceModification_word_variable_to_variable(targetVarName, target.datatype, operator, ident)
+                                        memread != null -> inplaceModification_word_memread_to_variable(targetVarName, target.datatype, operator, memread)
+                                        value is TypecastExpression -> {
+                                            if (tryRemoveRedundantCast(value, target, operator)) return
+                                            inplaceModification_word_value_to_variable(targetVarName, target.datatype, operator, value)
+                                        }
+                                        else -> inplaceModification_word_value_to_variable(targetVarName, target.datatype, operator, value)
+                                    }
+                                }
+                                DataType.FLOAT -> {
+                                    when {
+                                        valueLv != null -> inplaceModification_float_litval_to_variable(targetVarName, operator, valueLv.toDouble(), target.scope!!)
+                                        ident != null -> inplaceModification_float_variable_to_variable(targetVarName, operator, ident, target.scope!!)
+                                        value is TypecastExpression -> {
+                                            if (tryRemoveRedundantCast(value, target, operator)) return
+                                            inplaceModification_float_value_to_variable(targetVarName, operator, value, target.scope!!)
+                                        }
+                                        else -> inplaceModification_float_value_to_variable(targetVarName, operator, value, target.scope!!)
+                                    }
+                                }
+                                else -> throw AssemblyError("weird type to do in-place modification on ${target.datatype}")
+                            }
+                        }
+                        indexVar!=null -> {
+                            when(target.datatype) {
+                                in ByteDatatypes -> {
+                                    val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.A, null, program, asmgen)
+                                    val assign = AsmAssignment(target.origAssign.source, tgt, false, value.position)
+                                    assignmentAsmGen.translateNormalAssignment(assign)
+                                    assignmentAsmGen.assignRegisterByte(target, CpuRegister.A)
+                                }
+                                in WordDatatypes -> {
+                                    val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.AY, null, program, asmgen)
+                                    val assign = AsmAssignment(target.origAssign.source, tgt, false, value.position)
+                                    assignmentAsmGen.translateNormalAssignment(assign)
+                                    assignmentAsmGen.assignRegisterpairWord(target, RegisterOrPair.AY)
+                                }
+                                DataType.FLOAT -> {
+                                    val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.FAC1, null, program, asmgen)
+                                    val assign = AsmAssignment(target.origAssign.source, tgt, false, value.position)
+                                    assignmentAsmGen.translateNormalAssignment(assign)
+                                    assignmentAsmGen.assignFAC1float(target)
+                                }
+                                else -> throw AssemblyError("weird type to do in-place modification on ${target.datatype}")
+                            }
+                        }
+                        else -> throw AssemblyError("indexer expression should have been replaced by auto indexer var")
+                    }
+                }
             }
             TargetStorageKind.REGISTER -> TODO("reg in-place modification")
             TargetStorageKind.STACK -> TODO("stack in-place modification")
@@ -227,27 +289,20 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         return false
     }
 
-    private fun inplaceModification_byte_value_to_memory(pointervar: IdentifierReference, operator: String, value: Expression) {
-        if(asmgen.options.slowCodegenWarnings)
-            println("warning: slow stack evaluation used (3):  @(${pointervar.nameInSource.last()}) $operator= ${value::class.simpleName} at ${value.position}") // TODO
-        asmgen.translateExpression(value)
+    private fun inplaceModification_byte_value_to_pointer(pointervar: IdentifierReference, operator: String, value: Expression) {
+        asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_B1", DataType.UBYTE, null)
         val (ptrOnZp, sourceName) = asmgen.loadByteFromPointerIntoA(pointervar)
         when (operator) {
             // note: ** (power) operator requires floats.
-            "+" -> asmgen.out(" clc |  adc  P8ESTACK_LO+1,x")
-            "-" -> asmgen.out(" sec |  sbc  P8ESTACK_LO+1,x")
-            "*" -> asmgen.out("  pha |  lda  P8ESTACK_LO+1,x |  tay |  pla |  jsr  math.multiply_bytes |  ldy  #0")
-            "/" -> asmgen.out("  pha |  lda  P8ESTACK_LO+1,x |  tay |  pla |  jsr  math.divmod_ub_asm |  tya |  ldy  #0")
-            "%" -> asmgen.out("  pha |  lda  P8ESTACK_LO+1,x |  tay |  pla |  jsr  math.divmod_ub_asm |  ldy  #0")
+            "+" -> asmgen.out("  clc |  adc  P8ZP_SCRATCH_B1")
+            "-" -> asmgen.out("  sec |  sbc  P8ZP_SCRATCH_B1")
+            "*" -> asmgen.out("  ldy  P8ZP_SCRATCH_B1 |  jsr  math.multiply_bytes |  ldy  #0")
+            "/" -> asmgen.out("  ldy  P8ZP_SCRATCH_B1 |  jsr  math.divmod_ub_asm |  tya |  ldy  #0")
+            "%" -> asmgen.out("  ldy  P8ZP_SCRATCH_B1 |  jsr  math.divmod_ub_asm |  ldy  #0")
             "<<" -> {
                 asmgen.out("""
-                    pha
-                    lda  P8ESTACK_LO+1,x
-                    bne  +
-                    pla
-                    rts
-+                   tay
-                    pla 
+                    ldy  P8ZP_SCRATCH_B1
+                    beq  +
 -                   asl  a
                     dey
                     bne  -
@@ -255,38 +310,32 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             ">>" -> {
                 asmgen.out("""
-                    pha
-                    lda  P8ESTACK_LO+1,x
-                    bne  +
-                    pla
-                    rts
-+                   tay
-                    pla 
+                    ldy  P8ZP_SCRATCH_B1
+                    beq  +
 -                   lsr  a
                     dey
                     bne  -
 +""")
             }
-            "&" -> asmgen.out(" and  P8ESTACK_LO+1,x")
-            "^" -> asmgen.out(" eor  P8ESTACK_LO+1,x")
-            "|" -> asmgen.out(" ora  P8ESTACK_LO+1,x")
+            "&" -> asmgen.out(" and  P8ZP_SCRATCH_B1")
+            "^" -> asmgen.out(" eor  P8ZP_SCRATCH_B1")
+            "|" -> asmgen.out(" ora  P8ZP_SCRATCH_B1")
             else -> throw AssemblyError("invalid operator for in-place modification $operator")
         }
         if(ptrOnZp)
             asmgen.out("  sta  ($sourceName),y")
         else
             asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
-        asmgen.out(" inx")
     }
 
-    private fun inplaceModification_byte_variable_to_memory(pointervar: IdentifierReference, operator: String, value: IdentifierReference) {
+    private fun inplaceModification_byte_variable_to_pointer(pointervar: IdentifierReference, operator: String, value: IdentifierReference) {
         val otherName = asmgen.asmVariableName(value)
         val (ptrOnZp, sourceName) = asmgen.loadByteFromPointerIntoA(pointervar)
 
         when (operator) {
             // note: ** (power) operator requires floats.
-            "+" -> asmgen.out(" clc |  adc  $otherName")
-            "-" -> asmgen.out(" sec |  sbc  $otherName")
+            "+" -> asmgen.out("  clc |  adc  $otherName")
+            "-" -> asmgen.out("  sec |  sbc  $otherName")
             "*" -> asmgen.out("  ldy  $otherName |  jsr  math.multiply_bytes |  ldy  #0")
             "/" -> asmgen.out("  ldy  $otherName |  jsr  math.divmod_ub_asm |  tya |  ldy  #0")
             "%" -> asmgen.out("  ldy  $otherName |  jsr  math.divmod_ub_asm |  ldy  #0")
@@ -319,7 +368,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
     }
 
-    private fun inplaceModification_byte_litval_to_memory(pointervar: IdentifierReference, operator: String, value: Int) {
+    private fun inplaceModification_byte_litval_to_pointer(pointervar: IdentifierReference, operator: String, value: Int) {
         when (operator) {
             // note: ** (power) operator requires floats.
             "+" -> {
@@ -420,30 +469,36 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
     private fun inplaceModification_byte_value_to_variable(name: String, dt: DataType, operator: String, value: Expression) {
         // this should be the last resort for code generation for this,
         // because the value is evaluated onto the eval stack (=slow).
-        if(asmgen.options.slowCodegenWarnings)
-            println("warning: slow stack evaluation used (5):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-        asmgen.translateExpression(value)
         when (operator) {
             // note: ** (power) operator requires floats.
-            "+" -> asmgen.out(" lda  $name |  clc |  adc  P8ESTACK_LO+1,x |  sta  $name")
-            "-" -> asmgen.out(" lda  $name |  sec |  sbc  P8ESTACK_LO+1,x |  sta  $name")
-            "*" -> asmgen.out("  lda  P8ESTACK_LO+1,x |  ldy  $name |  jsr  math.multiply_bytes |  sta  $name")
+            "+" -> {
+                asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                asmgen.out("  clc |  adc  $name |  sta  $name")
+            }
+            "-" -> {
+                asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_B1", dt, null)
+                asmgen.out(" lda  $name |  sec |  sbc  P8ZP_SCRATCH_B1 |  sta  $name")
+            }
+            "*" -> {
+                asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                asmgen.out("  ldy  $name |  jsr  math.multiply_bytes |  sta  $name")
+            }
             "/" -> {
+                asmgen.assignExpressionToRegister(value, RegisterOrPair.Y)
                 if(dt==DataType.UBYTE)
-                    asmgen.out("  lda  P8ESTACK_LO+1,x |  tay |  lda  $name |  jsr  math.divmod_ub_asm |  sty  $name")
+                    asmgen.out("  lda  $name |  jsr  math.divmod_ub_asm |  sty  $name")
                 else
-                    asmgen.out("  lda  P8ESTACK_LO+1,x |  tay |  lda  $name |  jsr  math.divmod_b_asm |  sty  $name")
+                    asmgen.out("  lda  $name |  jsr  math.divmod_b_asm |  sty  $name")
             }
             "%" -> {
                 if(dt==DataType.BYTE)
                     throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
-                asmgen.out("  lda  P8ESTACK_LO+1,x |  tay |  lda  $name |  jsr  math.divmod_ub_asm |  sta  $name")
+                asmgen.assignExpressionToRegister(value, RegisterOrPair.Y)
+                asmgen.out("  lda  $name |  jsr  math.divmod_ub_asm |  sta  $name")
             }
             "<<" -> {
-                asmgen.translateExpression(value)       // todo directly into Y
+                asmgen.assignExpressionToRegister(value, RegisterOrPair.Y)
                 asmgen.out("""
-                    inx
-                    ldy  P8ESTACK_LO,x
                     beq  +
 -                   asl  $name
                     dey
@@ -451,11 +506,9 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 +""")
             }
             ">>" -> {
-                asmgen.translateExpression(value)   // todo directly into Y
+                asmgen.assignExpressionToRegister(value, RegisterOrPair.Y)
                 if(dt==DataType.UBYTE) {
                     asmgen.out("""
-                        inx
-                        ldy  P8ESTACK_LO,x
                         beq  +
 -                       lsr  $name
                         dey
@@ -463,8 +516,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 +""")
                 } else {
                     asmgen.out("""
-                        inx
-                        ldy  P8ESTACK_LO,x
                         beq  +
 -                       lda  $name
                         asl  a
@@ -474,12 +525,20 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 +""")
                 }
             }
-            "&" -> asmgen.out(" lda  $name |  and  P8ESTACK_LO+1,x |  sta  $name")
-            "^" -> asmgen.out(" lda  $name |  eor  P8ESTACK_LO+1,x |  sta  $name")
-            "|" -> asmgen.out(" lda  $name |  ora  P8ESTACK_LO+1,x |  sta  $name")
+            "&" -> {
+                asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                asmgen.out("  and  $name |  sta  $name")
+            }
+            "^" -> {
+                asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                asmgen.out("  eor  $name |  sta  $name")
+            }
+            "|" -> {
+                asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                asmgen.out("  ora  $name |  sta  $name")
+            }
             else -> throw AssemblyError("invalid operator for in-place modification $operator")
         }
-        asmgen.out(" inx")
     }
 
     private fun inplaceModification_byte_variable_to_variable(name: String, dt: DataType, operator: String, ident: IdentifierReference) {
@@ -584,14 +643,24 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     sta  $name""")
             }
             "<<" -> {
-                if(value>=8) asmgen.out(" lda  #0 |  sta  $name")
-                else repeat(value) { asmgen.out(" asl  $name") }
+                if(value>=8) {
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  $name")
+                    else
+                        asmgen.out("  lda  #0 |  sta  $name")
+                }
+                else repeat(value) { asmgen.out("  asl  $name") }
             }
             ">>" -> {
                 if(value>0) {
                     if (dt == DataType.UBYTE) {
-                        if(value>=8) asmgen.out(" lda  #0 |  sta  $name")
-                        else repeat(value) { asmgen.out(" lsr  $name") }
+                        if(value>=8) {
+                            if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                asmgen.out("  stz  $name")
+                            else
+                                asmgen.out("  lda  #0 |  sta  $name")
+                        }
+                        else repeat(value) { asmgen.out("  lsr  $name") }
                     } else {
                         when {
                             value>=8 -> asmgen.out("""
@@ -606,7 +675,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                 ldy  #$value
                                 jsr  math.lsr_byte_A
                                 sta  $name""")
-                            else -> repeat(value) { asmgen.out(" lda  $name | asl  a |  ror  $name") }
+                            else -> repeat(value) { asmgen.out("  lda  $name | asl  a |  ror  $name") }
                         }
                     }
                 }
@@ -799,9 +868,20 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             "<<" -> {
                 when {
-                    value>=16 -> asmgen.out(" lda  #0 |  sta  $name |  sta  $name+1")
-                    value==8 -> asmgen.out(" lda  $name |  sta  $name+1 |  lda  #0 |  sta  $name")
-                    value>2 -> asmgen.out("""
+                    value>=16 -> {
+                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            asmgen.out("  stz  $name |  stz  $name+1")
+                        else
+                            asmgen.out("  lda  #0 |  sta  $name |  sta  $name+1")
+                    }
+                    value==8 -> {
+                        asmgen.out("  lda  $name |  sta  $name+1")
+                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            asmgen.out("  stz  $name")
+                        else
+                            asmgen.out("  lda  #0 |  sta  $name")
+                    }
+                    value>3 -> asmgen.out("""
                         ldy  #$value
 -                       asl  $name
                         rol  $name+1
@@ -815,8 +895,19 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 if (value > 0) {
                     if(dt==DataType.UWORD) {
                         when {
-                            value>=16 -> asmgen.out(" lda  #0 |  sta  $name |  sta  $name+1")
-                            value==8 -> asmgen.out(" lda  $name+1 |  sta  $name |  lda  #0 |  sta  $name+1")
+                            value>=16 -> {
+                                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                    asmgen.out("  stz  $name |  stz  $name+1")
+                                else
+                                    asmgen.out("  lda  #0 |  sta  $name |  sta  $name+1")
+                            }
+                            value==8 -> {
+                                asmgen.out("  lda  $name+1 |  sta  $name")
+                                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                    asmgen.out("  stz  $name+1")
+                                else
+                                    asmgen.out("  lda  #0 |  sta  $name+1")
+                            }
                             value>2 -> asmgen.out("""
                                 ldy  #$value
 -                               lsr  $name+1
@@ -862,41 +953,41 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 when {
                     value == 0 -> {
                         if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
-                            asmgen.out(" stz  $name |  stz  $name+1")
+                            asmgen.out("  stz  $name |  stz  $name+1")
                         else
-                            asmgen.out(" lda  #0 |  sta  $name |  sta  $name+1")
+                            asmgen.out("  lda  #0 |  sta  $name |  sta  $name+1")
                     }
                     value and 255 == 0 -> {
                         if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
-                            asmgen.out(" stz  $name")
+                            asmgen.out("  stz  $name")
                         else
-                            asmgen.out(" lda  #0 |  sta  $name")
-                        asmgen.out(" lda  $name+1 |  and  #>$value |  sta  $name+1")
+                            asmgen.out("  lda  #0 |  sta  $name")
+                        asmgen.out("  lda  $name+1 |  and  #>$value |  sta  $name+1")
                     }
                     value < 0x0100 -> {
-                        asmgen.out(" lda  $name |  and  #$value |  sta  $name")
+                        asmgen.out("  lda  $name |  and  #$value |  sta  $name")
                         if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("  stz  $name+1")
                         else
                             asmgen.out("  lda  #0 |  sta  $name+1")
                     }
-                    else -> asmgen.out(" lda  $name |  and  #<$value |  sta  $name |  lda  $name+1 |  and  #>$value |  sta  $name+1")
+                    else -> asmgen.out("  lda  $name |  and  #<$value |  sta  $name |  lda  $name+1 |  and  #>$value |  sta  $name+1")
                 }
             }
             "^" -> {
                 when {
                     value == 0 -> {}
-                    value and 255 == 0 -> asmgen.out(" lda  $name+1 |  eor  #>$value |  sta  $name+1")
-                    value < 0x0100 -> asmgen.out(" lda  $name |  eor  #$value |  sta  $name")
-                    else -> asmgen.out(" lda  $name |  eor  #<$value |  sta  $name |  lda  $name+1 |  eor  #>$value |  sta  $name+1")
+                    value and 255 == 0 -> asmgen.out("  lda  $name+1 |  eor  #>$value |  sta  $name+1")
+                    value < 0x0100 -> asmgen.out("  lda  $name |  eor  #$value |  sta  $name")
+                    else -> asmgen.out("  lda  $name |  eor  #<$value |  sta  $name |  lda  $name+1 |  eor  #>$value |  sta  $name+1")
                 }
             }
             "|" -> {
                 when {
                     value == 0 -> {}
-                    value and 255 == 0 -> asmgen.out(" lda  $name+1 |  ora  #>$value |  sta  $name+1")
-                    value < 0x0100 -> asmgen.out(" lda  $name |  ora  #$value |  sta  $name")
-                    else -> asmgen.out(" lda  $name |  ora  #<$value |  sta  $name |  lda  $name+1 |  ora  #>$value |  sta  $name+1")
+                    value and 255 == 0 -> asmgen.out("  lda  $name+1 |  ora  #>$value |  sta  $name+1")
+                    value < 0x0100 -> asmgen.out("  lda  $name |  ora  #$value |  sta  $name")
+                    else -> asmgen.out("  lda  $name |  ora  #<$value |  sta  $name |  lda  $name+1 |  ora  #>$value |  sta  $name+1")
                 }
             }
             else -> throw AssemblyError("invalid operator for in-place modification $operator")
@@ -960,11 +1051,12 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                 sta  $name+1""")
                     }
                     "*" -> {
+                        asmgen.out("  lda  $otherName |  sta  P8ZP_SCRATCH_W1")
+                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            asmgen.out("  stz  P8ZP_SCRATCH_W1+1")
+                        else
+                            asmgen.out("  lda  #0 |  sta  P8ZP_SCRATCH_W1+1")
                         asmgen.out("""
-                            lda  $otherName
-                            sta  P8ZP_SCRATCH_W1
-                            lda  #0
-                            sta  P8ZP_SCRATCH_W1+1
                             lda  $name
                             ldy  $name+1
                             jsr  math.multiply_words
@@ -1009,12 +1101,16 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         }
                     }
                     "&" -> {
-                        asmgen.out(" lda  $otherName |  and  $name |  sta  $name")
-                        if(dt in WordDatatypes)
-                            asmgen.out(" lda  #0 |  sta  $name+1")
+                        asmgen.out("  lda  $otherName |  and  $name |  sta  $name")
+                        if(dt in WordDatatypes) {
+                            if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                asmgen.out("  stz  $name+1")
+                            else
+                                asmgen.out("  lda  #0 |  sta  $name+1")
+                        }
                     }
-                    "^" -> asmgen.out(" lda  $otherName |  eor  $name |  sta  $name")
-                    "|" -> asmgen.out(" lda  $otherName |  ora  $name |  sta  $name")
+                    "^" -> asmgen.out("  lda  $otherName |  eor  $name |  sta  $name")
+                    "|" -> asmgen.out("  lda  $otherName |  ora  $name |  sta  $name")
                     else -> throw AssemblyError("invalid operator for in-place modification $operator")
                 }
             }
@@ -1022,8 +1118,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 // the value is a proper 16-bit word, so use both bytes of it.
                 when (operator) {
                     // note: ** (power) operator requires floats.
-                    "+" -> asmgen.out(" lda  $name |  clc |  adc  $otherName |  sta  $name |  lda  $name+1 |  adc  $otherName+1 |  sta  $name+1")
-                    "-" -> asmgen.out(" lda  $name |  sec |  sbc  $otherName |  sta  $name |  lda  $name+1 |  sbc  $otherName+1 |  sta  $name+1")
+                    "+" -> asmgen.out("  lda  $name |  clc |  adc  $otherName |  sta  $name |  lda  $name+1 |  adc  $otherName+1 |  sta  $name+1")
+                    "-" -> asmgen.out("  lda  $name |  sec |  sbc  $otherName |  sta  $name |  lda  $name+1 |  sbc  $otherName+1 |  sta  $name+1")
                     "*" -> {
                         asmgen.out("""
                             lda  $otherName
@@ -1100,19 +1196,14 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
     private fun inplaceModification_word_value_to_variable(name: String, dt: DataType, operator: String, value: Expression) {
         // this should be the last resort for code generation for this,
         // because the value is evaluated onto the eval stack (=slow).
-        if(asmgen.options.slowCodegenWarnings)
-            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-        asmgen.translateExpression(value)
 
         val valueiDt = value.inferType(program)
         if(!valueiDt.isKnown)
             throw AssemblyError("unknown dt")
         val valueDt = valueiDt.typeOrElse(DataType.STRUCT)
 
-        fun multiplyWord() {
+        fun multiplyVarByWordInAY() {
             asmgen.out("""
-                lda  P8ESTACK_LO+1,x
-                ldy  P8ESTACK_HI+1,x
                 sta  P8ZP_SCRATCH_W1
                 sty  P8ZP_SCRATCH_W1+1
                 lda  $name
@@ -1125,49 +1216,36 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             """)
         }
 
-        fun divideWord() {
-            if (dt == DataType.WORD) {
-                asmgen.out("""
+        fun divideVarByWordInAY() {
+            asmgen.out("""
+                    pha
                     lda  $name
-                    ldy  $name+1
                     sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  P8ESTACK_LO+1,x
-                    ldy  P8ESTACK_HI+1,x
-                    jsr  math.divmod_w_asm
-                    sta  $name
-                    sty  $name+1
-                """)
-            } else {
-                asmgen.out("""
-                    lda  $name
-                    ldy  $name+1
-                    sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  P8ESTACK_LO+1,x
-                    ldy  P8ESTACK_HI+1,x
-                    jsr  math.divmod_uw_asm
-                    sta  $name
-                    sty  $name+1
-                """)
-            }
+                    lda  $name+1
+                    sta  P8ZP_SCRATCH_W1+1
+                    pla""")
+            if (dt == DataType.WORD)
+                asmgen.out("  jsr  math.divmod_w_asm")
+            else
+                asmgen.out("  jsr  math.divmod_uw_asm")
+            asmgen.out("  sta  $name |  sty  $name+1")
         }
 
-        fun remainderWord() {
+        fun remainderVarByWordInAY() {
             if(dt==DataType.WORD)
                 throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
             asmgen.out("""
+                pha
                 lda  $name
-                ldy  $name+1
                 sta  P8ZP_SCRATCH_W1
-                sty  P8ZP_SCRATCH_W1+1
-                lda  P8ESTACK_LO+1,x
-                ldy  P8ESTACK_HI+1,x
+                lda  $name+1
+                sta  P8ZP_SCRATCH_W1+1
+                pla
                 jsr  math.divmod_uw_asm
                 lda  P8ZP_SCRATCH_W2
+                ldy  P8ZP_SCRATCH_W2+1
                 sta  $name
-                lda  P8ZP_SCRATCH_W2+1
-                sta  $name+1
+                sty  $name+1
             """)
         }
 
@@ -1177,11 +1255,12 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 when (operator) {
                     // note: ** (power) operator requires floats.
                     "+" -> {
+                        asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_B1", valueDt, null)
                         if(valueDt==DataType.UBYTE)
                             asmgen.out("""
                                 lda  $name
                                 clc
-                                adc  P8ESTACK_LO+1,x
+                                adc  P8ZP_SCRATCH_B1
                                 sta  $name
                                 bcc  +
                                 inc  $name+1
@@ -1189,7 +1268,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         else
                             asmgen.out("""
                                 ldy  #0
-                                lda  P8ESTACK_LO+1,x
+                                lda  P8ZP_SCRATCH_B1
                                 bpl  +
                                 dey         ; sign extend
 +                               clc
@@ -1200,25 +1279,26 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                 sta  $name+1""")
                     }
                     "-" -> {
+                        asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_REG", valueDt, null)
                         if(valueDt==DataType.UBYTE)
                             asmgen.out("""
                                 lda  $name
                                 sec
-                                sbc  P8ESTACK_LO+1,x
+                                sbc  P8ZP_SCRATCH_REG
                                 sta  $name
-                                bcc  +
+                                bcs  +
                                 dec  $name+1
 +""")
                         else
                             asmgen.out("""
                                 ldy  #0
-                                lda  P8ESTACK_LO+1,x
+                                lda  P8ZP_SCRATCH_REG
                                 bpl  +
                                 dey         ; sign extend
 +                               sty  P8ZP_SCRATCH_B1
                                 lda  $name
                                 sec
-                                sbc  P8ESTACK_LO+1,x
+                                sbc  P8ZP_SCRATCH_REG
                                 sta  $name
                                 lda  $name+1
                                 sbc  P8ZP_SCRATCH_B1
@@ -1226,22 +1306,28 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     }
                     "*" -> {
                         // stack contains (u) byte value, sign extend that and proceed with regular 16 bit operation
-                        asmgen.signExtendStackLsb(valueDt)
-                        multiplyWord()
+                        // TODO use an optimized word * byte multiplication routine
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                        asmgen.signExtendAYlsb(valueDt)
+                        multiplyVarByWordInAY()
                     }
                     "/" -> {
                         // stack contains (u) byte value, sign extend that and proceed with regular 16 bit operation
-                        asmgen.signExtendStackLsb(valueDt)
-                        divideWord()
+                        // TODO use an optimized word / byte divmod routine
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                        asmgen.signExtendAYlsb(valueDt)
+                        divideVarByWordInAY()
                     }
                     "%" -> {
                         // stack contains (u) byte value, sign extend that and proceed with regular 16 bit operation
-                        asmgen.signExtendStackLsb(valueDt)
-                        remainderWord()
+                        // TODO use an optimized word / byte divmod routine
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                        asmgen.signExtendAYlsb(valueDt)
+                        remainderVarByWordInAY()
                     }
                     "<<" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.Y)
                         asmgen.out("""
-                            ldy  P8ESTACK_LO+1,x
                             beq  +
 -                   	    asl  $name
                             rol  $name+1
@@ -1250,18 +1336,17 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 +""")
                     }
                     ">>" -> {
-                        if(dt==DataType.UWORD) {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.Y)
+                        if(dt==DataType.UWORD)
                             asmgen.out("""
-                            ldy  P8ESTACK_LO+1,x
                             beq  +
 -                           lsr  $name+1
                             ror  $name
                             dey
                             bne  -
-+""") }
-                        else {
++""")
+                        else
                             asmgen.out("""
-                            ldy  P8ESTACK_LO+1,x
                             beq  +
 -                           lda  $name+1
                             asl  a
@@ -1270,15 +1355,25 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                             dey
                             bne  -
 +""")
-                        }
                     }
                     "&" -> {
-                        asmgen.out("  lda  P8ESTACK_LO+1,x |  and  $name |  sta  $name")
-                        if(dt in WordDatatypes)
-                            asmgen.out(" lda  #0 |  sta  $name+1")
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                        asmgen.out("  and  $name |  sta  $name")
+                        if(dt in WordDatatypes) {
+                            if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                asmgen.out("  stz  $name+1")
+                            else
+                                asmgen.out("  lda  #0 |  sta  $name+1")
+                        }
+                    }
+                    "^" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                        asmgen.out("  eor  $name |  sta  $name")
+                    }
+                    "|" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                        asmgen.out("  ora  $name |  sta  $name")
                     }
-                    "^" -> asmgen.out("  lda  P8ESTACK_LO+1,x |  eor  $name |  sta  $name")
-                    "|" -> asmgen.out("  lda  P8ESTACK_LO+1,x |  ora  $name |  sta  $name")
                     else -> throw AssemblyError("invalid operator for in-place modification $operator")
                 }
             }
@@ -1286,33 +1381,48 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 // the value is a proper 16-bit word, so use both bytes of it.
                 when (operator) {
                     // note: ** (power) operator requires floats.
-                    "+" -> asmgen.out(" lda  $name |  clc |  adc  P8ESTACK_LO+1,x |  sta  $name |  lda  $name+1 |  adc  P8ESTACK_HI+1,x |  sta  $name+1")
-                    "-" -> asmgen.out(" lda  $name |  sec |  sbc  P8ESTACK_LO+1,x |  sta  $name |  lda  $name+1 |  sbc  P8ESTACK_HI+1,x |  sta  $name+1")
-                    "*" -> multiplyWord()
-                    "/" -> divideWord()
-                    "%" -> remainderWord()
+                    "+" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        asmgen.out("  clc |  adc  $name |  sta  $name |  tya |  adc  $name+1 |  sta  $name+1")
+                    }
+                    "-" -> {
+                        asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_W1", valueDt, null)
+                        asmgen.out(" lda  $name |  sec |  sbc  P8ZP_SCRATCH_W1 |  sta  $name |  lda  $name+1 |  sbc  P8ZP_SCRATCH_W1+1 |  sta  $name+1")
+                    }
+                    "*" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        multiplyVarByWordInAY()
+                    }
+                    "/" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        divideVarByWordInAY()
+                    }
+                    "%" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        remainderVarByWordInAY()
+                    }
                     "<<", ">>" -> throw AssemblyError("shift by a word value not supported, max is a byte")
-                    "&" -> asmgen.out(" lda  $name |  and  P8ESTACK_LO+1,x |  sta  $name | lda  $name+1 |  and  P8ESTACK_HI+1,x  |  sta  $name+1")
-                    "^" -> asmgen.out(" lda  $name |  eor  P8ESTACK_LO+1,x |  sta  $name | lda  $name+1 |  eor  P8ESTACK_HI+1,x  |  sta  $name+1")
-                    "|" -> asmgen.out(" lda  $name |  ora  P8ESTACK_LO+1,x |  sta  $name | lda  $name+1 |  ora  P8ESTACK_HI+1,x  |  sta  $name+1")
+                    "&" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        asmgen.out("  and  $name |  sta  $name |  tya |  and  $name+1 |  sta  $name+1")
+                    }
+                    "^" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        asmgen.out("  eor  $name |  sta  $name |  tya |  eor  $name+1 |  sta  $name+1")
+                    }
+                    "|" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        asmgen.out("  ora  $name |  sta  $name |  tya |  ora  $name+1 |  sta  $name+1")
+                    }
                     else -> throw AssemblyError("invalid operator for in-place modification $operator")
                 }
             }
-            else -> {
-                throw AssemblyError("can only use integer datatypes here")
-            }
+            else -> throw AssemblyError("can only use integer datatypes here")
         }
-
-        asmgen.out(" inx")
     }
 
     private fun inplaceModification_float_value_to_variable(name: String, operator: String, value: Expression, scope: Subroutine) {
-        // this should be the last resort for code generation for this,
-        // because the value is evaluated onto the eval stack (=slow).
-        if(asmgen.options.slowCodegenWarnings)
-            println("warning: slow stack evaluation used (2):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-        asmgen.translateExpression(value)
-        asmgen.out("  jsr  floats.pop_float_fac1")
+        asmgen.assignExpressionToRegister(value, RegisterOrPair.FAC1)
         asmgen.saveRegister(CpuRegister.X, false, scope)
         when (operator) {
             "**" -> {
@@ -1592,16 +1702,14 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                     asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
                             }
                             else -> {
-                                if(asmgen.options.slowCodegenWarnings)
-                                    println("warning: slow stack evaluation used (6): ${mem.addressExpression::class.simpleName} at ${mem.addressExpression.position}") // TODO
-                                asmgen.translateExpression(mem.addressExpression)
+                                asmgen.assignExpressionToVariable(mem.addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, target.scope)
                                 asmgen.out("""
-                                    jsr  prog8_lib.read_byte_from_address_on_stack
+                                    ldy  #0
+                                    lda  (P8ZP_SCRATCH_W2),y
                                     beq  +
                                     lda  #1
 +                                   eor  #1                                    
-                                    jsr  prog8_lib.write_byte_to_address_on_stack
-                                    inx""")
+                                    sta  (P8ZP_SCRATCH_W2),y""")
                             }
                         }
                     }
@@ -1662,14 +1770,12 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                     asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
                             }
                             else -> {
-                                if(asmgen.options.slowCodegenWarnings)
-                                    println("warning: slow stack evaluation used (7): ${memory.addressExpression::class.simpleName} at ${memory.addressExpression.position}") // TODO
-                                asmgen.translateExpression(memory.addressExpression)
+                                asmgen.assignExpressionToVariable(memory.addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, target.scope)
                                 asmgen.out("""
-                                    jsr  prog8_lib.read_byte_from_address_on_stack
+                                    ldy  #0
+                                    lda  (P8ZP_SCRATCH_W2),y
                                     eor  #255
-                                    jsr  prog8_lib.write_byte_to_address_on_stack
-                                    inx""")
+                                    sta  (P8ZP_SCRATCH_W2),y""")
                             }
                         }
                     }

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -130,9 +130,9 @@ private val functionSignatures: List<FSignature> = listOf(
     FSignature("lsb"         , true, listOf(FParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> x and 255 }},
     FSignature("msb"         , 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}},
     FSignature("mkword"      , true, listOf(FParam("msb", setOf(DataType.UBYTE)), FParam("lsb", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinMkword),
-    FSignature("rnd"         , true, emptyList(), DataType.UBYTE),
-    FSignature("rndw"        , true, emptyList(), DataType.UWORD),
-    FSignature("rndf"        , true, emptyList(), DataType.FLOAT),
+    FSignature("rnd"         , false, emptyList(), DataType.UBYTE),
+    FSignature("rndw"        , false, emptyList(), DataType.UWORD),
+    FSignature("rndf"        , false, emptyList(), DataType.FLOAT),
     FSignature("exit"        , false, listOf(FParam("returnvalue", setOf(DataType.UBYTE))), null),
     FSignature("rsave"       , false, emptyList(), null),
     FSignature("rrestore"    , false, emptyList(), null),

compiler/src/prog8/optimizer/BinExprSplitter.kt

@@ -79,7 +79,7 @@ X =      BinExpr                                    X   =   LeftExpr
             expr is IdentifierReference || expr is NumericLiteralValue || expr is AddressOf || expr is DirectMemoryRead || expr is StringLiteralValue || expr is ArrayLiteralValue || expr is RangeExpr
 
     private fun isSimpleTarget(target: AssignTarget, namespace: INameScope) =
-            if (target.identifier!=null || target.memoryAddress!=null || target.arrayindexed!=null)
+            if (target.identifier!=null || target.memoryAddress!=null)
                 target.isInRegularRAM(namespace)
             else
                 false

docs/source/building.rst

@@ -93,6 +93,8 @@ Almost instant compilation times (less than a second) can be achieved when using
 Start the compiler with the ``-watch`` argument to enable this.
 It will compile your program and then instead of exiting, it waits for any changes in the module source files.
 As soon as a change happens, the program gets compiled again.
+It is possible to use the watch mode with multiple modules as well, but it will
+recompile everything in that list even if only of the files got updated.
 
 Other options
 ^^^^^^^^^^^^^

docs/source/index.rst

@@ -38,6 +38,27 @@ This software is licensed under the GNU GPL 3.0, see https://www.gnu.org/license
     :alt: Fully playable tetris clone
 
 
+Language 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.
+- 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 this emulator.
+- Based on simple and familiar imperative structured programming (it looks like a mix of C and Python)
+- Modular programming and scoping via modules, code blocks, and subroutines.
+- Provide high level programming constructs but at the same time stay close to the metal;
+  still able to directly use memory addresses and ROM subroutines,
+  and inline assembly to have full control when every register, cycle or byte matters
+- Arbitrary number of subroutine parameters, Complex nested expressions are possible
+- No stack frame allocations because parameters and local variables are automatically allocated statically
+- Nested subroutines can access variables from outer scopes to avoids the overhead to pass everything via parameters
+- Variable data types include signed and unsigned bytes and words, arrays, strings and floats.
+- High-level code optimizations, such as const-folding, expression and statement simplifications/rewriting.
+- 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)
+- If you only use standard kernel and prog8 library routines, it is possible to compile the *exact same program* for both machines (just change the compiler target flag)!
+
+
 Code example
 ------------
 
@@ -104,37 +125,6 @@ when the exact same program is compiled for the Commander X16 target, and run on
 
 
 
-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.
-- 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 at the same time stay close to the metal;
-  still able to directly use memory addresses and ROM subroutines,
-  and inline assembly to have full control when every register, cycle or byte matters
-- Arbitrary number of subroutine parameters
-- Complex nested expressions are possible
-- 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 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 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``, ``substr``, ``sort`` and ``reverse`` (and others)
-- Assembling the generated code into a program wil be done by an external cross-assembler tool.
-- If you only use standard kernel and prog8 library routines, it is possible to compile the *exact same program* for both machines (just change the compiler target flag)!
-
-
 .. _requirements:
 
 Required tools
@@ -143,14 +133,17 @@ Required tools
 `64tass <https://sourceforge.net/projects/tass64/>`_ - cross assembler. Install this on your shell path.
 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.
+*You need at least version 1.55.2257 of this assembler to correctly use the breakpoints feature.*
+It's possible to use older versions, but it is very likely that the automatic Vice breakpoints won't work with them.
 
-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/>`_ .
+A **Java runtime (jre or jdk), version 11 or newer**  is required to run the prog8 compiler itself.
+If you're scared of Oracle's licensing terms, most Linux distributions ship OpenJDK in their packages repository instead.
+For Windows it's possible to get that as well; check out `AdoptOpenJDK <https://adoptopenjdk.net/>`_ .
+For MacOS you can use the Homebrew system to install a recent version of OpenJDK.
 
-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/>`_.
-If you're targeting the CommanderX16, there's the `x16emu <https://github.com/commanderx16/x16-emulator>`_.
+Finally: an **emulator** (or a real machine ofcourse) to test and run your programs on.
+In C64 mode, thhe compiler assumes the presence of the `Vice emulator <http://vice-emu.sourceforge.net/>`_.
+If you're targeting the CommanderX16 instead, there's the `x16emu <https://github.com/commanderx16/x16-emulator>`_.
 
 .. important::
     **Building the compiler itself:** (*Only needed if you have not downloaded a pre-built 'fat-jar'*)

docs/source/libraries.rst

@@ -54,7 +54,8 @@ diskio
 ------
 Provides several routines that deal with disk drive I/O, such as:
 
-- show directory
+- list files on disk, optionally filtering by prefix or suffix
+- show disk directory as-is
 - display disk drive status
 - load and save data from and to the disk
 - delete and rename files on the disk
@@ -88,6 +89,15 @@ A 'fun' module that contains the Commander X16 logo and that allows you
 to print it anywhere on the screen.
 
 
+c64colors
+---------
+Available for the CommanderX16 target, a module that contains a few better
+color palettes for how the colors of the VIC-II looked on the Commodore-64.
+There are subroutines to activate one of the several palettes of your liking.
+The Commander X16's default colors for this (the first 16 colors) are too saturated
+and are quite different than how a C-64 looked.
+
+
 prog8_lib
 ---------
 Low level language support. You should not normally have to bother with this directly.

docs/source/programming.rst

@@ -309,18 +309,21 @@ read the syntax reference on strings.
 
 
 .. hint::
-    Strings and uwords (=memory address) can often be interchanged.
+    Strings/arrays and uwords (=memory address) can often be interchanged.
     An array of strings is actually an array of uwords where every element is the memory
     address of the string. You can pass a memory address to assembly functions
     that require a string as an argument.
+    For regular assignments you still need to use an explicit ``&`` (address-of) to take
+    the address of the string or array.
 
 .. caution::
-    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
+    It's probably best to avoid changing the contents in strings and treat them as static.
+    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!
-    The same is true for arrays.
+    This is because the changes persist in memory. If your program exits and is restarted
+    (without reloading it from disk), it will then start working with the modified strings
+    instead of the original ones!
+    The same is true for arrays! So be careful to (re)initialize them if needed.
 
 
 Structs

docs/source/todo.rst

@@ -2,10 +2,11 @@
 TODO
 ====
 
-- 64tass doesn't output all labels anymore in the vice-mon-list, so %breakpoint labels are no longer present....
+- see if we can group some errors together for instance the (now single) errors about unidentified symbols
+- Cx16 target: support full-screen 640x480 and 320x240 graphics? That requires our own custom graphics routines though to draw lines.
+- hoist all variable declarations up to the subroutine scope *before* even the constant folding takes place (to avoid undefined symbol errors when referring to a variable from another nested scope in the subroutine)
 - make it possible to use cpu opcodes such as 'nop' as variable names by prefixing all asm vars with something such as '_'
 - option to load the built-in library files from a directory instead of the embedded ones (for easier library development/debugging)
-- see if we can group some errors together for instance the (now single) errors about unidentified symbols
 - use VIC banking to move up the graphics bitmap memory location. Move it to $e000 under the kernal rom?
 - some support for recursive subroutines?
     - via %option recursive?: allocate all params and local vars on estack, don't allow nested subroutines, can begin by first not allowing any local variables just fixing the parameters

examples/arithmetic/builtins.p8

@@ -1,6 +1,7 @@
 %import textio
 %import floats
 %import syslib
+%import test_stack
 %zeropage basicsafe
 
 main {
@@ -11,7 +12,7 @@ main {
         integers()
         floatingpoint()
 
-        testX()
+        test_stack.test()
     }
 
     sub rotations() {
@@ -251,8 +252,7 @@ main {
         txt.chrout('\n')
         txt.chrout('\n')
 
-
-        testX()
+        test_stack.test()
 
     }
 
@@ -324,7 +324,7 @@ main {
         txt.print(result)
         txt.chrout('\n')
 
-        testX()
+        test_stack.test()
 
     }
 
@@ -643,7 +643,7 @@ main {
         reverse(uwarr)
         reverse(warr)
 
-        testX()
+        test_stack.test()
     }
 
     sub floatingpoint() {
@@ -831,36 +831,6 @@ main {
         floats.print_f(fl)
         txt.chrout('\n')
 
-        testX()
-    }
-
-    asmsub testX() {
-        %asm {{
-            stx  _saveX
-            lda  #13
-            jsr  txt.chrout
-            lda  #'x'
-            jsr  txt.chrout
-            lda  #'='
-            jsr  txt.chrout
-            lda  _saveX
-            jsr  txt.print_ub
-            lda  #' '
-            jsr  txt.chrout
-            lda  #'s'
-            jsr  txt.chrout
-            lda  #'p'
-            jsr  txt.chrout
-            lda  #'='
-            jsr  txt.chrout
-            tsx
-            txa
-            jsr  txt.print_ub
-            lda  #13
-            jsr  txt.chrout
-            ldx  _saveX
-            rts
-_saveX   .byte 0
-        }}
+        test_stack.test()
     }
 }

examples/arithmetic/minus.p8

@@ -1,5 +1,6 @@
 %import floats
 %import textio
+%import test_stack
 %zeropage basicsafe
 
 main {
@@ -31,6 +32,8 @@ main {
         minus_float(0,0,0)
         minus_float(2.5,1.5,1.0)
         minus_float(-1.5,3.5,-5.0)
+
+        test_stack.test()
     }
 
     sub minus_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -97,10 +100,11 @@ main {
         float r = a1-a2
         if abs(r-c)<0.00001
             txt.print(" ok  ")
-        else
+        else {
             txt.print("err! ")
+        }
 
-        txt.print("float ")
+        txt.print("  float ")
         floats.print_f(a1)
         txt.print(" - ")
         floats.print_f(a2)

examples/balloonflight.p8

@@ -1,6 +1,7 @@
 %target c64
 %import syslib
 %import textio
+%import test_stack
 %zeropage basicsafe
 
 main {
@@ -16,13 +17,16 @@ main {
 
         c64.SCROLX &= %11110111     ; 38 column mode
 
-        c64.set_rasterirq(1)     ; enable animation
+        c64.set_rasterirq(40)     ; enable animation
 
         ubyte target_height = 10
         ubyte active_height = 24
         ubyte upwards = true
 
         repeat {
+            ;txt.plot(0,0)
+            ;test_stack.test()
+
             ubyte mountain = 223        ; slope upwards
             if active_height < target_height {
                 active_height++

examples/balls.p8

@@ -0,0 +1,103 @@
+%import textio
+%import test_stack
+
+%zeropage basicsafe
+
+; Note: this program is compatible with C64 and CX16.
+
+main {
+
+    sub start() {
+        str  input = ".........."
+        ubyte ballCount
+        ubyte[255] BX
+        ubyte[255] BY
+        ubyte[255] BC
+        ubyte[255] DX
+        ubyte[255] DY
+
+        txt.print("number of balls (1-255)? ")
+        void txt.input_chars(input)
+        ballCount = conv.str2ubyte(input)
+        txt.fill_screen(81, 0)
+
+        ; Setup Starting Ball Positions
+        ubyte lp
+        for lp in 0 to ballCount-1 {
+            BX[lp] = rnd() % txt.DEFAULT_WIDTH
+            BY[lp] = rnd() % txt.DEFAULT_HEIGHT
+            BC[lp] = rnd() & 15
+            DX[lp] = rnd() & 1
+            DY[lp] = rnd() & 1
+            void rnd()
+        }
+
+        ; start clock
+        c64.SETTIM(0,0,0)
+
+        ; display balls
+        uword frame
+        for frame in 0 to 999 {
+            ; Loop though all balls clearing current spot and setting new spot
+            for lp in 0 to ballCount-1 {
+
+                ; Clear existing Location the ball is at
+                txt.setclr(BX[lp], BY[lp], 0)
+
+                if DX[lp] == 0 {
+                    if (BX[lp] == 0)
+                    {
+                        DX[lp] = 1
+                    } else {
+                        BX[lp]=BX[lp]-1
+                    }
+                } else if DX[lp] == 1 {
+                    if (BX[lp] == txt.DEFAULT_WIDTH-1)
+                    {
+                        BX[lp] = txt.DEFAULT_WIDTH-2
+                        DX[lp] = 0
+                    } else {
+                        BX[lp]=BX[lp]+1
+                    }
+                }
+                if DY[lp] == 0 {
+                    if (BY[lp] == 0)
+                    {
+                        DY[lp] = 1
+                    } else {
+                        BY[lp]=BY[lp]-1
+                    }
+                } else if DY[lp] == 1 {
+                    if (BY[lp] == txt.DEFAULT_HEIGHT-1)
+                    {
+                        BY[lp] = txt.DEFAULT_HEIGHT-2
+                        DY[lp] = 0
+                    } else {
+                        BY[lp]=BY[lp]+1
+                    }
+                }
+
+                ; Put the new ball possition
+                txt.setclr(BX[lp], BY[lp], BC[lp])
+            }
+
+            ;txt.plot(0,0)
+            ;txt.print_uw(frame)
+        }
+
+        ; read clock
+        uword jiffies
+        %asm {{
+            stx  P8ZP_SCRATCH_REG
+            jsr  c64.RDTIM
+            sta  jiffies
+            stx  jiffies+1
+            ldx  P8ZP_SCRATCH_REG
+        }}
+        txt.print("\nbenchmark: ")
+        txt.print_uw(jiffies)
+        txt.print(" jiffies for 1000 frames.\n")
+
+        ; test_stack.test()
+    }
+}

examples/cmp/word_comps.p8

@@ -0,0 +1,913 @@
+%import textio
+%import floats
+%zeropage basicsafe
+%import test_stack
+
+main {
+
+    sub start() {
+        word_less()
+        word_lessequal()
+        word_greaterequal()
+        word_greater()
+        uword_lessequal()
+    }
+
+    sub uword_lessequal() {
+        uword lessvar
+        uword comparevar
+
+        txt.print("uword <=\n")
+
+        txt.print_uw(65535)
+        txt.chrout('\n')
+        check_lesseq_uw(0, 65535)
+        txt.print_uw(0)
+        txt.chrout('\n')
+        check_not_lesseq_uw(65535, 0)
+
+        comparevar = 65535
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto 0  {
+            check_lesseq_uw(lessvar, comparevar)
+        }
+
+        comparevar = 65535-2
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto 0  {
+            check_lesseq_uw(lessvar, comparevar)
+        }
+
+        comparevar = 65535-254
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto 0  {
+            check_lesseq_uw(lessvar, comparevar)
+        }
+
+        comparevar = 65535-255
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto 0  {
+            check_lesseq_uw(lessvar, comparevar)
+        }
+
+        comparevar = 65535-256
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto 0  {
+            check_lesseq_uw(lessvar, comparevar)
+        }
+
+        comparevar = 65535-5000
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto 0  {
+            check_lesseq_uw(lessvar, comparevar)
+        }
+
+        comparevar = 32769
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto 0  {
+            check_lesseq_uw(lessvar, comparevar)
+        }
+
+
+        comparevar = 32768
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in 65535 downto comparevar+1  {
+            check_not_lesseq_uw(lessvar, comparevar)
+        }
+
+        comparevar = 1
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in 65535 downto comparevar+1  {
+            check_not_lesseq_uw(lessvar, comparevar)
+        }
+
+        comparevar = 0
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in 65535 downto comparevar+1  {
+            check_not_lesseq_uw(lessvar, comparevar)
+        }
+
+        comparevar = 11111
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in 65535 downto comparevar+1  {
+            check_not_lesseq_uw(lessvar, comparevar)
+        }
+
+        comparevar = 255
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in 65535 downto comparevar+1  {
+            check_not_lesseq_uw(lessvar, comparevar)
+        }
+
+        comparevar = 256
+        txt.print_uw(comparevar)
+        txt.chrout('\n')
+        for lessvar in 65535 downto comparevar+1  {
+            check_not_lesseq_uw(lessvar, comparevar)
+        }
+
+
+        test_stack.test()
+        return
+
+        sub check_lesseq_uw(uword w1, uword w2) {
+            uword zero = 0
+            ubyte error=0
+
+            ubyte ub = w1<=w2
+            if not ub {
+                error++
+                txt.print("ub!")
+            }
+
+            if w1<=(w2+zero) {
+                zero = 0 ; dummy
+            } else {
+                error++
+                txt.print("c!")
+            }
+
+            if error {
+                txt.print("  ")
+                txt.print_uw(w1)
+                txt.print(" <= ")
+                txt.print_uw(w2)
+                txt.chrout('\n')
+                exit(1)
+            }
+        }
+
+        sub check_not_lesseq_uw(uword w1, uword w2) {
+            uword zero = 0
+            ubyte error=0
+
+            ubyte ub = w1<=w2
+            if ub {
+                error++
+                txt.print("ub!")
+            }
+
+            if w1<=(w2+zero) {
+                error++
+                txt.print("c!")
+            } else {
+                zero = 0 ; dummy
+            }
+
+            if error {
+                txt.print("  ")
+                txt.print_uw(w1)
+                txt.print(" not <= ")
+                txt.print_uw(w2)
+                txt.chrout('\n')
+                exit(1)
+            }
+        }
+    }
+
+    sub word_greater() {
+        word biggervar
+        word comparevar
+
+        txt.print("word >\n")
+
+        txt.print_w(-32767)
+        txt.chrout('\n')
+        check_greater_w(32767, -32767)
+        txt.print_w(32766)
+        txt.chrout('\n')
+        check_not_greater_w(-32766, 32766)
+
+        comparevar = 32765
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in comparevar downto -32768  {
+            check_not_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = -1
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in comparevar downto -32768  {
+            check_not_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = 0
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in comparevar downto -32768  {
+            check_not_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = 11111
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in comparevar downto -32768  {
+            check_not_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = 0
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar+1  {
+            check_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = -2
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar+1  {
+            check_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = -254
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar+1  {
+            check_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = -255
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar+1  {
+            check_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = -256
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar+1  {
+            check_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = -5000
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar+1  {
+            check_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = 1
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar+1  {
+            check_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = 255
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar+1  {
+            check_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = 256
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar+1  {
+            check_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = 257
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar+1  {
+            check_greater_w(biggervar, comparevar)
+        }
+
+        comparevar = 32760
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar+1  {
+            check_greater_w(biggervar, comparevar)
+        }
+
+
+        test_stack.test()
+        return
+
+        sub check_greater_w(word w1, word w2) {
+            word zero = 0
+            ubyte error=0
+
+            ubyte ub = w1>(w2+zero)
+            if not ub {
+                error++
+                txt.print("ubz!")
+            }
+
+            ub = w1>w2
+            if not ub {
+                error++
+                txt.print("ub!")
+            }
+
+            if w1>(w2+zero) {
+                zero = 0 ; dummy
+            } else {
+                error++
+                txt.print("c!")
+            }
+
+            if error {
+                txt.print("  ")
+                txt.print_w(w1)
+                txt.print(" > ")
+                txt.print_w(w2)
+                txt.chrout('\n')
+                exit(1)
+            }
+        }
+
+        sub check_not_greater_w(word w1, word w2) {
+            word zero = 0
+            ubyte error=0
+
+            ubyte ub = w1>w2
+            if ub {
+                error++
+                txt.print("ub!")
+            }
+
+            if w1>(w2+zero) {
+                error++
+                txt.print("c!")
+            } else {
+                zero = 0 ; dummy
+            }
+
+            if w1>w2 {
+                error++
+                txt.print("c2!")
+            } else {
+                zero = 0 ; dummy
+            }
+
+            if error {
+                txt.print("  ")
+                txt.print_w(w1)
+                txt.print(" not > ")
+                txt.print_w(w2)
+                txt.chrout('\n')
+                exit(1)
+            }
+        }
+    }
+
+    sub word_greaterequal() {
+        word biggervar
+        word comparevar
+
+        txt.print("word >=\n")
+
+        txt.print_w(-32767)
+        txt.chrout('\n')
+        check_greatereq_w(32767, -32767)
+        txt.print_w(32766)
+        txt.chrout('\n')
+        check_not_greatereq_w(-32766, 32766)
+
+        comparevar = 32765
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in comparevar-1 downto -32768  {
+            check_not_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = -1
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in comparevar-1 downto -32768  {
+            check_not_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = 0
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in comparevar-1 downto -32768  {
+            check_not_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = 11111
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in comparevar-1 downto -32768  {
+            check_not_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = 0
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar  {
+            check_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = -2
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar  {
+            check_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = -254
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar  {
+            check_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = -255
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar  {
+            check_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = -256
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar  {
+            check_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = -5000
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar  {
+            check_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = 1
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar  {
+            check_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = 255
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar  {
+            check_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = 256
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar  {
+            check_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = 257
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar  {
+            check_greatereq_w(biggervar, comparevar)
+        }
+
+        comparevar = 32767
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for biggervar in 32767 downto comparevar  {
+            check_greatereq_w(biggervar, comparevar)
+        }
+
+
+        test_stack.test()
+        return
+
+        sub check_greatereq_w(word w1, word w2) {
+            word zero = 0
+            ubyte error=0
+
+            ubyte ub = w1>=(w2+zero)
+            if not ub {
+                error++
+                txt.print("ubz!")
+            }
+
+            ub = w1>=w2
+            if not ub {
+                error++
+                txt.print("ub!")
+            }
+
+            if w1>=(w2+zero) {
+                zero = 0 ; dummy
+            } else {
+                error++
+                txt.print("c!")
+            }
+
+            if error {
+                txt.print("  ")
+                txt.print_w(w1)
+                txt.print(" >= ")
+                txt.print_w(w2)
+                txt.chrout('\n')
+                exit(1)
+            }
+        }
+
+        sub check_not_greatereq_w(word w1, word w2) {
+            word zero = 0
+            ubyte error=0
+
+            ubyte ub = w1>=w2
+            if ub {
+                error++
+                txt.print("ub!")
+            }
+
+            if w1>=(w2+zero) {
+                error++
+                txt.print("c!")
+            } else {
+                zero = 0 ; dummy
+            }
+
+            if w1>=w2 {
+                error++
+                txt.print("c2!")
+            } else {
+                zero = 0 ; dummy
+            }
+
+            if error {
+                txt.print("  ")
+                txt.print_w(w1)
+                txt.print(" not >= ")
+                txt.print_w(w2)
+                txt.chrout('\n')
+                exit(1)
+            }
+        }
+    }
+
+    sub word_lessequal() {
+        word lessvar
+        word comparevar
+
+        txt.print("word <=\n")
+
+        txt.print_w(32767)
+        txt.chrout('\n')
+        check_lesseq_w(-32767, 32767)
+        txt.print_w(-32767)
+        txt.chrout('\n')
+        check_not_lesseq_w(32767, -32767)
+
+        comparevar = 0
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto -32768  {
+            check_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = -2
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto -32768  {
+            check_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = -254
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto -32768  {
+            check_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = -255
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto -32768  {
+            check_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = -256
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto -32768  {
+            check_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = -5000
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto -32768  {
+            check_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = 1
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto -32768  {
+            check_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = 255
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto -32768  {
+            check_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = 256
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto -32768  {
+            check_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = 257
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto -32768  {
+            check_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = 32767
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in comparevar downto -32768  {
+            check_lesseq_w(lessvar, comparevar)
+        }
+
+
+        comparevar = -32768
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 32766 downto comparevar+1  {
+            check_not_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = -1
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 32766 downto comparevar+1  {
+            check_not_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = 0
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 32766 downto comparevar+1  {
+            check_not_lesseq_w(lessvar, comparevar)
+        }
+
+        comparevar = 11111
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 32766 downto comparevar+1  {
+            check_not_lesseq_w(lessvar, comparevar)
+        }
+
+        test_stack.test()
+        return
+
+        sub check_lesseq_w(word w1, word w2) {
+            word zero = 0
+            ubyte error=0
+
+            ubyte ub = w1<=w2
+            if not ub {
+                error++
+                txt.print("ub!")
+            }
+
+            if w1<=(w2+zero) {
+                zero = 0 ; dummy
+            } else {
+                error++
+                txt.print("c!")
+            }
+
+            if error {
+                txt.print("  ")
+                txt.print_w(w1)
+                txt.print(" <= ")
+                txt.print_w(w2)
+                txt.chrout('\n')
+                exit(1)
+            }
+        }
+
+        sub check_not_lesseq_w(word w1, word w2) {
+            word zero = 0
+            ubyte error=0
+
+            ubyte ub = w1<=w2
+            if ub {
+                error++
+                txt.print("ub!")
+            }
+
+            if w1<=(w2+zero) {
+                error++
+                txt.print("c!")
+            } else {
+                zero = 0 ; dummy
+            }
+
+            if error {
+                txt.print("  ")
+                txt.print_w(w1)
+                txt.print(" not <= ")
+                txt.print_w(w2)
+                txt.chrout('\n')
+                exit(1)
+            }
+        }
+    }
+
+    sub word_less() {
+        word lessvar
+        word comparevar
+
+        txt.print("word <\n")
+
+        txt.print_w(32767)
+        txt.chrout('\n')
+        check_less_w(-32767, 32767)
+        txt.print_w(-32767)
+        txt.chrout('\n')
+        check_not_less_w(32767, -32767)
+
+        comparevar = 0
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in -1 downto -32768  {
+            check_less_w(lessvar, comparevar)
+        }
+
+        comparevar = -2
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in -3 downto -32768  {
+            check_less_w(lessvar, comparevar)
+        }
+
+        comparevar = -254
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in -255 downto -32768  {
+            check_less_w(lessvar, comparevar)
+        }
+
+        comparevar = -255
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in -256 downto -32768  {
+            check_less_w(lessvar, comparevar)
+        }
+
+        comparevar = -256
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in -257 downto -32768  {
+            check_less_w(lessvar, comparevar)
+        }
+
+        comparevar = -5000
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in -5001 downto -32768  {
+            check_less_w(lessvar, comparevar)
+        }
+
+        comparevar = 1
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 0 downto -32768  {
+            check_less_w(lessvar, comparevar)
+        }
+
+        comparevar = 255
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 254 downto -32768  {
+            check_less_w(lessvar, comparevar)
+        }
+
+        comparevar = 256
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 255 downto -32768  {
+            check_less_w(lessvar, comparevar)
+        }
+
+        comparevar = 257
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 256 downto -32768  {
+            check_less_w(lessvar, comparevar)
+        }
+
+        comparevar = 32767
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 32766 downto -32768  {
+            check_less_w(lessvar, comparevar)
+        }
+
+        comparevar = -32768
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 32766 downto -32768  {
+            check_not_less_w(lessvar, comparevar)
+        }
+
+        comparevar = -1
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 32766 downto -1  {
+            check_not_less_w(lessvar, comparevar)
+        }
+
+        comparevar = 0
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 32766 downto 0  {
+            check_not_less_w(lessvar, comparevar)
+        }
+
+        comparevar = 11111
+        txt.print_w(comparevar)
+        txt.chrout('\n')
+        for lessvar in 32766 downto 11111  {
+            check_not_less_w(lessvar, comparevar)
+        }
+
+        test_stack.test()
+        return
+
+        sub check_less_w(word w1, word w2) {
+            word zero = 0
+            ubyte error=0
+
+            ubyte ub = w1<w2
+            if not ub {
+                error++
+                txt.print("ub!")
+            }
+
+            if w1<(w2+zero) {
+                zero = 0 ; dummy
+            } else {
+                error++
+                txt.print("c!")
+            }
+
+            if error {
+                txt.print("  ")
+                txt.print_w(w1)
+                txt.print(" < ")
+                txt.print_w(w2)
+                txt.chrout('\n')
+                exit(1)
+            }
+        }
+
+        sub check_not_less_w(word w1, word w2) {
+            word zero = 0
+            ubyte error=0
+
+            ubyte ub = w1<w2
+            if ub {
+                error++
+                txt.print("ub!")
+            }
+
+            if w1<(w2+zero) {
+                error++
+                txt.print("c!")
+            } else {
+                zero = 0 ; dummy
+            }
+
+            if error {
+                txt.print("  ")
+                txt.print_w(w1)
+                txt.print(" not < ")
+                txt.print_w(w2)
+                txt.chrout('\n')
+                exit(1)
+            }
+        }
+    }
+
+}

examples/cube3d-float.p8

@@ -1,5 +1,6 @@
 %import floats
 %import textio
+%import test_stack
 %zeropage basicsafe
 
 ; Note: this program is compatible with C64 and CX16.
@@ -41,6 +42,8 @@ main {
             txt.print(" jiffies/fr = ")
             txt.print_ub(60/timer_jiffies)
             txt.print(" fps")
+
+            ;test_stack.test()
         }
     }
 

examples/cube3d-gfx.p8

@@ -1,5 +1,6 @@
 %import syslib
 %import graphics
+%import test_stack
 
 ; Note: this program is compatible with C64 and CX16.
 
@@ -37,6 +38,8 @@ main {
             anglez+=452
 
             wait_a_little_bit()
+
+            ; test_stack.test()
         }
     }
 

examples/cube3d-sprites.p8

@@ -1,6 +1,8 @@
 %target c64
 %import syslib
 %import textio
+%import test_stack
+
 
 spritedata $2000 {
     ; this memory block contains the sprite data
@@ -95,6 +97,8 @@ main {
             txt.print(" jiffies/fr = ")
             txt.print_ub(60/c64.TIME_LO)
             txt.print(" fps")
+
+            ; test_stack.test()
         }
     }
 

examples/cube3d.p8

@@ -1,7 +1,9 @@
 %target c64
 %import syslib
+%import test_stack
 %import textio
 
+
 main {
 
     ; vertices
@@ -33,6 +35,8 @@ main {
             txt.print_ub(60/c64.TIME_LO)
             txt.print(" fps")
             c64.TIME_LO=0
+
+            ; test_stack.test()
         }
     }
 

examples/cx16/cobramk3-gfx.p8

@@ -1,5 +1,6 @@
 %target cx16
 %import syslib
+%import test_stack
 %import conv
 
 ; TODO add all other Elite's ships, show their name, advance to next ship on keypress
@@ -41,6 +42,8 @@ main {
             anglex += 217
             angley -= 505
             anglez += 452
+
+            ; test_stack.test()
         }
     }
 

examples/cx16/imgviewer/koalaviewer.p8

@@ -0,0 +1,118 @@
+%target cx16
+%import graphics
+%import textio
+%import diskio
+%import c64colors
+
+main {
+    const uword load_location = $4000
+
+    sub start() {
+
+        str[] pictures = [
+            "i01-blubb-sphinx.bin",
+            "i02-bugjam-jsl.bin",
+            "i03-dinothawr-ar.bin",
+            "i04-fox-leon.bin",
+            "i05-hunter-agod.bin",
+            "i06-jazzman-jds.bin",
+            "i07-katakis-jegg.bin"
+        ]
+
+        ; set a better C64 color palette, the Cx16's default is too saturated
+        c64colors.set_palette_pepto()
+        graphics.enable_bitmap_mode()
+        repeat {
+            ubyte file_idx
+            for file_idx in 0 to len(pictures)-1 {
+                load_image(pictures[file_idx])
+                wait()
+            }
+        }
+    }
+
+    sub wait() {
+        uword jiffies = 0
+        c64.SETTIM(0,0,0)
+
+        while jiffies < 180 {
+            ; read clock
+            %asm {{
+                stx  P8ZP_SCRATCH_REG
+                jsr  c64.RDTIM
+                sta  jiffies
+                stx  jiffies+1
+                ldx  P8ZP_SCRATCH_REG
+            }}
+        }
+    }
+
+    sub load_image(uword filenameptr) {
+        uword length = diskio.load(8, filenameptr, load_location)
+
+        if length != 10001 {
+            txt.print_uw(length)
+            txt.print("\nload error\n")
+            diskio.status(8)
+            exit(1)
+        }
+        convert_koalapic()
+    }
+
+    sub convert_koalapic() {
+        ubyte cy
+        ubyte @zp cx
+        uword @zp cy_times_forty = 0
+        ubyte @zp d
+        uword bitmap_ptr = load_location
+
+        ; theoretically you could put the 8-pixel array in zeropage to squeeze out another tiny bit of performance
+        ubyte[8] pixels
+
+        for cy in 0 to 24*8 step 8 {
+            for cx in 0 to 39 {
+                for d in 0 to 7 {
+                    cx16.r0 = cx as uword * 8
+                    cx16.r1 = cy as uword + d
+                    cx16.FB_cursor_position()
+                    get_8_pixels()
+                    cx16.r0 = &pixels
+                    cx16.r1 = 8
+                    cx16.FB_set_pixels()
+                }
+            }
+            cy_times_forty += 40
+        }
+
+        sub get_8_pixels() {
+            ubyte  bm = @(bitmap_ptr)
+            ubyte  @zp  m = mcol(bm)
+            pixels[7] = m
+            pixels[6] = m
+            bm >>= 2
+            m = mcol(bm)
+            pixels[5] = m
+            pixels[4] = m
+            bm >>= 2
+            m = mcol(bm)
+            pixels[3] = m
+            pixels[2] = m
+            bm >>= 2
+            m = mcol(bm)
+            pixels[1] = m
+            pixels[0] = m
+            bitmap_ptr++
+
+            sub mcol(ubyte b) -> ubyte {
+                ubyte @zp color
+                when b & 3 {
+                    0 -> color = @(load_location + 8000 + 1000 + 1000) & 15
+                    1 -> color = @(load_location + 8000 + cy_times_forty + cx) >>4
+                    2 -> color = @(load_location + 8000 + cy_times_forty + cx) & 15
+                    else -> color = @(load_location + 8000 + 1000 + cy_times_forty + cx) & 15
+                }
+                return color
+            }
+        }
+    }
+}

examples/dirlist.p8

@@ -0,0 +1,53 @@
+%import textio
+%import diskio
+%zeropage basicsafe
+%import test_stack
+%option no_sysinit
+
+main {
+    sub start() {
+
+        if diskio.lf_start_list(8, "cub", false) {
+            txt.print("\nfiles starting with 'cub':\n")
+            while diskio.lf_next_entry() {
+                txt.print(diskio.list_filename)
+                txt.print("  ")
+                txt.print_uw(diskio.list_blocks)
+                txt.print(" blocks\n")
+            }
+            diskio.lf_end_list()
+        } else {
+            txt.print("error\n")
+        }
+
+        if diskio.lf_start_list(8, "gfx", true) {
+            txt.print("\nfiles ending with 'gfx':\n")
+            while diskio.lf_next_entry() {
+                txt.print(diskio.list_filename)
+                txt.print("  ")
+                txt.print_uw(diskio.list_blocks)
+                txt.print(" blocks\n")
+            }
+            diskio.lf_end_list()
+        } else {
+            txt.print("error\n")
+        }
+
+        if diskio.lf_start_list(8, 0, false) {
+            txt.print("\nfirst 10 files:\n")
+            ubyte counter=0
+            while counter < 10 and diskio.lf_next_entry() {
+                txt.print(diskio.list_filename)
+                txt.print("  ")
+                txt.print_uw(diskio.list_blocks)
+                txt.print(" blocks\n")
+                counter++
+            }
+            diskio.lf_end_list()
+        } else {
+            txt.print("error\n")
+        }
+
+        ; test_stack.test()
+    }
+}

examples/line-circle-gfx.p8

@@ -1,4 +1,5 @@
 %import graphics
+%import test_stack
 
 ; Note: this program is compatible with C64 and CX16.
 
@@ -6,8 +7,13 @@ main {
 
     sub start() {
         graphics.enable_bitmap_mode()
+
         draw_lines()
         draw_circles()
+
+        ; graphics.disable_bitmap_mode()
+        ; test_stack.test()
+
         repeat {
         }
     }

examples/line-circle-txt.p8

@@ -1,5 +1,6 @@
 %import textio
 %import syslib
+%import test_stack
 %zeropage basicsafe
 
 ; Note: this program is compatible with C64 and CX16.
@@ -40,6 +41,8 @@ main {
         rect(10, 10, 10, 10, false)
         rect(6, 0, 16, 20, true)
 
+        test_stack.test()
+
 
         sub rect(ubyte x1, ubyte y1, ubyte x2, ubyte y2, ubyte fill) {
             ubyte x
@@ -137,21 +140,17 @@ main {
             ubyte xx
 
             while x>=y {
-                for xx in cx to cx+x {
-                    txt.setcc(xx, cy + y as ubyte, 81, 1)
-                    txt.setcc(xx, cy - y as ubyte, 81, 2)
+                xx = cx-x
+                repeat 2*x+1 {
+                    txt.setcc(xx, cy + y as ubyte, 81, 11)
+                    txt.setcc(xx, cy - y as ubyte, 81, 12)
+                    xx++
                 }
-                for xx in cx-x to cx-1 {
-                    txt.setcc(xx, cy + y as ubyte, 81, 3)
-                    txt.setcc(xx, cy - y as ubyte, 81, 4)
-                }
-                for xx in cx to cx+y {
-                    txt.setcc(xx, cy + x as ubyte, 81, 5)
-                    txt.setcc(xx, cy - x as ubyte, 81, 6)
-                }
-                for xx in cx-y to cx {
-                    txt.setcc(xx, cy + x as ubyte, 81, 7)
-                    txt.setcc(xx, cy - x as ubyte, 81, 8)
+                xx = cx-y
+                repeat 2*y+1 {
+                    txt.setcc(xx, cy + x as ubyte, 81, 13)
+                    txt.setcc(xx, cy - x as ubyte, 81, 14)
+                    xx++
                 }
                 y++
                 if decisionOver2<=0

examples/mandelbrot-gfx.p8

@@ -1,5 +1,6 @@
 %import graphics
 %import floats
+%import test_stack
 %zeropage floatsafe
 
 ; Draw a mandelbrot in graphics mode (the image will be 256 x 200 pixels).
@@ -44,6 +45,9 @@ main {
             }
         }
 
+        ; graphics.disable_bitmap_mode()
+        ; test_stack.test()
+
         repeat {
         }
     }

examples/mandelbrot.p8

@@ -1,5 +1,6 @@
 %import textio
 %import floats
+%import test_stack
 %zeropage basicsafe
 
 ; Note: this program is compatible with C64 and CX16.
@@ -57,5 +58,7 @@ main {
         txt.print("finished in ")
         floats.print_f(duration)
         txt.print(" seconds!\n")
+
+        ; test_stack.test()
     }
 }

examples/numbergame.p8

@@ -1,5 +1,6 @@
 %import textio
 %import conv
+%import test_stack
 %zeropage basicsafe
 
 ; The classic number guessing game.
@@ -59,6 +60,8 @@ main {
             txt.print("Thanks for playing, ")
             txt.print(name)
             txt.print(".\n")
+
+            ; test_stack.test()
         }
     }
 }

examples/plasma.p8

@@ -1,5 +1,6 @@
 %target c64
 %import syslib
+%import test_stack
 %import textio
 
 ;  converted from plasma test program for cc65.
@@ -9,6 +10,7 @@
 ;  Converted to prog8 by Irmen de Jong.
 
 
+
 main {
     const uword SCREEN1 = $E000
     const uword SCREEN2 = $E400
@@ -37,6 +39,9 @@ main {
         ;c64.VMCSB = v
         ;c64.CIA2PRA = block
         ;txt.print("done!\n")
+        ;test_stack.test()
+        ;repeat {
+        ;}
     }
 
     ; several variables outside of doplasma to make them retain their value

examples/primes.p8

@@ -1,4 +1,5 @@
 %import textio
+%import test_stack
 %zeropage basicsafe
 
 ; Note: this program is compatible with C64 and CX16.
@@ -26,6 +27,8 @@ main {
         txt.print("number of primes (expected 54): ")
         txt.print_ub(amount)
         txt.chrout('\n')
+
+        ; test_stack.test()
     }