version 4.2

README.md

@@ -12,9 +12,18 @@ Prog8 - Structured Programming Language for 8-bit 6502/65c02 microprocessors
 
 This is a structured programming language for the 8-bit 6502/6510/65c02 microprocessor from the late 1970's and 1980's
 as used in many home computers from that era. It is a medium to low level programming language,
-which aims to provide many conveniences over raw assembly code (even when using a macro assembler):
+which aims to provide many conveniences over raw assembly code (even when using a macro assembler).
 
-- reduction of source code length
+Documentation
+-------------
+Full documentation (syntax reference, how to use the language and the compiler, etc.) can be found at:
+https://prog8.readthedocs.io/
+
+
+What use Prog8 provide?
+-----------------------
+
+- reduction of source code length over raw assembly
 - modularity, symbol scoping, subroutines
 - various data types other than just bytes (16-bit words, floats, strings)
 - automatic variable allocations, automatic string and array variables and string sharing
@@ -29,7 +38,7 @@ which aims to provide many conveniences over raw assembly code (even when using
 - inline assembly allows you to have full control when every cycle or byte matters
 - many built-in functions such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``sort`` and ``reverse``
 
-Rapid edit-compile-run-debug cycle:
+*Rapid edit-compile-run-debug cycle:*
 
 - use a modern PC to do the work on
 - very quick compilation times
@@ -37,17 +46,16 @@ Rapid edit-compile-run-debug cycle:
 - breakpoints, that let the Vice emulator drop into the monitor if execution hits them
 - source code labels automatically loaded in Vice emulator so it can show them in disassembly
 
-Prog8 is mainly targeted at the Commodore-64 machine.
-Preliminary support for the [CommanderX16](https://www.commanderx16.com) is available as a second compilation target.
-Contributions to improve these or to add support for other machines are welcome!
+*Two supported compiler targets* (contributions to improve these or to add support for other machines are welcome!):
+
+- "c64": Commodore-64  (6510 CPU = almost a 6502)  premium support.
+- "cx16": [CommanderX16](https://www.commanderx16.com)  (65c02 CPU)  experimental support.
 
 
-Documentation/manual
---------------------
-https://prog8.readthedocs.io/
 
-Required tools
---------------
+
+Additional required tools
+-------------------------
 
 [64tass](https://sourceforge.net/projects/tass64/) - cross assembler. Install this on your shell path.
 A recent .exe version of this tool for Windows can be obtained from my [clone](https://github.com/irmen/64tass/releases) of this project.

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/c64floats.asm

@@ -1,25 +1,31 @@
 ; --- 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
-		jsr  FREADUY
+		lda  #0
+		jsr  GIVAYF
 _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
@@ -29,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
@@ -40,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
@@ -53,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
@@ -63,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
@@ -72,9 +78,10 @@ stack_ub2float	.proc
 		; -- ub2float operating on the stack
 		inx
 		lda  P8ESTACK_LO,x
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		tay
-		jsr  FREADUY
+		lda  #0
+		jsr  GIVAYF
 		jmp  push_fac1_as_result
 		.pend
 
@@ -83,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
@@ -103,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
@@ -229,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
-		ldy  #>FL_FONE
+		lda  #<FL_ONE_const
+		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
 
@@ -245,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
-		lda  #<FL_FONE
-		ldy  #>FL_FONE
+		stx  P8ZP_SCRATCH_REG
+		lda  #<FL_ONE_const
+		ldy  #>FL_ONE_const
 		jsr  MOVFM
 		lda  P8ZP_SCRATCH_W1
 		ldy  P8ZP_SCRATCH_W1+1
@@ -255,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
 
@@ -284,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
 
@@ -296,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
@@ -320,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
@@ -330,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
@@ -340,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,7 +357,7 @@ mul_f		.proc
 neg_f		.proc
 		; -- push -flt back on stack
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  NEGOP
 		jmp  push_fac1_as_result
 		.pend
@@ -358,7 +365,7 @@ neg_f		.proc
 abs_f		.proc
 		; -- push abs(float) on stack (as float)
 		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		jsr  ABS
 		jmp  push_fac1_as_result
 		.pend
@@ -464,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
@@ -472,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
@@ -480,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
@@ -488,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
@@ -496,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
@@ -504,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
@@ -516,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
@@ -524,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
@@ -535,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
@@ -545,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
@@ -553,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
@@ -561,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
@@ -571,8 +578,8 @@ func_ceil	.proc
 		jsr  FCOMP
 		cmp  #0
 		beq  +
-		lda  #<FL_FONE
-		ldy  #>FL_FONE
+		lda  #<FL_ONE_const
+		ldy  #>FL_ONE_const
 		jsr  FADD
 +		jmp  push_fac1_as_result
 		.pend
@@ -628,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
@@ -648,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
@@ -663,11 +672,11 @@ _largest_pos_float	.byte  255,127,255,255,255		; largest positive float
 		.pend
 
 func_sum_f	.proc
-		lda  #<FL_ZERO
-		ldy  #>FL_ZERO
+		lda  #<FL_ZERO_const
+		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
@@ -683,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/c64flt.p8

@@ -4,14 +4,14 @@
 ;
 ; indent format: TABS, size=8
 
+%target c64
 %option enable_floats
 
-
 c64flt {
 	; ---- this block contains C-64 floating point related functions ----
 
-        const  float  PI        = 3.141592653589793
-        const  float  TWOPI	    = 6.283185307179586
+        const float  PI     = 3.141592653589793
+        const float  TWOPI  = 6.283185307179586
 
 
 ; ---- C64 basic and kernal ROM float constants and functions ----
@@ -35,13 +35,11 @@ c64flt {
 		&float  FL_TWOPI	= $e2e5  ; 2 * PI
 		&float  FL_FR4		= $e2ea  ; .25
 		; oddly enough, 0.0 isn't available in the kernel.
-        float   FL_ZERO     = 0.0    ; oddly enough 0.0 isn't available in the kernel
 
 
 ; note: fac1/2 might get clobbered even if not mentioned in the function's name.
 ; note: for subtraction and division, the left operand is in fac2, the right operand in fac1.
 
-; checked functions below:
 romsub $bba2 = MOVFM(uword mflpt @ AY) clobbers(A,Y)        ; load mflpt value from memory  in A/Y into fac1
 romsub $bba6 = FREADMEM() clobbers(A,Y)                     ; load mflpt value from memory  in $22/$23 into fac1
 romsub $ba8c = CONUPK(uword mflpt @ AY) clobbers(A,Y)       ; load mflpt value from memory  in A/Y into fac2
@@ -91,6 +89,7 @@ romsub $bb12 = FDIVT() clobbers(A,X,Y)                      ; fac1 = fac2/fac1
 romsub $bb0f = FDIV(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt in A/Y / fac1  (remainder in fac2)
 romsub $bf7b = FPWRT() clobbers(A,X,Y)                      ; fac1 = fac2 ** fac1
 romsub $bf78 = FPWR(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = fac2 ** mflpt from A/Y
+romsub $bd7e = FINLOG(byte value @A) clobbers (A, X, Y)     ; fac1 += signed byte in A
 
 romsub $aed4 = NOTOP() clobbers(A,X,Y)                      ; fac1 = NOT(fac1)
 romsub $bccc = INT() clobbers(A,X,Y)                        ; INT() truncates, use FADDH first to round instead of trunc
@@ -193,33 +192,26 @@ asmsub  GETADRAY  () clobbers(X) -> uword @ AY  {
 }
 
 sub  print_f  (float value) {
-	; ---- prints the floating point value (without a newline) using basic rom routines.
+	; ---- 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
-		jsr  c64.STROUT			; print string in A/Y
-		ldx  P8ZP_SCRATCH_REG_X
-		rts
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		ldy  #0
+-		lda  (P8ZP_SCRATCH_W1),y
+		beq  +
+		jsr  c64.CHROUT
+		iny
+		bne  -
+		ldx  floats_store_reg
++		rts
 	}}
 }
 
-sub  print_fln  (float value) {
-	; ---- prints the floating point value (with a newline at the end) using basic rom routines
-	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
-		lda  #<value
-		ldy  #>value
-		jsr  MOVFM		; load float into fac1
-		jsr  FPRINTLN		; print fac1 with newline
-		ldx  P8ZP_SCRATCH_REG_X
-		rts
-	}}
-
-}
-
 %asminclude "library:c64floats.asm", ""
 
-}  ; ------ end of block c64flt
+}

compiler/res/prog8lib/c64graphics.p8

@@ -0,0 +1,242 @@
+%target c64
+%import c64textio
+
+; bitmap pixel graphics module for the C64
+; only black/white monchrome for now
+; assumes bitmap screen memory is $2000-$3fff
+
+graphics {
+    const uword bitmap_address = $2000
+
+    sub enable_bitmap_mode() {
+        ; enable bitmap screen, erase it and set colors to black/white.
+        c64.SCROLY |= %00100000
+        c64.VMCSB = (c64.VMCSB & %11110000) | %00001000   ; $2000-$3fff
+        clear_screen(1, 0)
+    }
+
+    sub clear_screen(ubyte pixelcolor, ubyte bgcolor) {
+        memset(bitmap_address, 320*200/8, 0)
+        txt.fill_screen(pixelcolor << 4 | bgcolor, 0)
+    }
+
+    sub line(uword @zp x1, ubyte @zp y1, uword @zp x2, ubyte @zp y2) {
+        ; Bresenham algorithm.
+        ; This code special cases various quadrant loops to allow simple ++ and -- operations.
+        ; TODO rewrite this in optimized assembly
+        if y1>y2 {
+            ; make sure dy is always positive to avoid 8 instead of just 4 special cases
+            swap(x1, x2)
+            swap(y1, y2)
+        }
+        word @zp d = 0
+        ubyte positive_ix = true
+        word @zp dx = x2 - x1 as word
+        word @zp dy = y2 as word - y1 as word
+        if dx < 0 {
+            dx = -dx
+            positive_ix = false
+        }
+        dx *= 2
+        dy *= 2
+        internal_plotx = x1
+
+        if dx >= dy {
+            if positive_ix {
+                repeat {
+                    internal_plot(y1)
+                    if internal_plotx==x2
+                        return
+                    internal_plotx++
+                    d += dy
+                    if d > dx {
+                        y1++
+                        d -= dx
+                    }
+                }
+            } else {
+                repeat {
+                    internal_plot(y1)
+                    if internal_plotx==x2
+                        return
+                    internal_plotx--
+                    d += dy
+                    if d > dx {
+                        y1++
+                        d -= dx
+                    }
+                }
+            }
+        }
+        else {
+            if positive_ix {
+                repeat {
+                    internal_plot(y1)
+                    if y1 == y2
+                        return
+                    y1++
+                    d += dx
+                    if d > dy {
+                        internal_plotx++
+                        d -= dy
+                    }
+                }
+            } else {
+                repeat {
+                    internal_plot(y1)
+                    if y1 == y2
+                        return
+                    y1++
+                    d += dx
+                    if d > dy {
+                        internal_plotx--
+                        d -= dy
+                    }
+                }
+            }
+        }
+    }
+
+    sub circle(uword xcenter, ubyte ycenter, ubyte radius) {
+        ; Midpoint algorithm
+        ubyte @zp ploty
+        ubyte @zp xx = radius
+        ubyte @zp yy = 0
+        byte @zp decisionOver2 = 1-xx as byte
+
+        while xx>=yy {
+            internal_plotx = xcenter + xx
+            ploty = ycenter + yy
+            internal_plot(ploty)
+            internal_plotx = xcenter - xx
+            internal_plot(ploty)
+            internal_plotx = xcenter + xx
+            ploty = ycenter - yy
+            internal_plot(ploty)
+            internal_plotx = xcenter - xx
+            internal_plot(ploty)
+            internal_plotx = xcenter + yy
+            ploty = ycenter + xx
+            internal_plot(ploty)
+            internal_plotx = xcenter - yy
+            internal_plot(ploty)
+            internal_plotx = xcenter + yy
+            ploty = ycenter - xx
+            internal_plot(ploty)
+            internal_plotx = xcenter - yy
+            internal_plot(ploty)
+            yy++
+            if decisionOver2<=0
+                decisionOver2 += 2*yy+1
+            else {
+                xx--
+                decisionOver2 += 2*(yy-xx)+1
+            }
+        }
+    }
+
+    sub disc(uword cx, ubyte cy, ubyte radius) {
+        ; Midpoint algorithm, filled
+        ubyte xx = radius
+        ubyte yy = 0
+        byte decisionOver2 = 1-xx as byte
+
+        while xx>=yy {
+            ubyte cy_plus_yy = cy + yy
+            ubyte cy_min_yy = cy - yy
+            ubyte cy_plus_xx = cy + xx
+            ubyte cy_min_xx = cy - xx
+
+            for internal_plotx in cx to cx+xx {
+                internal_plot(cy_plus_yy)
+                internal_plot(cy_min_yy)
+            }
+            for internal_plotx in cx-xx to cx-1 {
+                internal_plot(cy_plus_yy)
+                internal_plot(cy_min_yy)
+            }
+            for internal_plotx in cx to cx+yy {
+                internal_plot(cy_plus_xx)
+                internal_plot(cy_min_xx)
+            }
+            for internal_plotx in cx-yy to cx {
+                internal_plot(cy_plus_xx)
+                internal_plot(cy_min_xx)
+            }
+            yy++
+            if decisionOver2<=0
+                decisionOver2 += 2*yy+1
+            else {
+                xx--
+                decisionOver2 += 2*(yy-xx)+1
+            }
+        }
+    }
+
+
+; here is the non-asm code for the plot routine below:
+;    sub plot_nonasm(uword px, ubyte py) {
+;        ubyte[] ormask = [128, 64, 32, 16, 8, 4, 2, 1]
+;        uword addr = bitmap_address + 320*(py>>3) + (py & 7) + (px & %0000000111111000)
+;        @(addr) |= ormask[lsb(px) & 7]
+;    }
+
+    asmsub  plot(uword plotx @XY, ubyte ploty @A) clobbers (A, X, Y) {
+        %asm {{
+            stx  internal_plotx
+            sty  internal_plotx+1
+            jmp  internal_plot
+        }}
+    }
+
+    ; 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) clobbers (A, X, Y) {      ; internal_plotx is 16 bits 0 to 319... doesn't fit in a register
+        %asm {{
+        tay
+        lda  internal_plotx+1
+        sta  P8ZP_SCRATCH_W2+1
+        lsr  a            ; 0
+        sta  P8ZP_SCRATCH_W2
+        lda  internal_plotx
+        pha
+        and  #7
+        tax
+
+        lda  _y_lookup_lo,y
+        clc
+        adc  P8ZP_SCRATCH_W2
+        sta  P8ZP_SCRATCH_W2
+        lda  _y_lookup_hi,y
+        adc  P8ZP_SCRATCH_W2+1
+        sta  P8ZP_SCRATCH_W2+1
+
+        pla     ; internal_plotx
+        and  #%11111000
+        tay
+        lda  (P8ZP_SCRATCH_W2),y
+        ora  _ormask,x
+        sta  (P8ZP_SCRATCH_W2),y
+        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)
+; 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)
+
+_y_lookup_lo    .byte  <_plot_y_values
+_y_lookup_hi    .byte  >_plot_y_values
+
+        }}
+    }
+
+}
+
+

compiler/res/prog8lib/c64lib.p8

@@ -5,6 +5,7 @@
 ;
 ; indent format: TABS, size=8
 
+%target c64
 
 c64 {
         &ubyte  TIME_HI         = $a0       ; software jiffy clock, hi byte
@@ -298,8 +299,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 +323,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 +337,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/c64textio.p8

@@ -5,14 +5,23 @@
 ; indent format: TABS, size=8
 
 
+%target c64
 %import c64lib
 %import conv
 
 
 txt {
 
-asmsub  clear_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
-	; ---- clear the character screen with the given fill character and character color.
+asmsub  clear_screen() {
+    %asm {{
+        lda  #' '
+        jmp  clear_screenchars
+    }}
+}
+
+
+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)
 
 	%asm {{
@@ -41,7 +50,7 @@ _loop		sta  c64.Screen,y
         }}
 }
 
-asmsub  clear_screencolors (ubyte color @ A) clobbers(Y)  {
+asmsub  clear_screencolors (ubyte scrcolor @ A) clobbers(Y)  {
 	; ---- clear the character screen colors with the given color (leaves characters).
 	;      (assumes color matrix is at the default address)
 	%asm {{
@@ -56,13 +65,17 @@ _loop		sta  c64.Colors,y
         }}
 }
 
+sub color (ubyte txtcol) {
+    c64.COLOR = txtcol
+}
+
 asmsub  scroll_left_full  (ubyte alsocolors @ Pc) clobbers(A, Y)  {
 	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 
 	%asm {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		bcs  +
 		jmp  _scroll_screen
 
@@ -90,7 +103,7 @@ _scroll_screen  ; scroll the screen memory
 		dey
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
@@ -100,7 +113,7 @@ asmsub  scroll_right_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 	;      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
 
@@ -124,7 +137,7 @@ _scroll_screen  ; scroll the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
@@ -134,7 +147,7 @@ asmsub  scroll_up_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 	;      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
 
@@ -158,7 +171,7 @@ _scroll_screen  ; scroll the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
@@ -168,7 +181,7 @@ asmsub  scroll_down_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 	;      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
 
@@ -192,7 +205,7 @@ _scroll_screen  ; scroll the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
@@ -218,7 +231,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
@@ -227,7 +240,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
 	}}
 }
@@ -235,7 +248,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
@@ -252,7 +265,7 @@ _print_byte_digits
         jsr  c64.CHROUT
 _ones   txa
 		jsr  c64.CHROUT
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
@@ -260,7 +273,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  +
@@ -268,16 +281,14 @@ asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
 		jsr  c64.CHROUT
 +		pla
 		jsr  conv.byte2decimal
-		jsr  print_ub._print_byte_digits
-		ldx  P8ZP_SCRATCH_REG_X
-		rts
+		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 {{
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 		bcc  +
 		pha
 		lda  #'$'
@@ -287,7 +298,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
 	}}
 }
@@ -295,7 +306,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  #'%'
@@ -308,7 +319,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
 	}}
 }
@@ -341,7 +352,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
@@ -349,7 +360,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
 	}}
 }
@@ -357,9 +368,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
@@ -504,7 +515,7 @@ _mod		lda  $ffff		; modified
 	}}
 }
 
-sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte color)  {
+sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
 	; ---- set char+color at the given position on the screen
 	%asm {{
 		lda  row
@@ -524,7 +535,7 @@ sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte color)  {
 		inc  _colormod+2
 +		lda  char
 _charmod	sta  $ffff		; modified
-		lda  color
+		lda  charcolor
 _colormod	sta  $ffff		; modified
 		rts
 	}}
@@ -533,11 +544,11 @@ _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
 	}}
 }

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

compiler/res/prog8lib/cx16flt.p8

@@ -0,0 +1,153 @@
+; Prog8 definitions for floating point handling on the CommanderX16
+;
+; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
+;
+; indent format: TABS, size=8
+
+%target cx16
+%option enable_floats
+
+c64flt {
+	; ---- this block contains C-64 floating point related functions ----
+
+        const float  PI     = 3.141592653589793
+        const float  TWOPI  = 6.283185307179586
+
+
+; ---- ROM float functions ----
+
+		; note: the fac1 and fac2 are working registers and take 6 bytes each,
+		; floats in memory  (and rom) are stored in 5-byte MFLPT packed format.
+
+; note: fac1/2 might get clobbered even if not mentioned in the function's name.
+; note: for subtraction and division, the left operand is in fac2, the right operand in fac1.
+
+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
+; (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)
+
+; fac1 -> unsigned word in Y/A (might throw ILLEGAL QUANTITY) (result also in $14/15)
+; (tip: use GETADRAY to get A/Y output; lo/hi switched to normal little endian order)
+romsub $fe06 = GETADR() clobbers(X) -> ubyte @ Y, ubyte @ A
+
+romsub $fe09 = FADDH() clobbers(A,X,Y)                      ; fac1 += 0.5, for rounding- call this before INT
+romsub $fe0c = FSUB(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt from A/Y - fac1
+romsub $fe0f = FSUBT() clobbers(A,X,Y)                      ; fac1 = fac2-fac1   mind the order of the operands
+romsub $fe12 = FADD(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 += mflpt value from A/Y
+romsub $fe15 = FADDT() clobbers(A,X,Y)                      ; fac1 += fac2
+romsub $fe1b = ZEROFC() clobbers(A,X,Y)                     ; fac1 = 0
+romsub $fe1e = NORMAL() clobbers(A,X,Y)                     ; normalize fac1 (?)
+romsub $fe24 = LOG() clobbers(A,X,Y)                        ; fac1 = LN(fac1)  (natural log)
+romsub $fe27 = FMULT(uword mflpt @ AY) clobbers(A,X,Y)      ; fac1 *= mflpt value from A/Y
+romsub $fe2a = FMULTT() clobbers(A,X,Y)                     ; fac1 *= fac2
+romsub $fe33 = CONUPK(uword mflpt @ AY) clobbers(A,Y)       ; load mflpt value from memory  in A/Y into fac2
+romsub $fe36 = MUL10() clobbers(A,X,Y)                      ; fac1 *= 10
+romsub $fe3c = DIV10() clobbers(A,X,Y)                      ; fac1 /= 10 , CAUTION: result is always positive!
+romsub $fe3f = FDIV(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt in A/Y / fac1  (remainder in fac2)
+romsub $fe42 = FDIVT() clobbers(A,X,Y)                      ; fac1 = fac2/fac1  (remainder in fac2)  mind the order of the operands
+
+romsub $fe48 = MOVFM(uword mflpt @ AY) clobbers(A,Y)        ; load mflpt value from memory  in A/Y into fac1
+romsub $fe4b = MOVMF(uword mflpt @ XY) clobbers(A,Y)        ; store fac1 to memory  X/Y as 5-byte mflpt
+romsub $fe4e = MOVFA() clobbers(A,X)                        ; copy fac2 to fac1
+romsub $fe51 = MOVAF() clobbers(A,X)                        ; copy fac1 to fac2  (rounded)
+romsub $fe54 = MOVEF() clobbers(A,X)                        ; copy fac1 to fac2
+romsub $fe5a = SIGN() -> ubyte @ A                          ; SIGN(fac1) to A, $ff, $0, $1 for negative, zero, positive
+romsub $fe5d = SGN() clobbers(A,X,Y)                        ; fac1 = SGN(fac1), result of SIGN (-1, 0 or 1)
+romsub $fe60 = FREADSA(byte value @ A) clobbers(A,X,Y)      ; 8 bit signed A -> float in fac1
+romsub $fe6c = ABS()                                        ; fac1 = ABS(fac1)
+romsub $fe6f = FCOMP(uword mflpt @ AY) clobbers(X,Y) -> ubyte @ A   ; A = compare fac1 to mflpt in A/Y, 0=equal 1=fac1 is greater, 255=fac1 is less than
+romsub $fe78 = INT() clobbers(A,X,Y)                        ; INT() truncates, use FADDH first to round instead of trunc
+romsub $fe7e = FINLOG(byte value @A) clobbers (A, X, Y)           ; fac1 += signed byte in A
+romsub $fe81 = FOUT() clobbers(X) -> uword @ AY             ; fac1 -> string, address returned in AY
+romsub $fe8a = SQR() clobbers(A,X,Y)                        ; fac1 = SQRT(fac1)
+romsub $fe8d = FPWRT() clobbers(A,X,Y)                      ; fac1 = fac2 ** fac1
+romsub $fe93 = NEGOP() clobbers(A)                          ; switch the sign of fac1
+romsub $fe96 = EXP() clobbers(A,X,Y)                        ; fac1 = EXP(fac1)  (e ** fac1)
+romsub $fe9f = RND2(byte value @A) clobbers(A,X,Y)                ; fac1 = RND(A) float random number generator
+romsub $fea2 = RND() clobbers(A,X,Y)                        ; fac1 = RND(fac1) float random number generator
+romsub $fea5 = COS() clobbers(A,X,Y)                        ; fac1 = COS(fac1)
+romsub $fea8 = SIN() clobbers(A,X,Y)                        ; fac1 = SIN(fac1)
+romsub $feab = TAN() clobbers(A,X,Y)                        ; fac1 = TAN(fac1)
+romsub $feae = ATN() clobbers(A,X,Y)                        ; fac1 = ATN(fac1)
+
+
+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
+        sty  P8ZP_SCRATCH_B1
+        tya
+        ldy  P8ZP_SCRATCH_REG
+        jsr  GIVAYF                 ; load it as signed... correct afterwards
+        lda  P8ZP_SCRATCH_B1
+	    bpl  +
+	    lda  #<_flt65536
+	    ldy  #>_flt65536
+	    jsr  FADD
++	    plx
+        rts
+_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
+		tya
+		ldy  P8ZP_SCRATCH_REG
+		jmp  GIVAYF		; this uses the inverse order, Y/A
+	}}
+}
+
+asmsub  FTOSWRDAY  () clobbers(X) -> uword @ AY  {
+	; ---- fac1 to signed word in A/Y
+	%asm {{
+		jsr  FTOSWORDYA	; note the inverse Y/A order
+		sta  P8ZP_SCRATCH_REG
+		tya
+		ldy  P8ZP_SCRATCH_REG
+		rts
+	}}
+}
+
+asmsub  GETADRAY  () clobbers(X) -> uword @ AY  {
+	; ---- fac1 to unsigned word in A/Y
+	%asm {{
+		jsr  GETADR		; this uses the inverse order, Y/A
+		sta  P8ZP_SCRATCH_B1
+		tya
+		ldy  P8ZP_SCRATCH_B1
+		rts
+	}}
+}
+
+sub  print_f  (float value) {
+	; ---- prints the floating point value (without a newline).
+	%asm {{
+		phx
+		lda  #<value
+		ldy  #>value
+		jsr  MOVFM		; load float into fac1
+		jsr  FOUT		; fac1 to string in A/Y
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		ldy  #0
+-		lda  (P8ZP_SCRATCH_W1),y
+		beq  +
+		jsr  c64.CHROUT
+		iny
+		bne  -
+		plx
++		rts
+	}}
+}
+
+%asminclude "library:c64floats.asm", ""
+
+}

