version 4.5

some programs are now 100% source compatible between C64 and Cx16 targets!
import libraries have been rena;med

README.md

@@ -50,7 +50,7 @@ What use Prog8 provide?
 
 - "c64": Commodore-64  (6510 CPU = almost a 6502)  premium support.
 - "cx16": [CommanderX16](https://www.commanderx16.com)  (65c02 CPU)  experimental support.
-
+- 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)!
 
 
 
@@ -75,16 +75,18 @@ Example code
 
 This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
 
-    %import c64textio
+    %import textio
     %zeropage basicsafe
-
+    
     main {
-
+    
         ubyte[256] sieve
-        ubyte candidate_prime = 2
+        ubyte candidate_prime = 2       ; is increased in the loop
-
+    
         sub start() {
-            memset(sieve, 256, false)   ; clear the sieve
+            ; clear the sieve, to reset starting situation on subsequent runs
+            memset(sieve, 256, false)   
+            ; calculate primes
             txt.print("prime numbers up to 255:\n\n")
             ubyte amount=0
             repeat {
@@ -95,22 +97,23 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
                 txt.print(", ")
                 amount++
             }
-            c64.CHROUT('\n')
+            txt.chrout('\n')
             txt.print("number of primes (expected 54): ")
             txt.print_ub(amount)
-            c64.CHROUT('\n')
+            txt.chrout('\n')
         }
-
+    
         sub find_next_prime() -> ubyte {
             while sieve[candidate_prime] {
                 candidate_prime++
                 if candidate_prime==0
-                    return 0        ; we wrapped; no more primes available
+                    return 0        ; we wrapped; no more primes available in the sieve
             }
+    
             ; found next one, mark the multiples and return it.
             sieve[candidate_prime] = true
             uword multiple = candidate_prime
-
+    
             while multiple < len(sieve) {
                 sieve[lsb(multiple)] = true
                 multiple += candidate_prime
@@ -120,11 +123,11 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
     }
 
 
+
 when compiled an ran on a C-64 you'll get:
 
 ![c64 screen](docs/source/_static/primes_example.png)
 
-
 One of the included examples (wizzine.p8) animates a bunch of sprite balloons and looks like this:
 
 ![wizzine screen](docs/source/_static/wizzine.png)
@@ -136,3 +139,8 @@ Another example (cube3d-sprites.p8) draws the vertices of a rotating 3d cube:
 If you want to play a video game, a fully working Tetris clone is included in the examples:
 
 ![tehtriz_screen](docs/source/_static/tehtriz.png)
+
+The CommanderX16 compiler target is quite capable already too, here's a well known space ship 
+animated in 3D with hidden line removal, in the CommanderX16 emulator:
+
+![cobra3d](docs/source/_static/cobra3d.png)

compiler/build.gradle

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

compiler/res/prog8lib/c64/floats.asm

@@ -1,10 +1,15 @@
 ; --- low level floating point assembly routines for the C64
 
+FL_ONE_const	.byte  129     			; 1.0
+FL_ZERO_const	.byte  0,0,0,0,0		; 0.0
+
+floats_store_reg	.byte  0		; temp storage
+
 
 ub2float	.proc
 		; -- convert ubyte in SCRATCH_ZPB1 to float at address A/Y
 		;    clobbers A, Y
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		ldy  P8ZP_SCRATCH_B1
@@ -13,14 +18,14 @@ ub2float	.proc
 _fac_to_mem	ldx  P8ZP_SCRATCH_W2
 		ldy  P8ZP_SCRATCH_W2+1
 		jsr  MOVMF
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 		.pend
 
 b2float		.proc
 		; -- convert byte in SCRATCH_ZPB1 to float at address A/Y
 		;    clobbers A, Y
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		lda  P8ZP_SCRATCH_B1
@@ -30,7 +35,7 @@ b2float		.proc
 
 uw2float	.proc
 		; -- convert uword in SCRATCH_ZPWORD1 to float at address A/Y
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		lda  P8ZP_SCRATCH_W1
@@ -41,7 +46,7 @@ uw2float	.proc
 
 w2float		.proc
 		; -- convert word in SCRATCH_ZPWORD1 to float at address A/Y
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		ldy  P8ZP_SCRATCH_W1
@@ -54,7 +59,7 @@ stack_b2float	.proc
 		; -- b2float operating on the stack
 		inx
 		lda  P8ESTACK_LO,x
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  FREADSA
 		jmp  push_fac1_as_result
 		.pend
@@ -64,7 +69,7 @@ stack_w2float	.proc
 		inx
 		ldy  P8ESTACK_LO,x
 		lda  P8ESTACK_HI,x
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  GIVAYF
 		jmp  push_fac1_as_result
 		.pend
@@ -73,7 +78,7 @@ stack_ub2float	.proc
 		; -- ub2float operating on the stack
 		inx
 		lda  P8ESTACK_LO,x
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		tay
 		lda  #0
 		jsr  GIVAYF
@@ -85,16 +90,16 @@ stack_uw2float	.proc
 		inx
 		lda  P8ESTACK_LO,x
 		ldy  P8ESTACK_HI,x
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  GIVUAYFAY
 		jmp  push_fac1_as_result
 		.pend
 
 stack_float2w	.proc               ; also used for float2b
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  AYINT
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		lda  $64
 		sta  P8ESTACK_HI,x
 		lda  $65
@@ -105,9 +110,9 @@ stack_float2w	.proc               ; also used for float2b
 
 stack_float2uw	.proc               ; also used for float2ub
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  GETADR
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		sta  P8ESTACK_HI,x
 		tya
 		sta  P8ESTACK_LO,x
@@ -231,15 +236,15 @@ inc_var_f	.proc
 		; -- add 1 to float pointed to by A/Y
 		sta  P8ZP_SCRATCH_W1
 		sty  P8ZP_SCRATCH_W1+1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  MOVFM
-		lda  #<FL_FONE
+		lda  #<FL_ONE_const
-		ldy  #>FL_FONE
+		ldy  #>FL_ONE_const
 		jsr  FADD
 		ldx  P8ZP_SCRATCH_W1
 		ldy  P8ZP_SCRATCH_W1+1
 		jsr  MOVMF
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 		.pend
 
@@ -247,9 +252,9 @@ dec_var_f	.proc
 		; -- subtract 1 from float pointed to by A/Y
 		sta  P8ZP_SCRATCH_W1
 		sty  P8ZP_SCRATCH_W1+1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
-		lda  #<FL_FONE
+		lda  #<FL_ONE_const
-		ldy  #>FL_FONE
+		ldy  #>FL_ONE_const
 		jsr  MOVFM
 		lda  P8ZP_SCRATCH_W1
 		ldy  P8ZP_SCRATCH_W1+1
@@ -257,7 +262,7 @@ dec_var_f	.proc
 		ldx  P8ZP_SCRATCH_W1
 		ldy  P8ZP_SCRATCH_W1+1
 		jsr  MOVMF
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 		.pend
 
@@ -286,7 +291,7 @@ push_fac1_as_result	.proc
 		jsr  MOVMF
 		lda  #<fmath_float1
 		ldy  #>fmath_float1
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		jmp  push_float
 		.pend
 
@@ -298,21 +303,21 @@ pow_f		.proc
 		lda  #<fmath_float1
 		ldy  #>fmath_float1
 		jsr  pop_float
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		lda  #<fmath_float1
 		ldy  #>fmath_float1
 		jsr  CONUPK		; fac2 = float1
 		lda  #<fmath_float2
 		ldy  #>fmath_float2
 		jsr  FPWR
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		jmp  push_fac1_as_result
 		.pend
 
 div_f		.proc
 		; -- push f1/f2 on stack
 		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		lda  #<fmath_float1
 		ldy  #>fmath_float1
 		jsr  FDIV
@@ -322,7 +327,7 @@ div_f		.proc
 add_f		.proc
 		; -- push f1+f2 on stack
 		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		lda  #<fmath_float1
 		ldy  #>fmath_float1
 		jsr  FADD
@@ -332,7 +337,7 @@ add_f		.proc
 sub_f		.proc
 		; -- push f1-f2 on stack
 		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		lda  #<fmath_float1
 		ldy  #>fmath_float1
 		jsr  FSUB
@@ -342,7 +347,7 @@ sub_f		.proc
 mul_f		.proc
 		; -- push f1*f2 on stack
 		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		lda  #<fmath_float1
 		ldy  #>fmath_float1
 		jsr  FMULT
@@ -350,19 +355,19 @@ mul_f		.proc
 		.pend
 
 neg_f		.proc
-		; -- push -flt back on stack
+		; -- toggle the sign bit on the stack
-		jsr  pop_float_fac1
+		lda  P8ESTACK_HI+3,x
-		stx  P8ZP_SCRATCH_REG_X
+		eor  #$80
-		jsr  NEGOP
+		sta  P8ESTACK_HI+3,x
-		jmp  push_fac1_as_result
+		rts
 		.pend
 
 abs_f		.proc
-		; -- push abs(float) on stack (as float)
+		; -- strip the sign bit on the stack
-		jsr  pop_float_fac1
+		lda  P8ESTACK_HI+3,x
-		stx  P8ZP_SCRATCH_REG_X
+		and  #$7f
-		jsr  ABS
+		sta  P8ESTACK_HI+3,x
-		jmp  push_fac1_as_result
+		rts
 		.pend
 
 equal_f		.proc
@@ -466,7 +471,7 @@ _return_true	lda  #1
 func_sin	.proc
 		; -- push sin(f) back onto stack
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  SIN
 		jmp  push_fac1_as_result
 		.pend
@@ -474,7 +479,7 @@ func_sin	.proc
 func_cos	.proc
 		; -- push cos(f) back onto stack
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  COS
 		jmp  push_fac1_as_result
 		.pend
@@ -482,7 +487,7 @@ func_cos	.proc
 func_tan	.proc
 		; -- push tan(f) back onto stack
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  TAN
 		jmp  push_fac1_as_result
 		.pend
@@ -490,7 +495,7 @@ func_tan	.proc
 func_atan	.proc
 		; -- push atan(f) back onto stack
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  ATN
 		jmp  push_fac1_as_result
 		.pend
@@ -498,7 +503,7 @@ func_atan	.proc
 func_ln		.proc
 		; -- push ln(f) back onto stack
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  LOG
 		jmp  push_fac1_as_result
 		.pend
@@ -506,7 +511,7 @@ func_ln		.proc
 func_log2	.proc
 		; -- push log base 2, ln(f)/ln(2), back onto stack
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  LOG
 		jsr  MOVEF
 		lda  #<c64.FL_LOG2
@@ -518,7 +523,7 @@ func_log2	.proc
 
 func_sqrt	.proc
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  SQR
 		jmp  push_fac1_as_result
 		.pend
@@ -526,7 +531,7 @@ func_sqrt	.proc
 func_rad	.proc
 		; -- convert degrees to radians (d * pi / 180)
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		lda  #<_pi_div_180
 		ldy  #>_pi_div_180
 		jsr  FMULT
@@ -537,7 +542,7 @@ _pi_div_180	.byte 123, 14, 250, 53, 18		; pi / 180
 func_deg	.proc
 		; -- convert radians to degrees (d * (1/ pi * 180))
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		lda  #<_one_over_pi_div_180
 		ldy  #>_one_over_pi_div_180
 		jsr  FMULT
@@ -547,7 +552,7 @@ _one_over_pi_div_180	.byte 134, 101, 46, 224, 211		; 1 / (pi * 180)
 
 func_round	.proc
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  FADDH
 		jsr  INT
 		jmp  push_fac1_as_result
@@ -555,7 +560,7 @@ func_round	.proc
 
 func_floor	.proc
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  INT
 		jmp  push_fac1_as_result
 		.pend
@@ -563,7 +568,7 @@ func_floor	.proc
 func_ceil	.proc
 		; -- ceil: tr = int(f); if tr==f -> return  else return tr+1
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		ldx  #<fmath_float1
 		ldy  #>fmath_float1
 		jsr  MOVMF
@@ -573,8 +578,8 @@ func_ceil	.proc
 		jsr  FCOMP
 		cmp  #0
 		beq  +
-		lda  #<FL_FONE
+		lda  #<FL_ONE_const
-		ldy  #>FL_FONE
+		ldy  #>FL_ONE_const
 		jsr  FADD
 +		jmp  push_fac1_as_result
 		.pend
@@ -630,7 +635,7 @@ func_max_f	.proc
 		ldy  #>_largest_neg_float
 _minmax_entry	jsr  MOVFM
 		jsr  prog8_lib.pop_array_and_lengthmin1Y
-		stx  P8ZP_SCRATCH_REG_X
+		stx  floats_store_reg
 -		sty  P8ZP_SCRATCH_REG
 		lda  P8ZP_SCRATCH_W1
 		ldy  P8ZP_SCRATCH_W1+1
@@ -650,6 +655,8 @@ _minmax_cmp	cmp  #255			; modified
 		dey
 		cpy  #255
 		bne  -
+		ldx  floats_store_reg
+		stx  P8ZP_SCRATCH_REG
 		jmp  push_fac1_as_result
 _largest_neg_float	.byte 255,255,255,255,255		; largest negative float -1.7014118345e+38
 		.pend
@@ -665,11 +672,11 @@ _largest_pos_float	.byte  255,127,255,255,255		; largest positive float
 		.pend
 
 func_sum_f	.proc
-		lda  #<ZERO
+		lda  #<FL_ZERO_const
-		ldy  #>ZERO
+		ldy  #>FL_ZERO_const
 		jsr  MOVFM
 		jsr  prog8_lib.pop_array_and_lengthmin1Y
-		stx  P8ZP_SCRATCH_REG_X
+		stx  floats_store_reg
 -		sty  P8ZP_SCRATCH_REG
 		lda  P8ZP_SCRATCH_W1
 		ldy  P8ZP_SCRATCH_W1+1
@@ -685,7 +692,9 @@ func_sum_f	.proc
 		bcc  -
 		inc  P8ZP_SCRATCH_W1+1
 		bne  -
-+		jmp  push_fac1_as_result
++		ldx  floats_store_reg
+		stx  P8ZP_SCRATCH_REG
+		jmp  push_fac1_as_result
 		.pend
 
 sign_f		.proc

compiler/res/prog8lib/c64/floats.p8

@@ -4,14 +4,14 @@
 ;
 ; indent format: TABS, size=8
 
+%target c64
 %option enable_floats
 
-c64flt {
+floats {
 	; ---- this block contains C-64 floating point related functions ----
 
-        const  float  PI        = 3.141592653589793
+        const float  PI     = 3.141592653589793
-        const  float  TWOPI	    = 6.283185307179586
+        const float  TWOPI  = 6.283185307179586
-        const  float  ZERO      = 0.0
 
 
 ; ---- C64 basic and kernal ROM float constants and functions ----
@@ -50,22 +50,22 @@ romsub $bc0f = MOVEF() clobbers(A,X)                        ; copy fac1 to fac2
 romsub $bbd4 = MOVMF(uword mflpt @ XY) clobbers(A,Y)        ; store fac1 to memory  X/Y as 5-byte mflpt
 
 ; fac1-> signed word in Y/A (might throw ILLEGAL QUANTITY)
-; (tip: use c64flt.FTOSWRDAY to get A/Y output; lo/hi switched to normal little endian order)
+; (tip: use floats.FTOSWRDAY to get A/Y output; lo/hi switched to normal little endian order)
 romsub $b1aa = FTOSWORDYA() clobbers(X) -> ubyte @ Y, ubyte @ A       ; note: calls AYINT.
 
 ; fac1 -> unsigned word in Y/A (might throw ILLEGAL QUANTITY) (result also in $14/15)
-; (tip: use c64flt.GETADRAY to get A/Y output; lo/hi switched to normal little endian order)
+; (tip: use floats.GETADRAY to get A/Y output; lo/hi switched to normal little endian order)
 romsub $b7f7 = GETADR() clobbers(X) -> ubyte @ Y, ubyte @ A
 
 romsub $bc9b = QINT() clobbers(A,X,Y)           ; fac1 -> 4-byte signed integer in 98-101 ($62-$65), with the MSB FIRST.
 romsub $b1bf = AYINT() clobbers(A,X,Y)          ; fac1-> signed word in 100-101 ($64-$65) MSB FIRST. (might throw ILLEGAL QUANTITY)
 
 ; GIVAYF: signed word in Y/A (note different lsb/msb order) -> float in fac1
-; (tip: use c64flt.GIVAYFAY to use A/Y input; lo/hi switched to normal order)
+; (tip: use floats.GIVAYFAY to use A/Y input; lo/hi switched to normal order)
-; there is also c64flt.GIVUAYFAY - unsigned word in A/Y (lo/hi) to fac1
+; there is also floats.GIVUAYFAY - unsigned word in A/Y (lo/hi) to fac1
-; there is also c64flt.FREADS32  that reads from 98-101 ($62-$65) MSB FIRST
+; there is also floats.FREADS32  that reads from 98-101 ($62-$65) MSB FIRST
-; there is also c64flt.FREADUS32  that reads from 98-101 ($62-$65) MSB FIRST
+; there is also floats.FREADUS32  that reads from 98-101 ($62-$65) MSB FIRST
-; there is also c64flt.FREADS24AXY  that reads signed int24 into fac1 from A/X/Y (lo/mid/hi bytes)
+; there is also floats.FREADS24AXY  that reads signed int24 into fac1 from A/X/Y (lo/mid/hi bytes)
 romsub $b391 = GIVAYF(ubyte lo @ Y, ubyte hi @ A) clobbers(A,X,Y)
 
 romsub $b3a2 = FREADUY(ubyte value @ Y) clobbers(A,X,Y)     ; 8 bit unsigned Y -> float in fac1
@@ -194,24 +194,24 @@ asmsub  GETADRAY  () clobbers(X) -> uword @ AY  {
 sub  print_f  (float value) {
 	; ---- prints the floating point value (without a newline).
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  floats_store_reg
 		lda  #<value
 		ldy  #>value
 		jsr  MOVFM		; load float into fac1
 		jsr  FOUT		; fac1 to string in A/Y
-		sta  P8ZP_SCRATCH_B1
+		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_REG
+		sty  P8ZP_SCRATCH_W1+1
 		ldy  #0
--		lda  (P8ZP_SCRATCH_B1),y
+-		lda  (P8ZP_SCRATCH_W1),y
 		beq  +
 		jsr  c64.CHROUT
 		iny
 		bne  -
-		ldx  P8ZP_SCRATCH_REG_X
++		ldx  floats_store_reg
-+		rts
+		rts
 	}}
 }
 
-%asminclude "library:c64floats.asm", ""
+%asminclude "library:c64/floats.asm", ""
 
 }

compiler/res/prog8lib/c64/graphics.p8

@@ -1,11 +1,14 @@
-%import c64textio
+%target c64
+%import textio
 
 ; bitmap pixel graphics module for the C64
-; only black/white monchrome for now
+; only black/white monchrome 320x200 for now
 ; assumes bitmap screen memory is $2000-$3fff
 
 graphics {
-    const uword bitmap_address = $2000
+    const uword BITMAP_ADDRESS = $2000
+    const uword WIDTH = 320
+    const ubyte HEIGHT = 200
 
     sub enable_bitmap_mode() {
         ; enable bitmap screen, erase it and set colors to black/white.
@@ -15,7 +18,7 @@ graphics {
     }
 
     sub clear_screen(ubyte pixelcolor, ubyte bgcolor) {
-        memset(bitmap_address, 320*200/8, 0)
+        memset(BITMAP_ADDRESS, 320*200/8, 0)
         txt.fill_screen(pixelcolor << 4 | bgcolor, 0)
     }
 
@@ -30,8 +33,8 @@ graphics {
         }
         word @zp d = 0
         ubyte positive_ix = true
-        word @zp dx = x2 - x1 as word
+        word @zp dx = x2-x1
-        word @zp dy = y2 as word - y1 as word
+        word @zp dy = y2-y1
         if dx < 0 {
             dx = -dx
             positive_ix = false
@@ -134,33 +137,33 @@ graphics {
         }
     }
 
-    sub disc(uword cx, ubyte cy, ubyte radius) {
+    sub disc(uword xcenter, ubyte ycenter, ubyte radius) {
         ; Midpoint algorithm, filled
         ubyte xx = radius
         ubyte yy = 0
         byte decisionOver2 = 1-xx as byte
 
         while xx>=yy {
-            ubyte cy_plus_yy = cy + yy
+            ubyte ycenter_plus_yy = ycenter + yy
-            ubyte cy_min_yy = cy - yy
+            ubyte ycenter_min_yy = ycenter - yy
-            ubyte cy_plus_xx = cy + xx
+            ubyte ycenter_plus_xx = ycenter + xx
-            ubyte cy_min_xx = cy - xx
+            ubyte ycenter_min_xx = ycenter - xx
 
-            for internal_plotx in cx to cx+xx {
+            for internal_plotx in xcenter to xcenter+xx {
-                internal_plot(cy_plus_yy)
+                internal_plot(ycenter_plus_yy)
-                internal_plot(cy_min_yy)
+                internal_plot(ycenter_min_yy)
             }
-            for internal_plotx in cx-xx to cx-1 {
+            for internal_plotx in xcenter-xx to xcenter-1 {
-                internal_plot(cy_plus_yy)
+                internal_plot(ycenter_plus_yy)
-                internal_plot(cy_min_yy)
+                internal_plot(ycenter_min_yy)
             }
-            for internal_plotx in cx to cx+yy {
+            for internal_plotx in xcenter to xcenter+yy {
-                internal_plot(cy_plus_xx)
+                internal_plot(ycenter_plus_xx)
-                internal_plot(cy_min_xx)
+                internal_plot(ycenter_min_xx)
             }
-            for internal_plotx in cx-yy to cx {
+            for internal_plotx in xcenter-yy to xcenter {
-                internal_plot(cy_plus_xx)
+                internal_plot(ycenter_plus_xx)
-                internal_plot(cy_min_xx)
+                internal_plot(ycenter_min_xx)
             }
             yy++
             if decisionOver2<=0
@@ -176,13 +179,11 @@ graphics {
 ; here is the non-asm code for the plot routine below:
 ;    sub plot_nonasm(uword px, ubyte py) {
 ;        ubyte[] ormask = [128, 64, 32, 16, 8, 4, 2, 1]
-;        uword addr = bitmap_address + 320*(py>>3) + (py & 7) + (px & %0000000111111000)
+;        uword addr = BITMAP_ADDRESS + 320*(py>>3) + (py & 7) + (px & %0000000111111000)
 ;        @(addr) |= ormask[lsb(px) & 7]
 ;    }
 
-    ; TODO fix the use of X (or XY) as parameter so we can actually use this plot() routine
+    asmsub  plot(uword plotx @XY, ubyte ploty @A) clobbers (A, X, Y) {
-    ;   calling it with a byte results in a compiler crash, calling it with word results in clobbering X register I think
-    asmsub  plotXXX(uword plotx @XY, ubyte ploty @A) {
         %asm {{
             stx  internal_plotx
             sty  internal_plotx+1
@@ -190,12 +191,14 @@ graphics {
         }}
     }
 
+    ; for efficiency of internal algorithms here is the internal plot routine
+    ; that takes the plotx coordinate in a separate variable instead of the XY register pair:
+
     uword internal_plotx     ; 0..319        ; separate 'parameter' for internal_plot()
 
-    asmsub  internal_plot(ubyte ploty @A) {      ; internal_plotx is 16 bits 0 to 319... doesn't fit in a register
+    asmsub  internal_plot(ubyte ploty @A) clobbers (A, X, Y) {      ; internal_plotx is 16 bits 0 to 319... doesn't fit in a register
         %asm {{
         tay
-        stx  P8ZP_SCRATCH_REG_X
         lda  internal_plotx+1
         sta  P8ZP_SCRATCH_W2+1
         lsr  a            ; 0
@@ -219,15 +222,13 @@ graphics {
         lda  (P8ZP_SCRATCH_W2),y
         ora  _ormask,x
         sta  (P8ZP_SCRATCH_W2),y
-
-        ldx  P8ZP_SCRATCH_REG_X
         rts
 
 _ormask     .byte 128, 64, 32, 16, 8, 4, 2, 1
 
 ; note: this can be even faster if we also have a 256 byte x-lookup table, but hey.
 ; see http://codebase64.org/doku.php?id=base:various_techniques_to_calculate_adresses_fast_common_screen_formats_for_pixel_graphics
-; the y lookup tables encodes this formula:  bitmap_address + 320*(py>>3) + (py & 7)    (y from 0..199)
+; the y lookup tables encodes this formula:  BITMAP_ADDRESS + 320*(py>>3) + (py & 7)    (y from 0..199)
 ; We use the 64tass syntax for range expressions to calculate this table on assembly time.
 
 _plot_y_values := $2000 + 320*(range(200)>>3) + (range(200) & 7)

compiler/res/prog8lib/c64/syslib.p8

@@ -5,11 +5,13 @@
 ;
 ; indent format: TABS, size=8
 
+%target c64
 
 c64 {
         &ubyte  TIME_HI         = $a0       ; software jiffy clock, hi byte
         &ubyte  TIME_MID        = $a1       ;  .. mid byte
         &ubyte  TIME_LO         = $a2       ;    .. lo byte. Updated by IRQ every 1/60 sec
+        &ubyte  STATUS          = $90       ; kernel status variable for I/O
         &ubyte  STKEY           = $91       ; various keyboard statuses (updated by IRQ)
         &ubyte  SFDX            = $cb       ; current key pressed (matrix value) (updated by IRQ)
 
@@ -202,19 +204,19 @@ romsub $FFB4 = TALK(ubyte device @ A) clobbers(A)               ; command serial
 romsub $FFB7 = READST() -> ubyte @ A                            ; read I/O status word
 romsub $FFBA = SETLFS(ubyte logical @ A, ubyte device @ X, ubyte address @ Y)   ; set logical file parameters
 romsub $FFBD = SETNAM(ubyte namelen @ A, str filename @ XY)     ; set filename parameters
-romsub $FFC0 = OPEN() clobbers(A,X,Y)                           ; (via 794 ($31A)) open a logical file
+romsub $FFC0 = OPEN() clobbers(X,Y) -> ubyte @Pc, ubyte @A      ; (via 794 ($31A)) open a logical file
 romsub $FFC3 = CLOSE(ubyte logical @ A) clobbers(A,X,Y)         ; (via 796 ($31C)) close a logical file
-romsub $FFC6 = CHKIN(ubyte logical @ X) clobbers(A,X)           ; (via 798 ($31E)) define an input channel
+romsub $FFC6 = CHKIN(ubyte logical @ X) clobbers(A,X) -> ubyte @Pc    ; (via 798 ($31E)) define an input channel
 romsub $FFC9 = CHKOUT(ubyte logical @ X) clobbers(A,X)          ; (via 800 ($320)) define an output channel
 romsub $FFCC = CLRCHN() clobbers(A,X)                           ; (via 802 ($322)) restore default devices
-romsub $FFCF = CHRIN() clobbers(Y) -> ubyte @ A                 ; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
+romsub $FFCF = CHRIN() clobbers(X, Y) -> ubyte @ A   ; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
 romsub $FFD2 = CHROUT(ubyte char @ A)                           ; (via 806 ($326)) output a character
 romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> ubyte @Pc, ubyte @ A, ubyte @ X, ubyte @ Y     ; (via 816 ($330)) load from device
 romsub $FFD8 = SAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) -> ubyte @ Pc, ubyte @ A                    ; (via 818 ($332)) save to a device
 romsub $FFDB = SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y)      ; set the software clock
 romsub $FFDE = RDTIM() -> ubyte @ A, ubyte @ X, ubyte @ Y       ; read the software clock
-romsub $FFE1 = STOP() clobbers(A,X) -> ubyte @ Pz, ubyte @ Pc   ; (via 808 ($328)) check the STOP key
+romsub $FFE1 = STOP() clobbers(X) -> ubyte @ Pz, ubyte @ A      ; (via 808 ($328)) check the STOP key (and some others in A)
-romsub $FFE4 = GETIN() clobbers(X,Y) -> ubyte @ A               ; (via 810 ($32A)) get a character
+romsub $FFE4 = GETIN() clobbers(X,Y) -> ubyte @Pc, ubyte @ A    ; (via 810 ($32A)) get a character
 romsub $FFE7 = CLALL() clobbers(A,X)                            ; (via 812 ($32C)) close all files
 romsub $FFEA = UDTIM() clobbers(A,X)                            ; update the software clock
 romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; read number of screen rows and columns
@@ -249,8 +251,7 @@ asmsub  init_system()  {
         sta  c64.COLOR
         lda  #0
         sta  c64.BGCOL0
-        tax
+        jsr  disable_runstop_and_charsetswitch
-        tay
         clc
         clv
         cli
@@ -258,6 +259,26 @@ asmsub  init_system()  {
     }}
 }
 
+asmsub  reset_system()  {
+    ; Soft-reset the system back to Basic prompt.
+    %asm {{
+        sei
+        lda  #14
+        sta  $01        ; bank the kernal in
+        jmp  (c64.RESET_VEC)
+    }}
+}
+
+asmsub  disable_runstop_and_charsetswitch() {
+    %asm {{
+        lda  #$80
+        sta  657    ; disable charset switching
+        lda  #239
+        sta  808    ; disable run/stop key
+        rts
+    }}
+}
+
 asmsub  set_irqvec_excl() clobbers(A)  {
 	%asm {{
 		sei
@@ -298,8 +319,6 @@ _irq_handler_init
 		sta  IRQ_SCRATCH_ZPB1
 		lda  P8ZP_SCRATCH_REG
 		sta  IRQ_SCRATCH_ZPREG
-		lda  P8ZP_SCRATCH_REG_X
-		sta  IRQ_SCRATCH_ZPREGX
 		lda  P8ZP_SCRATCH_W1
 		sta  IRQ_SCRATCH_ZPWORD1
 		lda  P8ZP_SCRATCH_W1+1
@@ -324,8 +343,6 @@ _irq_handler_end
 		sta  P8ZP_SCRATCH_B1
 		lda  IRQ_SCRATCH_ZPREG
 		sta  P8ZP_SCRATCH_REG
-		lda  IRQ_SCRATCH_ZPREGX
-		sta  P8ZP_SCRATCH_REG_X
 		lda  IRQ_SCRATCH_ZPWORD1
 		sta  P8ZP_SCRATCH_W1
 		lda  IRQ_SCRATCH_ZPWORD1+1
@@ -340,7 +357,6 @@ _irq_handler_end
 IRQ_X_REG		.byte  0
 IRQ_SCRATCH_ZPB1	.byte  0
 IRQ_SCRATCH_ZPREG	.byte  0
-IRQ_SCRATCH_ZPREGX	.byte  0
 IRQ_SCRATCH_ZPWORD1	.word  0
 IRQ_SCRATCH_ZPWORD2	.word  0
 

compiler/res/prog8lib/c64/textio.p8

@@ -4,22 +4,22 @@
 ;
 ; indent format: TABS, size=8
 
-
+%target c64
-%import c64lib
+%import syslib
 %import conv
 
 
 txt {
 
-asmsub  clear_screen() {
+const ubyte DEFAULT_WIDTH = 40
-    %asm {{
+const ubyte DEFAULT_HEIGHT = 25
-        lda  #' '
+
-        jmp  clear_screenchars
+
-    }}
+sub  clear_screen() {
+    clear_screenchars(' ')
 }
 
-
+asmsub  fill_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
-asmsub  fill_screen (ubyte char @ A, ubyte charcolor @ Y) clobbers(A)  {
 	; ---- fill the character screen with the given fill character and character color.
 	;      (assumes screen and color matrix are at their default addresses)
 
@@ -49,7 +49,7 @@ _loop		sta  c64.Screen,y
         }}
 }
 
-asmsub  clear_screencolors (ubyte scrcolor @ A) clobbers(Y)  {
+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 {{
@@ -68,13 +68,21 @@ sub color (ubyte txtcol) {
     c64.COLOR = txtcol
 }
 
-asmsub  scroll_left_full  (ubyte alsocolors @ Pc) clobbers(A, Y)  {
+sub lowercase() {
+    c64.VMCSB |= 2
+}
+
+sub uppercase() {
+    c64.VMCSB &= ~2
+}
+
+asmsub  scroll_left  (ubyte alsocolors @ Pc) clobbers(A, Y)  {
 	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		bcs  +
 		jmp  _scroll_screen
 
@@ -102,17 +110,17 @@ _scroll_screen  ; scroll the screen memory
 		dey
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  scroll_right_full  (ubyte alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_right  (ubyte alsocolors @ Pc) 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 determines if screen color data must be scrolled too
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		bcs  +
 		jmp  _scroll_screen
 
@@ -136,17 +144,17 @@ _scroll_screen  ; scroll the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  scroll_up_full  (ubyte alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_up  (ubyte alsocolors @ Pc) clobbers(A)  {
 	; ---- scroll the whole screen 1 character up
 	;      contents of the bottom row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		bcs  +
 		jmp  _scroll_screen
 
@@ -170,17 +178,17 @@ _scroll_screen  ; scroll the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  scroll_down_full  (ubyte alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_down  (ubyte alsocolors @ Pc) clobbers(A)  {
 	; ---- scroll the whole screen 1 character down
 	;      contents of the top row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		bcs  +
 		jmp  _scroll_screen
 
@@ -204,11 +212,13 @@ _scroll_screen  ; scroll the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
+romsub $FFD2 = chrout(ubyte char @ A)    ; for consistency. You can also use c64.CHROUT directly ofcourse.
+
 asmsub  print (str text @ AY) clobbers(A,Y)  {
 	; ---- print null terminated string from A/Y
 	; note: the compiler contains an optimization that will replace
@@ -230,7 +240,7 @@ asmsub  print (str text @ AY) clobbers(A,Y)  {
 asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
 	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  conv.ubyte2decimal
 		pha
 		tya
@@ -239,7 +249,7 @@ asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
 		jsr  c64.CHROUT
 		txa
 		jsr  c64.CHROUT
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
@@ -247,7 +257,7 @@ asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
 asmsub  print_ub  (ubyte value @ A) clobbers(A,Y)  {
 	; ---- print the ubyte in A in decimal form, without left padding 0s
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  conv.ubyte2decimal
 _print_byte_digits
 		pha
@@ -264,7 +274,7 @@ _print_byte_digits
         jsr  c64.CHROUT
 _ones   txa
 		jsr  c64.CHROUT
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
@@ -272,7 +282,7 @@ _ones   txa
 asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
 	; ---- print the byte in A in decimal form, without left padding 0s
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		pha
 		cmp  #0
 		bpl  +
@@ -280,16 +290,14 @@ asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
 		jsr  c64.CHROUT
 +		pla
 		jsr  conv.byte2decimal
-		jsr  print_ub._print_byte_digits
+		jmp  print_ub._print_byte_digits
-		ldx  P8ZP_SCRATCH_REG_X
-		rts
 	}}
 }
 
 asmsub  print_ubhex  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
 	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		bcc  +
 		pha
 		lda  #'$'
@@ -299,7 +307,7 @@ asmsub  print_ubhex  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
 		jsr  c64.CHROUT
 		tya
 		jsr  c64.CHROUT
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
@@ -307,7 +315,7 @@ asmsub  print_ubhex  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
 asmsub  print_ubbin  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
 	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		sta  P8ZP_SCRATCH_B1
 		bcc  +
 		lda  #'%'
@@ -320,7 +328,7 @@ asmsub  print_ubbin  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
 +		jsr  c64.CHROUT
 		dey
 		bne  -
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
@@ -353,7 +361,7 @@ asmsub  print_uwhex  (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y)  {
 asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
 	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG_X
+	    stx  P8ZP_SCRATCH_REG
 		jsr  conv.uword2decimal
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
@@ -361,7 +369,7 @@ asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
 		jsr  c64.CHROUT
 		iny
 		bne  -
-+		ldx  P8ZP_SCRATCH_REG_X
++		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
@@ -369,9 +377,9 @@ asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
 asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
 	; ---- print the uword in A/Y in decimal form, without left padding 0s
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG_X
+	    stx  P8ZP_SCRATCH_REG
 		jsr  conv.uword2decimal
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
 		beq  _allzero
@@ -434,21 +442,22 @@ asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
 	}}
 }
 
-asmsub  setchr  (ubyte col @Y, ubyte row @A) clobbers(A)  {
+asmsub  setchr  (ubyte col @X, ubyte row @Y, ubyte character @A) clobbers(A, Y)  {
-	; ---- set the character in SCRATCH_ZPB1 on the screen matrix at the given position
+	; ---- sets the character in the screen matrix at the given position
 	%asm {{
-		sty  P8ZP_SCRATCH_REG
+		pha
+		tya
 		asl  a
 		tay
 		lda  _screenrows+1,y
 		sta  _mod+2
-		lda  _screenrows,y
+		txa
 		clc
-		adc  P8ZP_SCRATCH_REG
+		adc  _screenrows,y
 		sta  _mod+1
 		bcc  +
 		inc  _mod+2
-+		lda  P8ZP_SCRATCH_B1
++		pla
 _mod		sta  $ffff		; modified
 		rts
 
@@ -456,17 +465,18 @@ _screenrows	.word  $0400 + range(0, 1000, 40)
 	}}
 }
 
-asmsub  getchr  (ubyte col @Y, ubyte row @A) clobbers(Y) -> ubyte @ A {
+asmsub  getchr  (ubyte col @A, ubyte row @Y) clobbers(Y) -> ubyte @ A {
 	; ---- get the character in the screen matrix at the given location
 	%asm  {{
-		sty  P8ZP_SCRATCH_B1
+		pha
+		tya
 		asl  a
 		tay
 		lda  setchr._screenrows+1,y
 		sta  _mod+2
-		lda  setchr._screenrows,y
+		pla
 		clc
-		adc  P8ZP_SCRATCH_B1
+		adc  setchr._screenrows,y
 		sta  _mod+1
 		bcc  _mod
 		inc  _mod+2
@@ -475,21 +485,22 @@ _mod		lda  $ffff		; modified
 	}}
 }
 
-asmsub  setclr  (ubyte col @Y, ubyte row @A) clobbers(A)  {
+asmsub  setclr  (ubyte col @X, ubyte row @Y, ubyte color @A) clobbers(A, Y)  {
-	; ---- set the color in SCRATCH_ZPB1 on the screen matrix at the given position
+	; ---- set the color in A on the screen matrix at the given position
 	%asm {{
-		sty  P8ZP_SCRATCH_REG
+		pha
+		tya
 		asl  a
 		tay
 		lda  _colorrows+1,y
 		sta  _mod+2
-		lda  _colorrows,y
+		txa
 		clc
-		adc  P8ZP_SCRATCH_REG
+		adc  _colorrows,y
 		sta  _mod+1
 		bcc  +
 		inc  _mod+2
-+		lda  P8ZP_SCRATCH_B1
++		pla
 _mod		sta  $ffff		; modified
 		rts
 
@@ -497,17 +508,18 @@ _colorrows	.word  $d800 + range(0, 1000, 40)
 	}}
 }
 
-asmsub  getclr  (ubyte col @Y, ubyte row @A) clobbers(Y) -> ubyte @ A {
+asmsub  getclr  (ubyte col @A, ubyte row @Y) clobbers(Y) -> ubyte @ A {
 	; ---- get the color in the screen color matrix at the given location
 	%asm  {{
-		sty  P8ZP_SCRATCH_B1
+		pha
+		tya
 		asl  a
 		tay
 		lda  setclr._colorrows+1,y
 		sta  _mod+2
-		lda  setclr._colorrows,y
+		pla
 		clc
-		adc  P8ZP_SCRATCH_B1
+		adc  setclr._colorrows,y
 		sta  _mod+1
 		bcc  _mod
 		inc  _mod+2
@@ -545,13 +557,31 @@ _colormod	sta  $ffff		; modified
 asmsub  plot  (ubyte col @ Y, ubyte row @ A) clobbers(A) {
 	; ---- safe wrapper around PLOT kernel routine, to save the X register.
 	%asm  {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		tax
 		clc
 		jsr  c64.PLOT
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
+asmsub width() clobbers(X,Y) -> ubyte @A {
+    ; -- returns the text screen width (number of columns)
+    %asm {{
+        jsr  c64.SCREEN
+        txa
+        rts
+    }}
+}
+
+asmsub height() clobbers(X, Y) -> ubyte @A {
+    ; -- returns the text screen height (number of rows)
+    %asm {{
+        jsr  c64.SCREEN
+        tya
+        rts
+    }}
+}
+
 }

compiler/res/prog8lib/conv.p8

@@ -213,7 +213,7 @@ asmsub  byte2decimal  (byte value @ A) -> ubyte @ Y, ubyte @ A, ubyte @ X  {
 asmsub  ubyte2hex  (ubyte value @ A) -> ubyte @ A, ubyte @ Y  {
 	; ---- A to hex petscii string in AY (first hex char in A, second hex char in Y)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		pha
 		and  #$0f
 		tax
@@ -225,7 +225,7 @@ asmsub  ubyte2hex  (ubyte value @ A) -> ubyte @ A, ubyte @ Y  {
 		lsr  a
 		tax
 		lda  _hex_digits,x
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 
 _hex_digits	.text "0123456789abcdef"	; can probably be reused for other stuff as well
@@ -249,6 +249,28 @@ output	.text  "0000", $00      ; 0-terminated output buffer (to make printing ea
 	}}
 }
 
+
+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
+	}}
+}
+
+
+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
+	}}
+}
+
 asmsub str2uword(str string @ AY) -> uword @ AY {
 	; -- returns the unsigned word value of the string number argument in AY
 	;    the number may NOT be preceded by a + sign and may NOT contain spaces

compiler/res/prog8lib/cx16/floats.p8

@@ -4,14 +4,14 @@
 ;
 ; indent format: TABS, size=8
 
+%target cx16
 %option enable_floats
 
-c64flt {
+floats {
 	; ---- this block contains C-64 floating point related functions ----
 
-        const  float  PI        = 3.141592653589793
+        const float  PI     = 3.141592653589793
-        const  float  TWOPI	    = 6.283185307179586
+        const float  TWOPI  = 6.283185307179586
-        const  float  ZERO      = 0.0
 
 
 ; ---- ROM float functions ----
@@ -25,7 +25,7 @@ c64flt {
 romsub $fe00 = AYINT() clobbers(A,X,Y)          ; fac1-> signed word in 100-101 ($64-$65) MSB FIRST. (might throw ILLEGAL QUANTITY)
 
 ; GIVAYF: signed word in Y/A (note different lsb/msb order) -> float in fac1
-; there is also c64flt.GIVUAYFAY - unsigned word in A/Y (lo/hi) to fac1
+; there is also floats.GIVUAYFAY - unsigned word in A/Y (lo/hi) to fac1
 ; (tip: use GIVAYFAY to use A/Y input; lo/hi switched to normal order)
 romsub $fe03 = GIVAYF(ubyte lo @ Y, ubyte hi @ A) clobbers(A,X,Y)
 
@@ -78,10 +78,10 @@ asmsub  GIVUAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- unsigned 16 bit word in A/Y (lo/hi) to fac1
 	%asm {{
         phx
-        sta  P8ZP_SCRATCH_REG
+        sta  P8ZP_SCRATCH_W2
         sty  P8ZP_SCRATCH_B1
         tya
-        ldy  P8ZP_SCRATCH_REG
+        ldy  P8ZP_SCRATCH_W2
         jsr  GIVAYF                 ; load it as signed... correct afterwards
         lda  P8ZP_SCRATCH_B1
 	    bpl  +
@@ -98,9 +98,9 @@ _flt65536    .byte 145,0,0,0,0       ; 65536.0
 asmsub  GIVAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- signed 16 bit word in A/Y (lo/hi) to float in fac1
 	%asm {{
-		sta  P8ZP_SCRATCH_REG
+		sta  P8ZP_SCRATCH_W2
 		tya
-		ldy  P8ZP_SCRATCH_REG
+		ldy  P8ZP_SCRATCH_W2
 		jmp  GIVAYF		; this uses the inverse order, Y/A
 	}}
 }
@@ -130,24 +130,24 @@ asmsub  GETADRAY  () clobbers(X) -> uword @ AY  {
 sub  print_f  (float value) {
 	; ---- prints the floating point value (without a newline).
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		phx
 		lda  #<value
 		ldy  #>value
 		jsr  MOVFM		; load float into fac1
 		jsr  FOUT		; fac1 to string in A/Y
-		sta  P8ZP_SCRATCH_B1
+		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_REG
+		sty  P8ZP_SCRATCH_W1+1
 		ldy  #0
--		lda  (P8ZP_SCRATCH_B1),y
+-		lda  (P8ZP_SCRATCH_W1),y
 		beq  +
 		jsr  c64.CHROUT
 		iny
 		bne  -
-		ldx  P8ZP_SCRATCH_REG_X
++		plx
-+		rts
+		rts
 	}}
 }
 
-%asminclude "library:c64floats.asm", ""
+%asminclude "library:c64/floats.asm", ""
 
 }

compiler/res/prog8lib/cx16/graphics.p8

@@ -0,0 +1,156 @@
+%target cx16
+%import syslib
+
+; bitmap pixel graphics module for the CommanderX16
+; wraps the graphics functions that are in ROM.
+; only black/white monchrome 320x200 for now.
+
+graphics {
+    const uword WIDTH = 320
+    const ubyte HEIGHT = 200
+
+    sub enable_bitmap_mode() {
+        ; enable bitmap screen, erase it and set colors to black/white.
+        void cx16.screen_set_mode($80)
+        cx16.r0 = 0
+        cx16.GRAPH_init()
+        clear_screen(1, 0)
+    }
+
+    sub clear_screen(ubyte pixelcolor, ubyte bgcolor) {
+        cx16.GRAPH_set_colors(pixelcolor, pixelcolor, bgcolor)
+        cx16.GRAPH_clear()
+    }
+
+    sub line(uword @zp x1, ubyte @zp y1, uword @zp x2, ubyte @zp y2) {
+        cx16.r0 = x1
+        cx16.r1 = y1
+        cx16.r2 = x2
+        cx16.r3 = y2
+        cx16.GRAPH_draw_line()
+    }
+
+    sub circle(uword xcenter, ubyte ycenter, ubyte radius) {
+        ;cx16.r0 = xcenter - radius/2
+        ;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
+
+        ; Midpoint algorithm
+        ubyte @zp xx = radius
+        ubyte @zp yy = 0
+        byte @zp decisionOver2 = 1-xx as byte
+
+        while xx>=yy {
+            cx16.r0 = xcenter + xx
+            cx16.r1 = ycenter + yy
+            cx16.FB_cursor_position()
+            cx16.FB_set_pixel(1)
+            cx16.r0 = xcenter - xx
+            cx16.FB_cursor_position()
+            cx16.FB_set_pixel(1)
+            cx16.r0 = xcenter + xx
+            cx16.r1 = ycenter - yy
+            cx16.FB_cursor_position()
+            cx16.FB_set_pixel(1)
+            cx16.r0 = xcenter - xx
+            cx16.FB_cursor_position()
+            cx16.FB_set_pixel(1)
+            cx16.r0 = xcenter + yy
+            cx16.r1 = ycenter + xx
+            cx16.FB_cursor_position()
+            cx16.FB_set_pixel(1)
+            cx16.r0 = xcenter - yy
+            cx16.FB_cursor_position()
+            cx16.FB_set_pixel(1)
+            cx16.r0 = xcenter + yy
+            cx16.r1 = ycenter - xx
+            cx16.FB_cursor_position()
+            cx16.FB_set_pixel(1)
+            cx16.r0 = xcenter - yy
+            cx16.FB_cursor_position()
+            cx16.FB_set_pixel(1)
+            yy++
+            if decisionOver2<=0 {
+                decisionOver2 += 2*yy+1
+            } else {
+                xx--
+                decisionOver2 += 2*(yy-xx)+1
+            }
+        }
+    }
+
+    sub disc(uword xcenter, ubyte ycenter, ubyte radius) {
+;        cx16.r0 = xcenter - radius/2
+;        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
+
+        ubyte xx = radius
+        ubyte yy = 0
+        byte decisionOver2 = 1-xx as byte
+
+        while xx>=yy {
+            ubyte ycenter_plus_yy = ycenter + yy
+            ubyte ycenter_min_yy = ycenter - yy
+            ubyte ycenter_plus_xx = ycenter + xx
+            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.FB_set_pixel(1)
+                cx16.r1 = ycenter_min_yy
+                cx16.FB_cursor_position()
+                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.FB_set_pixel(1)
+                cx16.r1 = ycenter_min_yy
+                cx16.FB_cursor_position()
+                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
+            else {
+                xx--
+                decisionOver2 += 2*(yy-xx)+1
+            }
+        }
+    }
+
+    sub  plot(uword plotx, ubyte ploty) {
+        cx16.r0 = plotx
+        cx16.r1 = ploty
+        cx16.FB_cursor_position()
+        cx16.FB_set_pixel(1)
+    }
+}
+
+

compiler/res/prog8lib/cx16/syslib.p8

@@ -0,0 +1,291 @@
+; Prog8 definitions for the CommanderX16
+; Including memory registers, I/O registers, Basic and Kernal subroutines.
+;
+; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
+;
+; indent format: TABS, size=8
+
+%target cx16
+
+
+c64 {
+
+; ---- kernal routines, these are the same as on the Commodore-64 (hence the same block name) ----
+
+; STROUT --> use screen.print
+; CLEARSCR -> use screen.clear_screen
+; HOMECRSR -> use screen.plot
+
+romsub $FF81 = CINT() clobbers(A,X,Y)                           ; (alias: SCINIT) initialize screen editor and video chip
+romsub $FF84 = IOINIT() clobbers(A, X)                          ; initialize I/O devices (CIA, SID, IRQ)
+romsub $FF87 = RAMTAS() clobbers(A,X,Y)                         ; initialize RAM, tape buffer, screen
+romsub $FF8A = RESTOR() clobbers(A,X,Y)                         ; restore default I/O vectors
+romsub $FF8D = VECTOR(uword userptr @ XY, ubyte dir @ Pc) clobbers(A,Y)     ; read/set I/O vector table
+romsub $FF90 = SETMSG(ubyte value @ A)                          ; set Kernal message control flag
+romsub $FF93 = SECOND(ubyte address @ A) clobbers(A)            ; (alias: LSTNSA) send secondary address after LISTEN
+romsub $FF96 = TKSA(ubyte address @ A) clobbers(A)              ; (alias: TALKSA) send secondary address after TALK
+romsub $FF99 = MEMTOP(uword address @ XY, ubyte dir @ Pc) -> uword @ XY     ; read/set top of memory  pointer
+romsub $FF9C = MEMBOT(uword address @ XY, ubyte dir @ Pc) -> uword @ XY     ; read/set bottom of memory  pointer
+romsub $FF9F = SCNKEY() clobbers(A,X,Y)                         ; scan the keyboard
+romsub $FFA2 = SETTMO(ubyte timeout @ A)                        ; set time-out flag for IEEE bus
+romsub $FFA5 = ACPTR() -> ubyte @ A                             ; (alias: IECIN) input byte from serial bus
+romsub $FFA8 = CIOUT(ubyte databyte @ A)                        ; (alias: IECOUT) output byte to serial bus
+romsub $FFAB = UNTLK() clobbers(A)                              ; command serial bus device to UNTALK
+romsub $FFAE = UNLSN() clobbers(A)                              ; command serial bus device to UNLISTEN
+romsub $FFB1 = LISTEN(ubyte device @ A) clobbers(A)             ; command serial bus device to LISTEN
+romsub $FFB4 = TALK(ubyte device @ A) clobbers(A)               ; command serial bus device to TALK
+romsub $FFB7 = READST() -> ubyte @ A                            ; read I/O status word
+romsub $FFBA = SETLFS(ubyte logical @ A, ubyte device @ X, ubyte address @ Y)   ; set logical file parameters
+romsub $FFBD = SETNAM(ubyte namelen @ A, str filename @ XY)     ; set filename parameters
+romsub $FFC0 = OPEN() clobbers(X,Y) -> ubyte @Pc, ubyte @A      ; (via 794 ($31A)) open a logical file
+romsub $FFC3 = CLOSE(ubyte logical @ A) clobbers(A,X,Y)         ; (via 796 ($31C)) close a logical file
+romsub $FFC6 = CHKIN(ubyte logical @ X) clobbers(A,X) -> ubyte @Pc    ; (via 798 ($31E)) define an input channel
+romsub $FFC9 = CHKOUT(ubyte logical @ X) clobbers(A,X)          ; (via 800 ($320)) define an output channel
+romsub $FFCC = CLRCHN() clobbers(A,X)                           ; (via 802 ($322)) restore default devices
+romsub $FFCF = CHRIN() clobbers(X, Y) -> ubyte @ A   ; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
+romsub $FFD2 = CHROUT(ubyte char @ A)                           ; (via 806 ($326)) output a character
+romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> ubyte @Pc, ubyte @ A, ubyte @ X, ubyte @ Y     ; (via 816 ($330)) load from device
+romsub $FFD8 = SAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) -> ubyte @ Pc, ubyte @ A                    ; (via 818 ($332)) save to a device
+romsub $FFDB = SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y)      ; set the software clock
+romsub $FFDE = RDTIM() -> ubyte @ A, ubyte @ X, ubyte @ Y       ; read the software clock
+romsub $FFE1 = STOP() clobbers(X) -> ubyte @ Pz, ubyte @ A      ; (via 808 ($328)) check the STOP key (and some others in A)
+romsub $FFE4 = GETIN() clobbers(X,Y) -> ubyte @Pc, ubyte @ A    ; (via 810 ($32A)) get a character
+romsub $FFE7 = CLALL() clobbers(A,X)                            ; (via 812 ($32C)) close all files
+romsub $FFEA = UDTIM() clobbers(A,X)                            ; update the software clock
+romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; read number of screen rows and columns
+romsub $FFF0 = PLOT(ubyte col @ Y, ubyte row @ X, ubyte dir @ Pc) -> ubyte @ X, ubyte @ Y       ; read/set position of cursor on screen.  Use c64scr.plot for a 'safe' wrapper that preserves X.
+romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base address of I/O devices
+
+}
+
+cx16 {
+
+; 65c02 hardware vectors:
+    &uword  NMI_VEC         = $FFFA     ; 6502 nmi vector, determined by the kernal if banked in
+    &uword  RESET_VEC       = $FFFC     ; 6502 reset vector, determined by the kernal if banked in
+    &uword  IRQ_VEC         = $FFFE     ; 6502 interrupt vector, determined by the kernal if banked in
+
+
+; the sixteen virtual 16-bit registers
+    &uword r0  = $0002
+    &uword r1  = $0004
+    &uword r2  = $0006
+    &uword r3  = $0008
+    &uword r4  = $000a
+    &uword r5  = $000c
+    &uword r6  = $000e
+    &uword r7  = $0010
+    &uword r8  = $0012
+    &uword r9  = $0014
+    &uword r10 = $0016
+    &uword r11 = $0018
+    &uword r12 = $001a
+    &uword r13 = $001c
+    &uword r14 = $001e
+    &uword r15 = $0020
+
+; VERA registers
+
+    const uword VERA_BASE = $9F20
+    &ubyte  VERA_ADDR_L   	  = VERA_BASE + $0000
+    &ubyte  VERA_ADDR_M   	  = VERA_BASE + $0001
+    &ubyte  VERA_ADDR_H   	  = VERA_BASE + $0002
+    &ubyte  VERA_DATA0        = VERA_BASE + $0003
+    &ubyte  VERA_DATA1        = VERA_BASE + $0004
+    &ubyte  VERA_CTRL         = VERA_BASE + $0005
+    &ubyte  VERA_IEN          = VERA_BASE + $0006
+    &ubyte  VERA_ISR          = VERA_BASE + $0007
+    &ubyte  VERA_IRQ_LINE_L   = VERA_BASE + $0008
+    &ubyte  VERA_DC_VIDEO     = VERA_BASE + $0009
+    &ubyte  VERA_DC_HSCALE    = VERA_BASE + $000A
+    &ubyte  VERA_DC_VSCALE    = VERA_BASE + $000B
+    &ubyte  VERA_DC_BORDER    = VERA_BASE + $000C
+    &ubyte  VERA_DC_HSTART    = VERA_BASE + $0009
+    &ubyte  VERA_DC_HSTOP     = VERA_BASE + $000A
+    &ubyte  VERA_DC_VSTART    = VERA_BASE + $000B
+    &ubyte  VERA_DC_VSTOP     = VERA_BASE + $000C
+    &ubyte  VERA_L0_CONFIG    = VERA_BASE + $000D
+    &ubyte  VERA_L0_MAPBASE   = VERA_BASE + $000E
+    &ubyte  VERA_L0_TILEBASE  = VERA_BASE + $000F
+    &ubyte  VERA_L0_HSCROLL_L = VERA_BASE + $0010
+    &ubyte  VERA_L0_HSCROLL_H = VERA_BASE + $0011
+    &ubyte  VERA_L0_VSCROLL_L = VERA_BASE + $0012
+    &ubyte  VERA_L0_VSCROLL_H = VERA_BASE + $0013
+    &ubyte  VERA_L1_CONFIG    = VERA_BASE + $0014
+    &ubyte  VERA_L1_MAPBASE   = VERA_BASE + $0015
+    &ubyte  VERA_L1_TILEBASE  = VERA_BASE + $0016
+    &ubyte  VERA_L1_HSCROLL_L = VERA_BASE + $0017
+    &ubyte  VERA_L1_HSCROLL_H = VERA_BASE + $0018
+    &ubyte  VERA_L1_VSCROLL_L = VERA_BASE + $0019
+    &ubyte  VERA_L1_VSCROLL_H = VERA_BASE + $001A
+    &ubyte  VERA_AUDIO_CTRL   = VERA_BASE + $001B
+    &ubyte  VERA_AUDIO_RATE   = VERA_BASE + $001C
+    &ubyte  VERA_AUDIO_DATA   = VERA_BASE + $001D
+    &ubyte  VERA_SPI_DATA     = VERA_BASE + $001E
+    &ubyte  VERA_SPI_CTRL     = VERA_BASE + $001F
+; VERA_PSG_BASE     = $1F9C0
+; VERA_PALETTE_BASE = $1FA00
+; VERA_SPRITES_BASE = $1FC00
+
+; I/O
+
+    const uword  via1  = $9f60                  ;VIA 6522 #1
+    &ubyte  d1prb	= via1+0
+    &ubyte  d1pra	= via1+1
+    &ubyte  d1ddrb	= via1+2
+    &ubyte  d1ddra	= via1+3
+    &ubyte  d1t1l	= via1+4
+    &ubyte  d1t1h	= via1+5
+    &ubyte  d1t1ll	= via1+6
+    &ubyte  d1t1lh	= via1+7
+    &ubyte  d1t2l	= via1+8
+    &ubyte  d1t2h	= via1+9
+    &ubyte  d1sr	= via1+10
+    &ubyte  d1acr	= via1+11
+    &ubyte  d1pcr	= via1+12
+    &ubyte  d1ifr	= via1+13
+    &ubyte  d1ier	= via1+14
+    &ubyte  d1ora	= via1+15
+
+    const uword  via2  = $9f70                  ;VIA 6522 #2
+    &ubyte  d2prb	=via2+0
+    &ubyte  d2pra	=via2+1
+    &ubyte  d2ddrb	=via2+2
+    &ubyte  d2ddra	=via2+3
+    &ubyte  d2t1l	=via2+4
+    &ubyte  d2t1h	=via2+5
+    &ubyte  d2t1ll	=via2+6
+    &ubyte  d2t1lh	=via2+7
+    &ubyte  d2t2l	=via2+8
+    &ubyte  d2t2h	=via2+9
+    &ubyte  d2sr	=via2+10
+    &ubyte  d2acr	=via2+11
+    &ubyte  d2pcr	=via2+12
+    &ubyte  d2ifr	=via2+13
+    &ubyte  d2ier	=via2+14
+    &ubyte  d2ora	=via2+15
+
+
+; ---- Commander X-16 additions on top of C64 kernal routines ----
+; spelling of the names is taken from the Commander X-16 rom sources
+
+; supported C128 additions
+romsub $ff4a = close_all(ubyte device @A)  clobbers(A,X,Y)
+romsub $ff59 = lkupla(ubyte la @A)  clobbers(A,X,Y)
+romsub $ff5c = lkupsa(ubyte sa @Y)  clobbers(A,X,Y)
+romsub $ff5f = screen_set_mode(ubyte mode @A)  clobbers(A, X, Y) -> ubyte @Pc
+romsub $ff62 = screen_set_charset(ubyte charset @A, uword charsetptr @XY)  clobbers(A,X,Y)      ; incompatible with C128  dlchr()
+; not yet supported: romsub $ff65 = pfkey()  clobbers(A,X,Y)
+romsub $ff6e = jsrfar()
+romsub $ff74 = fetch(ubyte bank @X, ubyte index @Y)  clobbers(X) -> ubyte @A
+romsub $ff77 = stash(ubyte data @A, ubyte bank @X, ubyte index @Y)  clobbers(X)
+romsub $ff7a = cmpare(ubyte data @A, ubyte bank @X, ubyte index @Y)  clobbers(X)
+romsub $ff7d = primm()
+
+; X16 additions
+romsub $ff44 = macptr()  clobbers(A,X,Y)
+romsub $ff47 = enter_basic(ubyte cold_or_warm @Pc)  clobbers(A,X,Y)
+romsub $ff68 = mouse_config(ubyte shape @A, ubyte scale @X)  clobbers (A, X, Y)
+romsub $ff6b = mouse_get(ubyte zpdataptr @X)  clobbers(A)
+romsub $ff71 = mouse_scan()  clobbers(A, X, Y)
+romsub $ff53 = joystick_scan()  clobbers(A, X, Y)
+romsub $ff56 = joystick_get(ubyte joynr @A) -> ubyte @A, ubyte @X, ubyte @Y
+romsub $ff4d = clock_set_date_time()  clobbers(A, X, Y)      ; args: r0, r1, r2, r3L
+romsub $ff50 = clock_get_date_time()  clobbers(A, X, Y)      ; outout args: r0, r1, r2, r3L
+
+; TODO specify the correct clobbers for alle these functions below, we now assume all 3 regs are clobbered
+
+; high level graphics & fonts
+romsub $ff20 = GRAPH_init()  clobbers(A,X,Y)           ; uses vectors=r0
+romsub $ff23 = GRAPH_clear()  clobbers(A,X,Y)
+romsub $ff26 = GRAPH_set_window()  clobbers(A,X,Y)      ; uses x=r0, y=r1, width=r2, height=r3
+romsub $ff29 = GRAPH_set_colors(ubyte stroke @A, ubyte fill @X, ubyte background @Y)  clobbers (A,X,Y)
+romsub $ff2c = GRAPH_draw_line()  clobbers(A,X,Y)       ; uses x1=r0, y1=r1, x2=r2, y2=r3
+romsub $ff2f = GRAPH_draw_rect(ubyte fill @Pc)  clobbers(A,X,Y)   ; uses x=r0, y=r1, width=r2, height=r3, cornerradius=r4
+romsub $ff32 = GRAPH_move_rect()  clobbers(A,X,Y)       ; uses sx=r0, sy=r1, tx=r2, ty=r3, width=r4, height=r5
+romsub $ff35 = GRAPH_draw_oval(ubyte fill @Pc)  clobbers(A,X,Y)       ; uses x=r0, y=r1, width=r2, height=r3
+romsub $ff38 = GRAPH_draw_image()  clobbers(A,X,Y)      ; uses x=r0, y=r1, ptr=r2, width=r3, height=r4
+romsub $ff3b = GRAPH_set_font()  clobbers(A,X,Y)         ; uses ptr=r0
+romsub $ff3e = GRAPH_get_char_size(ubyte baseline @A, ubyte width @X, ubyte height_or_style @Y, ubyte is_control @Pc)  clobbers(A,X,Y)
+romsub $ff41 = GRAPH_put_char(ubyte char @A)  clobbers(A,X,Y)   ; uses x=r0, y=r1
+
+; framebuffer
+romsub $fef6 = FB_init()  clobbers(A,X,Y)
+romsub $fef9 = FB_get_info()  clobbers(X,Y) -> byte @A    ; also outputs width=r0, height=r1
+romsub $fefc = FB_set_palette(ubyte index @A, ubyte bytecount @X)  clobbers(A,X,Y)      ; also uses pointer=r0
+romsub $feff = FB_cursor_position()  clobbers(A,X,Y)    ; uses x=r0, y=r1
+romsub $ff02 = FB_cursor_next_line()  clobbers(A,X,Y)   ; uses x=r0
+romsub $ff05 = FB_get_pixel()  clobbers(X,Y) -> ubyte @A
+romsub $ff08 = FB_get_pixels()  clobbers(A,X,Y)         ; uses ptr=r0, count=r1
+romsub $ff0b = FB_set_pixel(ubyte color @A)  clobbers(A,X,Y)
+romsub $ff0e = FB_set_pixels()  clobbers(A,X,Y)         ; uses ptr=r0, count=r1
+romsub $ff11 = FB_set_8_pixels(ubyte pattern @A, ubyte color @X)  clobbers(A,X,Y)
+romsub $ff14 = FB_set_8_pixels_opaque(ubyte pattern @A, ubyte color1 @X, ubyte color2 @Y)  clobbers(A,X,Y)  ; also uses mask=r0L
+romsub $ff17 = FB_fill_pixels(ubyte color @A)  clobbers(A,X,Y)   ; also uses count=r0, step=r1
+romsub $ff1a = FB_filter_pixels()  clobbers(A,X,Y)      ; uses ptr=r0, count=r1
+romsub $ff1d = FB_move_pixels()  clobbers(A,X,Y)        ; uses sx=r0, sy=r1, tx=r2, ty=r3, count=r4
+
+; misc
+romsub $fef0 = sprite_set_image(ubyte number @A, ubyte width @X, ubyte height @Y, ubyte apply_mask @Pc)  clobbers(A,X,Y) -> ubyte @Pc  ; also uses pixels=r0, mask=r1, bpp=r2L
+romsub $fef3 = sprite_set_position(ubyte number @A)  clobbers(A,X,Y)  ; also uses x=r0 and y=r1
+romsub $fee4 = memory_fill(ubyte value @A)  clobbers(A,X,Y)      ; uses address=r0, num_bytes=r1
+romsub $fee7 = memory_copy()  clobbers(A,X,Y)                    ; uses source=r0, target=r1, num_bytes=r2
+romsub $feea = memory_crc()  clobbers(A,X,Y)                     ; uses address=r0, num_bytes=r1     result->r2
+romsub $feed = memory_decompress()  clobbers(A,X,Y)              ; uses input=r0, output=r1     result->r1
+romsub $fedb = console_init()  clobbers(A,X,Y)           ; uses x=r0, y=r1, width=r2, height=r3
+romsub $fede = console_put_char(ubyte char @A, ubyte wrapping @Pc)  clobbers(A,X,Y)
+romsub $fee1 = console_get_char()  clobbers(X,Y) -> ubyte @A
+romsub $fed8 = console_put_image()  clobbers(A,X,Y)      ; uses ptr=r0, width=r1, height=r2
+romsub $fed5 = console_set_paging_message()  clobbers(A,X,Y)     ; uses messageptr=r0
+romsub $fed2 = kbdbuf_put(ubyte key @A)  clobbers(A,X,Y)
+romsub $fecf = entropy_get() -> ubyte @A, ubyte @X, ubyte @Y
+romsub $fecc = monitor()  clobbers(A,X,Y)
+
+
+
+; ---- end of kernal routines ----
+
+asmsub init_system()  {
+    ; Initializes the machine to a sane starting state.
+    ; Called automatically by the loader program logic.
+    %asm {{
+        sei
+        cld
+        ;stz  $00
+        ;stz  $01
+        ;stz  d1prb      ; select rom bank 0
+        lda  #$80
+        sta  VERA_CTRL
+        jsr  c64.IOINIT
+        jsr  c64.RESTOR
+        jsr  c64.CINT
+        lda  #$90       ; black
+        jsr  c64.CHROUT
+        lda  #1         ; swap fg/bg
+        jsr  c64.CHROUT
+        lda  #$9e       ; yellow
+        jsr  c64.CHROUT
+        lda  #147       ; clear screen
+        jsr  c64.CHROUT
+        lda  #0
+        tax
+        tay
+        clc
+        clv
+        cli
+        rts
+    }}
+}
+
+asmsub  reset_system()  {
+    ; Soft-reset the system back to Basic prompt.
+    %asm {{
+        sei
+        lda  #14
+        sta  $01
+        stz  cx16.d1prb         ; bank the kernal in
+        jmp  (cx16.RESET_VEC)
+    }}
+}
+
+}

compiler/res/prog8lib/cx16/textio.p8

@@ -0,0 +1,696 @@
+; Prog8 definitions for the Text I/O and Screen routines for the CommanderX16
+;
+; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
+;
+; indent format: TABS, size=8
+
+%target cx16
+%import syslib
+%import conv
+
+
+txt {
+
+const ubyte DEFAULT_WIDTH = 80
+const ubyte DEFAULT_HEIGHT = 60
+
+
+sub  clear_screen() {
+    clear_screenchars(' ')
+}
+
+asmsub  fill_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
+	; ---- fill the character screen with the given fill character and character color.
+	%asm {{
+	    sty  _ly+1
+        phx
+        pha
+        jsr  c64.SCREEN             ; get dimensions in X/Y
+        txa
+        lsr  a
+        lsr  a
+        sta  _lx+1
+        stz  cx16.VERA_CTRL
+        lda  #%00010000
+        sta  cx16.VERA_ADDR_H       ; enable auto increment by 1, bank 0.
+        stz  cx16.VERA_ADDR_L       ; start at (0,0)
+        stz  cx16.VERA_ADDR_M
+        pla
+_lx     ldx  #0                     ; modified
+        phy
+_ly     ldy  #1                     ; modified
+-       sta  cx16.VERA_DATA0
+        sty  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA0
+        sty  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA0
+        sty  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA0
+        sty  cx16.VERA_DATA0
+        dex
+        bne  -
+        ply
+        dey
+        beq  +
+        stz  cx16.VERA_ADDR_L
+        inc  cx16.VERA_ADDR_M       ; next line
+        bra  _lx
++       plx
+        rts
+        }}
+}
+
+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 {{
+        phx
+        pha
+        jsr  c64.SCREEN             ; get dimensions in X/Y
+        txa
+        lsr  a
+        lsr  a
+        sta  _lx+1
+        stz  cx16.VERA_CTRL
+        lda  #%00100000
+        sta  cx16.VERA_ADDR_H       ; enable auto increment by 2, bank 0.
+        stz  cx16.VERA_ADDR_L       ; start at (0,0)
+        stz  cx16.VERA_ADDR_M
+        pla
+_lx     ldx  #0                     ; modified
+-       sta  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA0
+        dex
+        bne  -
+        dey
+        beq  +
+        stz  cx16.VERA_ADDR_L
+        inc  cx16.VERA_ADDR_M       ; next line
+        bra  _lx
++       plx
+        rts
+        }}
+}
+
+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 {{
+        phx
+        sta  _la+1
+        jsr  c64.SCREEN             ; get dimensions in X/Y
+        txa
+        lsr  a
+        lsr  a
+        sta  _lx+1
+        stz  cx16.VERA_CTRL
+        lda  #%00100000
+        sta  cx16.VERA_ADDR_H       ; enable auto increment by 2, bank 0.
+        lda  #1
+        sta  cx16.VERA_ADDR_L       ; start at (1,0)
+        stz  cx16.VERA_ADDR_M
+_lx     ldx  #0                     ; modified
+_la     lda  #0                     ; modified
+-       sta  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA0
+        dex
+        bne  -
+        dey
+        beq  +
+        lda  #1
+        sta  cx16.VERA_ADDR_L
+        inc  cx16.VERA_ADDR_M       ; next line
+        bra  _lx
++       plx
+        rts
+        }}
+}
+
+
+ubyte[16] color_to_charcode = [$90,$05,$1c,$9f,$9c,$1e,$1f,$9e,$81,$95,$96,$97,$98,$99,$9a,$9b]
+
+sub color (ubyte txtcol) {
+    c64.CHROUT(color_to_charcode[txtcol & 15])
+}
+
+sub color2 (ubyte txtcol, ubyte bgcol) {
+    c64.CHROUT(color_to_charcode[bgcol & 15])
+    c64.CHROUT(1)       ; switch fg and bg colors
+    c64.CHROUT(color_to_charcode[txtcol & 15])
+}
+
+sub lowercase() {
+    cx16.screen_set_charset(3, 0)  ; lowercase charset
+}
+
+sub uppercase() {
+    cx16.screen_set_charset(2, 0)  ; uppercase charset
+}
+
+asmsub  scroll_left  (ubyte dummy @ Pc) clobbers(A, Y)  {
+	; ---- scroll the whole screen 1 character to the left
+	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
+	;      Carry flag is a dummy on the cx16
+	%asm {{
+	    phx
+	    jsr  c64.SCREEN
+	    dex
+	    stx  _lx+1
+        dey
+        sty  P8ZP_SCRATCH_B1    ; number of rows to scroll
+
+_nextline
+        stz  cx16.VERA_CTRL     ; data port 0: source column
+        lda  #%00010000         ; auto increment 1
+        sta  cx16.VERA_ADDR_H
+        lda  #2
+        sta  cx16.VERA_ADDR_L   ; begin in column 1
+        ldy  P8ZP_SCRATCH_B1
+        sty  cx16.VERA_ADDR_M
+        lda  #1
+        sta  cx16.VERA_CTRL     ; data port 1: destination column
+        lda  #%00010000         ; auto increment 1
+        sta  cx16.VERA_ADDR_H
+        stz  cx16.VERA_ADDR_L
+        sty  cx16.VERA_ADDR_M
+
+_lx     ldx  #0                ; modified
+-       lda  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA1    ; copy char
+        lda  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA1    ; copy color
+        dex
+        bne  -
+        dec  P8ZP_SCRATCH_B1
+        bpl  _nextline
+
+        lda  #0
+        sta  cx16.VERA_CTRL
+	    plx
+	    rts
+	}}
+}
+
+asmsub  scroll_right  (ubyte dummy @ Pc) 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
+	    dex
+	    stx  _lx+1
+	    txa
+	    asl  a
+	    dea
+	    sta  _rcol+1
+	    ina
+	    ina
+	    sta  _rcol2+1
+        dey
+        sty  P8ZP_SCRATCH_B1    ; number of rows to scroll
+
+_nextline
+        stz  cx16.VERA_CTRL     ; data port 0: source column
+        lda  #%00011000         ; auto decrement 1
+        sta  cx16.VERA_ADDR_H
+_rcol   lda  #79*2-1             ; modified
+        sta  cx16.VERA_ADDR_L   ; begin in rightmost column minus one
+        ldy  P8ZP_SCRATCH_B1
+        sty  cx16.VERA_ADDR_M
+        lda  #1
+        sta  cx16.VERA_CTRL     ; data port 1: destination column
+        lda  #%00011000         ; auto decrement 1
+        sta  cx16.VERA_ADDR_H
+_rcol2  lda  #79*2+1            ; modified
+        sta  cx16.VERA_ADDR_L
+        sty  cx16.VERA_ADDR_M
+
+_lx     ldx  #0                 ; modified
+-       lda  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA1    ; copy char
+        lda  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA1    ; copy color
+        dex
+        bne  -
+        dec  P8ZP_SCRATCH_B1
+        bpl  _nextline
+
+        lda  #0
+        sta  cx16.VERA_CTRL
+	    plx
+	    rts
+	}}
+}
+
+asmsub  scroll_up  (ubyte dummy @ Pc) 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
+	    stx  _nextline+1
+	    dey
+        sty  P8ZP_SCRATCH_B1
+        stz  cx16.VERA_CTRL         ; data port 0 is source
+        lda  #1
+        sta  cx16.VERA_ADDR_M       ; start at second line
+        stz  cx16.VERA_ADDR_L
+        lda  #%00010000
+        sta  cx16.VERA_ADDR_H       ; enable auto increment by 1, bank 0.
+
+        lda  #1
+        sta  cx16.VERA_CTRL         ; data port 1 is destination
+        stz  cx16.VERA_ADDR_M       ; start at top line
+        stz  cx16.VERA_ADDR_L
+        lda  #%00010000
+        sta  cx16.VERA_ADDR_H       ; enable auto increment by 1, bank 0.
+
+_nextline
+        ldx  #80        ; modified
+-       lda  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA1        ; copy char
+        lda  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA1        ; copy color
+        dex
+        bne  -
+        dec  P8ZP_SCRATCH_B1
+        beq  +
+        stz  cx16.VERA_CTRL         ; data port 0
+        stz  cx16.VERA_ADDR_L
+        inc  cx16.VERA_ADDR_M
+        lda  #1
+        sta  cx16.VERA_CTRL         ; data port 1
+        stz  cx16.VERA_ADDR_L
+        inc  cx16.VERA_ADDR_M
+        bra  _nextline
+
++       lda  #0
+        sta  cx16.VERA_CTRL
+	    plx
+	    rts
+	}}
+}
+
+asmsub  scroll_down  (ubyte dummy @ Pc) 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
+	    stx  _nextline+1
+	    dey
+        sty  P8ZP_SCRATCH_B1
+        stz  cx16.VERA_CTRL         ; data port 0 is source
+        dey
+        sty  cx16.VERA_ADDR_M       ; start at line before bottom line
+        stz  cx16.VERA_ADDR_L
+        lda  #%00010000
+        sta  cx16.VERA_ADDR_H       ; enable auto increment by 1, bank 0.
+
+        lda  #1
+        sta  cx16.VERA_CTRL         ; data port 1 is destination
+        iny
+        sty  cx16.VERA_ADDR_M       ; start at bottom line
+        stz  cx16.VERA_ADDR_L
+        lda  #%00010000
+        sta  cx16.VERA_ADDR_H       ; enable auto increment by 1, bank 0.
+
+_nextline
+        ldx  #80        ; modified
+-       lda  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA1        ; copy char
+        lda  cx16.VERA_DATA0
+        sta  cx16.VERA_DATA1        ; copy color
+        dex
+        bne  -
+        dec  P8ZP_SCRATCH_B1
+        beq  +
+        stz  cx16.VERA_CTRL         ; data port 0
+        stz  cx16.VERA_ADDR_L
+        dec  cx16.VERA_ADDR_M
+        lda  #1
+        sta  cx16.VERA_CTRL         ; data port 1
+        stz  cx16.VERA_ADDR_L
+        dec  cx16.VERA_ADDR_M
+        bra  _nextline
+
++       lda  #0
+        sta  cx16.VERA_CTRL
+	    plx
+	    rts
+	}}
+}
+
+romsub $FFD2 = chrout(ubyte char @ A)    ; for consistency. You can also use c64.CHROUT directly ofcourse.
+
+asmsub  print (str text @ AY) clobbers(A,Y)  {
+	; ---- print null terminated string from A/Y
+	; note: the compiler contains an optimization that will replace
+	;       a call to this subroutine with a string argument of just one char,
+	;       by just one call to c64.CHROUT of that single char.
+	%asm {{
+		sta  P8ZP_SCRATCH_B1
+		sty  P8ZP_SCRATCH_REG
+		ldy  #0
+-		lda  (P8ZP_SCRATCH_B1),y
+		beq  +
+		jsr  c64.CHROUT
+		iny
+		bne  -
++		rts
+	}}
+}
+
+asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
+	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
+	%asm {{
+		phx
+		jsr  conv.ubyte2decimal
+		pha
+		tya
+		jsr  c64.CHROUT
+		pla
+		jsr  c64.CHROUT
+		txa
+		jsr  c64.CHROUT
+		plx
+		rts
+	}}
+}
+
+asmsub  print_ub  (ubyte value @ A) clobbers(A,Y)  {
+	; ---- print the ubyte in A in decimal form, without left padding 0s
+	%asm {{
+		phx
+		jsr  conv.ubyte2decimal
+_print_byte_digits
+		pha
+		cpy  #'0'
+		beq  +
+		tya
+		jsr  c64.CHROUT
+		pla
+		jsr  c64.CHROUT
+		jmp  _ones
++       pla
+        cmp  #'0'
+        beq  _ones
+        jsr  c64.CHROUT
+_ones   txa
+		jsr  c64.CHROUT
+		plx
+		rts
+	}}
+}
+
+asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
+	; ---- print the byte in A in decimal form, without left padding 0s
+	%asm {{
+		phx
+		pha
+		cmp  #0
+		bpl  +
+		lda  #'-'
+		jsr  c64.CHROUT
++		pla
+		jsr  conv.byte2decimal
+		jmp  print_ub._print_byte_digits
+	}}
+}
+
+asmsub  print_ubhex  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
+	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
+	%asm {{
+		phx
+		bcc  +
+		pha
+		lda  #'$'
+		jsr  c64.CHROUT
+		pla
++		jsr  conv.ubyte2hex
+		jsr  c64.CHROUT
+		tya
+		jsr  c64.CHROUT
+		plx
+		rts
+	}}
+}
+
+asmsub  print_ubbin  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
+	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
+	%asm {{
+		phx
+		sta  P8ZP_SCRATCH_B1
+		bcc  +
+		lda  #'%'
+		jsr  c64.CHROUT
++		ldy  #8
+-		lda  #'0'
+		asl  P8ZP_SCRATCH_B1
+		bcc  +
+		lda  #'1'
++		jsr  c64.CHROUT
+		dey
+		bne  -
+		plx
+		rts
+	}}
+}
+
+asmsub  print_uwbin  (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y)  {
+	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
+	%asm {{
+		pha
+		tya
+		jsr  print_ubbin
+		pla
+		clc
+		jmp  print_ubbin
+	}}
+}
+
+asmsub  print_uwhex  (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y)  {
+	; ---- print the uword in A/Y in hexadecimal form (4 digits)
+	;      (if Carry is set, a radix prefix '$' is printed as well)
+	%asm {{
+		pha
+		tya
+		jsr  print_ubhex
+		pla
+		clc
+		jmp  print_ubhex
+	}}
+}
+
+asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
+	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
+	%asm {{
+	    phx
+		jsr  conv.uword2decimal
+		ldy  #0
+-		lda  conv.uword2decimal.decTenThousands,y
+        beq  +
+		jsr  c64.CHROUT
+		iny
+		bne  -
++		plx
+		rts
+	}}
+}
+
+asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
+	; ---- print the uword in A/Y in decimal form, without left padding 0s
+	%asm {{
+	    phx
+		jsr  conv.uword2decimal
+		plx
+		ldy  #0
+-		lda  conv.uword2decimal.decTenThousands,y
+		beq  _allzero
+		cmp  #'0'
+		bne  _gotdigit
+		iny
+		bne  -
+
+_gotdigit
+		jsr  c64.CHROUT
+		iny
+		lda  conv.uword2decimal.decTenThousands,y
+		bne  _gotdigit
+		rts
+_allzero
+        lda  #'0'
+        jmp  c64.CHROUT
+	}}
+}
+
+asmsub  print_w  (word value @ AY) clobbers(A,Y)  {
+	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
+	%asm {{
+		cpy  #0
+		bpl  +
+		pha
+		lda  #'-'
+		jsr  c64.CHROUT
+		tya
+		eor  #255
+		tay
+		pla
+		eor  #255
+		clc
+		adc  #1
+		bcc  +
+		iny
++		jmp  print_uw
+	}}
+}
+
+asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
+	; ---- Input a string (max. 80 chars) from the keyboard. Returns length in Y. (string is terminated with a 0 byte as well)
+	;      It assumes the keyboard is selected as I/O channel!
+
+	%asm {{
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		ldy  #0				; char counter = 0
+-		jsr  c64.CHRIN
+		cmp  #$0d			; return (ascii 13) pressed?
+		beq  +				; yes, end.
+		sta  (P8ZP_SCRATCH_W1),y	; else store char in buffer
+		iny
+		bne  -
++		lda  #0
+		sta  (P8ZP_SCRATCH_W1),y	; finish string with 0 byte
+		rts
+
+	}}
+}
+
+asmsub  setchr  (ubyte col @X, ubyte row @Y, ubyte character @A) clobbers(A)  {
+	; ---- sets the character in the screen matrix at the given position
+	%asm {{
+		pha
+		txa
+		asl  a
+        stz  cx16.VERA_CTRL
+		stz  cx16.VERA_ADDR_H
+		sta  cx16.VERA_ADDR_L
+		sty  cx16.VERA_ADDR_M
+		pla
+        sta  cx16.VERA_DATA0
+		rts
+	}}
+}
+
+asmsub  getchr  (ubyte col @A, ubyte row @Y) -> ubyte @ A {
+	; ---- get the character in the screen matrix at the given location
+	%asm  {{
+		asl  a
+        stz  cx16.VERA_CTRL
+		stz  cx16.VERA_ADDR_H
+		sta  cx16.VERA_ADDR_L
+		sty  cx16.VERA_ADDR_M
+        lda  cx16.VERA_DATA0
+		rts
+	}}
+}
+
+asmsub  setclr  (ubyte col @X, ubyte row @Y, ubyte color @A) clobbers(A)  {
+	; ---- set the color in A on the screen matrix at the given position
+	%asm {{
+		pha
+		txa
+		asl  a
+		ina
+        stz  cx16.VERA_CTRL
+		stz  cx16.VERA_ADDR_H
+		sta  cx16.VERA_ADDR_L
+		sty  cx16.VERA_ADDR_M
+		pla
+        sta  cx16.VERA_DATA0
+		rts
+	}}
+}
+
+asmsub  getclr  (ubyte col @A, ubyte row @Y) -> ubyte @ A {
+	; ---- get the color in the screen color matrix at the given location
+	%asm  {{
+		asl  a
+		ina
+        stz  cx16.VERA_CTRL
+		stz  cx16.VERA_ADDR_H
+		sta  cx16.VERA_ADDR_L
+		sty  cx16.VERA_ADDR_M
+        lda  cx16.VERA_DATA0
+		rts
+	}}
+}
+
+sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
+	; ---- set char+color at the given position on the screen
+	%asm {{
+	    phx
+		lda  column
+		asl  a
+		tax
+		ldy  row
+		lda  charcolor
+		and  #$0f
+	    sta  P8ZP_SCRATCH_B1
+        stz  cx16.VERA_CTRL
+        stz  cx16.VERA_ADDR_H
+        stx  cx16.VERA_ADDR_L
+        sty  cx16.VERA_ADDR_M
+        lda  char
+        sta  cx16.VERA_DATA0
+        inx
+        stz  cx16.VERA_ADDR_H
+        stx  cx16.VERA_ADDR_L
+        sty  cx16.VERA_ADDR_M
+        lda  cx16.VERA_DATA0
+        and  #$f0
+        ora  P8ZP_SCRATCH_B1
+        sta  cx16.VERA_DATA0
+		plx
+		rts
+    }}
+}
+
+asmsub  plot  (ubyte col @ Y, ubyte row @ A) clobbers(A) {
+	; ---- safe wrapper around PLOT kernel routine, to save the X register.
+	%asm  {{
+		phx
+		tax
+		clc
+		jsr  c64.PLOT
+		plx
+		rts
+	}}
+}
+
+asmsub width() clobbers(X,Y) -> ubyte @A {
+    ; -- returns the text screen width (number of columns)
+    %asm {{
+        jsr  c64.SCREEN
+        txa
+        rts
+    }}
+}
+
+asmsub height() clobbers(X, Y) -> ubyte @A {
+    ; -- returns the text screen height (number of rows)
+    %asm {{
+        jsr  c64.SCREEN
+        tya
+        rts
+    }}
+}
+
+}

compiler/res/prog8lib/cx16lib.p8

@@ -1,221 +0,0 @@
-; Prog8 definitions for the CommanderX16
-; Including memory registers, I/O registers, Basic and Kernal subroutines.
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8
-
-
-c64 {
-
-; ---- kernal routines, these are the same as on the Commodore-64 (hence the same block name) ----
-
-; STROUT --> use screen.print
-; CLEARSCR -> use screen.clear_screen
-; HOMECRSR -> use screen.plot
-
-romsub $FF81 = CINT() clobbers(A,X,Y)                           ; (alias: SCINIT) initialize screen editor and video chip
-romsub $FF84 = IOINIT() clobbers(A, X)                          ; initialize I/O devices (CIA, SID, IRQ)
-romsub $FF87 = RAMTAS() clobbers(A,X,Y)                         ; initialize RAM, tape buffer, screen
-romsub $FF8A = RESTOR() clobbers(A,X,Y)                         ; restore default I/O vectors
-romsub $FF8D = VECTOR(uword userptr @ XY, ubyte dir @ Pc) clobbers(A,Y)     ; read/set I/O vector table
-romsub $FF90 = SETMSG(ubyte value @ A)                          ; set Kernal message control flag
-romsub $FF93 = SECOND(ubyte address @ A) clobbers(A)            ; (alias: LSTNSA) send secondary address after LISTEN
-romsub $FF96 = TKSA(ubyte address @ A) clobbers(A)              ; (alias: TALKSA) send secondary address after TALK
-romsub $FF99 = MEMTOP(uword address @ XY, ubyte dir @ Pc) -> uword @ XY     ; read/set top of memory  pointer
-romsub $FF9C = MEMBOT(uword address @ XY, ubyte dir @ Pc) -> uword @ XY     ; read/set bottom of memory  pointer
-romsub $FF9F = SCNKEY() clobbers(A,X,Y)                         ; scan the keyboard
-romsub $FFA2 = SETTMO(ubyte timeout @ A)                        ; set time-out flag for IEEE bus
-romsub $FFA5 = ACPTR() -> ubyte @ A                             ; (alias: IECIN) input byte from serial bus
-romsub $FFA8 = CIOUT(ubyte databyte @ A)                        ; (alias: IECOUT) output byte to serial bus
-romsub $FFAB = UNTLK() clobbers(A)                              ; command serial bus device to UNTALK
-romsub $FFAE = UNLSN() clobbers(A)                              ; command serial bus device to UNLISTEN
-romsub $FFB1 = LISTEN(ubyte device @ A) clobbers(A)             ; command serial bus device to LISTEN
-romsub $FFB4 = TALK(ubyte device @ A) clobbers(A)               ; command serial bus device to TALK
-romsub $FFB7 = READST() -> ubyte @ A                            ; read I/O status word
-romsub $FFBA = SETLFS(ubyte logical @ A, ubyte device @ X, ubyte address @ Y)   ; set logical file parameters
-romsub $FFBD = SETNAM(ubyte namelen @ A, str filename @ XY)     ; set filename parameters
-romsub $FFC0 = OPEN() clobbers(A,X,Y)                           ; (via 794 ($31A)) open a logical file
-romsub $FFC3 = CLOSE(ubyte logical @ A) clobbers(A,X,Y)         ; (via 796 ($31C)) close a logical file
-romsub $FFC6 = CHKIN(ubyte logical @ X) clobbers(A,X)           ; (via 798 ($31E)) define an input channel
-romsub $FFC9 = CHKOUT(ubyte logical @ X) clobbers(A,X)          ; (via 800 ($320)) define an output channel
-romsub $FFCC = CLRCHN() clobbers(A,X)                           ; (via 802 ($322)) restore default devices
-romsub $FFCF = CHRIN() clobbers(Y) -> ubyte @ A                 ; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
-romsub $FFD2 = CHROUT(ubyte char @ A)                           ; (via 806 ($326)) output a character
-romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> ubyte @Pc, ubyte @ A, ubyte @ X, ubyte @ Y     ; (via 816 ($330)) load from device
-romsub $FFD8 = SAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) -> ubyte @ Pc, ubyte @ A                    ; (via 818 ($332)) save to a device
-romsub $FFDB = SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y)      ; set the software clock
-romsub $FFDE = RDTIM() -> ubyte @ A, ubyte @ X, ubyte @ Y       ; read the software clock
-romsub $FFE1 = STOP() clobbers(A,X) -> ubyte @ Pz, ubyte @ Pc   ; (via 808 ($328)) check the STOP key
-romsub $FFE4 = GETIN() clobbers(X,Y) -> ubyte @ A               ; (via 810 ($32A)) get a character
-romsub $FFE7 = CLALL() clobbers(A,X)                            ; (via 812 ($32C)) close all files
-romsub $FFEA = UDTIM() clobbers(A,X)                            ; update the software clock
-romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; read number of screen rows and columns
-romsub $FFF0 = PLOT(ubyte col @ Y, ubyte row @ X, ubyte dir @ Pc) -> ubyte @ X, ubyte @ Y       ; read/set position of cursor on screen.  Use screen.plot for a 'safe' wrapper that preserves X.
-romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base address of I/O devices
-
-}
-
-cx16 {
-
-; ---- Commander X-16 additions on top of C64 kernal routines ----
-; spelling of the names is taken from the Commander X-16 rom sources
-
-; the sixteen virtual 16-bit registers
-    &uword r0  = $02
-    &uword r1  = $04
-    &uword r2  = $06
-    &uword r3  = $08
-    &uword r4  = $0a
-    &uword r5  = $0c
-    &uword r6  = $0e
-    &uword r7  = $10
-    &uword r8  = $12
-    &uword r9  = $14
-    &uword r10 = $16
-    &uword r11 = $18
-    &uword r12 = $1a
-    &uword r13 = $1c
-    &uword r14 = $1e
-    &uword r15 = $20
-
-; VERA registers
-
-    const uword VERA_BASE = $9F20
-    &uword VERA_ADDR_L   	 = VERA_BASE + $00
-    &uword VERA_ADDR_M   	 = VERA_BASE + $01
-    &uword VERA_ADDR_H   	 = VERA_BASE + $02
-    &uword VERA_DATA0        = VERA_BASE + $03
-    &uword VERA_DATA1        = VERA_BASE + $04
-    &uword VERA_CTRL         = VERA_BASE + $05
-    &uword VERA_IEN          = VERA_BASE + $06
-    &uword VERA_ISR          = VERA_BASE + $07
-    &uword VERA_IRQ_LINE_L   = VERA_BASE + $08
-    &uword VERA_DC_VIDEO     = VERA_BASE + $09
-    &uword VERA_DC_HSCALE    = VERA_BASE + $0A
-    &uword VERA_DC_VSCALE    = VERA_BASE + $0B
-    &uword VERA_DC_BORDER    = VERA_BASE + $0C
-    &uword VERA_DC_HSTART    = VERA_BASE + $09
-    &uword VERA_DC_HSTOP     = VERA_BASE + $0A
-    &uword VERA_DC_VSTART    = VERA_BASE + $0B
-    &uword VERA_DC_VSTOP     = VERA_BASE + $0C
-    &uword VERA_L0_CONFIG    = VERA_BASE + $0D
-    &uword VERA_L0_MAPBASE   = VERA_BASE + $0E
-    &uword VERA_L0_TILEBASE  = VERA_BASE + $0F
-    &uword VERA_L0_HSCROLL_L = VERA_BASE + $10
-    &uword VERA_L0_HSCROLL_H = VERA_BASE + $11
-    &uword VERA_L0_VSCROLL_L = VERA_BASE + $12
-    &uword VERA_L0_VSCROLL_H = VERA_BASE + $13
-    &uword VERA_L1_CONFIG    = VERA_BASE + $14
-    &uword VERA_L1_MAPBASE   = VERA_BASE + $15
-    &uword VERA_L1_TILEBASE  = VERA_BASE + $16
-    &uword VERA_L1_HSCROLL_L = VERA_BASE + $17
-    &uword VERA_L1_HSCROLL_H = VERA_BASE + $18
-    &uword VERA_L1_VSCROLL_L = VERA_BASE + $19
-    &uword VERA_L1_VSCROLL_H = VERA_BASE + $1A
-    &uword VERA_AUDIO_CTRL   = VERA_BASE + $1B
-    &uword VERA_AUDIO_RATE   = VERA_BASE + $1C
-    &uword VERA_AUDIO_DATA   = VERA_BASE + $1D
-    &uword VERA_SPI_DATA     = VERA_BASE + $1E
-    &uword VERA_SPI_CTRL     = VERA_BASE + $1F
-; VERA_PSG_BASE     = $1F9C0
-; VERA_PALETTE_BASE = $1FA00
-; VERA_SPRITES_BASE = $1FC00
-
-
-; supported C128 additions
-romsub $ff4a = close_all()
-romsub $ff59 = lkupla()
-romsub $ff5c = lkupsa()
-romsub $ff5f = screen_set_mode(ubyte mode @A) clobbers(A, X, Y) -> ubyte @Pc
-romsub $ff62 = screen_set_charset(ubyte charset @A, uword charsetptr @XY) clobbers(A,X,Y)      ; incompatible with C128  dlchr()
-romsub $ff65 = pfkey()
-romsub $ff6e = jsrfar()
-romsub $ff74 = fetch()
-romsub $ff77 = stash()
-romsub $ff7a = cmpare()
-romsub $ff7d = primm()
-
-; X16 additions
-romsub $ff44 = macptr()
-romsub $ff47 = enter_basic(ubyte cold_or_warm @Pc)
-romsub $ff68 = mouse_config(ubyte shape @A, ubyte scale @X) clobbers (A, X, Y)
-romsub $ff6b = mouse_get(ubyte zpdataptr @X) clobbers(A)
-romsub $ff71 = mouse_scan() clobbers(A, X, Y)
-romsub $ff53 = joystick_scan() clobbers(A, X, Y)
-romsub $ff56 = joystick_get(ubyte joynr @A) -> ubyte @A, ubyte @X, ubyte @Y
-romsub $ff4d = clock_set_date_time() clobbers(A, X, Y)      ; args: r0, r1, r2, r3L
-romsub $ff50 = clock_get_date_time() clobbers(A)            ; outout args: r0, r1, r2, r3L
-
-; high level graphics & fonts
-romsub $ff20 = GRAPH_init()             ; uses vectors=r0
-romsub $ff23 = GRAPH_clear()
-romsub $ff26 = GRAPH_set_window()       ; uses x=r0, y=r1, width=r2, height=r3
-romsub $ff29 = GRAPH_set_colors(ubyte stroke @A, ubyte fill @X, ubyte background @Y)
-romsub $ff2c = GRAPH_draw_line()        ; uses x1=r0, y1=r1, x2=r2, y2=r3
-romsub $ff2f = GRAPH_draw_rect(ubyte fill @Pc)        ; uses x=r0, y=r1, width=r2, height=r3, cornerradius=r4
-romsub $ff32 = GRAPH_move_rect()        ; uses sx=r0, sy=r1, tx=r2, ty=r3, width=r4, height=r5
-romsub $ff35 = GRAPH_draw_oval(ubyte fill @Pc)        ; uses x=r0, y=r1, width=r2, height=r3
-romsub $ff38 = GRAPH_draw_image()       ; uses x=r0, y=r1, ptr=r2, width=r3, height=r4
-romsub $ff3b = GRAPH_set_font()         ; uses ptr=r0
-romsub $ff3e = GRAPH_get_char_size(ubyte baseline @A, ubyte width @X, ubyte height_or_style @Y, ubyte is_control @Pc)
-romsub $ff41 = GRAPH_put_char(ubyte char @A)   ; uses x=r0, y=r1
-
-; framebuffer
-romsub $fef6 = FB_init()
-romsub $fef9 = FB_get_info() -> byte @A    ; also outputs width=r0, height=r1
-romsub $fefc = FB_set_palette(ubyte index @A, ubyte bytecount @X)      ; also uses pointer=r0
-romsub $feff = FB_cursor_position()    ; uses x=r0, y=r1
-romsub $ff02 = FB_cursor_next_line()   ; uses x=r0
-romsub $ff05 = FB_get_pixel() -> ubyte @A
-romsub $ff08 = FB_get_pixels()         ; uses ptr=r0, count=r1
-romsub $ff0b = FB_set_pixel(ubyte color @A)
-romsub $ff0e = FB_set_pixels()         ; uses ptr=r0, count=r1
-romsub $ff11 = FB_set_8_pixels(ubyte pattern @A, ubyte color @X)
-romsub $ff14 = FB_set_8_pixels_opaque(ubyte pattern @A, ubyte color1 @X, ubyte color2 @Y)  ; also uses mask=r0L
-romsub $ff17 = FB_fill_pixels(ubyte color @A)   ; also uses count=r0, step=r1
-romsub $ff1a = FB_filter_pixels()      ; uses ptr=r0, count=r1
-romsub $ff1d = FB_move_pixels()        ; uses sx=r0, sy=r1, tx=r2, ty=r3, count=r4
-
-; misc
-romsub $fef0 = sprite_set_image(ubyte number @A, ubyte width @X, ubyte height @Y, ubyte apply_mask @Pc) -> ubyte @Pc  ; also uses pixels=r0, mask=r1, bpp=r2L
-romsub $fef3 = sprite_set_position(ubyte number @A)  ; also uses x=r0 and y=r1
-romsub $fee4 = memory_fill(ubyte value @A)      ; uses address=r0, num_bytes=r1
-romsub $fee7 = memory_copy()                    ; uses source=r0, target=r1, num_bytes=r2
-romsub $feea = memory_crc()                     ; uses address=r0, num_bytes=r1     result->r2
-romsub $feed = memory_decompress()              ; uses input=r0, output=r1     result->r1
-romsub $fedb = console_init()           ; uses x=r0, y=r1, width=r2, height=r3
-romsub $fede = console_put_char(ubyte char @A, ubyte wrapping @Pc)
-romsub $fee1 = console_get_char() -> ubyte @A
-romsub $fed8 = console_put_image()      ; uses ptr=r0, width=r1, height=r2
-romsub $fed5 = console_set_paging_message()     ; uses messageptr=r0
-romsub $fed2 = kbdbuf_put(ubyte key @A)
-romsub $fecf = entropy_get() -> ubyte @A, ubyte @X, ubyte @Y
-romsub $fecc = monitor()
-
-
-
-; ---- end of kernal routines ----
-
-asmsub init_system()  {
-    ; Initializes the machine to a sane starting state.
-    ; Called automatically by the loader program logic.
-    %asm {{
-        sei
-        cld
-        stz  $00
-        stz  $01
-        jsr  c64.IOINIT
-        jsr  c64.RESTOR
-        jsr  c64.CINT
-        lda  #0
-        tax
-        tay
-        clc
-        clv
-        cli
-        rts
-    }}
-}
-
-}

compiler/res/prog8lib/cx16textio.p8

@@ -1,314 +0,0 @@
-; Prog8 definitions for the Text I/O and Screen routines for the CommanderX16
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8
-
-
-%import cx16lib
-%import conv
-
-
-txt {
-
-sub  clear_screen() {
-    c64.CHROUT(147)         ; clear screen (spaces)
-}
-
-
-asmsub  fill_screen (ubyte char @ A, ubyte txtcolor @ Y) clobbers(A)  {
-	; ---- fill the character screen with the given fill character and character color.
-	%asm {{
-        sta  P8ZP_SCRATCH_W1        ; fillchar
-        sty  P8ZP_SCRATCH_W1+1      ; textcolor
-        phx
-        jsr  c64.SCREEN             ; get dimensions in X/Y
-        dex
-        dey
-        txa
-        asl  a
-        adc  #1
-        sta  P8ZP_SCRATCH_B1
--       ldx  P8ZP_SCRATCH_B1
--       stz  cx16.VERA_ADDR_H
-        stx  cx16.VERA_ADDR_L
-        sty  cx16.VERA_ADDR_M
-        lda  cx16.VERA_DATA0
-        and  #$f0
-        ora  P8ZP_SCRATCH_W1+1
-        sta  cx16.VERA_DATA0
-        dex
-        stz  cx16.VERA_ADDR_H
-        stx  cx16.VERA_ADDR_L
-        sty  cx16.VERA_ADDR_M
-        lda  P8ZP_SCRATCH_W1
-        sta  cx16.VERA_DATA0
-        dex
-        cpx  #255
-        bne  -
-        dey
-        bpl  --
-        plx
-        rts
-    }}
-
-}
-
-ubyte[16] color_to_charcode = [$90,$05,$1c,$9f,$9c,$1e,$1f,$9e,$81,$95,$96,$97,$98,$99,$9a,$9b]
-
-sub color (ubyte txtcol) {
-    c64.CHROUT(color_to_charcode[txtcol & 15])
-}
-
-sub color2 (ubyte txtcol, ubyte bgcol) {
-    c64.CHROUT(color_to_charcode[bgcol & 15])
-    c64.CHROUT(1)       ; switch fg and bg colors
-    c64.CHROUT(color_to_charcode[txtcol & 15])
-}
-
-asmsub  print (str text @ AY) clobbers(A,Y)  {
-	; ---- print null terminated string from A/Y
-	; note: the compiler contains an optimization that will replace
-	;       a call to this subroutine with a string argument of just one char,
-	;       by just one call to c64.CHROUT of that single char.
-	%asm {{
-		sta  P8ZP_SCRATCH_B1
-		sty  P8ZP_SCRATCH_REG
-		ldy  #0
--		lda  (P8ZP_SCRATCH_B1),y
-		beq  +
-		jsr  c64.CHROUT
-		iny
-		bne  -
-+		rts
-	}}
-}
-
-asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
-	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
-	%asm {{
-		phx
-		jsr  conv.ubyte2decimal
-		pha
-		tya
-		jsr  c64.CHROUT
-		pla
-		jsr  c64.CHROUT
-		txa
-		jsr  c64.CHROUT
-		plx
-		rts
-	}}
-}
-
-asmsub  print_ub  (ubyte value @ A) clobbers(A,Y)  {
-	; ---- print the ubyte in A in decimal form, without left padding 0s
-	%asm {{
-		phx
-		jsr  conv.ubyte2decimal
-_print_byte_digits
-		pha
-		cpy  #'0'
-		beq  +
-		tya
-		jsr  c64.CHROUT
-		pla
-		jsr  c64.CHROUT
-		jmp  _ones
-+       pla
-        cmp  #'0'
-        beq  _ones
-        jsr  c64.CHROUT
-_ones   txa
-		jsr  c64.CHROUT
-		plx
-		rts
-	}}
-}
-
-asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
-	; ---- print the byte in A in decimal form, without left padding 0s
-	%asm {{
-		phx
-		pha
-		cmp  #0
-		bpl  +
-		lda  #'-'
-		jsr  c64.CHROUT
-+		pla
-		jsr  conv.byte2decimal
-		jmp  print_ub._print_byte_digits
-	}}
-}
-
-asmsub  print_ubhex  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
-	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
-	%asm {{
-		phx
-		bcc  +
-		pha
-		lda  #'$'
-		jsr  c64.CHROUT
-		pla
-+		jsr  conv.ubyte2hex
-		jsr  c64.CHROUT
-		tya
-		jsr  c64.CHROUT
-		plx
-		rts
-	}}
-}
-
-asmsub  print_ubbin  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
-	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
-	%asm {{
-		phx
-		sta  P8ZP_SCRATCH_B1
-		bcc  +
-		lda  #'%'
-		jsr  c64.CHROUT
-+		ldy  #8
--		lda  #'0'
-		asl  P8ZP_SCRATCH_B1
-		bcc  +
-		lda  #'1'
-+		jsr  c64.CHROUT
-		dey
-		bne  -
-		plx
-		rts
-	}}
-}
-
-asmsub  print_uwbin  (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y)  {
-	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
-	%asm {{
-		pha
-		tya
-		jsr  print_ubbin
-		pla
-		clc
-		jmp  print_ubbin
-	}}
-}
-
-asmsub  print_uwhex  (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y)  {
-	; ---- print the uword in A/Y in hexadecimal form (4 digits)
-	;      (if Carry is set, a radix prefix '$' is printed as well)
-	%asm {{
-		pha
-		tya
-		jsr  print_ubhex
-		pla
-		clc
-		jmp  print_ubhex
-	}}
-}
-
-asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
-	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
-	%asm {{
-	    phx
-		jsr  conv.uword2decimal
-		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
-        beq  +
-		jsr  c64.CHROUT
-		iny
-		bne  -
-+		plx
-		rts
-	}}
-}
-
-asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
-	; ---- print the uword in A/Y in decimal form, without left padding 0s
-	%asm {{
-	    phx
-		jsr  conv.uword2decimal
-		plx
-		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
-		beq  _allzero
-		cmp  #'0'
-		bne  _gotdigit
-		iny
-		bne  -
-
-_gotdigit
-		jsr  c64.CHROUT
-		iny
-		lda  conv.uword2decimal.decTenThousands,y
-		bne  _gotdigit
-		rts
-_allzero
-        lda  #'0'
-        jmp  c64.CHROUT
-	}}
-}
-
-asmsub  print_w  (word value @ AY) clobbers(A,Y)  {
-	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
-	%asm {{
-		cpy  #0
-		bpl  +
-		pha
-		lda  #'-'
-		jsr  c64.CHROUT
-		tya
-		eor  #255
-		tay
-		pla
-		eor  #255
-		clc
-		adc  #1
-		bcc  +
-		iny
-+		jmp  print_uw
-	}}
-}
-
-; TODO implement the "missing" txtio subroutines
-
-sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
-	; ---- set char+color at the given position on the screen
-	%asm {{
-	    phx
-		lda  column
-		asl  a
-		tax
-		ldy  row
-		lda  charcolor
-		and  #$0f
-	    sta  P8ZP_SCRATCH_B1
-        stz  cx16.VERA_ADDR_H
-        stx  cx16.VERA_ADDR_L
-        sty  cx16.VERA_ADDR_M
-        lda  char
-        sta  cx16.VERA_DATA0
-        inx
-        stz  cx16.VERA_ADDR_H
-        stx  cx16.VERA_ADDR_L
-        sty  cx16.VERA_ADDR_M
-        lda  cx16.VERA_DATA0
-        and  #$f0
-        ora  P8ZP_SCRATCH_B1
-        sta  cx16.VERA_DATA0
-		plx
-		rts
-    }}
-}
-
-asmsub  plot  (ubyte col @ Y, ubyte row @ A) clobbers(A) {
-	; ---- safe wrapper around PLOT kernel routine, to save the X register.
-	%asm  {{
-		phx
-		tax
-		clc
-		jsr  c64.PLOT
-		plx
-		rts
-	}}
-}
-
-}

compiler/res/prog8lib/math.asm

@@ -11,6 +11,10 @@
 ;	http://codebase64.org/doku.php?id=base:6502_6510_maths
 ;
 
+
+math_store_reg	.byte  0		; temporary storage
+
+
 multiply_bytes	.proc
 	; -- multiply 2 bytes A and Y, result as byte in A  (signed or unsigned)
 		sta  P8ZP_SCRATCH_B1         ; num1
@@ -27,11 +31,11 @@ _enterloop	lsr  P8ZP_SCRATCH_REG
 		.pend
 
 
-multiply_bytes_16	.proc
+multiply_bytes_into_word	.proc
 	; -- multiply 2 bytes A and Y, result as word in A/Y (unsigned)
 		sta  P8ZP_SCRATCH_B1
 		sty  P8ZP_SCRATCH_REG
-		stx  P8ZP_SCRATCH_REG_X
+		stx  math_store_reg
 		lda  #0
 		ldx  #8
 		lsr  P8ZP_SCRATCH_B1
@@ -44,7 +48,7 @@ multiply_bytes_16	.proc
 		bne  -
 		tay
 		lda  P8ZP_SCRATCH_B1
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  math_store_reg
 		rts
 		.pend
 
@@ -57,7 +61,7 @@ multiply_words	.proc
 
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 
 mult16		lda  #0
 		sta  result+2	; clear upper bits of product
@@ -79,7 +83,7 @@ mult16		lda  #0
 		ror  result
 		dex
 		bne  -
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 
 result		.byte  0,0,0,0
@@ -124,7 +128,7 @@ divmod_ub_asm	.proc
 	;    division by zero will result in quotient = 255 and remainder = original number
 		sty  P8ZP_SCRATCH_REG
 		sta  P8ZP_SCRATCH_B1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  math_store_reg
 
 		lda  #0
 		ldx  #8
@@ -137,7 +141,7 @@ divmod_ub_asm	.proc
 		dex
 		bne  -
 		ldy  P8ZP_SCRATCH_B1
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  math_store_reg
 		rts
 		.pend
 
@@ -197,7 +201,7 @@ result = dividend ;save memory by reusing divident to store the result
 
 		sta  _divisor
 		sty  _divisor+1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		lda  #0	        	;preset remainder to 0
 		sta  remainder
 		sta  remainder+1
@@ -224,7 +228,7 @@ result = dividend ;save memory by reusing divident to store the result
 
 		lda  result
 		ldy  result+1
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 _divisor	.word 0
 		.pend
@@ -308,7 +312,8 @@ _seed		.word	$2c9e
 		.pend
 
 
-mul_byte_3	.proc
+; ----------- optimized multiplications (stack) : ---------
+stack_mul_byte_3	.proc
 		; X + X*2
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -318,7 +323,7 @@ mul_byte_3	.proc
 		rts
 		.pend
 
-mul_word_3	.proc
+stack_mul_word_3	.proc
 		; W*2 + W
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_REG
@@ -335,7 +340,7 @@ mul_word_3	.proc
 		.pend
 
 
-mul_byte_5	.proc
+stack_mul_byte_5	.proc
 		; X*4 + X
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -346,7 +351,7 @@ mul_byte_5	.proc
 		rts
 		.pend
 
-mul_word_5	.proc
+stack_mul_word_5	.proc
 		; W*4 + W
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_REG
@@ -365,7 +370,7 @@ mul_word_5	.proc
 		.pend
 
 
-mul_byte_6	.proc
+stack_mul_byte_6	.proc
 		; (X*2 + X)*2
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -376,7 +381,7 @@ mul_byte_6	.proc
 		rts
 		.pend
 
-mul_word_6	.proc
+stack_mul_word_6	.proc
 		; (W*2 + W)*2
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_REG
@@ -394,7 +399,7 @@ mul_word_6	.proc
 		rts
 		.pend
 
-mul_byte_7	.proc
+stack_mul_byte_7	.proc
 		; X*8 - X
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -406,7 +411,7 @@ mul_byte_7	.proc
 		rts
 		.pend
 
-mul_word_7	.proc
+stack_mul_word_7	.proc
 		; W*8 - W
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_REG
@@ -426,7 +431,7 @@ mul_word_7	.proc
 		rts
 		.pend
 
-mul_byte_9	.proc
+stack_mul_byte_9	.proc
 		; X*8 + X
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -438,7 +443,7 @@ mul_byte_9	.proc
 		rts
 		.pend
 
-mul_word_9	.proc
+stack_mul_word_9	.proc
 		; W*8 + W
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_REG
@@ -458,7 +463,7 @@ mul_word_9	.proc
 		rts
 		.pend
 
-mul_byte_10	.proc
+stack_mul_byte_10	.proc
 		; (X*4 + X)*2
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -470,7 +475,7 @@ mul_byte_10	.proc
 		rts
 		.pend
 
-mul_word_10	.proc
+stack_mul_word_10	.proc
 		; (W*4 + W)*2
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_REG
@@ -490,7 +495,7 @@ mul_word_10	.proc
 		rts
 		.pend
 
-mul_byte_11	.proc
+stack_mul_byte_11	.proc
 		; (X*2 + X)*4 - X
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -506,7 +511,7 @@ mul_byte_11	.proc
 
 ; mul_word_11 is skipped (too much code)
 
-mul_byte_12	.proc
+stack_mul_byte_12	.proc
 		; (X*2 + X)*4
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -518,7 +523,7 @@ mul_byte_12	.proc
 		rts
 		.pend
 
-mul_word_12	.proc
+stack_mul_word_12	.proc
 		; (W*2 + W)*4
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_REG
@@ -538,7 +543,7 @@ mul_word_12	.proc
 		rts
 		.pend
 
-mul_byte_13	.proc
+stack_mul_byte_13	.proc
 		; (X*2 + X)*4 + X
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -554,7 +559,7 @@ mul_byte_13	.proc
 
 ; mul_word_13 is skipped (too much code)
 
-mul_byte_14	.proc
+stack_mul_byte_14	.proc
 		; (X*8 - X)*2
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -569,7 +574,7 @@ mul_byte_14	.proc
 
 ; mul_word_14 is skipped (too much code)
 
-mul_byte_15	.proc
+stack_mul_byte_15	.proc
 		; X*16 - X
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -582,7 +587,7 @@ mul_byte_15	.proc
 		rts
 		.pend
 
-mul_word_15	.proc
+stack_mul_word_15	.proc
 		; W*16 - W
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_REG
@@ -604,7 +609,7 @@ mul_word_15	.proc
 		rts
 		.pend
 
-mul_byte_20	.proc
+stack_mul_byte_20	.proc
 		; (X*4 + X)*4
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -617,7 +622,7 @@ mul_byte_20	.proc
 		rts
 		.pend
 
-mul_word_20	.proc
+stack_mul_word_20	.proc
 		; (W*4 + W)*4
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_REG
@@ -639,7 +644,7 @@ mul_word_20	.proc
 		rts
 		.pend
 
-mul_byte_25	.proc
+stack_mul_byte_25	.proc
 		; (X*2 + X)*8 + X
 		lda  P8ESTACK_LO+1,x
 		asl  a
@@ -654,27 +659,26 @@ mul_byte_25	.proc
 		rts
 		.pend
 
-mul_word_25	.proc
+stack_mul_word_25	.proc
-		; W + W*8 + W*16
+		; W = (W*2 + W) *8 + W
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_W1+1
 		lda  P8ESTACK_LO+1,x
 		asl  a
 		rol  P8ZP_SCRATCH_W1+1
-		asl  a
-		rol  P8ZP_SCRATCH_W1+1
-		asl  a
-		rol  P8ZP_SCRATCH_W1+1
-		sta  P8ZP_SCRATCH_W1
 		clc
 		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
+		sta  P8ZP_SCRATCH_W1
 		lda  P8ZP_SCRATCH_W1+1
 		adc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
+		sta  P8ZP_SCRATCH_W1+1
 		lda  P8ZP_SCRATCH_W1
 		asl  a
 		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
 		clc
 		adc  P8ESTACK_LO+1,x
 		sta  P8ESTACK_LO+1,x
@@ -684,21 +688,16 @@ mul_word_25	.proc
 		rts
 		.pend
 
-mul_byte_40	.proc
+stack_mul_byte_40	.proc
-		; (X*4 + X)*8
 		lda  P8ESTACK_LO+1,x
-		asl  a
+		and  #7
-		asl  a
+		tay
-                clc
+		lda  mul_byte_40._forties,y
-		adc  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		asl  a
 		sta  P8ESTACK_LO+1,x
 		rts
 		.pend
 
-mul_word_40	.proc
+stack_mul_word_40	.proc
 		; (W*4 + W)*8
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_REG
@@ -722,6 +721,529 @@ mul_word_40	.proc
 		rts
 		.pend
 
+stack_mul_byte_50	.proc
+		lda  P8ESTACK_LO+1,x
+		and  #7
+		tay
+		lda  mul_byte_50._fifties, y
+		sta  P8ESTACK_LO+1,x
+		rts
+		.pend
+
+stack_mul_word_50	.proc
+		; W = W * 25 * 2
+		jsr  stack_mul_word_25
+		asl  P8ESTACK_LO+1,x
+		rol  P8ESTACK_HI+1,x
+		rts
+		.pend
+
+stack_mul_byte_80	.proc
+		lda  P8ESTACK_LO+1,x
+		and  #3
+		tay
+		lda  mul_byte_80._eighties, y
+		sta  P8ESTACK_LO+1,x
+		rts
+		.pend
+
+stack_mul_word_80	.proc
+		; W = W * 40 * 2
+		jsr  stack_mul_word_40
+		asl  P8ESTACK_LO+1,x
+		rol  P8ESTACK_HI+1,x
+		rts
+		.pend
+
+stack_mul_byte_100	.proc
+		lda  P8ESTACK_LO+1,x
+		and  #3
+		tay
+		lda  mul_byte_100._hundreds, y
+		sta  P8ESTACK_LO+1,x
+		rts
+		.pend
+
+stack_mul_word_100	.proc
+		; W = W * 25 * 4
+		jsr  stack_mul_word_25
+		asl  P8ESTACK_LO+1,x
+		rol  P8ESTACK_HI+1,x
+		asl  P8ESTACK_LO+1,x
+		rol  P8ESTACK_HI+1,x
+		rts
+		.pend
+
+
+; ----------- optimized multiplications (in-place A (byte) and ?? (word)) : ---------
+mul_byte_3	.proc
+		; A = A + A*2
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+		clc
+		adc  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+mul_word_3	.proc
+		; AY = AY*2 + AY
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		clc
+		adc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W1
+		lda  P8ZP_SCRATCH_W1+1
+		adc  P8ZP_SCRATCH_W2+1
+		tay
+		lda  P8ZP_SCRATCH_W1
+		rts
+		.pend
+
+
+mul_byte_5	.proc
+		; A = A*4 + A
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+		clc
+		adc  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+mul_word_5	.proc
+		; AY = AY*4 + AY
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		clc
+		adc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W1
+		lda  P8ZP_SCRATCH_W1+1
+		adc  P8ZP_SCRATCH_W2+1
+		tay
+		lda  P8ZP_SCRATCH_W1
+		rts
+		.pend
+
+
+mul_byte_6	.proc
+		; A = (A*2 + A)*2
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+                clc
+                adc  P8ZP_SCRATCH_REG
+		asl  a
+		rts
+		.pend
+
+mul_word_6	.proc
+		; AY = (AY*2 + AY)*2
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		clc
+		adc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W1
+		tay
+		lda  P8ZP_SCRATCH_W1+1
+		adc  P8ZP_SCRATCH_W2+1
+		sta  P8ZP_SCRATCH_W1+1
+		tya
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		ldy  P8ZP_SCRATCH_W1+1
+		rts
+		.pend
+
+mul_byte_7	.proc
+		; A = A*8 - A
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+		asl  a
+		sec
+		sbc  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+mul_word_7	.proc
+		; AY = AY*8 - AY
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		sec
+		sbc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W1
+		lda  P8ZP_SCRATCH_W1+1
+		sbc  P8ZP_SCRATCH_W2+1
+		tay
+		lda  P8ZP_SCRATCH_W1
+		rts
+		.pend
+
+mul_byte_9	.proc
+		; A = A*8 + A
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+		asl  a
+		clc
+		adc  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+mul_word_9	.proc
+		; AY = AY*8 + AY
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		clc
+		adc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W1
+		lda  P8ZP_SCRATCH_W1+1
+		adc  P8ZP_SCRATCH_W2+1
+		tay
+		lda  P8ZP_SCRATCH_W1
+		rts
+		rts
+		.pend
+
+mul_byte_10	.proc
+		; A=(A*4 + A)*2
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+		clc
+		adc  P8ZP_SCRATCH_REG
+		asl  a
+		rts
+		.pend
+
+mul_word_10	.proc
+		; AY=(AY*4 + AY)*2
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		clc
+		adc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W1
+		lda  P8ZP_SCRATCH_W1+1
+		adc  P8ZP_SCRATCH_W2+1
+		sta  P8ZP_SCRATCH_W1+1
+		lda  P8ZP_SCRATCH_W1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		ldy  P8ZP_SCRATCH_W1+1
+		rts
+		.pend
+
+mul_byte_11	.proc
+		; A=(A*2 + A)*4 - A
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+		clc
+		adc  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+		sec
+		sbc  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+; mul_word_11 is skipped (too much code)
+
+mul_byte_12	.proc
+		; A=(A*2 + A)*4
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+		clc
+		adc  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+		rts
+		.pend
+
+mul_word_12	.proc
+		; AY=(AY*2 + AY)*4
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		clc
+		adc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W1
+		lda  P8ZP_SCRATCH_W1+1
+		adc  P8ZP_SCRATCH_W2+1
+		sta  P8ZP_SCRATCH_W1+1
+		lda  P8ZP_SCRATCH_W1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		ldy  P8ZP_SCRATCH_W1+1
+		rts
+		.pend
+
+mul_byte_13	.proc
+		; A=(A*2 + A)*4 + A
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+                clc
+		adc  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+                clc
+		adc  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+; mul_word_13 is skipped (too much code)
+
+mul_byte_14	.proc
+		; A=(A*8 - A)*2
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+		asl  a
+                sec
+		sbc  P8ZP_SCRATCH_REG
+                asl  a
+		rts
+		.pend
+
+; mul_word_14 is skipped (too much code)
+
+mul_byte_15	.proc
+		; A=A*16 - A
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+		asl  a
+		asl  a
+		sec
+		sbc  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+mul_word_15	.proc
+		; AY = AY * 16 - AY
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		sec
+		sbc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W1
+		lda  P8ZP_SCRATCH_W1+1
+		sbc  P8ZP_SCRATCH_W2+1
+		tay
+		lda  P8ZP_SCRATCH_W1
+		rts
+		.pend
+
+mul_byte_20	.proc
+		; A=(A*4 + A)*4
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+		clc
+		adc  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+		rts
+		.pend
+
+mul_word_20	.proc
+		; AY = AY * 10 * 2
+		jsr  mul_word_10
+		sty  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		ldy  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+mul_byte_25	.proc
+		; A=(A*2 + A)*8 + A
+		sta  P8ZP_SCRATCH_REG
+		asl  a
+		clc
+		adc  P8ZP_SCRATCH_REG
+		asl  a
+		asl  a
+		asl  a
+		clc
+		adc  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+mul_word_25	.proc
+		; AY = (AY*2 + AY) *8 + AY
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		clc
+		adc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W1
+		lda  P8ZP_SCRATCH_W1+1
+		adc  P8ZP_SCRATCH_W2+1
+		sta  P8ZP_SCRATCH_W1+1
+		lda  P8ZP_SCRATCH_W1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		clc
+		adc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W1
+		lda  P8ZP_SCRATCH_W1+1
+		adc  P8ZP_SCRATCH_W2+1
+		tay
+		lda  P8ZP_SCRATCH_W1
+		rts
+		.pend
+
+mul_byte_40	.proc
+		and  #7
+		tay
+		lda  _forties,y
+		rts
+_forties	.byte  0*40, 1*40, 2*40, 3*40, 4*40, 5*40, 6*40, 7*40 & 255
+		.pend
+
+mul_word_40	.proc
+		; AY = (AY*4 + AY)*8
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		asl  a
+		rol  P8ZP_SCRATCH_W1+1
+		clc
+		adc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W1
+		lda  P8ZP_SCRATCH_W1+1
+		adc  P8ZP_SCRATCH_W2+1
+		asl  P8ZP_SCRATCH_W1
+		rol  a
+		asl  P8ZP_SCRATCH_W1
+		rol  a
+		asl  P8ZP_SCRATCH_W1
+		rol  a
+		asl  P8ZP_SCRATCH_W1
+		rol  a
+		tay
+		lda  P8ZP_SCRATCH_W1
+		rts
+		.pend
+
+mul_byte_50	.proc
+		and  #7
+		tay
+		lda  _fifties, y
+		rts
+_fifties	.byte  0*50, 1*50, 2*50, 3*50, 4*50, 5*50, 6*50 & 255, 7*50 & 255
+		.pend
+
+mul_word_50	.proc
+		; AY = AY * 25 * 2
+		jsr  mul_word_25
+		sty  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		ldy  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+mul_byte_80	.proc
+		and  #3
+		tay
+		lda  _eighties, y
+		rts
+_eighties	.byte  0*80, 1*80, 2*80, 3*80
+		.pend
+
+mul_word_80	.proc
+		; AY = AY * 40 * 2
+		jsr  mul_word_40
+		sty  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		ldy  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+mul_byte_100	.proc
+		and  #3
+		tay
+		lda  _hundreds, y
+		rts
+_hundreds	.byte  0*100, 1*100, 2*100, 3*100 & 255
+		.pend
+
+mul_word_100	.proc
+		; AY = AY * 25 * 4
+		jsr  mul_word_25
+		sty  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		ldy  P8ZP_SCRATCH_REG
+		rts
+		.pend
+
+; ----------- end optimized multiplications -----------
+
+
 sign_b		.proc
 		lda  P8ESTACK_LO+1,x
 		beq  _sign_zero

compiler/res/prog8lib/prog8_lib.asm

@@ -682,11 +682,12 @@ func_read_flags	.proc
 
 
 func_sqrt16	.proc
+		; TODO is this one faster?  http://6502org.wikidot.com/software-math-sqrt
 		lda  P8ESTACK_LO+1,x
 		sta  P8ZP_SCRATCH_W2
 		lda  P8ESTACK_HI+1,x
 		sta  P8ZP_SCRATCH_W2+1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		ldy  #$00    ; r = 0
 		ldx  #$07
 		clc         ; clear bit 16 of m
@@ -721,7 +722,7 @@ _skip1
 _skip2
 		iny         ; r = r or d (d is 1 here)
 _skip3
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		tya
 		sta  P8ESTACK_LO+1,x
 		lda  #0
@@ -1216,7 +1217,7 @@ func_rndw	.proc
 func_memcopy	.proc
 	; note: clobbers A,Y
 		inx
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		lda  P8ESTACK_LO+2,x
 		sta  P8ZP_SCRATCH_W1
 		lda  P8ESTACK_HI+2,x
@@ -1233,7 +1234,7 @@ func_memcopy	.proc
 		iny
 		dex
 		bne  -
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		inx
 		inx
 		rts
@@ -1242,7 +1243,7 @@ func_memcopy	.proc
 func_memset	.proc
 	; note: clobbers A,Y
 		inx
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		lda  P8ESTACK_LO+2,x
 		sta  P8ZP_SCRATCH_W1
 		lda  P8ESTACK_HI+2,x
@@ -1253,7 +1254,7 @@ func_memset	.proc
 		lda  P8ESTACK_LO,x
 		ldx  P8ZP_SCRATCH_B1
 		jsr  memset
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		inx
 		inx
 		rts
@@ -1264,7 +1265,7 @@ func_memsetw	.proc
 		; -- fill memory from (SCRATCH_ZPWORD1) number of words in SCRATCH_ZPWORD2, with word value in AY.
 
 		inx
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		lda  P8ESTACK_LO+2,x
 		sta  P8ZP_SCRATCH_W1
 		lda  P8ESTACK_HI+2,x
@@ -1276,7 +1277,7 @@ func_memsetw	.proc
 		lda  P8ESTACK_LO,x
 		ldy  P8ESTACK_HI,x
 		jsr  memsetw
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		inx
 		inx
 		rts
@@ -1328,9 +1329,9 @@ memset          .proc
 	; -- fill memory from (SCRATCH_ZPWORD1), length XY, with value in A.
 	;    clobbers X, Y
 		stx  P8ZP_SCRATCH_B1
-		sty  P8ZP_SCRATCH_REG
+		sty  _save_reg
 		ldy  #0
-		ldx  P8ZP_SCRATCH_REG
+		ldx  _save_reg
 		beq  _lastpage
 
 _fullpage	sta  (P8ZP_SCRATCH_W1),y
@@ -1347,6 +1348,7 @@ _lastpage	ldy  P8ZP_SCRATCH_B1
 		bne  -
 
 +           	rts
+_save_reg	.byte  0
 		.pend
 
 
@@ -1975,7 +1977,7 @@ ror2_array_uw	.proc
 
 
 strcpy		.proc
-		; copy a string (0-terminated) from A/Y to (ZPWORD1)
+		; copy a string (must be 0-terminated) from A/Y to (P8ZP_SCRATCH_W1)
 		; it is assumed the target string is large enough.
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1

compiler/res/prog8lib/prog8_lib.p8

@@ -5,5 +5,5 @@
 ; indent format: TABS, size=8
 
 prog8_lib {
-	%asminclude "library:prog8lib.asm", ""
+	%asminclude "library:prog8_lib.asm", ""
 }

compiler/res/version.txt

@@ -1 +1 @@
-4.1
+4.5

compiler/src/prog8/CompilerMain.kt

@@ -4,13 +4,10 @@ import kotlinx.cli.*
 import prog8.ast.base.AstException
 import prog8.compiler.CompilationResult
 import prog8.compiler.compileProgram
+import prog8.compiler.target.C64Target
+import prog8.compiler.target.Cx16Target
 import prog8.compiler.target.CompilationTarget
-import prog8.compiler.target.c64.C64MachineDefinition
-import prog8.compiler.target.c64.Petscii
-import prog8.compiler.target.c64.codegen.AsmGen
-import prog8.compiler.target.cx16.CX16MachineDefinition
 import prog8.parser.ParsingFailedError
-import java.io.IOException
 import java.nio.file.FileSystems
 import java.nio.file.Path
 import java.nio.file.StandardWatchEventKinds
@@ -41,7 +38,8 @@ private fun compileMain(args: Array<String>) {
     val dontWriteAssembly by cli.flagArgument("-noasm", "don't create assembly code")
     val dontOptimize by cli.flagArgument("-noopt", "don't perform any optimizations")
     val watchMode by cli.flagArgument("-watch", "continuous compilation mode (watches for file changes), greatly increases compilation speed")
-    val compilationTarget by cli.flagValueArgument("-target", "compilertarget", "target output of the compiler, currently 'c64' and 'cx16' available", "c64")
+    val compilationTarget by cli.flagValueArgument("-target", "compilertarget",
+            "target output of the compiler, currently '${C64Target.name}' and '${Cx16Target.name}' available", C64Target.name)
     val moduleFiles by cli.positionalArgumentsList("modules", "main module file(s) to compile", minArgs = 1)
 
     try {
@@ -50,39 +48,6 @@ private fun compileMain(args: Array<String>) {
         exitProcess(1)
     }
 
-    when(compilationTarget) {
-        "c64" -> {
-            with(CompilationTarget) {
-                name = "Commodore-64"
-                machine = C64MachineDefinition
-                encodeString = { str, altEncoding ->
-                    if(altEncoding) Petscii.encodeScreencode(str, true) else Petscii.encodePetscii(str, true)
-                }
-                decodeString = { bytes, altEncoding ->
-                    if(altEncoding) Petscii.decodeScreencode(bytes, true) else Petscii.decodePetscii(bytes, true)
-                }
-                asmGenerator = ::AsmGen
-            }
-        }
-        "cx16" -> {
-            with(CompilationTarget) {
-                name = "Commander X16"
-                machine = CX16MachineDefinition
-                encodeString = { str, altEncoding ->
-                    if(altEncoding) Petscii.encodeScreencode(str, true) else Petscii.encodePetscii(str, true)
-                }
-                decodeString = { bytes, altEncoding ->
-                    if(altEncoding) Petscii.decodeScreencode(bytes, true) else Petscii.decodePetscii(bytes, true)
-                }
-                asmGenerator = ::AsmGen
-            }
-        }
-        else -> {
-            System.err.println("invalid compilation target. Available are: c64, cx16")
-            exitProcess(1)
-        }
-    }
-
     val outputPath = pathFrom(outputDir)
     if(!outputPath.toFile().isDirectory) {
         System.err.println("Output path doesn't exist")
@@ -97,7 +62,7 @@ private fun compileMain(args: Array<String>) {
             println("Continuous watch mode active. Main module: $filepath")
 
             try {
-                val compilationResult = compileProgram(filepath, !dontOptimize, !dontWriteAssembly, outputDir=outputPath)
+                val compilationResult = compileProgram(filepath, !dontOptimize, !dontWriteAssembly, compilationTarget, outputPath)
                 println("Imported files (now watching:)")
                 for (importedFile in compilationResult.importedFiles) {
                     print("  ")
@@ -122,7 +87,7 @@ private fun compileMain(args: Array<String>) {
             val filepath = pathFrom(filepathRaw).normalize()
             val compilationResult: CompilationResult
             try {
-                compilationResult = compileProgram(filepath, !dontOptimize, !dontWriteAssembly, outputDir=outputPath)
+                compilationResult = compileProgram(filepath, !dontOptimize, !dontWriteAssembly, compilationTarget, outputPath)
                 if(!compilationResult.success)
                     exitProcess(1)
             } catch (x: ParsingFailedError) {
@@ -135,7 +100,7 @@ private fun compileMain(args: Array<String>) {
                 if (compilationResult.programName.isEmpty())
                     println("\nCan't start emulator because no program was assembled.")
                 else if(startEmulator) {
-                    CompilationTarget.machine.launchEmulator(compilationResult.programName)
+                    CompilationTarget.instance.machine.launchEmulator(compilationResult.programName)
                 }
             }
         }

compiler/src/prog8/ast/AstToSourceCode.kt

@@ -53,12 +53,14 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
     }
 
     override fun visit(expr: BinaryExpression) {
+        output("(")
         expr.left.accept(this)
         if(expr.operator.any { it.isLetter() })
             output(" ${expr.operator} ")
         else
             output(expr.operator)
         expr.right.accept(this)
+        output(")")
     }
 
     override fun visit(directive: Directive) {
@@ -85,7 +87,7 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
             DataType.ARRAY_W -> "word["
             DataType.ARRAY_F -> "float["
             DataType.STRUCT -> ""       // the name of the struct is enough
-            else -> "?????2"
+            else -> "?????"
         }
     }
 
@@ -113,7 +115,10 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
             VarDeclType.CONST -> output("const ")
             VarDeclType.MEMORY -> output("&")
         }
-        output(decl.struct?.name ?: "")
+
+        if(decl.datatype==DataType.STRUCT && decl.struct!=null)
+            output(decl.struct!!.name)
+
         output(datatypeString(decl.datatype))
         if(decl.arraysize!=null) {
             decl.arraysize!!.index.accept(this)
@@ -140,7 +145,7 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
                             param.second.stack -> "stack"
                             param.second.registerOrPair!=null -> param.second.registerOrPair.toString()
                             param.second.statusflag!=null -> param.second.statusflag.toString()
-                            else -> "?????1"
+                            else -> "?????"
                         }
                 output("${datatypeString(param.first.type)} ${param.first.name} @$reg")
                 if(param.first!==subroutine.parameters.last())
@@ -338,7 +343,7 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
         output("do ")
         untilLoop.body.accept(this)
         output(" until ")
-        untilLoop.untilCondition.accept(this)
+        untilLoop.condition.accept(this)
     }
 
     override fun visit(returnStmt: Return) {

compiler/src/prog8/ast/AstToplevel.kt

@@ -6,6 +6,7 @@ import prog8.ast.expressions.IdentifierReference
 import prog8.ast.processing.AstWalker
 import prog8.ast.processing.IAstVisitor
 import prog8.ast.statements.*
+import prog8.compiler.target.c64.codegen.AsmGen
 import prog8.functions.BuiltinFunctions
 import java.nio.file.Path
 
@@ -44,11 +45,19 @@ interface IFunctionCall {
     var args: MutableList<Expression>
 }
 
+
+class AsmGenInfo {
+    var usedRegsaveA = false
+    var usedRegsaveX = false
+    var usedRegsaveY = false
+}
+
 interface INameScope {
     val name: String
     val position: Position
     val statements: MutableList<Statement>
     val parent: Node
+    val asmGenInfo: AsmGenInfo
 
     fun linkParents(parent: Node)
 
@@ -137,7 +146,15 @@ interface INameScope {
             }
             return null
         } else {
-            // unqualified name, find the scope the localContext is in, look in that first
+            // unqualified name
+            // special case: the do....until statement can also look INSIDE the anonymous scope
+            if(localContext.parent.parent is UntilLoop) {
+                val symbolFromInnerScope = (localContext.parent.parent as UntilLoop).body.getLabelOrVariable(scopedName[0])
+                if(symbolFromInnerScope!=null)
+                    return symbolFromInnerScope
+            }
+
+            // find the scope the localContext is in, look in that first
             var statementScope = localContext
             while(statementScope !is ParentSentinel) {
                 val localScope = statementScope.definingScope()
@@ -232,7 +249,7 @@ class Program(val name: String, val modules: MutableList<Module>): Node {
 
     override fun linkParents(parent: Node) {
         modules.forEach {
-            it.linkParents(this)
+            it.linkParents(namespace)
         }
     }
 
@@ -252,10 +269,14 @@ class Module(override val name: String,
 
     override lateinit var parent: Node
     lateinit var program: Program
+    override val asmGenInfo = AsmGenInfo()
     val importedBy = mutableListOf<Module>()
     val imports = mutableSetOf<Module>()
 
-    var loadAddress: Int = 0        // can be set with the %address directive
+    val loadAddress: Int by lazy {
+        val address = (statements.singleOrNull { it is Directive && it.directive == "%address" } as? Directive)?.args?.single()?.int ?: 0
+        address
+    }
 
     override fun linkParents(parent: Node) {
         this.parent = parent
@@ -282,6 +303,7 @@ class GlobalNamespace(val modules: List<Module>): Node, INameScope {
     override val position = Position("<<<global>>>", 0, 0, 0)
     override val statements = mutableListOf<Statement>()
     override var parent: Node = ParentSentinel
+    override val asmGenInfo = AsmGenInfo()
 
     override fun linkParents(parent: Node) {
         modules.forEach { it.linkParents(this) }
@@ -312,6 +334,14 @@ class GlobalNamespace(val modules: List<Module>): Node, INameScope {
                 }
             }
         }
+
+        // special case: the do....until statement can also look INSIDE the anonymous scope
+        if(localContext.parent.parent is UntilLoop) {
+            val symbolFromInnerScope = (localContext.parent.parent as UntilLoop).body.lookup(scopedName, localContext)
+            if(symbolFromInnerScope!=null)
+                return symbolFromInnerScope
+        }
+
         // lookup something from the module.
         return when (val stmt = localContext.definingModule().lookup(scopedName, localContext)) {
             is Label, is VarDecl, is Block, is Subroutine, is StructDecl -> stmt
@@ -326,6 +356,7 @@ object BuiltinFunctionScopePlaceholder : INameScope {
     override val position = Position("<<placeholder>>", 0, 0, 0)
     override var statements = mutableListOf<Statement>()
     override var parent: Node = ParentSentinel
+    override val asmGenInfo = AsmGenInfo()
     override fun linkParents(parent: Node) {}
 }
 

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

@@ -30,7 +30,7 @@ private fun ParserRuleContext.toPosition() : Position {
     val customTokensource = this.start.tokenSource as? CustomLexer
     val filename =
             when {
-                customTokensource!=null -> customTokensource.modulePath.fileName.toString()
+                customTokensource!=null -> customTokensource.modulePath.toString()
                 start.tokenSource.sourceName == IntStream.UNKNOWN_SOURCE_NAME -> "@internal@"
                 else -> File(start.inputStream.sourceName).name
             }
@@ -254,7 +254,7 @@ private fun prog8Parser.Asmsub_declContext.toAst(): AsmsubDecl {
     val clobbers = asmsub_clobbers()?.clobber()?.toAst() ?: emptySet()
     val normalParameters = params.map { SubroutineParameter(it.name, it.type, it.position) }
     val normalReturntypes = returns.map { it.type }
-    val paramRegisters = params.map { RegisterOrStatusflag(it.registerOrPair, it.statusflag, it.stack) }
+    val paramRegisters = params.map { RegisterOrStatusflag(it.registerOrPair, it.statusflag, false) }
     val returnRegisters = returns.map { RegisterOrStatusflag(it.registerOrPair, it.statusflag, it.stack) }
     return AsmsubDecl(name, normalParameters, normalReturntypes, paramRegisters, returnRegisters, clobbers)
 }
@@ -263,7 +263,7 @@ private class AsmSubroutineParameter(name: String,
                                      type: DataType,
                                      val registerOrPair: RegisterOrPair?,
                                      val statusflag: Statusflag?,
-                                     val stack: Boolean,
+                                     // TODO implement: val stack: Boolean,
                                      position: Position) : SubroutineParameter(name, type, position)
 
 private class AsmSubroutineReturn(val type: DataType,
@@ -305,8 +305,7 @@ private fun prog8Parser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParamete
             else -> throw FatalAstException("invalid register or status flag '$name'")
         }
     }
-    AsmSubroutineParameter(vardecl.varname.text, datatype, registerorpair, statusregister,
+    AsmSubroutineParameter(vardecl.varname.text, datatype, registerorpair, statusregister, toPosition())
-            !it.stack?.text.isNullOrEmpty(), toPosition())
 }
 
 private fun prog8Parser.Functioncall_stmtContext.toAst(): Statement {
@@ -398,7 +397,7 @@ private fun prog8Parser.DirectiveargContext.toAst() : DirectiveArg {
 }
 
 private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
-    fun makeLiteral(text: String, radix: Int, forceWord: Boolean): NumericLiteral {
+    fun makeLiteral(text: String, radix: Int): NumericLiteral {
         val integer: Int
         var datatype = DataType.UBYTE
         when (radix) {
@@ -436,14 +435,14 @@ private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
             }
             else -> throw FatalAstException("invalid radix")
         }
-        return NumericLiteral(integer, if (forceWord) DataType.UWORD else datatype)
+        return NumericLiteral(integer, datatype)
     }
     val terminal: TerminalNode = children[0] as TerminalNode
     val integerPart = this.intpart.text
     return when (terminal.symbol.type) {
-        prog8Parser.DEC_INTEGER -> makeLiteral(integerPart, 10, wordsuffix()!=null)
+        prog8Parser.DEC_INTEGER -> makeLiteral(integerPart, 10)
-        prog8Parser.HEX_INTEGER -> makeLiteral(integerPart.substring(1), 16, wordsuffix()!=null)
+        prog8Parser.HEX_INTEGER -> makeLiteral(integerPart.substring(1), 16)
-        prog8Parser.BIN_INTEGER -> makeLiteral(integerPart.substring(1), 2, wordsuffix()!=null)
+        prog8Parser.BIN_INTEGER -> makeLiteral(integerPart.substring(1), 2)
         else -> throw FatalAstException(terminal.text)
     }
 }
@@ -472,7 +471,7 @@ private fun prog8Parser.ExpressionContext.toAst() : Expression {
                 litval.charliteral()!=null -> {
                     try {
                         val cc=litval.charliteral()
-                        NumericLiteralValue(DataType.UBYTE, CompilationTarget.encodeString(
+                        NumericLiteralValue(DataType.UBYTE, CompilationTarget.instance.encodeString(
                                 unescape(litval.charliteral().SINGLECHAR().text, litval.toPosition()),
                                 litval.charliteral().ALT_STRING_ENCODING()!=null)[0], litval.toPosition())
                     } catch (ce: CharConversionException) {
@@ -648,7 +647,21 @@ private fun prog8Parser.VardeclContext.toAst(): VarDecl {
     )
 }
 
-internal fun escape(str: String) = str.replace("\t", "\\t").replace("\n", "\\n").replace("\r", "\\r")
+internal fun escape(str: String): String {
+    val es2 = str.replace("\t", "\\t").replace("\n", "\\n").replace("\r", "\\r")
+    val es = str.map {
+        when(it) {
+            '\t' -> "\\t"
+            '\n' -> "\\n"
+            '\r' -> "\\r"
+            '"' -> "\\\""
+            in '\u8000'..'\u80ff' -> "\\x" + (it.toInt() - 0x8000).toString(16).padStart(2, '0')
+            in '\u0000'..'\u00ff' -> it.toString()
+            else -> "\\u" + it.toInt().toString(16).padStart(4, '0')
+        }
+    }
+    return es.joinToString("")
+}
 
 internal fun unescape(str: String, position: Position): String {
     val result = mutableListOf<Char>()
@@ -662,9 +675,15 @@ internal fun unescape(str: String, position: Position): String {
                 'n' -> '\n'
                 'r' -> '\r'
                 '"' -> '"'
+                '\'' -> '\''
                 'u' -> {
                     "${iter.nextChar()}${iter.nextChar()}${iter.nextChar()}${iter.nextChar()}".toInt(16).toChar()
                 }
+                'x' -> {
+                    // special hack 0x8000..0x80ff  will be outputted verbatim without encoding
+                    val hex = ("" + iter.nextChar() + iter.nextChar()).toInt(16)
+                    (0x8000 + hex).toChar()
+                }
                 else -> throw SyntaxError("invalid escape char in string: \\$ec", position)
             })
         } else {

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

@@ -39,16 +39,20 @@ enum class DataType {
     infix fun isAssignableTo(targetTypes: Set<DataType>) = targetTypes.any { this isAssignableTo it }
 
     infix fun largerThan(other: DataType) =
-            when(this) {
+            when {
-                in ByteDatatypes -> false
+                this == other -> false
-                in WordDatatypes -> other in ByteDatatypes
+                this in ByteDatatypes -> false
+                this in WordDatatypes -> other in ByteDatatypes
+                this==STR && other==UWORD || this==UWORD && other==STR -> false
                 else -> true
             }
 
     infix fun equalsSize(other: DataType) =
-            when(this) {
+            when {
-                in ByteDatatypes -> other in ByteDatatypes
+                this == other -> true
-                in WordDatatypes -> other in WordDatatypes
+                this in ByteDatatypes -> other in ByteDatatypes
+                this in WordDatatypes -> other in WordDatatypes
+                this==STR && other==UWORD || this==UWORD && other==STR -> true
                 else -> false
             }
 
@@ -56,8 +60,8 @@ enum class DataType {
         return when(this) {
             in ByteDatatypes -> 1
             in WordDatatypes -> 2
-            FLOAT -> CompilationTarget.machine.FLOAT_MEM_SIZE
+            FLOAT -> CompilationTarget.instance.machine.FLOAT_MEM_SIZE
-            in PassByReferenceDatatypes -> CompilationTarget.machine.POINTER_MEM_SIZE
+            in PassByReferenceDatatypes -> CompilationTarget.instance.machine.POINTER_MEM_SIZE
             else -> -9999999
         }
     }
@@ -165,6 +169,7 @@ object ParentSentinel : Node {
 
 data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) {
     override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]"
+    fun toClickableStr(): String = "$file:$line:$startCol:"
 
     companion object {
         val DUMMY = Position("<dummy>", 0, 0, 0)

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

@@ -24,7 +24,7 @@ class ErrorReporter {
                 MessageSeverity.ERROR -> System.err.print("\u001b[91m")  // bright red
                 MessageSeverity.WARNING -> System.err.print("\u001b[93m")  // bright yellow
             }
-            val msg = "${it.position} ${it.severity} ${it.message}".trim()
+            val msg = "${it.position.toClickableStr()} ${it.severity} ${it.message}".trim()
             if(msg !in alreadyReportedMessages) {
                 System.err.println(msg)
                 alreadyReportedMessages.add(msg)

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

@@ -7,11 +7,11 @@ open class FatalAstException (override var message: String) : Exception(message)
 open class AstException (override var message: String) : Exception(message)
 
 open class SyntaxError(override var message: String, val position: Position) : AstException(message) {
-    override fun toString() = "$position Syntax error: $message"
+    override fun toString() = "${position.toClickableStr()} Syntax error: $message"
 }
 
 class ExpressionError(message: String, val position: Position) : AstException(message) {
-    override fun toString() = "$position Error: $message"
+    override fun toString() = "${position.toClickableStr()} Error: $message"
 }
 
 class UndefinedSymbolError(symbol: IdentifierReference)

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

@@ -3,6 +3,7 @@ package prog8.ast.base
 import prog8.ast.Module
 import prog8.ast.Program
 import prog8.ast.processing.*
+import prog8.ast.statements.Directive
 import prog8.compiler.CompilationOptions
 import prog8.compiler.BeforeAsmGenerationAstChanger
 
@@ -18,8 +19,8 @@ internal fun Program.processAstBeforeAsmGeneration(errors: ErrorReporter) {
     fixer.applyModifications()
 }
 
-internal fun Program.reorderStatements() {
+internal fun Program.reorderStatements(errors: ErrorReporter) {
-    val reorder = StatementReorderer(this)
+    val reorder = StatementReorderer(this, errors)
     reorder.visit(this)
     reorder.applyModifications()
 }
@@ -56,6 +57,9 @@ internal fun Program.checkIdentifiers(errors: ErrorReporter) {
         val transforms = AstVariousTransforms(this)
         transforms.visit(this)
         transforms.applyModifications()
+        val lit2decl = LiteralsToAutoVars(this)
+        lit2decl.visit(this)
+        lit2decl.applyModifications()
     }
 
     if (modules.map { it.name }.toSet().size != modules.size) {
@@ -68,3 +72,37 @@ internal fun Program.variousCleanups() {
     process.visit(this)
     process.applyModifications()
 }
+
+internal fun Program.moveMainAndStartToFirst() {
+    // the module containing the program entrypoint is moved to the first in the sequence.
+    // the "main" block containing the entrypoint is moved to the top in there,
+    // and finally the entrypoint subroutine "start" itself is moved to the top in that block.
+
+    val directives = modules[0].statements.filterIsInstance<Directive>()
+    val start = this.entrypoint()
+    if(start!=null) {
+        val mod = start.definingModule()
+        val block = start.definingBlock()
+        if(!modules.remove(mod))
+            throw FatalAstException("module wrong")
+        modules.add(0, mod)
+        mod.remove(block)
+        var afterDirective = mod.statements.indexOfFirst { it !is Directive }
+        if(afterDirective<0)
+            mod.statements.add(block)
+        else
+            mod.statements.add(afterDirective, block)
+        block.remove(start)
+        afterDirective = block.statements.indexOfFirst { it !is Directive }
+        if(afterDirective<0)
+            block.statements.add(start)
+        else
+            block.statements.add(afterDirective, start)
+
+        // overwrite the directives in the module containing the entrypoint
+        for(directive in directives) {
+            modules[0].statements.removeAll { it is Directive && it.directive == directive.directive }
+            modules[0].statements.add(0, directive)
+        }
+    }
+}

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

@@ -17,13 +17,13 @@ import kotlin.math.abs
 
 val associativeOperators = setOf("+", "*", "&", "|", "^", "or", "and", "xor", "==", "!=")
 val comparisonOperators = setOf("==", "!=", "<", ">", "<=", ">=")
-
+val augmentAssignmentOperators = setOf("+", "-", "/", "*", "**", "&", "|", "^", "<<", ">>")
 
 sealed class Expression: Node {
     abstract fun constValue(program: Program): NumericLiteralValue?
     abstract fun accept(visitor: IAstVisitor)
     abstract fun accept(visitor: AstWalker, parent: Node)
-    abstract fun referencesIdentifiers(vararg name: String): Boolean
+    abstract fun referencesIdentifier(vararg scopedName: String): Boolean
     abstract fun inferType(program: Program): InferredTypes.InferredType
 
     infix fun isSameAs(assigntarget: AssignTarget) = assigntarget.isSameAs(this)
@@ -85,7 +85,7 @@ class PrefixExpression(val operator: String, var expression: Expression, overrid
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
 
-    override fun referencesIdentifiers(vararg name: String) = expression.referencesIdentifiers(*name)
+    override fun referencesIdentifier(vararg scopedName: String) = expression.referencesIdentifier(*scopedName)
     override fun inferType(program: Program): InferredTypes.InferredType {
         val inferred = expression.inferType(program)
         return when(operator) {
@@ -142,7 +142,7 @@ class BinaryExpression(var left: Expression, var operator: String, var right: Ex
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
 
-    override fun referencesIdentifiers(vararg name: String) = left.referencesIdentifiers(*name) || right.referencesIdentifiers(*name)
+    override fun referencesIdentifier(vararg scopedName: String) = left.referencesIdentifier(*scopedName) || right.referencesIdentifier(*scopedName)
     override fun inferType(program: Program): InferredTypes.InferredType {
         val leftDt = left.inferType(program)
         val rightDt = right.inferType(program)
@@ -255,7 +255,7 @@ class ArrayIndexedExpression(var identifier: IdentifierReference,
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
 
-    override fun referencesIdentifiers(vararg name: String) = identifier.referencesIdentifiers(*name)
+    override fun referencesIdentifier(vararg scopedName: String) = identifier.referencesIdentifier(*scopedName)
 
     override fun inferType(program: Program): InferredTypes.InferredType {
         val target = identifier.targetStatement(program.namespace)
@@ -291,7 +291,7 @@ class TypecastExpression(var expression: Expression, var type: DataType, val imp
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
 
-    override fun referencesIdentifiers(vararg name: String) = expression.referencesIdentifiers(*name)
+    override fun referencesIdentifier(vararg scopedName: String) = expression.referencesIdentifier(*scopedName)
     override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(type)
     override fun constValue(program: Program): NumericLiteralValue? {
         val cv = expression.constValue(program) ?: return null
@@ -322,7 +322,7 @@ data class AddressOf(var identifier: IdentifierReference, override val position:
     }
 
     override fun constValue(program: Program): NumericLiteralValue? = null
-    override fun referencesIdentifiers(vararg name: String) = false
+    override fun referencesIdentifier(vararg scopedName: String) = false
     override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.UWORD)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
@@ -345,7 +345,7 @@ class DirectMemoryRead(var addressExpression: Expression, override val position:
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
 
-    override fun referencesIdentifiers(vararg name: String) = false
+    override fun referencesIdentifier(vararg scopedName: String) = false
     override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.UBYTE)
     override fun constValue(program: Program): NumericLiteralValue? = null
 
@@ -398,7 +398,7 @@ class NumericLiteralValue(val type: DataType,    // only numerical types allowed
         throw FatalAstException("can't replace here")
     }
 
-    override fun referencesIdentifiers(vararg name: String) = false
+    override fun referencesIdentifier(vararg scopedName: String) = false
     override fun constValue(program: Program) = this
 
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
@@ -498,7 +498,7 @@ class StringLiteralValue(val value: String,
         throw FatalAstException("can't replace here")
     }
 
-    override fun referencesIdentifiers(vararg name: String) = false
+    override fun referencesIdentifier(vararg scopedName: String) = false
     override fun constValue(program: Program): NumericLiteralValue? = null
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
@@ -533,7 +533,7 @@ class ArrayLiteralValue(val type: InferredTypes.InferredType,     // inferred be
         replacement.parent = this
     }
 
-    override fun referencesIdentifiers(vararg name: String) = value.any { it.referencesIdentifiers(*name) }
+    override fun referencesIdentifier(vararg scopedName: String) = value.any { it.referencesIdentifier(*scopedName) }
     override fun constValue(program: Program): NumericLiteralValue? = null
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
@@ -569,10 +569,17 @@ class ArrayLiteralValue(val type: InferredTypes.InferredType,     // inferred be
         val dts = datatypesInArray.map { it.typeOrElse(DataType.STRUCT) }
         return when {
             DataType.FLOAT in dts -> InferredTypes.InferredType.known(DataType.ARRAY_F)
+            DataType.STR in dts -> InferredTypes.InferredType.known(DataType.ARRAY_UW)
             DataType.WORD in dts -> InferredTypes.InferredType.known(DataType.ARRAY_W)
             DataType.UWORD in dts -> InferredTypes.InferredType.known(DataType.ARRAY_UW)
             DataType.BYTE in dts -> InferredTypes.InferredType.known(DataType.ARRAY_B)
             DataType.UBYTE in dts -> InferredTypes.InferredType.known(DataType.ARRAY_UB)
+            DataType.ARRAY_UW in dts ||
+                DataType.ARRAY_W in dts ||
+                DataType.ARRAY_UB in dts ||
+                DataType.ARRAY_B in dts ||
+                DataType.ARRAY_F in dts ||
+                DataType.STRUCT in dts -> InferredTypes.InferredType.known(DataType.ARRAY_UW)
             else -> InferredTypes.InferredType.unknown()
         }
     }
@@ -631,7 +638,7 @@ class RangeExpr(var from: Expression,
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
 
-    override fun referencesIdentifiers(vararg name: String): Boolean  = from.referencesIdentifiers(*name) || to.referencesIdentifiers(*name)
+    override fun referencesIdentifier(vararg scopedName: String): Boolean  = from.referencesIdentifier(*scopedName) || to.referencesIdentifier(*scopedName)
     override fun inferType(program: Program): InferredTypes.InferredType {
         val fromDt=from.inferType(program)
         val toDt=to.inferType(program)
@@ -671,8 +678,8 @@ class RangeExpr(var from: Expression,
         val toString = to as? StringLiteralValue
         if(fromString!=null && toString!=null ) {
             // string range -> int range over character values
-            fromVal = CompilationTarget.encodeString(fromString.value, fromString.altEncoding)[0].toInt()
+            fromVal = CompilationTarget.instance.encodeString(fromString.value, fromString.altEncoding)[0].toInt()
-            toVal = CompilationTarget.encodeString(toString.value, fromString.altEncoding)[0].toInt()
+            toVal = CompilationTarget.instance.encodeString(toString.value, fromString.altEncoding)[0].toInt()
         } else {
             val fromLv = from as? NumericLiteralValue
             val toLv = to as? NumericLiteralValue
@@ -744,7 +751,8 @@ data class IdentifierReference(val nameInSource: List<String>, override val posi
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
 
-    override fun referencesIdentifiers(vararg name: String): Boolean = nameInSource.last() in name
+    override fun referencesIdentifier(vararg scopedName: String): Boolean =
+            nameInSource.size==scopedName.size && nameInSource.toTypedArray().contentEquals(scopedName)
 
     override fun inferType(program: Program): InferredTypes.InferredType {
         return when (val targetStmt = targetStatement(program.namespace)) {
@@ -766,6 +774,18 @@ data class IdentifierReference(val nameInSource: List<String>, override val posi
             else -> throw FatalAstException("requires a reference value")
         }
     }
+
+    fun firstStructVarName(namespace: INameScope): String? {
+        // take the name of the first struct member of the structvariable instead
+        // if it's just a regular variable, return null.
+        val struct = memberOfStruct(namespace) ?: return null
+        val decl = targetVarDecl(namespace)!!
+        val firstStructMember = struct.nameOfFirstMember()
+        // find the flattened var that belongs to this first struct member
+        val firstVarName = listOf(decl.name, firstStructMember)
+        val firstVar = definingScope().lookup(firstVarName, this) as VarDecl
+        return firstVar.name
+    }
 }
 
 class FunctionCall(override var target: IdentifierReference,
@@ -832,7 +852,7 @@ class FunctionCall(override var target: IdentifierReference,
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node)= visitor.visit(this, parent)
 
-    override fun referencesIdentifiers(vararg name: String): Boolean = target.referencesIdentifiers(*name) || args.any{it.referencesIdentifiers(*name)}
+    override fun referencesIdentifier(vararg scopedName: String): Boolean = target.referencesIdentifier(*scopedName) || args.any{it.referencesIdentifier(*scopedName)}
 
     override fun inferType(program: Program): InferredTypes.InferredType {
         val constVal = constValue(program ,false)
@@ -852,6 +872,12 @@ class FunctionCall(override var target: IdentifierReference,
                     return InferredTypes.void()     // no return value
                 if(stmt.returntypes.size==1)
                     return InferredTypes.knownFor(stmt.returntypes[0])
+
+                // multiple return values. Can occur for asmsub routines. If there is exactly one register return value, take that.
+                val numRegisterReturns = stmt.asmReturnvaluesRegisters.count { it.registerOrPair!=null }
+                if(numRegisterReturns==1)
+                    return InferredTypes.InferredType.known(DataType.UBYTE)
+
                 return InferredTypes.unknown()     // has multiple return types... so not a single resulting datatype possible
             }
             else -> return InferredTypes.unknown()

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

@@ -7,7 +7,9 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.compiler.CompilationOptions
+import prog8.compiler.target.C64Target
 import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.Cx16Target
 import prog8.functions.BuiltinFunctions
 import java.io.File
 
@@ -332,8 +334,8 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(untilLoop: UntilLoop) {
-        if(untilLoop.untilCondition.inferType(program).typeOrElse(DataType.STRUCT) !in IntegerDatatypes)
+        if(untilLoop.condition.inferType(program).typeOrElse(DataType.STRUCT) !in IntegerDatatypes)
-            errors.err("condition value should be an integer type", untilLoop.untilCondition.position)
+            errors.err("condition value should be an integer type", untilLoop.condition.position)
         super.visit(untilLoop)
     }
 
@@ -344,17 +346,15 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(assignment: Assignment) {
-        // assigning from a functioncall COULD return multiple values (from an asm subroutine)
         if(assignment.value is FunctionCall) {
             val stmt = (assignment.value as FunctionCall).target.targetStatement(program.namespace)
-            if (stmt is Subroutine && stmt.isAsmSubroutine) {
+            if (stmt is Subroutine) {
-                if(stmt.returntypes.size>1)
+                val idt = assignment.target.inferType(program, assignment)
-                    errors.err("It's not possible to store the multiple results of this asmsub call; you should use a small block of custom inline assembly for this.", assignment.value.position)
+                if(!idt.isKnown) {
-                else {
+                     errors.err("return type mismatch", assignment.value.position)
-                    val idt = assignment.target.inferType(program, assignment)
+                }
-                    if(!idt.isKnown || stmt.returntypes.single()!=idt.typeOrElse(DataType.BYTE)) {
+                if(stmt.returntypes.size <= 1 && stmt.returntypes.single()!=idt.typeOrElse(DataType.BYTE)) {
-                         errors.err("return type mismatch", assignment.value.position)
+                    errors.err("return type mismatch", assignment.value.position)
-                    }
                 }
             }
         }
@@ -374,6 +374,9 @@ internal class AstChecker(private val program: Program,
                         if (sourceVar?.struct != null) {
                             if (sourceVar.struct !== targetVar.struct)
                                 errors.err("assignment of different struct types", assignment.position)
+                        } else if(sourceVar?.isArray==true) {
+                            if((sourceVar.value as ArrayLiteralValue).value.size != targetVar.struct?.numberOfElements)
+                                errors.err("number of elements doesn't match struct definition", sourceVar.position)
                         }
                     }
                 }
@@ -381,7 +384,8 @@ internal class AstChecker(private val program: Program,
         }
 
         val targetDt = assignment.target.inferType(program, assignment)
-        if(assignment.value.inferType(program) != targetDt) {
+        val valueDt = assignment.value.inferType(program)
+        if(valueDt.isKnown && valueDt != targetDt) {
             if(targetDt.typeOrElse(DataType.STRUCT) in IterableDatatypes)
                 errors.err("cannot assign value to string or array", assignment.value.position)
             else
@@ -441,12 +445,8 @@ internal class AstChecker(private val program: Program,
                     checkValueTypeAndRange(targetDatatype.typeOrElse(DataType.BYTE), constVal)
                 } else {
                     val sourceDatatype = assignment.value.inferType(program)
-                    if (!sourceDatatype.isKnown) {
+                    if (sourceDatatype.isUnknown) {
-                        if (assignment.value is FunctionCall) {
+                        if (assignment.value !is FunctionCall)
-                            val targetStmt = (assignment.value as FunctionCall).target.targetStatement(program.namespace)
-                            if (targetStmt != null)
-                                errors.err("function call doesn't return a suitable value to use in assignment", assignment.value.position)
-                        } else
                             errors.err("assignment value is invalid or has no proper datatype", assignment.value.position)
                     } else {
                         checkAssignmentCompatible(targetDatatype.typeOrElse(DataType.BYTE), assignTarget,
@@ -471,14 +471,11 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(decl: VarDecl) {
-        fun err(msg: String, position: Position?=null) {
+        fun err(msg: String, position: Position?=null) = errors.err(msg, position ?: decl.position)
-            errors.err(msg, position ?: decl.position)
-        }
 
         // the initializer value can't refer to the variable itself (recursive definition)
-        if(decl.value?.referencesIdentifiers(decl.name) == true || decl.arraysize?.index?.referencesIdentifiers(decl.name) == true) {
+        if(decl.value?.referencesIdentifier(decl.name) == true || decl.arraysize?.index?.referencesIdentifier(decl.name) == true)
             err("recursive var declaration")
-        }
 
         // CONST can only occur on simple types (byte, word, float)
         if(decl.type== VarDeclType.CONST) {
@@ -486,10 +483,12 @@ internal class AstChecker(private val program: Program,
                 err("const modifier can only be used on numeric types (byte, word, float)")
         }
 
-        // FLOATS
+        // FLOATS enabled?
-        if(!compilerOptions.floats && decl.datatype in setOf(DataType.FLOAT, DataType.ARRAY_F) && decl.type!= VarDeclType.MEMORY) {
+        if(!compilerOptions.floats && decl.datatype in setOf(DataType.FLOAT, DataType.ARRAY_F) && decl.type!= VarDeclType.MEMORY)
             err("floating point used, but that is not enabled via options")
-        }
+
+        if(decl.datatype == DataType.FLOAT && (decl.zeropage==ZeropageWish.REQUIRE_ZEROPAGE || decl.zeropage==ZeropageWish.PREFER_ZEROPAGE))
+            errors.warn("floating point values won't be placed in Zeropage due to size constraints", decl.position)
 
         // ARRAY without size specifier MUST have an iterable initializer value
         if(decl.isArray && decl.arraysize==null) {
@@ -558,9 +557,11 @@ internal class AstChecker(private val program: Program,
                         checkValueTypeAndRange(decl.datatype, decl.value as NumericLiteralValue)
                     }
                     else -> {
-                        err("var/const declaration needs a compile-time constant initializer value, or range, instead found: ${decl.value!!.javaClass.simpleName}")
+                        if(decl.type==VarDeclType.CONST) {
-                        super.visit(decl)
+                            err("const declaration needs a compile-time constant initializer value, or range")
-                        return
+                            super.visit(decl)
+                            return
+                        }
                     }
                 }
             }
@@ -581,13 +582,13 @@ internal class AstChecker(private val program: Program,
                     }
                 }
 
-                if(decl.value !is NumericLiteralValue) {
+                if(decl.value is NumericLiteralValue) {
-                    err("value of memory var decl is not a numeric literal (it is a ${decl.value!!.javaClass.simpleName}).", decl.value?.position)
-                } else {
                     val value = decl.value as NumericLiteralValue
                     if (value.type !in IntegerDatatypes || value.number.toInt() < 0 || value.number.toInt() > 65535) {
                         err("memory address must be valid integer 0..\$ffff", decl.value?.position)
                     }
+                } else {
+                    err("value of memory mapped variable can only be a number, perhaps you meant to use an address pointer type instead?", decl.value?.position)
                 }
             }
         }
@@ -626,6 +627,14 @@ internal class AstChecker(private val program: Program,
             }
         }
 
+        // string assignment is not supported in a vard
+        if(decl.datatype==DataType.STR) {
+            if(decl.value==null)
+                err("string var must be initialized with a string literal")
+            else if (decl.type==VarDeclType.VAR && decl.value !is StringLiteralValue)
+                err("string var can only be initialized with a string literal")
+        }
+
         super.visit(decl)
     }
 
@@ -706,9 +715,17 @@ internal class AstChecker(private val program: Program,
                     err("this directive may only occur in a block or at module level")
                 if(directive.args.isEmpty())
                     err("missing option directive argument(s)")
-                else if(directive.args.map{it.name in setOf("enable_floats", "force_output")}.any { !it })
+                else if(directive.args.map{it.name in setOf("enable_floats", "force_output", "no_sysinit")}.any { !it })
                     err("invalid option directive argument(s)")
             }
+            "%target" -> {
+                if(directive.parent !is Block && directive.parent !is Module)
+                    err("this directive may only occur in a block or at module level")
+                if(directive.args.size != 1)
+                    err("directive requires one argument")
+                if(directive.args.single().name !in setOf(C64Target.name, Cx16Target.name))
+                    err("invalid compilation target")
+            }
             else -> throw SyntaxError("invalid directive ${directive.directive}", directive.position)
         }
         super.visit(directive)
@@ -731,6 +748,22 @@ internal class AstChecker(private val program: Program,
             checkValueTypeAndRangeArray(array.type.typeOrElse(DataType.STRUCT), null, arrayspec, array)
         }
 
+        fun isPassByReferenceElement(e: Expression): Boolean {
+            if(e is IdentifierReference) {
+                val decl = e.targetVarDecl(program.namespace)!!
+                return decl.datatype in PassByReferenceDatatypes
+            }
+            return e is StringLiteralValue
+        }
+
+        if(array.parent is VarDecl) {
+            if (!array.value.all { it is NumericLiteralValue || it is AddressOf || isPassByReferenceElement(it) })
+                errors.err("array literal for variable initialization contains invalid types", array.position)
+        } else if(array.parent is ForLoop) {
+            if (!array.value.all { it.constValue(program) != null })
+                errors.err("array literal for iteration must contain constants. Try using a separate array variable instead?", array.position)
+        }
+
         super.visit(array)
     }
 
@@ -758,6 +791,8 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(expr: BinaryExpression) {
+        super.visit(expr)
+
         val leftIDt = expr.left.inferType(program)
         val rightIDt = expr.right.inferType(program)
         if(!leftIDt.isKnown || !rightIDt.isKnown)
@@ -797,13 +832,12 @@ internal class AstChecker(private val program: Program,
             }
         }
 
-        if(leftDt !in NumericDatatypes)
+        if(leftDt !in NumericDatatypes && leftDt != DataType.STR)
-            errors.err("left operand is not numeric", expr.left.position)
+            errors.err("left operand is not numeric or str", expr.left.position)
-        if(rightDt!in NumericDatatypes)
+        if(rightDt!in NumericDatatypes && rightDt != DataType.STR)
-            errors.err("right operand is not numeric", expr.right.position)
+            errors.err("right operand is not numeric or str", expr.right.position)
         if(leftDt!=rightDt)
             errors.err("left and right operands aren't the same type", expr.left.position)
-        super.visit(expr)
     }
 
     override fun visit(typecast: TypecastExpression) {
@@ -863,7 +897,29 @@ internal class AstChecker(private val program: Program,
 
         val error = VerifyFunctionArgTypes.checkTypes(functionCall, functionCall.definingScope(), program)
         if(error!=null)
-            errors.err(error, functionCall.args.first().position)
+            errors.err(error, functionCall.position)
+
+        // check the functions that return multiple returnvalues.
+        val stmt = functionCall.target.targetStatement(program.namespace)
+        if (stmt is Subroutine) {
+            if (stmt.returntypes.size > 1) {
+                // Currently, it's only possible to handle ONE (or zero) return values from a subroutine.
+                // asmsub routines can have multiple return values, for instance in 2 different registers.
+                // It's not (yet) possible to handle these multiple return values because assignments
+                // are only to a single unique target at the same time.
+                //   EXCEPTION:
+                // if the asmsub returns multiple values and one of them is via a status register bit,
+                // it *is* possible to handle them by just actually assigning the register value and
+                // dealing with the status bit as just being that, the status bit after the call.
+                val (returnRegisters, returnStatusflags) = stmt.asmReturnvaluesRegisters.partition { rr -> rr.registerOrPair != null }
+                if (returnRegisters.isEmpty() || returnRegisters.size == 1) {
+                    if (returnStatusflags.any())
+                        errors.warn("this asmsub also has one or more return 'values' in one of the status flags", functionCall.position)
+                } else {
+                    errors.err("It's not possible to store the multiple result values of this asmsub call; you should use a small block of custom inline assembly for this.", functionCall.position)
+                }
+            }
+        }
 
         super.visit(functionCall)
     }
@@ -1087,7 +1143,7 @@ internal class AstChecker(private val program: Program,
         }
 
         if(value.type.isUnknown)
-            return err("attempt to check values of array with as yet unknown datatype")
+            return false
 
         when (targetDt) {
             DataType.STR -> return err("string value expected")
@@ -1156,7 +1212,7 @@ internal class AstChecker(private val program: Program,
 
                     // check if the floating point values are all within range
                     val doubles = value.value.map {it.constValue(program)?.number!!.toDouble()}.toDoubleArray()
-                    if(doubles.any { it < CompilationTarget.machine.FLOAT_MAX_NEGATIVE || it > CompilationTarget.machine.FLOAT_MAX_POSITIVE })
+                    if(doubles.any { it < CompilationTarget.instance.machine.FLOAT_MAX_NEGATIVE || it > CompilationTarget.instance.machine.FLOAT_MAX_POSITIVE })
                         return err("floating point value overflow")
                     return true
                 }

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

@@ -22,7 +22,7 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
     }
 
     override fun visit(block: Block) {
-        if(block.name in CompilationTarget.machine.opcodeNames)
+        if(block.name in CompilationTarget.instance.machine.opcodeNames)
             errors.err("can't use a cpu opcode name as a symbol: '${block.name}'", block.position)
 
         val existing = blocks[block.name]
@@ -34,13 +34,23 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
         super.visit(block)
     }
 
+    override fun visit(directive: Directive) {
+        if(directive.directive=="%target") {
+            val compatibleTarget = directive.args.single().name
+            if (compatibleTarget != CompilationTarget.instance.name)
+                errors.err("module's compilation target ($compatibleTarget) differs from active target (${CompilationTarget.instance.name})", directive.position)
+        }
+
+        super.visit(directive)
+    }
+
     override fun visit(decl: VarDecl) {
         decl.datatypeErrors.forEach { errors.err(it.message, it.position) }
 
         if(decl.name in BuiltinFunctions)
             errors.err("builtin function cannot be redefined", decl.position)
 
-        if(decl.name in CompilationTarget.machine.opcodeNames)
+        if(decl.name in CompilationTarget.instance.machine.opcodeNames)
             errors.err("can't use a cpu opcode name as a symbol: '${decl.name}'", decl.position)
 
         if(decl.datatype==DataType.STRUCT) {
@@ -74,7 +84,7 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
     }
 
     override fun visit(subroutine: Subroutine) {
-        if(subroutine.name in CompilationTarget.machine.opcodeNames) {
+        if(subroutine.name in CompilationTarget.instance.machine.opcodeNames) {
             errors.err("can't use a cpu opcode name as a symbol: '${subroutine.name}'", subroutine.position)
         } else if(subroutine.name in BuiltinFunctions) {
             // the builtin functions can't be redefined
@@ -88,14 +98,6 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
             if (existing != null && existing !== subroutine)
                 nameError(subroutine.name, subroutine.position, existing)
 
-            // does the parameter redefine a variable declared elsewhere?
-            for(param in subroutine.parameters) {
-                val existingVar = subroutine.lookup(listOf(param.name), subroutine)
-                if (existingVar != null && existingVar.parent !== subroutine) {
-                    nameError(param.name, param.position, existingVar)
-                }
-            }
-
             // check that there are no local variables, labels, or other subs that redefine the subroutine's parameters
             val symbolsInSub = subroutine.allDefinedSymbols()
             val namesInSub = symbolsInSub.map{ it.first }.toSet()
@@ -119,7 +121,7 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
     }
 
     override fun visit(label: Label) {
-        if(label.name in CompilationTarget.machine.opcodeNames)
+        if(label.name in CompilationTarget.instance.machine.opcodeNames)
             errors.err("can't use a cpu opcode name as a symbol: '${label.name}'", label.position)
 
         if(label.name in BuiltinFunctions) {
@@ -141,8 +143,8 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
     }
 
     override fun visit(string: StringLiteralValue) {
-        if (string.value.length !in 1..255)
+        if (string.value.length > 255)
-            errors.err("string literal length must be between 1 and 255", string.position)
+            errors.err("string literal length max is 255", string.position)
 
         super.visit(string)
     }

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

@@ -10,43 +10,6 @@ import prog8.ast.statements.*
 internal class AstVariousTransforms(private val program: Program) : AstWalker() {
     private val noModifications = emptyList<IAstModification>()
 
-    override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
-        if(functionCallStatement.target.nameInSource == listOf("swap")) {
-            // if x and y are both just identifiers, do not rewrite (there should be asm generation for that)
-            // otherwise:
-            // rewrite swap(x,y) as follows:
-            // - declare a temp variable of the same datatype
-            // - temp = x, x = y, y= temp
-            val first = functionCallStatement.args[0]
-            val second = functionCallStatement.args[1]
-            if(first !is IdentifierReference && second !is IdentifierReference) {
-                val dt = first.inferType(program).typeOrElse(DataType.STRUCT)
-                val tempname = "prog8_swaptmp_${functionCallStatement.hashCode()}"
-                val tempvardecl = VarDecl(VarDeclType.VAR, dt, ZeropageWish.DONTCARE, null, tempname, null, null, isArray = false, autogeneratedDontRemove = true, position = first.position)
-                val tempvar = IdentifierReference(listOf(tempname), first.position)
-                val assignTemp = Assignment(
-                        AssignTarget(tempvar, null, null, first.position),
-                        first,
-                        first.position
-                )
-                val assignFirst = Assignment(
-                        AssignTarget.fromExpr(first),
-                        second,
-                        first.position
-                )
-                val assignSecond = Assignment(
-                        AssignTarget.fromExpr(second),
-                        tempvar,
-                        first.position
-                )
-                val scope = AnonymousScope(mutableListOf(tempvardecl, assignTemp, assignFirst, assignSecond), first.position)
-                return listOf(IAstModification.ReplaceNode(functionCallStatement, scope, parent))
-            }
-        }
-
-        return noModifications
-    }
-
     override fun before(decl: VarDecl, parent: Node): Iterable<IAstModification> {
         // is it a struct variable? then define all its struct members as mangled names,
         //    and include the original decl as well.
@@ -84,78 +47,59 @@ internal class AstVariousTransforms(private val program: Program) : AstWalker()
         return noModifications
     }
 
-    override fun before(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
+    override fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
-        when {
+        val leftStr = expr.left as? StringLiteralValue
-            expr.left is StringLiteralValue ->
+        val rightStr = expr.right as? StringLiteralValue
-                return listOf(IAstModification.ReplaceNode(
+        if(expr.operator == "+") {
-                        expr,
+            val concatenatedString = concatString(expr)
-                        processBinaryExprWithString(expr.left as StringLiteralValue, expr.right, expr),
+            if(concatenatedString!=null)
-                        parent
+                return listOf(IAstModification.ReplaceNode(expr, concatenatedString, parent))
-                ))
-            expr.right is StringLiteralValue ->
-                return listOf(IAstModification.ReplaceNode(
-                        expr,
-                        processBinaryExprWithString(expr.right as StringLiteralValue, expr.left, expr),
-                        parent
-                ))
         }
-
+        else if(expr.operator == "*") {
-        return noModifications
+            if (leftStr!=null) {
-    }
+                val amount = expr.right.constValue(program)
-
+                if(amount!=null) {
-    override fun after(string: StringLiteralValue, parent: Node): Iterable<IAstModification> {
+                    val string = leftStr.value.repeat(amount.number.toInt())
-        if(string.parent !is VarDecl) {
+                    val strval = StringLiteralValue(string, leftStr.altEncoding, expr.position)
-            // replace the literal string by a identifier reference to a new local vardecl
+                    return listOf(IAstModification.ReplaceNode(expr, strval, parent))
-            val vardecl = VarDecl.createAuto(string)
+                }
-            val identifier = IdentifierReference(listOf(vardecl.name), vardecl.position)
-            return listOf(
-                    IAstModification.ReplaceNode(string, identifier, parent),
-                    IAstModification.InsertFirst(vardecl, string.definingScope() as Node)
-            )
-        }
-        return noModifications
-    }
-
-    override fun after(array: ArrayLiteralValue, parent: Node): Iterable<IAstModification> {
-        val vardecl = array.parent as? VarDecl
-        if(vardecl!=null) {
-            // adjust the datatype of the array (to an educated guess)
-            val arrayDt = array.type
-            if(!arrayDt.istype(vardecl.datatype)) {
-                val cast = array.cast(vardecl.datatype)
-                if (cast != null && cast!=array)
-                    return listOf(IAstModification.ReplaceNode(vardecl.value!!, cast, vardecl))
             }
-        } else {
+            else if (rightStr!=null) {
-            val arrayDt = array.guessDatatype(program)
+                val amount = expr.right.constValue(program)
-            if(arrayDt.isKnown) {
+                if(amount!=null) {
-                // this array literal is part of an expression, turn it into an identifier reference
+                    val string = rightStr.value.repeat(amount.number.toInt())
-                val litval2 = array.cast(arrayDt.typeOrElse(DataType.STRUCT))
+                    val strval = StringLiteralValue(string, rightStr.altEncoding, expr.position)
-                if(litval2!=null && litval2!=array) {
+                    return listOf(IAstModification.ReplaceNode(expr, strval, parent))
-                    val vardecl2 = VarDecl.createAuto(litval2)
-                    val identifier = IdentifierReference(listOf(vardecl2.name), vardecl2.position)
-                    return listOf(
-                            IAstModification.ReplaceNode(array, identifier, parent),
-                            IAstModification.InsertFirst(vardecl2, array.definingScope() as Node)
-                    )
                 }
             }
         }
+
         return noModifications
     }
 
-    private fun processBinaryExprWithString(string: StringLiteralValue, operand: Expression, expr: BinaryExpression): Expression {
+    private fun concatString(expr: BinaryExpression): StringLiteralValue? {
-        val constvalue = operand.constValue(program)
+        val rightStrval = expr.right as? StringLiteralValue
-        if(constvalue!=null) {
+        val leftStrval = expr.left as? StringLiteralValue
-            if (expr.operator == "*") {
+        return when {
-                // repeat a string a number of times
+            expr.operator!="+" -> null
-                return StringLiteralValue(string.value.repeat(constvalue.number.toInt()), string.altEncoding, expr.position)
+            expr.left is BinaryExpression && rightStrval!=null -> {
+                val subStrVal = concatString(expr.left as BinaryExpression)
+                if(subStrVal==null)
+                    null
+                else
+                    StringLiteralValue("${subStrVal.value}${rightStrval.value}", subStrVal.altEncoding, rightStrval.position)
             }
+            expr.right is BinaryExpression && leftStrval!=null -> {
+                val subStrVal = concatString(expr.right as BinaryExpression)
+                if(subStrVal==null)
+                    null
+                else
+                    StringLiteralValue("${leftStrval.value}${subStrVal.value}", subStrVal.altEncoding, leftStrval.position)
+            }
+            leftStrval!=null && rightStrval!=null -> {
+                StringLiteralValue("${leftStrval.value}${rightStrval.value}", leftStrval.altEncoding, leftStrval.position)
+            }
+            else -> null
         }
-        if(expr.operator == "+" && operand is StringLiteralValue) {
-            // concatenate two strings
-            return StringLiteralValue("${string.value}${operand.value}", string.altEncoding, expr.position)
-        }
-        return expr
     }
 }

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

@@ -82,6 +82,7 @@ interface IAstModification {
 
     class SwapOperands(val expr: BinaryExpression): IAstModification {
         override fun perform() {
+            require(expr.operator in associativeOperators)
             val tmp = expr.left
             expr.left = expr.right
             expr.right = tmp
@@ -228,6 +229,7 @@ abstract class AstWalker {
         track(before(decl, parent), decl, parent)
         decl.value?.accept(this, decl)
         decl.arraysize?.accept(this, decl)
+        decl.struct?.accept(this, decl)
         track(after(decl, parent), decl, parent)
     }
 
@@ -348,7 +350,7 @@ abstract class AstWalker {
 
     fun visit(untilLoop: UntilLoop, parent: Node) {
         track(before(untilLoop, parent), untilLoop, parent)
-        untilLoop.untilCondition.accept(this, untilLoop)
+        untilLoop.condition.accept(this, untilLoop)
         untilLoop.body.accept(this, untilLoop)
         track(after(untilLoop, parent), untilLoop, parent)
     }

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

@@ -33,6 +33,7 @@ interface IAstVisitor {
     fun visit(decl: VarDecl) {
         decl.value?.accept(this)
         decl.arraysize?.accept(this)
+        decl.struct?.accept(this)
     }
 
     fun visit(subroutine: Subroutine) {
@@ -115,7 +116,7 @@ interface IAstVisitor {
     }
 
     fun visit(untilLoop: UntilLoop) {
-        untilLoop.untilCondition.accept(this)
+        untilLoop.condition.accept(this)
         untilLoop.body.accept(this)
     }
 

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

@@ -0,0 +1,53 @@
+package prog8.ast.processing
+
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+
+
+internal class LiteralsToAutoVars(private val program: Program) : AstWalker() {
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun after(string: StringLiteralValue, parent: Node): Iterable<IAstModification> {
+        if(string.parent !is VarDecl) {
+            // replace the literal string by a identifier reference to a new local vardecl
+            val vardecl = VarDecl.createAuto(string)
+            val identifier = IdentifierReference(listOf(vardecl.name), vardecl.position)
+            return listOf(
+                    IAstModification.ReplaceNode(string, identifier, parent),
+                    IAstModification.InsertFirst(vardecl, string.definingScope() as Node)
+            )
+        }
+        return noModifications
+    }
+
+    override fun after(array: ArrayLiteralValue, parent: Node): Iterable<IAstModification> {
+        val vardecl = array.parent as? VarDecl
+        if(vardecl!=null) {
+            // adjust the datatype of the array (to an educated guess)
+            val arrayDt = array.type
+            if(!arrayDt.istype(vardecl.datatype)) {
+                val cast = array.cast(vardecl.datatype)
+                if (cast != null && cast !== array)
+                    return listOf(IAstModification.ReplaceNode(vardecl.value!!, cast, vardecl))
+            }
+        } else {
+            val arrayDt = array.guessDatatype(program)
+            if(arrayDt.isKnown) {
+                // this array literal is part of an expression, turn it into an identifier reference
+                val litval2 = array.cast(arrayDt.typeOrElse(DataType.STRUCT))
+                if(litval2!=null) {
+                    val vardecl2 = VarDecl.createAuto(litval2)
+                    val identifier = IdentifierReference(listOf(vardecl2.name), vardecl2.position)
+                    return listOf(
+                            IAstModification.ReplaceNode(array, identifier, parent),
+                            IAstModification.InsertFirst(vardecl2, array.definingScope() as Node)
+                    )
+                }
+            }
+        }
+        return noModifications
+    }
+}

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

@@ -6,7 +6,7 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.*
 
 
-internal class StatementReorderer(val program: Program) : AstWalker() {
+internal class StatementReorderer(val program: Program, val errors: ErrorReporter) : AstWalker() {
     // Reorders the statements in a way the compiler needs.
     // - 'main' block must be the very first statement UNLESS it has an address set.
     // - library blocks are put last.
@@ -71,23 +71,6 @@ internal class StatementReorderer(val program: Program) : AstWalker() {
         return noModifications
     }
 
-    override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
-        val declValue = decl.value
-        if(declValue!=null && decl.type== VarDeclType.VAR && decl.datatype in NumericDatatypes) {
-            val declConstValue = declValue.constValue(program)
-            if(declConstValue==null) {
-                // move the vardecl (without value) to the scope and replace this with a regular assignment
-                decl.value = null
-                val target = AssignTarget(IdentifierReference(listOf(decl.name), decl.position), null, null, decl.position)
-                val assign = Assignment(target, declValue, decl.position)
-                return listOf(
-                        IAstModification.ReplaceNode(decl, assign, parent),
-                        IAstModification.InsertFirst(decl, decl.definingScope() as Node)
-                )
-            }
-        }
-        return noModifications
-    }
 
     override fun after(whenStatement: WhenStatement, parent: Node): Iterable<IAstModification> {
         val choices = whenStatement.choiceValues(program).sortedBy {
@@ -101,20 +84,31 @@ internal class StatementReorderer(val program: Program) : AstWalker() {
     override fun before(assignment: Assignment, parent: Node): Iterable<IAstModification> {
         val valueType = assignment.value.inferType(program)
         val targetType = assignment.target.inferType(program, assignment)
-        if(valueType.istype(DataType.STRUCT) && targetType.istype(DataType.STRUCT)) {
+        var assignments = emptyList<Assignment>()
-            val assignments = if (assignment.value is ArrayLiteralValue) {
+
-                flattenStructAssignmentFromStructLiteral(assignment, program)    //  'structvar = [ ..... ] '
+        if(targetType.istype(DataType.STRUCT) && (valueType.istype(DataType.STRUCT) || valueType.typeOrElse(DataType.STRUCT) in ArrayDatatypes )) {
+            assignments = if (assignment.value is ArrayLiteralValue) {
+                flattenStructAssignmentFromStructLiteral(assignment)    //  'structvar = [ ..... ] '
             } else {
-                flattenStructAssignmentFromIdentifier(assignment, program)    //   'structvar1 = structvar2'
+                flattenStructAssignmentFromIdentifier(assignment)    //   'structvar1 = structvar2'
             }
-            if(assignments.isNotEmpty()) {
+        }
-                val modifications = mutableListOf<IAstModification>()
+
-                assignments.reversed().mapTo(modifications) { IAstModification.InsertAfter(assignment, it, parent) }
+        if(targetType.typeOrElse(DataType.STRUCT) in ArrayDatatypes && valueType.typeOrElse(DataType.STRUCT) in ArrayDatatypes ) {
-                modifications.add(IAstModification.Remove(assignment, parent))
+            assignments = if (assignment.value is ArrayLiteralValue) {
-                return modifications
+                flattenArrayAssignmentFromArrayLiteral(assignment)    //  'arrayvar = [ ..... ] '
+            } else {
+                flattenArrayAssignmentFromIdentifier(assignment)    //   'arrayvar1 = arrayvar2'
             }
         }
 
+        if(assignments.isNotEmpty()) {
+            val modifications = mutableListOf<IAstModification>()
+            assignments.reversed().mapTo(modifications) { IAstModification.InsertAfter(assignment, it, parent) }
+            modifications.add(IAstModification.Remove(assignment, parent))
+            return modifications
+        }
+
         return noModifications
     }
 
@@ -167,15 +161,69 @@ internal class StatementReorderer(val program: Program) : AstWalker() {
         return noModifications
     }
 
-    private fun flattenStructAssignmentFromStructLiteral(structAssignment: Assignment, program: Program): List<Assignment> {
+    private fun flattenArrayAssignmentFromArrayLiteral(assign: Assignment): List<Assignment> {
+        // TODO use a pointer loop instead of individual assignments
+
+        val identifier = assign.target.identifier!!
+        val targetVar = identifier.targetVarDecl(program.namespace)!!
+
+        val alv = assign.value as? ArrayLiteralValue
+        if(targetVar.arraysize==null) {
+            errors.err("array has no defined size", identifier.position)
+            return emptyList()
+        }
+
+        if(alv==null || alv.value.size != targetVar.arraysize!!.constIndex()) {
+            errors.err("element count mismatch", assign.position)
+            return emptyList()
+        }
+
+        return alv.value.withIndex().map { (index, value)->
+            val idx = ArrayIndexedExpression(identifier, ArrayIndex(NumericLiteralValue(DataType.UBYTE, index, assign.position), assign.position), assign.position)
+            Assignment(AssignTarget(null, idx, null, assign.position), value, value.position)
+        }
+    }
+
+    private fun flattenArrayAssignmentFromIdentifier(assign: Assignment): List<Assignment> {
+        // TODO use a pointer loop instead of individual assignments
+
+        val identifier = assign.target.identifier!!
+        val targetVar = identifier.targetVarDecl(program.namespace)!!
+
+        val sourceIdent = assign.value as IdentifierReference
+        val sourceVar = sourceIdent.targetVarDecl(program.namespace)!!
+        if(!sourceVar.isArray) {
+            errors.err("value must be an array",  sourceIdent.position)
+            return emptyList()
+        }
+        if(targetVar.arraysize==null) {
+            errors.err("array has no defined size", identifier.position)
+            return emptyList()
+        }
+
+        val alv = sourceVar.value as? ArrayLiteralValue
+        if(alv==null || alv.value.size != targetVar.arraysize!!.constIndex()) {
+            errors.err("element count mismatch", assign.position)
+            return emptyList()
+        }
+
+        return alv.value.withIndex().map { (index, value)->
+            val idx = ArrayIndexedExpression(identifier, ArrayIndex(NumericLiteralValue(DataType.UBYTE, index, assign.position), assign.position), assign.position)
+            Assignment(AssignTarget(null, idx, null, assign.position), value, value.position)
+        }
+    }
+
+    private fun flattenStructAssignmentFromStructLiteral(structAssignment: Assignment): List<Assignment> {
         val identifier = structAssignment.target.identifier!!
         val identifierName = identifier.nameInSource.single()
         val targetVar = identifier.targetVarDecl(program.namespace)!!
         val struct = targetVar.struct!!
 
         val slv = structAssignment.value as? ArrayLiteralValue
-        if(slv==null || slv.value.size != struct.numberOfElements)
+        if(slv==null || slv.value.size != struct.numberOfElements) {
-            throw FatalAstException("element count mismatch")
+            errors.err("element count mismatch", structAssignment.position)
+            return emptyList()
+        }
 
         return struct.statements.zip(slv.value).map { (targetDecl, sourceValue) ->
             targetDecl as VarDecl
@@ -188,7 +236,8 @@ internal class StatementReorderer(val program: Program) : AstWalker() {
         }
     }
 
-    private fun flattenStructAssignmentFromIdentifier(structAssignment: Assignment, program: Program): List<Assignment> {
+    private fun flattenStructAssignmentFromIdentifier(structAssignment: Assignment): List<Assignment> {
+        // TODO use memcopy beyond a certain number of elements
         val identifier = structAssignment.target.identifier!!
         val identifierName = identifier.nameInSource.single()
         val targetVar = identifier.targetVarDecl(program.namespace)!!
@@ -196,26 +245,47 @@ internal class StatementReorderer(val program: Program) : AstWalker() {
         when (structAssignment.value) {
             is IdentifierReference -> {
                 val sourceVar = (structAssignment.value as IdentifierReference).targetVarDecl(program.namespace)!!
-                if (sourceVar.struct == null)
+                when {
-                    throw FatalAstException("can only assign arrays or structs to structs")
+                    sourceVar.struct!=null -> {
-                // struct memberwise copy
+                        // struct memberwise copy
-                val sourceStruct = sourceVar.struct!!
+                        val sourceStruct = sourceVar.struct!!
-                if(sourceStruct!==targetVar.struct) {
+                        if(sourceStruct!==targetVar.struct) {
-                    // structs are not the same in assignment
+                            // structs are not the same in assignment
-                    return listOf()     // error will be printed elsewhere
+                            return listOf()     // error will be printed elsewhere
-                }
+                        }
-                return struct.statements.zip(sourceStruct.statements).map { member ->
+                        if(struct.statements.size!=sourceStruct.statements.size)
-                    val targetDecl = member.first as VarDecl
+                            return listOf()     // error will be printed elsewhere
-                    val sourceDecl = member.second as VarDecl
+                        return struct.statements.zip(sourceStruct.statements).map { member ->
-                    if(targetDecl.name != sourceDecl.name)
+                            val targetDecl = member.first as VarDecl
-                        throw FatalAstException("struct member mismatch")
+                            val sourceDecl = member.second as VarDecl
-                    val mangled = mangledStructMemberName(identifierName, targetDecl.name)
+                            if(targetDecl.name != sourceDecl.name)
-                    val idref = IdentifierReference(listOf(mangled), structAssignment.position)
+                                throw FatalAstException("struct member mismatch")
-                    val sourcemangled = mangledStructMemberName(sourceVar.name, sourceDecl.name)
+                            val mangled = mangledStructMemberName(identifierName, targetDecl.name)
-                    val sourceIdref = IdentifierReference(listOf(sourcemangled), structAssignment.position)
+                            val idref = IdentifierReference(listOf(mangled), structAssignment.position)
-                    val assign = Assignment(AssignTarget(idref, null, null, structAssignment.position), sourceIdref, member.second.position)
+                            val sourcemangled = mangledStructMemberName(sourceVar.name, sourceDecl.name)
-                    assign.linkParents(structAssignment)
+                            val sourceIdref = IdentifierReference(listOf(sourcemangled), structAssignment.position)
-                    assign
+                            val assign = Assignment(AssignTarget(idref, null, null, structAssignment.position), sourceIdref, member.second.position)
+                            assign.linkParents(structAssignment)
+                            assign
+                        }
+                    }
+                    sourceVar.isArray -> {
+                        val array = (sourceVar.value as ArrayLiteralValue).value
+                        if(struct.statements.size!=array.size)
+                            return listOf()     // error will be printed elsewhere
+                        return struct.statements.zip(array).map {
+                            val decl = it.first as VarDecl
+                            val mangled = mangledStructMemberName(identifierName, decl.name)
+                            val targetName = IdentifierReference(listOf(mangled), structAssignment.position)
+                            val target = AssignTarget(targetName, null, null, structAssignment.position)
+                            val assign = Assignment(target, it.second, structAssignment.position)
+                            assign.linkParents(structAssignment)
+                            assign
+                        }
+                    }
+                    else -> {
+                        throw FatalAstException("can only assign arrays or structs to structs")
+                    }
                 }
             }
             is ArrayLiteralValue -> {

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

@@ -18,6 +18,21 @@ class TypecastsAdder(val program: Program, val errors: ErrorReporter) : AstWalke
 
     private val noModifications = emptyList<IAstModification>()
 
+    override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
+        val declValue = decl.value
+        if(decl.type==VarDeclType.VAR && declValue!=null && decl.struct==null) {
+            val valueDt = declValue.inferType(program)
+            if(!valueDt.istype(decl.datatype)) {
+                return listOf(IAstModification.ReplaceNode(
+                        declValue,
+                        TypecastExpression(declValue, decl.datatype, true, declValue.position),
+                        decl
+                ))
+            }
+        }
+        return noModifications
+    }
+
     override fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
         val leftDt = expr.left.inferType(program)
         val rightDt = expr.right.inferType(program)
@@ -109,10 +124,12 @@ class TypecastsAdder(val program: Program, val errors: ErrorReporter) : AstWalke
                                         call as Node)
                             } else if(requiredType == DataType.UWORD && argtype in PassByReferenceDatatypes) {
                                 // we allow STR/ARRAY values in place of UWORD parameters. Take their address instead.
-                                modifications += IAstModification.ReplaceNode(
+                                if(arg.second.value is IdentifierReference) {
-                                        call.args[arg.second.index],
+                                    modifications += IAstModification.ReplaceNode(
-                                        AddressOf(arg.second.value as IdentifierReference, arg.second.value.position),
+                                            call.args[arg.second.index],
-                                        call as Node)
+                                            AddressOf(arg.second.value as IdentifierReference, arg.second.value.position),
+                                            call as Node)
+                                }
                             } else if(arg.second.value is NumericLiteralValue) {
                                 val cast = (arg.second.value as NumericLiteralValue).cast(requiredType)
                                 if(cast.isValid)
@@ -139,6 +156,7 @@ class TypecastsAdder(val program: Program, val errors: ErrorReporter) : AstWalke
                                         call.args[arg.second.index],
                                         TypecastExpression(arg.second.value, possibleType, true, arg.second.value.position),
                                         call as Node)
+                                break
                             }
                         }
                     }

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

@@ -4,10 +4,9 @@ import prog8.ast.IFunctionCall
 import prog8.ast.INameScope
 import prog8.ast.Program
 import prog8.ast.base.DataType
+import prog8.ast.expressions.Expression
 import prog8.ast.expressions.FunctionCall
-import prog8.ast.statements.BuiltinFunctionStatementPlaceholder
+import prog8.ast.statements.*
-import prog8.ast.statements.FunctionCallStatement
-import prog8.ast.statements.Subroutine
 import prog8.compiler.CompilerException
 import prog8.functions.BuiltinFunctions
 
@@ -26,20 +25,42 @@ class VerifyFunctionArgTypes(val program: Program) : IAstVisitor {
     }
 
     companion object {
+
+        private fun argTypeCompatible(argDt: DataType, paramDt: DataType): Boolean {
+            if(argDt==paramDt)
+                return true
+
+            // there are some exceptions that are considered compatible, such as STR <> UWORD
+            if(argDt==DataType.STR && paramDt==DataType.UWORD ||
+                    argDt==DataType.UWORD && paramDt==DataType.STR)
+                return true
+
+            return false
+        }
+
         fun checkTypes(call: IFunctionCall, scope: INameScope, program: Program): String? {
             val argtypes = call.args.map { it.inferType(program).typeOrElse(DataType.STRUCT) }
             val target = call.target.targetStatement(scope)
             if (target is Subroutine) {
-                // asmsub types are not checked specifically at this time
                 if(call.args.size != target.parameters.size)
                     return "invalid number of arguments"
                 val paramtypes = target.parameters.map { it.type }
-                val mismatch = argtypes.zip(paramtypes).indexOfFirst { it.first != it.second}
+                val mismatch = argtypes.zip(paramtypes).indexOfFirst { !argTypeCompatible(it.first, it.second) }
                 if(mismatch>=0) {
                     val actual = argtypes[mismatch].toString()
                     val expected = paramtypes[mismatch].toString()
                     return "argument ${mismatch + 1} type mismatch, was: $actual expected: $expected"
                 }
+                if(target.isAsmSubroutine) {
+                    if(target.asmReturnvaluesRegisters.size>1) {
+                        // multiple return values will NOT work inside an expression.
+                        // they MIGHT work in a regular assignment or just a function call statement.
+                        val parent = if(call is Statement) call.parent else if(call is Expression) call.parent else null
+                        if(call !is FunctionCallStatement && parent !is Assignment && parent !is VarDecl) {
+                            return "can't use subroutine call that returns multiple return values here (try moving it into a separate assignment)"
+                        }
+                    }
+                }
             }
             else if (target is BuiltinFunctionStatementPlaceholder) {
                 val func = BuiltinFunctions.getValue(target.name)
@@ -47,7 +68,8 @@ class VerifyFunctionArgTypes(val program: Program) : IAstVisitor {
                     return "invalid number of arguments"
                 val paramtypes = func.parameters.map { it.possibleDatatypes }
                 for (x in argtypes.zip(paramtypes).withIndex()) {
-                    if (x.value.first !in x.value.second) {
+                    val anyCompatible = x.value.second.any { argTypeCompatible(x.value.first, it) }
+                    if (!anyCompatible) {
                         val actual = x.value.first.toString()
                         val expected = x.value.second.toString()
                         return "argument ${x.index + 1} type mismatch, was: $actual expected: $expected"

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

@@ -5,6 +5,7 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.processing.AstWalker
 import prog8.ast.processing.IAstVisitor
+import prog8.compiler.target.CompilationTarget
 
 
 sealed class Statement : Node {
@@ -56,6 +57,7 @@ class Block(override val name: String,
             val isInLibrary: Boolean,
             override val position: Position) : Statement(), INameScope {
     override lateinit var parent: Node
+    override val asmGenInfo = AsmGenInfo()
 
     override fun linkParents(parent: Node) {
         this.parent = parent
@@ -214,8 +216,9 @@ open class VarDecl(val type: VarDeclType,
                 DataType.UWORD -> DataType.ARRAY_UW
                 DataType.WORD -> DataType.ARRAY_W
                 DataType.FLOAT -> DataType.ARRAY_F
+                DataType.STR -> DataType.ARRAY_UW       // use memory address of the string instead
                 else -> {
-                    datatypeErrors.add(SyntaxError("array can only contain bytes/words/floats", position))
+                    datatypeErrors.add(SyntaxError("array can only contain bytes/words/floats/strings(ptrs)", position))
                     DataType.ARRAY_UB
                 }
             }
@@ -232,7 +235,8 @@ open class VarDecl(val type: VarDeclType,
     }
 
     override fun replaceChildNode(node: Node, replacement: Node) {
-        require(replacement is Expression && node===value)
+        // TODO the check that node===value is too strict sometimes, but leaving it out allows for bugs to creep through ... :( Perhaps check when adding the replace if there is already a replace on the same node?
+        require(replacement is Expression)
         value = replacement
         replacement.parent = this
     }
@@ -301,6 +305,8 @@ class ArrayIndex(var index: Expression, override val position: Position) : Node
     }
 
     fun constIndex() = (index as? NumericLiteralValue)?.number?.toInt()
+
+    infix fun isSameAs(other: ArrayIndex) = index.isSameAs(other.index)
 }
 
 open class Assignment(var target: AssignTarget, var value: Expression, override val position: Position) : Statement() {
@@ -391,8 +397,8 @@ data class AssignTarget(var identifier: IdentifierReference?,
 
     override fun replaceChildNode(node: Node, replacement: Node) {
         when {
-            node===identifier -> identifier = replacement as IdentifierReference
+            node === identifier -> identifier = replacement as IdentifierReference
-            node===arrayindexed -> arrayindexed = replacement as ArrayIndexedExpression
+            node === arrayindexed -> arrayindexed = replacement as ArrayIndexedExpression
             else -> throw FatalAstException("invalid replace")
         }
         replacement.parent = this
@@ -412,17 +418,17 @@ data class AssignTarget(var identifier: IdentifierReference?,
         }
     }
 
-    fun inferType(program: Program, stmt: Statement): InferredTypes.InferredType {
+    fun inferType(program: Program, stmt: Statement): InferredTypes.InferredType {  // TODO why does this have the extra 'stmt' scope parameter???
-        if(identifier!=null) {
+        if (identifier != null) {
             val symbol = program.namespace.lookup(identifier!!.nameInSource, stmt) ?: return InferredTypes.unknown()
             if (symbol is VarDecl) return InferredTypes.knownFor(symbol.datatype)
         }
 
-        if(arrayindexed!=null) {
+        if (arrayindexed != null) {
             return arrayindexed!!.inferType(program)
         }
 
-        if(memoryAddress!=null)
+        if (memoryAddress != null)
             return InferredTypes.knownFor(DataType.UBYTE)
 
         return InferredTypes.unknown()
@@ -430,69 +436,93 @@ data class AssignTarget(var identifier: IdentifierReference?,
 
     fun toExpression(): Expression {
         return when {
-            identifier!=null -> identifier!!
+            identifier != null -> identifier!!
-            arrayindexed!=null -> arrayindexed!!
+            arrayindexed != null -> arrayindexed!!
-            memoryAddress!=null -> DirectMemoryRead(memoryAddress.addressExpression, memoryAddress.position)
+            memoryAddress != null -> DirectMemoryRead(memoryAddress.addressExpression, memoryAddress.position)
             else -> throw FatalAstException("invalid assignmenttarget $this")
         }
     }
 
     infix fun isSameAs(value: Expression): Boolean {
         return when {
-            this.memoryAddress!=null -> {
+            memoryAddress != null -> {
                 // if the target is a memory write, and the value is a memory read, they're the same if the address matches
-                if(value is DirectMemoryRead)
+                if (value is DirectMemoryRead)
                     this.memoryAddress.addressExpression isSameAs value.addressExpression
                 else
                     false
             }
-            this.identifier!=null -> value is IdentifierReference && value.nameInSource==identifier!!.nameInSource
+            identifier != null -> value is IdentifierReference && value.nameInSource == identifier!!.nameInSource
-            this.arrayindexed!=null -> value is ArrayIndexedExpression &&
+            arrayindexed != null -> {
-                    value.identifier.nameInSource==arrayindexed!!.identifier.nameInSource &&
+                if(value is ArrayIndexedExpression && value.identifier.nameInSource == arrayindexed!!.identifier.nameInSource)
-                    value.arrayspec.constIndex()!=null &&
+                    arrayindexed!!.arrayspec isSameAs value.arrayspec
-                    arrayindexed!!.arrayspec.constIndex()!=null &&
+                else
-                    value.arrayspec.constIndex()==arrayindexed!!.arrayspec.constIndex()
+                    false
+            }
             else -> false
         }
     }
 
     fun isSameAs(other: AssignTarget, program: Program): Boolean {
-        if(this===other)
+        if (this === other)
             return true
-        if(this.identifier!=null && other.identifier!=null)
+        if (this.identifier != null && other.identifier != null)
-            return this.identifier!!.nameInSource==other.identifier!!.nameInSource
+            return this.identifier!!.nameInSource == other.identifier!!.nameInSource
-        if(this.memoryAddress!=null && other.memoryAddress!=null) {
+        if (this.memoryAddress != null && other.memoryAddress != null) {
             val addr1 = this.memoryAddress.addressExpression.constValue(program)
             val addr2 = other.memoryAddress.addressExpression.constValue(program)
-            return addr1!=null && addr2!=null && addr1==addr2
+            return addr1 != null && addr2 != null && addr1 == addr2
         }
-        if(this.arrayindexed!=null && other.arrayindexed!=null) {
+        if (this.arrayindexed != null && other.arrayindexed != null) {
-            if(this.arrayindexed!!.identifier.nameInSource == other.arrayindexed!!.identifier.nameInSource) {
+            if (this.arrayindexed!!.identifier.nameInSource == other.arrayindexed!!.identifier.nameInSource) {
                 val x1 = this.arrayindexed!!.arrayspec.index.constValue(program)
                 val x2 = other.arrayindexed!!.arrayspec.index.constValue(program)
-                return x1!=null && x2!=null && x1==x2
+                return x1 != null && x2 != null && x1 == x2
             }
         }
         return false
     }
 
-    fun isNotMemory(namespace: INameScope): Boolean {
+    fun isInRegularRAM(namespace: INameScope): Boolean {
-        if(this.memoryAddress!=null)
+        when {
-            return false
+            this.memoryAddress != null -> {
-        if(this.arrayindexed!=null) {
+                return when (this.memoryAddress.addressExpression) {
-            val targetStmt = this.arrayindexed!!.identifier.targetVarDecl(namespace)
+                    is NumericLiteralValue -> {
-            if(targetStmt!=null)
+                        CompilationTarget.instance.machine.isRegularRAMaddress((this.memoryAddress.addressExpression as NumericLiteralValue).number.toInt())
-                return targetStmt.type!= VarDeclType.MEMORY
+                    }
+                    is IdentifierReference -> {
+                        val decl = (this.memoryAddress.addressExpression as IdentifierReference).targetVarDecl(namespace)
+                        if ((decl?.type == VarDeclType.VAR || decl?.type == VarDeclType.CONST) && decl.value is NumericLiteralValue)
+                            CompilationTarget.instance.machine.isRegularRAMaddress((decl.value as NumericLiteralValue).number.toInt())
+                        else
+                            false
+                    }
+                    else -> false
+                }
+            }
+            this.arrayindexed != null -> {
+                val targetStmt = this.arrayindexed!!.identifier.targetVarDecl(namespace)
+                return if (targetStmt?.type == VarDeclType.MEMORY) {
+                    val addr = targetStmt.value as? NumericLiteralValue
+                    if (addr != null)
+                        CompilationTarget.instance.machine.isRegularRAMaddress(addr.number.toInt())
+                    else
+                        false
+                } else true
+            }
+            this.identifier != null -> {
+                val decl = this.identifier!!.targetVarDecl(namespace)!!
+                return if (decl.type == VarDeclType.MEMORY && decl.value is NumericLiteralValue)
+                    CompilationTarget.instance.machine.isRegularRAMaddress((decl.value as NumericLiteralValue).number.toInt())
+                else
+                    true
+            }
+            else -> return true
         }
-        if(this.identifier!=null) {
-            val targetStmt = this.identifier!!.targetVarDecl(namespace)
-            if(targetStmt!=null)
-                return targetStmt.type!= VarDeclType.MEMORY
-        }
-        return false
     }
 }
 
+
 class PostIncrDecr(var target: AssignTarget, val operator: String, override val position: Position) : Statement() {
     override lateinit var parent: Node
 
@@ -581,6 +611,7 @@ class AnonymousScope(override var statements: MutableList<Statement>,
                      override val position: Position) : INameScope, Statement() {
     override val name: String
     override lateinit var parent: Node
+    override val asmGenInfo = AsmGenInfo()
 
     companion object {
         private var sequenceNumber = 1
@@ -634,6 +665,7 @@ class Subroutine(override val name: String,
                  override val position: Position) : Statement(), INameScope {
 
     override lateinit var parent: Node
+    override val asmGenInfo = AsmGenInfo()
     val scopedname: String by lazy { makeScopedName(name) }
 
     override fun linkParents(parent: Node) {
@@ -815,19 +847,19 @@ class RepeatLoop(var iterations: Expression?, var body: AnonymousScope, override
 }
 
 class UntilLoop(var body: AnonymousScope,
-                var untilCondition: Expression,
+                var condition: Expression,
                 override val position: Position) : Statement() {
     override lateinit var parent: Node
 
     override fun linkParents(parent: Node) {
         this.parent = parent
-        untilCondition.linkParents(this)
+        condition.linkParents(this)
         body.linkParents(this)
     }
 
     override fun replaceChildNode(node: Node, replacement: Node) {
         when {
-            node===untilCondition -> untilCondition = replacement as Expression
+            node===condition -> condition = replacement as Expression
             node===body -> body = replacement as AnonymousScope
             else -> throw FatalAstException("invalid replace")
         }
@@ -911,6 +943,7 @@ class StructDecl(override val name: String,
                  override val position: Position): Statement(), INameScope {
 
     override lateinit var parent: Node
+    override val asmGenInfo = AsmGenInfo()
 
     override fun linkParents(parent: Node) {
         this.parent = parent

compiler/src/prog8/compiler/BeforeAsmGenerationAstChanger.kt

@@ -1,5 +1,6 @@
 package prog8.compiler
 
+import prog8.ast.IFunctionCall
 import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.base.*
@@ -14,9 +15,15 @@ internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: E
     private val noModifications = emptyList<IAstModification>()
 
     override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
-        if (decl.value == null && decl.type == VarDeclType.VAR && decl.datatype in NumericDatatypes) {
+        subroutineVariables.add(Pair(decl.name, decl))
-            // a numeric vardecl without an initial value is initialized with zero.
+        if (decl.value == null && !decl.autogeneratedDontRemove && decl.type == VarDeclType.VAR && decl.datatype in NumericDatatypes) {
-            decl.value = decl.zeroElementValue()
+            // a numeric vardecl without an initial value is initialized with zero,
+            // unless there's already an assignment below, that initializes the value
+            val nextAssign = decl.definingScope().nextSibling(decl) as? Assignment
+            if(nextAssign!=null && nextAssign.target.isSameAs(IdentifierReference(listOf(decl.name), Position.DUMMY)))
+                decl.value = null
+            else
+                decl.value = decl.zeroElementValue()
         }
         return noModifications
     }
@@ -24,52 +31,78 @@ internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: E
     override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
         // Try to replace A = B <operator> Something  by A= B, A = A <operator> Something
         // this triggers the more efficent augmented assignment code generation more often.
+        // But it can only be done if the target variable IS NOT OCCURRING AS AN OPERAND ITSELF.
         if(!assignment.isAugmentable
                 && assignment.target.identifier != null
-                && assignment.target.isNotMemory(program.namespace)) {
+                && assignment.target.isInRegularRAM(program.namespace)) {
             val binExpr = assignment.value as? BinaryExpression
-            if(binExpr!=null && binExpr.operator !in comparisonOperators) {
+            if (binExpr != null && binExpr.operator !in comparisonOperators) {
-                if(binExpr.left !is BinaryExpression) {
+                if (binExpr.left !is BinaryExpression) {
-                    val assignLeft = Assignment(assignment.target, binExpr.left, assignment.position)
+                    if (binExpr.right.referencesIdentifier(*assignment.target.identifier!!.nameInSource.toTypedArray())) {
-                    return listOf(
+                        // the right part of the expression contains the target variable itself.
-                            IAstModification.InsertBefore(assignment, assignLeft, parent),
+                        // we can't 'split' it trivially because the variable will be changed halfway through.
-                            IAstModification.ReplaceNode(binExpr.left, assignment.target.toExpression(), binExpr))
+                        if(binExpr.operator in associativeOperators) {
+                            // A = <something-without-A>  <associativeoperator>  <otherthing-with-A>
+                            // use the other part of the expression to split.
+                            val assignRight = Assignment(assignment.target, binExpr.right, assignment.position)
+                            return listOf(
+                                    IAstModification.InsertBefore(assignment, assignRight, parent),
+                                    IAstModification.ReplaceNode(binExpr.right, binExpr.left, binExpr),
+                                    IAstModification.ReplaceNode(binExpr.left, assignment.target.toExpression(), binExpr))
+                        }
+                    } else {
+                        val assignLeft = Assignment(assignment.target, binExpr.left, assignment.position)
+                        return listOf(
+                                IAstModification.InsertBefore(assignment, assignLeft, parent),
+                                IAstModification.ReplaceNode(binExpr.left, assignment.target.toExpression(), binExpr))
+                    }
                 }
             }
         }
         return noModifications
     }
 
+    private val subroutineVariables = mutableListOf<Pair<String, VarDecl>>()
+
+    override fun before(subroutine: Subroutine, parent: Node): Iterable<IAstModification> {
+        subroutineVariables.clear()
+        return noModifications
+    }
+
     override fun after(scope: AnonymousScope, parent: Node): Iterable<IAstModification> {
         val decls = scope.statements.filterIsInstance<VarDecl>()
+        subroutineVariables.addAll(decls.map { Pair(it.name, it) })
+
         val sub = scope.definingSubroutine()
         if (sub != null) {
-            val existingVariables = sub.statements.filterIsInstance<VarDecl>().associateBy { it.name }
+            // move vardecls of the scope into the upper scope. Make sure the position remains the same!
-            var conflicts = false
+            val numericVarsWithValue = decls.filter { it.value != null && it.datatype in NumericDatatypes }
-            decls.forEach {
+            val replaceVardecls =numericVarsWithValue.map {
-                val existing = existingVariables[it.name]
+                val initValue = it.value!!  // assume here that value has always been set by now
-                if (existing != null) {
+                it.value = null     // make sure no value init assignment for this vardecl will be created later (would be superfluous)
-                    errors.err("variable ${it.name} already defined in subroutine ${sub.name} at ${existing.position}", it.position)
+                val target = AssignTarget(IdentifierReference(listOf(it.name), it.position), null, null, it.position)
-                    conflicts = true
+                val assign = Assignment(target, initValue, it.position)
-                }
+                initValue.parent = assign
-            }
+                IAstModification.ReplaceNode(it, assign, scope)
-            if (!conflicts) {
-                val numericVarsWithValue = decls.filter { it.value != null && it.datatype in NumericDatatypes }
-                return numericVarsWithValue.map {
-                    val initValue = it.value!!  // assume here that value has always been set by now
-                    it.value = null     // make sure no value init assignment for this vardecl will be created later (would be superfluous)
-                    val target = AssignTarget(IdentifierReference(listOf(it.name), it.position), null, null, it.position)
-                    val assign = Assignment(target, initValue, it.position)
-                    initValue.parent = assign
-                    IAstModification.InsertFirst(assign, scope)
-                } +  decls.map { IAstModification.ReplaceNode(it, NopStatement(it.position), scope) } +
-                     decls.map { IAstModification.InsertFirst(it, sub) }    // move it up to the subroutine
             }
+            val moveVardeclsUp = decls.map { IAstModification.InsertFirst(it, sub) }
+            return replaceVardecls + moveVardeclsUp
         }
         return noModifications
     }
 
     override fun after(subroutine: Subroutine, parent: Node): Iterable<IAstModification> {
+        val firstDeclarations = mutableMapOf<String, VarDecl>()
+        for(decl in subroutineVariables) {
+            val existing = firstDeclarations[decl.first]
+            if(existing!=null && existing !== decl.second) {
+                errors.err("variable ${decl.first} already defined in subroutine ${subroutine.name} at ${existing.position}", decl.second.position)
+            } else {
+                firstDeclarations[decl.first] = decl.second
+            }
+        }
+
+
         // add the implicit return statement at the end (if it's not there yet), but only if it's not a kernel routine.
         // and if an assembly block doesn't contain a rts/rti, and some other situations.
         val mods = mutableListOf<IAstModification>()
@@ -93,7 +126,6 @@ internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: E
                 && outerScope !is Block) {
             mods += IAstModification.InsertAfter(outerStatements[subroutineStmtIdx - 1], returnStmt, outerScope as Node)
         }
-
         return mods
     }
 
@@ -114,14 +146,28 @@ internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: E
         // that the types of assignment values and their target are the same,
         // and that the types of both operands of a binaryexpression node are the same.
         // So, it is not easily possible to remove the typecasts that are there to make these conditions true.
+        // The only place for now where we can do this is for:
+        //    asmsub register pair parameter.
+
+        if(typecast.type in WordDatatypes) {
+            val fcall = typecast.parent as? IFunctionCall
+            if (fcall != null) {
+                val sub = fcall.target.targetStatement(program.namespace) as? Subroutine
+                if (sub != null && sub.isAsmSubroutine) {
+                    return listOf(IAstModification.ReplaceNode(typecast, typecast.expression, parent))
+                }
+            }
+        }
 
         if(sourceDt in PassByReferenceDatatypes) {
             if(typecast.type==DataType.UWORD) {
-                return listOf(IAstModification.ReplaceNode(
+                if(typecast.expression is IdentifierReference) {
-                        typecast,
+                    return listOf(IAstModification.ReplaceNode(
-                        AddressOf(typecast.expression as IdentifierReference, typecast.position),
+                            typecast,
-                        parent
+                            AddressOf(typecast.expression as IdentifierReference, typecast.position),
-                ))
+                            parent
+                    ))
+                }
             } else {
                 errors.err("cannot cast pass-by-reference value to type ${typecast.type} (only to UWORD)", typecast.position)
             }
@@ -129,4 +175,34 @@ internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: E
 
         return noModifications
     }
+
+    override fun after(ifStatement: IfStatement, parent: Node): Iterable<IAstModification> {
+        val binExpr = ifStatement.condition as? BinaryExpression
+        if(binExpr==null || binExpr.operator !in comparisonOperators) {
+            // if x  ->  if x!=0,    if x+5  ->  if x+5 != 0
+            val booleanExpr = BinaryExpression(ifStatement.condition, "!=", NumericLiteralValue.optimalInteger(0, ifStatement.condition.position), ifStatement.condition.position)
+            return listOf(IAstModification.ReplaceNode(ifStatement.condition, booleanExpr, ifStatement))
+        }
+        return noModifications
+    }
+
+    override fun after(untilLoop: UntilLoop, parent: Node): Iterable<IAstModification> {
+        val binExpr = untilLoop.condition as? BinaryExpression
+        if(binExpr==null || binExpr.operator !in comparisonOperators) {
+            // until x  ->  until x!=0,    until x+5  ->  until x+5 != 0
+            val booleanExpr = BinaryExpression(untilLoop.condition, "!=", NumericLiteralValue.optimalInteger(0, untilLoop.condition.position), untilLoop.condition.position)
+            return listOf(IAstModification.ReplaceNode(untilLoop.condition, booleanExpr, untilLoop))
+        }
+        return noModifications
+    }
+
+    override fun after(whileLoop: WhileLoop, parent: Node): Iterable<IAstModification> {
+        val binExpr = whileLoop.condition as? BinaryExpression
+        if(binExpr==null || binExpr.operator !in comparisonOperators) {
+            // while x  ->  while x!=0,    while x+5  ->  while x+5 != 0
+            val booleanExpr = BinaryExpression(whileLoop.condition, "!=", NumericLiteralValue.optimalInteger(0, whileLoop.condition.position), whileLoop.condition.position)
+            return listOf(IAstModification.ReplaceNode(whileLoop.condition, booleanExpr, whileLoop))
+        }
+        return noModifications
+    }
 }

compiler/src/prog8/compiler/Compiler.kt

@@ -27,7 +27,8 @@ data class CompilationOptions(val output: OutputType,
                               val launcher: LauncherType,
                               val zeropage: ZeropageType,
                               val zpReserved: List<IntRange>,
-                              val floats: Boolean)
+                              val floats: Boolean,
+                              val noSysInit: Boolean)
 
 
 class CompilerException(message: String?) : Exception(message)

compiler/src/prog8/compiler/Main.kt

@@ -4,7 +4,10 @@ import prog8.ast.AstToSourceCode
 import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.statements.Directive
+import prog8.compiler.target.C64Target
 import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.Cx16Target
+import prog8.optimizer.*
 import prog8.optimizer.UnusedCodeRemover
 import prog8.optimizer.constantFold
 import prog8.optimizer.optimizeStatements
@@ -13,6 +16,7 @@ import prog8.parser.ModuleImporter
 import prog8.parser.ParsingFailedError
 import prog8.parser.moduleName
 import java.nio.file.Path
+import kotlin.system.exitProcess
 import kotlin.system.measureTimeMillis
 
 
@@ -25,12 +29,22 @@ class CompilationResult(val success: Boolean,
 fun compileProgram(filepath: Path,
                    optimize: Boolean,
                    writeAssembly: Boolean,
+                   compilationTarget: String,
                    outputDir: Path): CompilationResult {
     var programName = ""
     lateinit var programAst: Program
     lateinit var importedFiles: List<Path>
     val errors = ErrorReporter()
 
+    when(compilationTarget) {
+        C64Target.name -> CompilationTarget.instance = C64Target
+        Cx16Target.name -> CompilationTarget.instance = Cx16Target
+        else -> {
+            System.err.println("invalid compilation target")
+            exitProcess(1)
+        }
+    }
+
     try {
         val totalTime = measureTimeMillis {
             // import main module and everything it needs
@@ -78,7 +92,7 @@ fun compileProgram(filepath: Path,
 }
 
 private fun parseImports(filepath: Path, errors: ErrorReporter): Triple<Program, CompilationOptions, List<Path>> {
-    println("Parsing...")
+    println("Compiler target: ${CompilationTarget.instance.name}. Parsing...")
     val importer = ModuleImporter()
     val programAst = Program(moduleName(filepath.fileName), mutableListOf())
     importer.importModule(programAst, filepath)
@@ -90,12 +104,12 @@ private fun parseImports(filepath: Path, errors: ErrorReporter): Triple<Program,
     if (compilerOptions.launcher == LauncherType.BASIC && compilerOptions.output != OutputType.PRG)
         throw ParsingFailedError("${programAst.modules.first().position} BASIC launcher requires output type PRG.")
 
-    // depending on the mach9ine and compiler options we may have to include some libraries
+    // depending on the machine and compiler options we may have to include some libraries
-    CompilationTarget.machine.importLibs(compilerOptions, importer, programAst)
+    CompilationTarget.instance.machine.importLibs(compilerOptions, importer, programAst)
 
-    // always import prog8lib and math
+    // always import prog8_lib and math
     importer.importLibraryModule(programAst, "math")
-    importer.importLibraryModule(programAst, "prog8lib")
+    importer.importLibraryModule(programAst, "prog8_lib")
     errors.handle()
     return Triple(programAst, compilerOptions, importedFiles)
 }
@@ -106,13 +120,12 @@ private fun determineCompilationOptions(program: Program): CompilationOptions {
             as? Directive)?.args?.single()?.name?.toUpperCase()
     val launcherType = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%launcher" }
             as? Directive)?.args?.single()?.name?.toUpperCase()
-    mainModule.loadAddress = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%address" }
-            as? Directive)?.args?.single()?.int ?: 0
     val zpoption: String? = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%zeropage" }
             as? Directive)?.args?.single()?.name?.toUpperCase()
     val allOptions = program.modules.flatMap { it.statements }.filter { it is Directive && it.directive == "%option" }.flatMap { (it as Directive).args }.toSet()
     val floatsEnabled = allOptions.any { it.name == "enable_floats" }
-    val zpType: ZeropageType =
+    val noSysInit = allOptions.any { it.name == "no_sysinit" }
+    var zpType: ZeropageType =
             if (zpoption == null)
                 if(floatsEnabled) ZeropageType.FLOATSAFE else ZeropageType.KERNALSAFE
             else
@@ -122,6 +135,12 @@ private fun determineCompilationOptions(program: Program): CompilationOptions {
                     ZeropageType.KERNALSAFE
                     // error will be printed by the astchecker
                 }
+
+    if (zpType==ZeropageType.FLOATSAFE && CompilationTarget.instance.name == Cx16Target.name) {
+        System.err.println("Warning: Cx16 target must use zp option basicsafe instead of floatsafe")
+        zpType = ZeropageType.BASICSAFE
+    }
+
     val zpReserved = mainModule.statements
             .asSequence()
             .filter { it is Directive && it.directive == "%zpreserved" }
@@ -129,21 +148,31 @@ private fun determineCompilationOptions(program: Program): CompilationOptions {
             .map { it[0].int!!..it[1].int!! }
             .toList()
 
+    if(outputType!=null && !OutputType.values().any {it.name==outputType}) {
+        System.err.println("invalid output type $outputType")
+        exitProcess(1)
+    }
+    if(launcherType!=null && !LauncherType.values().any {it.name==launcherType}) {
+        System.err.println("invalid launcher type $launcherType")
+        exitProcess(1)
+    }
+
     return CompilationOptions(
             if (outputType == null) OutputType.PRG else OutputType.valueOf(outputType),
             if (launcherType == null) LauncherType.BASIC else LauncherType.valueOf(launcherType),
-            zpType, zpReserved, floatsEnabled
+            zpType, zpReserved, floatsEnabled, noSysInit
     )
 }
 
 private fun processAst(programAst: Program, errors: ErrorReporter, compilerOptions: CompilationOptions) {
     // perform initial syntax checks and processings
-    println("Processing...")
+    println("Processing for target ${CompilationTarget.instance.name}...")
     programAst.checkIdentifiers(errors)
     errors.handle()
     programAst.constantFold(errors)
     errors.handle()
-    programAst.reorderStatements()
+    programAst.reorderStatements(errors)
+    errors.handle()
     programAst.addTypecasts(errors)
     errors.handle()
     programAst.variousCleanups()
@@ -159,14 +188,15 @@ private fun optimizeAst(programAst: Program, errors: ErrorReporter) {
     while (true) {
         // keep optimizing expressions and statements until no more steps remain
         val optsDone1 = programAst.simplifyExpressions()
-        val optsDone2 = programAst.optimizeStatements(errors)
+        val optsDone2 = programAst.splitBinaryExpressions()
-        programAst.constantFold(errors) // because simplified statements and expressions could give rise to more constants that can be folded away:
+        val optsDone3 = programAst.optimizeStatements(errors)
+        programAst.constantFold(errors) // because simplified statements and expressions can result in more constants that can be folded away
         errors.handle()
-        if (optsDone1 + optsDone2 == 0)
+        if (optsDone1 + optsDone2 + optsDone3 == 0)
             break
     }
 
-    val remover = UnusedCodeRemover(errors)
+    val remover = UnusedCodeRemover(programAst, errors)
     remover.visit(programAst)
     remover.applyModifications()
     errors.handle()
@@ -181,6 +211,7 @@ private fun postprocessAst(programAst: Program, errors: ErrorReporter, compilerO
     programAst.checkRecursion(errors)         // check if there are recursive subroutine calls
     errors.handle()
     programAst.verifyFunctionArgTypes()
+    programAst.moveMainAndStartToFirst()
 }
 
 private fun writeAssembly(programAst: Program, errors: ErrorReporter, outputDir: Path,
@@ -191,11 +222,11 @@ private fun writeAssembly(programAst: Program, errors: ErrorReporter, outputDir:
 
     // printAst(programAst)
 
-    CompilationTarget.machine.initializeZeropage(compilerOptions)
+    CompilationTarget.instance.machine.initializeZeropage(compilerOptions)
-    val assembly = CompilationTarget.asmGenerator(
+    val assembly = CompilationTarget.instance.asmGenerator(
             programAst,
             errors,
-            CompilationTarget.machine.zeropage,
+            CompilationTarget.instance.machine.zeropage,
             compilerOptions,
             outputDir).compileToAssembly(optimize)
     assembly.assemble(compilerOptions)

compiler/src/prog8/compiler/Zeropage.kt

@@ -10,7 +10,6 @@ abstract class Zeropage(protected val options: CompilationOptions) {
 
     abstract val SCRATCH_B1 : Int      // temp storage for a single byte
     abstract val SCRATCH_REG : Int     // temp storage for a register
-    abstract val SCRATCH_REG_X : Int   // temp storage for register X (the evaluation stack pointer)
     abstract val SCRATCH_W1 : Int      // temp storage 1 for a word  $fb+$fc
     abstract val SCRATCH_W2 : Int      // temp storage 2 for a word  $fb+$fc
 
@@ -71,12 +70,4 @@ abstract class Zeropage(protected val options: CompilationOptions) {
 
     private fun loneByte(address: Int) = address in free && address-1 !in free && address+1 !in free
     private fun sequentialFree(address: Int, size: Int) = free.containsAll((address until address+size).toList())
-
-    enum class ExitProgramStrategy {
-        CLEAN_EXIT,
-        SYSTEM_RESET
-    }
-
-    abstract val exitProgramStrategy: ExitProgramStrategy
-
 }

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

@@ -4,15 +4,44 @@ import prog8.ast.Program
 import prog8.ast.base.ErrorReporter
 import prog8.compiler.CompilationOptions
 import prog8.compiler.Zeropage
+import prog8.compiler.target.c64.C64MachineDefinition
+import prog8.compiler.target.c64.Petscii
+import prog8.compiler.target.c64.codegen.AsmGen
+import prog8.compiler.target.cx16.CX16MachineDefinition
 import java.nio.file.Path
 
 
 internal interface CompilationTarget {
+    val name: String
+    val machine: IMachineDefinition
+    fun encodeString(str: String, altEncoding: Boolean): List<Short>
+    fun decodeString(bytes: List<Short>, altEncoding: Boolean): String
+    fun asmGenerator(program: Program, errors: ErrorReporter, zp: Zeropage, options: CompilationOptions, path: Path): IAssemblyGenerator
+
     companion object {
-        lateinit var name: String
+        lateinit var instance: CompilationTarget
-        lateinit var machine: IMachineDefinition
-        lateinit var encodeString: (str: String, altEncoding: Boolean) -> List<Short>
-        lateinit var decodeString: (bytes: List<Short>, altEncoding: Boolean) -> String
-        lateinit var asmGenerator: (Program, ErrorReporter, Zeropage, CompilationOptions, Path) -> IAssemblyGenerator
     }
 }
+
+
+internal object C64Target: CompilationTarget {
+    override val name = "c64"
+    override val machine = C64MachineDefinition
+    override fun encodeString(str: String, altEncoding: Boolean) =
+            if(altEncoding) Petscii.encodeScreencode(str, true) else Petscii.encodePetscii(str, true)
+    override fun decodeString(bytes: List<Short>, altEncoding: Boolean) =
+            if(altEncoding) Petscii.decodeScreencode(bytes, true) else Petscii.decodePetscii(bytes, true)
+    override fun asmGenerator(program: Program, errors: ErrorReporter, zp: Zeropage, options: CompilationOptions, path: Path) =
+            AsmGen(program, errors, zp, options, path)
+}
+
+internal object Cx16Target: CompilationTarget {
+    override val name = "cx16"
+    override val machine = CX16MachineDefinition
+    override fun encodeString(str: String, altEncoding: Boolean) =
+            if(altEncoding) Petscii.encodeScreencode(str, true) else Petscii.encodePetscii(str, true)
+    override fun decodeString(bytes: List<Short>, altEncoding: Boolean) =
+            if(altEncoding) Petscii.decodeScreencode(bytes, true) else Petscii.decodePetscii(bytes, true)
+    override fun asmGenerator(program: Program, errors: ErrorReporter, zp: Zeropage, options: CompilationOptions, path: Path) =
+            AsmGen(program, errors, zp, options, path)
+}

compiler/src/prog8/compiler/target/IMachineDefinition.kt

@@ -28,7 +28,6 @@ internal interface IMachineDefinition {
 
     val opcodeNames: Set<String>
     var zeropage: Zeropage
-    val initSystemProcname: String
     val cpu: CpuType
 
     fun initializeZeropage(compilerOptions: CompilationOptions)
@@ -36,4 +35,5 @@ internal interface IMachineDefinition {
     fun getFloatRomConst(number: Double): String?
     fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program)
     fun launchEmulator(programName: String)
+    fun isRegularRAMaddress(address: Int): Boolean
 }

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

@@ -2,6 +2,7 @@ package prog8.compiler.target.c64
 
 import prog8.compiler.CompilationOptions
 import prog8.compiler.OutputType
+import prog8.compiler.target.CompilationTarget
 import prog8.compiler.target.IAssemblyProgram
 import prog8.compiler.target.generatedLabelPrefix
 import java.nio.file.Path
@@ -22,12 +23,12 @@ class AssemblyProgram(override val name: String, outputDir: Path) : IAssemblyPro
         val outFile = when (options.output) {
             OutputType.PRG -> {
                 command.add("--cbm-prg")
-                println("\nCreating prg.")
+                println("\nCreating prg for target ${CompilationTarget.instance.name}.")
                 prgFile
             }
             OutputType.RAW -> {
                 command.add("--nostart")
-                println("\nCreating raw binary.")
+                println("\nCreating raw binary for target ${CompilationTarget.instance.name}.")
                 binFile
             }
         }

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

@@ -29,7 +29,6 @@ internal object C64MachineDefinition: IMachineDefinition {
     override val ESTACK_HI = 0xcf00        //  $ce00-$ceff inclusive
 
     override lateinit var zeropage: Zeropage
-    override val initSystemProcname = "c64.init_system"
 
     override fun getFloat(num: Number) = Mflpt5.fromNumber(num)
 
@@ -38,28 +37,29 @@ internal object C64MachineDefinition: IMachineDefinition {
         val mflpt5 = Mflpt5.fromNumber(number)
         val floatbytes = shortArrayOf(mflpt5.b0, mflpt5.b1, mflpt5.b2, mflpt5.b3, mflpt5.b4)
         when {
-            floatbytes.contentEquals(shortArrayOf(0x00, 0x00, 0x00, 0x00, 0x00)) -> return "c64flt.ZERO"        // not a ROM const
+            floatbytes.contentEquals(shortArrayOf(0x00, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_ZERO_const"        // not a ROM const
-            floatbytes.contentEquals(shortArrayOf(0x82, 0x49, 0x0f, 0xda, 0xa1)) -> return "c64flt.FL_PIVAL"
+            floatbytes.contentEquals(shortArrayOf(0x81, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_ONE_const"        // not a ROM const
-            floatbytes.contentEquals(shortArrayOf(0x90, 0x80, 0x00, 0x00, 0x00)) -> return "c64flt.FL_N32768"
+            floatbytes.contentEquals(shortArrayOf(0x82, 0x49, 0x0f, 0xda, 0xa1)) -> return "floats.FL_PIVAL"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x00, 0x00, 0x00, 0x00)) -> return "c64flt.FL_FONE"
+            floatbytes.contentEquals(shortArrayOf(0x90, 0x80, 0x00, 0x00, 0x00)) -> return "floats.FL_N32768"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x35, 0x04, 0xf3, 0x34)) -> return "c64flt.FL_SQRHLF"
+            floatbytes.contentEquals(shortArrayOf(0x81, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_FONE"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x35, 0x04, 0xf3, 0x34)) -> return "c64flt.FL_SQRTWO"
+            floatbytes.contentEquals(shortArrayOf(0x80, 0x35, 0x04, 0xf3, 0x34)) -> return "floats.FL_SQRHLF"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x80, 0x00, 0x00, 0x00)) -> return "c64flt.FL_NEGHLF"
+            floatbytes.contentEquals(shortArrayOf(0x81, 0x35, 0x04, 0xf3, 0x34)) -> return "floats.FL_SQRTWO"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x31, 0x72, 0x17, 0xf8)) -> return "c64flt.FL_LOG2"
+            floatbytes.contentEquals(shortArrayOf(0x80, 0x80, 0x00, 0x00, 0x00)) -> return "floats.FL_NEGHLF"
-            floatbytes.contentEquals(shortArrayOf(0x84, 0x20, 0x00, 0x00, 0x00)) -> return "c64flt.FL_TENC"
+            floatbytes.contentEquals(shortArrayOf(0x80, 0x31, 0x72, 0x17, 0xf8)) -> return "floats.FL_LOG2"
-            floatbytes.contentEquals(shortArrayOf(0x9e, 0x6e, 0x6b, 0x28, 0x00)) -> return "c64flt.FL_NZMIL"
+            floatbytes.contentEquals(shortArrayOf(0x84, 0x20, 0x00, 0x00, 0x00)) -> return "floats.FL_TENC"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x00, 0x00, 0x00, 0x00)) -> return "c64flt.FL_FHALF"
+            floatbytes.contentEquals(shortArrayOf(0x9e, 0x6e, 0x6b, 0x28, 0x00)) -> return "floats.FL_NZMIL"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x38, 0xaa, 0x3b, 0x29)) -> return "c64flt.FL_LOGEB2"
+            floatbytes.contentEquals(shortArrayOf(0x80, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_FHALF"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x49, 0x0f, 0xda, 0xa2)) -> return "c64flt.FL_PIHALF"
+            floatbytes.contentEquals(shortArrayOf(0x81, 0x38, 0xaa, 0x3b, 0x29)) -> return "floats.FL_LOGEB2"
-            floatbytes.contentEquals(shortArrayOf(0x83, 0x49, 0x0f, 0xda, 0xa2)) -> return "c64flt.FL_TWOPI"
+            floatbytes.contentEquals(shortArrayOf(0x81, 0x49, 0x0f, 0xda, 0xa2)) -> return "floats.FL_PIHALF"
-            floatbytes.contentEquals(shortArrayOf(0x7f, 0x00, 0x00, 0x00, 0x00)) -> return "c64flt.FL_FR4"
+            floatbytes.contentEquals(shortArrayOf(0x83, 0x49, 0x0f, 0xda, 0xa2)) -> return "floats.FL_TWOPI"
+            floatbytes.contentEquals(shortArrayOf(0x7f, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_FR4"
             else -> {
                 // attempt to correct for a few rounding issues
                 when (number.toBigDecimal().setScale(10, RoundingMode.HALF_DOWN).toDouble()) {
-                    3.1415926536 -> return "c64flt.FL_PIVAL"
+                    3.1415926536 -> return "floats.FL_PIVAL"
-                    1.4142135624 -> return "c64flt.FL_SQRTWO"
+                    1.4142135624 -> return "floats.FL_SQRTWO"
-                    0.7071067812 -> return "c64flt.FL_SQRHLF"
+                    0.7071067812 -> return "floats.FL_SQRHLF"
-                    0.6931471806 -> return "c64flt.FL_LOG2"
+                    0.6931471806 -> return "floats.FL_LOG2"
                     else -> {}
                 }
             }
@@ -69,7 +69,7 @@ internal object C64MachineDefinition: IMachineDefinition {
 
     override fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program) {
         if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG)
-            importer.importLibraryModule(program, "c64lib")
+            importer.importLibraryModule(program, "syslib")
     }
 
     override fun launchEmulator(programName: String) {
@@ -89,6 +89,8 @@ internal object C64MachineDefinition: IMachineDefinition {
         }
     }
 
+    override fun isRegularRAMaddress(address: Int): Boolean = address<0xa000 || address in 0xc000..0xcfff
+
     override fun initializeZeropage(compilerOptions: CompilationOptions) {
         zeropage = C64Zeropage(compilerOptions)
     }
@@ -109,17 +111,10 @@ internal object C64MachineDefinition: IMachineDefinition {
 
         override val SCRATCH_B1 = 0x02      // temp storage for a single byte
         override val SCRATCH_REG = 0x03     // temp storage for a register
-        override val SCRATCH_REG_X = 0xfa   // temp storage for register X (the evaluation stack pointer)
         override val SCRATCH_W1 = 0xfb      // temp storage 1 for a word  $fb+$fc
         override val SCRATCH_W2 = 0xfd      // temp storage 2 for a word  $fb+$fc
 
 
-        override val exitProgramStrategy: ExitProgramStrategy = when (options.zeropage) {
-            ZeropageType.BASICSAFE, ZeropageType.DONTUSE -> ExitProgramStrategy.CLEAN_EXIT
-            ZeropageType.FLOATSAFE, ZeropageType.KERNALSAFE, ZeropageType.FULL -> ExitProgramStrategy.SYSTEM_RESET
-        }
-
-
         init {
             if (options.floats && options.zeropage !in setOf(ZeropageType.FLOATSAFE, ZeropageType.BASICSAFE, ZeropageType.DONTUSE ))
                 throw CompilerException("when floats are enabled, zero page type should be 'floatsafe' or 'basicsafe' or 'dontuse'")
@@ -127,7 +122,7 @@ internal object C64MachineDefinition: IMachineDefinition {
             if (options.zeropage == ZeropageType.FULL) {
                 free.addAll(0x04..0xf9)
                 free.add(0xff)
-                free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_REG_X, SCRATCH_W1, SCRATCH_W1 + 1, SCRATCH_W2, SCRATCH_W2 + 1))
+                free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_W1, SCRATCH_W1 + 1, SCRATCH_W2, SCRATCH_W2 + 1))
                 free.removeAll(listOf(0xa0, 0xa1, 0xa2, 0x91, 0xc0, 0xc5, 0xcb, 0xf5, 0xf6))        // these are updated by IRQ
             } else {
                 if (options.zeropage == ZeropageType.KERNALSAFE || options.zeropage == ZeropageType.FLOATSAFE) {
@@ -149,7 +144,7 @@ internal object C64MachineDefinition: IMachineDefinition {
                 if (options.zeropage == ZeropageType.FLOATSAFE) {
                     // remove the zero page locations used for floating point operations from the free list
                     free.removeAll(listOf(
-                            0x12, 0x26, 0x27, 0x28, 0x29, 0x2a,
+                            0x10, 0x11, 0x12, 0x26, 0x27, 0x28, 0x29, 0x2a,
                             0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
                             0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
                             0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
@@ -170,7 +165,6 @@ internal object C64MachineDefinition: IMachineDefinition {
             }
             require(SCRATCH_B1 !in free)
             require(SCRATCH_REG !in free)
-            require(SCRATCH_REG_X !in free)
             require(SCRATCH_W1 !in free)
             require(SCRATCH_W2 !in free)
 

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

@@ -1054,11 +1054,16 @@ object Petscii {
         val lookup = if(lowercase) encodingPetsciiLowercase else encodingPetsciiUppercase
         return text.map {
             val petscii = lookup[it]
-            petscii?.toShort() ?: if(it=='\u0000')
+            petscii?.toShort() ?: when (it) {
-                0.toShort()
+                '\u0000' -> 0.toShort()
-            else {
+                in '\u8000'..'\u80ff' -> {
-                val case = if (lowercase) "lower" else "upper"
+                    // special case: take the lower 8 bit hex value directly
-                throw CharConversionException("no ${case}case Petscii character for '$it' (${it.toShort()})")
+                    (it.toInt() - 0x8000).toShort()
+                }
+                else -> {
+                    val case = if (lowercase) "lower" else "upper"
+                    throw CharConversionException("no ${case}case Petscii character for '$it' (${it.toShort()})")
+                }
             }
         }
     }
@@ -1072,11 +1077,16 @@ object Petscii {
         val lookup = if(lowercase) encodingScreencodeLowercase else encodingScreencodeUppercase
         return text.map{
             val screencode = lookup[it]
-            screencode?.toShort() ?: if(it=='\u0000')
+            screencode?.toShort() ?: when (it) {
-                0.toShort()
+                '\u0000' -> 0.toShort()
-            else {
+                in '\u8000'..'\u80ff' -> {
-                val case = if (lowercase) "lower" else "upper"
+                    // special case: take the lower 8 bit hex value directly
-                throw CharConversionException("no ${case}Screencode character for '$it' (${it.toShort()})")
+                    (it.toInt() - 0x8000).toShort()
+                }
+                else -> {
+                    val case = if (lowercase) "lower" else "upper"
+                    throw CharConversionException("no ${case}Screencode character for '$it' (${it.toShort()})")
+                }
             }
         }
     }

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

@@ -35,6 +35,10 @@ internal class AsmGen(private val program: Program,
                       val options: CompilationOptions,
                       private val outputDir: Path): IAssemblyGenerator {
 
+    // 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)
+
     private val assemblyLines = mutableListOf<String>()
     private val globalFloatConsts = mutableMapOf<Double, String>()     // all float values in the entire program (value -> varname)
     private val allocatedZeropageVariables = mutableMapOf<String, Pair<Int, DataType>>()
@@ -43,10 +47,10 @@ internal class AsmGen(private val program: Program,
     private val forloopsAsmGen = ForLoopsAsmGen(program, this)
     private val postincrdecrAsmGen = PostIncrDecrAsmGen(program, this)
     private val functioncallAsmGen = FunctionCallAsmGen(program, this)
-    private val assignmentAsmGen = AssignmentAsmGen(program, this)
     private val expressionsAsmGen = ExpressionsAsmGen(program, this)
+    private val assignmentAsmGen = AssignmentAsmGen(program, this, expressionsAsmGen)
     internal val loopEndLabels = ArrayDeque<String>()
-    internal val blockLevelVarInits = mutableMapOf<Block, MutableSet<VarDecl>>()
+    private val blockLevelVarInits = mutableMapOf<Block, MutableSet<VarDecl>>()
 
     override fun compileToAssembly(optimize: Boolean): IAssemblyProgram {
         assemblyLines.clear()
@@ -77,9 +81,10 @@ internal class AsmGen(private val program: Program,
         return AssemblyProgram(program.name, outputDir)
     }
 
+
     private fun header() {
         val ourName = this.javaClass.name
-        val cpu = when(CompilationTarget.machine.cpu) {
+        val cpu = when(CompilationTarget.instance.machine.cpu) {
             CpuType.CPU6502 -> "6502"
             CpuType.CPU65c02 -> "65c02"
             else -> "unsupported"
@@ -94,18 +99,16 @@ internal class AsmGen(private val program: Program,
         program.actualLoadAddress = program.definedLoadAddress
         if (program.actualLoadAddress == 0)   // fix load address
             program.actualLoadAddress = if (options.launcher == LauncherType.BASIC)
-                CompilationTarget.machine.BASIC_LOAD_ADDRESS else CompilationTarget.machine.RAW_LOAD_ADDRESS
+                CompilationTarget.instance.machine.BASIC_LOAD_ADDRESS else CompilationTarget.instance.machine.RAW_LOAD_ADDRESS
 
         // the global prog8 variables needed
-        val zp = CompilationTarget.machine.zeropage
+        val zp = CompilationTarget.instance.machine.zeropage
-        val initproc = CompilationTarget.machine.initSystemProcname
         out("P8ZP_SCRATCH_B1 = ${zp.SCRATCH_B1}")
         out("P8ZP_SCRATCH_REG = ${zp.SCRATCH_REG}")
-        out("P8ZP_SCRATCH_REG_X = ${zp.SCRATCH_REG_X}")
         out("P8ZP_SCRATCH_W1 = ${zp.SCRATCH_W1}    ; word")
         out("P8ZP_SCRATCH_W2 = ${zp.SCRATCH_W2}    ; word")
-        out("P8ESTACK_LO = ${CompilationTarget.machine.ESTACK_LO.toHex()}")
+        out("P8ESTACK_LO = ${CompilationTarget.instance.machine.ESTACK_LO.toHex()}")
-        out("P8ESTACK_HI = ${CompilationTarget.machine.ESTACK_HI.toHex()}")
+        out("P8ESTACK_HI = ${CompilationTarget.instance.machine.ESTACK_HI.toHex()}")
 
         when {
             options.launcher == LauncherType.BASIC -> {
@@ -118,18 +121,14 @@ internal class AsmGen(private val program: Program,
                 out("  .null  $9e, format(' %d ', _prog8_entrypoint), $3a, $8f, ' prog8 by idj'")
                 out("+\t.word  0")
                 out("_prog8_entrypoint\t; assembly code starts here\n")
-                out("  tsx")
+                if(!options.noSysInit)
-                out("  stx  prog8_lib.orig_stackpointer")
+                    out("  jsr  ${CompilationTarget.instance.name}.init_system")
-                if(!initproc.isNullOrEmpty())
-                    out("  jsr  $initproc")
             }
             options.output == OutputType.PRG -> {
                 out("; ---- program without basic sys call ----")
                 out("* = ${program.actualLoadAddress.toHex()}\n")
-                out("  tsx")
+                if(!options.noSysInit)
-                out("  stx  prog8_lib.orig_stackpointer")
+                    out("  jsr  ${CompilationTarget.instance.name}.init_system")
-                if(!initproc.isNullOrEmpty())
-                    out("  jsr  $initproc")
             }
             options.output == OutputType.RAW -> {
                 out("; ---- raw assembler program ----")
@@ -137,40 +136,23 @@ internal class AsmGen(private val program: Program,
             }
         }
 
-        if (zeropage.exitProgramStrategy != Zeropage.ExitProgramStrategy.CLEAN_EXIT) {
+        if(options.zeropage !in setOf(ZeropageType.BASICSAFE, ZeropageType.DONTUSE)) {
-            // disable shift-commodore charset switching and run/stop key
+            out("""
-            out("  lda  #$80")
+                ; zeropage is clobbered so we need to reset the machine at exit
-            out("  lda  #$80")
+                lda  #>${CompilationTarget.instance.name}.reset_system
-            out("  sta  657\t; disable charset switching")
+                pha
-            out("  lda  #239")
+                lda  #<${CompilationTarget.instance.name}.reset_system
-            out("  sta  808\t; disable run/stop key")
+                pha""")
         }
 
-        out("  ldx  #\$ff\t; init estack pointer")
+        out("  jmp  main.start  ; start program / force start proc to be included")
-
-        out("  ; initialize the variables in each block that has globals")
-        program.allBlocks().forEach {
-            if(it.statements.filterIsInstance<VarDecl>().any { vd->vd.value!=null && vd.type==VarDeclType.VAR && vd.datatype in NumericDatatypes})
-                out("  jsr  ${it.name}.prog8_init_vars")
-        }
-
-        out("  clc")
-        when (zeropage.exitProgramStrategy) {
-            Zeropage.ExitProgramStrategy.CLEAN_EXIT -> {
-                out("  jmp  main.start\t; jump to program entrypoint")
-            }
-            Zeropage.ExitProgramStrategy.SYSTEM_RESET -> {
-                out("  jsr  main.start\t; call program entrypoint")
-                out("  jmp  (c64.RESET_VEC)\t; cold reset")
-            }
-        }
     }
 
     private fun footer() {
         // the global list of all floating point constants for the whole program
         out("; global float constants")
         for (flt in globalFloatConsts) {
-            val floatFill = CompilationTarget.machine.getFloat(flt.key).makeFloatFillAsm()
+            val floatFill = CompilationTarget.instance.machine.getFloat(flt.key).makeFloatFillAsm()
             val floatvalue = flt.key
             out("${flt.value}\t.byte  $floatFill  ; float $floatvalue")
         }
@@ -212,11 +194,10 @@ internal class AsmGen(private val program: Program,
     }
 
     private fun assignInitialValueToVar(decl: VarDecl, variableName: List<String>) {
-        val variable = IdentifierReference(variableName, decl.position)
+        val asmName = asmVariableName(variableName)
-        variable.linkParents(decl.parent)
         val asgn = AsmAssignment(
-                AsmAssignSource.fromAstSource(decl.value!!, program),
+                AsmAssignSource.fromAstSource(decl.value!!, program, this),
-                AsmAssignTarget(TargetStorageKind.VARIABLE, program, this, decl.datatype, variable = variable),
+                AsmAssignTarget(TargetStorageKind.VARIABLE, program, this, decl.datatype, decl.definingSubroutine(), variableAsmName = asmName),
                 false, decl.position)
         assignmentAsmGen.translateNormalAssignment(asgn)
     }
@@ -340,7 +321,7 @@ internal class AsmGen(private val program: Program,
                         }
                 val floatFills = array.map {
                     val number = (it as NumericLiteralValue).number
-                    CompilationTarget.machine.getFloat(number).makeFloatFillAsm()
+                    CompilationTarget.instance.machine.getFloat(number).makeFloatFillAsm()
                 }
                 out(name)
                 for (f in array.zip(floatFills))
@@ -353,7 +334,10 @@ internal class AsmGen(private val program: Program,
         out("\n; memdefs and kernel subroutines")
         val memvars = statements.filterIsInstance<VarDecl>().filter { it.type==VarDeclType.MEMORY || it.type==VarDeclType.CONST }
         for(m in memvars) {
-            out("  ${m.name} = ${(m.value as NumericLiteralValue).number.toHex()}")
+            if(m.value is NumericLiteralValue)
+                out("  ${m.name} = ${(m.value as NumericLiteralValue).number.toHex()}")
+            else
+                out("  ${m.name} = ${asmVariableName((m.value as AddressOf).identifier)}")
         }
         val asmSubs = statements.filterIsInstance<Subroutine>().filter { it.isAsmSubroutine }
         for(sub in asmSubs) {
@@ -421,10 +405,17 @@ internal class AsmGen(private val program: Program,
                     "$"+number.toString(16).padStart(2, '0')
                 }
             DataType.ARRAY_UW -> array.map {
-                if(it is NumericLiteralValue) {
+                when (it) {
-                    "$" + it.number.toInt().toString(16).padStart(4, '0')
+                    is NumericLiteralValue -> {
-                } else {
+                        "$" + it.number.toInt().toString(16).padStart(4, '0')
-                    (it as AddressOf).identifier.nameInSource.joinToString(".")
+                    }
+                    is AddressOf -> {
+                        it.identifier.firstStructVarName(program.namespace) ?: asmSymbolName(it.identifier)
+                    }
+                    is IdentifierReference -> {
+                        it.firstStructVarName(program.namespace) ?: asmSymbolName(it)
+                    }
+                    else -> throw AssemblyError("weird array elt dt")
                 }
             }
             else -> throw AssemblyError("invalid arraysize type")
@@ -474,7 +465,7 @@ internal class AsmGen(private val program: Program,
     }
 
     internal fun getFloatAsmConst(number: Double): String {
-        var asmName = CompilationTarget.machine.getFloatRomConst(number)
+        var asmName = CompilationTarget.instance.machine.getFloatRomConst(number)
         if(asmName.isNullOrEmpty()) {
             // no ROM float const for this value, create our own
             asmName = globalFloatConsts[number]
@@ -504,8 +495,14 @@ internal class AsmGen(private val program: Program,
         }
     }
 
+    internal fun asmSymbolName(name: String) = fixNameSymbols(name)
+    internal fun asmVariableName(name: String) = fixNameSymbols(name)
+    internal fun asmSymbolName(name: Iterable<String>) = fixNameSymbols(name.joinToString("."))
+    internal fun asmVariableName(name: Iterable<String>) = fixNameSymbols(name.joinToString("."))
+
+
     internal fun loadByteFromPointerIntoA(pointervar: IdentifierReference): Pair<Boolean, String> {
-        // returns if the pointer is already on the ZP itself or not (in which case SCRATCH_W1 is used as intermediary)
+        // returns if the pointer is already on the ZP itself or not (in the latter case SCRATCH_W1 is used as intermediary)
         val sourceName = asmVariableName(pointervar)
         val vardecl = pointervar.targetVarDecl(program.namespace)!!
         val scopedName = vardecl.makeScopedName(vardecl.name)
@@ -546,34 +543,77 @@ internal class AsmGen(private val program: Program,
         }
     }
 
-    internal fun fixNameSymbols(name: String) = name.replace("<", "prog8_").replace(">", "")     // take care of the autogenerated invalid (anon) label names
+    private  fun fixNameSymbols(name: String) = name.replace("<", "prog8_").replace(">", "")     // take care of the autogenerated invalid (anon) label names
 
-    internal fun saveRegister(register: CpuRegister) {
+    private val saveRegisterLabels = Stack<String>()
-        when(register) {
+
-            CpuRegister.A -> out("  pha")
+    internal fun saveRegister(register: CpuRegister, dontUseStack: Boolean, scope: Subroutine?) {
-            CpuRegister.X -> {
+        if(dontUseStack) {
-                if(CompilationTarget.machine.cpu == CpuType.CPU65c02)
+            when (register) {
-                    out("  phx")
+                CpuRegister.A -> {
-                else
+                    out("  sta  _prog8_regsaveA")
-                    out("  stx  P8ZP_SCRATCH_REG_X")
+                    if (scope != null)
+                        scope.asmGenInfo.usedRegsaveA = true
+                }
+                CpuRegister.X -> {
+                    out("  stx  _prog8_regsaveX")
+                    if (scope != null)
+                        scope.asmGenInfo.usedRegsaveX = true
+                }
+                CpuRegister.Y -> {
+                    out("  sty  _prog8_regsaveY")
+                    if (scope != null)
+                        scope.asmGenInfo.usedRegsaveY = true
+                }
+            }
+
+        } else {
+            when (register) {
+                CpuRegister.A -> out("  pha")
+                CpuRegister.X -> {
+                    if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phx")
+                    else {
+                        out("  stx  _prog8_regsaveX")
+                        if (scope != null)
+                            scope.asmGenInfo.usedRegsaveX = true
+                    }
+                }
+                CpuRegister.Y -> {
+                    if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phy")
+                    else {
+                        out("  sty  _prog8_regsaveY")
+                        if (scope != null)
+                            scope.asmGenInfo.usedRegsaveY = true
+                    }
+                }
             }
-            CpuRegister.Y -> out("  tya | pha")
         }
     }
 
-    internal fun restoreRegister(register: CpuRegister) {
+    internal fun restoreRegister(register: CpuRegister, dontUseStack: Boolean) {
-        when(register) {
+        if(dontUseStack) {
-            CpuRegister.A -> out("  pla")
+            when (register) {
-            CpuRegister.X -> {
+                CpuRegister.A -> out("  sta  _prog8_regsaveA")
-                if(CompilationTarget.machine.cpu == CpuType.CPU65c02)
+                CpuRegister.X -> out("  ldx  _prog8_regsaveX")
-                    out("  plx")
+                CpuRegister.Y -> out("  ldy  _prog8_regsaveY")
-                else
+            }
-                    out("  ldx  P8ZP_SCRATCH_REG_X")
+
+        } else {
+            when (register) {
+                CpuRegister.A -> out("  pla")
+                CpuRegister.X -> {
+                    if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  plx")
+                    else out("  ldx  _prog8_regsaveX")
+                }
+                CpuRegister.Y -> {
+                    if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  ply")
+                    else out("  ldy  _prog8_regsaveY")
+                }
             }
-            CpuRegister.Y -> out("  pla | tay")
         }
     }
 
+
     internal fun translate(stmt: Statement) {
         outputSourceLine(stmt)
         when(stmt) {
@@ -587,19 +627,22 @@ internal class AsmGen(private val program: Program,
             is FunctionCallStatement -> {
                 val functionName = stmt.target.nameInSource.last()
                 val builtinFunc = BuiltinFunctions[functionName]
-                if(builtinFunc!=null) {
+                if (builtinFunc != null) {
                     builtinFunctionsAsmGen.translateFunctioncallStatement(stmt, builtinFunc)
                 } else {
-                    functioncallAsmGen.translateFunctionCall(stmt)
-                    // discard any results from the stack:
                     val sub = stmt.target.targetSubroutine(program.namespace)!!
+                    val preserveStatusRegisterAfterCall = sub.asmReturnvaluesRegisters.any {it.statusflag!=null}
+                    functioncallAsmGen.translateFunctionCall(stmt, preserveStatusRegisterAfterCall)
+                    // discard any results from the stack:
                     val returns = sub.returntypes.zip(sub.asmReturnvaluesRegisters)
-                    for((t, reg) in returns) {
+                    for ((t, reg) in returns) {
-                        if(reg.stack) {
+                        if (reg.stack) {
                             if (t in IntegerDatatypes || t in PassByReferenceDatatypes) out("  inx")
                             else if (t == DataType.FLOAT) out("  inx |  inx |  inx")
                         }
                     }
+                    if(preserveStatusRegisterAfterCall)
+                        out("  plp\t; restore status flags from call")
                 }
             }
             is Assignment -> assignmentAsmGen.translate(stmt)
@@ -684,7 +727,7 @@ internal class AsmGen(private val program: Program,
 +""")
                 when(register) {
                     CpuRegister.A -> out("  inx |  lda  P8ESTACK_LO,x")
-                    CpuRegister.X -> throw AssemblyError("can't use X here")
+                    CpuRegister.X -> out("  inx |  lda  P8ESTACK_LO,x |  tax")
                     CpuRegister.Y -> out("  inx |  ldy  P8ESTACK_LO,x")
                 }
             }
@@ -720,10 +763,41 @@ internal class AsmGen(private val program: Program,
             }
             else {
                 expressionsAsmGen.translateExpression(index)
-                when(register) {
+                when(elementDt) {
-                    CpuRegister.A -> out("  inx |  lda  P8ESTACK_LO,x")
+                    in ByteDatatypes -> {
-                    CpuRegister.X -> throw AssemblyError("can't use X here")
+                        when (register) {
-                    CpuRegister.Y -> out("  inx |  ldy  P8ESTACK_LO,x")
+                            CpuRegister.A -> out("  inx |  lda  P8ESTACK_LO,x")
+                            CpuRegister.X -> out("  inx |  lda  P8ESTACK_LO,x |  tax")
+                            CpuRegister.Y -> out("  inx |  ldy  P8ESTACK_LO,x")
+                        }
+                    }
+                    in WordDatatypes -> {
+                        out("""
+                            inx
+                            lda  P8ESTACK_LO,x
+                            asl  a""")
+                        when (register) {
+                            CpuRegister.A -> {}
+                            CpuRegister.X -> out("  tax")
+                            CpuRegister.Y -> out("  tay")
+                        }
+                    }
+                    DataType.FLOAT -> {
+                        require(DataType.FLOAT.memorySize()==5)
+                        out("""
+                            inx
+                            lda  P8ESTACK_LO,x
+                            asl  a
+                            asl  a
+                            clc
+                            adc  P8ESTACK_LO,x""")
+                        when (register) {
+                            CpuRegister.A -> {}
+                            CpuRegister.X -> out("  tax")
+                            CpuRegister.Y -> out("  tay")
+                        }
+                    }
+                    else -> throw AssemblyError("weird dt")
                 }
             }
         }
@@ -735,8 +809,8 @@ internal class AsmGen(private val program: Program,
     internal fun translateFunctioncallExpression(functionCall: FunctionCall, signature: FSignature) =
             builtinFunctionsAsmGen.translateFunctioncallExpression(functionCall, signature)
 
-    internal fun translateFunctionCall(functionCall: FunctionCall) =
+    internal fun translateFunctionCall(functionCall: FunctionCall, preserveStatusRegisterAfterCall: Boolean) =
-            functioncallAsmGen.translateFunctionCall(functionCall)
+            functioncallAsmGen.translateFunctionCall(functionCall, preserveStatusRegisterAfterCall)
 
     internal fun translateNormalAssignment(assign: AsmAssignment) =
             assignmentAsmGen.translateNormalAssignment(assign)
@@ -758,9 +832,33 @@ internal class AsmGen(private val program: Program,
             out("${sub.name}\t.proc")
             zeropagevars2asm(sub.statements)
             memdefs2asm(sub.statements)
+
+            // the main.start subroutine is the program's entrypoint and should perform some initialization logic
+            if(sub.name=="start" && sub.definingBlock().name=="main") {
+                out("; program startup initialization")
+                out("  cld")
+                program.allBlocks().forEach {
+                    if(it.statements.filterIsInstance<VarDecl>().any { vd->vd.value!=null && vd.type==VarDeclType.VAR && vd.datatype in NumericDatatypes})
+                        out("  jsr  ${it.name}.prog8_init_vars")
+                }
+                out("""
+                    tsx
+                    stx  prog8_lib.orig_stackpointer    ; required for func_exit                    
+                    ldx  #255       ; init estack ptr
+                    clv
+                    clc""")
+            }
+
             out("; statements")
             sub.statements.forEach{ translate(it) }
             out("; variables")
+            out("; register saves")
+            if(sub.asmGenInfo.usedRegsaveA)
+                out("_prog8_regsaveA     .byte  0")
+            if(sub.asmGenInfo.usedRegsaveX)
+                out("_prog8_regsaveX     .byte  0")
+            if(sub.asmGenInfo.usedRegsaveY)
+                out("_prog8_regsaveY     .byte  0")
             vardecls2asm(sub.statements)
             out("  .pend\n")
         }
@@ -792,25 +890,32 @@ internal class AsmGen(private val program: Program,
             }
 
     private fun translate(stmt: IfStatement) {
-        expressionsAsmGen.translateExpression(stmt.condition)
+        checkBooleanExpression(stmt.condition)  // we require the condition to be of the form  'x <comparison> <value>'
-        translateTestStack(stmt.condition.inferType(program).typeOrElse(DataType.STRUCT))
+        val booleanCondition = stmt.condition as BinaryExpression
-        val elseLabel = makeLabel("if_else")
+
-        val endLabel = makeLabel("if_end")
+        if (stmt.elsepart.containsNoCodeNorVars()) {
-        out("  beq  $elseLabel")
+            // empty else
-        translate(stmt.truepart)
+            val endLabel = makeLabel("if_end")
-        out("  jmp  $endLabel")
+            expressionsAsmGen.translateComparisonExpressionWithJumpIfFalse(booleanCondition, endLabel)
-        out(elseLabel)
+            translate(stmt.truepart)
-        translate(stmt.elsepart)
+            out(endLabel)
-        out(endLabel)
+        }
+        else {
+            // both true and else parts
+            val elseLabel = makeLabel("if_else")
+            val endLabel = makeLabel("if_end")
+            expressionsAsmGen.translateComparisonExpressionWithJumpIfFalse(booleanCondition, elseLabel)
+            translate(stmt.truepart)
+            out("  jmp  $endLabel")
+            out(elseLabel)
+            translate(stmt.elsepart)
+            out(endLabel)
+        }
     }
 
-    private fun translateTestStack(dataType: DataType) {
+    private fun checkBooleanExpression(condition: Expression) {
-        when(dataType) {
+        if(condition !is BinaryExpression || condition.operator !in comparisonOperators)
-            in ByteDatatypes -> out("  inx |  lda  P8ESTACK_LO,x")
+            throw AssemblyError("expected boolean expression $condition")
-            in WordDatatypes -> out("  inx |  lda  P8ESTACK_LO,x |  ora  P8ESTACK_HI,x")
-            DataType.FLOAT -> throw AssemblyError("conditional value should be an integer (boolean)")
-            else -> throw AssemblyError("non-numerical dt")
-        }
     }
 
     private fun translate(stmt: RepeatLoop) {
@@ -881,7 +986,11 @@ internal class AsmGen(private val program: Program,
         // note: A/Y must have been loaded with the number of iterations already!
         val counterVar = makeLabel("repeatcounter")
         out("""
-                sta  $counterVar
+                bne  +
+                cpy  #0
+                bne  +
+                beq  $endLabel
++               sta  $counterVar
                 sty  $counterVar+1
 $repeatLabel    lda  $counterVar
                 bne  +
@@ -910,6 +1019,7 @@ $counterVar    .word  0""")
         // note: A must have been loaded with the number of iterations already!
         val counterVar = makeLabel("repeatcounter")
         out("""
+            beq  $endLabel
             sta  $counterVar
 $repeatLabel""")
         translate(body)
@@ -929,25 +1039,13 @@ $counterVar    .byte  0""")
     }
 
     private fun translate(stmt: WhileLoop) {
+        checkBooleanExpression(stmt.condition)  // we require the condition to be of the form  'x <comparison> <value>'
+        val booleanCondition = stmt.condition as BinaryExpression
         val whileLabel = makeLabel("while")
         val endLabel = makeLabel("whileend")
         loopEndLabels.push(endLabel)
         out(whileLabel)
-        expressionsAsmGen.translateExpression(stmt.condition)
+        expressionsAsmGen.translateComparisonExpressionWithJumpIfFalse(booleanCondition, endLabel)
-        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  |  beq  $endLabel")
-        } else {
-            out("""
-                inx
-                lda  P8ESTACK_LO,x
-                bne  +
-                lda  P8ESTACK_HI,x
-                beq  $endLabel
-+  """)
-        }
         translate(stmt.body)
         out("  jmp  $whileLabel")
         out(endLabel)
@@ -955,26 +1053,14 @@ $counterVar    .byte  0""")
     }
 
     private fun translate(stmt: UntilLoop) {
+        checkBooleanExpression(stmt.condition)  // we require the condition to be of the form  'x <comparison> <value>'
+        val booleanCondition = stmt.condition as BinaryExpression
         val repeatLabel = makeLabel("repeat")
         val endLabel = makeLabel("repeatend")
         loopEndLabels.push(endLabel)
         out(repeatLabel)
         translate(stmt.body)
-        expressionsAsmGen.translateExpression(stmt.untilCondition)
+        expressionsAsmGen.translateComparisonExpressionWithJumpIfFalse(booleanCondition, repeatLabel)
-        val conditionDt = stmt.untilCondition.inferType(program)
-        if(!conditionDt.isKnown)
-            throw AssemblyError("unknown condition dt")
-        if(conditionDt.typeOrElse(DataType.BYTE) in ByteDatatypes) {
-            out("  inx |  lda  P8ESTACK_LO,x  |  beq  $repeatLabel")
-        } else {
-            out("""
-                inx
-                lda  P8ESTACK_LO,x
-                bne  +
-                lda  P8ESTACK_HI,x
-                beq  $repeatLabel
-+ """)
-        }
         out(endLabel)
         loopEndLabels.pop()
     }
@@ -1014,6 +1100,7 @@ $counterVar    .byte  0""")
                 }
             }
         }
+        out("  jmp  $endLabel")
         for(choiceBlock in choiceBlocks) {
             out(choiceBlock.first)
             translate(choiceBlock.second)
@@ -1136,4 +1223,40 @@ $counterVar    .byte  0""")
         val assembly = asm.assembly.trimEnd().trimStart('\n')
         assemblyLines.add(assembly)
     }
+
+    internal fun signExtendStackLsb(valueDt: DataType) {
+        // sign extend signed byte on stack to signed word
+        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""")
+            }
+            else -> throw AssemblyError("need byte type")
+        }
+    }
+
+    internal fun signExtendVariableLsb(asmvar: String, valueDt: DataType) {
+        // sign extend signed byte in a word variable
+        when(valueDt) {
+            DataType.UBYTE -> {
+                out("  lda  #0 |  sta  $asmvar+1")
+            }
+            DataType.BYTE -> {
+                out("""
+                    lda  $asmvar+1
+                    ora  #$7f
+                    bmi  +
+                    lda  #0
++                   sta  $asmvar+1""")
+            }
+            else -> throw AssemblyError("need byte type")
+        }
+    }
 }

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

@@ -152,7 +152,7 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
 
         if(first.startsWith("lda") && second.startsWith("ldy") && third.startsWith("sta") && fourth.startsWith("sty") &&
                 fifth.startsWith("lda") && sixth.startsWith("ldy") &&
-                (seventh.startsWith("jsr  c64flt.copy_float") || seventh.startsWith("jsr  cx16flt.copy_float"))) {
+                (seventh.startsWith("jsr  floats.copy_float") || seventh.startsWith("jsr  cx16flt.copy_float"))) {
 
             val nineth = pair[8].value.trimStart()
             val tenth = pair[9].value.trimStart()
@@ -163,7 +163,7 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
 
             if(eighth.startsWith("lda") && nineth.startsWith("ldy") && tenth.startsWith("sta") && eleventh.startsWith("sty") &&
                     twelveth.startsWith("lda") && thirteenth.startsWith("ldy") &&
-                    (fourteenth.startsWith("jsr  c64flt.copy_float") || fourteenth.startsWith("jsr  cx16flt.copy_float"))) {
+                    (fourteenth.startsWith("jsr  floats.copy_float") || fourteenth.startsWith("jsr  cx16flt.copy_float"))) {
 
                 if(first.substring(4) == eighth.substring(4) && second.substring(4)==nineth.substring(4)) {
                     // identical float init
@@ -179,6 +179,7 @@ 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
     val mods = mutableListOf<Modification>()
     for (pair in linesByFour) {

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

@@ -4,8 +4,14 @@ import prog8.ast.IFunctionCall
 import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
+import prog8.ast.statements.DirectMemoryWrite
 import prog8.ast.statements.FunctionCallStatement
 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.SourceStorageKind
+import prog8.compiler.target.c64.codegen.assignment.TargetStorageKind
 import prog8.compiler.toHex
 import prog8.functions.FSignature
 
@@ -342,7 +348,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
 
     private fun funcVariousFloatFuncs(fcall: IFunctionCall, func: FSignature, functionName: String) {
         translateFunctionArguments(fcall.args, func)
-        asmgen.out("  jsr  c64flt.func_$functionName")
+        asmgen.out("  jsr  floats.func_$functionName")
     }
 
     private fun funcSgn(fcall: IFunctionCall, func: FSignature) {
@@ -353,7 +359,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             DataType.BYTE -> asmgen.out("  jsr  math.sign_b")
             DataType.UWORD -> asmgen.out("  jsr  math.sign_uw")
             DataType.WORD -> asmgen.out("  jsr  math.sign_w")
-            DataType.FLOAT -> asmgen.out("  jsr  c64flt.sign_f")
+            DataType.FLOAT -> asmgen.out("  jsr  floats.sign_f")
             else -> throw AssemblyError("weird type $dt")
         }
     }
@@ -364,7 +370,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
         when (dt.typeOrElse(DataType.STRUCT)) {
             DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${functionName}_b")
             DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${functionName}_w")
-            DataType.ARRAY_F -> asmgen.out("  jsr  c64flt.func_${functionName}_f")
+            DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${functionName}_f")
             else -> throw AssemblyError("weird type $dt")
         }
     }
@@ -377,30 +383,42 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             DataType.ARRAY_B -> asmgen.out("  jsr  prog8_lib.func_${functionName}_b")
             DataType.ARRAY_UW -> asmgen.out("  jsr  prog8_lib.func_${functionName}_uw")
             DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${functionName}_w")
-            DataType.ARRAY_F -> asmgen.out("  jsr  c64flt.func_${functionName}_f")
+            DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${functionName}_f")
             else -> throw AssemblyError("weird type $dt")
         }
     }
 
     private fun funcStrlen(fcall: IFunctionCall) {
         val name = asmgen.asmVariableName(fcall.args[0] as IdentifierReference)
-        asmgen.out("""
+        val type = fcall.args[0].inferType(program)
-            lda  #<$name
+        when {
-            ldy  #>$name
+            type.istype(DataType.STR) -> asmgen.out("""
-            jsr  prog8_lib.strlen
+                lda  #<$name
-            sta  P8ESTACK_LO,x
+                ldy  #>$name
-            dex""")
+                jsr  prog8_lib.strlen
+                sta  P8ESTACK_LO,x
+                dex""")
+            type.istype(DataType.UWORD) -> asmgen.out("""
+                lda  $name
+                ldy  $name+1
+                jsr  prog8_lib.strlen
+                sta  P8ESTACK_LO,x
+                dex""")
+            else -> throw AssemblyError("strlen requires str or uword arg")
+        }
     }
 
     private fun funcSwap(fcall: IFunctionCall) {
         val first = fcall.args[0]
         val second = fcall.args[1]
+
+        // optimized simple case: swap two variables
         if(first is IdentifierReference && second is IdentifierReference) {
             val firstName = asmgen.asmVariableName(first)
             val secondName = asmgen.asmVariableName(second)
             val dt = first.inferType(program)
             if(dt.istype(DataType.BYTE) || dt.istype(DataType.UBYTE)) {
-                asmgen.out(" ldy  $firstName |  lda  $secondName |  sta  $firstName |  tya |  sta  $secondName")
+                asmgen.out(" ldy  $firstName |  lda  $secondName |  sta  $firstName |  sty  $secondName")
                 return
             }
             if(dt.istype(DataType.WORD) || dt.istype(DataType.UWORD)) {
@@ -426,14 +444,196 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     sta  P8ZP_SCRATCH_W2
                     lda  #>$secondName
                     sta  P8ZP_SCRATCH_W2+1
-                    jsr  c64flt.swap_floats
+                    jsr  floats.swap_floats
                 """)
                 return
             }
         }
 
-        // other types of swap() calls should have been replaced by a different statement sequence involving a temp variable
+        // optimized simple case: swap two memory locations
-        throw AssemblyError("no asm generation for swap funccall $fcall")
+        if(first is DirectMemoryRead && second is DirectMemoryRead) {
+            val addr1 = (first.addressExpression as? NumericLiteralValue)?.number?.toHex()
+            val addr2 = (second.addressExpression as? NumericLiteralValue)?.number?.toHex()
+            val name1 = if(first.addressExpression is IdentifierReference) asmgen.asmVariableName(first.addressExpression as IdentifierReference) else null
+            val name2 = if(second.addressExpression is IdentifierReference) asmgen.asmVariableName(second.addressExpression as IdentifierReference) else null
+
+            when {
+                addr1!=null && addr2!=null -> {
+                    asmgen.out("  ldy  $addr1 |  lda  $addr2 |  sta  $addr1 |  sty  $addr2")
+                    return
+                }
+                addr1!=null && name2!=null -> {
+                    asmgen.out("  ldy  $addr1 |  lda  $name2 |  sta  $addr1 |  sty  $name2")
+                    return
+                }
+                name1!=null && addr2 != null -> {
+                    asmgen.out("  ldy  $name1 |  lda  $addr2 |  sta  $name1 |  sty  $addr2")
+                    return
+                }
+                name1!=null && name2!=null -> {
+                    asmgen.out("  ldy  $name1 |  lda  $name2 |  sta  $name1 |  sty  $name2")
+                    return
+                }
+            }
+        }
+
+        if(first is ArrayIndexedExpression && second is ArrayIndexedExpression) {
+            val indexValue1 = first.arrayspec.index as? NumericLiteralValue
+            val indexName1 = first.arrayspec.index as? IdentifierReference
+            val indexValue2 = second.arrayspec.index as? NumericLiteralValue
+            val indexName2 = second.arrayspec.index as? IdentifierReference
+            val arrayVarName1 = asmgen.asmVariableName(first.identifier)
+            val arrayVarName2 = asmgen.asmVariableName(second.identifier)
+            val elementDt = first.inferType(program).typeOrElse(DataType.STRUCT)
+
+            if(indexValue1!=null && indexValue2!=null) {
+                swapArrayValues(elementDt, arrayVarName1, indexValue1, arrayVarName2, indexValue2)
+                return
+            } else if(indexName1!=null && indexName2!=null) {
+                swapArrayValues(elementDt, arrayVarName1, indexName1, arrayVarName2, indexName2)
+                return
+            }
+        }
+
+        // all other types of swap() calls are done via the evaluation stack
+        fun targetFromExpr(expr: Expression, datatype: DataType): AsmAssignTarget {
+            return when (expr) {
+                is IdentifierReference -> AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, datatype, expr.definingSubroutine(), variableAsmName = asmgen.asmVariableName(expr))
+                is ArrayIndexedExpression -> AsmAssignTarget(TargetStorageKind.ARRAY, program, asmgen, datatype, expr.definingSubroutine(), array = expr)
+                is DirectMemoryRead -> AsmAssignTarget(TargetStorageKind.MEMORY, program, asmgen, datatype, expr.definingSubroutine(), memory = DirectMemoryWrite(expr.addressExpression, expr.position))
+                else -> throw AssemblyError("invalid expression object $expr")
+            }
+        }
+
+        asmgen.translateExpression(first)
+        asmgen.translateExpression(second)
+        val datatype = first.inferType(program).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)
+    }
+
+    private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexValue1: NumericLiteralValue, arrayVarName2: String, indexValue2: NumericLiteralValue) {
+        val index1 = indexValue1.number.toInt() * elementDt.memorySize()
+        val index2 = indexValue2.number.toInt() * elementDt.memorySize()
+        when(elementDt) {
+            DataType.UBYTE, DataType.BYTE -> {
+                asmgen.out("""
+                    lda  $arrayVarName1+$index1
+                    ldy  $arrayVarName2+$index2
+                    sta  $arrayVarName2+$index2
+                    sty  $arrayVarName1+$index1
+                """)
+            }
+            DataType.UWORD, DataType.WORD -> {
+                asmgen.out("""
+                    lda  $arrayVarName1+$index1
+                    ldy  $arrayVarName2+$index2
+                    sta  $arrayVarName2+$index2
+                    sty  $arrayVarName1+$index1
+                    lda  $arrayVarName1+$index1+1
+                    ldy  $arrayVarName2+$index2+1
+                    sta  $arrayVarName2+$index2+1
+                    sty  $arrayVarName1+$index1+1
+                """)
+            }
+            DataType.FLOAT -> {
+                asmgen.out("""
+                    lda  #<(${arrayVarName1}+$index1)
+                    sta  P8ZP_SCRATCH_W1
+                    lda  #>(${arrayVarName1}+$index1)
+                    sta  P8ZP_SCRATCH_W1+1
+                    lda  #<(${arrayVarName2}+$index2)
+                    sta  P8ZP_SCRATCH_W2
+                    lda  #>(${arrayVarName2}+$index2)
+                    sta  P8ZP_SCRATCH_W2+1
+                    jsr  floats.swap_floats
+                """)
+            }
+            else -> throw AssemblyError("invalid aray elt type")
+        }
+    }
+
+    private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexName1: IdentifierReference, arrayVarName2: String, indexName2: IdentifierReference) {
+        val idxAsmName1 = asmgen.asmVariableName(indexName1)
+        val idxAsmName2 = asmgen.asmVariableName(indexName2)
+        when(elementDt) {
+            DataType.UBYTE, DataType.BYTE -> {
+                asmgen.out("""
+                    stx  P8ZP_SCRATCH_REG
+                    ldx  $idxAsmName1
+                    ldy  $idxAsmName2
+                    lda  $arrayVarName1,x
+                    pha
+                    lda  $arrayVarName2,y
+                    sta  $arrayVarName1,x
+                    pla
+                    sta  $arrayVarName2,y
+                    ldx  P8ZP_SCRATCH_REG
+                """)
+            }
+            DataType.UWORD, DataType.WORD -> {
+                asmgen.out("""
+                    stx  P8ZP_SCRATCH_REG
+                    lda  $idxAsmName1
+                    asl  a
+                    tax
+                    lda  $idxAsmName2
+                    asl  a
+                    tay
+                    lda  $arrayVarName1,x
+                    pha
+                    lda  $arrayVarName2,y
+                    sta  $arrayVarName1,x
+                    pla
+                    sta  $arrayVarName2,y
+                    lda  $arrayVarName1+1,x
+                    pha
+                    lda  $arrayVarName2+1,y
+                    sta  $arrayVarName1+1,x
+                    pla
+                    sta  $arrayVarName2+1,y                    
+                    ldx  P8ZP_SCRATCH_REG
+                """)
+            }
+            DataType.FLOAT -> {
+                asmgen.out("""
+                    lda  #>$arrayVarName1
+                    sta  P8ZP_SCRATCH_W1+1
+                    lda  $idxAsmName1
+                    asl  a
+                    asl  a
+                    clc
+                    adc  $idxAsmName1
+                    adc  #<$arrayVarName1
+                    sta  P8ZP_SCRATCH_W1
+                    bcc  +
+                    inc  P8ZP_SCRATCH_W1+1
++                   lda  #>$arrayVarName2
+                    sta  P8ZP_SCRATCH_W2+1
+                    lda  $idxAsmName2
+                    asl  a
+                    asl  a
+                    clc
+                    adc  $idxAsmName2
+                    adc  #<$arrayVarName2
+                    sta  P8ZP_SCRATCH_W2
+                    bcc  +
+                    inc  P8ZP_SCRATCH_W2+1
++                   jsr  floats.swap_floats                                   
+                """)
+            }
+            else -> throw AssemblyError("invalid aray elt type")
+        }
     }
 
     private fun funcAbs(fcall: IFunctionCall, func: FSignature) {
@@ -442,7 +642,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
         when (dt.typeOrElse(DataType.STRUCT)) {
             in ByteDatatypes -> asmgen.out("  jsr  prog8_lib.abs_b")
             in WordDatatypes -> asmgen.out("  jsr  prog8_lib.abs_w")
-            DataType.FLOAT -> asmgen.out("  jsr  c64flt.abs_f")
+            DataType.FLOAT -> asmgen.out("  jsr  floats.abs_f")
             else -> throw AssemblyError("weird type")
         }
     }

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

@@ -610,8 +610,8 @@ $endLabel""")
     }
 
     private fun assignLoopvar(stmt: ForLoop, range: RangeExpr) {
-        val target = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, stmt.loopVarDt(program).typeOrElse(DataType.STRUCT), variable=stmt.loopVar)
+        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).adjustDataTypeToTarget(target)
+        val src = AsmAssignSource.fromAstSource(range.from, program, asmgen).adjustSignedUnsigned(target)
         val assign = AsmAssignment(src, target, false, range.position)
         asmgen.translateNormalAssignment(assign)
     }

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

@@ -1,9 +1,11 @@
 package prog8.compiler.target.c64.codegen
 
 import prog8.ast.IFunctionCall
+import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
+import prog8.ast.statements.RegisterOrStatusflag
 import prog8.ast.statements.Subroutine
 import prog8.ast.statements.SubroutineParameter
 import prog8.compiler.AssemblyError
@@ -12,13 +14,13 @@ import prog8.compiler.target.c64.codegen.assignment.*
 
 internal class FunctionCallAsmGen(private val program: Program, private val asmgen: AsmGen) {
 
-    internal fun translateFunctionCall(stmt: IFunctionCall) {
+    internal fun translateFunctionCall(stmt: IFunctionCall, preserveStatusRegisterAfterCall: Boolean) {
         // 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()
         if(saveX)
-            asmgen.saveRegister(CpuRegister.X)  // we only save X for now (required! is the eval stack pointer), screw A and Y...
+            asmgen.saveRegister(CpuRegister.X, preserveStatusRegisterAfterCall, (stmt as Node).definingSubroutine())
 
         val subName = asmgen.asmSymbolName(stmt.target)
         if(stmt.args.isNotEmpty()) {
@@ -56,40 +58,92 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         }
         asmgen.out("  jsr  $subName")
 
+        if(preserveStatusRegisterAfterCall) {
+            asmgen.out("  php\t; save status flags from call")
+            // note: the containing statement (such as the FunctionCallStatement or the Assignment or the Expression)
+            //       must take care of popping this value again at the end!
+        }
+
         if(saveX)
-            asmgen.restoreRegister(CpuRegister.X)
+            asmgen.restoreRegister(CpuRegister.X, preserveStatusRegisterAfterCall)
     }
 
     private fun registerArgsViaStackEvaluation(stmt: IFunctionCall, sub: Subroutine) {
         // this is called when one or more of the arguments are 'complex' and
         // cannot be assigned to a register easily or risk clobbering other registers.
+
+        if(sub.parameters.isEmpty())
+            return
+
+        // 1. load all arguments reversed onto the stack: first arg goes last (is on top).
         for (arg in stmt.args.reversed())
             asmgen.translateExpression(arg)
-        for (regparam in sub.asmParameterRegisters) {
+
+        var argForCarry: IndexedValue<Pair<Expression, RegisterOrStatusflag>>? = null
+        var argForXregister: IndexedValue<Pair<Expression, RegisterOrStatusflag>>? = null
+        var argForAregister: IndexedValue<Pair<Expression, RegisterOrStatusflag>>? = null
+
+        asmgen.out("  inx")     // align estack pointer
+
+        for(argi in stmt.args.zip(sub.asmParameterRegisters).withIndex()) {
             when {
-                regparam.statusflag==Statusflag.Pc -> {
+                argi.value.second.stack -> TODO("asmsub @stack parameter")
-                    asmgen.out("""
+                argi.value.second.statusflag == Statusflag.Pc -> {
-                        inx
+                    require(argForCarry == null)
-                        pha
+                    argForCarry = argi
-                        lda  P8ESTACK_LO,x
-                        beq  +
-                        sec  
-                        bcs  ++
-+                       clc
-+                       pla""")
                 }
-                regparam.statusflag!=null -> {
+                argi.value.second.statusflag != null -> throw AssemblyError("can only use Carry as status flag parameter")
-                    throw AssemblyError("can only use Carry as status flag parameter")
+                argi.value.second.registerOrPair in setOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) -> {
+                    require(argForXregister==null)
+                    argForXregister = argi
                 }
-                regparam.registerOrPair!=null -> {
+                argi.value.second.registerOrPair in setOf(RegisterOrPair.A, RegisterOrPair.AY) -> {
-                    val tgt = AsmAssignTarget.fromRegisters(regparam.registerOrPair, program, asmgen)
+                    require(argForAregister == null)
-                    val source = AsmAssignSource(SourceStorageKind.STACK, program, tgt.datatype)
+                    argForAregister = argi
-                    val asgn = AsmAssignment(source, tgt, false, Position.DUMMY)
-                    asmgen.translateNormalAssignment(asgn)
                 }
-                else -> {}
+                argi.value.second.registerOrPair == RegisterOrPair.Y -> {
+                    asmgen.out("  ldy  P8ESTACK_LO+${argi.index},x")
+                }
+                else -> throw AssemblyError("weird argument")
             }
         }
+
+        if(argForCarry!=null) {
+            asmgen.out("""
+                lda  P8ESTACK_LO+${argForCarry.index},x
+                beq  +
+                sec
+                bcs  ++
++               clc
++               php""")             // push the status flags
+        }
+
+        if(argForAregister!=null) {
+            when(argForAregister.value.second.registerOrPair) {
+                RegisterOrPair.A -> asmgen.out("  lda  P8ESTACK_LO+${argForAregister.index},x")
+                RegisterOrPair.AY -> asmgen.out("  lda  P8ESTACK_LO+${argForAregister.index},x |  ldy  P8ESTACK_HI+${argForAregister.index},x")
+                else -> throw AssemblyError("weird arg")
+            }
+        }
+
+        if(argForXregister!=null) {
+
+            if(argForAregister!=null)
+                asmgen.out("  pha")
+            when(argForXregister.value.second.registerOrPair) {
+                RegisterOrPair.X -> asmgen.out("  lda  P8ESTACK_LO+${argForXregister.index},x |  tax")
+                RegisterOrPair.AX -> asmgen.out("  ldy  P8ESTACK_LO+${argForXregister.index},x |  lda  P8ESTACK_HI+${argForXregister.index},x |  tax |  tya")
+                RegisterOrPair.XY -> asmgen.out("  ldy  P8ESTACK_HI+${argForXregister.index},x |  lda  P8ESTACK_LO+${argForXregister.index},x |  tax")
+                else -> throw AssemblyError("weird arg")
+            }
+            if(argForAregister!=null)
+                asmgen.out("  pla")
+        } else {
+            repeat(sub.parameters.size - 1) { asmgen.out("  inx") }       // unwind stack
+        }
+
+        if(argForCarry!=null)
+            asmgen.out("  plp")       // set the carry flag back to correct value
     }
 
     private fun argumentViaVariable(sub: Subroutine, parameter: IndexedValue<SubroutineParameter>, value: Expression) {
@@ -101,11 +155,9 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         if(!isArgumentTypeCompatible(valueDt, parameter.value.type))
             throw AssemblyError("argument type incompatible")
 
-        val scopedParamVar = (sub.scopedname+"."+parameter.value.name).split(".")
+        val varName = asmgen.asmVariableName(sub.scopedname+"."+parameter.value.name)
-        val identifier = IdentifierReference(scopedParamVar, sub.position)
+        val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, parameter.value.type, sub, variableAsmName = varName)
-        identifier.linkParents(value.parent)
+        val source = AsmAssignSource.fromAstSource(value, program, asmgen).adjustSignedUnsigned(tgt)
-        val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, parameter.value.type, variable = identifier)
-        val source = AsmAssignSource.fromAstSource(value, program).adjustDataTypeToTarget(tgt)
         val asgn = AsmAssignment(source, tgt, false, Position.DUMMY)
         asmgen.translateNormalAssignment(asgn)
     }
@@ -123,13 +175,22 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         val statusflag = paramRegister.statusflag
         val register = paramRegister.registerOrPair
         val stack = paramRegister.stack
+        val requiredDt = parameter.value.type
+        if(requiredDt!=valueDt) {
+            if(valueDt largerThan requiredDt)
+                throw AssemblyError("can only convert byte values to word param types")
+        }
         when {
             stack -> {
                 // push arg onto the stack
                 // note: argument order is reversed (first argument will be deepest on the stack)
                 asmgen.translateExpression(value)
+                if(requiredDt!=valueDt)
+                    asmgen.signExtendStackLsb(valueDt)
             }
             statusflag!=null -> {
+                if(requiredDt!=valueDt)
+                    throw AssemblyError("for statusflag, byte value is required")
                 if (statusflag == Statusflag.Pc) {
                     // this param needs to be set last, right before the jsr
                     // for now, this is already enforced on the subroutine definition by the Ast Checker
@@ -169,15 +230,30 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
             }
             else -> {
                 // via register or register pair
-                val target = AsmAssignTarget.fromRegisters(register!!, program, asmgen)
+                val target = AsmAssignTarget.fromRegisters(register!!, sub, program, asmgen)
-                val src = if(valueDt in PassByReferenceDatatypes) {
+                if(requiredDt largerThan valueDt) {
-                    val addr = AddressOf(value as IdentifierReference, Position.DUMMY)
+                    // we need to sign extend the source, do this via temporary word variable
-                    AsmAssignSource.fromAstSource(addr, program).adjustDataTypeToTarget(target)
+                    val scratchVar = asmgen.asmVariableName("P8ZP_SCRATCH_W1")
-                } else {
+                    val scratchTarget = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UBYTE, sub, scratchVar)
-                    AsmAssignSource.fromAstSource(value, program).adjustDataTypeToTarget(target)
+                    val source = AsmAssignSource.fromAstSource(value, program, asmgen)
+                    asmgen.translateNormalAssignment(AsmAssignment(source, scratchTarget, false, value.position))
+                    asmgen.signExtendVariableLsb(scratchVar, valueDt)
+                    val src = AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, DataType.UWORD, scratchVar)
+                    asmgen.translateNormalAssignment(AsmAssignment(src, target, false, Position.DUMMY))
+                }
+                else {
+                    val src = if(valueDt in PassByReferenceDatatypes) {
+                        if(value is IdentifierReference) {
+                            val addr = AddressOf(value, Position.DUMMY)
+                            AsmAssignSource.fromAstSource(addr, program, asmgen).adjustSignedUnsigned(target)
+                        } else {
+                            AsmAssignSource.fromAstSource(value, program, asmgen).adjustSignedUnsigned(target)
+                        }
+                    } else {
+                        AsmAssignSource.fromAstSource(value, program, asmgen).adjustSignedUnsigned(target)
+                    }
+                    asmgen.translateNormalAssignment(AsmAssignment(src, target, false, Position.DUMMY))
                 }
-
-                asmgen.translateNormalAssignment(AsmAssignment(src, target, false, Position.DUMMY))
             }
         }
     }

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

@@ -15,6 +15,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
         val targetIdent = stmt.target.identifier
         val targetMemory = stmt.target.memoryAddress
         val targetArrayIdx = stmt.target.arrayindexed
+        val scope = stmt.definingSubroutine()
         when {
             targetIdent!=null -> {
                 val what = asmgen.asmVariableName(targetIdent)
@@ -33,7 +34,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                     }
                     DataType.FLOAT -> {
                         asmgen.out("  lda  #<$what |  ldy  #>$what")
-                        asmgen.out(if(incr) "  jsr  c64flt.inc_var_f" else "  jsr  c64flt.dec_var_f")
+                        asmgen.out(if(incr) "  jsr  floats.inc_var_f" else "  jsr  floats.dec_var_f")
                     }
                     else -> throw AssemblyError("need numeric type")
                 }
@@ -90,14 +91,14 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                             }
                             DataType.FLOAT -> {
                                 asmgen.out("  lda  #<$asmArrayvarname+$indexValue |  ldy  #>$asmArrayvarname+$indexValue")
-                                asmgen.out(if(incr) "  jsr  c64flt.inc_var_f" else "  jsr  c64flt.dec_var_f")
+                                asmgen.out(if(incr) "  jsr  floats.inc_var_f" else "  jsr  floats.dec_var_f")
                             }
                             else -> throw AssemblyError("need numeric type")
                         }
                     }
                     else -> {
                         asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, elementDt, CpuRegister.A)
-                        asmgen.saveRegister(CpuRegister.X)
+                        asmgen.saveRegister(CpuRegister.X, false, scope)
                         asmgen.out("  tax")
                         when(elementDt) {
                             in ByteDatatypes -> {
@@ -121,11 +122,11 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                         adc  #<$asmArrayvarname
                         bcc  +
                         iny
-+                       jsr  c64flt.inc_var_f""")
++                       jsr  floats.inc_var_f""")
                             }
                             else -> throw AssemblyError("weird array elt dt")
                         }
-                        asmgen.restoreRegister(CpuRegister.X)
+                        asmgen.restoreRegister(CpuRegister.X, false)
                     }
                 }
             }

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

@@ -1,11 +1,13 @@
 package prog8.compiler.target.c64.codegen.assignment
 
+import prog8.ast.INameScope
 import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.AssignTarget
 import prog8.ast.statements.Assignment
 import prog8.ast.statements.DirectMemoryWrite
+import prog8.ast.statements.Subroutine
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.c64.codegen.AsmGen
 
@@ -29,10 +31,11 @@ internal enum class SourceStorageKind {
 }
 
 internal class AsmAssignTarget(val kind: TargetStorageKind,
-                               program: Program,
+                               private val program: Program,
-                               asmgen: AsmGen,
+                               private val asmgen: AsmGen,
                                val datatype: DataType,
-                               val variable: IdentifierReference? = null,
+                               val scope: Subroutine?,
+                               private val variableAsmName: String? = null,
                                val array: ArrayIndexedExpression? = null,
                                val memory: DirectMemoryWrite? = null,
                                val register: RegisterOrPair? = null,
@@ -41,19 +44,15 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
 {
     val constMemoryAddress by lazy { memory?.addressExpression?.constValue(program)?.number?.toInt() ?: 0}
     val constArrayIndexValue by lazy { array?.arrayspec?.constIndex() }
-    val vardecl by lazy { variable?.targetVarDecl(program.namespace)!! }
+    val asmVarname: String
-    val asmVarname by lazy {
+        get() = if(array==null)
-        if(variable!=null)
+            variableAsmName!!
-            asmgen.asmVariableName(variable)
         else
-            asmgen.asmVariableName(array!!.identifier)
+            asmgen.asmVariableName(array.identifier)
-    }
 
     lateinit var origAssign: AsmAssignment
 
     init {
-        if(variable!=null && vardecl.type == VarDeclType.CONST)
-            throw AssemblyError("can't assign to a constant")
         if(register!=null && datatype !in IntegerDatatypes)
             throw AssemblyError("register must be integer type")
     }
@@ -62,29 +61,30 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
         fun fromAstAssignment(assign: Assignment, program: Program, asmgen: AsmGen): AsmAssignTarget = with(assign.target) {
             val dt = inferType(program, assign).typeOrElse(DataType.STRUCT)
             when {
-                identifier != null -> AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, dt, variable=identifier, origAstTarget =  this)
+                identifier != null -> AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, dt, assign.definingSubroutine(), variableAsmName = asmgen.asmVariableName(identifier!!), origAstTarget =  this)
-                arrayindexed != null -> AsmAssignTarget(TargetStorageKind.ARRAY, program, asmgen, dt, array = arrayindexed, origAstTarget =  this)
+                arrayindexed != null -> AsmAssignTarget(TargetStorageKind.ARRAY, program, asmgen, dt, assign.definingSubroutine(), array = arrayindexed, origAstTarget =  this)
-                memoryAddress != null -> AsmAssignTarget(TargetStorageKind.MEMORY, program, asmgen, dt, memory =  memoryAddress, origAstTarget =  this)
+                memoryAddress != null -> AsmAssignTarget(TargetStorageKind.MEMORY, program, asmgen, dt, assign.definingSubroutine(), memory =  memoryAddress, origAstTarget =  this)
                 else -> throw AssemblyError("weird target")
             }
         }
 
-        fun fromRegisters(registers: RegisterOrPair, program: Program, asmgen: AsmGen): AsmAssignTarget =
+        fun fromRegisters(registers: RegisterOrPair, scope: Subroutine?, program: Program, asmgen: AsmGen): AsmAssignTarget =
                 when(registers) {
                     RegisterOrPair.A,
                     RegisterOrPair.X,
-                    RegisterOrPair.Y -> AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.UBYTE, register = registers)
+                    RegisterOrPair.Y -> AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.UBYTE, scope, register = registers)
                     RegisterOrPair.AX,
                     RegisterOrPair.AY,
-                    RegisterOrPair.XY -> AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.UWORD, register = registers)
+                    RegisterOrPair.XY -> AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.UWORD, scope, register = registers)
                 }
     }
 }
 
 internal class AsmAssignSource(val kind: SourceStorageKind,
                                private val program: Program,
+                               private val asmgen: AsmGen,
                                val datatype: DataType,
-                               val variable: IdentifierReference? = null,
+                               private val variableAsmName: String? = null,
                                val array: ArrayIndexedExpression? = null,
                                val memory: DirectMemoryRead? = null,
                                val register: CpuRegister? = null,
@@ -94,51 +94,70 @@ internal class AsmAssignSource(val kind: SourceStorageKind,
 {
     val constMemoryAddress by lazy { memory?.addressExpression?.constValue(program)?.number?.toInt() ?: 0}
     val constArrayIndexValue by lazy { array?.arrayspec?.constIndex() }
-    val vardecl by lazy { variable?.targetVarDecl(program.namespace)!! }
+
+    val asmVarname: String
+        get() = if(array==null)
+            variableAsmName!!
+        else
+            asmgen.asmVariableName(array.identifier)
 
     companion object {
-        fun fromAstSource(value: Expression, program: Program): AsmAssignSource {
+        fun fromAstSource(value: Expression, program: Program, asmgen: AsmGen): AsmAssignSource {
             val cv = value.constValue(program)
             if(cv!=null)
-                return AsmAssignSource(SourceStorageKind.LITERALNUMBER, program, cv.type, number = cv)
+                return AsmAssignSource(SourceStorageKind.LITERALNUMBER, program, asmgen, cv.type, number = cv)
 
             return when(value) {
-                is NumericLiteralValue -> AsmAssignSource(SourceStorageKind.LITERALNUMBER, program, value.type, number = cv)
+                is NumericLiteralValue -> AsmAssignSource(SourceStorageKind.LITERALNUMBER, program, asmgen, value.type, number = cv)
                 is StringLiteralValue -> throw AssemblyError("string literal value should not occur anymore for asm generation")
                 is ArrayLiteralValue -> throw AssemblyError("array literal value should not occur anymore for asm generation")
                 is IdentifierReference -> {
                     val dt = value.inferType(program).typeOrElse(DataType.STRUCT)
-                    AsmAssignSource(SourceStorageKind.VARIABLE, program, dt, variable = value)
+                    AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, dt, variableAsmName = asmgen.asmVariableName(value))
                 }
                 is DirectMemoryRead -> {
-                    AsmAssignSource(SourceStorageKind.MEMORY, program, DataType.UBYTE, memory = value)
+                    AsmAssignSource(SourceStorageKind.MEMORY, program, asmgen, DataType.UBYTE, memory = value)
                 }
                 is ArrayIndexedExpression -> {
                     val dt = value.inferType(program).typeOrElse(DataType.STRUCT)
-                    AsmAssignSource(SourceStorageKind.ARRAY, program, dt, array = value)
+                    AsmAssignSource(SourceStorageKind.ARRAY, program, asmgen, dt, array = value)
                 }
                 else -> {
+                    if(value is FunctionCall) {
+                        // functioncall.
+                        val asmSub = value.target.targetStatement(program.namespace)
+                        if(asmSub is Subroutine && asmSub.isAsmSubroutine) {
+                            when (asmSub.asmReturnvaluesRegisters.count { rr -> rr.registerOrPair!=null }) {
+                                0 -> throw AssemblyError("can't translate zero return values in assignment")
+                                1 -> {
+                                    // assignment generation itself must make sure the status register is correct after the subroutine call, if status register is involved!
+                                    val reg = asmSub.asmReturnvaluesRegisters.single { rr->rr.registerOrPair!=null }.registerOrPair!!
+                                    val dt = when(reg) {
+                                        RegisterOrPair.A,
+                                        RegisterOrPair.X,
+                                        RegisterOrPair.Y -> DataType.UBYTE
+                                        RegisterOrPair.AX,
+                                        RegisterOrPair.AY,
+                                        RegisterOrPair.XY -> DataType.UWORD
+                                    }
+                                    return AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, dt, expression = value)
+                                }
+                                else -> throw AssemblyError("can't translate multiple return values in assignment")
+                            }
+                        }
+                    }
+
                     val dt = value.inferType(program).typeOrElse(DataType.STRUCT)
-                    AsmAssignSource(SourceStorageKind.EXPRESSION, program, dt, expression = value)
+                    return AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, dt, expression = value)
                 }
             }
         }
     }
 
-    fun getAstValue(): Expression = when(kind) {
-        SourceStorageKind.LITERALNUMBER -> number!!
-        SourceStorageKind.VARIABLE -> variable!!
-        SourceStorageKind.ARRAY -> array!!
-        SourceStorageKind.MEMORY -> memory!!
-        SourceStorageKind.EXPRESSION -> expression!!
-        SourceStorageKind.REGISTER -> throw AssemblyError("cannot get a register source as Ast node")
-        SourceStorageKind.STACK -> throw AssemblyError("cannot get a stack source as Ast node")
-    }
-
     fun withAdjustedDt(newType: DataType) =
-            AsmAssignSource(kind, program, newType, variable, array, memory, register, number, expression)
+            AsmAssignSource(kind, program, asmgen, newType, variableAsmName, array, memory, register, number, expression)
 
-    fun adjustDataTypeToTarget(target: AsmAssignTarget): AsmAssignSource {
+    fun adjustSignedUnsigned(target: AsmAssignTarget): AsmAssignSource {
         // allow some signed/unsigned relaxations
         if(target.datatype!=datatype) {
             if(target.datatype in ByteDatatypes && datatype in ByteDatatypes) {
@@ -159,6 +178,10 @@ internal class AsmAssignment(val source: AsmAssignSource,
                              val position: Position) {
 
     init {
-        require(source.datatype==target.datatype) {"source and target datatype must be identical"}
+        if(target.register !in setOf(RegisterOrPair.XY, RegisterOrPair.AX, RegisterOrPair.AY))
+            require(source.datatype != DataType.STRUCT) { "must not be placeholder datatype" }
+            require(source.datatype.memorySize() <= target.datatype.memorySize()) {
+                "source storage size must be less or equal to target datatype storage size"
+            }
     }
 }

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

@@ -8,16 +8,17 @@ import prog8.compiler.AssemblyError
 import prog8.compiler.target.CompilationTarget
 import prog8.compiler.target.CpuType
 import prog8.compiler.target.c64.codegen.AsmGen
+import prog8.compiler.target.c64.codegen.ExpressionsAsmGen
 import prog8.compiler.toHex
 
 
-internal class AssignmentAsmGen(private val program: Program, private val asmgen: AsmGen) {
+internal class AssignmentAsmGen(private val program: Program, private val asmgen: AsmGen, private val exprAsmgen: ExpressionsAsmGen) {
 
-    private val augmentableAsmGen = AugmentableAssignmentAsmGen(program, this, asmgen)
+    private val augmentableAsmGen = AugmentableAssignmentAsmGen(program, this, exprAsmgen, asmgen)
 
     fun translate(assignment: Assignment) {
         val target = AsmAssignTarget.fromAstAssignment(assignment, program, asmgen)
-        val source = AsmAssignSource.fromAstSource(assignment.value, program).adjustDataTypeToTarget(target)
+        val source = AsmAssignSource.fromAstSource(assignment.value, program, asmgen).adjustSignedUnsigned(target)
 
         val assign = AsmAssignment(source, target, assignment.isAugmentable, assignment.position)
         target.origAssign = assign
@@ -33,7 +34,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             SourceStorageKind.LITERALNUMBER -> {
                 // simple case: assign a constant number
                 val num = assign.source.number!!.number
-                when (assign.source.datatype) {
+                when (assign.target.datatype) {
                     DataType.UBYTE, DataType.BYTE -> assignConstantByte(assign.target, num.toShort())
                     DataType.UWORD, DataType.WORD -> assignConstantWord(assign.target, num.toInt())
                     DataType.FLOAT -> assignConstantFloat(assign.target, num.toDouble())
@@ -42,12 +43,16 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             }
             SourceStorageKind.VARIABLE -> {
                 // simple case: assign from another variable
-                val variable = assign.source.variable!!
+                val variable = assign.source.asmVarname!!
-                when (assign.source.datatype) {
+                when (assign.target.datatype) {
                     DataType.UBYTE, DataType.BYTE -> assignVariableByte(assign.target, variable)
                     DataType.UWORD, DataType.WORD -> assignVariableWord(assign.target, variable)
                     DataType.FLOAT -> assignVariableFloat(assign.target, variable)
-                    in PassByReferenceDatatypes -> assignAddressOf(assign.target, variable)
+                    DataType.STR -> assignVariableString(assign.target, variable)
+                    in PassByReferenceDatatypes -> {
+                        // TODO what about when the name is a struct? name.firstStructVarName(program.namespace)
+                        assignAddressOf(assign.target, variable)
+                    }
                     else -> throw AssemblyError("unsupported assignment target type ${assign.target.datatype}")
                 }
             }
@@ -65,7 +70,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         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  c64flt.push_float")
+                            asmgen.out("  lda  #<$arrayVarName+$indexValue |  ldy  #>$arrayVarName+$indexValue |  jsr  floats.push_float")
                         else ->
                             throw AssemblyError("weird array type")
                     }
@@ -87,7 +92,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                                 adc  #<$arrayVarName
                                 bcc  +
                                 iny
-+                               jsr  c64flt.push_float""")
++                               jsr  floats.push_float""")
                         }
                         else ->
                             throw AssemblyError("weird array elt type")
@@ -115,39 +120,45 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             SourceStorageKind.EXPRESSION -> {
                 val value = assign.source.expression!!
                 when(value) {
-                    is AddressOf -> assignAddressOf(assign.target, value.identifier)
+                    is AddressOf -> {
+                        val sourceName = value.identifier.firstStructVarName(program.namespace) ?: asmgen.asmVariableName(value.identifier)
+                        assignAddressOf(assign.target, sourceName)
+                    }
                     is NumericLiteralValue -> throw AssemblyError("source kind should have been literalnumber")
                     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 -> {
+                    is TypecastExpression -> assignTypeCastedValue(assign.target, value.type, value.expression, assign)
-//                        if(assign.target.kind == TargetStorageKind.STACK) {
+                    is FunctionCall -> {
-//                            asmgen.translateExpression(value)
+                        if(value.target.targetSubroutine(program.namespace)?.isAsmSubroutine==true) {
-//                            assignStackValue(assign.target)
+                            // handle asmsub functioncalls specifically, without shoving stuff on the estack
-//                        } else {
+                            val sub = value.target.targetSubroutine(program.namespace)!!
-//                            println("!!!!TYPECAST to ${assign.target.kind} $value")
+                            val preserveStatusRegisterAfterCall = sub.asmReturnvaluesRegisters.any { it.statusflag != null }
-//                            // TODO maybe we can do the typecast on the target directly instead of on the stack?
+                            asmgen.translateFunctionCall(value, preserveStatusRegisterAfterCall)
-//                            asmgen.translateExpression(value)
+                            when((sub.asmReturnvaluesRegisters.single { it.registerOrPair!=null }).registerOrPair) {
-//                            assignStackValue(assign.target)
+                                RegisterOrPair.A -> assignRegisterByte(assign.target, CpuRegister.A)
-//                        }
+                                RegisterOrPair.X -> assignRegisterByte(assign.target, CpuRegister.X)
-//                    }
+                                RegisterOrPair.Y -> assignRegisterByte(assign.target, CpuRegister.Y)
-//                    is FunctionCall -> {
+                                RegisterOrPair.AX -> assignRegisterpairWord(assign.target, RegisterOrPair.AX)
-//                        if (assign.target.kind == TargetStorageKind.STACK) {
+                                RegisterOrPair.AY -> assignRegisterpairWord(assign.target, RegisterOrPair.AY)
-//                            asmgen.translateExpression(value)
+                                RegisterOrPair.XY -> assignRegisterpairWord(assign.target, RegisterOrPair.XY)
-//                            assignStackValue(assign.target)
+                                else -> throw AssemblyError("should be just one register byte result value")
-//                        } else {
+                            }
-//                            val functionName = value.target.nameInSource.last()
+                            if(preserveStatusRegisterAfterCall)
-//                            val builtinFunc = BuiltinFunctions[functionName]
+                                asmgen.out("  plp\t; restore status flags from call")
-//                            if (builtinFunc != null) {
+                        } else {
-//                                println("!!!!BUILTIN-FUNCCALL target=${assign.target.kind} $value") // TODO optimize certain functions?
+                            // regular subroutine, return values are (for now) always done via the stack...  TODO optimize this
-//                            }
+                            asmgen.translateExpression(value)
-//                            asmgen.translateExpression(value)
+                            if(assign.target.datatype in WordDatatypes && assign.source.datatype in ByteDatatypes)
-//                            assignStackValue(assign.target)
+                                asmgen.signExtendStackLsb(assign.source.datatype)
-//                        }
+                            assignStackValue(assign.target)
-//                    }
+                        }
+                    }
                     else -> {
                         // everything else just evaluate via the stack.
                         asmgen.translateExpression(value)
+                        if(assign.target.datatype in WordDatatypes && assign.source.datatype in ByteDatatypes)
+                            asmgen.signExtendStackLsb(assign.source.datatype)
                         assignStackValue(assign.target)
                     }
                 }
@@ -161,6 +172,56 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
+    private fun assignTypeCastedValue(target: AsmAssignTarget, targetDt: DataType, value: Expression, origAssign: AsmAssignment) {
+        val valueDt = value.inferType(program).typeOrElse(DataType.STRUCT)
+        when(value) {
+            is IdentifierReference -> {
+                if(targetDt in WordDatatypes) {
+                    if(valueDt==DataType.UBYTE) {
+                        assignVariableUByteIntoWord(target, value)
+                        return
+                    }
+                    if(valueDt==DataType.BYTE) {
+                        assignVariableByteIntoWord(target, value)
+                        return
+                    }
+                }
+            }
+            is DirectMemoryRead -> {
+                if(targetDt in WordDatatypes) {
+                    if (value.addressExpression is NumericLiteralValue) {
+                        val address = (value.addressExpression as NumericLiteralValue).number.toInt()
+                        assignMemoryByteIntoWord(target, address, null)
+                        return
+                    }
+                    else if (value.addressExpression is IdentifierReference) {
+                        assignMemoryByteIntoWord(target, null, value.addressExpression as IdentifierReference)
+                        return
+                    }
+                }
+            }
+            is NumericLiteralValue -> throw AssemblyError("a cast of a literal value should have been const-folded away")
+            else -> {}
+        }
+
+        when(value) {
+            is PrefixExpression -> {}
+            is BinaryExpression -> {}
+            is ArrayIndexedExpression -> {}
+            is TypecastExpression -> {}
+            is RangeExpr -> {}
+            is FunctionCall -> {}
+            else -> {
+                // TODO optimize the others further?
+                println("warning: slow stack evaluation used for typecast: into $targetDt at ${value.position}")
+            }
+        }
+
+        // give up, do it via eval stack
+        asmgen.translateExpression(origAssign.source.expression!!)
+        assignStackValue(target)
+    }
+
     private fun assignStackValue(target: AsmAssignTarget) {
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
@@ -181,9 +242,21 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         asmgen.out("""
                             lda  #<${target.asmVarname}
                             ldy  #>${target.asmVarname}
-                            jsr  c64flt.pop_float
+                            jsr  floats.pop_float
                         """)
                     }
+                    DataType.STR -> {
+                        asmgen.out("""
+                            lda  #<${target.asmVarname}
+                            sta  P8ZP_SCRATCH_W1
+                            lda  #>${target.asmVarname}
+                            sta  P8ZP_SCRATCH_W1+1
+                            inx
+                            lda  P8ESTACK_HI,x
+                            tay
+                            lda  P8ESTACK_LO,x
+                            jsr  prog8_lib.strcpy""")
+                    }
                     else -> throw AssemblyError("weird target variable type ${target.datatype}")
                 }
             }
@@ -213,7 +286,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                                 asmgen.out("""
                                     lda  #<${target.asmVarname}+$scaledIdx
                                     ldy  #>${target.asmVarname}+$scaledIdx
-                                    jsr  c64flt.pop_float
+                                    jsr  floats.pop_float
                                 """)
                             }
                             else -> throw AssemblyError("weird target variable type ${target.datatype}")
@@ -243,7 +316,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                                     adc  #<${target.asmVarname}
                                     bcc  +
                                     iny
-+                                   jsr  c64flt.pop_float""")
++                                   jsr  floats.pop_float""")
                             }
                             else -> throw AssemblyError("weird dt")
                         }
@@ -260,16 +333,18 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     DataType.UBYTE, DataType.BYTE -> {
                         when(target.register!!) {
                             RegisterOrPair.A -> asmgen.out(" inx |  lda  P8ESTACK_LO,x")
-                            RegisterOrPair.X -> throw AssemblyError("can't use X here")
+                            RegisterOrPair.X -> throw AssemblyError("can't load X from stack here - use intermediary var? ${target.origAstTarget?.position}")
                             RegisterOrPair.Y -> asmgen.out(" inx |  ldy  P8ESTACK_LO,x")
-                            else -> throw AssemblyError("can't assign byte to register pair word")
+                            RegisterOrPair.AX -> asmgen.out(" inx |  lda  P8ESTACK_LO,x |  ldx  #0")
+                            RegisterOrPair.AY -> asmgen.out(" inx |  lda  P8ESTACK_LO,x |  ldy  #0")
+                            else -> throw AssemblyError("can't assign byte from stack to register pair XY")
                         }
                     }
                     DataType.UWORD, DataType.WORD, in PassByReferenceDatatypes -> {
                         when(target.register!!) {
-                            RegisterOrPair.AX -> throw AssemblyError("can't use X here")
+                            RegisterOrPair.AX -> throw AssemblyError("can't load X from stack here - use intermediary var? ${target.origAstTarget?.position}")
                             RegisterOrPair.AY-> asmgen.out(" inx |  lda  P8ESTACK_LO,x |  ldy  P8ESTACK_HI,x")
-                            RegisterOrPair.XY-> throw AssemblyError("can't use X here")
+                            RegisterOrPair.XY-> throw AssemblyError("can't load X from stack here - use intermediary var? ${target.origAstTarget?.position}")
                             else -> throw AssemblyError("can't assign word to single byte register")
                         }
                     }
@@ -280,20 +355,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
-    private fun assignAddressOf(target: AsmAssignTarget, name: IdentifierReference) {
+    private fun assignAddressOf(target: AsmAssignTarget, sourceName: String) {
-        val struct = name.memberOfStruct(program.namespace)
-        val sourceName = if (struct != null) {
-            // take the address of the first struct member instead
-            val decl = name.targetVarDecl(program.namespace)!!
-            val firstStructMember = struct.nameOfFirstMember()
-            // find the flattened var that belongs to this first struct member
-            val firstVarName = listOf(decl.name, firstStructMember)
-            val firstVar = name.definingScope().lookup(firstVarName, name) as VarDecl
-            firstVar.name
-        } else {
-            asmgen.fixNameSymbols(name.nameInSource.joinToString("."))
-        }
-
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
                 asmgen.out("""
@@ -318,19 +380,54 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 }
             }
             TargetStorageKind.STACK -> {
-                val srcname = asmgen.asmVariableName(name)
                 asmgen.out("""
-                    lda  #<$srcname
+                    lda  #<$sourceName
                     sta  P8ESTACK_LO,x
-                    lda  #>$srcname
+                    lda  #>$sourceName
                     sta  P8ESTACK_HI,x
                     dex""")
             }
         }
     }
 
-    private fun assignVariableWord(target: AsmAssignTarget, variable: IdentifierReference) {
+    private fun assignVariableString(target: AsmAssignTarget, sourceName: String) {
-        val sourceName = asmgen.asmVariableName(variable)
+        when(target.kind) {
+            TargetStorageKind.VARIABLE -> {
+                when(target.datatype) {
+                    DataType.UWORD -> {
+                        asmgen.out("""
+                            lda #<$sourceName
+                            sta ${target.asmVarname}
+                            lda #>$sourceName
+                            sta ${target.asmVarname}+1
+                        """)
+                    }
+                    DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                        asmgen.out("""
+                            lda  #<${target.asmVarname}
+                            sta  P8ZP_SCRATCH_W1
+                            lda  #>${target.asmVarname}
+                            sta  P8ZP_SCRATCH_W1+1
+                            lda  #<$sourceName
+                            ldy  #>$sourceName
+                            jsr  prog8_lib.strcpy""")
+                    }
+                    else -> throw AssemblyError("assign string to incompatible variable type")
+                }
+            }
+            TargetStorageKind.STACK -> {
+                asmgen.out("""
+                    lda  #<$sourceName
+                    sta  P8ESTACK_LO,x
+                    lda  #>$sourceName+1
+                    sta  P8ESTACK_HI,x
+                    dex""")
+            }
+            else -> throw AssemblyError("string-assign to weird target")
+        }
+    }
+
+    private fun assignVariableWord(target: AsmAssignTarget, sourceName: String) {
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
                 asmgen.out("""
@@ -368,7 +465,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                                     sty  P8ZP_SCRATCH_W1+1
                                     lda  #<${target.asmVarname}+$scaledIdx
                                     ldy  #>${target.asmVarname}+$scaledIdx
-                                    jsr  c64flt.copy_float
+                                    jsr  floats.copy_float
                                 """)
                             }
                             else -> throw AssemblyError("weird target variable type ${target.datatype}")
@@ -401,7 +498,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                                     adc  #<${target.asmVarname}
                                     bcc  +
                                     iny
-+                                   jsr  c64flt.copy_float""")
++                                   jsr  floats.copy_float""")
                             }
                             else -> throw AssemblyError("weird dt")
                         }
@@ -433,8 +530,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
-    private fun assignVariableFloat(target: AsmAssignTarget, variable: IdentifierReference) {
+    private fun assignVariableFloat(target: AsmAssignTarget, sourceName: String) {
-        val sourceName = asmgen.asmVariableName(variable)
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
                 asmgen.out("""
@@ -458,18 +554,17 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
 //                    TODO("array[var] ${target.constArrayIndexValue}")
 //                }
                 val index = target.array!!.arrayspec.index
-                asmgen.out("  lda  #<$sourceName |  ldy  #>$sourceName |  jsr  c64flt.push_float")
+                asmgen.out("  lda  #<$sourceName |  ldy  #>$sourceName |  jsr  floats.push_float")
                 asmgen.translateExpression(index)
-                asmgen.out("  lda  #<${target.asmVarname} |  ldy  #>${target.asmVarname} |  jsr  c64flt.pop_float_to_indexed_var")
+                asmgen.out("  lda  #<${target.asmVarname} |  ldy  #>${target.asmVarname} |  jsr  floats.pop_float_to_indexed_var")
             }
             TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to mem byte")
             TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
-            TargetStorageKind.STACK -> asmgen.out("  lda  #<$sourceName |  ldy  #>$sourceName |  jsr  c64flt.push_float")
+            TargetStorageKind.STACK -> asmgen.out("  lda  #<$sourceName |  ldy  #>$sourceName |  jsr  floats.push_float")
         }
     }
 
-    private fun assignVariableByte(target: AsmAssignTarget, variable: IdentifierReference) {
+    private fun assignVariableByte(target: AsmAssignTarget, sourceName: String) {
-        val sourceName = asmgen.asmVariableName(variable)
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
                 asmgen.out("""
@@ -518,6 +613,117 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
+    private fun assignVariableByteIntoWord(wordtarget: AsmAssignTarget, bytevar: IdentifierReference) {
+        val sourceName = asmgen.asmVariableName(bytevar)
+        when (wordtarget.kind) {
+            TargetStorageKind.VARIABLE -> {
+                asmgen.out("""
+                    lda  $sourceName
+                    sta  ${wordtarget.asmVarname}
+                    ora  #$7f
+                    bmi  +
+                    lda  #0
++                   sta  ${wordtarget.asmVarname}+1
+                    """)
+            }
+            TargetStorageKind.ARRAY -> {
+                // TODO optimize slow stack evaluation for this case, see assignVariableUByteIntoWord
+                println("warning: slow stack evaluation used for sign-extend byte typecast at ${bytevar.position}")
+                asmgen.translateExpression(wordtarget.origAssign.source.expression!!)
+                assignStackValue(wordtarget)
+            }
+            TargetStorageKind.REGISTER -> {
+                when(wordtarget.register!!) {
+                    RegisterOrPair.AX -> asmgen.out("""
+                        lda  $sourceName
+                        pha
+                        ora  #$7f
+                        bmi  +
+                        ldx  #0
++                       tax
+                        pla""")
+                    RegisterOrPair.AY -> asmgen.out("""
+                        lda  $sourceName
+                        pha
+                        ora  #$7f
+                        bmi  +
+                        ldy  #0
++                       tay
+                        pla""")
+                    RegisterOrPair.XY -> asmgen.out("""
+                        lda  $sourceName
+                        tax 
+                        ora  #$7f
+                        bmi  +
+                        ldy  #0
++                       tay""")
+                    else -> throw AssemblyError("only reg pairs are words")
+                }
+            }
+            TargetStorageKind.STACK -> {
+                asmgen.out("""
+                    lda  $sourceName
+                    sta  P8ESTACK_LO,x
+                    ora  #$7f
+                    bmi  +                    
+                    lda  #0
++                   sta  P8ESTACK_HI,x
+                    dex""")
+            }
+            else -> throw AssemblyError("target type isn't word")
+        }
+    }
+
+    private fun assignVariableUByteIntoWord(wordtarget: AsmAssignTarget, bytevar: IdentifierReference) {
+        val sourceName = asmgen.asmVariableName(bytevar)
+        when(wordtarget.kind) {
+            TargetStorageKind.VARIABLE -> {
+                asmgen.out("""
+                    lda  $sourceName
+                    sta  ${wordtarget.asmVarname}
+                    lda  #0
+                    sta  ${wordtarget.asmVarname}+1
+                    """)
+            }
+            TargetStorageKind.ARRAY -> {
+                val index = wordtarget.array!!.arrayspec.index
+                when {
+                    wordtarget.constArrayIndexValue!=null -> {
+                        val scaledIdx = wordtarget.constArrayIndexValue!! * 2
+                        asmgen.out(" lda  $sourceName  | sta  ${wordtarget.asmVarname}+$scaledIdx |  lda  #0  | sta  ${wordtarget.asmVarname}+$scaledIdx+1")
+                    }
+                    index is IdentifierReference -> {
+                        asmgen.loadScaledArrayIndexIntoRegister(wordtarget.array, wordtarget.datatype, CpuRegister.Y)
+                        asmgen.out(" lda  $sourceName |  sta  ${wordtarget.asmVarname},y |  lda  #0 |  iny |  sta  ${wordtarget.asmVarname},y")
+                    }
+                    else -> {
+                        asmgen.out("  lda  $sourceName |  sta  P8ESTACK_LO,x |  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
+                        asmgen.translateExpression(index)
+                        asmgen.out("  inx |  lda  P8ESTACK_LO,x")
+                        popAndWriteArrayvalueWithUnscaledIndexA(wordtarget.datatype, wordtarget.asmVarname)
+                    }
+                }
+            }
+            TargetStorageKind.REGISTER -> {
+                when(wordtarget.register!!) {
+                    RegisterOrPair.AX -> asmgen.out("  lda  $sourceName |  ldx  #0")
+                    RegisterOrPair.AY -> asmgen.out("  lda  $sourceName |  ldy  #0")
+                    RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName |  ldy  #0")
+                    else -> throw AssemblyError("only reg pairs are words")
+                }
+            }
+            TargetStorageKind.STACK -> {
+                asmgen.out("""
+                    lda  $sourceName
+                    sta  P8ESTACK_LO,x
+                    lda  #0
+                    sta  P8ESTACK_HI,x
+                    dex""")
+            }
+            else -> throw AssemblyError("target type isn't word")
+        }
+    }
+
     private fun assignRegisterByte(target: AsmAssignTarget, register: CpuRegister) {
         require(target.datatype in ByteDatatypes)
         when(target.kind) {
@@ -547,9 +753,9 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         asmgen.out(" ldy  ${asmgen.asmVariableName(index)} |  sta  ${target.asmVarname},y")
                     }
                     else -> {
-                        asmgen.saveRegister(register)
+                        asmgen.saveRegister(register, false, target.scope)
                         asmgen.translateExpression(index)
-                        asmgen.restoreRegister(register)
+                        asmgen.restoreRegister(register, false)
                         when (register) {
                             CpuRegister.A -> asmgen.out("  sta  P8ZP_SCRATCH_B1")
                             CpuRegister.X -> asmgen.out("  stx  P8ZP_SCRATCH_B1")
@@ -571,19 +777,25 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.A -> {}
                         RegisterOrPair.X -> { asmgen.out("  tax") }
                         RegisterOrPair.Y -> { asmgen.out("  tay") }
-                        else -> throw AssemblyError("attempt to assign byte to register pair word")
+                        RegisterOrPair.AY -> { asmgen.out("  ldy  #0") }
+                        RegisterOrPair.AX -> { asmgen.out("  ldx  #0") }
+                        RegisterOrPair.XY -> { asmgen.out("  tax |  ldy  #0") }
                     }
                     CpuRegister.X -> when(target.register!!) {
                         RegisterOrPair.A -> { asmgen.out("  txa") }
                         RegisterOrPair.X -> {  }
                         RegisterOrPair.Y -> { asmgen.out("  txy") }
-                        else -> throw AssemblyError("attempt to assign byte to register pair word")
+                        RegisterOrPair.AY -> { asmgen.out("  txa |  ldy  #0") }
+                        RegisterOrPair.AX -> { asmgen.out("  txa |  ldx  #0") }
+                        RegisterOrPair.XY -> { asmgen.out("  ldy  #0") }
                     }
                     CpuRegister.Y -> when(target.register!!) {
                         RegisterOrPair.A -> { asmgen.out("  tya") }
                         RegisterOrPair.X -> { asmgen.out("  tyx") }
                         RegisterOrPair.Y -> { }
-                        else -> throw AssemblyError("attempt to assign byte to register pair word")
+                        RegisterOrPair.AY -> { asmgen.out("  tya |  ldy  #0") }
+                        RegisterOrPair.AX -> { asmgen.out("  tya |  ldx  #0") }
+                        RegisterOrPair.XY -> { asmgen.out("  tya |  tax |  ldy  #0") }
                     }
                 }
             }
@@ -597,6 +809,54 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
+    private fun assignRegisterpairWord(target: AsmAssignTarget, regs: RegisterOrPair) {
+        require(target.datatype in WordDatatypes)
+        when(target.kind) {
+            TargetStorageKind.VARIABLE -> {
+                when(regs) {
+                    RegisterOrPair.AX -> asmgen.out("  sta  ${target.asmVarname} |  stx  ${target.asmVarname}+1")
+                    RegisterOrPair.AY -> asmgen.out("  sta  ${target.asmVarname} |  sty  ${target.asmVarname}+1")
+                    RegisterOrPair.XY -> asmgen.out("  stx  ${target.asmVarname} |  sty  ${target.asmVarname}+1")
+                    else -> throw AssemblyError("expected reg pair")
+                }
+            }
+            TargetStorageKind.ARRAY -> {
+                TODO("store register pair $regs into word-array ${target.array}")
+            }
+            TargetStorageKind.REGISTER -> {
+                when(regs) {
+                    RegisterOrPair.AX -> when(target.register!!) {
+                        RegisterOrPair.AY -> { asmgen.out("  stx  P8ZP_SCRATCH_REG |  ldy  P8ZP_SCRATCH_REG") }
+                        RegisterOrPair.AX -> { }
+                        RegisterOrPair.XY -> { asmgen.out("  stx  P8ZP_SCRATCH_REG |  ldy  P8ZP_SCRATCH_REG |  tax") }
+                        else -> throw AssemblyError("expected reg pair")
+                    }
+                    RegisterOrPair.AY -> when(target.register!!) {
+                        RegisterOrPair.AY -> { }
+                        RegisterOrPair.AX -> { asmgen.out("  sty  P8ZP_SCRATCH_REG |  ldx  P8ZP_SCRATCH_REG") }
+                        RegisterOrPair.XY -> { asmgen.out("  tax") }
+                        else -> throw AssemblyError("expected reg pair")
+                    }
+                    RegisterOrPair.XY -> when(target.register!!) {
+                        RegisterOrPair.AY -> { asmgen.out("  txa") }
+                        RegisterOrPair.AX -> { asmgen.out("  txa |  sty  P8ZP_SCRATCH_REG |  ldx  P8ZP_SCRATCH_REG") }
+                        RegisterOrPair.XY -> { }
+                        else -> throw AssemblyError("expected reg pair")
+                    }
+                    else -> throw AssemblyError("expected reg pair")
+                }
+            }
+            TargetStorageKind.STACK -> {
+                when(regs) {
+                    RegisterOrPair.AY -> asmgen.out(" sta  P8ESTACK_LO,x |  sty  P8ESTACK_HI,x |  dex")
+                    RegisterOrPair.AX, RegisterOrPair.XY -> throw AssemblyError("can't use X here")
+                    else -> throw AssemblyError("expected reg pair")
+                }
+            }
+            TargetStorageKind.MEMORY -> throw AssemblyError("can't store word into memory byte")
+        }
+    }
+
     private fun assignConstantWord(target: AsmAssignTarget, word: Int) {
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
@@ -692,7 +952,9 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 RegisterOrPair.A -> asmgen.out("  lda  #${byte.toHex()}")
                 RegisterOrPair.X -> asmgen.out("  ldx  #${byte.toHex()}")
                 RegisterOrPair.Y -> asmgen.out("  ldy  #${byte.toHex()}")
-                else -> throw AssemblyError("can't assign byte to word register apir")
+                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")
             }
             TargetStorageKind.STACK -> {
                 asmgen.out("""
@@ -708,7 +970,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             // optimized case for float zero
             when(target.kind) {
                 TargetStorageKind.VARIABLE -> {
-                    if(CompilationTarget.machine.cpu == CpuType.CPU65c02)
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("""
                             stz  ${target.asmVarname}
                             stz  ${target.asmVarname}+1
@@ -751,7 +1013,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                             sta  P8ZP_SCRATCH_W1
                             lda  #>${target.asmVarname}
                             sta  P8ZP_SCRATCH_W1+1
-                            jsr  c64flt.set_0_array_float
+                            jsr  floats.set_0_array_float
                         """)
                     }
                 }
@@ -759,7 +1021,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
                 TargetStorageKind.STACK -> {
                     val floatConst = asmgen.getFloatAsmConst(float)
-                    asmgen.out(" lda  #<$floatConst |  ldy  #>$floatConst |  jsr  c64flt.push_float")
+                    asmgen.out(" lda  #<$floatConst |  ldy  #>$floatConst |  jsr  floats.push_float")
                 }
             }
         } else {
@@ -814,7 +1076,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                             sta  P8ZP_SCRATCH_W2
                             lda  #>${arrayVarName}
                             sta  P8ZP_SCRATCH_W2+1
-                            jsr  c64flt.set_array_float
+                            jsr  floats.set_array_float
                         """)
                     }
                 }
@@ -822,7 +1084,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
                 TargetStorageKind.STACK -> {
                     val floatConst = asmgen.getFloatAsmConst(float)
-                    asmgen.out(" lda  #<$floatConst |  ldy  #>$floatConst |  jsr  c64flt.push_float")
+                    asmgen.out(" lda  #<$floatConst |  ldy  #>$floatConst |  jsr  floats.push_float")
                 }
             }
         }
@@ -847,7 +1109,9 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     RegisterOrPair.A -> asmgen.out("  lda  ${address.toHex()}")
                     RegisterOrPair.X -> asmgen.out("  ldx  ${address.toHex()}")
                     RegisterOrPair.Y -> asmgen.out("  ldy  ${address.toHex()}")
-                    else -> throw AssemblyError("can't assign byte to word register apir")
+                    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")
                 }
                 TargetStorageKind.STACK -> {
                     asmgen.out("""
@@ -875,7 +1139,9 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.A -> {}
                         RegisterOrPair.X -> asmgen.out("  tax")
                         RegisterOrPair.Y -> asmgen.out("  tay")
-                        else -> throw AssemblyError("can't assign byte to word register apir")
+                        RegisterOrPair.AX -> asmgen.out("  ldx  #0")
+                        RegisterOrPair.AY -> asmgen.out("  ldy  #0")
+                        RegisterOrPair.XY -> asmgen.out("  tax |  ldy  #0")
                     }
                 }
                 TargetStorageKind.STACK -> {
@@ -886,6 +1152,63 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
+    private fun assignMemoryByteIntoWord(wordtarget: AsmAssignTarget, address: Int?, identifier: IdentifierReference?) {
+        if (address != null) {
+            when(wordtarget.kind) {
+                TargetStorageKind.VARIABLE -> {
+                    asmgen.out("""
+                        lda  ${address.toHex()}
+                        sta  ${wordtarget.asmVarname}
+                        lda  #0
+                        sta  ${wordtarget.asmVarname}+1
+                        """)
+                }
+                TargetStorageKind.ARRAY -> {
+                    throw AssemblyError("no asm gen for assign memory byte at $address to array ${wordtarget.asmVarname}")
+                }
+                TargetStorageKind.REGISTER -> when(wordtarget.register!!) {
+                    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")
+                    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""")
+                }
+                else -> throw AssemblyError("other types aren't word")
+            }
+        } else if (identifier != null) {
+            when(wordtarget.kind) {
+                TargetStorageKind.VARIABLE -> {
+                    asmgen.loadByteFromPointerIntoA(identifier)
+                    asmgen.out(" sta  ${wordtarget.asmVarname} |  lda  #0 |  sta ${wordtarget.asmVarname}+1")
+                }
+                TargetStorageKind.ARRAY -> {
+                    throw AssemblyError("no asm gen for assign memory byte $identifier to array ${wordtarget.asmVarname} ")
+                }
+                TargetStorageKind.REGISTER -> {
+                    asmgen.loadByteFromPointerIntoA(identifier)
+                    when(wordtarget.register!!) {
+                        RegisterOrPair.AX -> asmgen.out("  ldx  #0")
+                        RegisterOrPair.AY -> asmgen.out("  ldy  #0")
+                        RegisterOrPair.XY -> asmgen.out("  tax |  ldy  #0")
+                        else -> throw AssemblyError("word regs can only be pair")
+                    }
+                }
+                TargetStorageKind.STACK -> {
+                    asmgen.loadByteFromPointerIntoA(identifier)
+                    asmgen.out(" sta  P8ESTACK_LO,x |  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
+                }
+                else -> throw AssemblyError("other types aren't word")
+            }
+        }
+    }
+
     private fun storeByteViaRegisterAInMemoryAddress(ldaInstructionArg: String, memoryAddress: DirectMemoryWrite) {
         val addressExpr = memoryAddress.addressExpression
         val addressLv = addressExpr as? NumericLiteralValue
@@ -929,9 +1252,9 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 asmgen.storeByteIntoPointer(addressExpr, null)
             }
             else -> {
-                asmgen.saveRegister(register)
+                asmgen.saveRegister(register, false, memoryAddress.definingSubroutine())
                 asmgen.translateExpression(addressExpr)
-                asmgen.restoreRegister(CpuRegister.A)
+                asmgen.restoreRegister(CpuRegister.A, false)
                 asmgen.out("""
                     inx
                     ldy  P8ESTACK_LO,x
@@ -957,7 +1280,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     dex
                     lda  #<$asmArrayvarname
                     ldy  #>$asmArrayvarname
-                    jsr  c64flt.pop_float_to_indexed_var
+                    jsr  floats.pop_float_to_indexed_var
                 """)
             else ->
                 throw AssemblyError("weird array type")

compiler/src/prog8/compiler/target/cx16/CX16MachineDefinition.kt

@@ -26,14 +26,13 @@ internal object CX16MachineDefinition: IMachineDefinition {
     override val ESTACK_HI = 0x0500        //  $0500-$05ff inclusive
 
     override lateinit var zeropage: Zeropage
-    override val initSystemProcname = "cx16.init_system"
 
     override fun getFloat(num: Number) = C64MachineDefinition.Mflpt5.fromNumber(num)
 
     override fun getFloatRomConst(number: Double): String? = null       // Cx16 has no pulblic ROM float locations
     override fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program) {
         if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG)
-            importer.importLibraryModule(program, "cx16lib")
+            importer.importLibraryModule(program, "syslib")
     }
 
     override fun launchEmulator(programName: String) {
@@ -53,6 +52,8 @@ internal object CX16MachineDefinition: IMachineDefinition {
         }
     }
 
+    override fun isRegularRAMaddress(address: Int): Boolean = address < 0x9f00 || address in 0xa000..0xbfff
+
     override fun initializeZeropage(compilerOptions: CompilationOptions) {
         zeropage = CX16Zeropage(compilerOptions)
     }
@@ -75,18 +76,10 @@ internal object CX16MachineDefinition: IMachineDefinition {
 
         override val SCRATCH_B1 = 0x79      // temp storage for a single byte
         override val SCRATCH_REG = 0x7a     // temp storage for a register
-        override val SCRATCH_REG_X = 0x7b   // temp storage for register X (the evaluation stack pointer)
         override val SCRATCH_W1 = 0x7c      // temp storage 1 for a word  $7c+$7d
         override val SCRATCH_W2 = 0x7e      // temp storage 2 for a word  $7e+$7f
 
 
-        override val exitProgramStrategy: ExitProgramStrategy = when (options.zeropage) {
-            ZeropageType.BASICSAFE, ZeropageType.DONTUSE -> ExitProgramStrategy.CLEAN_EXIT
-            ZeropageType.KERNALSAFE, ZeropageType.FULL -> ExitProgramStrategy.SYSTEM_RESET
-            else -> ExitProgramStrategy.SYSTEM_RESET
-        }
-
-
         init {
             if (options.floats && options.zeropage !in setOf(ZeropageType.BASICSAFE, ZeropageType.DONTUSE ))
                 throw CompilerException("when floats are enabled, zero page type should be 'basicsafe' or 'dontuse'")
@@ -96,16 +89,16 @@ internal object CX16MachineDefinition: IMachineDefinition {
             when (options.zeropage) {
                 ZeropageType.FULL -> {
                     free.addAll(0x22..0xff)
-                    free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_REG_X, SCRATCH_W1, SCRATCH_W1 + 1, SCRATCH_W2, SCRATCH_W2 + 1))
+                    free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_W1, SCRATCH_W1 + 1, SCRATCH_W2, SCRATCH_W2 + 1))
                 }
                 ZeropageType.KERNALSAFE -> {
                     free.addAll(0x22..0x7f)
                     free.addAll(0xa9..0xff)
-                    free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_REG_X, SCRATCH_W1, SCRATCH_W1 + 1, SCRATCH_W2, SCRATCH_W2 + 1))
+                    free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_W1, SCRATCH_W1 + 1, SCRATCH_W2, SCRATCH_W2 + 1))
                 }
                 ZeropageType.BASICSAFE -> {
                     free.addAll(0x22..0x7f)
-                    free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_REG_X, SCRATCH_W1, SCRATCH_W1 + 1, SCRATCH_W2, SCRATCH_W2 + 1))
+                    free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_W1, SCRATCH_W1 + 1, SCRATCH_W2, SCRATCH_W2 + 1))
                 }
                 ZeropageType.DONTUSE -> {
                     free.clear() // don't use zeropage at all
@@ -115,7 +108,6 @@ internal object CX16MachineDefinition: IMachineDefinition {
 
             require(SCRATCH_B1 !in free)
             require(SCRATCH_REG !in free)
-            require(SCRATCH_REG_X !in free)
             require(SCRATCH_W1 !in free)
             require(SCRATCH_W2 !in free)
 

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -285,9 +285,9 @@ private fun builtinStrlen(args: List<Expression>, position: Position, program: P
         return NumericLiteralValue.optimalInteger(argument.value.length, argument.position)
     val vardecl = (argument as IdentifierReference).targetVarDecl(program.namespace)
     if(vardecl!=null) {
-        if(vardecl.datatype!=DataType.STR)
+        if(vardecl.datatype!=DataType.STR && vardecl.datatype!=DataType.UWORD)
             throw SyntaxError("strlen must have string argument", position)
-        if(vardecl.autogeneratedDontRemove) {
+        if(vardecl.autogeneratedDontRemove && vardecl.value!=null) {
             return NumericLiteralValue.optimalInteger((vardecl.value as StringLiteralValue).value.length, argument.position)
         }
     }

compiler/src/prog8/optimizer/BinExprSplitter.kt

@@ -0,0 +1,89 @@
+package prog8.optimizer
+
+import prog8.ast.INameScope
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.expressions.*
+import prog8.ast.processing.AstWalker
+import prog8.ast.processing.IAstModification
+import prog8.ast.statements.AssignTarget
+import prog8.ast.statements.Assignment
+
+
+internal class BinExprSplitter(private val program: Program) : AstWalker() {
+    private val noModifications = emptyList<IAstModification>()
+
+//    override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
+// TODO somehow if we do this, the resulting code for some programs (cube3d.p8) gets hundreds of bytes larger...:
+//        if(decl.type==VarDeclType.VAR ) {
+//            val binExpr = decl.value as? BinaryExpression
+//            if (binExpr != null && binExpr.operator in augmentAssignmentOperators) {
+//                // split into a vardecl with just the left expression, and an aug. assignment with the right expression.
+//                val augExpr = BinaryExpression(IdentifierReference(listOf(decl.name), decl.position), binExpr.operator, binExpr.right, binExpr.position)
+//                val target = AssignTarget(IdentifierReference(listOf(decl.name), decl.position), null, null, decl.position)
+//                val assign = Assignment(target, augExpr, binExpr.position)
+//                println("SPLIT VARDECL $decl")
+//                return listOf(
+//                        IAstModification.SetExpression({ decl.value = it }, binExpr.left, decl),
+//                        IAstModification.InsertAfter(decl, assign, parent)
+//                )
+//            }
+//        }
+//        return noModifications
+//    }
+
+    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
+
+        val binExpr = assignment.value as? BinaryExpression
+        if (binExpr != null) {
+/*
+
+reduce the complexity of a (binary) expression that has to be evaluated on the eval stack,
+by attempting to splitting it up into individual simple steps:
+
+
+X =      BinExpr                                   X   =   LeftExpr
+        <operator>                                   followed by
+          /   \              IF 'X' not used       X   =   BinExpr
+         /     \               IN LEFTEXPR ==>             <operator>
+        /       \                                           /   \
+    LeftExpr.  RightExpr.                                  /     \
+      /  \       /  \                                     X     RightExpr.
+    ..  ..      ..  ..
+
+ */
+            if(binExpr.operator in augmentAssignmentOperators && isSimpleTarget(assignment.target, program.namespace)) {
+                if (!assignment.isAugmentable) {
+                    val firstAssign = Assignment(assignment.target, binExpr.left, binExpr.left.position)
+                    val targetExpr = assignment.target.toExpression()
+                    val augExpr = BinaryExpression(targetExpr, binExpr.operator, binExpr.right, binExpr.right.position)
+                    return listOf(
+                            IAstModification.InsertBefore(assignment, firstAssign, parent),
+                            IAstModification.ReplaceNode(assignment.value, augExpr, assignment))
+                }
+            }
+
+            // TODO further unraveling of binary expression trees into flat statements.
+            // however this should probably be done in a more generic way to also service
+            // the expressiontrees that are not used in an assignment statement...
+        }
+
+        return noModifications
+    }
+
+    private fun isSimpleTarget(target: AssignTarget, namespace: INameScope): Boolean {
+        return when {
+            target.identifier!=null -> target.isInRegularRAM(namespace)
+            target.memoryAddress!=null -> target.isInRegularRAM(namespace)
+            target.arrayindexed!=null -> {
+                val index = target.arrayindexed!!.arrayspec.index
+                if(index is NumericLiteralValue)
+                    target.isInRegularRAM(namespace)
+                else
+                    false
+            }
+            else -> false
+        }
+    }
+
+}

compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt

@@ -7,178 +7,6 @@ import prog8.ast.expressions.*
 import prog8.ast.processing.AstWalker
 import prog8.ast.processing.IAstModification
 import prog8.ast.statements.*
-import prog8.compiler.target.CompilationTarget
-
-
-// First thing to do is replace all constant identifiers with their actual value,
-// and the array var initializer values and sizes.
-// This is needed because further constant optimizations depend on those.
-internal class ConstantIdentifierReplacer(private val program: Program, private val errors: ErrorReporter) : AstWalker() {
-    private val noModifications = emptyList<IAstModification>()
-
-    override fun after(identifier: IdentifierReference, parent: Node): Iterable<IAstModification> {
-        // replace identifiers that refer to const value, with the value itself
-        // if it's a simple type and if it's not a left hand side variable
-        if(identifier.parent is AssignTarget)
-            return noModifications
-        var forloop = identifier.parent as? ForLoop
-        if(forloop==null)
-            forloop = identifier.parent.parent as? ForLoop
-        if(forloop!=null && identifier===forloop.loopVar)
-            return noModifications
-
-        val cval = identifier.constValue(program) ?: return noModifications
-        return when (cval.type) {
-            in NumericDatatypes -> listOf(IAstModification.ReplaceNode(identifier, NumericLiteralValue(cval.type, cval.number, identifier.position), identifier.parent))
-            in PassByReferenceDatatypes -> throw FatalAstException("pass-by-reference type should not be considered a constant")
-            else -> noModifications
-        }
-    }
-
-    override fun before(decl: VarDecl, parent: Node): Iterable<IAstModification> {
-        // the initializer value can't refer to the variable itself (recursive definition)
-        // TODO: use call graph for this?
-        if(decl.value?.referencesIdentifiers(decl.name) == true || decl.arraysize?.index?.referencesIdentifiers(decl.name) == true) {
-            errors.err("recursive var declaration", decl.position)
-            return noModifications
-        }
-
-        if(decl.type==VarDeclType.CONST || decl.type==VarDeclType.VAR) {
-            if(decl.isArray){
-                if(decl.arraysize==null) {
-                    // for arrays that have no size specifier (or a non-constant one) attempt to deduce the size
-                    val arrayval = decl.value as? ArrayLiteralValue
-                    if(arrayval!=null) {
-                        return listOf(IAstModification.SetExpression(
-                                { decl.arraysize = ArrayIndex(it, decl.position) },
-                                NumericLiteralValue.optimalInteger(arrayval.value.size, decl.position),
-                                decl
-                        ))
-                    }
-                }
-                else if(decl.arraysize?.constIndex()==null) {
-                    val size = decl.arraysize!!.index.constValue(program)
-                    if(size!=null) {
-                        return listOf(IAstModification.SetExpression(
-                                { decl.arraysize = ArrayIndex(it, decl.position) },
-                                size, decl
-                        ))
-                    }
-                }
-            }
-
-            when(decl.datatype) {
-                DataType.FLOAT -> {
-                    // vardecl: for scalar float vars, promote constant integer initialization values to floats
-                    val litval = decl.value as? NumericLiteralValue
-                    if (litval!=null && litval.type in IntegerDatatypes) {
-                        val newValue = NumericLiteralValue(DataType.FLOAT, litval.number.toDouble(), litval.position)
-                        return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
-                    }
-                }
-                DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
-                    val numericLv = decl.value as? NumericLiteralValue
-                    val rangeExpr = decl.value as? RangeExpr
-                    if(rangeExpr!=null) {
-                        // convert the initializer range expression to an actual array
-                        val declArraySize = decl.arraysize?.constIndex()
-                        if(declArraySize!=null && declArraySize!=rangeExpr.size())
-                            errors.err("range expression size doesn't match declared array size", decl.value?.position!!)
-                        val constRange = rangeExpr.toConstantIntegerRange()
-                        if(constRange!=null) {
-                            val eltType = rangeExpr.inferType(program).typeOrElse(DataType.UBYTE)
-                            val newValue = if(eltType in ByteDatatypes) {
-                                ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
-                                        constRange.map { NumericLiteralValue(eltType, it.toShort(), decl.value!!.position) }.toTypedArray(),
-                                        position = decl.value!!.position)
-                            } else {
-                                ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
-                                        constRange.map { NumericLiteralValue(eltType, it, decl.value!!.position) }.toTypedArray(),
-                                        position = decl.value!!.position)
-                            }
-                            return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
-                        }
-                    }
-                    if(numericLv!=null && numericLv.type==DataType.FLOAT)
-                        errors.err("arraysize requires only integers here", numericLv.position)
-                    val size = decl.arraysize?.constIndex() ?: return noModifications
-                    if (rangeExpr==null && numericLv!=null) {
-                        // arraysize initializer is empty or a single int, and we know the size; create the arraysize.
-                        val fillvalue = numericLv.number.toInt()
-                        when(decl.datatype){
-                            DataType.ARRAY_UB -> {
-                                if(fillvalue !in 0..255)
-                                    errors.err("ubyte value overflow", numericLv.position)
-                            }
-                            DataType.ARRAY_B -> {
-                                if(fillvalue !in -128..127)
-                                    errors.err("byte value overflow", numericLv.position)
-                            }
-                            DataType.ARRAY_UW -> {
-                                if(fillvalue !in 0..65535)
-                                    errors.err("uword value overflow", numericLv.position)
-                            }
-                            DataType.ARRAY_W -> {
-                                if(fillvalue !in -32768..32767)
-                                    errors.err("word value overflow", numericLv.position)
-                            }
-                            else -> {}
-                        }
-                        // create the array itself, filled with the fillvalue.
-                        val array = Array(size) {fillvalue}.map { NumericLiteralValue(ArrayElementTypes.getValue(decl.datatype), it, numericLv.position) }.toTypedArray<Expression>()
-                        val refValue = ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype), array, position = numericLv.position)
-                        return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
-                    }
-                }
-                DataType.ARRAY_F  -> {
-                    val size = decl.arraysize?.constIndex() ?: return noModifications
-                    val litval = decl.value as? NumericLiteralValue
-                    val rangeExpr = decl.value as? RangeExpr
-                    if(rangeExpr!=null) {
-                        // convert the initializer range expression to an actual array of floats
-                        val declArraySize = decl.arraysize?.constIndex()
-                        if(declArraySize!=null && declArraySize!=rangeExpr.size())
-                            errors.err("range expression size doesn't match declared array size", decl.value?.position!!)
-                        val constRange = rangeExpr.toConstantIntegerRange()
-                        if(constRange!=null) {
-                            val newValue = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_F),
-                                        constRange.map { NumericLiteralValue(DataType.FLOAT, it.toDouble(), decl.value!!.position) }.toTypedArray(),
-                                        position = decl.value!!.position)
-                            return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
-                        }
-                    }
-                    if(rangeExpr==null && litval!=null) {
-                        // arraysize initializer is a single int, and we know the size.
-                        val fillvalue = litval.number.toDouble()
-                        if (fillvalue < CompilationTarget.machine.FLOAT_MAX_NEGATIVE || fillvalue > CompilationTarget.machine.FLOAT_MAX_POSITIVE)
-                            errors.err("float value overflow", litval.position)
-                        else {
-                            // create the array itself, filled with the fillvalue.
-                            val array = Array(size) {fillvalue}.map { NumericLiteralValue(DataType.FLOAT, it, litval.position) }.toTypedArray<Expression>()
-                            val refValue = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_F), array, position = litval.position)
-                            return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
-                        }
-                    }
-                }
-                else -> {
-                    // nothing to do for this type
-                    // this includes strings and structs
-                }
-            }
-        }
-
-        val declValue = decl.value
-        if(declValue!=null && decl.type==VarDeclType.VAR
-                && declValue is NumericLiteralValue && !declValue.inferType(program).istype(decl.datatype)) {
-            // cast the numeric literal to the appropriate datatype of the variable
-            val cast = declValue.cast(decl.datatype)
-            if(cast.isValid)
-                return listOf(IAstModification.ReplaceNode(decl.value!!, cast.valueOrZero(), decl))
-        }
-
-        return noModifications
-    }
-}
 
 
 internal class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
@@ -216,9 +44,24 @@ internal class ConstantFoldingOptimizer(private val program: Program) : AstWalke
                     else -> throw ExpressionError("can only take negative of int or float", subexpr.position)
                 }
                 "~" -> when (subexpr.type) {
-                    in IntegerDatatypes -> {
+                    DataType.BYTE -> {
                         listOf(IAstModification.ReplaceNode(expr,
-                                NumericLiteralValue.optimalInteger(subexpr.number.toInt().inv(), subexpr.position),
+                                NumericLiteralValue(DataType.BYTE, subexpr.number.toInt().inv(), subexpr.position),
+                                parent))
+                    }
+                    DataType.UBYTE -> {
+                        listOf(IAstModification.ReplaceNode(expr,
+                                NumericLiteralValue(DataType.UBYTE, subexpr.number.toInt().inv() and 255, subexpr.position),
+                                parent))
+                    }
+                    DataType.WORD -> {
+                        listOf(IAstModification.ReplaceNode(expr,
+                                NumericLiteralValue(DataType.WORD, subexpr.number.toInt().inv(), subexpr.position),
+                                parent))
+                    }
+                    DataType.UWORD -> {
+                        listOf(IAstModification.ReplaceNode(expr,
+                                NumericLiteralValue(DataType.UWORD, subexpr.number.toInt().inv() and 65535, subexpr.position),
                                 parent))
                     }
                     else -> throw ExpressionError("can only take bitwise inversion of int", subexpr.position)

compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -0,0 +1,192 @@
+package prog8.optimizer
+
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.AstWalker
+import prog8.ast.processing.IAstModification
+import prog8.ast.statements.ArrayIndex
+import prog8.ast.statements.AssignTarget
+import prog8.ast.statements.ForLoop
+import prog8.ast.statements.VarDecl
+import prog8.compiler.target.CompilationTarget
+
+// Fix up the literal value's type to match that of the vardecl
+internal class VarConstantValueTypeAdjuster(private val program: Program, private val errors: ErrorReporter) : AstWalker() {
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
+        val declConstValue = decl.value?.constValue(program)
+        if(declConstValue!=null && (decl.type==VarDeclType.VAR || decl.type==VarDeclType.CONST)
+                && !declConstValue.inferType(program).istype(decl.datatype)) {
+            // cast the numeric literal to the appropriate datatype of the variable
+            val cast = declConstValue.cast(decl.datatype)
+            if(cast.isValid)
+                return listOf(IAstModification.ReplaceNode(decl.value!!, cast.valueOrZero(), decl))
+        }
+        return noModifications
+    }
+}
+
+
+// Replace all constant identifiers with their actual value,
+// and the array var initializer values and sizes.
+// This is needed because further constant optimizations depend on those.
+internal class ConstantIdentifierReplacer(private val program: Program, private val errors: ErrorReporter) : AstWalker() {
+    private val noModifications = emptyList<IAstModification>()
+
+    override fun after(identifier: IdentifierReference, parent: Node): Iterable<IAstModification> {
+        // replace identifiers that refer to const value, with the value itself
+        // if it's a simple type and if it's not a left hand side variable
+        if(identifier.parent is AssignTarget)
+            return noModifications
+        var forloop = identifier.parent as? ForLoop
+        if(forloop==null)
+            forloop = identifier.parent.parent as? ForLoop
+        if(forloop!=null && identifier===forloop.loopVar)
+            return noModifications
+
+        val cval = identifier.constValue(program) ?: return noModifications
+        return when (cval.type) {
+            in NumericDatatypes -> listOf(IAstModification.ReplaceNode(identifier, NumericLiteralValue(cval.type, cval.number, identifier.position), identifier.parent))
+            in PassByReferenceDatatypes -> throw FatalAstException("pass-by-reference type should not be considered a constant")
+            else -> noModifications
+        }
+    }
+
+    override fun before(decl: VarDecl, parent: Node): Iterable<IAstModification> {
+        // the initializer value can't refer to the variable itself (recursive definition)
+        // TODO: use call graph for this?
+        if(decl.value?.referencesIdentifier(decl.name) == true || decl.arraysize?.index?.referencesIdentifier(decl.name) == true) {
+            errors.err("recursive var declaration", decl.position)
+            return noModifications
+        }
+
+        if(decl.type== VarDeclType.CONST || decl.type== VarDeclType.VAR) {
+            if(decl.isArray){
+                if(decl.arraysize==null) {
+                    // for arrays that have no size specifier (or a non-constant one) attempt to deduce the size
+                    val arrayval = decl.value as? ArrayLiteralValue
+                    if(arrayval!=null) {
+                        return listOf(IAstModification.SetExpression(
+                                { decl.arraysize = ArrayIndex(it, decl.position) },
+                                NumericLiteralValue.optimalInteger(arrayval.value.size, decl.position),
+                                decl
+                        ))
+                    }
+                }
+                else if(decl.arraysize?.constIndex()==null) {
+                    val size = decl.arraysize!!.index.constValue(program)
+                    if(size!=null) {
+                        return listOf(IAstModification.SetExpression(
+                                { decl.arraysize = ArrayIndex(it, decl.position) },
+                                size, decl
+                        ))
+                    }
+                }
+            }
+
+            when(decl.datatype) {
+                DataType.FLOAT -> {
+                    // vardecl: for scalar float vars, promote constant integer initialization values to floats
+                    val litval = decl.value as? NumericLiteralValue
+                    if (litval!=null && litval.type in IntegerDatatypes) {
+                        val newValue = NumericLiteralValue(DataType.FLOAT, litval.number.toDouble(), litval.position)
+                        return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
+                    }
+                }
+                DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                    val numericLv = decl.value as? NumericLiteralValue
+                    val rangeExpr = decl.value as? RangeExpr
+                    if(rangeExpr!=null) {
+                        // convert the initializer range expression to an actual array
+                        val declArraySize = decl.arraysize?.constIndex()
+                        if(declArraySize!=null && declArraySize!=rangeExpr.size())
+                            errors.err("range expression size doesn't match declared array size", decl.value?.position!!)
+                        val constRange = rangeExpr.toConstantIntegerRange()
+                        if(constRange!=null) {
+                            val eltType = rangeExpr.inferType(program).typeOrElse(DataType.UBYTE)
+                            val newValue = if(eltType in ByteDatatypes) {
+                                ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
+                                        constRange.map { NumericLiteralValue(eltType, it.toShort(), decl.value!!.position) }.toTypedArray(),
+                                        position = decl.value!!.position)
+                            } else {
+                                ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
+                                        constRange.map { NumericLiteralValue(eltType, it, decl.value!!.position) }.toTypedArray(),
+                                        position = decl.value!!.position)
+                            }
+                            return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
+                        }
+                    }
+                    if(numericLv!=null && numericLv.type== DataType.FLOAT)
+                        errors.err("arraysize requires only integers here", numericLv.position)
+                    val size = decl.arraysize?.constIndex() ?: return noModifications
+                    if (rangeExpr==null && numericLv!=null) {
+                        // arraysize initializer is empty or a single int, and we know the size; create the arraysize.
+                        val fillvalue = numericLv.number.toInt()
+                        when(decl.datatype){
+                            DataType.ARRAY_UB -> {
+                                if(fillvalue !in 0..255)
+                                    errors.err("ubyte value overflow", numericLv.position)
+                            }
+                            DataType.ARRAY_B -> {
+                                if(fillvalue !in -128..127)
+                                    errors.err("byte value overflow", numericLv.position)
+                            }
+                            DataType.ARRAY_UW -> {
+                                if(fillvalue !in 0..65535)
+                                    errors.err("uword value overflow", numericLv.position)
+                            }
+                            DataType.ARRAY_W -> {
+                                if(fillvalue !in -32768..32767)
+                                    errors.err("word value overflow", numericLv.position)
+                            }
+                            else -> {}
+                        }
+                        // create the array itself, filled with the fillvalue.
+                        val array = Array(size) {fillvalue}.map { NumericLiteralValue(ArrayElementTypes.getValue(decl.datatype), it, numericLv.position) }.toTypedArray<Expression>()
+                        val refValue = ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype), array, position = numericLv.position)
+                        return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
+                    }
+                }
+                DataType.ARRAY_F -> {
+                    val size = decl.arraysize?.constIndex() ?: return noModifications
+                    val litval = decl.value as? NumericLiteralValue
+                    val rangeExpr = decl.value as? RangeExpr
+                    if(rangeExpr!=null) {
+                        // convert the initializer range expression to an actual array of floats
+                        val declArraySize = decl.arraysize?.constIndex()
+                        if(declArraySize!=null && declArraySize!=rangeExpr.size())
+                            errors.err("range expression size doesn't match declared array size", decl.value?.position!!)
+                        val constRange = rangeExpr.toConstantIntegerRange()
+                        if(constRange!=null) {
+                            val newValue = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_F),
+                                    constRange.map { NumericLiteralValue(DataType.FLOAT, it.toDouble(), decl.value!!.position) }.toTypedArray(),
+                                    position = decl.value!!.position)
+                            return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
+                        }
+                    }
+                    if(rangeExpr==null && litval!=null) {
+                        // arraysize initializer is a single int, and we know the size.
+                        val fillvalue = litval.number.toDouble()
+                        if (fillvalue < CompilationTarget.instance.machine.FLOAT_MAX_NEGATIVE || fillvalue > CompilationTarget.instance.machine.FLOAT_MAX_POSITIVE)
+                            errors.err("float value overflow", litval.position)
+                        else {
+                            // create the array itself, filled with the fillvalue.
+                            val array = Array(size) {fillvalue}.map { NumericLiteralValue(DataType.FLOAT, it, litval.position) }.toTypedArray<Expression>()
+                            val refValue = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_F), array, position = litval.position)
+                            return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
+                        }
+                    }
+                }
+                else -> {
+                    // nothing to do for this type
+                    // this includes strings and structs
+                }
+            }
+        }
+
+        return noModifications
+    }
+}

compiler/src/prog8/optimizer/ExpressionSimplifier.kt

@@ -175,28 +175,6 @@ internal class ExpressionSimplifier(private val program: Program) : AstWalker()
                 // unsigned >= 0 --> true
                 return listOf(IAstModification.ReplaceNode(expr, NumericLiteralValue.fromBoolean(true, expr.position), parent))
             }
-            when(leftDt) {
-                DataType.BYTE -> {
-                    // signed >=0   --> signed ^ $80
-                    return listOf(IAstModification.ReplaceNode(
-                            expr,
-                            BinaryExpression(expr.left, "^", NumericLiteralValue.optimalInteger(0x80, expr.position), expr.position),
-                            parent
-                    ))
-                }
-                DataType.WORD -> {
-                    // signedw >=0   --> msb(signedw) ^ $80
-                    return listOf(IAstModification.ReplaceNode(
-                            expr,
-                            BinaryExpression(FunctionCall(IdentifierReference(listOf("msb"), expr.position),
-                                    mutableListOf(expr.left),
-                                    expr.position
-                            ), "^", NumericLiteralValue.optimalInteger(0x80, expr.position), expr.position),
-                            parent
-                    ))
-                }
-                else -> {}
-            }
         }
 
         if(expr.operator == "<" && rightVal?.number == 0) {
@@ -297,6 +275,49 @@ internal class ExpressionSimplifier(private val program: Program) : AstWalker()
         return noModifications
     }
 
+    override fun after(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> {
+        if(functionCall.target.nameInSource == listOf("lsb")) {
+            val arg = functionCall.args[0]
+            if(arg is TypecastExpression) {
+                val valueDt = arg.expression.inferType(program)
+                if (valueDt.istype(DataType.BYTE) || valueDt.istype(DataType.UBYTE)) {
+                    // useless lsb() of byte value that was casted to word
+                    return listOf(IAstModification.ReplaceNode(functionCall, arg.expression, parent))
+                }
+            } else {
+                val argDt = arg.inferType(program)
+                if (argDt.istype(DataType.BYTE) || argDt.istype(DataType.UBYTE)) {
+                    // useless lsb() of byte value
+                    return listOf(IAstModification.ReplaceNode(functionCall, arg, parent))
+                }
+            }
+        }
+        else if(functionCall.target.nameInSource == listOf("msb")) {
+            val arg = functionCall.args[0]
+            if(arg is TypecastExpression) {
+                val valueDt = arg.expression.inferType(program)
+                if (valueDt.istype(DataType.BYTE) || valueDt.istype(DataType.UBYTE)) {
+                    // useless msb() of byte value that was casted to word, replace with 0
+                    return listOf(IAstModification.ReplaceNode(
+                            functionCall,
+                            NumericLiteralValue(valueDt.typeOrElse(DataType.UBYTE), 0, arg.expression.position),
+                            parent))
+                }
+            } else {
+                val argDt = arg.inferType(program)
+                if (argDt.istype(DataType.BYTE) || argDt.istype(DataType.UBYTE)) {
+                    // useless msb() of byte value, replace with 0
+                    return listOf(IAstModification.ReplaceNode(
+                            functionCall,
+                            NumericLiteralValue(argDt.typeOrElse(DataType.UBYTE), 0, arg.position),
+                            parent))
+                }
+            }
+        }
+
+        return noModifications
+    }
+
     private fun determineY(x: Expression, subBinExpr: BinaryExpression): Expression? {
         return when {
             subBinExpr.left isSameAs x -> subBinExpr.right

compiler/src/prog8/optimizer/Extensions.kt

@@ -5,20 +5,31 @@ import prog8.ast.base.ErrorReporter
 
 
 internal fun Program.constantFold(errors: ErrorReporter) {
-    val replacer = ConstantIdentifierReplacer(this, errors)
+    val valuetypefixer = VarConstantValueTypeAdjuster(this, errors)
-    replacer.visit(this)
+    valuetypefixer.visit(this)
     if(errors.isEmpty()) {
-        replacer.applyModifications()
+        valuetypefixer.applyModifications()
 
-        val optimizer = ConstantFoldingOptimizer(this)
+        val replacer = ConstantIdentifierReplacer(this, errors)
-        optimizer.visit(this)
+        replacer.visit(this)
-        while (errors.isEmpty() && optimizer.applyModifications() > 0) {
+        if (errors.isEmpty()) {
-            optimizer.visit(this)
-        }
-
-        if(errors.isEmpty()) {
-            replacer.visit(this)
             replacer.applyModifications()
+
+            valuetypefixer.visit(this)
+            if(errors.isEmpty()) {
+                valuetypefixer.applyModifications()
+
+                val optimizer = ConstantFoldingOptimizer(this)
+                optimizer.visit(this)
+                while (errors.isEmpty() && optimizer.applyModifications() > 0) {
+                    optimizer.visit(this)
+                }
+
+                if (errors.isEmpty()) {
+                    replacer.visit(this)
+                    replacer.applyModifications()
+                }
+            }
         }
     }
 
@@ -42,3 +53,9 @@ internal fun Program.simplifyExpressions() : Int {
     opti.visit(this)
     return opti.applyModifications()
 }
+
+internal fun Program.splitBinaryExpressions() : Int {
+    val opti = BinExprSplitter(this)
+    opti.visit(this)
+    return opti.applyModifications()
+}

compiler/src/prog8/optimizer/StatementOptimizer.kt

@@ -49,11 +49,6 @@ internal class StatementOptimizer(private val program: Program,
             }
         }
 
-        val linesToRemove = deduplicateAssignments(subroutine.statements)
-        if(linesToRemove.isNotEmpty()) {
-            linesToRemove.reversed().forEach{subroutine.statements.removeAt(it)}
-        }
-
         if(subroutine !in callgraph.usedSymbols && !forceOutput) {
             errors.warn("removing unused subroutine '${subroutine.name}'", subroutine.position)
             return listOf(IAstModification.Remove(subroutine, parent))
@@ -62,11 +57,6 @@ internal class StatementOptimizer(private val program: Program,
         return noModifications
     }
 
-    override fun after(scope: AnonymousScope, parent: Node): Iterable<IAstModification> {
-        val linesToRemove = deduplicateAssignments(scope.statements)
-        return linesToRemove.reversed().map { IAstModification.Remove(scope.statements[it], scope) }
-    }
-
     override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
         val forceOutput = "force_output" in decl.definingBlock().options()
         if(decl !in callgraph.usedSymbols && !forceOutput) {
@@ -104,7 +94,7 @@ internal class StatementOptimizer(private val program: Program,
                 if(string!=null) {
                     val pos = functionCallStatement.position
                     if (string.value.length == 1) {
-                        val firstCharEncoded = CompilationTarget.encodeString(string.value, string.altEncoding)[0]
+                        val firstCharEncoded = CompilationTarget.instance.encodeString(string.value, string.altEncoding)[0]
                         val chrout = FunctionCallStatement(
                                 IdentifierReference(listOf("c64", "CHROUT"), pos),
                                 mutableListOf(NumericLiteralValue(DataType.UBYTE, firstCharEncoded.toInt(), pos)),
@@ -112,7 +102,7 @@ internal class StatementOptimizer(private val program: Program,
                         )
                         return listOf(IAstModification.ReplaceNode(functionCallStatement, chrout, parent))
                     } else if (string.value.length == 2) {
-                        val firstTwoCharsEncoded = CompilationTarget.encodeString(string.value.take(2), string.altEncoding)
+                        val firstTwoCharsEncoded = CompilationTarget.instance.encodeString(string.value.take(2), string.altEncoding)
                         val chrout1 = FunctionCallStatement(
                                 IdentifierReference(listOf("c64", "CHROUT"), pos),
                                 mutableListOf(NumericLiteralValue(DataType.UBYTE, firstTwoCharsEncoded[0].toInt(), pos)),
@@ -220,7 +210,7 @@ internal class StatementOptimizer(private val program: Program,
                 val size = sv.value.length
                 if(size==1) {
                     // loop over string of length 1 -> just assign the single character
-                    val character = CompilationTarget.encodeString(sv.value, sv.altEncoding)[0]
+                    val character = CompilationTarget.instance.encodeString(sv.value, sv.altEncoding)[0]
                     val byte = NumericLiteralValue(DataType.UBYTE, character, iterable.position)
                     val scope = AnonymousScope(mutableListOf(), forLoop.position)
                     scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), byte, forLoop.position))
@@ -249,11 +239,11 @@ internal class StatementOptimizer(private val program: Program,
     }
 
     override fun before(untilLoop: UntilLoop, parent: Node): Iterable<IAstModification> {
-        val constvalue = untilLoop.untilCondition.constValue(program)
+        val constvalue = untilLoop.condition.constValue(program)
         if(constvalue!=null) {
             if(constvalue.asBooleanValue) {
                 // always true -> keep only the statement block (if there are no break statements)
-                errors.warn("condition is always true", untilLoop.untilCondition.position)
+                errors.warn("condition is always true", untilLoop.condition.position)
                 if(!hasBreak(untilLoop.body))
                     return listOf(IAstModification.ReplaceNode(untilLoop, untilLoop.body, parent))
             } else {
@@ -395,21 +385,21 @@ internal class StatementOptimizer(private val program: Program,
         val targetDt = targetIDt.typeOrElse(DataType.STRUCT)
         val bexpr=assignment.value as? BinaryExpression
         if(bexpr!=null) {
-            val cv = bexpr.right.constValue(program)?.number?.toDouble()
+            val rightCv = bexpr.right.constValue(program)?.number?.toDouble()
-            if (cv != null && assignment.target isSameAs bexpr.left) {
+            if (rightCv != null && assignment.target isSameAs bexpr.left) {
                 // assignments of the form:  X = X <operator> <expr>
                 // remove assignments that have no effect (such as X=X+0)
                 // optimize/rewrite some other expressions
                 val vardeclDt = (assignment.target.identifier?.targetVarDecl(program.namespace))?.type
                 when (bexpr.operator) {
                     "+" -> {
-                        if (cv == 0.0) {
+                        if (rightCv == 0.0) {
                             return listOf(IAstModification.Remove(assignment, parent))
-                        } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
+                        } else if (targetDt in IntegerDatatypes && floor(rightCv) == rightCv) {
-                            if (vardeclDt != VarDeclType.MEMORY && cv in 1.0..4.0) {
+                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..4.0) {
                                 // replace by several INCs if it's not a memory address (inc on a memory mapped register doesn't work very well)
                                 val incs = AnonymousScope(mutableListOf(), assignment.position)
-                                repeat(cv.toInt()) {
+                                repeat(rightCv.toInt()) {
                                     incs.statements.add(PostIncrDecr(assignment.target, "++", assignment.position))
                                 }
                                 return listOf(IAstModification.ReplaceNode(assignment, incs, parent))
@@ -417,62 +407,38 @@ internal class StatementOptimizer(private val program: Program,
                         }
                     }
                     "-" -> {
-                        if (cv == 0.0) {
+                        if (rightCv == 0.0) {
                             return listOf(IAstModification.Remove(assignment, parent))
-                        } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
+                        } else if (targetDt in IntegerDatatypes && floor(rightCv) == rightCv) {
-                            if (vardeclDt != VarDeclType.MEMORY && cv in 1.0..4.0) {
+                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..4.0) {
                                 // replace by several DECs if it's not a memory address (dec on a memory mapped register doesn't work very well)
                                 val decs = AnonymousScope(mutableListOf(), assignment.position)
-                                repeat(cv.toInt()) {
+                                repeat(rightCv.toInt()) {
                                     decs.statements.add(PostIncrDecr(assignment.target, "--", assignment.position))
                                 }
                                 return listOf(IAstModification.ReplaceNode(assignment, decs, parent))
                             }
                         }
                     }
-                    "*" -> if (cv == 1.0) return listOf(IAstModification.Remove(assignment, parent))
+                    "*" -> if (rightCv == 1.0) return listOf(IAstModification.Remove(assignment, parent))
-                    "/" -> if (cv == 1.0) return listOf(IAstModification.Remove(assignment, parent))
+                    "/" -> if (rightCv == 1.0) return listOf(IAstModification.Remove(assignment, parent))
-                    "**" -> if (cv == 1.0) return listOf(IAstModification.Remove(assignment, parent))
+                    "**" -> if (rightCv == 1.0) return listOf(IAstModification.Remove(assignment, parent))
-                    "|" -> if (cv == 0.0) return listOf(IAstModification.Remove(assignment, parent))
+                    "|" -> if (rightCv == 0.0) return listOf(IAstModification.Remove(assignment, parent))
-                    "^" -> if (cv == 0.0) return listOf(IAstModification.Remove(assignment, parent))
+                    "^" -> if (rightCv == 0.0) return listOf(IAstModification.Remove(assignment, parent))
                     "<<" -> {
-                        if (cv == 0.0)
+                        if (rightCv == 0.0)
                             return listOf(IAstModification.Remove(assignment, parent))
                     }
                     ">>" -> {
-                        if (cv == 0.0)
+                        if (rightCv == 0.0)
                             return listOf(IAstModification.Remove(assignment, parent))
                     }
                 }
 
             }
         }
-        return noModifications
-    }
 
-    private fun deduplicateAssignments(statements: List<Statement>): MutableList<Int> {
+        return noModifications
-        // removes 'duplicate' assignments that assign the isSameAs target
-        val linesToRemove = mutableListOf<Int>()
-        var previousAssignmentLine: Int? = null
-        for (i in statements.indices) {
-            val stmt = statements[i] as? Assignment
-            if (stmt != null && stmt.value is NumericLiteralValue) {
-                if (previousAssignmentLine == null) {
-                    previousAssignmentLine = i
-                    continue
-                } else {
-                    val prev = statements[previousAssignmentLine] as Assignment
-                    if (prev.target.isSameAs(stmt.target, program)) {
-                        // get rid of the previous assignment, if the target is not MEMORY
-                        if (prev.target.isNotMemory(program.namespace))
-                            linesToRemove.add(previousAssignmentLine)
-                    }
-                    previousAssignmentLine = i
-                }
-            } else
-                previousAssignmentLine = null
-        }
-        return linesToRemove
     }
 
     private fun hasBreak(scope: INameScope): Boolean {

compiler/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -8,7 +8,8 @@ import prog8.ast.processing.AstWalker
 import prog8.ast.processing.IAstModification
 import prog8.ast.statements.*
 
-internal class UnusedCodeRemover(private val errors: ErrorReporter): AstWalker() {
+
+internal class UnusedCodeRemover(private val program: Program, private val errors: ErrorReporter): AstWalker() {
 
     override fun before(program: Program, parent: Node): Iterable<IAstModification> {
         val callgraph = CallGraph(program)
@@ -66,4 +67,35 @@ internal class UnusedCodeRemover(private val errors: ErrorReporter): AstWalker()
             else -> errors.warn("unreachable code", next.position)
         }
     }
+
+    override fun after(scope: AnonymousScope, parent: Node): Iterable<IAstModification> {
+        val removeDoubleAssignments = deduplicateAssignments(scope.statements)
+        return removeDoubleAssignments.map { IAstModification.Remove(it, scope) }
+    }
+
+    override fun after(block: Block, parent: Node): Iterable<IAstModification> {
+        val removeDoubleAssignments = deduplicateAssignments(block.statements)
+        return removeDoubleAssignments.map { IAstModification.Remove(it, block) }
+    }
+
+    override fun after(subroutine: Subroutine, parent: Node): Iterable<IAstModification> {
+        val removeDoubleAssignments = deduplicateAssignments(subroutine.statements)
+        return removeDoubleAssignments.map { IAstModification.Remove(it, subroutine) }
+    }
+
+    private fun deduplicateAssignments(statements: List<Statement>): List<Assignment> {
+        // removes 'duplicate' assignments that assign the same target directly after another
+        val linesToRemove = mutableListOf<Assignment>()
+
+        for (stmtPairs in statements.windowed(2, step = 1)) {
+            val assign1 = stmtPairs[0] as? Assignment
+            val assign2 = stmtPairs[1] as? Assignment
+            if (assign1 != null && assign2 != null && !assign2.isAugmentable) {
+                if (assign1.target.isSameAs(assign2.target, program) && assign1.target.isInRegularRAM(program.namespace))
+                    linesToRemove.add(assign1)
+            }
+        }
+
+        return linesToRemove
+    }
 }

compiler/src/prog8/parser/ModuleParsing.kt

@@ -9,6 +9,7 @@ import prog8.ast.base.SyntaxError
 import prog8.ast.base.checkImportedValid
 import prog8.ast.statements.Directive
 import prog8.ast.statements.DirectiveArg
+import prog8.compiler.target.CompilationTarget
 import prog8.pathFrom
 import java.io.InputStream
 import java.nio.file.Files
@@ -19,14 +20,6 @@ import java.nio.file.Paths
 internal class ParsingFailedError(override var message: String) : Exception(message)
 
 
-private class LexerErrorListener: BaseErrorListener() {
-    var  numberOfErrors: Int = 0
-    override fun syntaxError(p0: Recognizer<*, *>?, p1: Any?, p2: Int, p3: Int, p4: String?, p5: RecognitionException?) {
-        numberOfErrors++
-    }
-}
-
-
 internal class CustomLexer(val modulePath: Path, input: CharStream?) : prog8Lexer(input)
 
 
@@ -60,13 +53,28 @@ internal class ModuleImporter {
         return executeImportDirective(program, import, Paths.get(""))
     }
 
+    private class MyErrorListener: ConsoleErrorListener() {
+        var  numberOfErrors: Int = 0
+        override fun syntaxError(recognizer: Recognizer<*, *>?, offendingSymbol: Any?, line: Int, charPositionInLine: Int, msg: String, e: RecognitionException?) {
+            numberOfErrors++
+            when (recognizer) {
+                is CustomLexer -> System.err.println("${recognizer.modulePath}:$line:$charPositionInLine: $msg")
+                is prog8Parser -> System.err.println("${recognizer.inputStream.sourceName}:$line:$charPositionInLine: $msg")
+                else -> System.err.println("$line:$charPositionInLine $msg")
+            }
+        }
+    }
+
     private fun importModule(program: Program, stream: CharStream, modulePath: Path, isLibrary: Boolean): Module {
         val moduleName = moduleName(modulePath.fileName)
         val lexer = CustomLexer(modulePath, stream)
-        val lexerErrors = LexerErrorListener()
+        lexer.removeErrorListeners()
+        val lexerErrors = MyErrorListener()
         lexer.addErrorListener(lexerErrors)
         val tokens = CommentHandlingTokenStream(lexer)
         val parser = prog8Parser(tokens)
+        parser.removeErrorListeners()
+        parser.addErrorListener(MyErrorListener())
         val parseTree = parser.module()
         val numberOfErrors = parser.numberOfSyntaxErrors + lexerErrors.numberOfErrors
         if(numberOfErrors > 0)
@@ -123,13 +131,14 @@ internal class ModuleImporter {
         if(existing!=null)
             return null
 
-        val resource = tryGetEmbeddedResource("$moduleName.p8")
+        val rsc = tryGetEmbeddedResource("$moduleName.p8")
         val importedModule =
-                if(resource!=null) {
+                if(rsc!=null) {
                     // load the module from the embedded resource
+                    val (resource, resourcePath) = rsc
                     resource.use {
                         println("importing '$moduleName' (library)")
-                        importModule(program, CharStreams.fromStream(it), Paths.get("@embedded@/$moduleName"), true)
+                        importModule(program, CharStreams.fromStream(it), Paths.get("@embedded@/$resourcePath"), true)
                     }
                 } else {
                     val modulePath = discoverImportedModuleFile(moduleName, source, import.position)
@@ -140,7 +149,18 @@ internal class ModuleImporter {
         return importedModule
     }
 
-    private fun tryGetEmbeddedResource(name: String): InputStream? {
+    private fun tryGetEmbeddedResource(name: String): Pair<InputStream, String>? {
-        return object{}.javaClass.getResourceAsStream("/prog8lib/$name")
+        val target = CompilationTarget.instance.name
+        val targetSpecificPath = "/prog8lib/$target/$name"
+        val targetSpecificResource = object{}.javaClass.getResourceAsStream(targetSpecificPath)
+        if(targetSpecificResource!=null)
+            return Pair(targetSpecificResource, targetSpecificPath)
+
+        val generalPath = "/prog8lib/$name"
+        val generalResource = object{}.javaClass.getResourceAsStream(generalPath)
+        if(generalResource!=null)
+            return Pair(generalResource, generalPath)
+
+        return null
     }
 }

compiler/test/UnitTests.kt

@@ -5,18 +5,21 @@ import org.hamcrest.Matchers.closeTo
 import org.hamcrest.Matchers.equalTo
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import prog8.ast.base.DataType
+import prog8.ast.Module
-import prog8.ast.base.ErrorReporter
+import prog8.ast.Program
-import prog8.ast.base.Position
+import prog8.ast.base.*
-import prog8.ast.expressions.NumericLiteralValue
+import prog8.ast.expressions.*
-import prog8.ast.expressions.StringLiteralValue
+import prog8.ast.statements.*
 import prog8.compiler.*
+import prog8.compiler.target.C64Target
+import prog8.compiler.target.CompilationTarget
 import prog8.compiler.target.c64.C64MachineDefinition.C64Zeropage
 import prog8.compiler.target.c64.C64MachineDefinition.FLOAT_MAX_NEGATIVE
 import prog8.compiler.target.c64.C64MachineDefinition.FLOAT_MAX_POSITIVE
 import prog8.compiler.target.c64.C64MachineDefinition.Mflpt5
 import prog8.compiler.target.c64.Petscii
 import java.io.CharConversionException
+import java.nio.file.Path
 import kotlin.test.*
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
@@ -129,7 +132,7 @@ class TestC64Zeropage {
 
     @Test
     fun testNames() {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, false))
 
         zp.allocate("", DataType.UBYTE, null, errors)
         zp.allocate("", DataType.UBYTE, null, errors)
@@ -142,37 +145,37 @@ class TestC64Zeropage {
 
     @Test
     fun testZpFloatEnable() {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false))
         assertFailsWith<CompilerException> {
             zp.allocate("", DataType.FLOAT, null, errors)
         }
-        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), true))
+        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), true, false))
         assertFailsWith<CompilerException> {
             zp2.allocate("", DataType.FLOAT, null, errors)
         }
-        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true))
+        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true, false))
         zp3.allocate("", DataType.FLOAT, null, errors)
     }
 
     @Test
     fun testZpModesWithFloats() {
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, false))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false, false))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true, false))
         assertFailsWith<CompilerException> {
-            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), true))
+            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), true, false))
         }
         assertFailsWith<CompilerException> {
-            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), true))
+            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), true, false))
         }
     }
 
     @Test
     fun testZpDontuse() {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), false))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), false, false))
         println(zp.free)
         assertEquals(0, zp.available())
         assertFailsWith<CompilerException> {
@@ -182,19 +185,19 @@ class TestC64Zeropage {
 
     @Test
     fun testFreeSpaces() {
-        val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true))
+        val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false))
         assertEquals(16, zp1.available())
-        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false))
+        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false, false))
-        assertEquals(91, zp2.available())
+        assertEquals(89, zp2.available())
-        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false))
+        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false))
         assertEquals(125, zp3.available())
-        val zp4 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
+        val zp4 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false))
         assertEquals(238, zp4.available())
     }
 
     @Test
     fun testReservedSpace() {
-        val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
+        val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false))
         assertEquals(238, zp1.available())
         assertTrue(50 in zp1.free)
         assertTrue(100 in zp1.free)
@@ -203,7 +206,7 @@ class TestC64Zeropage {
         assertTrue(200 in zp1.free)
         assertTrue(255 in zp1.free)
         assertTrue(199 in zp1.free)
-        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, listOf(50 .. 100, 200..255), false))
+        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, listOf(50 .. 100, 200..255), false, false))
         assertEquals(139, zp2.available())
         assertFalse(50 in zp2.free)
         assertFalse(100 in zp2.free)
@@ -216,7 +219,7 @@ class TestC64Zeropage {
 
     @Test
     fun testBasicsafeAllocation() {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false))
         assertEquals(16, zp.available())
 
         assertFailsWith<ZeropageDepletedError> {
@@ -239,7 +242,7 @@ class TestC64Zeropage {
 
     @Test
     fun testFullAllocation() {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false))
         assertEquals(238, zp.available())
         val loc = zp.allocate("", DataType.UWORD, null, errors)
         assertTrue(loc > 3)
@@ -269,7 +272,7 @@ class TestC64Zeropage {
 
     @Test
     fun testEfficientAllocation() {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(),  true))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(),  true, false))
         assertEquals(16, zp.available())
         assertEquals(0x04, zp.allocate("", DataType.WORD, null, errors))
         assertEquals(0x06, zp.allocate("", DataType.UBYTE, null, errors))
@@ -379,3 +382,169 @@ class TestPetscii {
         assertFalse(abc!=abc)
     }
 }
+
+
+class TestMemory {
+    @Test
+    fun testInValidRamC64_memory_addresses() {
+        CompilationTarget.instance = C64Target
+
+        var memexpr = NumericLiteralValue.optimalInteger(0x0000, Position.DUMMY)
+        var target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
+        var scope = AnonymousScope(mutableListOf(), Position.DUMMY)
+        assertTrue(target.isInRegularRAM(scope))
+
+        memexpr = NumericLiteralValue.optimalInteger(0x1000, Position.DUMMY)
+        target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
+        scope = AnonymousScope(mutableListOf(), Position.DUMMY)
+        assertTrue(target.isInRegularRAM(scope))
+
+        memexpr = NumericLiteralValue.optimalInteger(0x9fff, Position.DUMMY)
+        target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
+        scope = AnonymousScope(mutableListOf(), Position.DUMMY)
+        assertTrue(target.isInRegularRAM(scope))
+
+        memexpr = NumericLiteralValue.optimalInteger(0xc000, Position.DUMMY)
+        target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
+        scope = AnonymousScope(mutableListOf(), Position.DUMMY)
+        assertTrue(target.isInRegularRAM(scope))
+
+        memexpr = NumericLiteralValue.optimalInteger(0xcfff, Position.DUMMY)
+        target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
+        scope = AnonymousScope(mutableListOf(), Position.DUMMY)
+        assertTrue(target.isInRegularRAM(scope))
+    }
+
+    @Test
+    fun testNotInValidRamC64_memory_addresses() {
+        CompilationTarget.instance = C64Target
+
+        var memexpr = NumericLiteralValue.optimalInteger(0xa000, Position.DUMMY)
+        var target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
+        var scope = AnonymousScope(mutableListOf(), Position.DUMMY)
+        assertFalse(target.isInRegularRAM(scope))
+
+        memexpr = NumericLiteralValue.optimalInteger(0xafff, Position.DUMMY)
+        target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
+        scope = AnonymousScope(mutableListOf(), Position.DUMMY)
+        assertFalse(target.isInRegularRAM(scope))
+
+        memexpr = NumericLiteralValue.optimalInteger(0xd000, Position.DUMMY)
+        target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
+        scope = AnonymousScope(mutableListOf(), Position.DUMMY)
+        assertFalse(target.isInRegularRAM(scope))
+
+        memexpr = NumericLiteralValue.optimalInteger(0xffff, Position.DUMMY)
+        target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
+        scope = AnonymousScope(mutableListOf(), Position.DUMMY)
+        assertFalse(target.isInRegularRAM(scope))
+    }
+
+    @Test
+    fun testInValidRamC64_memory_identifiers() {
+        CompilationTarget.instance = C64Target
+        var target = createTestProgramForMemoryRefViaVar(0x1000, VarDeclType.VAR)
+        assertTrue(target.isInRegularRAM(target.definingScope()))
+        target = createTestProgramForMemoryRefViaVar(0xd020, VarDeclType.VAR)
+        assertFalse(target.isInRegularRAM(target.definingScope()))
+        target = createTestProgramForMemoryRefViaVar(0x1000, VarDeclType.CONST)
+        assertTrue(target.isInRegularRAM(target.definingScope()))
+        target = createTestProgramForMemoryRefViaVar(0xd020, VarDeclType.CONST)
+        assertFalse(target.isInRegularRAM(target.definingScope()))
+        target = createTestProgramForMemoryRefViaVar(0x1000, VarDeclType.MEMORY)
+        assertFalse(target.isInRegularRAM(target.definingScope()))
+    }
+
+    @Test
+    private fun createTestProgramForMemoryRefViaVar(address: Int, vartype: VarDeclType): AssignTarget {
+        val decl = VarDecl(vartype, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", null, NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
+        val memexpr = IdentifierReference(listOf("address"), Position.DUMMY)
+        val target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        subroutine.linkParents(ParentSentinel)
+        return target
+    }
+
+    @Test
+    fun testInValidRamC64_memory_expression() {
+        CompilationTarget.instance = C64Target
+        val memexpr = PrefixExpression("+", NumericLiteralValue.optimalInteger(0x1000, Position.DUMMY), Position.DUMMY)
+        val target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
+        val scope = AnonymousScope(mutableListOf(), Position.DUMMY)
+        assertFalse(target.isInRegularRAM(scope))
+    }
+
+    @Test
+    fun testInValidRamC64_variable() {
+        CompilationTarget.instance = C64Target
+        val decl = VarDecl(VarDeclType.VAR, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", null, null, false, false, Position.DUMMY)
+        val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        subroutine.linkParents(ParentSentinel)
+        assertTrue(target.isInRegularRAM(target.definingScope()))
+    }
+
+    @Test
+    fun testInValidRamC64_memmap_variable() {
+        CompilationTarget.instance = C64Target
+        val address = 0x1000
+        val decl = VarDecl(VarDeclType.MEMORY, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", null, NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
+        val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        subroutine.linkParents(ParentSentinel)
+        assertTrue(target.isInRegularRAM(target.definingScope()))
+    }
+
+    @Test
+    fun testNotInValidRamC64_memmap_variable() {
+        CompilationTarget.instance = C64Target
+        val address = 0xd020
+        val decl = VarDecl(VarDeclType.MEMORY, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", null, NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
+        val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        subroutine.linkParents(ParentSentinel)
+        assertFalse(target.isInRegularRAM(target.definingScope()))
+    }
+
+    @Test
+    fun testInValidRamC64_array() {
+        CompilationTarget.instance = C64Target
+        val decl = VarDecl(VarDeclType.VAR, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, null, false, false, Position.DUMMY)
+        val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
+        val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        subroutine.linkParents(ParentSentinel)
+        assertTrue(target.isInRegularRAM(target.definingScope()))
+    }
+
+    @Test
+    fun testInValidRamC64_array_memmapped() {
+        CompilationTarget.instance = C64Target
+        val address = 0x1000
+        val decl = VarDecl(VarDeclType.MEMORY, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
+        val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
+        val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        subroutine.linkParents(ParentSentinel)
+        assertTrue(target.isInRegularRAM(target.definingScope()))
+    }
+
+    @Test
+    fun testNotValidRamC64_array_memmapped() {
+        CompilationTarget.instance = C64Target
+        val address = 0xe000
+        val decl = VarDecl(VarDeclType.MEMORY, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
+        val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
+        val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        subroutine.linkParents(ParentSentinel)
+        assertFalse(target.isInRegularRAM(target.definingScope()))
+    }
+}

docs/source/building.rst

@@ -149,10 +149,10 @@ If your running program hits one of the breakpoints, Vice will halt execution an
 Troubleshooting
 ---------------
 
-Getting an assembler error about undefined symbols such as ``not defined 'c64flt'``?
+Getting an assembler error about undefined symbols such as ``not defined 'floats'``?
-This happens when your program uses floating point values, and you forgot to import ``c64flt`` library.
+This happens when your program uses floating point values, and you forgot to import ``floats`` library.
 If you use floating points, the compiler needs routines from that library.
-Fix it by adding an ``%import c64flt``.
+Fix it by adding an ``%import floats``.
 
 
 Examples

docs/source/index.rst

@@ -38,21 +38,22 @@ This software is licensed under the GNU GPL 3.0, see https://www.gnu.org/license
     :alt: Fully playable tetris clone
 
 
-Code examples
+Code example
--------------
+------------
 
 This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
 
-    %import c64textio
+    %import textio
     %zeropage basicsafe
 
     main {
-
         ubyte[256] sieve
-        ubyte candidate_prime = 2
+        ubyte candidate_prime = 2       ; is increased in the loop
 
         sub start() {
-            memset(sieve, 256, false)   ; clear the sieve
+            ; clear the sieve, to reset starting situation on subsequent runs
+            memset(sieve, 256, false)
+            ; calculate primes
             txt.print("prime numbers up to 255:\n\n")
             ubyte amount=0
             repeat {
@@ -63,18 +64,19 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
                 txt.print(", ")
                 amount++
             }
-            c64.CHROUT('\n')
+            txt.chrout('\n')
             txt.print("number of primes (expected 54): ")
             txt.print_ub(amount)
-            c64.CHROUT('\n')
+            txt.chrout('\n')
         }
 
         sub find_next_prime() -> ubyte {
             while sieve[candidate_prime] {
                 candidate_prime++
                 if candidate_prime==0
-                    return 0        ; we wrapped; no more primes available
+                    return 0        ; we wrapped; no more primes available in the sieve
             }
+
             ; found next one, mark the multiples and return it.
             sieve[candidate_prime] = true
             uword multiple = candidate_prime
@@ -88,51 +90,19 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
     }
 
 
-
 when compiled an ran on a C-64 you get this:
 
 .. image:: _static/primes_example.png
     :align: center
     :alt: result when run on C-64
 
+when the exact same program is compiled for the Commander X16 target, and run on the emulator, you get this:
 
-The following programs shows a use of the high level ``struct`` type::
+.. image:: _static/primes_cx16.png
+    :align: center
+    :alt: result when run on CX16 emulator
 
 
-    %import c64textio
-    %zeropage basicsafe
-
-    main {
-
-        struct Color {
-            ubyte red
-            ubyte green
-            ubyte blue
-        }
-
-        sub start() {
-
-            Color purple = [255, 0, 255]
-
-            Color other
-
-            other = purple
-            other.red /= 2
-            other.green = 10 + other.green / 2
-            other.blue = 99
-
-            txt.print_ub(other.red)
-            c64.CHROUT(',')
-            txt.print_ub(other.green)
-            c64.CHROUT(',')
-            txt.print_ub(other.blue)
-            c64.CHROUT('\n')
-        }
-    }
-
-
-when compiled and ran, it prints  ``127,10,99`` on the screen.
-
 
 Design principles and features
 ------------------------------
@@ -162,6 +132,7 @@ Design principles and features
   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:

docs/source/programming.rst

@@ -226,7 +226,7 @@ This is because routines in the C-64 BASIC and KERNAL ROMs are used for that.
 So floating point operations will only work if the C-64 BASIC ROM (and KERNAL ROM)
 are banked in.
 
-Also your code needs to import the ``c64flt`` library to enable floating point support
+Also your code needs to import the ``floats`` library to enable floating point support
 in the compiler, and to gain access to the floating point routines.
 (this library contains the directive to enable floating points, you don't have
 to worry about this yourself)
@@ -236,12 +236,15 @@ The largest 5-byte MFLPT float that can be stored is: **1.7014118345e+38**   (ne
 
 Arrays
 ^^^^^^
-Array types are also supported. They can be made of bytes, words or floats::
+Array types are also supported. They can be made of bytes, words or floats, strings, and other arrays
+(although the usefulness of the latter is very limited for now)::
 
     byte[10]  array                   ; array of 10 bytes, initially set to 0
     byte[]  array = [1, 2, 3, 4]      ; initialize the array, size taken from value
     byte[99] array = 255              ; initialize array with 99 times 255 [255, 255, 255, 255, ...]
     byte[] array = 100 to 199         ; initialize array with [100, 101, ..., 198, 199]
+    str[] names = ["ally", "pete"]    ; array of string pointers/addresses (equivalent to uword)
+    uword[] others = [names, array]   ; array of pointers/addresses to other arrays
 
     value = array[3]            ; the fourth value in the array (index is 0-based)
     char = string[4]            ; the fifth character (=byte) in the string
@@ -257,6 +260,11 @@ Note that the various keywords for the data type and variable type (``byte``, ``
 can't be used as *identifiers* elsewhere. You can't make a variable, block or subroutine with the name ``byte``
 for instance.
 
+It's possible to assign a new array to another array, this will overwrite all elements in the original
+array with those in the value array. The number and types of elements have to match.
+For large arrays this is a slow operation because every element is copied over. It should probably be avoided.
+
+
 **Arrays at a specific memory location:**
 Using the memory-mapped syntax it is possible to define an array to be located at a specific memory location.
 For instance to reference the first 5 rows of the Commodore 64's screen matrix as an array, you can define::
@@ -284,7 +292,7 @@ This @-prefix can also be used for character byte values.
 You can concatenate two string literals using '+' (not very useful though) or repeat
 a string literal a given number of times using '*'. You can also assign a new string
 value to another string. No bounds check is done so be sure the destination string is
-large enough to contain the new value::
+large enough to contain the new value (it is overwritten in memory)::
 
     str string1 = "first part" + "second part"
     str string2 = "hello!" * 10
@@ -293,6 +301,18 @@ large enough to contain the new value::
     string1 = "new value"
 
 
+There are several 'escape sequences' to help you put special characters into strings, such
+as newlines, quote characters themselves, and so on. The ones used most often are
+``\\``, ``\"``, ``\n``, ``\r``.  For a detailed description of all of them and what they mean,
+read the syntax reference on strings.
+
+
+.. note::
+    Strings 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.
+
 .. 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
@@ -327,7 +347,7 @@ and then create a variable with it::
         ubyte blue
     }
 
-    Color rgb = {255,122,0}     ; note the curly braces here instead of brackets
+    Color rgb = [255,122,0]     ; note that struct initializer value is same as an array
     Color another               ; the init value is optional, like arrays
 
     another = rgb           ; assign all of the values of rgb to another
@@ -578,25 +598,24 @@ within parentheses will be evaluated first. So ``(4 + 8) * 2`` is 24 and not 20,
 and ``(true or false) and false`` is false instead of true.
 
 .. attention::
-    **calculations keep their datatype:**
+    **calculations keep their datatype even if the target variable is larger:**
     When you do calculations on a BYTE type, the result will remain a BYTE.
     When you do calculations on a WORD type, the result will remain a WORD.
     For instance::
 
         byte b = 44
         word w = b*55   ; the result will be 116! (even though the target variable is a word)
-        w *= 999        ; the result will be -15188  (the multiplication stays within a word)
+        w *= 999        ; the result will be -15188  (the multiplication stays within a word, but overflows)
 
-    The compiler will NOT give a warning about this! It's doing this for
+    *The compiler does NOT warn about this!* It's doing this for
     performance reasons - so you won't get sudden 16 bit (or even float)
     calculations where you needed only simple fast byte arithmetic.
     If you do need the extended resulting value, cast at least one of the
-    operands of an operator to the larger datatype. For example::
+    operands explicitly to the larger datatype. For example::
 
         byte b = 44
-        word w = b*55.w     ; the result will be 2420
+        w = (b as word)*55
-        w = (b as word)*55  ; same result
+        w = b*(55 as word)
-
 
 
 
@@ -719,7 +738,7 @@ sort(array)
     floating point values.
 
 reverse(array)
-    Reverse the values in the array (in-place). Supports all data types including floats.
+    Reverse the values in the array (in-place).
     Can be used after sort() to sort an array in descending order.
 
 len(x)
@@ -803,7 +822,7 @@ memset(address, numbytes, bytevalue)
     Efficiently set a part of memory to the given (u)byte value.
     But the most efficient will always be to write a specialized fill routine in assembly yourself!
     Note that for clearing the character screen, very fast specialized subroutines are
-    available in the ``screen`` block (part of the ``c64textio`` or ``cx16textio`` modules)
+    available in the ``txt`` block (part of the ``textio`` module)
 
 memsetw(address, numwords, wordvalue)
     Efficiently set a part of memory to the given (u)word value.

docs/source/syntaxreference.rst

@@ -33,6 +33,13 @@ This makes it easier to understand and relate the generated code. Examples::
 Directives
 -----------
 
+.. data:: %target <target>
+
+    Level: module.
+    Global setting, specifies that this module can only work for the given compiler target.
+    If compiled with a different target, compilation is aborted with an error message.
+
+
 .. data:: %output <type>
 
 	Level: module.
@@ -60,7 +67,8 @@ Directives
     - style ``kernalsafe`` -- use the part of the ZP that is 'free' or only used by BASIC routines,
       and don't change anything else.  This allows full use of KERNAL ROM routines (but not BASIC routines),
       including default IRQs during normal system operation.
-      When the program exits, a system reset is performed (because BASIC will be in a corrupt state).
+      It's not possible to return cleanly to BASIC when the program exits. The only choice is
+      to perform a system reset. (A ``system_reset`` subroutine is available in the syslib to help you do this)
     - style ``floatsafe`` -- like the previous one but also reserves the addresses that
       are required to perform floating point operations (from the BASIC kernel). No clean exit is possible.
     - style ``basicsafe`` -- the most restricted mode; only use the handful 'free' addresses in the ZP, and don't
@@ -70,10 +78,11 @@ Directives
     - style ``full`` -- claim the whole ZP for variables for the program, overwriting everything,
       except the few addresses mentioned above that are used by the system's IRQ routine.
       Even though the default IRQ routine is still active, it is impossible to use most BASIC and KERNAL ROM routines.
-      This includes many floating point operations and several utility routines that do I/O, such as ``print_string``.
+      This includes many floating point operations and several utility routines that do I/O, such as ``print``.
-      As with ``kernalsafe``, it is not possible to cleanly exit the program, other than to reset the machine.
       This option makes programs smaller and faster because even more variables can
       be stored in the ZP (which allows for more efficient assembly code).
+      It's not possible to return cleanly to BASIC when the program exits. The only choice is
+      to perform a system reset. (A ``system_reset`` subroutine is available in the syslib to help you do this)
     - style ``dontuse`` -- don't use *any* location in the zeropage.
 
     Also read :ref:`zeropage`.
@@ -110,33 +119,38 @@ Directives
 
 	Level: module, block.
 	Sets special compiler options.
-	For a module option, only the ``enable_floats`` option is recognised, which will tell the compiler
+
-	to deal with floating point numbers (by using various subroutines from the Commodore-64 kernal).
+    - For a module option, there is ``enable_floats``, which will tell the compiler
-	Otherwise, floating point support is not enabled.
+      to deal with floating point numbers (by using various subroutines from the Commodore-64 kernal).
-	When used in a block with the ``force_output`` option, it will force the block to be outputted
+      Otherwise, floating point support is not enabled.
-	in the final program. Can be useful to make sure some
+    - There's also ``no_sysinit`` which cause the resulting program to *not* include
-	data is generated that would otherwise be discarded because it's not referenced (such as sprite data).
+      the system re-initialization logic of clearing the screen, resetting I/O config etc. You'll have to
+      take care of that yourself. The program will just start running from whatever state the machine is in when the
+      program was launched.
+    - When used in a block with the ``force_output`` option, it will force the block to be outputted
+      in the final program. Can be useful to make sure some
+      data is generated that would otherwise be discarded because it's not referenced (such as sprite data).
 
 
 .. data:: %asmbinary "<filename>" [, <offset>[, <length>]]
 
-	Level: block.
+    Level: block.
-        This directive can only be used inside a block.
+    This directive can only be used inside a block.
-        The assembler will include the file as binary bytes at this point, prog8 will not process this at all.
+    The assembler will include the file as binary bytes at this point, prog8 will not process this at all.
-        The optional offset and length can be used to select a particular piece of the file.
+    The optional offset and length can be used to select a particular piece of the file.
-        The file is located relative to the current working directory!
+    The file is located relative to the current working directory!
 
 .. data:: %asminclude "<filename>", "scopelabel"
 
-	Level: block.
+    Level: block.
-        This directive can only be used inside a block.
+    This directive can only be used inside a block.
-        The assembler will include the file as raw assembly source text at this point,
+    The assembler will include the file as raw assembly source text at this point,
-        prog8 will not process this at all, with one exception: the labels.
+    prog8 will not process this at all, with one exception: the labels.
-        The scopelabel argument will be used as a prefix to access the labels from the included source code,
+    The scopelabel argument will be used as a prefix to access the labels from the included source code,
-        otherwise you would risk symbol redefinitions or duplications.
+    otherwise you would risk symbol redefinitions or duplications.
-        If you know what you are doing you can leave it as an empty string to not have a scope prefix.
+    If you know what you are doing you can leave it as an empty string to not have a scope prefix.
-        The compiler first looks for the file relative to the same directory as the module containing this statement is in,
+    The compiler first looks for the file relative to the same directory as the module containing this statement is in,
-        if the file can't be found there it is searched relative to the current directory.
+    if the file can't be found there it is searched relative to the current directory.
 
 .. data:: %breakpoint
 
@@ -267,6 +281,7 @@ type identifier  type                     storage size       example var declara
 ``word[]``       signed word array        depends on value   ``word[] myvar = [1, 2, 3, 4]``
 ``uword[]``      unsigned word array      depends on value   ``uword[] myvar = [1, 2, 3, 4]``
 ``float[]``      floating-point array     depends on value   ``float[] myvar = [1.1, 2.2, 3.3, 4.4]``
+``str[]``        array with string ptrs   2*x bytes + strs   ``str[] names = ["ally", "pete"]``
 ``str``          string (petscii)         varies             ``str myvar = "hello."``
                                                              implicitly terminated by a 0-byte
 ===============  =======================  =================  =========================================
@@ -289,7 +304,8 @@ of something with an operand starting with 1 or 0, you'll have to add a space in
 - When an integer value ranges from 256..65535 the compiler sees it as a ``uword``.  For -32768..32767 it's a ``word``.
 - When a hex number has 3 or 4 digits, for example ``$0004``, it is seen as a ``word`` otherwise as a ``byte``.
 - When a binary number has 9 to 16 digits, for example ``%1100110011``, it is seen as a ``word`` otherwise as a ``byte``.
-- You can force a byte value into a word value by adding the ``.w`` datatype suffix to the number: ``$2a.w`` is equivalent to ``$002a``.
+- If the number fits in a byte but you really require it as a word value, you'll have to explicitly cast it: ``60 as uword``
+  or you can use the full word hexadecimal notation ``$003c``.
 
 
 Data type conversion
@@ -383,7 +399,25 @@ After defining a struct you can use the name of the struct as a data type to dec
 
 Struct variables can be assigned a struct literal value (also in their declaration as initial value)::
 
-    Color rgb = {255, 100, 0}          ; curly braces instead of brackets
+    Color rgb = [255, 100, 0]          ; note that the value is an array
+
+
+String
+^^^^^^
+
+``"hello"``   is a string translated into the default character encoding (PETSCII)
+
+``@"hello"``  is a string translated into the alternate character encoding (Screencodes/pokes)
+
+There are several escape sequences available to put special characters into your string value:
+
+- ``\\`` - the backslash itself, has to be escaped because it is the escape symbol by itself
+- ``\n`` - newline character (move cursor down and to beginning of next line)
+- ``\r`` - carriage return character (more or less the same as newline if printing to the screen)
+- ``\"`` - quote character (otherwise it would terminate the string)
+- ``\'`` - apostrophe character (has to be escaped in character literals, is okay inside a string)
+- ``\uHHHH`` - a unicode codepoint \u0000 - \uffff (16-bit hexadecimal)
+- ``\xHH`` - 8-bit hex value that will be copied verbatim *without encoding*
 
 
 Operators
@@ -470,6 +504,8 @@ takes no parameters.  If the subroutine returns a value, usually you assign it t
 If you're not interested in the return value, prefix the function call with the ``void`` keyword.
 Otherwise the compiler will warn you about discarding the result of the call.
 
+Multiple return values
+^^^^^^^^^^^^^^^^^^^^^^
 Normal subroutines can only return zero or one return values.
 However, the special ``asmsub`` routines (implemented in assembly code) or ``romsub`` routines
 (referencing a routine in kernel ROM) can return more than one return value.
@@ -477,9 +513,16 @@ For example a status in the carry bit and a number in A, or a 16-bit value in A/
 It is not possible to process the results of a call to these kind of routines
 directly from the language, because only single value assignments are possible.
 You can still call the subroutine and not store the results.
-But if you want to do something with the values it returns, you'll have to write
+
-a small block of custom inline assembly that does the call and stores the values
+**There is an exception:** if there's just one return value in a register, and one or more others that are returned
-appropriately. Don't forget to save/restore the registers if required.
+as bits in the status register (such as the Carry bit), the compiler allows you to call the subroutine.
+It will then store the result value in a variable if required, and *keep the status register untouched
+after the call* so you can use a conditional branch statement for that.
+Note that this makes no sense inside an expression, so the compiler will still give an error for that.
+
+If there really are multiple return values (other than a combined 16 bit return value in 2 registers),
+you'll have to write a small block of custom inline assembly that does the call and stores the values
+appropriately. Don't forget to save/restore any registers that are modified.
 
 
 Subroutine definitions
@@ -514,18 +557,20 @@ and returning stuff in several registers as well. The ``clobbers`` clause is use
 what CPU registers are clobbered by the call instead of being unchanged or returning a meaningful result value.
 
 
-Subroutines that are implemented purely in assembly code and which have an assembly calling convention (i.e.
+User subroutines in the program source code that are implemented purely in assembly and which have an assembly calling convention (i.e.
-the parameters are strictly passed via cpu registers), are defined like this::
+the parameters are strictly passed via cpu registers), are defined with ``asmsub`` like this::
 
-    asmsub  FREADS32() clobbers(A,X,Y)  {
+    asmsub  clear_screenchars (ubyte char @ A) clobbers(Y)  {
         %asm {{
-            lda  $62
+            ldy  #0
-            eor  #$ff
+    _loop   sta  c64.Screen,y
-            asl  a
+            sta  c64.Screen+$0100,y
-            lda  #0
+            sta  c64.Screen+$0200,y
-            ldx  #$a0
+            sta  c64.Screen+$02e8,y
-            jmp  $bc4f
+            iny
-        }}
+            bne  _loop
+            rts
+            }}
     }
 
 the statement body of such a subroutine should consist of just an inline assembly block.

docs/source/targetsystem.rst

@@ -9,13 +9,16 @@ Prog8 targets the following hardware:
 - optional use of memory mapped I/O registers
 - optional use of system ROM routines
 
-Currently there are two machines that are supported as compiler target (via the ``-target`` compiler argument):
+Currently there are two machines that are supported as compiler target (selectable via the ``-target`` compiler argument):
 
 - 'c64': the well-known Commodore-64, premium support
 - 'cx16': the `CommanderX16 <https://www.commanderx16.com/>`_ a project from the 8-Bit Guy. Support for this is still experimental.
 
 This chapter explains the relevant system details of these machines.
 
+.. note::
+    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)!
+
 
 Memory Model
 ============

docs/source/todo.rst

@@ -2,30 +2,27 @@
 TODO
 ====
 
-- optimize assignment codegeneration
+- get rid of all other TODO's in the code ;-)
-- get rid of all TODO's ;-)
+- implement @stack for asmsub parameters
 - 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)
-- aliases for imported symbols for example perhaps '%alias print = c64scr.print' ?
-- investigate support for 8bitguy's Commander X16 platform https://www.commanderx16.com  and https://github.com/commanderx16/x16-docs
 - see if we can group some errors together for instance the (now single) errors about unidentified symbols
-
+- use VIC banking to move up the graphics bitmap memory location. Don't move it under the ROM though as that would require IRQ disabling and memory bank swapping for every bitmap manipulation
+- add some primitives/subroutines/examples for using custom char sets, copying the default charset.
+- 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
 
 More optimizations
 ^^^^^^^^^^^^^^^^^^
 
 Add more compiler optimizations to the existing ones.
 
-- more targeted optimizations for assigment asm code, such as the following:
+- further optimize assignment codegeneration, such as the following:
-- subroutine calling convention? like: 1 byte arg -> pass in A, 2 bytes -> pass in A+Y, return value likewise.
+- binexpr splitting (beware self-referencing expressions and asm code ballooning though)
-- remove unreachable code after an exit(), return or goto
+- subroutine calling convention? like: 1 byte arg -> pass in A, 2 bytes -> pass in A+Y, return value likewise.  Especially for built-in functions!
-- add a compiler option to not include variable initialization code (useful if the program is expected to run only once, such as a game)
+- can such parameter passing to subroutines be optimized to avoid copying?
-  the program will then rely solely on the values as they are in memory at the time of program startup.
-- Also some library routines and code patterns could perhaps be optimized further
-- can the parameter passing to subroutines be optimized to avoid copying?
 - more optimizations on the language AST level
 - more optimizations on the final assembly source level
-- note: abandoned subroutine inlining because of problems referencing non-local stuff. Can't move everything around.
+- note: subroutine inlining is abandoned because of problems referencing non-local stuff. Can't move everything around.
 
 
 Eval stack redesign? (lot of work)

examples/arithmetic/aggregates.p8

@@ -1,5 +1,5 @@
-%import c64flt
+%import floats
-%import c64textio
+%import textio
 %zeropage basicsafe
 
 main {

examples/arithmetic/bitshift.p8

@@ -1,4 +1,4 @@
-%import c64textio
+%import textio
 %zeropage basicsafe
 
 

examples/arithmetic/div.p8

@@ -1,5 +1,5 @@
-%import c64flt
+%import floats
-%import c64textio
+%import textio
 %zeropage basicsafe
 
 main {
@@ -93,11 +93,11 @@ main {
             txt.print("err! ")
 
         txt.print("float ")
-        c64flt.print_f(a1)
+        floats.print_f(a1)
         txt.print(" / ")
-        c64flt.print_f(a2)
+        floats.print_f(a2)
         txt.print(" = ")
-        c64flt.print_f(r)
+        floats.print_f(r)
         c64.CHROUT('\n')
     }
 }

examples/arithmetic/minus.p8

@@ -1,5 +1,5 @@
-%import c64flt
+%import floats
-%import c64textio
+%import textio
 %zeropage basicsafe
 
 main {
@@ -101,11 +101,11 @@ main {
             txt.print("err! ")
 
         txt.print("float ")
-        c64flt.print_f(a1)
+        floats.print_f(a1)
         txt.print(" - ")
-        c64flt.print_f(a2)
+        floats.print_f(a2)
         txt.print(" = ")
-        c64flt.print_f(r)
+        floats.print_f(r)
         c64.CHROUT('\n')
     }
 }

examples/arithmetic/mult.p8

@@ -1,5 +1,5 @@
-%import c64flt
+%import floats
-%import c64textio
+%import textio
 %zeropage basicsafe
 
 main {
@@ -95,11 +95,11 @@ main {
             txt.print("err! ")
 
         txt.print("float ")
-        c64flt.print_f(a1)
+        floats.print_f(a1)
         txt.print(" * ")
-        c64flt.print_f(a2)
+        floats.print_f(a2)
         txt.print(" = ")
-        c64flt.print_f(r)
+        floats.print_f(r)
         c64.CHROUT('\n')
     }
 }

examples/arithmetic/plus.p8

@@ -1,5 +1,5 @@
-%import c64flt
+%import floats
-%import c64textio
+%import textio
 %zeropage basicsafe
 
 main {
@@ -99,11 +99,11 @@ main {
             txt.print("err! ")
 
         txt.print("float ")
-        c64flt.print_f(a1)
+        floats.print_f(a1)
         txt.print(" + ")
-        c64flt.print_f(a2)
+        floats.print_f(a2)
         txt.print(" = ")
-        c64flt.print_f(r)
+        floats.print_f(r)
         c64.CHROUT('\n')
     }
 }

examples/arithmetic/postincrdecr.p8

@@ -1,5 +1,5 @@
-%import c64flt
+%import floats
-%import c64textio
+%import textio
 %zeropage basicsafe
 
 main {
@@ -132,9 +132,9 @@ main {
         else
             txt.print("err! ")
         txt.print(" float ")
-        c64flt.print_f(value)
+        floats.print_f(value)
         c64.CHROUT(',')
-        c64flt.print_f(expected)
+        floats.print_f(expected)
         c64.CHROUT('\n')
     }
 }

examples/arithmetic/remainder.p8

@@ -1,4 +1,4 @@
-%import c64textio
+%import textio
 %zeropage basicsafe
 
 main {

examples/arithmetic/sgn.p8

@@ -1,5 +1,5 @@
-%import c64flt
+%import floats
-%import c64textio
+%import textio
 %zeropage basicsafe
 
 main {

examples/arithmetic/wordbyte.p8

@@ -0,0 +1,315 @@
+%import textio
+%import syslib
+%zeropage basicsafe
+
+
+main {
+    sub start() {
+        repeat 25 {
+            txt.chrout('\n')
+        }
+
+        ubyte ub
+        byte bb
+        uword uwsum
+        word wsum
+
+        uwsum = 50000
+        ub=50
+        uwsum += ub
+        ub=250
+        uwsum += ub
+
+        if uwsum==50300
+            txt.print("1 ok\n")
+        else {
+            txt.print("1 fail:")
+            txt.print_uw(uwsum)
+            txt.chrout('\n')
+        }
+
+        wsum  = -30000
+        bb = 100
+        wsum += bb
+        bb = -50
+        wsum += bb
+
+        if wsum==-29950
+            txt.print("2 ok\n")
+        else {
+            txt.print("2 fail:")
+            txt.print_w(wsum)
+            txt.chrout('\n')
+        }
+
+        uwsum = 50000
+        ub=50
+        uwsum -= ub
+        ub=250
+        uwsum -= ub
+
+        if uwsum==49700
+            txt.print("3 ok\n")
+        else {
+            txt.print("3 fail:")
+            txt.print_uw(uwsum)
+            txt.chrout('\n')
+        }
+        wsum  = -30000
+        bb = 100
+        wsum -= bb
+        bb = -50
+        wsum -= bb
+
+        if wsum==-30050
+            txt.print("4 ok\n")
+        else
+            txt.print("4 fail\n")
+
+
+
+        uwsum = 50000
+        bb=50
+        uwsum += bb as uword
+        bb=-100
+        uwsum += bb as uword
+
+        if uwsum==49950
+            txt.print("5 ok\n")
+        else
+            txt.print("5 fail\n")
+
+        uwsum = 50000
+        bb=50
+        uwsum -= bb as uword
+        bb=100
+        uwsum -= bb as uword
+
+        if uwsum==49850
+            txt.print("6 ok\n")
+        else {
+            txt.print("6 fail:")
+            txt.print_uw(uwsum)
+            txt.chrout('\n')
+        }
+
+        wsum  = -30000
+        ub = 50
+        wsum += ub
+        ub = 250
+        wsum += ub
+
+        if wsum==-29700
+            txt.print("7 ok\n")
+        else {
+            txt.print("7 fail:")
+            txt.print_w(wsum)
+            txt.chrout('\n')
+        }
+
+        wsum  = -30000
+        ub = 50
+        wsum -= ub
+        ub = 250
+        wsum -= ub
+
+        if wsum==-30300
+            txt.print("8 ok\n")
+        else {
+            txt.print("8 fail:")
+            txt.print_w(wsum)
+            txt.chrout('\n')
+        }
+
+        txt.chrout('\n')
+
+
+
+        uwsum = 50000
+        ub=0
+        uwsum += (50+ub)
+        uwsum += (250+ub)
+
+        if uwsum==50300
+            txt.print("1b ok\n")
+        else {
+            txt.print("1b fail:")
+            txt.print_uw(uwsum)
+            txt.chrout('\n')
+        }
+
+        bb = 0
+        wsum  = -30000
+        wsum += (100+bb)
+        wsum += (-50+bb)
+
+        if wsum==-29950
+            txt.print("2b ok\n")
+        else {
+            txt.print("2b fail:")
+            txt.print_w(wsum)
+            txt.chrout('\n')
+        }
+
+        uwsum = 50000
+        uwsum -= (50+ub)
+        uwsum -= (250+ub)
+
+        if uwsum==49700
+            txt.print("3b ok\n")
+        else {
+            txt.print("3b fail:")
+            txt.print_uw(uwsum)
+            txt.chrout('\n')
+        }
+        wsum  = -30000
+        wsum -= (100+bb)
+        wsum -= (-50+bb)
+
+        if wsum==-30050
+            txt.print("4b ok\n")
+        else
+            txt.print("4b fail\n")
+
+
+        uwsum = 50000
+        uwsum += (50+bb) as uword
+        uwsum += (-100+bb) as uword
+
+        if uwsum==49950
+            txt.print("5b ok\n")
+        else
+            txt.print("5b fail\n")
+
+        uwsum = 50000
+        uwsum -= (50+bb) as uword
+        uwsum -= (100+bb) as uword
+
+        if uwsum==49850
+            txt.print("6b ok\n")
+        else {
+            txt.print("6b fail:")
+            txt.print_uw(uwsum)
+            txt.chrout('\n')
+        }
+
+        wsum  = -30000
+        wsum += (50+ub)
+        wsum += (250+ub)
+
+        if wsum==-29700
+            txt.print("7b ok\n")
+        else {
+            txt.print("7b fail:")
+            txt.print_w(wsum)
+            txt.chrout('\n')
+        }
+
+        wsum  = -30000
+        wsum -= (50+ub)
+        wsum -= (250+ub)
+
+        if wsum==-30300
+            txt.print("8b ok\n")
+        else {
+            txt.print("8b fail:")
+            txt.print_w(wsum)
+            txt.chrout('\n')
+        }
+
+        txt.chrout('\n')
+
+
+
+        uwsum = 50000
+        uwsum += 50
+        uwsum += 250
+
+        if uwsum==50300
+            txt.print("1c ok\n")
+        else {
+            txt.print("1c fail:")
+            txt.print_uw(uwsum)
+            txt.chrout('\n')
+        }
+
+        wsum  = -30000
+        wsum += 100
+        wsum += -50
+
+        if wsum==-29950
+            txt.print("2c ok\n")
+        else {
+            txt.print("2c fail:")
+            txt.print_w(wsum)
+            txt.chrout('\n')
+        }
+
+        uwsum = 50000
+        uwsum -= 50
+        uwsum -= 250
+
+        if uwsum==49700
+            txt.print("3c ok\n")
+        else {
+            txt.print("3c fail:")
+            txt.print_uw(uwsum)
+            txt.chrout('\n')
+        }
+        wsum  = -30000
+        wsum -= 100
+        wsum -= -50
+
+        if wsum==-30050
+            txt.print("4c ok\n")
+        else
+            txt.print("4c fail\n")
+
+
+        uwsum = 50000
+        uwsum += 50 as uword
+        uwsum += -100 as uword
+
+        if uwsum==49950
+            txt.print("5c ok\n")
+        else
+            txt.print("5c fail\n")
+
+        uwsum = 50000
+        uwsum -= 50 as uword
+        uwsum -= 100 as uword
+
+        if uwsum==49850
+            txt.print("6c ok\n")
+        else {
+            txt.print("6c fail:")
+            txt.print_uw(uwsum)
+            txt.chrout('\n')
+        }
+
+        wsum  = -30000
+        wsum += 50
+        wsum += 250
+
+        if wsum==-29700
+            txt.print("7c ok\n")
+        else {
+            txt.print("7c fail:")
+            txt.print_w(wsum)
+            txt.chrout('\n')
+        }
+
+        wsum  = -30000
+        wsum -= 50
+        wsum -= 250
+
+        if wsum==-30300
+            txt.print("8c ok\n")
+        else {
+            txt.print("8c fail:")
+            txt.print_w(wsum)
+            txt.chrout('\n')
+        }
+    }
+
+}

examples/balloonflight.p8

@@ -1,5 +1,6 @@
-%import c64lib
+%target c64
-%import c64textio
+%import syslib
+%import textio
 %zeropage basicsafe
 
 main {
@@ -43,8 +44,10 @@ main {
             }
 
             perform_scroll = false
-            txt.scroll_left_full(true)
+            txt.scroll_left(true)
-            if c64.RASTER & 1
+
+            ; float the balloon
+            if rnd() & %10000
                 c64.SPXY[1] ++
             else
                 c64.SPXY[1] --

examples/bdmusic-irq.p8

@@ -1,5 +1,6 @@
-%import c64lib
+%target c64
-%import c64textio
+%import syslib
+%import textio
 %zeropage basicsafe
 
 main {

examples/bdmusic.p8

@@ -1,4 +1,6 @@
-%import c64textio
+%target c64
+%import textio
+%import syslib
 
 main {
 

examples/cmp/comparison_ifs_byte.p8

@@ -1,6 +1,7 @@
-%import c64textio
+%import textio
 %zeropage basicsafe
 
+; Note: this program is compatible with C64 and CX16.
 
 main {
 

examples/cmp/comparison_ifs_float.p8

@@ -1,7 +1,9 @@
-%import c64textio
+%import textio
-%import c64flt
+%import floats
 %zeropage basicsafe
 
+; Note: this program is compatible with C64 and CX16.
+
 main {
 
     sub start()  {

examples/cmp/comparison_ifs_ubyte.p8

@@ -1,7 +1,9 @@
-%import c64textio
+%import textio
 %zeropage basicsafe
 
 
+; Note: this program is compatible with C64 and CX16.
+
 main {
 
     sub start()  {

examples/cmp/comparison_ifs_uword.p8

@@ -1,6 +1,7 @@
-%import c64textio
+%import textio
 %zeropage basicsafe
 
+; Note: this program is compatible with C64 and CX16.
 
 main {
 

examples/cmp/comparison_ifs_word.p8

@@ -1,6 +1,7 @@
-%import c64textio
+%import textio
 %zeropage basicsafe
 
+; Note: this program is compatible with C64 and CX16.
 
 main {
 

examples/comparisons_byte.p8

@@ -1,93 +0,0 @@
-%import c64textio
-%zeropage basicsafe
-
-main {
-
-    sub start()  {
-
-        byte v1
-        byte v2
-        ubyte cr
-
-        txt.print("signed byte ")
-
-        cr=v1==v2
-        cr=v1==v2
-        cr=v1==v2
-        cr=v1!=v2
-        cr=v1!=v2
-        cr=v1!=v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-
-        ; comparisons:
-        v1=-20
-        v2=125
-        txt.print("v1=-20, v2=125\n")
-        compare()
-
-        v1=80
-        v2=80
-        txt.print("v1 = v2 = 80\n")
-        compare()
-
-        v1=20
-        v2=-111
-        txt.print("v1=20, v2=-111\n")
-        compare()
-
-        return
-
-        sub compare() {
-        txt.print("  ==  !=  <   >   <=  >=\n")
-
-        if v1==v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-        if v1!=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1<v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1>v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1<=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1>=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-        c64.CHROUT('\n')
-
-    }
-
-    }
-}

examples/comparisons_float.p8

@@ -1,110 +0,0 @@
-%import c64textio
-%import c64flt
-%zeropage basicsafe
-
-main {
-
-    sub start()  {
-
-        float v1
-        float v2
-        ubyte cr
-
-        txt.print("floating point ")
-
-        cr=v1==v2
-        cr=v1==v2
-        cr=v1==v2
-        cr=v1!=v2
-        cr=v1!=v2
-        cr=v1!=v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-
-        ; comparisons:
-        v1=20
-        v2=666.66
-        txt.print("v1=20, v2=666.66\n")
-        compare()
-
-        v1=-20
-        v2=666.66
-        txt.print("v1=-20, v2=666.66\n")
-        compare()
-
-        v1=666.66
-        v2=555.55
-        txt.print("v1=666.66, v2=555.55\n")
-        compare()
-
-        v1=3.1415
-        v2=-3.1415
-        txt.print("v1 = 3.1415, v2 = -3.1415\n")
-        compare()
-
-        v1=3.1415
-        v2=3.1415
-        txt.print("v1 = v2 = 3.1415\n")
-        compare()
-
-        v1=0
-        v2=0
-        txt.print("v1 = v2 = 0\n")
-        compare()
-
-        return
-
-        sub compare() {
-        txt.print("  ==  !=  <   >   <=  >=\n")
-
-        if v1==v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-        if v1!=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1<v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1>v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1<=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1>=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-        c64.CHROUT('\n')
-
-    }
-
-    }
-
-}

examples/comparisons_ubyte.p8

@@ -1,94 +0,0 @@
-%import c64textio
-%zeropage basicsafe
-
-main {
-
-    sub start()  {
-
-        ubyte v1
-        ubyte v2
-        ubyte cr
-
-        txt.print("unsigned byte ")
-
-        cr=v1==v2
-        cr=v1==v2
-        cr=v1==v2
-        cr=v1!=v2
-        cr=v1!=v2
-        cr=v1!=v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-
-        ; comparisons:
-        v1=20
-        v2=199
-        txt.print("v1=20, v2=199\n")
-        compare()
-
-        v1=80
-        v2=80
-        txt.print("v1 = v2 = 80\n")
-        compare()
-
-        v1=220
-        v2=10
-        txt.print("v1=220, v2=10\n")
-        compare()
-
-        return
-
-        sub compare() {
-        txt.print("  ==  !=  <   >   <=  >=\n")
-
-        if v1==v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-        if v1!=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1<v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1>v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1<=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1>=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-        c64.CHROUT('\n')
-
-    }
-
-    }
-
-}

examples/comparisons_uword.p8

@@ -1,123 +0,0 @@
-%import c64textio
-%zeropage basicsafe
-
-main {
-
-    sub start()  {
-
-        uword v1
-        uword v2
-        ubyte cr
-
-        txt.print("unsigned word ")
-
-        cr=v1==v2
-        cr=v1==v2
-        cr=v1==v2
-        cr=v1!=v2
-        cr=v1!=v2
-        cr=v1!=v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-
-        ; comparisons:
-        v1=20
-        v2=$00aa
-        txt.print("v1=20, v2=$00aa\n")
-        compare()
-
-        v1=20
-        v2=$ea00
-        txt.print("v1=20, v2=$ea00\n")
-        compare()
-
-        v1=$c400
-        v2=$22
-        txt.print("v1=$c400, v2=$22\n")
-        compare()
-
-        v1=$c400
-        v2=$2a00
-        txt.print("v1=$c400, v2=$2a00\n")
-        compare()
-
-        v1=$c433
-        v2=$2a00
-        txt.print("v1=$c433, v2=$2a00\n")
-        compare()
-
-        v1=$c433
-        v2=$2aff
-        txt.print("v1=$c433, v2=$2aff\n")
-        compare()
-
-        v1=$aabb
-        v2=$aabb
-        txt.print("v1 = v2 = aabb\n")
-        compare()
-
-        v1=$aa00
-        v2=$aa00
-        txt.print("v1 = v2 = aa00\n")
-        compare()
-
-        v1=$aa
-        v2=$aa
-        txt.print("v1 = v2 = aa\n")
-        compare()
-
-        return
-
-        sub compare() {
-        txt.print("  ==  !=  <   >   <=  >=\n")
-
-        if v1==v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-        if v1!=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1<v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1>v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1<=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1>=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-        c64.CHROUT('\n')
-
-    }
-
-    }
-}

examples/comparisons_word.p8

@@ -1,159 +0,0 @@
-%import c64textio
-%zeropage basicsafe
-
-main {
-
-    sub start()  {
-
-        word v1
-        word v2
-        ubyte cr
-
-        txt.print("signed word ")
-
-        cr=v1==v2
-        cr=v1==v2
-        cr=v1==v2
-        cr=v1!=v2
-        cr=v1!=v2
-        cr=v1!=v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1<v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1>v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1<=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-        cr=v1>=v2
-
-        ; comparisons:
-        v1=20
-        v2=$00aa
-        txt.print("v1=20, v2=$00aa\n")
-        compare()
-
-        v1=20
-        v2=$7a00
-        txt.print("v1=20, v2=$7a00\n")
-        compare()
-
-        v1=$7400
-        v2=$22
-        txt.print("v1=$7400, v2=$22\n")
-        compare()
-
-        v1=$7400
-        v2=$2a00
-        txt.print("v1=$7400, v2=$2a00\n")
-        compare()
-
-        v1=$7433
-        v2=$2a00
-        txt.print("v1=$7433, v2=$2a00\n")
-        compare()
-
-        v1=$7433
-        v2=$2aff
-        txt.print("v1=$7433, v2=$2aff\n")
-        compare()
-
-        ;  with negative numbers:
-        v1=-512
-        v2=$00aa
-        txt.print("v1=-512, v2=$00aa\n")
-        compare()
-
-        v1=-512
-        v2=$7a00
-        txt.print("v1=-512, v2=$7a00\n")
-        compare()
-
-        v1=$7400
-        v2=-512
-        txt.print("v1=$7400, v2=-512\n")
-        compare()
-
-        v1=-20000
-        v2=-1000
-        txt.print("v1=-20000, v2=-1000\n")
-        compare()
-
-        v1=-1000
-        v2=-20000
-        txt.print("v1=-1000, v2=-20000\n")
-        compare()
-
-        v1=-1
-        v2=32767
-        txt.print("v1=-1, v2=32767\n")
-        compare()
-
-        v1=32767
-        v2=-1
-        txt.print("v1=32767, v2=-1\n")
-        compare()
-
-        v1=$7abb
-        v2=$7abb
-        txt.print("v1 = v2 = 7abb\n")
-        compare()
-
-        v1=$7a00
-        v2=$7a00
-        txt.print("v1 = v2 = 7a00\n")
-        compare()
-
-        v1=$aa
-        v2=$aa
-        txt.print("v1 = v2 = aa\n")
-        compare()
-
-        return
-
-        sub compare() {
-        txt.print("  ==  !=  <   >   <=  >=\n")
-
-        if v1==v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-        if v1!=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1<v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1>v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1<=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-
-        if v1>=v2
-            txt.print("  Q ")
-        else
-            txt.print("  . ")
-        c64.CHROUT('\n')
-
-    }
-
-    }
-}