compiler/res/prog8lib/cx16lib.p8

@@ -5,6 +5,8 @@
 ;
 ; indent format: TABS, size=8
 
+%target cx16
+
 
 c64 {
 
@@ -14,42 +16,42 @@ c64 {
 ; 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 $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 $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 $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 $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 $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 $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
@@ -58,116 +60,186 @@ romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base addr
 
 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  = $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
+    &ubyte  VERA_ADDR_L   	  = VERA_BASE + $00
+    &ubyte  VERA_ADDR_M   	  = VERA_BASE + $01
+    &ubyte  VERA_ADDR_H   	  = VERA_BASE + $02
+    &ubyte  VERA_DATA0        = VERA_BASE + $03
+    &ubyte  VERA_DATA1        = VERA_BASE + $04
+    &ubyte  VERA_CTRL         = VERA_BASE + $05
+    &ubyte  VERA_IEN          = VERA_BASE + $06
+    &ubyte  VERA_ISR          = VERA_BASE + $07
+    &ubyte  VERA_IRQ_LINE_L   = VERA_BASE + $08
+    &ubyte  VERA_DC_VIDEO     = VERA_BASE + $09
+    &ubyte  VERA_DC_HSCALE    = VERA_BASE + $0A
+    &ubyte  VERA_DC_VSCALE    = VERA_BASE + $0B
+    &ubyte  VERA_DC_BORDER    = VERA_BASE + $0C
+    &ubyte  VERA_DC_HSTART    = VERA_BASE + $09
+    &ubyte  VERA_DC_HSTOP     = VERA_BASE + $0A
+    &ubyte  VERA_DC_VSTART    = VERA_BASE + $0B
+    &ubyte  VERA_DC_VSTOP     = VERA_BASE + $0C
+    &ubyte  VERA_L0_CONFIG    = VERA_BASE + $0D
+    &ubyte  VERA_L0_MAPBASE   = VERA_BASE + $0E
+    &ubyte  VERA_L0_TILEBASE  = VERA_BASE + $0F
+    &ubyte  VERA_L0_HSCROLL_L = VERA_BASE + $10
+    &ubyte  VERA_L0_HSCROLL_H = VERA_BASE + $11
+    &ubyte  VERA_L0_VSCROLL_L = VERA_BASE + $12
+    &ubyte  VERA_L0_VSCROLL_H = VERA_BASE + $13
+    &ubyte  VERA_L1_CONFIG    = VERA_BASE + $14
+    &ubyte  VERA_L1_MAPBASE   = VERA_BASE + $15
+    &ubyte  VERA_L1_TILEBASE  = VERA_BASE + $16
+    &ubyte  VERA_L1_HSCROLL_L = VERA_BASE + $17
+    &ubyte  VERA_L1_HSCROLL_H = VERA_BASE + $18
+    &ubyte  VERA_L1_VSCROLL_L = VERA_BASE + $19
+    &ubyte  VERA_L1_VSCROLL_H = VERA_BASE + $1A
+    &ubyte  VERA_AUDIO_CTRL   = VERA_BASE + $1B
+    &ubyte  VERA_AUDIO_RATE   = VERA_BASE + $1C
+    &ubyte  VERA_AUDIO_DATA   = VERA_BASE + $1D
+    &ubyte  VERA_SPI_DATA     = VERA_BASE + $1E
+    &ubyte  VERA_SPI_CTRL     = VERA_BASE + $1F
+; 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
 
-; the sixteen virtual 16-bit registers
-&ubyte r0  = $02
-&ubyte r0L = $02
-&ubyte r0H = $03
-&ubyte r1  = $04
-&ubyte r1L = $04
-&ubyte r1H = $05
-&ubyte r2  = $06
-&ubyte r2L = $06
-&ubyte r2H = $07
-&ubyte r3  = $08
-&ubyte r3L = $08
-&ubyte r3H = $09
-&ubyte r4  = $0a
-&ubyte r4L = $0a
-&ubyte r4H = $0b
-&ubyte r5  = $0c
-&ubyte r5L = $0c
-&ubyte r5H = $0d
-&ubyte r6  = $0e
-&ubyte r6L = $0e
-&ubyte r6H = $0f
-&ubyte r7  = $10
-&ubyte r7L = $10
-&ubyte r7H = $11
-&ubyte r8  = $12
-&ubyte r8L = $12
-&ubyte r8H = $13
-&ubyte r9  = $14
-&ubyte r9L = $14
-&ubyte r9H = $15
-&ubyte r10 = $16
-&ubyte r10L    = $16
-&ubyte r10H    = $17
-&ubyte r11     = $18
-&ubyte r11L    = $18
-&ubyte r11H    = $19
-&ubyte r12     = $1a
-&ubyte r12L    = $1a
-&ubyte r12H    = $1b
-&ubyte r13     = $1c
-&ubyte r13L    = $1c
-&ubyte r13H    = $1d
-&ubyte r14     = $1e
-&ubyte r14L    = $1e
-&ubyte r14H    = $1f
-&ubyte r15     = $20
-&ubyte r15L    = $20
-&ubyte r15H    = $21
-
-
-; TODO subroutine args + soubroutine returnvalues + clobber registers
+; TODO specify the correct clobbers for alle these functions, for simplicity all 3 regs are marked clobbered atm
 
 ; supported C128 additions
-romsub $ff4a = close_all()
-romsub $ff59 = lkupla()
-romsub $ff5c = lkupsa()
-romsub $ff5f = screen_set_mode()
-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()
+romsub $ff4a = close_all()  clobbers(A,X,Y)
+romsub $ff59 = lkupla()  clobbers(A,X,Y)
+romsub $ff5c = lkupsa()  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()
+romsub $ff65 = pfkey()  clobbers(A,X,Y)
+romsub $ff6e = jsrfar()  clobbers(A,X,Y)
+romsub $ff74 = fetch()  clobbers(A,X,Y)
+romsub $ff77 = stash()  clobbers(A,X,Y)
+romsub $ff7a = cmpare()  clobbers(A,X,Y)
+romsub $ff7d = primm()  clobbers(A,X,Y)
 
 ; X16 additions
-romsub $ff44 = macptr()
-romsub $ff47 = enter_basic()
-romsub $ff68 = mouse_config()
-romsub $ff6b = mouse_get()
-romsub $ff71 = mouse_scan()
-romsub $ff53 = joystick_scan()
-romsub $ff56 = joystick_get()
-romsub $ff4d = clock_set_date_time()
-romsub $ff50 = clock_get_date_time()
+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)            ; outout args: r0, r1, r2, r3L
 
 ; high level graphics & fonts
-romsub $ff20 = GRAPH_init()
-romsub $ff23 = GRAPH_clear()
-romsub $ff26 = GRAPH_set_window()
-romsub $ff29 = GRAPH_set_colors()
-romsub $ff2c = GRAPH_draw_line()
-romsub $ff2f = GRAPH_draw_rect()
-romsub $ff32 = GRAPH_move_rect()
-romsub $ff35 = GRAPH_draw_oval()
-romsub $ff38 = GRAPH_draw_image()
-romsub $ff3b = GRAPH_set_font()
-romsub $ff3e = GRAPH_get_char_size()
-romsub $ff41 = GRAPH_put_char()
+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
 
-; TODO framebuffer API not yet included, include it
+; 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
 
-romsub $fef0 = sprite_set_image()
-romsub $fef3 = sprite_set_position()
-romsub $fee4 = memory_fill()
-romsub $fee7 = memory_copy()
-romsub $feea = memory_crc()
-romsub $feed = memory_decompress()
-romsub $fedb = console_init()
-romsub $fede = console_put_char()
-romsub $fee1 = console_get_char()
-romsub $fed8 = console_put_image()
-romsub $fed5 = console_set_paging_message()
-romsub $fed2 = kbdbuf_put()
-romsub $fecf = entropy_get()
-romsub $fecc = monitor()
+; 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)
 
 
 
@@ -179,9 +251,11 @@ asmsub init_system()  {
     %asm {{
         sei
         cld
-        lda  #0
-        sta  $00
-        sta  $01
+        ;stz  $00
+        ;stz  $01
+        ;stz  d1prb      ; select rom bank 0
+        lda  #$80
+        sta  VERA_CTRL
         jsr  c64.IOINIT
         jsr  c64.RESTOR
         jsr  c64.CINT
@@ -191,9 +265,6 @@ asmsub init_system()  {
         clc
         clv
         cli
-        lda  #66
-        clc
-        jsr  console_put_char
         rts
     }}
 }

compiler/res/prog8lib/cx16textio.p8

@@ -4,23 +4,98 @@
 ;
 ; indent format: TABS, size=8
 
-
+%target cx16
 %import cx16lib
 %import conv
 
 
 txt {
 
-asmsub  clear_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
-	; ---- clear the character screen with the given fill character and character color.
-	;      (assumes screen and color matrix are at their default addresses)
+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 {{
-	    brk     ; TODO
-        }}
+        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
+    }}
 
 }
 
+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 {{
+        pha
+        phx
+        jsr  c64.SCREEN             ; get dimensions in X/Y
+        dex
+        dey
+        txa
+        asl  a
+        sta  P8ZP_SCRATCH_B1
+        pla
+-       ldx  P8ZP_SCRATCH_B1
+-       stz  cx16.VERA_ADDR_H
+        stx  cx16.VERA_ADDR_L
+        sty  cx16.VERA_ADDR_M
+        sta  cx16.VERA_DATA0
+        dex
+        dex
+        cpx  #254
+        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
@@ -42,7 +117,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
+		phx
 		jsr  conv.ubyte2decimal
 		pha
 		tya
@@ -51,7 +126,7 @@ asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
 		jsr  c64.CHROUT
 		txa
 		jsr  c64.CHROUT
-		ldx  P8ZP_SCRATCH_REG_X
+		plx
 		rts
 	}}
 }
@@ -59,7 +134,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
+		phx
 		jsr  conv.ubyte2decimal
 _print_byte_digits
 		pha
@@ -76,7 +151,7 @@ _print_byte_digits
         jsr  c64.CHROUT
 _ones   txa
 		jsr  c64.CHROUT
-		ldx  P8ZP_SCRATCH_REG_X
+		plx
 		rts
 	}}
 }
@@ -84,7 +159,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
+		phx
 		pha
 		cmp  #0
 		bpl  +
@@ -92,16 +167,14 @@ asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
 		jsr  c64.CHROUT
 +		pla
 		jsr  conv.byte2decimal
-		jsr  print_ub._print_byte_digits
-		ldx  P8ZP_SCRATCH_REG_X
-		rts
+		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 {{
-		stx  P8ZP_SCRATCH_REG_X
+		phx
 		bcc  +
 		pha
 		lda  #'$'
@@ -111,7 +184,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
+		plx
 		rts
 	}}
 }
@@ -119,7 +192,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
+		phx
 		sta  P8ZP_SCRATCH_B1
 		bcc  +
 		lda  #'%'
@@ -132,7 +205,7 @@ asmsub  print_ubbin  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
 +		jsr  c64.CHROUT
 		dey
 		bne  -
-		ldx  P8ZP_SCRATCH_REG_X
+		plx
 		rts
 	}}
 }
@@ -165,7 +238,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
+	    phx
 		jsr  conv.uword2decimal
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
@@ -173,7 +246,7 @@ asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
 		jsr  c64.CHROUT
 		iny
 		bne  -
-+		ldx  P8ZP_SCRATCH_REG_X
++		plx
 		rts
 	}}
 }
@@ -181,9 +254,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
+	    phx
 		jsr  conv.uword2decimal
-		ldx  P8ZP_SCRATCH_REG_X
+		plx
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
 		beq  _allzero
@@ -225,14 +298,45 @@ asmsub  print_w  (word value @ AY) clobbers(A,Y)  {
 	}}
 }
 
+; 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  {{
-		stx  P8ZP_SCRATCH_REG_X
+		phx
 		tax
 		clc
 		jsr  c64.PLOT
-		ldx  P8ZP_SCRATCH_REG_X
+		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
@@ -31,7 +35,7 @@ multiply_bytes_16	.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,9 +61,9 @@ multiply_words	.proc
 
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
-		stx  P8ZP_SCRATCH_REG_X
+		stx  P8ZP_SCRATCH_REG
 
-mult16		lda  #$00
+mult16		lda  #0
 		sta  result+2	; clear upper bits of product
 		sta  result+3
 		ldx  #16			; for all 16 bits...
@@ -79,20 +83,52 @@ mult16		lda  #$00
 		ror  result
 		dex
 		bne  -
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		rts
 
 result		.byte  0,0,0,0
 		.pend
 
 
+divmod_b_asm	.proc
+	; signed byte division: make everything positive and fix sign afterwards
+		sta  P8ZP_SCRATCH_B1
+		tya
+		eor  P8ZP_SCRATCH_B1
+		php			; save sign
+		lda  P8ZP_SCRATCH_B1
+		bpl  +
+		eor  #$ff
+		sec
+		adc  #0			; make it positive
++		pha
+		tya
+		bpl  +
+		eor  #$ff
+		sec
+		adc  #0			; make it positive
+		tay
++		pla
+		jsr  divmod_ub_asm
+		sta  _remainder
+		plp
+		bpl  +
+		tya
+		eor  #$ff
+		sec
+		adc  #0			; negate result
+		tay
++		rts
+_remainder	.byte  0
+		.pend
+
+
 divmod_ub_asm	.proc
-	; TODO divmod_ub_asm doesn't work correctly.  (remainder = ok, quotient = FAULTY)
 	; -- divide A by Y, result quotient in Y, remainder in A   (unsigned)
 	;    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
@@ -105,10 +141,53 @@ divmod_ub_asm	.proc
 		dex
 		bne  -
 		ldy  P8ZP_SCRATCH_B1
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  math_store_reg
 		rts
 		.pend
 
+divmod_w_asm	.proc
+	; signed word division: make everything positive and fix sign afterwards
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		lda  P8ZP_SCRATCH_W1+1
+		eor  P8ZP_SCRATCH_W2+1
+		php			; save sign
+		lda  P8ZP_SCRATCH_W1+1
+		bpl  +
+		lda  #0
+		sec
+		sbc  P8ZP_SCRATCH_W1
+		sta  P8ZP_SCRATCH_W1
+		lda  #0
+		sbc  P8ZP_SCRATCH_W1+1
+		sta  P8ZP_SCRATCH_W1+1
++		lda  P8ZP_SCRATCH_W2+1
+		bpl  +
+		lda  #0
+		sec
+		sbc  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_W2
+		lda  #0
+		sbc  P8ZP_SCRATCH_W2+1
+		sta  P8ZP_SCRATCH_W2+1
++		tay
+		lda  P8ZP_SCRATCH_W2
+		jsr  divmod_uw_asm
+		plp			; restore sign
+		bpl  +
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		lda  #0
+		sec
+		sbc  P8ZP_SCRATCH_W2
+		pha
+		lda  #0
+		sbc  P8ZP_SCRATCH_W2+1
+		tay
+		pla
++		rts
+		.pend
+
 divmod_uw_asm	.proc
 	; -- divide two unsigned words (16 bit each) into 16 bit results
 	;    input:  P8ZP_SCRATCH_W1 in ZP: 16 bit number, A/Y: 16 bit divisor
@@ -122,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
@@ -149,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
@@ -233,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
@@ -243,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
@@ -260,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
@@ -271,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
@@ -290,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
@@ -301,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
@@ -319,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
@@ -331,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
@@ -351,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
@@ -363,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
@@ -383,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
@@ -395,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
@@ -415,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
@@ -431,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
@@ -443,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
@@ -463,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
@@ -479,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
@@ -494,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
@@ -507,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
@@ -529,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
@@ -542,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
@@ -564,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
@@ -579,27 +659,26 @@ mul_byte_25	.proc
 		rts
 		.pend
 
-mul_word_25	.proc
-		; W + W*8 + W*16
+stack_mul_word_25	.proc
+		; 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
@@ -609,21 +688,16 @@ mul_word_25	.proc
 		rts
 		.pend
 
-mul_byte_40	.proc
-		; (X*4 + X)*8
+stack_mul_byte_40	.proc
 		lda  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-                clc
-		adc  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		asl  a
+		and  #7
+		tay
+		lda  mul_byte_40._forties,y
 		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
@@ -647,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  P8P_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/prog8lib.asm

@@ -686,7 +686,7 @@ func_sqrt16	.proc
 		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 +721,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
@@ -960,7 +960,7 @@ _result_maxuw	.word  0
 		.pend
 
 func_max_w	.proc
-		lda  #$00
+		lda  #0
 		sta  _result_maxw
 		lda  #$80
 		sta  _result_maxw+1
@@ -1216,7 +1216,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 +1233,7 @@ func_memcopy	.proc
 		iny
 		dex
 		bne  -
-		ldx  P8ZP_SCRATCH_REG_X
+		ldx  P8ZP_SCRATCH_REG
 		inx
 		inx
 		rts
@@ -1242,7 +1242,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 +1253,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 +1264,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 +1276,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 +1328,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 +1347,7 @@ _lastpage	ldy  P8ZP_SCRATCH_B1
 		bne  -
 
 +           	rts
+_save_reg	.byte  0
 		.pend
 
 

compiler/res/version.txt

@@ -1 +1 @@
-4.0
+4.2

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
@@ -36,12 +33,13 @@ fun pathFrom(stringPath: String, vararg rest: String): Path  = FileSystems.getDe
 
 private fun compileMain(args: Array<String>) {
     val cli = CommandLineInterface("prog8compiler")
-    val startEmulator by cli.flagArgument("-emu", "auto-start the Vice C-64 emulator after successful compilation")
+    val startEmulator by cli.flagArgument("-emu", "auto-start emulator after successful compilation")
     val outputDir by cli.flagValueArgument("-out", "directory", "directory for output files instead of current directory", ".")
     val dontWriteAssembly by cli.flagArgument("-noasm", "don't create assembly code")
     val dontOptimize by cli.flagArgument("-noopt", "don't perform any optimizations")
     val 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

@@ -140,7 +140,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())

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

@@ -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,
-            !it.stack?.text.isNullOrEmpty(), toPosition())
+    AsmSubroutineParameter(vardecl.varname.text, datatype, registerorpair, statusregister, toPosition())
 }
 
 private fun prog8Parser.Functioncall_stmtContext.toAst(): Statement {
@@ -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) {

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

@@ -56,8 +56,8 @@ enum class DataType {
         return when(this) {
             in ByteDatatypes -> 1
             in WordDatatypes -> 2
-            FLOAT -> CompilationTarget.machine.FLOAT_MEM_SIZE
-            in PassByReferenceDatatypes -> CompilationTarget.machine.POINTER_MEM_SIZE
+            FLOAT -> CompilationTarget.instance.machine.FLOAT_MEM_SIZE
+            in PassByReferenceDatatypes -> CompilationTarget.instance.machine.POINTER_MEM_SIZE
             else -> -9999999
         }
     }

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

@@ -642,7 +642,14 @@ class RangeExpr(var from: Expression,
             fromDt istype DataType.STR && toDt istype DataType.STR -> InferredTypes.knownFor(DataType.STR)
             fromDt istype DataType.WORD || toDt istype DataType.WORD -> InferredTypes.knownFor(DataType.ARRAY_W)
             fromDt istype DataType.BYTE || toDt istype DataType.BYTE -> InferredTypes.knownFor(DataType.ARRAY_B)
-            else -> InferredTypes.knownFor(DataType.ARRAY_UB)
+            else -> {
+                val fdt = fromDt.typeOrElse(DataType.STRUCT)
+                val tdt = toDt.typeOrElse(DataType.STRUCT)
+                if(fdt largerThan tdt)
+                    InferredTypes.knownFor(ElementArrayTypes.getValue(fdt))
+                else
+                    InferredTypes.knownFor(ElementArrayTypes.getValue(tdt))
+            }
         }
     }
     override fun toString(): String {
@@ -664,8 +671,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()
-            toVal = CompilationTarget.encodeString(toString.value, fromString.altEncoding)[0].toInt()
+            fromVal = CompilationTarget.instance.encodeString(fromString.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

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
 
@@ -118,6 +120,11 @@ internal class AstChecker(private val program: Program,
             if(loopvar==null || loopvar.type== VarDeclType.CONST) {
                 errors.err("for loop requires a variable to loop with", forLoop.position)
             } else {
+
+                fun checkLoopRangeValues() {
+
+                }
+
                 when (loopvar.datatype) {
                     DataType.UBYTE -> {
                         if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.ARRAY_UB && iterableDt != DataType.STR)
@@ -142,6 +149,22 @@ internal class AstChecker(private val program: Program,
                     }
                     else -> errors.err("loop variable must be numeric type", forLoop.position)
                 }
+                if(errors.isEmpty()) {
+                    // check loop range values
+                    val range = forLoop.iterable as? RangeExpr
+                    if(range!=null) {
+                        val from = range.from as? NumericLiteralValue
+                        val to = range.to as? NumericLiteralValue
+                        if(from != null)
+                            checkValueTypeAndRange(loopvar.datatype, from)
+                        else if(!range.from.inferType(program).istype(loopvar.datatype))
+                            errors.err("range start value is incompatible with loop variable type", range.position)
+                        if(to != null)
+                            checkValueTypeAndRange(loopvar.datatype, to)
+                        else if(!range.to.inferType(program).istype(loopvar.datatype))
+                            errors.err("range end value is incompatible with loop variable type", range.position)
+                    }
+                }
             }
         }
 
@@ -450,14 +473,11 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(decl: VarDecl) {
-        fun err(msg: String, position: Position?=null) {
-            errors.err(msg, position ?: decl.position)
-        }
+        fun err(msg: String, position: Position?=null) = 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?.referencesIdentifiers(decl.name) == true || decl.arraysize?.index?.referencesIdentifiers(decl.name) == true)
             err("recursive var declaration")
-        }
 
         // CONST can only occur on simple types (byte, word, float)
         if(decl.type== VarDeclType.CONST) {
@@ -465,10 +485,12 @@ internal class AstChecker(private val program: Program,
                 err("const modifier can only be used on numeric types (byte, word, float)")
         }
 
-        // FLOATS
-        if(!compilerOptions.floats && decl.datatype in setOf(DataType.FLOAT, DataType.ARRAY_F) && decl.type!= VarDeclType.MEMORY) {
+        // FLOATS enabled?
+        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) {
@@ -537,9 +559,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}")
-                        super.visit(decl)
-                        return
+                        if(decl.type==VarDeclType.CONST) {
+                            err("const declaration needs a compile-time constant initializer value, or range")
+                            super.visit(decl)
+                            return
+                        }
                     }
                 }
             }
@@ -688,6 +712,14 @@ internal class AstChecker(private val program: Program,
                 else if(directive.args.map{it.name in setOf("enable_floats", "force_output")}.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)
@@ -915,9 +947,6 @@ internal class AstChecker(private val program: Program,
                     val argIDt = arg.first.value.inferType(program)
                     if (!argIDt.isKnown)
                         return
-                    if (target.asmParameterRegisters[arg.first.index].registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.XY, RegisterOrPair.X)
-                            && arg.first.value !is NumericLiteralValue && arg.first.value !is IdentifierReference)
-                        errors.warn("calling a subroutine that expects X as a parameter is problematic. If you see a compiler error/crash about this later, try to change this call", position)
                 }
             }
         }
@@ -1138,7 +1167,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]
@@ -40,7 +40,7 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
         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 +74,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
@@ -119,7 +119,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) {

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

@@ -12,6 +12,7 @@ internal class AstVariousTransforms(private val program: Program) : AstWalker()
 
     override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
         if(functionCallStatement.target.nameInSource == listOf("swap")) {
+            // TODO don't replace swap(), let the code generator figure this all out
             // 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:

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

@@ -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 {

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)
@@ -139,6 +154,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/statements/AstStatements.kt

@@ -657,6 +657,7 @@ class Subroutine(override val name: String,
     }
 
     fun regXasResult() = asmReturnvaluesRegisters.any { it.registerOrPair in setOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
+    fun regXasParam() = asmParameterRegisters.any { it.registerOrPair in setOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
 
     fun amountOfRtsInAsm(): Int = statements
             .asSequence()

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,7 +15,7 @@ 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) {
+        if (decl.value == null && !decl.autogeneratedDontRemove && decl.type == VarDeclType.VAR && decl.datatype in NumericDatatypes) {
             // a numeric vardecl without an initial value is initialized with zero.
             decl.value = decl.zeroElementValue()
         }
@@ -54,7 +55,8 @@ internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: E
                 }
             }
             if (!conflicts) {
-                val numericVarsWithValue = decls.filter { it.value != null && it.datatype in NumericDatatypes }
+                // move vardecls of the scope into the upper scope. Make sure the order remains the same!
+                val numericVarsWithValue = decls.filter { it.value != null && it.datatype in NumericDatatypes }.reversed()
                 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)
@@ -114,6 +116,18 @@ 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) {

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 compilationTarget: String?)
 
 
 class CompilerException(message: String?) : Exception(message)

compiler/src/prog8/compiler/Main.kt

@@ -4,7 +4,9 @@ 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.UnusedCodeRemover
 import prog8.optimizer.constantFold
 import prog8.optimizer.optimizeStatements
@@ -13,6 +15,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 +28,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
@@ -90,8 +103,8 @@ 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
-    CompilationTarget.machine.importLibs(compilerOptions, importer, programAst)
+    // depending on the machine and compiler options we may have to include some libraries
+    CompilationTarget.instance.machine.importLibs(compilerOptions, importer, programAst)
 
     // always import prog8lib and math
     importer.importLibraryModule(programAst, "math")
@@ -129,16 +142,26 @@ private fun determineCompilationOptions(program: Program): CompilationOptions {
             .map { it[0].int!!..it[1].int!! }
             .toList()
 
+    var target = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%target" }
+            as? Directive)?.args?.single()?.name
+
+    when(target) {
+        C64Target.name -> CompilationTarget.instance = C64Target
+        Cx16Target.name -> CompilationTarget.instance = Cx16Target
+        null -> target = CompilationTarget.instance.name
+        else -> throw FatalAstException("invalid target")
+    }
+
     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, target
     )
 }
 
 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)
@@ -191,11 +214,14 @@ private fun writeAssembly(programAst: Program, errors: ErrorReporter, outputDir:
 
     // printAst(programAst)
 
-    CompilationTarget.machine.initializeZeropage(compilerOptions)
-    val assembly = CompilationTarget.asmGenerator(
+    if(compilerOptions.compilationTarget!=null && compilerOptions.compilationTarget != CompilationTarget.instance.name)
+        throw AssemblyError("program's compilation target differs from configured target")
+
+    CompilationTarget.instance.machine.initializeZeropage(compilerOptions)
+    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
 

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

@@ -4,15 +4,50 @@ 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
+    val asmForSystemReset: String
+    val initProcName: String?
+
     companion object {
-        lateinit var name: String
-        lateinit var machine: IMachineDefinition
-        lateinit var encodeString: (str: String, altEncoding: Boolean) -> List<Short>
-        lateinit var decodeString: (bytes: List<Short>, altEncoding: Boolean) -> String
-        lateinit var asmGenerator: (Program, ErrorReporter, Zeropage, CompilationOptions, Path) -> IAssemblyGenerator
+        lateinit var instance: CompilationTarget
     }
 }
+
+
+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)
+    override val asmForSystemReset = "  sei |  lda  #14 |  sta  $1 |  jmp  (c64.RESET_VEC)"
+    override val initProcName = "c64.init_system"
+}
+
+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)
+    override val asmForSystemReset = "  sei |  stz  cx16.d1prb |  jmp  (cx16.RESET_VEC)"
+    override val initProcName = "cx16.init_system"
+}

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

@@ -11,6 +11,11 @@ internal interface IMachineFloat {
     fun makeFloatFillAsm(): String
 }
 
+internal enum class CpuType {
+    CPU6502,
+    CPU65c02
+}
+
 internal interface IMachineDefinition {
     val FLOAT_MAX_NEGATIVE: Double
     val FLOAT_MAX_POSITIVE: Double
@@ -23,8 +28,7 @@ internal interface IMachineDefinition {
 
     val opcodeNames: Set<String>
     var zeropage: Zeropage
-    val initSystemProcname: String
-    val cpu: String
+    val cpu: CpuType
 
     fun initializeZeropage(compilerOptions: CompilationOptions)
     fun getFloat(num: Number): IMachineFloat

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

@@ -2,6 +2,7 @@ package prog8.compiler.target.c64
 
 import prog8.ast.Program
 import prog8.compiler.*
+import prog8.compiler.target.CpuType
 import prog8.compiler.target.IMachineDefinition
 import prog8.compiler.target.IMachineFloat
 import prog8.parser.ModuleImporter
@@ -12,7 +13,7 @@ import kotlin.math.pow
 
 internal object C64MachineDefinition: IMachineDefinition {
 
-    override val cpu = "6502"
+    override val cpu = CpuType.CPU6502
 
     // 5-byte cbm MFLPT format limitations:
     override val FLOAT_MAX_POSITIVE = 1.7014118345e+38         // bytes: 255,127,255,255,255
@@ -28,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)
 
@@ -37,7 +37,7 @@ 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.FL_ZERO"
+            floatbytes.contentEquals(shortArrayOf(0x00, 0x00, 0x00, 0x00, 0x00)) -> return "c64flt.ZERO"        // not a ROM const
             floatbytes.contentEquals(shortArrayOf(0x82, 0x49, 0x0f, 0xda, 0xa1)) -> return "c64flt.FL_PIVAL"
             floatbytes.contentEquals(shortArrayOf(0x90, 0x80, 0x00, 0x00, 0x00)) -> return "c64flt.FL_N32768"
             floatbytes.contentEquals(shortArrayOf(0x81, 0x00, 0x00, 0x00, 0x00)) -> return "c64flt.FL_FONE"
@@ -108,7 +108,6 @@ 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
 
@@ -126,7 +125,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) {
@@ -169,7 +168,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/codegen/AsmGen.kt

@@ -9,6 +9,7 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.compiler.*
 import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.CpuType
 import prog8.compiler.target.IAssemblyGenerator
 import prog8.compiler.target.IAssemblyProgram
 import prog8.compiler.target.c64.AssemblyProgram
@@ -34,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>>()
@@ -78,7 +83,11 @@ internal class AsmGen(private val program: Program,
 
     private fun header() {
         val ourName = this.javaClass.name
-        val cpu = CompilationTarget.machine.cpu
+        val cpu = when(CompilationTarget.instance.machine.cpu) {
+            CpuType.CPU6502 -> "6502"
+            CpuType.CPU65c02 -> "65c02"
+            else -> "unsupported"
+        }
 
         out("; $cpu assembly code for '${program.name}'")
         out("; generated by $ourName on ${LocalDateTime.now().withNano(0)}")
@@ -89,18 +98,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 initproc = CompilationTarget.machine.initSystemProcname
+        val zp = CompilationTarget.instance.machine.zeropage
         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_HI = ${CompilationTarget.machine.ESTACK_HI.toHex()}")
+        out("P8ESTACK_LO = ${CompilationTarget.instance.machine.ESTACK_LO.toHex()}")
+        out("P8ESTACK_HI = ${CompilationTarget.instance.machine.ESTACK_HI.toHex()}")
 
         when {
             options.launcher == LauncherType.BASIC -> {
@@ -115,16 +122,16 @@ internal class AsmGen(private val program: Program,
                 out("_prog8_entrypoint\t; assembly code starts here\n")
                 out("  tsx")
                 out("  stx  prog8_lib.orig_stackpointer")
-                if(!initproc.isNullOrEmpty())
-                    out("  jsr  $initproc")
+                if(!CompilationTarget.instance.initProcName.isNullOrEmpty())
+                    out("  jsr  ${CompilationTarget.instance.initProcName}")
             }
             options.output == OutputType.PRG -> {
                 out("; ---- program without basic sys call ----")
                 out("* = ${program.actualLoadAddress.toHex()}\n")
                 out("  tsx")
                 out("  stx  prog8_lib.orig_stackpointer")
-                if(!initproc.isNullOrEmpty())
-                    out("  jsr  $initproc")
+                if(!CompilationTarget.instance.initProcName.isNullOrEmpty())
+                    out("  jsr  ${CompilationTarget.instance.initProcName}")
             }
             options.output == OutputType.RAW -> {
                 out("; ---- raw assembler program ----")
@@ -156,7 +163,7 @@ internal class AsmGen(private val program: Program,
             }
             Zeropage.ExitProgramStrategy.SYSTEM_RESET -> {
                 out("  jsr  main.start\t; call program entrypoint")
-                out("  jmp  (c64.RESET_VEC)\t; cold reset")
+                out(CompilationTarget.instance.asmForSystemReset)
             }
         }
     }
@@ -165,7 +172,7 @@ internal class AsmGen(private val program: Program,
         // 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")
         }
@@ -335,7 +342,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))
@@ -469,7 +476,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]
@@ -543,22 +550,59 @@ 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 val saveRegisterLabels = Stack<String>();
+
     internal fun saveRegister(register: CpuRegister) {
         when(register) {
             CpuRegister.A -> out("  pha")
-            CpuRegister.X -> out("  txa | pha")
-            CpuRegister.Y -> out("  tya | pha")
+            CpuRegister.X -> {
+                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phx")
+                else {
+                    val save = makeLabel("saveX")
+                    saveRegisterLabels.push(save)
+                    out("""
+            stx  $save
+            jmp  +
+$save       .byte 0
++""")
+                }
+            }
+            CpuRegister.Y -> {
+                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phy")
+                else {
+                    val save = makeLabel("saveY")
+                    out("""
+            sty  $save
+            jmp  +
+$save       .byte 0
++""")
+                }
+            }
         }
     }
 
     internal fun restoreRegister(register: CpuRegister) {
         when(register) {
             CpuRegister.A -> out("  pla")
-            CpuRegister.X -> out("  pla | tax")
-            CpuRegister.Y -> out("  pla | tay")
+            CpuRegister.X -> {
+                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  plx")
+                else {
+                    val save = saveRegisterLabels.pop()
+                    out("  ldx  $save")
+                }
+            }
+            CpuRegister.Y -> {
+                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  ply")
+                else {
+                    val save = saveRegisterLabels.pop()
+                    out("  ldy  $save")
+                }
+            }
         }
     }
 
+
     internal fun translate(stmt: Statement) {
         outputSourceLine(stmt)
         when(stmt) {
@@ -669,7 +713,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")
                 }
             }
@@ -707,7 +751,7 @@ internal class AsmGen(private val program: Program,
                 expressionsAsmGen.translateExpression(index)
                 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")
                 }
             }
@@ -777,16 +821,38 @@ internal class AsmGen(private val program: Program,
             }
 
     private fun translate(stmt: IfStatement) {
-        expressionsAsmGen.translateExpression(stmt.condition)
-        translateTestStack(stmt.condition.inferType(program).typeOrElse(DataType.STRUCT))
-        val elseLabel = makeLabel("if_else")
-        val endLabel = makeLabel("if_end")
-        out("  beq  $elseLabel")
-        translate(stmt.truepart)
-        out("  jmp  $endLabel")
-        out(elseLabel)
-        translate(stmt.elsepart)
-        out(endLabel)
+        when {
+            stmt.elsepart.containsNoCodeNorVars() -> {
+                // empty else
+                expressionsAsmGen.translateExpression(stmt.condition)
+                translateTestStack(stmt.condition.inferType(program).typeOrElse(DataType.STRUCT))
+                val endLabel = makeLabel("if_end")
+                out("  beq  $endLabel")
+                translate(stmt.truepart)
+                out(endLabel)
+            }
+            stmt.truepart.containsNoCodeNorVars() -> {
+                // empty true part
+                expressionsAsmGen.translateExpression(stmt.condition)
+                translateTestStack(stmt.condition.inferType(program).typeOrElse(DataType.STRUCT))
+                val endLabel = makeLabel("if_end")
+                out("  bne  $endLabel")
+                translate(stmt.elsepart)
+                out(endLabel)
+            }
+            else -> {
+                expressionsAsmGen.translateExpression(stmt.condition)
+                translateTestStack(stmt.condition.inferType(program).typeOrElse(DataType.STRUCT))
+                val elseLabel = makeLabel("if_else")
+                val endLabel = makeLabel("if_end")
+                out("  beq  $elseLabel")
+                translate(stmt.truepart)
+                out("  jmp  $endLabel")
+                out(elseLabel)
+                translate(stmt.elsepart)
+                out(endLabel)
+            }
+        }
     }
 
     private fun translateTestStack(dataType: DataType) {

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

@@ -151,7 +151,8 @@ 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")) {
+                fifth.startsWith("lda") && sixth.startsWith("ldy") &&
+                (seventh.startsWith("jsr  c64flt.copy_float") || seventh.startsWith("jsr  cx16flt.copy_float"))) {
 
             val nineth = pair[8].value.trimStart()
             val tenth = pair[9].value.trimStart()
@@ -161,7 +162,8 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
             val fourteenth = pair[13].value.trimStart()
 
             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")) {
+                    twelveth.startsWith("lda") && thirteenth.startsWith("ldy") &&
+                    (fourteenth.startsWith("jsr  c64flt.copy_float") || fourteenth.startsWith("jsr  cx16flt.copy_float"))) {
 
                 if(first.substring(4) == eighth.substring(4) && second.substring(4)==nineth.substring(4)) {
                     // identical float init

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

@@ -4,6 +4,8 @@ import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.compiler.AssemblyError
+import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.CpuType
 import prog8.compiler.toHex
 import prog8.functions.BuiltinFunctions
 import kotlin.math.absoluteValue
@@ -45,15 +47,28 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                             RegisterOrPair.AY -> asmgen.out("  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
                             RegisterOrPair.X -> {
                                 // return value in X register has been discarded, just push a zero
-                                asmgen.out("  lda  #0 |  sta  P8ESTACK_LO,x |  dex")
+                                if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                                    asmgen.out("  stz  P8ESTACK_LO,x")
+                                else
+                                    asmgen.out("  lda  #0 |  sta  P8ESTACK_LO,x")
+                                asmgen.out("  dex")
                             }
                             RegisterOrPair.AX -> {
                                 // return value in X register has been discarded, just push a zero in this place
-                                asmgen.out("  sta  P8ESTACK_LO,x |  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
+                                asmgen.out("  sta  P8ESTACK_LO,x")
+                                if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                                    asmgen.out("  stz  P8ESTACK_HI,x")
+                                else
+                                    asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x")
+                                asmgen.out("  dex")
                             }
                             RegisterOrPair.XY -> {
                                 // return value in X register has been discarded, just push a zero in this place
-                                asmgen.out("  lda  #0 |  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
+                                if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                                    asmgen.out("  stz  P8ESTACK_LO,x")
+                                else
+                                    asmgen.out("  lda  #0 |  sta  P8ESTACK_LO,x")
+                                asmgen.out("  tya |  sta  P8ESTACK_HI,x |  dex")
                             }
                         }
                     }
@@ -69,7 +84,12 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
             DataType.UBYTE -> {
                 when(expr.type) {
                     DataType.UBYTE, DataType.BYTE -> {}
-                    DataType.UWORD, DataType.WORD -> asmgen.out("  lda  #0  |  sta  P8ESTACK_HI+1,x")
+                    DataType.UWORD, DataType.WORD -> {
+                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                            asmgen.out("  stz  P8ESTACK_HI+1,x")
+                        else
+                            asmgen.out("  lda  #0  |  sta  P8ESTACK_HI+1,x")
+                    }
                     DataType.FLOAT -> asmgen.out(" jsr  c64flt.stack_ub2float")
                     in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
                     else -> throw AssemblyError("weird type")
@@ -187,9 +207,6 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
         }
     }
 
-    private val optimizedByteMultiplications = setOf(3,5,6,7,9,10,11,12,13,14,15,20,25,40)
-    private val optimizedWordMultiplications = setOf(3,5,6,7,9,10,12,15,20,25,40)
-
     private fun translateExpression(expr: BinaryExpression) {
         val leftIDt = expr.left.inferType(program)
         val rightIDt = expr.right.inferType(program)
@@ -283,40 +300,40 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                         val amount = value.number.toInt()
                         when(rightDt) {
                             DataType.UBYTE -> {
-                                if(amount in optimizedByteMultiplications) {
+                                if(amount in asmgen.optimizedByteMultiplications) {
                                     translateExpression(expr.left)
-                                    asmgen.out(" jsr  math.mul_byte_$amount")
+                                    asmgen.out(" jsr  math.stack_mul_byte_$amount")
                                     return
                                 }
                             }
                             DataType.BYTE -> {
-                                if(amount in optimizedByteMultiplications) {
+                                if(amount in asmgen.optimizedByteMultiplications) {
                                     translateExpression(expr.left)
-                                    asmgen.out(" jsr  math.mul_byte_$amount")
+                                    asmgen.out(" jsr  math.stack_mul_byte_$amount")
                                     return
                                 }
-                                if(amount.absoluteValue in optimizedByteMultiplications) {
+                                if(amount.absoluteValue in asmgen.optimizedByteMultiplications) {
                                     translateExpression(expr.left)
-                                    asmgen.out(" jsr  prog8_lib.neg_b |  jsr  math.mul_byte_${amount.absoluteValue}")
+                                    asmgen.out(" jsr  prog8_lib.neg_b |  jsr  math.stack_mul_byte_${amount.absoluteValue}")
                                     return
                                 }
                             }
                             DataType.UWORD -> {
-                                if(amount in optimizedWordMultiplications) {
+                                if(amount in asmgen.optimizedWordMultiplications) {
                                     translateExpression(expr.left)
-                                    asmgen.out(" jsr  math.mul_word_$amount")
+                                    asmgen.out(" jsr  math.stack_mul_word_$amount")
                                     return
                                 }
                             }
                             DataType.WORD -> {
-                                if(amount in optimizedWordMultiplications) {
+                                if(amount in asmgen.optimizedWordMultiplications) {
                                     translateExpression(expr.left)
-                                    asmgen.out(" jsr  math.mul_word_$amount")
+                                    asmgen.out(" jsr  math.stack_mul_word_$amount")
                                     return
                                 }
-                                if(amount.absoluteValue in optimizedWordMultiplications) {
+                                if(amount.absoluteValue in asmgen.optimizedWordMultiplications) {
                                     translateExpression(expr.left)
-                                    asmgen.out(" jsr  prog8_lib.neg_w |  jsr  math.mul_word_${amount.absoluteValue}")
+                                    asmgen.out(" jsr  prog8_lib.neg_w |  jsr  math.stack_mul_word_${amount.absoluteValue}")
                                     return
                                 }
                             }

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

@@ -46,7 +46,7 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen:
             DataType.ARRAY_B, DataType.ARRAY_UB -> {
                 if (stepsize==1 || stepsize==-1) {
 
-                    // bytes, step 1 or -1
+                    // bytes array, step 1 or -1
 
                     val incdec = if(stepsize==1) "inc" else "dec"
                     // loop over byte range via loopvar
@@ -258,13 +258,6 @@ $endLabel       inx""")
         asmgen.loopEndLabels.pop()
     }
 
-    private fun assignLoopvar(stmt: ForLoop, range: RangeExpr) {
-        val target = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, stmt.loopVarDt(program).typeOrElse(DataType.STRUCT), variable=stmt.loopVar)
-        val src = AsmAssignSource.fromAstSource(range.from, program).adjustDataTypeToTarget(target)
-        val assign = AsmAssignment(src, target, false, range.position)
-        asmgen.translateNormalAssignment(assign)
-    }
-
     private fun translateForOverIterableVar(stmt: ForLoop, iterableDt: DataType, ident: IdentifierReference) {
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
@@ -615,4 +608,11 @@ $loopLabel""")
 $endLabel""")
         asmgen.loopEndLabels.pop()
     }
+
+    private fun assignLoopvar(stmt: ForLoop, range: RangeExpr) {
+        val target = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, stmt.loopVarDt(program).typeOrElse(DataType.STRUCT), variable=stmt.loopVar)
+        val src = AsmAssignSource.fromAstSource(range.from, program).adjustDataTypeToTarget(target)
+        val assign = AsmAssignment(src, target, false, range.position)
+        asmgen.translateNormalAssignment(assign)
+    }
 }

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

@@ -4,6 +4,7 @@ import prog8.ast.IFunctionCall
 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
@@ -16,9 +17,9 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         // output the code to setup the parameters and perform the actual call
         // does NOT output the code to deal with the result values!
         val sub = stmt.target.targetSubroutine(program.namespace) ?: throw AssemblyError("undefined subroutine ${stmt.target}")
-        val saveX = CpuRegister.X in sub.asmClobbers || sub.regXasResult()
+        val saveX = CpuRegister.X in sub.asmClobbers || sub.regXasResult() || sub.regXasParam()
         if(saveX)
-            asmgen.out("  stx  P8ZP_SCRATCH_REG_X")        // we only save X for now (required! is the eval stack pointer), screw A and Y...
+            asmgen.saveRegister(CpuRegister.X)
 
         val subName = asmgen.asmSymbolName(stmt.target)
         if(stmt.args.isNotEmpty()) {
@@ -57,39 +58,85 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         asmgen.out("  jsr  $subName")
 
         if(saveX)
-            asmgen.out("  ldx  P8ZP_SCRATCH_REG_X")        // restore X again
+            asmgen.restoreRegister(CpuRegister.X)
     }
 
     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 -> {
-                    asmgen.out("""
-                        inx
-                        pha
-                        lda  P8ESTACK_LO,x
-                        beq  +
-                        sec  
-                        bcs  ++
-+                       clc
-+                       pla""")
+                argi.value.second.stack -> TODO("asmsub @stack parameter")
+                argi.value.second.statusflag == Statusflag.Pc -> {
+                    require(argForCarry == null)
+                    argForCarry = argi
                 }
-                regparam.statusflag!=null -> {
-                    throw AssemblyError("can only use Carry as status flag parameter")
+                argi.value.second.statusflag != null -> 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 -> {
-                    val tgt = AsmAssignTarget.fromRegisters(regparam.registerOrPair, program, asmgen)
-                    val source = AsmAssignSource(SourceStorageKind.STACK, program, tgt.datatype)
-                    val asgn = AsmAssignment(source, tgt, false, Position.DUMMY)
-                    asmgen.translateNormalAssignment(asgn)
+                argi.value.second.registerOrPair in setOf(RegisterOrPair.A, RegisterOrPair.AY) -> {
+                    require(argForAregister == null)
+                    argForAregister = argi
                 }
-                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) {

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

@@ -97,7 +97,8 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                     }
                     else -> {
                         asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, elementDt, CpuRegister.A)
-                        asmgen.out("  stx  P8ZP_SCRATCH_REG_X |  tax")
+                        asmgen.saveRegister(CpuRegister.X)
+                        asmgen.out("  tax")
                         when(elementDt) {
                             in ByteDatatypes -> {
                                 asmgen.out(if(incr) "  inc  $asmArrayvarname,x" else "  dec  $asmArrayvarname,x")
@@ -124,7 +125,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                             }
                             else -> throw AssemblyError("weird array elt dt")
                         }
-                        asmgen.out("  ldx  P8ZP_SCRATCH_REG_X")
+                        asmgen.restoreRegister(CpuRegister.X)
                     }
                 }
             }

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

@@ -159,6 +159,7 @@ 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.memorySize() == target.datatype.memorySize()) { "source and target datatype must be same storage class" }
     }
 }

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

@@ -5,6 +5,8 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.compiler.AssemblyError
+import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.CpuType
 import prog8.compiler.target.c64.codegen.AsmGen
 import prog8.compiler.toHex
 
@@ -118,17 +120,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     is IdentifierReference -> throw AssemblyError("source kind should have been variable")
                     is ArrayIndexedExpression -> throw AssemblyError("source kind should have been array")
                     is DirectMemoryRead -> throw AssemblyError("source kind should have been memory")
-//                    is TypecastExpression -> {
-//                        if(assign.target.kind == TargetStorageKind.STACK) {
-//                            asmgen.translateExpression(value)
-//                            assignStackValue(assign.target)
-//                        } else {
-//                            println("!!!!TYPECAST to ${assign.target.kind} $value")
-//                            // TODO maybe we can do the typecast on the target directly instead of on the stack?
-//                            asmgen.translateExpression(value)
-//                            assignStackValue(assign.target)
-//                        }
-//                    }
+                    is TypecastExpression -> assignTypeCastedValue(assign.target, value.type, value.expression, assign)
 //                    is FunctionCall -> {
 //                        if (assign.target.kind == TargetStorageKind.STACK) {
 //                            asmgen.translateExpression(value)
@@ -159,6 +151,52 @@ 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 (valueDt == DataType.UBYTE || valueDt == DataType.BYTE) {
+                    if(targetDt in WordDatatypes) {
+                        assignVariableByteIntoWord(target, value, valueDt)
+                        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 -> {
@@ -258,16 +296,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")
                         }
                     }
@@ -516,6 +556,59 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
+    private fun assignVariableByteIntoWord(wordtarget: AsmAssignTarget, bytevar: IdentifierReference, valueDt: DataType) {
+        if(valueDt == DataType.BYTE)
+            TODO("sign extend byte to word")
+
+        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("other types aren't word")
+        }
+    }
+
     private fun assignRegisterByte(target: AsmAssignTarget, register: CpuRegister) {
         require(target.datatype in ByteDatatypes)
         when(target.kind) {
@@ -569,19 +662,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") }
                     }
                 }
             }
@@ -690,7 +789,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("""
@@ -706,7 +807,16 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             // optimized case for float zero
             when(target.kind) {
                 TargetStorageKind.VARIABLE -> {
-                    asmgen.out("""
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("""
+                            stz  ${target.asmVarname}
+                            stz  ${target.asmVarname}+1
+                            stz  ${target.asmVarname}+2
+                            stz  ${target.asmVarname}+3
+                            stz  ${target.asmVarname}+4
+                        """)
+                    else
+                        asmgen.out("""
                             lda  #0
                             sta  ${target.asmVarname}
                             sta  ${target.asmVarname}+1
@@ -836,7 +946,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("""
@@ -864,7 +976,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 -> {
@@ -875,6 +989,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

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

@@ -5,8 +5,10 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.CpuType
 import prog8.compiler.target.c64.codegen.AsmGen
 import prog8.compiler.toHex
+import kotlin.math.absoluteValue
 
 internal class AugmentableAssignmentAsmGen(private val program: Program,
                                            private val assignmentAsmGen: AssignmentAsmGen,
@@ -21,8 +23,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 // A = -A , A = +A, A = ~A, A = not A
                 val type = value.inferType(program).typeOrElse(DataType.STRUCT)
                 when (value.operator) {
-                    "+" -> {
-                    }
+                    "+" -> {}
                     "-" -> inplaceNegate(assign.target, type)
                     "~" -> inplaceInvert(assign.target, type)
                     "not" -> inplaceBooleanNot(assign.target, type)
@@ -125,7 +126,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                             ident != null -> inplaceModification_word_variable_to_variable(target.asmVarname, target.datatype, operator, ident)
                             // TODO more specialized code for types such as memory read etc.
 //                            value is DirectMemoryRead -> {
-//                                println("warning: slow stack evaluation used (8):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
+//                                println("warning: slow stack evaluation used (8):  $name $operator= ${value::class.simpleName} at ${value.position}")
 //                                // assignmentAsmGen.translateOtherAssignment(origAssign)
 //                                asmgen.translateExpression(value.addressExpression)
 //                                asmgen.out("""
@@ -134,7 +135,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 //                                    inx
 //                                    """)
 //                                inplaceModification_word_value_to_variable(name, operator, )
-//                                // TODO
 //                            }
                             value is TypecastExpression -> {
                                 if (tryRemoveRedundantCast(value, target, operator)) return
@@ -193,7 +193,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         asmgen.translateExpression(memory.addressExpression)
                         // TODO buggy?:
                         asmgen.out("  jsr  prog8_lib.read_byte_from_address_on_stack |  sta  P8ZP_SCRATCH_B1")
-                        val zp = CompilationTarget.machine.zeropage
+                        val zp = CompilationTarget.instance.machine.zeropage
                         when {
                             valueLv != null -> inplaceModification_byte_litval_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, valueLv.toInt())
                             ident != null -> inplaceModification_byte_variable_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, ident)
@@ -250,16 +250,18 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 else
                     asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
             }
-            "*" -> TODO("mul")// asmgen.out("  jsr  prog8_lib.mul_byte")  //  the optimized routines should have been checked earlier
-            "/" -> TODO("div")// asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.idiv_ub" else "  jsr  prog8_lib.idiv_b")
+            "*" -> {
+                TODO("mul mem byte")// asmgen.out("  jsr  prog8_lib.mul_byte")
+            }
+            "/" -> TODO("div mem byte")// asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.idiv_ub" else "  jsr  prog8_lib.idiv_b")
             "%" -> {
-                TODO("byte remainder")
+                TODO("mem byte remainder")
 //                if(types==DataType.BYTE)
 //                    throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
 //                asmgen.out("  jsr prog8_lib.remainder_ub")
             }
-            "<<" -> TODO("ubyte asl")
-            ">>" -> TODO("ubyte lsr")
+            "<<" -> TODO("mem ubyte asl")
+            ">>" -> TODO("mem ubyte lsr")
             "&" -> {
                 val (ptrOnZp, sourceName) = asmgen.loadByteFromPointerIntoA(pointervar)
                 asmgen.out(" and  P8ESTACK_LO+1,x")
@@ -309,16 +311,18 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 else
                     asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
             }
-            "*" -> TODO("mul")// asmgen.out("  jsr  prog8_lib.mul_byte")  //  the optimized routines should have been checked earlier
-            "/" -> TODO("div")// asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.idiv_ub" else "  jsr  prog8_lib.idiv_b")
+            "*" -> {
+                TODO("mem mul")// asmgen.out("  jsr  prog8_lib.mul_byte")
+            }
+            "/" -> TODO("mem div")// asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.idiv_ub" else "  jsr  prog8_lib.idiv_b")
             "%" -> {
-                TODO("byte remainder")
+                TODO("mem byte remainder")
 //                if(types==DataType.BYTE)
 //                    throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
 //                asmgen.out("  jsr prog8_lib.remainder_ub")
             }
-            "<<" -> TODO("ubyte asl")
-            ">>" -> TODO("ubyte lsr")
+            "<<" -> TODO("mem ubyte asl")
+            ">>" -> TODO("mem ubyte lsr")
             "&" -> {
                 val (ptrOnZp, sourceName) = asmgen.loadByteFromPointerIntoA(pointervar)
                 asmgen.out(" and  $otherName")
@@ -367,19 +371,23 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
             }
             "*" -> {
-                TODO("mul byte litval")
-                // asmgen.out("  jsr  prog8_lib.mul_byte")  //  the optimized routines should have been checked earlier
+                if(value in asmgen.optimizedByteMultiplications) {
+                    TODO("optimized mem mul ubyte litval $value")
+                } else {
+                    TODO("mem mul ubyte litval $value")
+                    // asmgen.out("  jsr  prog8_lib.mul_byte")
+                }
             }
             "/" -> {
                 if(value==0)
                     throw AssemblyError("division by zero")
-                TODO("div byte litval")
+                TODO("mem div byte litval")
                 // asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.idiv_ub" else "  jsr  prog8_lib.idiv_b")
             }
             "%" -> {
                 if(value==0)
                     throw AssemblyError("division by zero")
-                TODO("byte remainder litval")
+                TODO("mem byte remainder litval")
 //                if(types==DataType.BYTE)
 //                    throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
 //                asmgen.out("  jsr prog8_lib.remainder_ub")
@@ -442,14 +450,14 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             "+" -> asmgen.out(" lda  $name |  clc |  adc  P8ESTACK_LO+1,x |  sta  $name")
             "-" -> asmgen.out(" lda  $name |  sec |  sbc  P8ESTACK_LO+1,x |  sta  $name")
             "*" -> {
-                TODO("mul byte expr")
-                // asmgen.out("  jsr  prog8_lib.mul_byte")  //  the optimized routines should have been checked earlier
+                TODO("var mul byte expr")
+                // asmgen.out("  jsr  prog8_lib.mul_byte")
             }
             "/" -> {
-                TODO("div byte expr")// asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.idiv_ub" else "  jsr  prog8_lib.idiv_b")
+                TODO("var div byte expr")// asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.idiv_ub" else "  jsr  prog8_lib.idiv_b")
             }
             "%" -> {
-                TODO("byte remainder expr")
+                TODO("var byte remainder expr")
 //                if(types==DataType.BYTE)
 //                    throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
 //                asmgen.out("  jsr prog8_lib.remainder_ub")
@@ -506,7 +514,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             "*" -> asmgen.out(" lda  $name |  ldy  $otherName  |  jsr  math.multiply_bytes |  sta  $name")
             "/" -> {
                 if(dt==DataType.BYTE) {
-                    TODO("signed byte divide see prog8lib.idiv_b")
+                    asmgen.out(" lda  $name |  ldy  $otherName  |  jsr  math.divmod_b_asm |  sty  $name")
                 }
                 else {
                     asmgen.out(" lda  $name |  ldy  $otherName  |  jsr  math.divmod_ub_asm |  sty  $name")
@@ -572,9 +580,21 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             "+" -> asmgen.out(" lda  $name |  clc |  adc  #$value |  sta  $name")
             "-" -> asmgen.out(" lda  $name |  sec |  sbc  #$value |  sta  $name")
             "*" -> {
-                // TODO what about the optimized mul_5 etc routines?
-                TODO("byte mul litval")
-                // asmgen.out("  jsr  prog8_lib.mul_byte")  //  the optimized routines should have been checked earlier
+                if(dt == DataType.UBYTE) {
+                    if(value in asmgen.optimizedByteMultiplications) {
+                        asmgen.out("  lda  $name |  jsr  math.mul_byte_$value |  sta  $name")
+                    } else {
+                        TODO("var mul ubyte litval $value")
+                        // asmgen.out("  jsr  prog8_lib.mul_byte")
+                    }
+                } else {
+                    if(value.absoluteValue in asmgen.optimizedByteMultiplications) {
+                        asmgen.out("  lda  $name |  jsr  math.mul_byte_$value |  sta  $name")
+                    } else {
+                        TODO("var mul sbyte litval $value")
+                        // asmgen.out("  jsr  prog8_lib.mul_byte")
+                    }
+                }
             }
             "/" -> {
                 if (dt == DataType.UBYTE) {
@@ -585,7 +605,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         sty  $name                                              
                     """)
                 } else {
-                    TODO("BYTE div  litval")
+                    TODO("var BYTE div  litval")
                 }
             }
             "%" -> {
@@ -669,25 +689,48 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 }
             }
             "*" -> {
-                // TODO what about the optimized mul_5 etc routines?
-                asmgen.out("""
-                    lda  $name
-                    sta  P8ZP_SCRATCH_W1
-                    lda  $name+1
-                    sta  P8ZP_SCRATCH_W1+1
-                    lda  #<$value
-                    ldy  #>$value
-                    jsr  math.multiply_words
-                    lda  math.multiply_words.result
-                    sta  $name
-                    lda  math.multiply_words.result+1
-                    sta  $name+1""")
+                if(dt == DataType.UWORD){
+                    if(value in asmgen.optimizedWordMultiplications) {
+                        asmgen.out("  lda  $name |  ldy  $name+1 |  jsr  math.mul_word_$value |  sta  $name |  sty  $name+1")
+                    } else {
+                        TODO("var uword mul litval $value")
+                    }
+                } else {
+                    if(value.absoluteValue in asmgen.optimizedWordMultiplications) {
+                        asmgen.out("  lda  $name |  ldy  $name+1 |  jsr  math.mul_word_$value |  sta  $name |  sty  $name+1")
+                    } else {
+                        // TODO don't use stack here
+                        // TODO does this work for signed words?
+                        asmgen.out("""
+                        lda  $name
+                        sta  P8ZP_SCRATCH_W1
+                        lda  $name+1
+                        sta  P8ZP_SCRATCH_W1+1
+                        lda  #<$value
+                        ldy  #>$value
+                        jsr  math.multiply_words
+                        lda  math.multiply_words.result
+                        sta  $name
+                        lda  math.multiply_words.result+1
+                        sta  $name+1""")
+                    }
+                }
             }
             "/" -> {
                 if(value==0)
                     throw AssemblyError("division by zero")
                 if(dt==DataType.WORD) {
-                    TODO("signed word divide see prog8lib.idiv_w")
+                    asmgen.out("""
+                        lda  $name
+                        ldy  $name+1
+                        sta  P8ZP_SCRATCH_W1
+                        sty  P8ZP_SCRATCH_W1+1
+                        lda  #<$value
+                        ldy  #>$value
+                        jsr  math.divmod_w_asm
+                        sta  $name
+                        sty  $name+1
+                    """)
                 }
                 else {
                     asmgen.out("""
@@ -736,9 +779,26 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             "&" -> {
                 when {
-                    value == 0 -> asmgen.out(" lda  #0 |  sta  $name |  sta  $name+1")
-                    value and 255 == 0 -> asmgen.out(" lda  #0 |  sta  $name |  lda  $name+1 |  and  #>$value |  sta  $name+1")
-                    value < 0x0100 -> asmgen.out(" lda  $name |  and  #$value |  sta  $name |  lda  #0 |  sta  $name+1")
+                    value == 0 -> {
+                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            asmgen.out(" stz  $name |  stz  $name+1")
+                        else
+                            asmgen.out(" lda  #0 |  sta  $name |  sta  $name+1")
+                    }
+                    value and 255 == 0 -> {
+                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            asmgen.out(" stz  $name")
+                        else
+                            asmgen.out(" lda  #0 |  sta  $name")
+                        asmgen.out(" lda  $name+1 |  and  #>$value |  sta  $name+1")
+                    }
+                    value < 0x0100 -> {
+                        asmgen.out(" lda  $name |  and  #$value |  sta  $name")
+                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            asmgen.out("  stz  $name+1")
+                        else
+                            asmgen.out("  lda  #0 |  sta  $name+1")
+                    }
                     else -> asmgen.out(" lda  $name |  and  #<$value |  sta  $name |  lda  $name+1 |  and  #>$value |  sta  $name+1")
                 }
             }
@@ -845,7 +905,17 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     }
                     "/" -> {
                         if(dt==DataType.WORD) {
-                            TODO("signed word divide see prog8lib.idiv_w")
+                            asmgen.out("""
+                                lda  $name
+                                ldy  $name+1
+                                sta  P8ZP_SCRATCH_W1
+                                sty  P8ZP_SCRATCH_W1+1
+                                lda  $otherName
+                                ldy  $otherName+1
+                                jsr  math.divmod_w_asm
+                                sta  $name
+                                sty  $name+1
+                            """)
                         }
                         else {
                             asmgen.out("""
@@ -989,7 +1059,17 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     }
                     "/" -> {
                         if (dt == DataType.WORD) {
-                            TODO("signed word divide see prog8lib.idiv_w")
+                            asmgen.out("""
+                                lda  $name
+                                ldy  $name+1
+                                sta  P8ZP_SCRATCH_W1
+                                sty  P8ZP_SCRATCH_W1+1
+                                lda  P8ESTACK_LO+1,x
+                                ldy  P8ESTACK_HI+1,x
+                                jsr  math.divmod_w_asm
+                                sta  $name
+                                sty  $name+1
+                            """)
                         } else {
                             asmgen.out("""
                                 lda  $name
@@ -1041,11 +1121,11 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         // because the value is evaluated onto the eval stack (=slow).
         println("warning: slow stack evaluation used (2):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
         asmgen.translateExpression(value)
+        asmgen.out("  jsr  c64flt.pop_float_fac1")
+        asmgen.saveRegister(CpuRegister.X)
         when (operator) {
             "**" -> {
                 asmgen.out("""
-                    jsr  c64flt.pop_float_fac1
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$name
                     ldy  #>$name
                     jsr  c64flt.CONUPK
@@ -1054,8 +1134,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             "+" -> {
                 asmgen.out("""
-                    jsr  c64flt.pop_float_fac1
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$name
                     ldy  #>$name
                     jsr  c64flt.FADD
@@ -1063,8 +1141,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             "-" -> {
                 asmgen.out("""
-                    jsr  c64flt.pop_float_fac1
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$name
                     ldy  #>$name
                     jsr  c64flt.FSUB
@@ -1072,8 +1148,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             "*" -> {
                 asmgen.out("""
-                    jsr  c64flt.pop_float_fac1
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$name
                     ldy  #>$name
                     jsr  c64flt.FMULT
@@ -1081,8 +1155,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             "/" -> {
                 asmgen.out("""
-                    jsr  c64flt.pop_float_fac1
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$name
                     ldy  #>$name
                     jsr  c64flt.FDIV
@@ -1090,13 +1162,12 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             else -> throw AssemblyError("invalid operator for in-place float modification $operator")
         }
-        // store Fac1 back into memory
         asmgen.out("""
             ldx  #<$name
             ldy  #>$name
             jsr  c64flt.MOVMF
-            ldx  P8ZP_SCRATCH_REG_X
         """)
+        asmgen.restoreRegister(CpuRegister.X)
     }
 
     private fun inplaceModification_float_variable_to_variable(name: String, operator: String, ident: IdentifierReference) {
@@ -1105,10 +1176,10 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             throw AssemblyError("float variable expected")
 
         val otherName = asmgen.asmVariableName(ident)
+        asmgen.saveRegister(CpuRegister.X)
         when (operator) {
             "**" -> {
                 asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$name
                     ldy  #>$name
                     jsr  c64flt.CONUPK
@@ -1119,7 +1190,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             "+" -> {
                 asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$name
                     ldy  #>$name
                     jsr  c64flt.MOVFM
@@ -1130,7 +1200,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             "-" -> {
                 asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$otherName
                     ldy  #>$otherName
                     jsr  c64flt.MOVFM
@@ -1141,7 +1210,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             "*" -> {
                 asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$name
                     ldy  #>$name
                     jsr  c64flt.MOVFM
@@ -1152,7 +1220,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             "/" -> {
                 asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$otherName
                     ldy  #>$otherName
                     jsr  c64flt.MOVFM
@@ -1168,16 +1235,16 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             ldx  #<$name
             ldy  #>$name
             jsr  c64flt.MOVMF
-            ldx  P8ZP_SCRATCH_REG_X
         """)
+        asmgen.restoreRegister(CpuRegister.X)
     }
 
     private fun inplaceModification_float_litval_to_variable(name: String, operator: String, value: Double) {
         val constValueName = asmgen.getFloatAsmConst(value)
+        asmgen.saveRegister(CpuRegister.X)
         when (operator) {
             "**" -> {
                 asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$name
                     ldy  #>$name
                     jsr  c64flt.CONUPK
@@ -1190,7 +1257,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 if (value == 0.0)
                     return
                 asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$name
                     ldy  #>$name
                     jsr  c64flt.MOVFM
@@ -1203,7 +1269,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 if (value == 0.0)
                     return
                 asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$constValueName
                     ldy  #>$constValueName
                     jsr  c64flt.MOVFM
@@ -1213,8 +1278,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 """)
             }
             "*" -> {
+                // assume that code optimization is already done on the AST level for special cases such as 0, 1, 2...
                 asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$name
                     ldy  #>$name
                     jsr  c64flt.MOVFM
@@ -1227,7 +1292,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 if (value == 0.0)
                     throw AssemblyError("division by zero")
                 asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG_X
                     lda  #<$constValueName
                     ldy  #>$constValueName
                     jsr  c64flt.MOVFM
@@ -1243,14 +1307,13 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             ldx  #<$name
             ldy  #>$name
             jsr  c64flt.MOVMF
-            ldx  P8ZP_SCRATCH_REG_X
         """)
+        asmgen.restoreRegister(CpuRegister.X)
     }
 
     private fun inplaceCast(target: AsmAssignTarget, cast: TypecastExpression, position: Position) {
         val outerCastDt = cast.type
         val innerCastDt = (cast.expression as? TypecastExpression)?.type
-
         if (innerCastDt == null) {
             // simple typecast where the value is the target
             when (target.datatype) {
@@ -1259,12 +1322,25 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     when (outerCastDt) {
                         DataType.UBYTE, DataType.BYTE -> {
                             when(target.kind) {
-                                TargetStorageKind.VARIABLE -> asmgen.out(" lda  #0 |  sta  ${target.asmVarname}+1")
+                                TargetStorageKind.VARIABLE -> {
+                                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                        asmgen.out(" stz  ${target.asmVarname}+1")
+                                    else
+                                        asmgen.out(" lda  #0 |  sta  ${target.asmVarname}+1")
+                                }
                                 TargetStorageKind.ARRAY -> {
                                     asmgen.loadScaledArrayIndexIntoRegister(target.array!!, target.datatype, CpuRegister.Y, true)
-                                    asmgen.out("  lda  #0 |  sta  ${target.asmVarname},y")
+                                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                        asmgen.out("  stz  ${target.asmVarname},y")
+                                    else
+                                        asmgen.out("  lda  #0 |  sta  ${target.asmVarname},y")
+                                }
+                                TargetStorageKind.STACK -> {
+                                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                        asmgen.out(" stz  P8ESTACK_HI+1,x")
+                                    else
+                                        asmgen.out(" lda  #0 |  sta  P8ESTACK_HI+1,x")
                                 }
-                                TargetStorageKind.STACK -> asmgen.out(" lda  #0 |  sta  P8ESTACK_HI+1,x")
                                 else -> throw AssemblyError("weird target")
                             }
                         }
@@ -1468,8 +1544,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             DataType.FLOAT -> {
                 when(target.kind) {
                     TargetStorageKind.VARIABLE -> {
+                        asmgen.saveRegister(CpuRegister.X)
                         asmgen.out("""
-                            stx  P8ZP_SCRATCH_REG_X
                             lda  #<${target.asmVarname}
                             ldy  #>${target.asmVarname}
                             jsr  c64flt.MOVFM
@@ -1477,8 +1553,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                             ldx  #<${target.asmVarname}
                             ldy  #>${target.asmVarname}
                             jsr  c64flt.MOVMF
-                            ldx  P8ZP_SCRATCH_REG_X
                         """)
+                        asmgen.restoreRegister(CpuRegister.X)
                     }
                     TargetStorageKind.ARRAY -> TODO("in-place negate float array")
                     TargetStorageKind.STACK -> TODO("stack float negate")

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

@@ -2,6 +2,7 @@ package prog8.compiler.target.cx16
 
 import prog8.ast.Program
 import prog8.compiler.*
+import prog8.compiler.target.CpuType
 import prog8.compiler.target.IMachineDefinition
 import prog8.compiler.target.c64.C64MachineDefinition
 import prog8.parser.ModuleImporter
@@ -9,7 +10,7 @@ import java.io.IOException
 
 internal object CX16MachineDefinition: IMachineDefinition {
 
-    override val cpu = "65c02"
+    override val cpu = CpuType.CPU65c02
 
     // 5-byte cbm MFLPT format limitations:
     override val FLOAT_MAX_POSITIVE = 1.7014118345e+38         // bytes: 255,127,255,255,255
@@ -25,11 +26,10 @@ 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       // TODO Does Cx16 have ROM float locations?
+    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")
@@ -57,23 +57,23 @@ internal object CX16MachineDefinition: IMachineDefinition {
     }
 
     // 6502 opcodes (including aliases and illegal opcodes), these cannot be used as variable or label names
-    // TODO add 65C02 opcodes
-    override val opcodeNames = setOf("adc", "ahx", "alr", "anc", "and", "ane", "arr", "asl", "asr", "axs", "bcc", "bcs",
+    override val opcodeNames = setOf("adc", "and", "asl", "bcc", "bcs",
             "beq", "bge", "bit", "blt", "bmi", "bne", "bpl", "brk", "bvc", "bvs", "clc",
-            "cld", "cli", "clv", "cmp", "cpx", "cpy", "dcm", "dcp", "dec", "dex", "dey",
+            "cld", "cli", "clv", "cmp", "cpx", "cpy", "dec", "dex", "dey",
             "eor", "gcc", "gcs", "geq", "gge", "glt", "gmi", "gne", "gpl", "gvc", "gvs",
-            "inc", "ins", "inx", "iny", "isb", "isc", "jam", "jmp", "jsr", "lae", "las",
-            "lax", "lda", "lds", "ldx", "ldy", "lsr", "lxa", "nop", "ora", "pha", "php",
-            "pla", "plp", "rla", "rol", "ror", "rra", "rti", "rts", "sax", "sbc", "sbx",
-            "sec", "sed", "sei", "sha", "shl", "shr", "shs", "shx", "shy", "slo", "sre",
-            "sta", "stx", "sty", "tas", "tax", "tay", "tsx", "txa", "txs", "tya", "xaa")
+            "inc", "inx", "iny", "jmp", "jsr",
+            "lda", "ldx", "ldy", "lsr", "nop", "ora", "pha", "php",
+            "pla", "plp", "rol", "ror", "rti", "rts", "sbc",
+            "sec", "sed", "sei",
+            "sta", "stx", "sty", "tax", "tay", "tsx", "txa", "txs", "tya",
+            "bra", "phx", "phy", "plx", "ply", "stz", "trb", "tsb", "bbr", "bbs",
+            "rmb", "smb", "stp", "wai")
 
 
     internal class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
 
         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
 
@@ -94,16 +94,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
@@ -113,7 +113,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/optimizer/ConstantFoldingOptimizer.kt

@@ -150,7 +150,7 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                     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)
+                        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.
@@ -318,11 +318,11 @@ internal class ConstantFoldingOptimizer(private val program: Program) : AstWalke
     }
 
     override fun after(forLoop: ForLoop, parent: Node): Iterable<IAstModification> {
-        fun adjustRangeDt(rangeFrom: NumericLiteralValue, targetDt: DataType, rangeTo: NumericLiteralValue, stepLiteral: NumericLiteralValue?, range: RangeExpr): RangeExpr {
+        fun adjustRangeDt(rangeFrom: NumericLiteralValue, targetDt: DataType, rangeTo: NumericLiteralValue, stepLiteral: NumericLiteralValue?, range: RangeExpr): RangeExpr? {
             val fromCast = rangeFrom.cast(targetDt)
             val toCast = rangeTo.cast(targetDt)
             if(!fromCast.isValid || !toCast.isValid)
-                return range
+                return null
 
             val newStep =
                 if(stepLiteral!=null) {
@@ -351,28 +351,32 @@ internal class ConstantFoldingOptimizer(private val program: Program) : AstWalke
                 if(rangeFrom.type!= DataType.UBYTE) {
                     // attempt to translate the iterable into ubyte values
                     val newIter = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
-                    return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
+                    if(newIter!=null)
+                        return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
                 }
             }
             DataType.BYTE -> {
                 if(rangeFrom.type!= DataType.BYTE) {
                     // attempt to translate the iterable into byte values
                     val newIter = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
-                    return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
+                    if(newIter!=null)
+                        return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
                 }
             }
             DataType.UWORD -> {
                 if(rangeFrom.type!= DataType.UWORD) {
                     // attempt to translate the iterable into uword values
                     val newIter = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
-                    return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
+                    if(newIter!=null)
+                        return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
                 }
             }
             DataType.WORD -> {
                 if(rangeFrom.type!= DataType.WORD) {
                     // attempt to translate the iterable into word values
                     val newIter = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
-                    return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
+                    if(newIter!=null)
+                        return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
                 }
             }
             else -> throw FatalAstException("invalid loopvar datatype $loopvar")

compiler/src/prog8/optimizer/ExpressionSimplifier.kt

@@ -297,6 +297,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/StatementOptimizer.kt

@@ -104,7 +104,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 +112,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 +220,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))

compiler/test/UnitTests.kt

@@ -129,7 +129,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, "c64"))
 
         zp.allocate("", DataType.UBYTE, null, errors)
         zp.allocate("", DataType.UBYTE, null, errors)
@@ -142,37 +142,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, "c64"))
         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, "c64"))
         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, "c64"))
         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.KERNALSAFE, emptyList(), false))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, "c64"))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, "c64"))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, "c64"))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false, "c64"))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, "c64"))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true, "c64"))
         assertFailsWith<CompilerException> {
-            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), true))
+            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), true, "c64"))
         }
         assertFailsWith<CompilerException> {
-            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), true))
+            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), true, "c64"))
         }
     }
 
     @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, "c64"))
         println(zp.free)
         assertEquals(0, zp.available())
         assertFailsWith<CompilerException> {
@@ -182,19 +182,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, "c64"))
         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, "c64"))
         assertEquals(91, 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, "c64"))
         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, "c64"))
         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, "c64"))
         assertEquals(238, zp1.available())
         assertTrue(50 in zp1.free)
         assertTrue(100 in zp1.free)
@@ -203,7 +203,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, "c64"))
         assertEquals(139, zp2.available())
         assertFalse(50 in zp2.free)
         assertFalse(100 in zp2.free)
@@ -216,7 +216,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, "c64"))
         assertEquals(16, zp.available())
 
         assertFailsWith<ZeropageDepletedError> {
@@ -239,7 +239,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, "c64"))
         assertEquals(238, zp.available())
         val loc = zp.allocate("", DataType.UWORD, null, errors)
         assertTrue(loc > 3)
@@ -269,7 +269,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, "c64"))
         assertEquals(16, zp.available())
         assertEquals(0x04, zp.allocate("", DataType.WORD, null, errors))
         assertEquals(0x06, zp.allocate("", DataType.UBYTE, null, errors))

docs/source/building.rst

@@ -83,7 +83,7 @@ For normal use the compiler is invoked with the command:
 By default, assembly code is generated and written to ``sourcefile.asm``.
 It is then (automatically) fed to the `64tass <https://sourceforge.net/projects/tass64/>`_ cross assembler tool
 that assembles it into the final program.
-If you use the option to let the compiler auto-start a C-64 emulator, it will do so after
+If you use the option to let the compiler auto-start an emulator, it will do so after
 a successful compilation. This will load your program and the symbol and breakpoint lists
 (for the machine code monitor) into the emulator.
 

docs/source/index.rst

@@ -12,6 +12,7 @@ What is Prog8?
 
 This is an experimental compiled programming language targeting the 8-bit
 `6502 <https://en.wikipedia.org/wiki/MOS_Technology_6502>`_ /
+`65c02 <https://en.wikipedia.org/wiki/MOS_Technology_65C02>`_ /
 `6510 <https://en.wikipedia.org/wiki/MOS_Technology_6510>`_ microprocessor.
 This CPU is from the late 1970's and early 1980's and was used in many home computers from that era,
 such as the `Commodore-64 <https://en.wikipedia.org/wiki/Commodore_64>`_.
@@ -95,7 +96,6 @@ when compiled an ran on a C-64 you get this:
     :alt: result when run on C-64
 
 
-// TODO fix code example
 The following programs shows a use of the high level ``struct`` type::
 
 
@@ -179,6 +179,7 @@ Fnd for Windows it's possible to get that as well. Check out `AdoptOpenJDK <http
 
 Finally: a **C-64 emulator** (or a real C-64 ofcourse) can be nice to test and run your programs on.
 The compiler assumes the presence of the `Vice emulator <http://vice-emu.sourceforge.net/>`_.
+If you're targeting the CommanderX16, there's the `x16emu <https://github.com/commanderx16/x16-emulator>`_.
 
 .. important::
     **Building the compiler itself:** (*Only needed if you have not downloaded a pre-built 'fat-jar'*)

docs/source/syntaxreference.rst

@@ -33,6 +33,14 @@ This makes it easier to understand and relate the generated code. Examples::
 Directives
 -----------
 
+.. data:: %target <target>
+
+    Level: module.
+    Global setting, selects a compilation target from within the source file.
+    The default compilation target is "c64" which targets the Commodore-64 machine.
+    You can also omit this and use the ``-target`` command line option.
+
+
 .. data:: %output <type>
 
 	Level: module.
@@ -514,18 +522,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.
-the parameters are strictly passed via cpu registers), are defined like this::
+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 with ``asmsub`` like this::
 
-    asmsub  FREADS32() clobbers(A,X,Y)  {
+    asmsub  clear_screenchars (ubyte char @ A) clobbers(Y)  {
         %asm {{
-            lda  $62
-            eor  #$ff
-            asl  a
-            lda  #0
-            ldx  #$a0
-            jmp  $bc4f
-        }}
+            ldy  #0
+    _loop   sta  c64.Screen,y
+            sta  c64.Screen+$0100,y
+            sta  c64.Screen+$0200,y
+            sta  c64.Screen+$02e8,y
+            iny
+            bne  _loop
+            rts
+            }}
     }
 
 the statement body of such a subroutine should consist of just an inline assembly block.

docs/source/targetsystem.rst

@@ -9,10 +9,12 @@ Prog8 targets the following hardware:
 - optional use of memory mapped I/O registers
 - optional use of system ROM routines
 
-The main target machine is the well-known Commodore-64, which is an example of this.
-Another (preliminary) supported target machine is the `CommanderX16 <https://www.commanderx16.com/>`_ .
+Currently there are two machines that are supported as compiler target (via the ``-target`` compiler argument):
 
-This chapter explains the relevant system details of such machines.
+- '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.
 
 
 Memory Model

docs/source/todo.rst

@@ -2,12 +2,15 @@
 TODO
 ====
 
-- optimize assignment codegeneration
-- get rid of all TODO's ;-)
+- get rid of all other TODO's in the code ;-)
+- line-circle-gfx examples are now a few hundred bytes larger than before. Why is that, can it be fixed?
+- compiler errors and warnings in standard format so the IDE shows them as clickable links; ./test.asm:2578:3: blablabla
+- further optimize assignment codegeneration
+- auto select correct library to import based on target, instead of having c64- and  cx16-  prefix variants
+- 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
 
 

examples/arithmetic/div.p8

@@ -2,8 +2,6 @@
 %import c64textio
 %zeropage basicsafe
 
-; TODO implement signed byte/word DIV asm generation, fix unsigned DIV asm generation (for in-place)
-
 main {
 
     sub start() {
@@ -11,17 +9,17 @@ main {
         div_ubyte(100, 6, 16)
         div_ubyte(255, 2, 127)
 
-        ;div_byte(0, 1, 0)      ; TODO implement
-        ;div_byte(100, -6, -16) ; TODO implement
-        ;div_byte(127, -2, -63) ; TODO implement
+        div_byte(0, 1, 0)
+        div_byte(100, -6, -16)
+        div_byte(127, -2, -63)
 
         div_uword(0,1,0)
         div_uword(40000,500,80)
         div_uword(43211,2,21605)
 
-        ;div_word(0,1,0)            ; TODO implement
-        ;div_word(-20000,500,-40)   ; TODO implement
-        ;div_word(-2222,2,-1111)    ; TODO implement
+        div_word(0,1,0)
+        div_word(-20000,500,-40)
+        div_word(-2222,2,-1111)
 
         div_float(0,1,0)
         div_float(999.9,111.0,9.008108108108107)

examples/bdmusic.p8

@@ -47,10 +47,10 @@ sub delay() {
 sub print_notes(ubyte n1, ubyte n2) {
     c64.CHROUT('\n')
     txt.plot(n1/2, 24)
-    c64.COLOR=7
+    txt.color(7)
     c64.CHROUT('Q')
     txt.plot(n2/2, 24)
-    c64.COLOR=4
+    txt.color(4)
     c64.CHROUT('Q')
 }
 

examples/c64graphics.p8

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

examples/cube3d-float.p8

@@ -57,7 +57,7 @@ main {
         float Azy = cosb*sinc
         float Azz = cosb*cosc
 
-        ubyte i
+        ubyte @zp i
         for i in 0 to len(xcoor)-1 {
             rotatedx[i] = Axx*xcoor[i] + Axy*ycoor[i] + Axz*zcoor[i]
             rotatedy[i] = Ayx*xcoor[i] + Ayy*ycoor[i] + Ayz*zcoor[i]
@@ -69,7 +69,7 @@ main {
 
         ; plot the points of the 3d cube
         ; first the points on the back, then the points on the front (painter algorithm)
-        ubyte i
+        ubyte @zp i
         float rz
         float persp
         ubyte sx

examples/cube3d-gfx.p8

@@ -1,12 +1,8 @@
 %import c64lib
 %import c64graphics
 
-
 main {
 
-    const uword width = 255
-    const uword height = 200
-
     ; vertices
     word[] xcoor = [ -100, -100, -100, -100,  100,  100,  100, 100 ]
     word[] ycoor = [ -100, -100,  100,  100, -100, -100,  100, 100 ]
@@ -32,7 +28,7 @@ main {
 
         repeat {
             rotate_vertices(msb(anglex), msb(angley), msb(anglez))
-            graphics.clear_screen()
+            graphics.clear_screen(1, 0)
             draw_lines()
             anglex-=500
             angley+=217
@@ -69,7 +65,7 @@ main {
         word Azy = wcosb*wsinc / 128
         word Azz = wcosb*wcosc / 128
 
-        ubyte i
+        ubyte @zp i
         for i in 0 to len(xcoor)-1 {
             ; don't normalize by dividing by 128, instead keep some precision for perspective calc later
             rotatedx[i] = (Axx*xcoor[i] + Axy*ycoor[i] + Axz*zcoor[i])
@@ -78,17 +74,21 @@ main {
         }
     }
 
+    const uword screen_width = 320
+    const ubyte screen_height = 200
+
+
     sub draw_lines() {
-        ubyte i
+        ubyte @zp i
         for i in len(edgesFrom) -1 downto 0 {
-            ubyte vFrom = edgesFrom[i]
-            ubyte vTo = edgesTo[i]
-            word persp1 = 256 + rotatedz[vFrom]/256
-            word persp2 = 256 + rotatedz[vTo]/256
-            graphics.line(rotatedx[vFrom] / persp1 + 160.w as uword,
-                          rotatedy[vFrom] / persp1 + 100 as ubyte,
-                          rotatedx[vTo] / persp2 + 160.w as uword,
-                          rotatedy[vTo] / persp2 + 100 as ubyte)
+            ubyte @zp vFrom = edgesFrom[i]
+            ubyte @zp vTo = edgesTo[i]              ; TODO need compiler error for double declaration if also declared outside the for loop!
+            word @zp persp1 = 256 + rotatedz[vFrom]/256
+            word @zp persp2 = 256 + rotatedz[vTo]/256
+            graphics.line(rotatedx[vFrom] / persp1 + screen_width/2 as uword,
+                          rotatedy[vFrom] / persp1 + screen_height/2 as ubyte,
+                          rotatedx[vTo] / persp2 + screen_width/2 as uword,
+                          rotatedy[vTo] / persp2 + screen_height/2 as ubyte)
         }
     }
 }

examples/cube3d-sprites.p8

@@ -122,7 +122,7 @@ main {
         word Azy = wcosb*wsinc / 128
         word Azz = wcosb*wcosc / 128
 
-        ubyte i
+        ubyte @zp i
         for i in 0 to len(xcoor)-1 {
             ; don't normalize by dividing by 128, instead keep some precision for perspective calc later
             rotatedx[i] = (Axx*xcoor[i] + Axy*ycoor[i] + Axz*zcoor[i])
@@ -138,8 +138,8 @@ main {
 
         ; first sort vertices to sprite order so the back/front order is correct as well
         ; (simple bubble sort as it's only 8 items to sort)
-        ubyte i
-        ubyte i1
+        ubyte @zp i
+        ubyte @zp i1
         for i in 6 downto 0 {
             for i1 in 0 to i {
                 ubyte i2 = i1+1
@@ -154,7 +154,7 @@ main {
         ubyte[] spritecolors = [1,1,7,15,12,11,9,9]
 
         for i in 0 to 7 {
-            word zc = rotatedz[i]
+            word @zp zc = rotatedz[i]
             word persp = 300+zc/256
             ubyte sx = rotatedx[i] / persp + width/2 as ubyte + 20
             ubyte sy = rotatedy[i] / persp + height/2 as ubyte + 40

examples/cube3d.p8

@@ -62,7 +62,7 @@ main {
         word Azy = wcosb*wsinc / 128
         word Azz = wcosb*wcosc / 128
 
-        ubyte i
+        ubyte @zp i
         for i in 0 to len(xcoor)-1 {
             ; don't normalize by dividing by 128, instead keep some precision for perspective calc later
             rotatedx[i] = Axx*xcoor[i] + Axy*ycoor[i] + Axz*zcoor[i]
@@ -76,9 +76,9 @@ main {
         ; plot the points of the 3d cube
         ; first the points on the back, then the points on the front (painter algorithm)
 
-        ubyte i
-        word rz
-        word persp
+        ubyte @zp i
+        word @zp rz
+        word @zp persp
         byte sx
         byte sy
 

examples/cx16/arithmetic/aggregates.p8

@@ -0,0 +1,109 @@
+%target cx16
+%import cx16flt
+%import cx16textio
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        ubyte[]  ubarr = [100, 0, 99, 199, 22]
+        byte[]  barr = [-100, 0, 99, -122, 22]
+        uword[] uwarr = [1000, 0, 222, 4444, 999]
+        word[]  warr = [-1000, 0, 999, -4444, 222]
+        float[]  farr = [-1000.1, 0, 999.9, -4444.4, 222.2]
+        str name = "irmen"
+        ubyte ub
+        byte bb
+        word ww
+        uword uw
+        float ff
+
+        ; LEN/STRLEN
+        ubyte length = len(name)
+        if length!=5 txt.print("error len1\n")
+        length = len(uwarr)
+        if length!=5 txt.print("error len2\n")
+        length=strlen(name)
+        if length!=5 txt.print("error strlen1\n")
+        name[3] = 0
+        length=strlen(name)
+        if length!=3 txt.print("error strlen2\n")
+
+        ; MAX
+        ub = max(ubarr)
+        if ub!=199 txt.print("error max1\n")
+        bb = max(barr)
+        if bb!=99 txt.print("error max2\n")
+        uw = max(uwarr)
+        if uw!=4444 txt.print("error max3\n")
+        ww = max(warr)
+        if ww!=999 txt.print("error max4\n")
+        ff = max(farr)
+        if ff!=999.9 txt.print("error max5\n")
+
+        ; MIN
+        ub = min(ubarr)
+        if ub!=0 txt.print("error min1\n")
+        bb = min(barr)
+        if bb!=-122 txt.print("error min2\n")
+        uw = min(uwarr)
+        if uw!=0 txt.print("error min3\n")
+        ww = min(warr)
+        if ww!=-4444 txt.print("error min4\n")
+        ff = min(farr)
+        if ff!=-4444.4 txt.print("error min5\n")
+
+        ; SUM
+        uw = sum(ubarr)
+        if uw!=420 txt.print("error sum1\n")
+        ww = sum(barr)
+        if ww!=-101 txt.print("error sum2\n")
+        uw = sum(uwarr)
+        if uw!=6665 txt.print("error sum3\n")
+        ww = sum(warr)
+        if ww!=-4223 txt.print("error sum4\n")
+        ff = sum(farr)
+        if ff!=-4222.4 txt.print("error sum5\n")
+
+        ; ANY
+        ub = any(ubarr)
+        if ub==0 txt.print("error any1\n")
+        ub = any(barr)
+        if ub==0 txt.print("error any2\n")
+        ub = any(uwarr)
+        if ub==0 txt.print("error any3\n")
+        ub = any(warr)
+        if ub==0 txt.print("error any4\n")
+        ub = any(farr)
+        if ub==0 txt.print("error any5\n")
+
+        ; ALL
+        ub = all(ubarr)
+        if ub==1 txt.print("error all1\n")
+        ub = all(barr)
+        if ub==1 txt.print("error all2\n")
+        ub = all(uwarr)
+        if ub==1 txt.print("error all3\n")
+        ub = all(warr)
+        if ub==1 txt.print("error all4\n")
+        ub = all(farr)
+        if ub==1 txt.print("error all5\n")
+        ubarr[1]=$40
+        barr[1]=$40
+        uwarr[1]=$4000
+        warr[1]=$4000
+        farr[1]=1.1
+        ub = all(ubarr)
+        if ub==0 txt.print("error all6\n")
+        ub = all(barr)
+        if ub==0 txt.print("error all7\n")
+        ub = all(uwarr)
+        if ub==0 txt.print("error all8\n")
+        ub = all(warr)
+        if ub==0 txt.print("error all9\n")
+        ub = all(farr)
+        if ub==0 txt.print("error all10\n")
+
+        txt.print("\nyou should see no errors printed above (only at first run).")
+    }
+}

examples/cx16/arithmetic/bitshift.p8

@@ -0,0 +1,924 @@
+%target cx16
+%import cx16textio
+%zeropage basicsafe
+
+
+main {
+
+    sub start() {
+        ubyte A
+
+        txt.print("ubyte shift left\n")
+        A = shiftlb0()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftlb1()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftlb2()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftlb3()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftlb4()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftlb5()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftlb6()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftlb7()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftlb8()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftlb9()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        txt.print("enter to continue:\n")
+        void c64.CHRIN()
+
+        txt.print("ubyte shift right\n")
+        A = shiftrb0()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftrb1()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftrb2()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftrb3()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftrb4()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftrb5()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftrb6()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftrb7()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftrb8()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        A = shiftrb9()
+        txt.print_ubbin(A, true)
+        c64.CHROUT('\n')
+        txt.print("enter to continue:\n")
+        void c64.CHRIN()
+
+
+
+
+        txt.print("signed byte shift left\n")
+        byte signedb
+        signedb = shiftlsb0()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftlsb1()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftlsb2()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftlsb3()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftlsb4()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftlsb5()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftlsb6()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftlsb7()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftlsb8()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftlsb9()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        txt.print("enter to continue:\n")
+        void c64.CHRIN()
+
+        txt.print("signed byte shift right\n")
+        signedb = shiftrsb0()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftrsb1()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftrsb2()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftrsb3()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftrsb4()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftrsb5()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftrsb6()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftrsb7()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftrsb8()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        signedb = shiftrsb9()
+        txt.print_ubbin(signedb as ubyte, true)
+        c64.CHROUT('\n')
+        txt.print("enter to continue:\n")
+        void c64.CHRIN()
+
+
+
+
+        txt.print("uword shift left\n")
+        uword uw
+        uw = shiftluw0()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw1()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw2()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw3()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw4()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw5()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw6()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw7()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw8()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw9()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw10()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw11()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw12()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw13()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw14()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw15()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw16()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftluw17()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        txt.print("enter to continue:\n")
+        void c64.CHRIN()
+
+        txt.print("uword shift right\n")
+        uw = shiftruw0()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw1()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw2()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw3()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw4()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw5()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw6()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw7()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw8()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw9()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw10()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw11()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw12()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw13()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw14()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw15()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw16()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        uw = shiftruw17()
+        txt.print_uwbin(uw, true)
+        c64.CHROUT('\n')
+        txt.print("enter to continue:\n")
+        void c64.CHRIN()
+
+        txt.print("signed word shift left\n")
+        word sw
+        sw = shiftlsw0()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw1()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw2()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw3()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw4()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw5()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw6()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw7()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw8()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw9()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw10()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw11()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw12()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw13()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw14()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw15()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw16()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftlsw17()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        txt.print("enter to continue:\n")
+        void c64.CHRIN()
+
+        txt.print("signed word shift right\n")
+        sw = shiftrsw0()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw1()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw2()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw3()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw4()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw5()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw6()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw7()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw8()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw9()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw10()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw11()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw12()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw13()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw14()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw15()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw16()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+        sw = shiftrsw17()
+        txt.print_uwbin(sw as uword, true)
+        c64.CHROUT('\n')
+
+    }
+
+    sub shiftruw0() -> uword {
+        uword q = $a49f
+        return q >> 0
+    }
+
+    sub shiftruw1() -> uword {
+        uword q = $a49f
+        return q >> 1
+    }
+
+    sub shiftruw2() -> uword {
+        uword q = $a49f
+        return q >> 2
+    }
+
+    sub shiftruw3() -> uword {
+        uword q = $a49f
+        return q >> 3
+    }
+
+    sub shiftruw4() -> uword {
+        uword q = $a49f
+        return q >> 4
+    }
+
+    sub shiftruw5() -> uword {
+        uword q = $a49f
+        return q >> 5
+    }
+
+    sub shiftruw6() -> uword {
+        uword q = $a49f
+        return q >> 6
+    }
+
+    sub shiftruw7() -> uword {
+        uword q = $a49f
+        return q >> 7
+    }
+
+    sub shiftruw8() -> uword {
+        uword q = $a49f
+        return (q >> 8)
+    }
+
+    sub shiftruw9() -> uword {
+        uword q = $a49f
+        return (q >> 9)
+    }
+
+    sub shiftruw10() -> uword {
+        uword q = $a49f
+        return (q >> 10)
+    }
+
+    sub shiftruw11() -> uword {
+        uword q = $a49f
+        return (q >> 11)
+    }
+
+    sub shiftruw12() -> uword {
+        uword q = $a49f
+        return (q >> 12)
+    }
+
+    sub shiftruw13() -> uword {
+        uword q = $a49f
+        return (q >> 13)
+    }
+
+    sub shiftruw14() -> uword {
+        uword q = $a49f
+        return (q >> 14)
+    }
+
+    sub shiftruw15() -> uword {
+        uword q = $a49f
+        return (q >> 15)
+    }
+
+    sub shiftruw16() -> uword {
+        uword q = $a49f
+        return (q >> 16)
+    }
+
+    sub shiftruw17() -> uword {
+        uword q = $a49f
+        return (q >> 17)
+    }
+
+
+
+
+
+    sub shiftrsw0() -> word {
+        word q = -12345
+        return q >> 0
+    }
+
+    sub shiftrsw1() -> word {
+        word q = -12345
+        return q >> 1
+    }
+
+    sub shiftrsw2() -> word {
+        word q = -12345
+        return q >> 2
+    }
+
+    sub shiftrsw3() -> word {
+        word q = -12345
+        return q >> 3
+    }
+
+    sub shiftrsw4() -> word {
+        word q = -12345
+        return q >> 4
+    }
+
+    sub shiftrsw5() -> word {
+        word q = -12345
+        return q >> 5
+    }
+
+    sub shiftrsw6() -> word {
+        word q = -12345
+        return q >> 6
+    }
+
+    sub shiftrsw7() -> word {
+        word q = -12345
+        return q >> 7
+    }
+
+    sub shiftrsw8() -> word {
+        word q = -12345
+        return (q >> 8)
+    }
+
+    sub shiftrsw9() -> word {
+        word q = -12345
+        return (q >> 9)
+    }
+
+    sub shiftrsw10() -> word {
+        word q = -12345
+        return (q >> 10)
+    }
+
+    sub shiftrsw11() -> word {
+        word q = -12345
+        return (q >> 11)
+    }
+
+    sub shiftrsw12() -> word {
+        word q = -12345
+        return (q >> 12)
+    }
+
+    sub shiftrsw13() -> word {
+        word q = -12345
+        return (q >> 13)
+    }
+
+    sub shiftrsw14() -> word {
+        word q = -12345
+        return (q >> 14)
+    }
+
+    sub shiftrsw15() -> word {
+        word q = -12345
+        return (q >> 15)
+    }
+
+    sub shiftrsw16() -> word {
+        word q = -12345
+        return (q >> 16)
+    }
+
+    sub shiftrsw17() -> word {
+        word q = -12345
+        return (q >> 17)
+    }
+
+
+
+
+    sub shiftluw0() -> uword {
+        uword q = $a49f
+        return q << 0
+    }
+
+    sub shiftluw1() -> uword {
+        uword q = $a49f
+        return q << 1
+    }
+
+    sub shiftluw2() -> uword {
+        uword q = $a49f
+        return q << 2
+    }
+
+    sub shiftluw3() -> uword {
+        uword q = $a49f
+        return q << 3
+    }
+
+    sub shiftluw4() -> uword {
+        uword q = $a49f
+        return q << 4
+    }
+
+    sub shiftluw5() -> uword {
+        uword q = $a49f
+        return q << 5
+    }
+
+    sub shiftluw6() -> uword {
+        uword q = $a49f
+        return q << 6
+    }
+
+    sub shiftluw7() -> uword {
+        uword q = $a49f
+        return q << 7
+    }
+
+    sub shiftluw8() -> uword {
+        uword q = $a49f
+        return q << 8
+    }
+
+    sub shiftluw9() -> uword {
+        uword q = $a49f
+        return q << 9
+    }
+
+    sub shiftluw10() -> uword {
+        uword q = $a49f
+        return q << 10
+    }
+
+    sub shiftluw11() -> uword {
+        uword q = $a49f
+        return q << 11
+    }
+
+    sub shiftluw12() -> uword {
+        uword q = $a49f
+        return q << 12
+    }
+
+    sub shiftluw13() -> uword {
+        uword q = $a49f
+        return q << 13
+    }
+
+    sub shiftluw14() -> uword {
+        uword q = $a49f
+        return q << 14
+    }
+
+    sub shiftluw15() -> uword {
+        uword q = $a49f
+        return q << 15
+    }
+
+    sub shiftluw16() -> uword {
+        uword q = $a49f
+        return q << 16
+    }
+
+    sub shiftluw17() -> uword {
+        uword q = $a49f
+        return q << 17
+    }
+
+
+
+    sub shiftlsw0() -> word {
+        word q = -12345
+        return q << 0
+    }
+
+    sub shiftlsw1() -> word {
+        word q = -12345
+        return q << 1
+    }
+
+    sub shiftlsw2() -> word {
+        word q = -12345
+        return q << 2
+    }
+
+    sub shiftlsw3() -> word {
+        word q = -12345
+        return q << 3
+    }
+
+    sub shiftlsw4() -> word {
+        word q = -12345
+        return q << 4
+    }
+
+    sub shiftlsw5() -> word {
+        word q = -12345
+        return q << 5
+    }
+
+    sub shiftlsw6() -> word {
+        word q = -12345
+        return q << 6
+    }
+
+    sub shiftlsw7() -> word {
+        word q = -12345
+        return q << 7
+    }
+
+    sub shiftlsw8() -> word {
+        word q = -12345
+        return q << 8
+    }
+
+    sub shiftlsw9() -> word {
+        word q = -12345
+        return q << 9
+    }
+
+    sub shiftlsw10() -> word {
+        word q = -12345
+        return q << 10
+    }
+
+    sub shiftlsw11() -> word {
+        word q = -12345
+        return q << 11
+    }
+
+    sub shiftlsw12() -> word {
+        word q = -12345
+        return q << 12
+    }
+
+    sub shiftlsw13() -> word {
+        word q = -12345
+        return q << 13
+    }
+
+    sub shiftlsw14() -> word {
+        word q = -12345
+        return q << 14
+    }
+
+    sub shiftlsw15() -> word {
+        word q = -12345
+        return q << 15
+    }
+
+    sub shiftlsw16() -> word {
+        word q = -12345
+        return q << 16
+    }
+
+    sub shiftlsw17() -> word {
+        word q = -12345
+        return q << 17
+    }
+
+
+
+    sub shiftlb0() -> ubyte {
+        ubyte yy=$ed
+        return yy << 0
+    }
+    sub shiftlb1() -> ubyte {
+        ubyte yy=$ed
+        return yy << 1
+    }
+    sub shiftlb2() -> ubyte {
+        ubyte yy=$ed
+        return yy << 2
+    }
+    sub shiftlb3() -> ubyte {
+        ubyte yy=$ed
+        return yy << 3
+    }
+    sub shiftlb4() -> ubyte {
+        ubyte yy=$ed
+        return yy << 4
+    }
+    sub shiftlb5() -> ubyte {
+        ubyte yy=$ed
+        return yy << 5
+    }
+    sub shiftlb6() -> ubyte {
+        ubyte yy=$ed
+        return yy << 6
+    }
+    sub shiftlb7() -> ubyte {
+        ubyte yy=$ed
+        return yy << 7
+    }
+    sub shiftlb8() -> ubyte {
+        ubyte yy=$ed
+        return yy << 8
+    }
+    sub shiftlb9() -> ubyte {
+        ubyte yy=$ed
+        return yy << 9
+    }
+
+    sub shiftrb0() -> ubyte {
+        ubyte yy=$ed
+        return yy >> 0
+    }
+    sub shiftrb1() -> ubyte {
+        ubyte yy=$ed
+        return yy >> 1
+    }
+    sub shiftrb2() -> ubyte {
+        ubyte yy=$ed
+        return yy >> 2
+    }
+    sub shiftrb3() -> ubyte {
+        ubyte yy=$ed
+        return yy >> 3
+    }
+    sub shiftrb4() -> ubyte {
+        ubyte yy=$ed
+        return yy >> 4
+    }
+    sub shiftrb5() -> ubyte {
+        ubyte yy=$ed
+        return yy >> 5
+    }
+    sub shiftrb6() -> ubyte {
+        ubyte yy=$ed
+        return yy >> 6
+    }
+    sub shiftrb7() -> ubyte {
+        ubyte yy=$ed
+        return yy >> 7
+    }
+    sub shiftrb8() -> ubyte {
+        ubyte yy=$ed
+        return yy >> 8
+    }
+    sub shiftrb9() -> ubyte {
+        ubyte yy=$ed
+        return yy >> 9
+    }
+
+
+
+    sub shiftlsb0() -> byte {
+        byte yy=-123
+        return yy << 0
+    }
+    sub shiftlsb1() -> byte {
+        byte yy=-123
+        return yy << 1
+    }
+    sub shiftlsb2() -> byte {
+        byte yy=-123
+        return yy << 2
+    }
+    sub shiftlsb3() -> byte {
+        byte yy=-123
+        return yy << 3
+    }
+    sub shiftlsb4() -> byte {
+        byte yy=-123
+        return yy << 4
+    }
+    sub shiftlsb5() -> byte {
+        byte yy=-123
+        return yy << 5
+    }
+    sub shiftlsb6() -> byte {
+        byte yy=-123
+        return yy << 6
+    }
+    sub shiftlsb7() -> byte {
+        byte yy=-123
+        return yy << 7
+    }
+    sub shiftlsb8() -> byte {
+        byte yy=-123
+        return yy << 8
+    }
+    sub shiftlsb9() -> byte {
+        byte yy=-123
+        return yy << 9
+    }
+
+    sub shiftrsb0() -> byte {
+        byte yy=-123
+        return yy >> 0
+    }
+    sub shiftrsb1() -> byte {
+        byte yy=-123
+        return yy >> 1
+    }
+    sub shiftrsb2() -> byte {
+        byte yy=-123
+        return yy >> 2
+    }
+    sub shiftrsb3() -> byte {
+        byte yy=-123
+        return yy >> 3
+    }
+    sub shiftrsb4() -> byte {
+        byte yy=-123
+        return yy >> 4
+    }
+    sub shiftrsb5() -> byte {
+        byte yy=-123
+        return yy >> 5
+    }
+    sub shiftrsb6() -> byte {
+        byte yy=-123
+        return yy >> 6
+    }
+    sub shiftrsb7() -> byte {
+        byte yy=-123
+        return yy >> 7
+    }
+    sub shiftrsb8() -> byte {
+        byte yy=-123
+        return yy >> 8
+    }
+    sub shiftrsb9() -> byte {
+        byte yy=-123
+        return yy >> 9
+    }
+}

examples/cx16/arithmetic/div.p8

@@ -0,0 +1,104 @@
+%target cx16
+%import cx16flt
+%import cx16textio
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        div_ubyte(0, 1, 0)
+        div_ubyte(100, 6, 16)
+        div_ubyte(255, 2, 127)
+
+        div_byte(0, 1, 0)
+        div_byte(100, -6, -16)
+        div_byte(127, -2, -63)
+
+        div_uword(0,1,0)
+        div_uword(40000,500,80)
+        div_uword(43211,2,21605)
+
+        div_word(0,1,0)
+        div_word(-20000,500,-40)
+        div_word(-2222,2,-1111)
+
+        div_float(0,1,0)
+        div_float(999.9,111.0,9.008108108108107)
+    }
+
+    sub div_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1/a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("ubyte ")
+        txt.print_ub(a1)
+        txt.print(" / ")
+        txt.print_ub(a2)
+        txt.print(" = ")
+        txt.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_byte(byte a1, byte a2, byte c) {
+        byte r = a1/a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("byte ")
+        txt.print_b(a1)
+        txt.print(" / ")
+        txt.print_b(a2)
+        txt.print(" = ")
+        txt.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1/a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("uword ")
+        txt.print_uw(a1)
+        txt.print(" / ")
+        txt.print_uw(a2)
+        txt.print(" = ")
+        txt.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_word(word a1, word a2, word c) {
+        word r = a1/a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("word ")
+        txt.print_w(a1)
+        txt.print(" / ")
+        txt.print_w(a2)
+        txt.print(" = ")
+        txt.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_float(float  a1, float a2, float  c) {
+        float r = a1/a2
+        if abs(r-c)<0.00001
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+
+        txt.print("float ")
+        c64flt.print_f(a1)
+        txt.print(" / ")
+        c64flt.print_f(a2)
+        txt.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}

examples/cx16/arithmetic/minus.p8

@@ -0,0 +1,112 @@
+%target cx16
+%import cx16flt
+%import cx16textio
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        minus_ubyte(0, 0, 0)
+        minus_ubyte(200, 0, 200)
+        minus_ubyte(200, 100, 100)
+        minus_ubyte(100, 200, 156)
+
+        minus_byte(0, 0, 0)
+        minus_byte(100, 100, 0)
+        minus_byte(50, -50, 100)
+        minus_byte(0, -30, 30)
+        minus_byte(-30, 0, -30)
+
+        minus_uword(0,0,0)
+        minus_uword(50000,0, 50000)
+        minus_uword(50000,20000,30000)
+        minus_uword(20000,50000,35536)
+
+        minus_word(0,0,0)
+        minus_word(1000,1000,0)
+        minus_word(-1000,1000,-2000)
+        minus_word(1000,500,500)
+        minus_word(0,-3333,3333)
+        minus_word(-3333,0,-3333)
+
+        minus_float(0,0,0)
+        minus_float(2.5,1.5,1.0)
+        minus_float(-1.5,3.5,-5.0)
+    }
+
+    sub minus_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1-a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("ubyte ")
+        txt.print_ub(a1)
+        txt.print(" - ")
+        txt.print_ub(a2)
+        txt.print(" = ")
+        txt.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_byte(byte a1, byte a2, byte c) {
+        byte r = a1-a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("byte ")
+        txt.print_b(a1)
+        txt.print(" - ")
+        txt.print_b(a2)
+        txt.print(" = ")
+        txt.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1-a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("uword ")
+        txt.print_uw(a1)
+        txt.print(" - ")
+        txt.print_uw(a2)
+        txt.print(" = ")
+        txt.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_word(word a1, word a2, word c) {
+        word r = a1-a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("word ")
+        txt.print_w(a1)
+        txt.print(" - ")
+        txt.print_w(a2)
+        txt.print(" = ")
+        txt.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_float(float  a1, float a2, float  c) {
+        float r = a1-a2
+        if abs(r-c)<0.00001
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+
+        txt.print("float ")
+        c64flt.print_f(a1)
+        txt.print(" - ")
+        c64flt.print_f(a2)
+        txt.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}

examples/cx16/arithmetic/mult.p8

@@ -0,0 +1,106 @@
+%target cx16
+%import cx16flt
+%import cx16textio
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        mul_ubyte(0, 0, 0)
+        mul_ubyte(20, 1, 20)
+        mul_ubyte(20, 10, 200)
+
+        mul_byte(0, 0, 0)
+        mul_byte(10, 10, 100)
+        mul_byte(5, -5, -25)
+        mul_byte(0, -30, 0)
+
+        mul_uword(0,0,0)
+        mul_uword(50000,1, 50000)
+        mul_uword(500,100,50000)
+
+        mul_word(0,0,0)
+        mul_word(-10,1000,-10000)
+        mul_word(1,-3333,-3333)
+
+        mul_float(0,0,0)
+        mul_float(2.5,10,25)
+        mul_float(-1.5,10,-15)
+    }
+
+    sub mul_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1*a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("ubyte ")
+        txt.print_ub(a1)
+        txt.print(" * ")
+        txt.print_ub(a2)
+        txt.print(" = ")
+        txt.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_byte(byte a1, byte a2, byte c) {
+        byte r = a1*a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("byte ")
+        txt.print_b(a1)
+        txt.print(" * ")
+        txt.print_b(a2)
+        txt.print(" = ")
+        txt.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1*a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("uword ")
+        txt.print_uw(a1)
+        txt.print(" * ")
+        txt.print_uw(a2)
+        txt.print(" = ")
+        txt.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_word(word a1, word a2, word c) {
+        word r = a1*a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("word ")
+        txt.print_w(a1)
+        txt.print(" * ")
+        txt.print_w(a2)
+        txt.print(" = ")
+        txt.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_float(float  a1, float a2, float  c) {
+        float r = a1*a2
+        if abs(r-c)<0.00001
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+
+        txt.print("float ")
+        c64flt.print_f(a1)
+        txt.print(" * ")
+        c64flt.print_f(a2)
+        txt.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}

examples/cx16/arithmetic/plus.p8

@@ -0,0 +1,110 @@
+%target cx16
+%import cx16flt
+%import cx16textio
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        plus_ubyte(0, 0, 0)
+        plus_ubyte(0, 200, 200)
+        plus_ubyte(100, 200, 44)
+
+        plus_byte(0, 0, 0)
+        plus_byte(-100, 100, 0)
+        plus_byte(-50, 100, 50)
+        plus_byte(0, -30, -30)
+        plus_byte(-30, 0, -30)
+
+        plus_uword(0,0,0)
+        plus_uword(0,50000,50000)
+        plus_uword(50000,20000,4464)
+
+        plus_word(0,0,0)
+        plus_word(-1000,1000,0)
+        plus_word(-500,1000,500)
+        plus_word(0,-3333,-3333)
+        plus_word(-3333,0,-3333)
+
+        plus_float(0,0,0)
+        plus_float(1.5,2.5,4.0)
+        plus_float(-1.5,3.5,2.0)
+        plus_float(-1.1,3.3,2.2)
+    }
+
+    sub plus_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1+a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("ubyte ")
+        txt.print_ub(a1)
+        txt.print(" + ")
+        txt.print_ub(a2)
+        txt.print(" = ")
+        txt.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_byte(byte a1, byte a2, byte c) {
+        byte r = a1+a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("byte ")
+        txt.print_b(a1)
+        txt.print(" + ")
+        txt.print_b(a2)
+        txt.print(" = ")
+        txt.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1+a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("uword ")
+        txt.print_uw(a1)
+        txt.print(" + ")
+        txt.print_uw(a2)
+        txt.print(" = ")
+        txt.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_word(word a1, word a2, word c) {
+        word r = a1+a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("word ")
+        txt.print_w(a1)
+        txt.print(" + ")
+        txt.print_w(a2)
+        txt.print(" = ")
+        txt.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_float(float  a1, float a2, float  c) {
+        float r = a1+a2
+        if abs(r-c)<0.00001
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+
+        txt.print("float ")
+        c64flt.print_f(a1)
+        txt.print(" + ")
+        c64flt.print_f(a2)
+        txt.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}

examples/cx16/arithmetic/postincrdecr.p8

@@ -0,0 +1,141 @@
+%target cx16
+%import cx16flt
+%import cx16textio
+%zeropage basicsafe
+
+main {
+
+    sub start()  {
+
+        txt.plot(0,24)
+
+        ubyte Y
+        ubyte ub=200
+        byte bb=-100
+        uword uw = 2000
+        word ww = -1000
+        float fl = 999.99
+        ubyte[3] ubarr = 200
+        byte[3] barr = -100
+        uword[3] uwarr = 2000
+        word[3] warr = -1000
+        float[3] flarr = 999.99
+
+        txt.print("++\n")
+        ub++
+        bb++
+        uw++
+        ww++
+        fl++
+        ubarr[1]++
+        barr[1]++
+        uwarr[1]++
+        warr[1]++
+        flarr[1] ++
+
+        check_ub(ub, 201)
+        Y=100
+        Y++
+        check_ub(Y, 101)
+        check_fl(fl, 1000.99)
+        check_b(bb, -99)
+        check_uw(uw, 2001)
+        check_w(ww, -999)
+        check_ub(ubarr[0], 200)
+        check_fl(flarr[0], 999.99)
+        check_b(barr[0], -100)
+        check_uw(uwarr[0], 2000)
+        check_w(warr[0], -1000)
+        check_ub(ubarr[1], 201)
+        check_fl(flarr[1], 1000.99)
+        check_b(barr[1], -99)
+        check_uw(uwarr[1], 2001)
+        check_w(warr[1], -999)
+
+        txt.print("--\n")
+        ub--
+        bb--
+        uw--
+        ww--
+        fl--
+        ubarr[1]--
+        barr[1]--
+        uwarr[1]--
+        warr[1]--
+        flarr[1] --
+        check_ub(ub, 200)
+
+        Y=100
+        Y--
+        check_ub(Y, 99)
+        check_fl(fl, 999.99)
+        check_b(bb, -100)
+        check_uw(uw, 2000)
+        check_w(ww, -1000)
+        check_ub(ubarr[1], 200)
+        check_fl(flarr[1], 999.99)
+        check_b(barr[1], -100)
+        check_uw(uwarr[1], 2000)
+        check_w(warr[1], -1000)
+    }
+
+    sub check_ub(ubyte value, ubyte expected) {
+        if value==expected
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print(" ubyte ")
+        txt.print_ub(value)
+        c64.CHROUT(',')
+        txt.print_ub(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_b(byte value, byte expected) {
+        if value==expected
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print(" byte ")
+        txt.print_b(value)
+        c64.CHROUT(',')
+        txt.print_b(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_uw(uword value, uword expected) {
+        if value==expected
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print(" uword ")
+        txt.print_uw(value)
+        c64.CHROUT(',')
+        txt.print_uw(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_w(word value, word expected) {
+        if value==expected
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print(" word ")
+        txt.print_w(value)
+        c64.CHROUT(',')
+        txt.print_w(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_fl(float value, float expected) {
+        if value==expected
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print(" float ")
+        c64flt.print_f(value)
+        c64.CHROUT(',')
+        c64flt.print_f(expected)
+        c64.CHROUT('\n')
+    }
+}

examples/cx16/arithmetic/remainder.p8

@@ -0,0 +1,48 @@
+%target cx16
+%import cx16textio
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        remainder_ubyte(0, 1, 0)
+        remainder_ubyte(100, 6, 4)
+        remainder_ubyte(255, 2, 1)
+        remainder_ubyte(255, 20, 15)
+
+        remainder_uword(0,1,0)
+        remainder_uword(40000,511,142)
+        remainder_uword(40000,500,0)
+        remainder_uword(43211,12,11)
+    }
+
+    sub remainder_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1%a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("ubyte ")
+        txt.print_ub(a1)
+        txt.print(" % ")
+        txt.print_ub(a2)
+        txt.print(" = ")
+        txt.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub remainder_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1%a2
+        if r==c
+            txt.print(" ok  ")
+        else
+            txt.print("err! ")
+        txt.print("uword ")
+        txt.print_uw(a1)
+        txt.print(" % ")
+        txt.print_uw(a2)
+        txt.print(" = ")
+        txt.print_uw(r)
+        c64.CHROUT('\n')
+    }
+}

examples/cx16/arithmetic/sgn.p8

@@ -0,0 +1,132 @@
+%target cx16
+%import cx16flt
+%import cx16textio
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        byte b1
+        byte b2
+        ubyte ub1
+        ubyte ub2
+        word w1
+        word w2
+        uword uw1
+        uword uw2
+        float f1
+        float f2
+
+        b1 = 10
+        b2 = 10
+        if sgn(b2-b1) != 0
+            txt.print("sgn1 error1\n")
+
+        b1 = -100
+        b2 = -100
+        if sgn(b2-b1) != 0
+            txt.print("sgn1 error2\n")
+
+        ub1 = 200
+        ub2 = 200
+        if sgn(ub2-ub1) != 0
+            txt.print("sgn1 error3\n")
+
+        w1 = 100
+        w2 = 100
+        if sgn(w2-w1) != 0
+            txt.print("sgn1 error4\n")
+
+        w1 = -2000
+        w2 = -2000
+        if sgn(w2-w1) != 0
+            txt.print("sgn1 error5\n")
+
+        uw1 = 999
+        uw2 = 999
+        if sgn(uw2-uw1) != 0
+            txt.print("sgn1 error6\n")
+
+        f1 = 3.45
+        f2 = 3.45
+        if sgn(f2-f1) != 0
+            txt.print("sgn1 error7\n")
+
+
+        ; -1
+        b1 = 11
+        b2 = 10
+        if sgn(b2-b1) != -1
+            txt.print("sgn2 error1\n")
+
+        b1 = -10
+        b2 = -100
+        if sgn(b2-b1) != -1
+            txt.print("sgn2 error2\n")
+
+        ub1 = 202
+        ub2 = 200
+        if sgn(ub2 as byte - ub1 as byte) != -1
+            txt.print("sgn2 error3\n")
+
+        w1 = 101
+        w2 = 100
+        if sgn(w2-w1) != -1
+            txt.print("sgn2 error4\n")
+
+        w1 = -200
+        w2 = -2000
+        if sgn(w2-w1) != -1
+            txt.print("sgn2 error5\n")
+
+        uw1 = 2222
+        uw2 = 999
+        if sgn((uw2 as word) - (uw1 as word)) != -1
+            txt.print("sgn2 error6a\n")
+        if sgn(uw2 - uw1) != 1      ; always 0 or 1 if unsigned
+            txt.print("sgn2 error6b\n")
+
+        f1 = 3.45
+        f2 = 1.11
+        if sgn(f2-f1) != -1
+            txt.print("sgn2 error7\n")
+
+        ; +1
+        b1 = 11
+        b2 = 20
+        if sgn(b2-b1) != 1
+            txt.print("sgn3 error1\n")
+
+        b1 = -10
+        b2 = -1
+        if sgn(b2-b1) != 1
+            txt.print("sgn3 error2\n")
+
+        ub1 = 202
+        ub2 = 205
+        if sgn(ub2-ub1) != 1
+            txt.print("sgn3 error3\n")
+
+        w1 = 101
+        w2 = 200
+        if sgn(w2-w1) != 1
+            txt.print("sgn3 error4\n")
+
+        w1 = -200
+        w2 = -20
+        if sgn(w2-w1) != 1
+            txt.print("sgn3 error5\n")
+
+        uw1 = 2222
+        uw2 = 9999
+        if sgn(uw2-uw1) != 1
+            txt.print("sgn3 error6\n")
+
+        f1 = 3.45
+        f2 = 5.11
+        if sgn(f2-f1) != 1
+            txt.print("sgn3 error7\n")
+
+        txt.print("should see no sgn errors\n")
+    }
+ }

examples/cx16/cobramk3-gfx.p8

@@ -0,0 +1,211 @@
+%target cx16
+%import cx16lib
+%import conv
+
+main {
+
+    ; storage for rotated coordinates
+    word[shipdata.totalNumberOfPoints] rotatedx
+    word[shipdata.totalNumberOfPoints] rotatedy
+    word[shipdata.totalNumberOfPoints] rotatedz
+
+
+    ; TODO hidden surface removal - this needs surfaces data and surface normal calculations.
+    ; TODO add all other Elite's ships, show their name, advance to next ship on keypress
+
+    sub start()  {
+        uword anglex
+        uword angley
+        uword anglez
+
+        void cx16.screen_set_mode($80)
+        cx16.r0 = 0
+        cx16.GRAPH_init()
+        cx16.GRAPH_set_colors(13, 6, 6)
+        cx16.GRAPH_clear()
+        print_ship_name()
+
+
+        repeat {
+            rotate_vertices(msb(anglex), msb(angley), msb(anglez))
+
+            cx16.GRAPH_set_colors(0, 0, 0)
+            cx16.r0 = 32
+            cx16.r1 = 10
+            cx16.r2 = 256
+            cx16.r3 = 185
+            cx16.r4 = 0
+            cx16.GRAPH_draw_rect(true)
+
+            cx16.GRAPH_set_colors(1, 0, 0)
+            draw_lines()
+
+            anglex -= 505
+            angley += 217
+            anglez += 452
+        }
+    }
+
+    sub print_ship_name() {
+        cx16.r0 = 32
+        cx16.r1 = 8
+        ubyte c
+        for c in "ship: "
+            cx16.GRAPH_put_char(c)
+        for c in shipdata.shipName
+            cx16.GRAPH_put_char(c)
+
+        cx16.r0 += 16
+        print_number_gfx(shipdata.totalNumberOfPoints)
+        for c in " vertices, "
+            cx16.GRAPH_put_char(c)
+        print_number_gfx(shipdata.totalNumberOfEdges)
+        for c in " edges, "
+            cx16.GRAPH_put_char(c)
+        print_number_gfx(shipdata.totalNumberOfFaces)
+        for c in " faces"
+            cx16.GRAPH_put_char(c)
+    }
+
+    asmsub print_number_gfx(ubyte num @ A) clobbers(A,Y) {
+    	%asm {{
+    		phx
+    		jsr  conv.ubyte2decimal
+    		phx
+    		pha
+    		cpy  #'0'
+    		beq  +
+    		tya
+    		jsr  cx16.GRAPH_put_char
+    		pla
+    		jsr  cx16.GRAPH_put_char
+    		jmp  _ones
+    +       pla
+            cmp  #'0'
+            beq  _ones
+            jsr  cx16.GRAPH_put_char
+    _ones   pla
+    		jsr  cx16.GRAPH_put_char
+    		plx
+    		rts
+    	}}
+    }
+
+    sub rotate_vertices(ubyte ax, ubyte ay, ubyte az) {
+        ; rotate around origin (0,0,0)
+
+        ; set up the 3d rotation matrix values
+        word wcosa = cos8(ax)
+        word wsina = sin8(ax)
+        word wcosb = cos8(ay)
+        word wsinb = sin8(ay)
+        word wcosc = cos8(az)
+        word wsinc = sin8(az)
+
+        word wcosa_sinb = wcosa*wsinb / 128
+        word wsina_sinb = wsina*wsinb / 128
+
+        word Axx = wcosa*wcosb / 128
+        word Axy = (wcosa_sinb*wsinc - wsina*wcosc) / 128
+        word Axz = (wcosa_sinb*wcosc + wsina*wsinc) / 128
+        word Ayx = wsina*wcosb / 128
+        word Ayy = (wsina_sinb*wsinc + wcosa*wcosc) / 128
+        word Ayz = (wsina_sinb*wcosc - wcosa*wsinc) / 128
+        word Azx = -wsinb
+        word Azy = wcosb*wsinc / 128
+        word Azz = wcosb*wcosc / 128
+
+        ubyte @zp i
+        for i in 0 to shipdata.totalNumberOfPoints-1 {
+            ; don't normalize by dividing by 128, instead keep some precision for perspective calc later
+            rotatedx[i] = Axx*shipdata.xcoor[i] + Axy*shipdata.ycoor[i] + Axz*shipdata.zcoor[i]
+            rotatedy[i] = Ayx*shipdata.xcoor[i] + Ayy*shipdata.ycoor[i] + Ayz*shipdata.zcoor[i]
+            rotatedz[i] = Azx*shipdata.xcoor[i] + Azy*shipdata.ycoor[i] + Azz*shipdata.zcoor[i]
+        }
+    }
+
+    const uword screen_width = 320
+    const ubyte screen_height = 200
+
+    sub draw_lines() {
+        ubyte @zp i
+        for i in shipdata.totalNumberOfEdges -1 downto 0 {
+            ubyte @zp vFrom = shipdata.edgesFrom[i]
+            ubyte @zp vTo = shipdata.edgesTo[i]
+            word persp1 = 200 + rotatedz[vFrom]/256
+            word persp2 = 200 + rotatedz[vTo]/256
+            cx16.r0 = rotatedx[vFrom] / persp1 + screen_width/2 as uword
+            cx16.r1 = rotatedy[vFrom] / persp1 + screen_height/2 as uword
+            cx16.r2 = rotatedx[vTo] / persp2 + screen_width/2 as uword
+            cx16.r3 = rotatedy[vTo] / persp2 + screen_height/2 as uword
+            cx16.GRAPH_draw_line()
+        }
+    }
+}
+
+shipdata {
+
+    ; Ship model data converted from BBC Elite's Cobra MK 3
+    ; downloaded from http://www.elitehomepage.org/archive/index.htm
+
+const ubyte totalNumberOfEdges = 51
+const ubyte totalNumberOfFaces = 22
+const ubyte totalNumberOfPoints = 34
+str shipName = "cobra-mk3"
+; vertices
+word[] xcoor = [ 32,-32,0,-120,120,-88,88,128,-128,0,-32,32,-36,-8,8,36,36,8,-8,-36,-1,-1,-80,-80,-88,80,88,80,1,1,1,1,-1,-1 ]
+word[] ycoor = [ 0,0,26,-3,-3,16,16,-8,-8,26,-24,-24,8,12,12,8,-12,-16,-16,-12,-1,-1,-6,6,0,6,0,-6,-1,-1,1,1,1,1 ]
+word[] zcoor = [ 76,76,24,-8,-8,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,76,90,-40,-40,-40,-40,-40,-40,76,90,76,90,76,90 ]
+; edges and faces
+ubyte[] edgesFrom = [ 0,1,0,10,1,0,2,0,4,0,4,7,2,1,1,3,8,3,2,5,6,5,6,16,15,14,14,18,13,12,12,26,25,25,22,23,22,20,28,21,20,28,29,30,31,30,32,20,21,20,20 ]
+ubyte[] edgesTo = [ 1,2,2,11,10,11,6,6,6,4,7,11,5,5,3,5,10,8,9,9,9,8,7,17,16,15,17,19,18,13,19,27,26,27,23,24,24,28,29,29,21,30,31,31,33,32,33,32,33,33,29 ]
+ubyte[] facesPoints = [
+     0,1,2 ,255,
+     11,10,1,0 ,255,
+     0,2,6 ,255,
+     6,4,0 ,255,
+     4,7,11,0 ,255,
+     5,2,1 ,255,
+     1,3,5 ,255,
+     10,8,3,1 ,255,
+     9,2,5 ,255,
+     9,6,2 ,255,
+     3,8,5 ,255,
+     4,6,7 ,255,
+     5,8,10,11,7,6,9 ,255,
+     17,16,15,14 ,255,
+     19,18,13,12 ,255,
+     27,26,25 ,255,
+     22,23,24 ,255,
+     20,28,29,21 ,255,
+     30,28,29,31 ,255,
+     33,31,30,32 ,255,
+     20,32,33,21 ,255,
+     29,31,33,20 ,255
+]
+ubyte[] facesEdges = [
+     0,1,2 ,255,
+     3,4,0,5 ,255,
+     2,6,7 ,255,
+     8,9,7 ,255,
+     10,11,5,9 ,255,
+     12,1,13 ,255,
+     14,15,13 ,255,
+     16,17,14,4 ,255,
+     18,12,19 ,255,
+     20,6,18 ,255,
+     17,21,15 ,255,
+     8,22,10 ,255,
+     21,16,3,11,22,20,19 ,255,
+     23,24,25,26 ,255,
+     27,28,29,30 ,255,
+     31,32,33 ,255,
+     34,35,36 ,255,
+     37,38,39,40 ,255,
+     41,38,42,43 ,255,
+     44,43,45,46 ,255,
+     47,46,48,40 ,255,
+     42,44,49,50 ,255
+]
+
+}

examples/cx16/cube3d-float.p8

@@ -0,0 +1,110 @@
+%target cx16
+%import cx16flt
+%import cx16textio
+%zeropage basicsafe
+
+main {
+
+    const uword width = 80
+    const uword height = 60
+
+    ; vertices
+    float[] xcoor = [ -1.0, -1.0, -1.0, -1.0,  1.0,  1.0,  1.0, 1.0 ]
+    float[] ycoor = [ -1.0, -1.0,  1.0,  1.0, -1.0, -1.0,  1.0, 1.0 ]
+    float[] zcoor = [ -1.0,  1.0, -1.0,  1.0, -1.0,  1.0, -1.0, 1.0 ]
+
+    ; storage for rotated coordinates
+    float[len(xcoor)] rotatedx=0.0
+    float[len(ycoor)] rotatedy=0.0
+    float[len(zcoor)] rotatedz=-1.0
+
+    sub start()  {
+        float time=0.0
+        ubyte timer_jiffies
+
+        repeat {
+            rotate_vertices(time)
+            txt.clear_screenchars(' ')
+            draw_edges()
+            time+=0.1
+
+            txt.plot(0,0)
+            txt.print("3d cube! (floating point calc) ")
+
+            %asm {{
+                phx
+                jsr  c64.RDTIM      ; A/X/Y
+                sta  timer_jiffies
+                lda  #0
+                jsr  c64.SETTIM
+                plx
+            }}
+            txt.print_ub(timer_jiffies)
+            txt.print(" jiffies/fr = ")
+            txt.print_ub(60/timer_jiffies)
+            txt.print(" fps")
+        }
+    }
+
+    sub rotate_vertices(float t) {
+        ; rotate around origin (0,0,0)
+
+        ; set up the 3d rotation matrix values
+        float cosa = cos(t)
+        float sina = sin(t)
+        float cosb = cos(t*0.33)
+        float sinb = sin(t*0.33)
+        float cosc = cos(t*0.78)
+        float sinc = sin(t*0.78)
+
+        float cosa_sinb = cosa*sinb
+        float sina_sinb = sina*sinb
+        float Axx = cosa*cosb
+        float Axy = cosa_sinb*sinc - sina*cosc
+        float Axz = cosa_sinb*cosc + sina*sinc
+        float Ayx = sina*cosb
+        float Ayy = sina_sinb*sinc + cosa*cosc
+        float Ayz = sina_sinb*cosc - cosa*sinc
+        float Azx = -sinb
+        float Azy = cosb*sinc
+        float Azz = cosb*cosc
+
+        ubyte @zp i
+        for i in 0 to len(xcoor)-1 {
+            rotatedx[i] = Axx*xcoor[i] + Axy*ycoor[i] + Axz*zcoor[i]
+            rotatedy[i] = Ayx*xcoor[i] + Ayy*ycoor[i] + Ayz*zcoor[i]
+            rotatedz[i] = Azx*xcoor[i] + Azy*ycoor[i] + Azz*zcoor[i]
+        }
+    }
+
+    sub draw_edges() {
+
+        ; plot the points of the 3d cube
+        ; first the points on the back, then the points on the front (painter algorithm)
+        ubyte @zp i
+        float rz
+        float persp
+        ubyte sx
+        ubyte sy
+
+        for i in 0 to len(xcoor)-1 {
+            rz = rotatedz[i]
+            if rz >= 0.1 {
+                persp = (5.0+rz)/(height as float)
+                sx = rotatedx[i] / persp + width/2.0 as ubyte
+                sy = rotatedy[i] / persp + height/2.0 as ubyte
+                txt.setcc(sx, sy, 46, 1)
+            }
+        }
+
+        for i in 0 to len(xcoor)-1 {
+            rz = rotatedz[i]
+            if rz < 0.1 {
+                persp = (5.0+rz)/(height as float)
+                sx = rotatedx[i] / persp + width/2.0 as ubyte
+                sy = rotatedy[i] / persp + height/2.0 as ubyte
+                txt.setcc(sx, sy, 81, 1)
+            }
+        }
+    }
+}

examples/cx16/cube3d.p8

@@ -0,0 +1,100 @@
+%target cx16
+%import cx16textio
+
+main {
+
+    const uword screen_width = 80
+    const uword screen_height = 60
+
+    ; vertices
+    word[] xcoor = [ -40, -40, -40, -40,  40,  40,  40, 40 ]
+    word[] ycoor = [ -40, -40,  40,  40, -40, -40,  40, 40 ]
+    word[] zcoor = [ -40,  40, -40,  40, -40,  40, -40, 40 ]
+
+    ; storage for rotated coordinates
+    word[len(xcoor)] rotatedx
+    word[len(ycoor)] rotatedy
+    word[len(zcoor)] rotatedz
+
+    sub start()  {
+
+        uword anglex
+        uword angley
+        uword anglez
+        ubyte timer_jiffies
+
+        repeat {
+            rotate_vertices(msb(anglex), msb(angley), msb(anglez))
+            txt.clear_screenchars(' ')
+            draw_edges()
+            anglex+=500
+            angley+=215
+            anglez+=453
+        }
+    }
+
+    sub rotate_vertices(ubyte ax, ubyte ay, ubyte az) {
+        ; rotate around origin (0,0,0)
+
+        ; set up the 3d rotation matrix values
+        word wcosa = cos8(ax)
+        word wsina = sin8(ax)
+        word wcosb = cos8(ay)
+        word wsinb = sin8(ay)
+        word wcosc = cos8(az)
+        word wsinc = sin8(az)
+
+        word wcosa_sinb = wcosa*wsinb / 128
+        word wsina_sinb = wsina*wsinb / 128
+
+        word Axx = wcosa*wcosb / 128
+        word Axy = (wcosa_sinb*wsinc - wsina*wcosc) / 128
+        word Axz = (wcosa_sinb*wcosc + wsina*wsinc) / 128
+        word Ayx = wsina*wcosb / 128
+        word Ayy = (wsina_sinb*wsinc + wcosa*wcosc) / 128
+        word Ayz = (wsina_sinb*wcosc - wcosa*wsinc) / 128
+        word Azx = -wsinb
+        word Azy = wcosb*wsinc / 128
+        word Azz = wcosb*wcosc / 128
+
+        ubyte @zp i
+        for i in 0 to len(xcoor)-1 {
+            ; don't normalize by dividing by 128, instead keep some precision for perspective calc later
+            rotatedx[i] = Axx*xcoor[i] + Axy*ycoor[i] + Axz*zcoor[i]
+            rotatedy[i] = Ayx*xcoor[i] + Ayy*ycoor[i] + Ayz*zcoor[i]
+            rotatedz[i] = Azx*xcoor[i] + Azy*ycoor[i] + Azz*zcoor[i]
+        }
+    }
+
+    sub draw_edges() {
+
+        ; plot the points of the 3d cube
+        ; first the points on the back, then the points on the front (painter algorithm)
+
+        ubyte @zp i
+        word @zp rz
+        word @zp persp
+        byte sx
+        byte sy
+
+        for i in 0 to len(xcoor)-1 {
+            rz = rotatedz[i]
+            if rz >= 10 {
+                persp = 500 + rz/64
+                sx = rotatedx[i] / persp as byte + screen_width/2
+                sy = rotatedy[i] / persp as byte + screen_height/2
+                txt.setcc(sx as ubyte, sy as ubyte, 46, 7)
+            }
+        }
+
+        for i in 0 to len(xcoor)-1 {
+            rz = rotatedz[i]
+            if rz < 10 {
+                persp = 500 + rz/64
+                sx = rotatedx[i] / persp as byte + screen_width/2
+                sy = rotatedy[i] / persp as byte + screen_height/2
+                txt.setcc(sx as ubyte, sy as ubyte, 81, 7)
+            }
+        }
+    }
+}

examples/cx16/datetime.p8

@@ -1,6 +1,7 @@
-; CommanderX16 text clock example!
+; CommanderX16 text datetime example!
 ; make sure to compile with the cx16 compiler target.
 
+%target cx16
 %import cx16textio
 %zeropage basicsafe
 
@@ -8,18 +9,12 @@ main {
 
     sub start() {
 
-        cx16.r0L = 2020 - 1900
-        cx16.r0H = 8
-        cx16.r1L = 27
-        cx16.r1H = 19
-        cx16.r2L = 16
-        cx16.r2H = 0
-        cx16.r3L = 0
+        cx16.r0 = mkword(8, 2020 - 1900)
+        cx16.r1 = mkword(19, 27)
+        cx16.r2 = mkword(0, 16)
+        cx16.r3 = 0
         cx16.clock_set_date_time()
-
-
-        cx16.screen_set_charset(3, 0)
-        ; c64.CHROUT(14)      ; lowercase charset
+        cx16.screen_set_charset(3, 0)  ; lowercase charset
 
         repeat {
             c64.CHROUT(19)      ; HOME
@@ -33,33 +28,33 @@ main {
     }
 
     sub print_date() {
-        txt.print_uw(1900 + cx16.r0L)
+        txt.print_uw(1900 + lsb(cx16.r0))
         c64.CHROUT('-')
-        if cx16.r0H < 10
+        if msb(cx16.r0) < 10
             c64.CHROUT('0')
-        txt.print_ub(cx16.r0H)
+        txt.print_ub(msb(cx16.r0))
         c64.CHROUT('-')
-        if cx16.r1L < 10
+        if lsb(cx16.r1) < 10
             c64.CHROUT('0')
-        txt.print_ub(cx16.r1L)
+        txt.print_ub(lsb(cx16.r1))
     }
 
     sub print_time() {
-        if cx16.r1H < 10
+        if msb(cx16.r1) < 10
            c64.CHROUT('0')
-        txt.print_ub(cx16.r1H)
+        txt.print_ub(msb(cx16.r1))
         c64.CHROUT(':')
-        if cx16.r2L < 10
+        if lsb(cx16.r2) < 10
             c64.CHROUT('0')
-        txt.print_ub(cx16.r2L)
+        txt.print_ub(lsb(cx16.r2))
         c64.CHROUT(':')
-        if cx16.r2H < 10
+        if msb(cx16.r2) < 10
             c64.CHROUT('0')
-        txt.print_ub(cx16.r2H)
+        txt.print_ub(msb(cx16.r2))
         c64.CHROUT('.')
-        if cx16.r3L < 10
+        if lsb(cx16.r3) < 10
             c64.CHROUT('0')
-        txt.print_ub(cx16.r3L)
+        txt.print_ub(lsb(cx16.r3))
     }
 }
 

examples/cx16/mandelbrot-gfx.bas

@@ -0,0 +1,31 @@
+100 REM MANDELBROT GFX - BASIC VERSION FOR COMMANDERX16
+110 REM MANDELBROT COORDINATES
+120 XL=-2.000:XU=0.500
+130 YL=-1.100:YU=1.100
+140 MI%=16 :REM MAXIMUM ITERATIONS
+150 WI%=256:HI%=200 :REM SCREEN DIMENSIONS
+160 DX=(XU-XL)/WI%
+170 DY=(YU-YL)/HI%
+200 SCREEN $80:TI$="000000"
+500 REM MAIN LOOP
+520 X0=0:Y0=0:GOSUB2000
+530 FOR YY=0 TO HI%-1
+540 Y0=YL+DY*YY
+610 FOR XX=0 TO WI%-1
+620 X0=XL+DX*XX
+700 REM CALCULATE MANDELBROT
+710 X=0:Y=0:IT%=0
+720 X2=0:Y2=0
+730 XY=X*Y
+740 X=X2-Y2+X0
+750 Y=2*XY+Y0
+760 IT%=IT%+1
+770 X2=X*X:Y2=Y*Y
+780 IF (X2+Y2 <= 4) AND (IT% < MI%) THEN GOTO 730
+790 PSET XX,YY,MI%-IT%
+800 NEXT XX
+810 GOSUB2000
+820 NEXT YY
+1000 GOTO 1000
+2000 REM OUTPUT TIME SPENT
+2010 PRINT CHR$(19)SPC(33)TI$:RETURN

examples/cx16/mandelbrot-gfx.p8

@@ -0,0 +1,95 @@
+%target cx16
+%import cx16textio
+%import cx16flt
+%zeropage basicsafe
+
+main {
+    const uword width = 256
+    const uword height = 200
+    const ubyte max_iter = 16       ; 32 actually looks pretty nice but takes longer
+
+    sub start()  {
+        initialize()
+        mandel()
+        repeat {
+            ; do nothing
+        }
+    }
+
+    sub mandel() {
+        const float XL=-2.000
+        const float XU=0.500
+        const float YL=-1.100
+        const float YU=1.100
+        float dx = (XU-XL)/width
+        float dy = (YU-YL)/height
+        ubyte pixelx
+        ubyte pixely
+
+        for pixely in 0 to height-1 {
+            float yy = YL+dy*(pixely as float)
+
+            cx16.r0 = 0
+            cx16.r1 = pixely
+            cx16.FB_cursor_position()
+
+            for pixelx in 0 to width-1 {
+                float xx = XL+dx*(pixelx as float)
+
+                float xsquared = 0.0
+                float ysquared = 0.0
+                float x = 0.0
+                float y = 0.0
+                ubyte iter = 0
+
+                while iter<max_iter and xsquared+ysquared<4.0 {
+                    y = x*y*2.0 + yy
+                    x = xsquared - ysquared + xx
+                    xsquared = x*x
+                    ysquared = y*y
+                    iter++
+                }
+                cx16.FB_set_pixel(max_iter-iter)
+            }
+
+            print_time()
+        }
+    }
+
+    sub initialize() {
+        void cx16.screen_set_mode($80)
+
+        txt.plot(32, 5)
+        txt.print("256*200")
+        txt.plot(32, 6)
+        txt.print("mandel-")
+        txt.plot(33, 7)
+        txt.print("brot")
+        txt.plot(32, 9)
+        txt.print("floats")
+        txt.plot(32, 10)
+        txt.print_b(max_iter)
+        txt.print(" iter")
+
+        cx16.r0 = 0
+        cx16.r1 = 0
+        cx16.r2 = 0
+        cx16.r3 = 0
+        cx16.clock_set_date_time()
+
+        cx16.r0=0
+        cx16.FB_init()
+    }
+
+    sub print_time() {
+        cx16.clock_get_date_time()
+        txt.plot(33, 12)
+        if lsb(cx16.r2) < 10
+            c64.CHROUT('0')
+        txt.print_ub(lsb(cx16.r2))
+        c64.CHROUT(':')
+        if msb(cx16.r2) < 10
+            c64.CHROUT('0')
+        txt.print_ub(msb(cx16.r2))
+    }
+}

examples/cx16/mandelbrot.p8

@@ -0,0 +1,43 @@
+%target cx16
+%import cx16textio
+%import cx16flt
+%zeropage basicsafe
+
+main {
+    const uword width = 60
+    const uword height = 50
+    const ubyte max_iter = 16
+
+    sub start()  {
+        txt.print("calculating mandelbrot fractal...\n\n")
+
+        ubyte pixelx
+        ubyte pixely
+
+        for pixely in 0 to height-1 {
+            float yy = (pixely as float)/0.40/height - 1.3
+
+            for pixelx in 0 to width-1 {
+                float xx = (pixelx as float)/0.32/width - 2.2
+
+                float xsquared = 0.0
+                float ysquared = 0.0
+                float x = 0.0
+                float y = 0.0
+                ubyte iter = 0
+
+                while iter<max_iter and xsquared+ysquared<4.0 {
+                    y = x*y*2.0 + yy
+                    x = xsquared - ysquared + xx
+                    xsquared = x*x
+                    ysquared = y*y
+                    iter++
+                }
+                ; txt.setchr(pixelx, pixely, '*')
+                txt.color2(1, max_iter-iter)
+                c64.CHROUT(' ')
+            }
+            c64.CHROUT('\n')
+        }
+    }
+}

examples/cx16/simplegraphics.p8

@@ -0,0 +1,40 @@
+; CommanderX16 simple graphics example!
+; make sure to compile with the cx16 compiler target.
+
+%target cx16
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+
+        void cx16.screen_set_mode($80)
+        cx16.r0=0
+
+        cx16.FB_init()
+        cx16.r0 = 0
+        cx16.r1 = 0
+        cx16.FB_cursor_position()
+        uword xx
+        ubyte yy
+        for yy in 199 downto 0 {
+            for xx in 319 downto 0 {
+                cx16.FB_set_pixel( yy+lsb(xx))
+            }
+        }
+
+        ; cx16.GRAPH_init()
+        for xx in 0 to 319 step 32 {
+            ubyte q
+            for q in 0 to 31 {
+                cx16.GRAPH_set_colors(q, 2, 0)
+                cx16.r0 = xx+q
+                cx16.r1=0
+                cx16.r2=rnd()
+                cx16.r3=199
+                cx16.GRAPH_draw_line()
+            }
+        }
+    }
+}
+

examples/cx16/swirl-float.p8

@@ -0,0 +1,28 @@
+%target cx16
+%import cx16textio
+%import cx16flt
+%zeropage basicsafe
+
+main {
+
+    const uword width = 80
+    const uword height = 60
+
+    struct Ball {
+        float t
+        ubyte color
+    }
+
+    sub start()  {
+
+        Ball ball
+
+        repeat {
+            ubyte xx=(sin(ball.t) * width/2.1) + width/2.0 as ubyte
+            ubyte yy=(cos(ball.t*1.1356) * height/2.1) + height/2.0 as ubyte
+            txt.setcc(xx, yy, 81, ball.color)
+            ball.t  += 0.05
+            ball.color++
+        }
+    }
+}

examples/cx16/swirl.p8

@@ -0,0 +1,31 @@
+%target cx16
+%import cx16lib
+%import cx16textio
+%zeropage basicsafe
+
+main {
+
+    const uword width = 79
+    const uword height = 59
+
+    struct Ball {
+        uword anglex
+        uword angley
+        ubyte color
+    }
+
+    sub start()  {
+
+        Ball ball
+
+        repeat {
+            ubyte x = msb(sin8u(msb(ball.anglex)) as uword * width)
+            ubyte y = msb(cos8u(msb(ball.angley)) as uword * height)
+            txt.setcc(x, y, 81, ball.color)
+
+            ball.anglex+=266
+            ball.angley+=215
+            ball.color++
+        }
+    }
+}

examples/hello.p8

@@ -9,7 +9,7 @@ main {
     sub start() {
 
         ; set text color and activate lowercase charset
-        c64.COLOR = 13
+        txt.color(13)
         c64.VMCSB |= 2
 
         ; use optimized routine to write text

examples/line-circle-txt.p8

@@ -16,13 +16,13 @@ main {
         txt.print("enter for disc:")
         void c64.CHRIN()
         c64.CHROUT('\n')
-        txt.clear_screen(' ', 1)
+        txt.clear_screen()
         disc(20, 12, 12)
 
         txt.print("enter for lines:")
         void c64.CHRIN()
         c64.CHROUT('\n')
-        txt.clear_screen(' ', 1)
+        txt.clear_screen()
 
         line(1, 10, 38, 24)
         line(1, 20, 38, 2)
@@ -32,7 +32,7 @@ main {
         txt.print("enter for rectangles:")
         void c64.CHRIN()
         c64.CHROUT('\n')
-        txt.clear_screen(' ', 1)
+        txt.clear_screen()
 
         rect(4, 8, 37, 23, false)
         rect(20, 12, 30, 20, true)

examples/mandelbrot-gfx.p8

@@ -37,10 +37,8 @@ main {
                     iter++
                 }
 
-                if iter & 1 {
-                    graphics.plotx = pixelx
-                    graphics.plot(pixely)
-                }
+                if iter & 1
+                    graphics.plot(pixelx, pixely)
             }
         }
 

examples/plasma.p8

@@ -21,7 +21,7 @@ main {
     const ubyte PAGE2 = ((SCREEN2 >> 6) & $F0) | ((CHARSET >> 10) & $0E)
 
     sub start() {
-        c64.COLOR = 1
+        txt.color(1)
         txt.print("creating charset...\n")
         makechar()
 

examples/romfloats.p8

@@ -4,8 +4,47 @@
 main {
 
     sub start() {
+        print_rom_floats_values()
+       	c64.CHROUT('\n')
+        print_rom_floats()
+       	c64.CHROUT('\n')
+    }
 
+    sub print_rom_floats() {
+        c64flt.FL_PIVAL=9.9999
+    	c64flt.print_f(c64flt.FL_PIVAL)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_N32768)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_FONE)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_SQRHLF)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_SQRTWO)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_NEGHLF)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_LOG2)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_TENC)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_NZMIL)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_FHALF)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_LOGEB2)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_PIHALF)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_TWOPI)
+    	c64.CHROUT('\n')
+    	c64flt.print_f(c64flt.FL_FR4)
+    	c64.CHROUT('\n')
+    }
+
+    sub print_rom_floats_values() {
         ; these are all floating point constants defined in the ROM so no allocation required
+        ; the compiler recognises these and will substitute the ROM values automatically
 
         c64flt.print_f(3.141592653589793)
         c64.CHROUT('\n')

examples/swirl-float.p8

@@ -6,17 +6,21 @@ main {
     const uword width = 40
     const uword height = 25
 
-    sub start()  {
-
+    struct Ball {
         float t
         ubyte color
+    }
+
+    sub start()  {
+
+        Ball ball
 
         repeat {
-            ubyte xx=(sin(t) * width/2.2) + width/2.0 as ubyte
-            ubyte yy=(cos(t*1.1356) * height/2.2) + height/2.0 as ubyte
-            txt.setcc(xx, yy, 81, color)
-            t  += 0.08
-            color++
+            ubyte xx=(sin(ball.t) * width/2.1) + width/2.0 as ubyte
+            ubyte yy=(cos(ball.t*1.1356) * height/2.1) + height/2.0 as ubyte
+            txt.setcc(xx, yy, 81, ball.color)
+            ball.t  += 0.08
+            ball.color++
         }
     }
 }

examples/tehtriz.p8

@@ -280,12 +280,12 @@ waitkey:
 
     sub drawBoard() {
         c64.CLEARSCR()
-        c64.COLOR = 7
+        txt.color(7)
         txt.plot(1,1)
         txt.print("irmen's")
         txt.plot(2,2)
         txt.print("teh▁triz")
-        c64.COLOR = 5
+        txt.color(5)
         txt.plot(6,4)
         txt.print("hold:")
         txt.plot(2,22)
@@ -296,10 +296,10 @@ waitkey:
         txt.print("lines:")
         txt.plot(28,14)
         txt.print("score:")
-        c64.COLOR = 12
+        txt.color(12)
         txt.plot(27,18)
         txt.print("controls:")
-        c64.COLOR = 11
+        txt.color(11)
         txt.plot(28,19)
         txt.print(",/  move")
         txt.plot(28,20)
@@ -342,7 +342,7 @@ waitkey:
     }
 
     sub drawScore() {
-        c64.COLOR=1
+        txt.color(1)
         txt.plot(30,11)
         txt.print_uw(lines)
         txt.plot(30,15)
@@ -385,9 +385,9 @@ waitkey:
     }
 
     sub drawBlock(ubyte x, ubyte y, ubyte character) {
-        ubyte i
+        ubyte @zp i
         for i in 15 downto 0 {
-            ubyte c=blocklogic.currentBlock[i]
+            ubyte @zp c=blocklogic.currentBlock[i]
             if c
                 txt.setcc((i&3)+x, (i/4)+y, character, c)
         }
@@ -534,7 +534,7 @@ blocklogic {
     }
 
     sub noCollision(ubyte xpos, ubyte ypos) -> ubyte {
-        ubyte i
+        ubyte @zp i
         for i in 15 downto 0 {
             if currentBlock[i] and txt.getchr(xpos + (i&3), ypos+i/4)!=32
                 return false

examples/test.p8

@@ -1,18 +1,20 @@
+%import c64lib
+%import c64graphics
 %import c64textio
+;%import c64flt
+;%option enable_floats
 %zeropage basicsafe
 
+
 main {
-    sub start() {
-        ubyte b1 = 2
-        ubyte b2 = 13
-        ubyte b3 = 100
 
-        uword w1 = 2222
-        uword w2 = 11
-        uword w3 = 33
+;asmsub  clear_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  { ...}
+; TODO dont cause name conflict if we define sub or sub with param 'color' or even a var 'color' later.
 
-        w1 %= (w2+w3)
-        txt.print_uw(w1)
-        c64.CHROUT('\n')
+;   sub color(...) {}
+;   sub other(ubyte color) {}    ; TODO don't cause name conflict
+
+
+    sub start()  {
     }
 }

parser/antlr/prog8.g4

@@ -126,7 +126,7 @@ unconditionaljump :  'goto'  (integerliteral | scoped_identifier) ;
 
 directive :
 	directivename=('%output' | '%launcher' | '%zeropage' | '%zpreserved' | '%address' | '%import' |
-                       '%breakpoint' | '%asminclude' | '%asmbinary' | '%option')
+                       '%breakpoint' | '%asminclude' | '%asmbinary' | '%option' | '%target' )
         (directivearg? | directivearg (',' directivearg)*)
         ;
 
@@ -273,7 +273,7 @@ asmsub_decl : identifier '(' asmsub_params? ')' asmsub_clobbers? asmsub_returns?
 
 asmsub_params :  asmsub_param (',' EOL? asmsub_param)* ;
 
-asmsub_param :  vardecl '@' (identifier | stack='stack') ;      // A,X,Y,AX,AY,XY,Pc,Pz,Pn,Pv allowed
+asmsub_param :  vardecl '@' identifier ;      // A,X,Y,AX,AY,XY,Pc,Pz,Pn,Pv allowed.  TODO implement  stack='stack'
 
 asmsub_clobbers : 'clobbers' '(' clobber? ')' ;