readme

For function calls, register saves go via stack (to allow nested saves) for simpler cases, registers are saved in a local variable.
Fixed too agressive removal of sta-lda sequence if the lda is followed by a branching instruction.
Insert missing cmp #0 after functioncall if the value of the A register is needed in a comparison expression (could otherwise test wrong status flag)

.gitignore

@@ -29,3 +29,5 @@ parsetab.py
 
 .gradle
 /prog8compiler.jar
+sd*.img
+

.idea/libraries/antlr_4_7_2_complete.xml

@@ -1,9 +0,0 @@
-<component name="libraryTable">
-  <library name="antlr-4.7.2-complete">
-    <CLASSES>
-      <root url="jar://$PROJECT_DIR$/parser/antlr/lib/antlr-4.7.2-complete.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/antlr_4_9_complete.xml

@@ -1,7 +1,7 @@
 <component name="libraryTable">
-  <library name="antlr-4.8-complete">
+  <library name="antlr-4.9-complete">
     <CLASSES>
-      <root url="jar://$PROJECT_DIR$/parser/antlr/lib/antlr-4.8-complete.jar!/" />
+      <root url="jar://$PROJECT_DIR$/parser/antlr/lib/antlr-4.9-complete.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/antlr_runtime_4_7_2.xml

@@ -1,9 +0,0 @@
-<component name="libraryTable">
-  <library name="antlr-runtime-4.7.2">
-    <CLASSES>
-      <root url="jar://$PROJECT_DIR$/parser/antlr/lib/antlr-runtime-4.7.2.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/antlr_runtime_4_9.xml

@@ -1,7 +1,7 @@
 <component name="libraryTable">
-  <library name="antlr-runtime-4.8">
+  <library name="antlr-runtime-4.9">
     <CLASSES>
-      <root url="jar://$PROJECT_DIR$/parser/antlr/lib/antlr-runtime-4.8.jar!/" />
+      <root url="jar://$PROJECT_DIR$/parser/antlr/lib/antlr-runtime-4.9.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/dbus_java_3_2_4.xml

@@ -0,0 +1,9 @@
+<component name="libraryTable">
+  <library name="dbus-java-3.2.4">
+    <CLASSES>
+      <root url="jar://$PROJECT_DIR$/dbusCompilerService/lib/dbus-java-3.2.4.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/libraries/javax_json_api_1_1_4.xml

@@ -0,0 +1,10 @@
+<component name="libraryTable">
+  <library name="javax.json-api-1.1.4">
+    <CLASSES>
+      <root url="jar://$PROJECT_DIR$/httpCompilerService/lib/javax.json-api-1.1.4.jar!/" />
+      <root url="jar://$PROJECT_DIR$/httpCompilerService/lib/javax.json-1.1.4.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/libraries/kotlinx_cli_jvm.xml

@@ -1,7 +1,7 @@
 <component name="libraryTable">
-  <library name="kotlinx-cli-jvm-0.1.0-dev-5">
+  <library name="kotlinx-cli-jvm">
     <CLASSES>
-      <root url="jar://$PROJECT_DIR$/compiler/lib/kotlinx-cli-jvm-0.1.0-dev-5.jar!/" />
+      <root url="jar://$PROJECT_DIR$/compiler/lib/kotlinx-cli-jvm-0.3.1.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/slf4j_api_1_7_30.xml

@@ -0,0 +1,10 @@
+<component name="libraryTable">
+  <library name="slf4j-api-1.7.30">
+    <CLASSES>
+      <root url="jar://$PROJECT_DIR$/httpCompilerService/lib/slf4j-api-1.7.30.jar!/" />
+      <root url="jar://$PROJECT_DIR$/httpCompilerService/lib/slf4j-simple-1.7.30.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/libraries/takes_http.xml

@@ -0,0 +1,12 @@
+<component name="libraryTable">
+  <library name="takes-http">
+    <CLASSES>
+      <root url="jar://$PROJECT_DIR$/httpCompilerService/lib/cactoos-0.42.jar!/" />
+      <root url="jar://$PROJECT_DIR$/httpCompilerService/lib/commons-lang3-3.7.jar!/" />
+      <root url="jar://$PROJECT_DIR$/httpCompilerService/lib/commons-text-1.4.jar!/" />
+      <root url="jar://$PROJECT_DIR$/httpCompilerService/lib/takes-1.19.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/modules.xml

@@ -3,8 +3,10 @@
   <component name="ProjectModuleManager">
     <modules>
       <module fileurl="file://$PROJECT_DIR$/compiler/compiler.iml" filepath="$PROJECT_DIR$/compiler/compiler.iml" />
+      <module fileurl="file://$PROJECT_DIR$/dbusCompilerService/dbusCompilerService.iml" filepath="$PROJECT_DIR$/dbusCompilerService/dbusCompilerService.iml" />
       <module fileurl="file://$PROJECT_DIR$/docs/docs.iml" filepath="$PROJECT_DIR$/docs/docs.iml" />
       <module fileurl="file://$PROJECT_DIR$/examples/examples.iml" filepath="$PROJECT_DIR$/examples/examples.iml" />
+      <module fileurl="file://$PROJECT_DIR$/httpCompilerService/httpCompilerService.iml" filepath="$PROJECT_DIR$/httpCompilerService/httpCompilerService.iml" />
       <module fileurl="file://$PROJECT_DIR$/parser/parser.iml" filepath="$PROJECT_DIR$/parser/parser.iml" />
     </modules>
   </component>

README.md

@@ -33,11 +33,13 @@ What does Prog8 provide?
 - conditional branches
 - floating point operations  (requires the C64 Basic ROM routines for this)
 - 'when' statement to provide a concise jump table alternative to if/elseif chains
-- many built-in functions such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``sort`` and ``reverse``
 - structs to group together sets of variables and manipulate them at once
+- many built-in functions such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``sort`` and ``reverse``
+- various powerful built-in libraries to do I/O, number conversions, graphics and more  
 - convenience abstractions for low level aspects such as ZeroPage handling, program startup, explicit memory addresses
 - fast execution speed due to compilation to native assembly code
 - inline assembly allows you to have full control when every cycle or byte matters
+- supports the sixteen 'virtual' 16-bit registers R0 .. R15 from the Commander X16, and provides them also on the C64.
 
 *Rapid edit-compile-run-debug cycle:*
 
@@ -48,8 +50,8 @@ What does Prog8 provide?
 
 *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), the main target.
-- "cx16": [CommanderX16](https://www.commanderx16.com)  (65c02 CPU) .
+- "c64": Commodore-64  (6510 CPU = almost a 6502)
+- "cx16": [CommanderX16](https://www.commanderx16.com)  (65c02 CPU)
 - If you only use standard kernel and prog8 library routines, it is possible to compile the *exact same program* for both machines (just change the compiler target flag)!
 
 
@@ -84,9 +86,7 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
         ubyte candidate_prime = 2       ; is increased in the loop
     
         sub start() {
-            ; clear the sieve, to reset starting situation on subsequent runs
-            memset(sieve, 256, false)   
-            ; calculate primes
+            sys.memset(sieve, 256, false)   ; clear the sieve
             txt.print("prime numbers up to 255:\n\n")
             ubyte amount=0
             repeat {
@@ -97,17 +97,17 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
                 txt.print(", ")
                 amount++
             }
-            txt.chrout('\n')
+            txt.nl()
             txt.print("number of primes (expected 54): ")
             txt.print_ub(amount)
-            txt.chrout('\n')
+            txt.nl()
         }
     
         sub find_next_prime() -> ubyte {
             while sieve[candidate_prime] {
                 candidate_prime++
                 if candidate_prime==0
-                    return 0        ; we wrapped; no more primes available in the sieve
+                    return 0        ; we wrapped; no more primes
             }
     
             ; found next one, mark the multiples and return it.
@@ -124,6 +124,7 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
 
 
 
+
 when compiled an ran on a C-64 you'll get:
 
 ![c64 screen](docs/source/_static/primes_example.png)
@@ -140,7 +141,8 @@ If you want to play a video game, a fully working Tetris clone is included in th
 
 ![tehtriz_screen](docs/source/_static/tehtriz.png)
 
-The CommanderX16 compiler target is quite capable already too, here's a well known space ship 
-animated in 3D with hidden line removal, in the CommanderX16 emulator:
+There are a couple of examples specially made for the CommanderX16 compiler target.
+For instance here's a well known space ship animated in 3D with hidden line removal,
+in the CommanderX16 emulator:
 
 ![cobra3d](docs/source/_static/cobra3d.png)

compiler/build.gradle

@@ -1,28 +1,18 @@
-buildscript {
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.20"
-    }
-}
-
 plugins {
-    // id "org.jetbrains.kotlin.jvm" version "1.4.20"
-    id 'application'
-    id 'org.jetbrains.dokka' version "0.9.18"
-    id 'com.github.johnrengelman.shadow' version '5.2.0'
     id 'java'
+    id 'application'
+    id "org.jetbrains.kotlin.jvm" version "1.4.21"
+    id 'org.jetbrains.dokka' version "0.9.18"
+    id 'com.github.johnrengelman.shadow' version '6.1.0'
 }
 
-apply plugin: "kotlin"
-apply plugin: "java"
-
 targetCompatibility = 11
 sourceCompatibility = 11
 
 repositories {
     mavenLocal()
     mavenCentral()
-    jcenter()
-    maven { url "https://dl.bintray.com/orangy/maven/" }
+    maven { url "https://kotlin.bintray.com/kotlinx" }
 }
 
 def prog8version = rootProject.file('compiler/res/version.txt').text.trim()
@@ -32,9 +22,9 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
     implementation 'org.antlr:antlr4-runtime:4.8'
-    implementation 'org.jetbrains.kotlinx:kotlinx-cli-jvm:0.1.0-dev-5'
-    // implementation 'net.razorvine:ksim65:1.6'
-    // implementation "com.github.hypfvieh:dbus-java:3.2.0"
+    implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.1'
+    // implementation 'net.razorvine:ksim65:1.8'
+    // implementation "com.github.hypfvieh:dbus-java:3.2.4"
     implementation project(':parser')
 
     testImplementation "org.jetbrains.kotlin:kotlin-test-junit5"
@@ -76,7 +66,8 @@ sourceSets {
 startScripts.enabled = true
 
 application {
-    mainClassName = 'prog8.CompilerMainKt'
+    mainClass = 'prog8.CompilerMainKt'
+    mainClassName = 'prog8.CompilerMainKt'  // deprecated
     applicationName = 'p8compile'
 }
 
@@ -112,5 +103,5 @@ dokka {
 }
 
 task wrapper(type: Wrapper) {
-    gradleVersion = '6.1.1'
+    gradleVersion = '6.7'
 }

compiler/compiler.iml

@@ -13,7 +13,7 @@
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
     <orderEntry type="module" module-name="parser" />
     <orderEntry type="library" name="unittest-libs" level="project" />
-    <orderEntry type="library" name="kotlinx-cli-jvm-0.1.0-dev-5" level="project" />
-    <orderEntry type="library" name="antlr-runtime-4.8" level="project" />
+    <orderEntry type="library" name="kotlinx-cli-jvm" level="project" />
+    <orderEntry type="library" name="antlr-runtime-4.9" level="project" />
   </component>
 </module>

compiler/res/.editorconfig

@@ -0,0 +1,20 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+max_line_length = 120
+tab_width = 8
+trim_trailing_whitespace = true
+ij_smart_tabs = true
+
+[*.p8]
+indent_size = 4
+indent_style = space
+
+[*.asm]
+indent_size = 8
+indent_style = tab

compiler/res/prog8lib/c64/floats.asm

@@ -2,6 +2,8 @@
 
 FL_ONE_const	.byte  129     			; 1.0
 FL_ZERO_const	.byte  0,0,0,0,0		; 0.0
+FL_LOG2_const	.byte  $80, $31, $72, $17, $f8	; log(2)
+
 
 floats_store_reg	.byte  0		; temp storage
 

compiler/res/prog8lib/c64/floats.p8

@@ -19,23 +19,6 @@ floats {
 		; 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.
 
-		; constants in five-byte "mflpt" format in the BASIC ROM
-		&float  FL_PIVAL	= $aea8  ; 3.1415926...
-		&float  FL_N32768	= $b1a5  ; -32768
-		&float  FL_FONE		= $b9bc  ; 1
-		&float  FL_SQRHLF	= $b9d6  ; SQR(2) / 2
-		&float  FL_SQRTWO	= $b9db  ; SQR(2)
-		&float  FL_NEGHLF	= $b9e0  ; -.5
-		&float  FL_LOG2		= $b9e5  ; LOG(2)
-		&float  FL_TENC		= $baf9  ; 10
-		&float  FL_NZMIL	= $bdbd  ; 1e9 (1 billion)
-		&float  FL_FHALF	= $bf11  ; .5
-		&float  FL_LOGEB2	= $bfbf  ; 1 / LOG(2)
-		&float  FL_PIHALF	= $e2e0  ; PI / 2
-		&float  FL_TWOPI	= $e2e5  ; 2 * PI
-		&float  FL_FR4		= $e2ea  ; .25
-		; 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.

compiler/res/prog8lib/c64/floats_funcs.asm

@@ -175,8 +175,8 @@ func_log2_fac1	.proc
 		stx  P8ZP_SCRATCH_REG
 		jsr  LOG
 		jsr  MOVEF
-		lda  #<FL_LOG2
-		ldy  #>FL_LOG2
+		lda  #<FL_LOG2_const
+		ldy  #>FL_LOG2_const
 		jsr  MOVFM
 		jsr  FDIVT
 		ldx  P8ZP_SCRATCH_REG

compiler/res/prog8lib/c64/graphics.p8

@@ -27,23 +27,36 @@ graphics {
     }
 
     sub clear_screen(ubyte pixelcolor, ubyte bgcolor) {
-        memset(BITMAP_ADDRESS, 320*200/8, 0)
+        sys.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
+        ; 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
+            ; make sure dy is always positive to have only 4 instead of 8 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-y1
+
+        if dx==0 {
+            vertical_line(x1, y1, abs(dy)+1 as ubyte)
+            return
+        }
+        if dy==0 {
+            if x1>x2
+                x1=x2
+            horizontal_line(x1, y1, abs(dx)+1 as uword)
+            return
+        }
+
+        ; TODO rewrite the rest in optimized assembly
+
+        word @zp d = 0
+        ubyte positive_ix = true
         if dx < 0 {
             dx = -dx
             positive_ix = false
@@ -108,78 +121,173 @@ graphics {
         }
     }
 
+    sub rect(uword x, ubyte y, uword width, ubyte height) {
+        if width==0 or height==0
+            return
+        horizontal_line(x, y, width)
+        if height==1
+            return
+        horizontal_line(x, y+height-1, width)
+        vertical_line(x, y+1, height-2)
+        if width==1
+            return
+        vertical_line(x+width-1, y+1, height-2)
+    }
+
+    sub fillrect(uword x, ubyte y, uword width, ubyte height) {
+        if width==0
+            return
+        repeat height {
+            horizontal_line(x, y, width)
+            y++
+        }
+    }
+
+    sub horizontal_line(uword x, ubyte y, uword length) {
+        if length<8 {
+            internal_plotx=x
+            repeat lsb(length) {
+                internal_plot(y)
+                internal_plotx++
+            }
+            return
+        }
+
+        ubyte separate_pixels = lsb(x) & 7
+        uword addr = get_y_lookup(y) + (x&$fff8)
+
+        if separate_pixels {
+            %asm {{
+                lda  addr
+                sta  P8ZP_SCRATCH_W1
+                lda  addr+1
+                sta  P8ZP_SCRATCH_W1+1
+                ldy  separate_pixels
+                lda  _filled_right,y
+                eor  #255
+                ldy  #0
+                ora  (P8ZP_SCRATCH_W1),y
+                sta  (P8ZP_SCRATCH_W1),y
+            }}
+            addr += 8
+            length += separate_pixels
+            length -= 8
+        }
+
+        if length {
+            %asm {{
+                lda  length
+                and  #7
+                sta  separate_pixels
+                stx  P8ZP_SCRATCH_REG
+                lsr  length+1
+                ror  length
+                lsr  length+1
+                ror  length
+                lsr  length+1
+                ror  length
+                lda  addr
+                sta  _modified+1
+                lda  addr+1
+                sta  _modified+2
+                lda  length
+                ora  length+1
+                beq  _zero
+                ldy  length
+                ldx  #$ff
+_modified       stx  $ffff      ; modified
+                lda  _modified+1
+                clc
+                adc  #8
+                sta  _modified+1
+                bcc  +
+                inc  _modified+2
++               dey
+                bne  _modified
+_zero           ldx  P8ZP_SCRATCH_REG
+
+                ldy  separate_pixels
+                beq  _zero2
+                lda  _modified+1
+                sta  P8ZP_SCRATCH_W1
+                lda  _modified+2
+                sta  P8ZP_SCRATCH_W1+1
+                lda  _filled_right,y
+                ldy  #0
+                ora  (P8ZP_SCRATCH_W1),y
+                sta  (P8ZP_SCRATCH_W1),y
+                jmp  _zero2
+_filled_right   .byte  0, %10000000, %11000000, %11100000, %11110000, %11111000, %11111100, %11111110
+_zero2
+            }}
+        }
+    }
+
+    sub vertical_line(uword x, ubyte y, ubyte height) {
+        internal_plotx = x
+        repeat height {
+            internal_plot(y)
+            y++
+        }
+    }
+
     sub circle(uword xcenter, ubyte ycenter, ubyte radius) {
         ; Midpoint algorithm
+        if radius==0
+            return
         ubyte @zp ploty
-        ubyte @zp xx = radius
         ubyte @zp yy = 0
-        byte @zp decisionOver2 = 1-xx as byte
+        word @zp decisionOver2 = (1 as word)-radius
 
-        while xx>=yy {
-            internal_plotx = xcenter + xx
+        while radius>=yy {
+            internal_plotx = xcenter + radius
             ploty = ycenter + yy
             internal_plot(ploty)
-            internal_plotx = xcenter - xx
+            internal_plotx = xcenter - radius
             internal_plot(ploty)
-            internal_plotx = xcenter + xx
+            internal_plotx = xcenter + radius
             ploty = ycenter - yy
             internal_plot(ploty)
-            internal_plotx = xcenter - xx
+            internal_plotx = xcenter - radius
             internal_plot(ploty)
             internal_plotx = xcenter + yy
-            ploty = ycenter + xx
+            ploty = ycenter + radius
             internal_plot(ploty)
             internal_plotx = xcenter - yy
             internal_plot(ploty)
             internal_plotx = xcenter + yy
-            ploty = ycenter - xx
+            ploty = ycenter - radius
             internal_plot(ploty)
             internal_plotx = xcenter - yy
             internal_plot(ploty)
             yy++
             if decisionOver2<=0
-                decisionOver2 += 2*yy+1
+                decisionOver2 += (yy as word)*2+1
             else {
-                xx--
-                decisionOver2 += 2*(yy-xx)+1
+                radius--
+                decisionOver2 += (yy as word -radius)*2+1
             }
         }
     }
 
     sub disc(uword xcenter, ubyte ycenter, ubyte radius) {
         ; Midpoint algorithm, filled
-        ubyte xx = radius
-        ubyte yy = 0
-        byte decisionOver2 = 1-xx as byte
+        if radius==0
+            return
+        ubyte @zp yy = 0
+        word decisionOver2 = (1 as word)-radius
 
-        while xx>=yy {
-            ubyte ycenter_plus_yy = ycenter + yy
-            ubyte ycenter_min_yy = ycenter - yy
-            ubyte ycenter_plus_xx = ycenter + xx
-            ubyte ycenter_min_xx = ycenter - xx
-
-            for internal_plotx in xcenter to xcenter+xx {
-                internal_plot(ycenter_plus_yy)
-                internal_plot(ycenter_min_yy)
-            }
-            for internal_plotx in xcenter-xx to xcenter-1 {
-                internal_plot(ycenter_plus_yy)
-                internal_plot(ycenter_min_yy)
-            }
-            for internal_plotx in xcenter to xcenter+yy {
-                internal_plot(ycenter_plus_xx)
-                internal_plot(ycenter_min_xx)
-            }
-            for internal_plotx in xcenter-yy to xcenter {
-                internal_plot(ycenter_plus_xx)
-                internal_plot(ycenter_min_xx)
-            }
+        while radius>=yy {
+            horizontal_line(xcenter-radius, ycenter+yy, radius*2+1)
+            horizontal_line(xcenter-radius, ycenter-yy, radius*2+1)
+            horizontal_line(xcenter-yy, ycenter+radius, yy*2+1)
+            horizontal_line(xcenter-yy, ycenter-radius, yy*2+1)
             yy++
             if decisionOver2<=0
-                decisionOver2 += 2*yy+1
+                decisionOver2 += (yy as word)*2+1
             else {
-                xx--
-                decisionOver2 += 2*(yy-xx)+1
+                radius--
+                decisionOver2 += (yy as word -radius)*2+1
             }
         }
     }
@@ -192,11 +300,11 @@ graphics {
 ;        @(addr) |= ormask[lsb(px) & 7]
 ;    }
 
-    asmsub  plot(uword plotx @XY, ubyte ploty @A) clobbers (A, X, Y) {
+    inline asmsub  plot(uword plotx @XY, ubyte ploty @A) clobbers (A, X, Y) {
         %asm {{
-            stx  internal_plotx
-            sty  internal_plotx+1
-            jmp  internal_plot
+            stx  graphics.internal_plotx
+            sty  graphics.internal_plotx+1
+            jsr  graphics.internal_plot
         }}
     }
 
@@ -248,6 +356,17 @@ _y_lookup_hi    .byte  >_plot_y_values
         }}
     }
 
+    asmsub get_y_lookup(ubyte y @Y) -> uword @AY {
+        %asm {{
+            lda  internal_plot._y_lookup_lo,y
+            pha
+            lda  internal_plot._y_lookup_hi,y
+            tay
+            pla
+            rts
+        }}
+    }
+
 }
 
 

compiler/res/prog8lib/c64/syslib.p8

@@ -225,6 +225,41 @@ romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base addr
 
 ; ---- end of C64 ROM kernal routines ----
 
+; ---- utilities -----
+
+asmsub STOP2() -> ubyte @A  {
+    ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the carry status flag.
+    %asm {{
+        txa
+        pha
+        jsr  c64.STOP
+        beq  +
+        pla
+        tax
+        lda  #0
+        rts
++       pla
+        tax
+        lda  #1
+        rts
+    }}
+}
+
+asmsub RDTIM16() -> uword @AY {
+    ; --  like RDTIM() but only returning the lower 16 bits for convenience
+    %asm {{
+        stx  P8ZP_SCRATCH_REG
+        jsr  c64.RDTIM
+        pha
+        txa
+        tay
+        pla
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+
 
 ; ---- C64 specific system utility routines: ----
 
@@ -259,17 +294,7 @@ asmsub  init_system()  {
     }}
 }
 
-asmsub  reset_system()  {
-    ; Soft-reset the system back to Basic prompt.
-    %asm {{
-        sei
-        lda  #14
-        sta  $01        ; bank the kernal in
-        jmp  (c64.RESET_VEC)
-    }}
-}
-
-asmsub  disable_runstop_and_charsetswitch() {
+asmsub  disable_runstop_and_charsetswitch() clobbers(A) {
     %asm {{
         lda  #$80
         sta  657    ; disable charset switching
@@ -363,7 +388,7 @@ IRQ_SCRATCH_ZPWORD2	.word  0
 		}}
 }
 
-asmsub  restore_irqvec() {
+asmsub  restore_irqvec() clobbers(A) {
 	%asm {{
 		sei
 		lda  #<c64.IRQDFRT
@@ -444,5 +469,208 @@ _raster_irq_handler
 
 ; ---- end of C64 specific system utility routines ----
 
+}
+
+sys {
+    ; ------- lowlevel system routines --------
+
+    const ubyte target = 64         ;  compilation target specifier.  64 = C64,  16 = CommanderX16.
+
+
+    asmsub  reset_system()  {
+        ; Soft-reset the system back to Basic prompt.
+        %asm {{
+            sei
+            lda  #14
+            sta  $01        ; bank the kernal in
+            jmp  (c64.RESET_VEC)
+        }}
+    }
+
+    sub wait(uword jiffies) {
+        ; --- wait approximately the given number of jiffies (1/60th seconds)
+        repeat jiffies {
+            ubyte jiff = lsb(c64.RDTIM16())
+            while jiff==lsb(c64.RDTIM16()) {
+                ; wait until 1 jiffy has passed
+            }
+        }
+    }
+
+    asmsub memcopy(uword source @R0, uword target @R1, uword count @AY) clobbers(A,X,Y) {
+        %asm {{
+            ldx  cx16.r0
+            stx  P8ZP_SCRATCH_W1
+            ldx  cx16.r0+1
+            stx  P8ZP_SCRATCH_W1+1
+            ldx  cx16.r1
+            stx  P8ZP_SCRATCH_W2
+            ldx  cx16.r1+1
+            stx  P8ZP_SCRATCH_W2+1
+            cpy  #0
+            bne  _longcopy
+            ; copy <= 255
+            tay
+
+_remainder
+            lda  P8ZP_SCRATCH_W1
+            bne  +
+            dec  P8ZP_SCRATCH_W1+1
++           dec  P8ZP_SCRATCH_W1
+            lda  P8ZP_SCRATCH_W2
+            bne  +
+            dec  P8ZP_SCRATCH_W2+1
++           dec  P8ZP_SCRATCH_W2
+-           lda  (P8ZP_SCRATCH_W1), y
+            sta  (P8ZP_SCRATCH_W2), y
+            dey
+            bne  -
+            rts
+
+_longcopy
+            sta  P8ZP_SCRATCH_B1        ; lsb(count) = remainder
+            tya
+            tax                         ; x = num pages (1+)
+            ldy  #0
+-           lda  (P8ZP_SCRATCH_W1),y    ; copy a page at a time
+            sta  (P8ZP_SCRATCH_W2),y
+            iny
+            bne  -
+            inc  P8ZP_SCRATCH_W1+1
+            inc  P8ZP_SCRATCH_W2+1
+            dex
+            bne  -
+            ldy  P8ZP_SCRATCH_B1
+            jmp  _remainder
+        }}
+    }
+
+    asmsub memset(uword mem @R0, uword numbytes @R1, ubyte value @A) clobbers(A,X,Y) {
+        %asm {{
+            ldy  cx16.r0
+            sty  P8ZP_SCRATCH_W1
+            ldy  cx16.r0+1
+            sty  P8ZP_SCRATCH_W1+1
+            ldx  cx16.r1
+            ldy  cx16.r1+1
+            jmp  prog8_lib.memset
+        }}
+    }
+
+    asmsub memsetw(uword mem @R0, uword numwords @R1, uword value @AY) clobbers(A,X,Y) {
+        %asm {{
+            ldx  cx16.r0
+            stx  P8ZP_SCRATCH_W1
+            ldx  cx16.r0+1
+            stx  P8ZP_SCRATCH_W1+1
+            ldx  cx16.r1
+            stx  P8ZP_SCRATCH_W2
+            ldx  cx16.r1+1
+            stx  P8ZP_SCRATCH_W2+1
+            jmp  prog8_lib.memsetw
+        }}
+    }
+
+
+    inline asmsub rsave() {
+        ; save cpu status flag and all registers A, X, Y.
+        ; see http://6502.org/tutorials/register_preservation.html
+        %asm {{
+            php
+            sta  P8ZP_SCRATCH_REG
+            pha
+            txa
+            pha
+            tya
+            pha
+            lda  P8ZP_SCRATCH_REG
+        }}
+    }
+
+    inline asmsub rrestore() {
+        ; restore all registers and cpu status flag
+        %asm {{
+            pla
+            tay
+            pla
+            tax
+            pla
+            plp
+        }}
+    }
+
+    inline asmsub read_flags() -> ubyte @A {
+        %asm {{
+            php
+            pla
+        }}
+    }
+
+    inline asmsub clear_carry() {
+        %asm {{
+            clc
+        }}
+    }
+
+    inline asmsub set_carry() {
+        %asm {{
+            sec
+        }}
+    }
+
+    inline asmsub clear_irqd() {
+        %asm {{
+            cli
+        }}
+    }
+
+    inline asmsub set_irqd() {
+        %asm {{
+            sei
+        }}
+    }
+
+    inline asmsub exit(ubyte returnvalue @A) {
+        ; -- immediately exit the program with a return code in the A register
+        %asm {{
+            jsr  c64.CLRCHN		; reset i/o channels
+            ldx  prog8_lib.orig_stackpointer
+            txs
+            rts		; return to original caller
+        }}
+    }
+
+    inline asmsub progend() -> uword @AY {
+        %asm {{
+            lda  #<prog8_program_end
+            ldy  #>prog8_program_end
+        }}
+    }
+
+}
+
+cx16 {
+
+    ; the sixteen virtual 16-bit registers that the CX16 has defined in the zeropage
+    ; they are simulated on the C64 as well but their location in memory is different
+    ; (because there's no room for them in the zeropage)
+    ; they are allocated at the bottom of the eval-stack (should be ample space unless
+    ; you're doing insane nesting of expressions...)
+    &uword r0  = $cf00
+    &uword r1  = $cf02
+    &uword r2  = $cf04
+    &uword r3  = $cf06
+    &uword r4  = $cf08
+    &uword r5  = $cf0a
+    &uword r6  = $cf0c
+    &uword r7  = $cf0e
+    &uword r8  = $cf10
+    &uword r9  = $cf12
+    &uword r10 = $cf14
+    &uword r11 = $cf16
+    &uword r12 = $cf18
+    &uword r13 = $cf1a
+    &uword r14 = $cf1c
+    &uword r15 = $cf1e
 
 }

compiler/res/prog8lib/c64/textio.p8

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

compiler/res/prog8lib/conv.p8

@@ -1,30 +1,28 @@
-; Prog8 definitions for number conversions routines.
+; Number conversions routines.
 ;
 ; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8
 
 
 conv {
 
-; ----- number conversions to decimal strings
+; ----- number conversions to decimal strings ----
 
-asmsub  ubyte2decimal  (ubyte value @ A) -> ubyte @ Y, ubyte @ A, ubyte @ X  {
+asmsub  ubyte2decimal  (ubyte value @A) -> ubyte @Y, ubyte @A, ubyte @X  {
 	; ---- A to decimal string in Y/A/X  (100s in Y, 10s in A, 1s in X)
-    %asm {{
-        ldy  #uword2decimal.ASCII_0_OFFSET
-        bne  uword2decimal.hex_try200
-        rts
+	%asm {{
+		ldy  #uword2decimal.ASCII_0_OFFSET
+		bne  uword2decimal.hex_try200
+		rts
 	}}
 }
 
-asmsub  uword2decimal  (uword value @ AY) -> ubyte @Y, ubyte @A, ubyte @X  {
-    ;  ---- convert 16 bit uword in A/Y to decimal
-    ;  output in uword2decimal.decTenThousands, decThousands, decHundreds, decTens, decOnes
-    ;  (these are terminated by a zero byte so they can be easily printed)
-    ;  also returns Y = 100's, A = 10's, X = 1's
+asmsub  uword2decimal  (uword value @AY) -> ubyte @Y, ubyte @A, ubyte @X  {
+	;  ---- convert 16 bit uword in A/Y to decimal
+	;  output in uword2decimal.decTenThousands, decThousands, decHundreds, decTens, decOnes
+	;  (these are terminated by a zero byte so they can be easily printed)
+	;  also returns Y = 100's, A = 10's, X = 1's
 
-    %asm {{
+	%asm {{
 
 ;Convert 16 bit Hex to Decimal (0-65535) Rev 2
 ;By Omegamatrix    Further optimizations by tepples
@@ -193,11 +191,7 @@ decOnes   		.byte  0
     }}
 }
 
-
-; ----- utility functions ----
-
-
-asmsub  byte2decimal  (byte value @ A) -> ubyte @ Y, ubyte @ A, ubyte @ X  {
+asmsub  byte2decimal  (byte value @A) -> ubyte @Y, ubyte @A, ubyte @X  {
 	; ---- A (signed byte) to decimal string in Y/A/X  (100s in Y, 10s in A, 1s in X)
 	;      note: if the number is negative, you have to deal with the '-' yourself!
 	%asm {{
@@ -210,7 +204,7 @@ asmsub  byte2decimal  (byte value @ A) -> ubyte @ Y, ubyte @ A, ubyte @ X  {
 	}}
 }
 
-asmsub  ubyte2hex  (ubyte value @ A) -> ubyte @ A, ubyte @ Y  {
+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
@@ -232,7 +226,7 @@ _hex_digits	.text "0123456789abcdef"	; can probably be reused for other stuff as
 	}}
 }
 
-asmsub  uword2hex  (uword value @ AY) clobbers(A,Y)  {
+asmsub  uword2hex  (uword value @AY) clobbers(A,Y)  {
 	; ---- convert 16 bit uword in A/Y into 4-character hexadecimal string 'uword2hex.output' (0-terminated)
 	%asm {{
 		sta  P8ZP_SCRATCH_REG
@@ -245,49 +239,95 @@ asmsub  uword2hex  (uword value @ AY) clobbers(A,Y)  {
 		sta  output+2
 		sty  output+3
 		rts
-output	.text  "0000", $00      ; 0-terminated output buffer (to make printing easier)
+output		.text  "0000", $00      ; 0-terminated output buffer (to make printing easier)
 	}}
 }
 
 
-asmsub  str2ubyte(str string @ AY) clobbers(Y) -> ubyte @A {
-	; -- returns the unsigned byte value of the string number argument in AY
+; ---- string conversion to numbers -----
+
+asmsub  any2uword(str string @AY) clobbers(Y) -> ubyte @A {
+	; -- parses a string into a 16 bit unsigned number. String may be in decimal, hex or binary format.
+	;    (the latter two require a $ or % prefix to be recognised)
+	;    (any non-digit character will terminate the number string that is parsed)
+	;    returns amount of processed characters in A, and the parsed number will be in cx16.r15.
+	;    if the string was invalid, 0 will be returned in A.
+	%asm {{
+	pha
+	sta  P8ZP_SCRATCH_W1
+	sty  P8ZP_SCRATCH_W1+1
+	ldy  #0
+	lda  (P8ZP_SCRATCH_W1)
+	ldy  P8ZP_SCRATCH_W1+1
+	cmp  #'$'
+	beq  _hex
+	cmp  #'%'
+	beq  _bin
+	pla
+	jsr  str2uword
+	jmp  _result
+_hex	pla
+	jsr  hex2uword
+	jmp  _result
+_bin	pla
+	jsr  bin2uword
+_result
+        pha
+        lda  cx16.r15
+        sta  P8ZP_SCRATCH_B1        ; result value
+        pla
+        sta  cx16.r15
+        sty  cx16.r15+1
+        lda  P8ZP_SCRATCH_B1
+        rts
+	}}
+}
+
+inline asmsub  str2ubyte(str string @AY) clobbers(Y) -> ubyte @A {
+	; -- returns in A the unsigned byte value of the string number argument in AY
 	;    the number may NOT be preceded by a + sign and may NOT contain spaces
 	;    (any non-digit character will terminate the number string that is parsed)
+	;    result in A,  number of characters processed also remains in cx16.r15 if you want to use it!! (0 = error)
 	%asm {{
-    	jmp  str2uword
+		jsr  conv.str2uword
 	}}
 }
 
-asmsub  str2byte(str string @ AY) clobbers(Y) -> ubyte @A {
-	; -- returns the signed byte value of the string number argument in AY
+inline asmsub  str2byte(str string @AY) clobbers(Y) -> ubyte @A {
+	; -- returns in A the signed byte value of the string number argument in AY
 	;    the number may be preceded by a + or - sign but may NOT contain spaces
 	;    (any non-digit character will terminate the number string that is parsed)
+	;    result in A,  number of characters processed also remains in cx16.r15 if you want to use it!! (0 = error)
 	%asm {{
-    	jmp  str2word
+		jsr  conv.str2word
 	}}
 }
 
-asmsub  str2uword(str string @ AY) -> uword @ AY {
+asmsub  str2uword(str string @AY) -> uword @AY {
 	; -- returns the unsigned word value of the string number argument in AY
 	;    the number may NOT be preceded by a + sign and may NOT contain spaces
 	;    (any non-digit character will terminate the number string that is parsed)
+	;    result in AY,  number of characters processed also remains in cx16.r15 if you want to use it!! (0 = error)
 	%asm {{
-_result = P8ZP_SCRATCH_W2
-		sta  _mod+1
-		sty  _mod+2
+_result = P8ZP_SCRATCH_W1
+        	sta  P8ZP_SCRATCH_W2
+        	sty  P8ZP_SCRATCH_W2+1
 		ldy  #0
 		sty  _result
 		sty  _result+1
-_mod		lda  $ffff,y		; modified
+		sty  cx16.r15+1
+_loop
+		lda  (P8ZP_SCRATCH_W2),y
 		sec
 		sbc  #48
-		bpl  +
-_done		; return result
+		bpl  _digit
+_done
+		sty  cx16.r15
 		lda  _result
 		ldy  _result+1
 		rts
-+		cmp  #10
+_digit
+		cmp  #10
 		bcs  _done
 		; add digit to result
 		pha
@@ -299,7 +339,7 @@ _done		; return result
 		bcc  +
 		inc  _result+1
 +		iny
-		bne  _mod
+		bne  _loop
 		; never reached
 
 _result_times_10     ; (W*4 + W)*2
@@ -322,19 +362,21 @@ _result_times_10     ; (W*4 + W)*2
 	}}
 }
 
-asmsub  str2word(str string @ AY) -> word @ AY {
+asmsub  str2word(str string @AY) -> word @AY {
 	; -- returns the signed word value of the string number argument in AY
 	;    the number may be preceded by a + or - sign but may NOT contain spaces
 	;    (any non-digit character will terminate the number string that is parsed)
+	;    result in AY,  number of characters processed also remains in cx16.r15 if you want to use it!! (0 = error)
 	%asm {{
-_result = P8ZP_SCRATCH_W2
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
+_result = P8ZP_SCRATCH_W1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
 		ldy  #0
 		sty  _result
 		sty  _result+1
 		sty  _negative
-		lda  (P8ZP_SCRATCH_W1),y
+		sty  cx16.r15+1
+		lda  (P8ZP_SCRATCH_W2),y
 		cmp  #'+'
 		bne  +
 		iny
@@ -342,11 +384,12 @@ _result = P8ZP_SCRATCH_W2
 		bne  _parse
 		inc  _negative
 		iny
-_parse		lda  (P8ZP_SCRATCH_W1),y
+_parse		lda  (P8ZP_SCRATCH_W2),y
 		sec
 		sbc  #48
 		bpl  _digit
-_done		; return result
+_done
+		sty  cx16.r15
 		lda  _negative
 		beq  +
 		sec
@@ -359,7 +402,8 @@ _done		; return result
 +		lda  _result
 		ldy  _result+1
 		rts
-_digit		cmp  #10
+_digit
+		cmp  #10
 		bcs  _done
 		; add digit to result
 		pha
@@ -377,77 +421,103 @@ _negative	.byte  0
 	}}
 }
 
-asmsub  hex2uword(str string @ AY) -> uword @AY {
-    ; -- hexadecimal string with or without '$' to uword.
-    ;    string may be in petscii or c64-screencode encoding.
-    %asm {{
-        sta  P8ZP_SCRATCH_W2
-        sty  P8ZP_SCRATCH_W2+1
-        ldy  #0
-        sty  P8ZP_SCRATCH_W1
-        sty  P8ZP_SCRATCH_W1+1
-_loop       ldy  #0
-        sty  P8ZP_SCRATCH_B1
-        lda  (P8ZP_SCRATCH_W2),y
-        beq  _stop
-        cmp  #'$'
-        beq  _skip
-        cmp  #7
-        bcc  _add_nine
-        cmp  #'9'
-        beq  _calc
-        bcs  _add_nine
-_calc       asl  P8ZP_SCRATCH_W1
-        rol  P8ZP_SCRATCH_W1+1
-        asl  P8ZP_SCRATCH_W1
-        rol  P8ZP_SCRATCH_W1+1
-        asl  P8ZP_SCRATCH_W1
-        rol  P8ZP_SCRATCH_W1+1
-        asl  P8ZP_SCRATCH_W1
-        rol  P8ZP_SCRATCH_W1+1
-        and  #$0f
-        clc
-        adc  P8ZP_SCRATCH_B1
-        ora  P8ZP_SCRATCH_W1
-        sta  P8ZP_SCRATCH_W1
-_skip       inc  P8ZP_SCRATCH_W2
-        bne  _loop
-        inc  P8ZP_SCRATCH_W2+1
-        bne  _loop
-_stop       lda  P8ZP_SCRATCH_W1
-        ldy  P8ZP_SCRATCH_W1+1
-        rts
-_add_nine   ldy  #9
-        sty  P8ZP_SCRATCH_B1
-        bne  _calc
-    }}
+asmsub  hex2uword(str string @AY) -> uword @AY {
+	; -- hexadecimal string (with or without '$') to uword.
+	;    string may be in petscii or c64-screencode encoding.
+	;    stops parsing at the first character that's not a hex digit (except leading $)
+	;    result in AY,  number of characters processed also remains in cx16.r15 if you want to use it!! (0 = error)
+	%asm {{
+	sta  P8ZP_SCRATCH_W2
+	sty  P8ZP_SCRATCH_W2+1
+	ldy  #0
+	sty  P8ZP_SCRATCH_W1
+	sty  P8ZP_SCRATCH_W1+1
+	sty  cx16.r15+1
+	lda  (P8ZP_SCRATCH_W2),y
+	beq  _stop
+	cmp  #'$'
+	bne  _loop
+	iny
+_loop
+	lda  #0
+	sta  P8ZP_SCRATCH_B1
+	lda  (P8ZP_SCRATCH_W2),y
+	beq  _stop
+	cmp  #7                 ; screencode letters A-F are 1-6
+	bcc  _add_letter
+	cmp  #'g'
+	bcs  _stop
+	cmp  #'a'
+	bcs  _add_letter
+	cmp  #'0'
+	bcc  _stop
+	cmp  #'9'+1
+	bcs  _stop
+_calc
+	asl  P8ZP_SCRATCH_W1
+	rol  P8ZP_SCRATCH_W1+1
+	asl  P8ZP_SCRATCH_W1
+	rol  P8ZP_SCRATCH_W1+1
+	asl  P8ZP_SCRATCH_W1
+	rol  P8ZP_SCRATCH_W1+1
+	asl  P8ZP_SCRATCH_W1
+	rol  P8ZP_SCRATCH_W1+1
+	and  #$0f
+	clc
+	adc  P8ZP_SCRATCH_B1
+	ora  P8ZP_SCRATCH_W1
+	sta  P8ZP_SCRATCH_W1
+	iny
+	bne  _loop
+_stop
+	sty  cx16.r15
+	lda  P8ZP_SCRATCH_W1
+	ldy  P8ZP_SCRATCH_W1+1
+	rts
+_add_letter
+	pha
+	lda  #9
+	sta  P8ZP_SCRATCH_B1
+	pla
+	jmp  _calc
+	}}
 }
 
-asmsub  bin2uword(str string @ AY) -> uword @AY {
-    ; -- binary string with or without '%' to uword.
-    %asm {{
-        sta  P8ZP_SCRATCH_W2
-        sty  P8ZP_SCRATCH_W2+1
-        ldy  #0
-        sty  P8ZP_SCRATCH_W1
-        sty  P8ZP_SCRATCH_W1+1
-_loop       lda  (P8ZP_SCRATCH_W2),y
-        beq  _stop
-        cmp  #'%'
-        beq  +
-        asl  P8ZP_SCRATCH_W1
-        rol  P8ZP_SCRATCH_W1+1
-        and  #1
-        ora  P8ZP_SCRATCH_W1
-        sta  P8ZP_SCRATCH_W1
-+           inc  P8ZP_SCRATCH_W2
-        bne  _loop
-        inc  P8ZP_SCRATCH_W2+1
-        bne  _loop
-_stop       lda  P8ZP_SCRATCH_W1
-        ldy  P8ZP_SCRATCH_W1+1
-        rts
-    }}
+asmsub  bin2uword(str string @AY) -> uword @AY {
+	; -- binary string (with or without '%') to uword.
+	;    stops parsing at the first character that's not a 0 or 1. (except leading %)
+	;    result in AY,  number of characters processed also remains in cx16.r15 if you want to use it!! (0 = error)
+	%asm {{
+	sta  P8ZP_SCRATCH_W2
+	sty  P8ZP_SCRATCH_W2+1
+	ldy  #0
+	sty  P8ZP_SCRATCH_W1
+	sty  P8ZP_SCRATCH_W1+1
+	sty  cx16.r15+1
+	lda  (P8ZP_SCRATCH_W2),y
+	beq  _stop
+	cmp  #'%'
+	bne  _loop
+	iny
+_loop
+	lda  (P8ZP_SCRATCH_W2),y
+	cmp  #'0'
+	bcc  _stop
+	cmp  #'2'
+	bcs  _stop
+_first  asl  P8ZP_SCRATCH_W1
+	rol  P8ZP_SCRATCH_W1+1
+	and  #1
+	ora  P8ZP_SCRATCH_W1
+	sta  P8ZP_SCRATCH_W1
+	iny
+	bne  _loop
+_stop
+	sty  cx16.r15
+	lda  P8ZP_SCRATCH_W1
+	ldy  P8ZP_SCRATCH_W1+1
+	rts
+	}}
 }
 
 }

compiler/res/prog8lib/cx16/floats.p8

@@ -64,6 +64,7 @@ romsub $fe7e = FINLOG(byte value @A) clobbers (A, X, Y)           ; fac1 += sign
 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
+; note: there is no FPWR() on the Cx16
 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
@@ -98,9 +99,9 @@ _flt65536    .byte 145,0,0,0,0       ; 65536.0
 asmsub  GIVAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- signed 16 bit word in A/Y (lo/hi) to float in fac1
 	%asm {{
-		sta  P8ZP_SCRATCH_W2
+		sta  P8ZP_SCRATCH_B1
 		tya
-		ldy  P8ZP_SCRATCH_W2
+		ldy  P8ZP_SCRATCH_B1
 		jmp  GIVAYF		; this uses the inverse order, Y/A
 	}}
 }
@@ -109,9 +110,9 @@ 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
+		sta  P8ZP_SCRATCH_B1
 		tya
-		ldy  P8ZP_SCRATCH_REG
+		ldy  P8ZP_SCRATCH_B1
 		rts
 	}}
 }

compiler/res/prog8lib/cx16/gfx2.p8

@@ -0,0 +1,756 @@
+%target cx16
+
+; Bitmap pixel graphics module for the CommanderX16
+; Custom routines to use the full-screen 640x480 and 320x240 screen modes.
+; This only works on the Cx16. No text layer is currently shown, text can be drawn as part of the bitmap itself.
+; Note: for compatible graphics code that words on C64 too, use the "graphics" module instead.
+; Note: there is no color palette manipulation here, you have to do that yourself or use the "palette" module.
+
+; TODO can we make a FB vector table and emulation routines for the Cx16s' GRAPH_init() call? to replace the builtin 320x200 fb driver?
+
+gfx2 {
+
+    ; read-only control variables:
+    ubyte active_mode = 255
+    uword width = 0
+    uword height = 0
+    ubyte bpp = 0
+    ubyte monochrome_dont_stipple_flag = false            ; set to false to enable stippling mode in monochrome displaymodes
+
+    sub screen_mode(ubyte mode) {
+        ; mode 0 = bitmap 320 x 240 x 1c monochrome
+        ; mode 1 = bitmap 320 x 240 x 256c
+        ; mode 128 = bitmap 640 x 480 x 1c monochrome
+        ; ...other modes?
+
+        ; copy the lower-case charset to the upper part of the vram, so we can use it later to plot text
+
+        when mode {
+            0 -> {
+                ; 320 x 240 x 1c
+                cx16.VERA_DC_VIDEO = (cx16.VERA_DC_VIDEO & %11001111) | %00100000      ; enable only layer 1
+                cx16.VERA_DC_HSCALE = 64
+                cx16.VERA_DC_VSCALE = 64
+                cx16.VERA_L1_CONFIG = %00000100
+                cx16.VERA_L1_MAPBASE = 0
+                cx16.VERA_L1_TILEBASE = 0
+                width = 320
+                height = 240
+                bpp = 1
+            }
+            1 -> {
+                ; 320 x 240 x 256c
+                cx16.VERA_DC_VIDEO = (cx16.VERA_DC_VIDEO & %11001111) | %00100000      ; enable only layer 1
+                cx16.VERA_DC_HSCALE = 64
+                cx16.VERA_DC_VSCALE = 64
+                cx16.VERA_L1_CONFIG = %00000111
+                cx16.VERA_L1_MAPBASE = 0
+                cx16.VERA_L1_TILEBASE = 0
+                width = 320
+                height = 240
+                bpp = 8
+            }
+            128 -> {
+                ; 640 x 480 x 1c
+                cx16.VERA_DC_VIDEO = (cx16.VERA_DC_VIDEO & %11001111) | %00100000      ; enable only layer 1
+                cx16.VERA_DC_HSCALE = 128
+                cx16.VERA_DC_VSCALE = 128
+                cx16.VERA_L1_CONFIG = %00000100
+                cx16.VERA_L1_MAPBASE = 0
+                cx16.VERA_L1_TILEBASE = %00000001
+                width = 640
+                height = 480
+                bpp = 1
+            }
+            255 -> {
+                ; back to default text mode and colors
+                cx16.VERA_CTRL = %10000000      ; reset VERA and palette
+                c64.CINT()      ; back to text mode
+                width = 0
+                height = 0
+                bpp = 0
+            }
+        }
+
+        active_mode = mode
+        if bpp
+            clear_screen()
+    }
+
+    sub clear_screen() {
+        monochrome_stipple(false)
+        position(0, 0)
+        when active_mode {
+            0 -> {
+                ; 320 x 240 x 1c
+                repeat 240/2/8
+                    cs_innerloop640()
+            }
+            1 -> {
+                ; 320 x 240 x 256c
+                repeat 240/2
+                    cs_innerloop640()
+            }
+            128 -> {
+                ; 640 x 480 x 1c
+                repeat 480/8
+                    cs_innerloop640()
+            }
+        }
+        position(0, 0)
+    }
+
+    sub monochrome_stipple(ubyte enable) {
+        monochrome_dont_stipple_flag = not enable
+    }
+
+    sub rect(uword x, uword y, uword width, uword height, ubyte color) {
+        if width==0 or height==0
+            return
+        horizontal_line(x, y, width, color)
+        if height==1
+            return
+        horizontal_line(x, y+height-1, width, color)
+        vertical_line(x, y+1, height-2, color)
+        if width==1
+            return
+        vertical_line(x+width-1, y+1, height-2, color)
+    }
+
+    sub fillrect(uword x, uword y, uword width, uword height, ubyte color) {
+        if width==0
+            return
+        repeat height {
+            horizontal_line(x, y, width, color)
+            y++
+        }
+    }
+
+    sub horizontal_line(uword x, uword y, uword length, ubyte color) {
+        if length==0
+            return
+        when active_mode {
+            1 -> {
+                ; 8bpp mode
+                position(x, y)
+                %asm {{
+                    lda  color
+                    phx
+                    ldx  length+1
+                    beq  +
+                    ldy  #0
+-                   sta  cx16.VERA_DATA0
+                    iny
+                    bne  -
+                    dex
+                    bne  -
++                   ldy  length     ; remaining
+                    beq  +
+-                   sta  cx16.VERA_DATA0
+                    dey
+                    bne  -
++                   plx
+                }}
+            }
+            0, 128 -> {
+                ; 1 bpp mode
+                ubyte separate_pixels = (8-lsb(x)) & 7
+                if separate_pixels as uword > length
+                    separate_pixels = lsb(length)
+                repeat separate_pixels {
+                    ; this could be  optimized by setting this byte in 1 go but probably not worth it due to code size
+                    plot(x, y, color)
+                    x++
+                }
+                length -= separate_pixels
+                if length {
+                    position(x, y)
+                    separate_pixels = lsb(length) & 7
+                    x += length & $fff8
+                    %asm {{
+                        lsr  length+1
+                        ror  length
+                        lsr  length+1
+                        ror  length
+                        lsr  length+1
+                        ror  length
+                        lda  color
+                        bne  +
+                        ldy  #0     ; black
+                        bra  _loop
++                       lda  monochrome_dont_stipple_flag
+                        beq  _stipple
+                        ldy  #255       ; don't stipple
+                        bra  _loop
+_stipple                lda  y
+                        and  #1         ; determine stipple pattern to use
+                        bne  +
+                        ldy  #%01010101
+                        bra  _loop
++                       ldy  #%10101010
+_loop                   lda  length
+                        ora  length+1
+                        beq  _done
+                        sty  cx16.VERA_DATA0
+                        lda  length
+                        bne  +
+                        dec  length+1
++                       dec  length
+                        bra  _loop
+_done
+                    }}
+                    repeat separate_pixels {
+                        ; this could be  optimized by setting this byte in 1 go but probably not worth it due to code size
+                        plot(x, y, color)
+                        x++
+                    }
+                }
+                cx16.VERA_ADDR_H = (cx16.VERA_ADDR_H & %00000111)   ; vera auto-increment off again
+            }
+        }
+    }
+
+    sub vertical_line(uword x, uword y, uword height, ubyte color) {
+        position(x,y)
+        if active_mode==1 {
+            ; set vera auto-increment to 320 pixel increment (=next line)
+            cx16.VERA_ADDR_H = (cx16.VERA_ADDR_H & %00000111) | (14<<4)
+            %asm {{
+                ldy  height
+                beq  +
+                lda  color
+-               sta  cx16.VERA_DATA0
+                dey
+                bne  -
++
+            }}
+            return
+        }
+
+        ; note for the 1 bpp modes we can't use vera's auto increment mode because we have to 'or' the pixel data in place.
+        cx16.VERA_ADDR_H = (cx16.VERA_ADDR_H & %00000111)   ; no auto advance
+        cx16.r15 = gfx2.plot.bits[x as ubyte & 7]           ; bitmask
+        if active_mode>=128
+            cx16.r14 = 640/8
+        else
+            cx16.r14 = 320/8
+        if color {
+            if monochrome_dont_stipple_flag {
+                repeat height {
+                    %asm {{
+                        lda  cx16.VERA_DATA0
+                        ora  cx16.r15
+                        sta  cx16.VERA_DATA0
+                        lda  cx16.VERA_ADDR_L
+                        clc
+                        adc  cx16.r14                 ; advance vera ptr to go to the next line
+                        sta  cx16.VERA_ADDR_L
+                        lda  cx16.VERA_ADDR_M
+                        adc  #0
+                        sta  cx16.VERA_ADDR_M
+                        ; lda  cx16.VERA_ADDR_H     ; the bitmap size is small enough to not have to deal with the _H part.
+                        ; adc  #0
+                        ; sta  cx16.VERA_ADDR_H
+                    }}
+                }
+            } else {
+                ; stippling.
+                height = (height+1)/2
+                %asm {{
+                    lda x
+                    eor y
+                    and #1
+                    bne +
+                    lda  cx16.VERA_ADDR_L
+                    clc
+                    adc  cx16.r14                ; advance vera ptr to go to the next line for correct stipple pattern
+                    sta  cx16.VERA_ADDR_L
+                    lda  cx16.VERA_ADDR_M
+                    adc  #0
+                    sta  cx16.VERA_ADDR_M
++
+                    asl  cx16.r14
+                    ldy  height
+                    beq  +
+-                   lda  cx16.VERA_DATA0
+                    ora  cx16.r15
+                    sta  cx16.VERA_DATA0
+                    lda  cx16.VERA_ADDR_L
+                    clc
+                    adc  cx16.r14               ; advance vera data ptr to go to the next-next line
+                    sta  cx16.VERA_ADDR_L
+                    lda  cx16.VERA_ADDR_M
+                    adc  #0
+                    sta  cx16.VERA_ADDR_M
+                    ; lda  cx16.VERA_ADDR_H      ; the bitmap size is small enough to not have to deal with the _H part.
+                    ; adc  #0
+                    ; sta  cx16.VERA_ADDR_H
+                    dey
+                    bne  -
++
+                }}
+            }
+        } else {
+            cx16.r15 = ~cx16.r15
+            repeat height {
+                %asm {{
+                    lda  cx16.VERA_DATA0
+                    and  cx16.r15
+                    sta  cx16.VERA_DATA0
+                    lda  cx16.VERA_ADDR_L
+                    clc
+                    adc  cx16.r14             ; advance vera data ptr to go to the next line
+                    sta  cx16.VERA_ADDR_L
+                    lda  cx16.VERA_ADDR_M
+                    adc  #0
+                    sta  cx16.VERA_ADDR_M
+                    ; lda  cx16.VERA_ADDR_H      ; the bitmap size is small enough to not have to deal with the _H part.
+                    ; adc  #0
+                    ; sta  cx16.VERA_ADDR_H
+                }}
+            }
+        }
+    }
+
+    sub line(uword @zp x1, uword @zp y1, uword @zp x2, uword @zp y2, ubyte color) {
+        ; Bresenham algorithm.
+        ; This code special-cases various quadrant loops to allow simple ++ and -- operations.
+        if y1>y2 {
+            ; make sure dy is always positive to have only 4 instead of 8 special cases
+            swap(x1, x2)
+            swap(y1, y2)
+        }
+        word @zp dx = x2-x1 as word
+        word @zp dy = y2-y1 as word
+
+        if dx==0 {
+            vertical_line(x1, y1, abs(dy)+1 as uword, color)
+            return
+        }
+        if dy==0 {
+            if x1>x2
+                x1=x2
+            horizontal_line(x1, y1, abs(dx)+1 as uword, color)
+            return
+        }
+
+        ; TODO rewrite the rest in optimized assembly (or reuse GRAPH_draw_line if we can get the FB replacement vector layer working)
+        word @zp d = 0
+        ubyte positive_ix = true
+        if dx < 0 {
+            dx = -dx
+            positive_ix = false
+        }
+        dx *= 2
+        dy *= 2
+        cx16.r14 = x1       ; internal plot X
+
+        if dx >= dy {
+            if positive_ix {
+                repeat {
+                    plot(cx16.r14, y1, color)
+                    if cx16.r14==x2
+                        return
+                    cx16.r14++
+                    d += dy
+                    if d > dx {
+                        y1++
+                        d -= dx
+                    }
+                }
+            } else {
+                repeat {
+                    plot(cx16.r14, y1, color)
+                    if cx16.r14==x2
+                        return
+                    cx16.r14--
+                    d += dy
+                    if d > dx {
+                        y1++
+                        d -= dx
+                    }
+                }
+            }
+        }
+        else {
+            if positive_ix {
+                repeat {
+                    plot(cx16.r14, y1, color)
+                    if y1 == y2
+                        return
+                    y1++
+                    d += dx
+                    if d > dy {
+                        cx16.r14++
+                        d -= dy
+                    }
+                }
+            } else {
+                repeat {
+                    plot(cx16.r14, y1, color)
+                    if y1 == y2
+                        return
+                    y1++
+                    d += dx
+                    if d > dy {
+                        cx16.r14--
+                        d -= dy
+                    }
+                }
+            }
+        }
+    }
+
+    sub circle(uword @zp xcenter, uword @zp ycenter, ubyte radius, ubyte color) {
+        ; Midpoint algorithm.
+        if radius==0
+            return
+
+        ubyte @zp xx = radius
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-xx
+        ; R14 = internal plot X
+        ; R15 = internal plot Y
+
+        while xx>=yy {
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter + yy
+            plot(cx16.r14, cx16.r15, color)
+            cx16.r14 = xcenter - xx
+            plot(cx16.r14, cx16.r15, color)
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter - yy
+            plot(cx16.r14, cx16.r15, color)
+            cx16.r14 = xcenter - xx
+            plot(cx16.r14, cx16.r15, color)
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter + xx
+            plot(cx16.r14, cx16.r15, color)
+            cx16.r14 = xcenter - yy
+            plot(cx16.r14, cx16.r15, color)
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter - xx
+            plot(cx16.r14, cx16.r15, color)
+            cx16.r14 = xcenter - yy
+            plot(cx16.r14, cx16.r15, color)
+
+            yy++
+            if decisionOver2<=0
+                decisionOver2 += (yy as word)*2+1
+            else {
+                xx--
+                decisionOver2 += (yy as word -xx)*2+1
+            }
+        }
+    }
+
+    sub disc(uword @zp xcenter, uword @zp ycenter, ubyte @zp radius, ubyte color) {
+        ; Midpoint algorithm, filled
+        if radius==0
+            return
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-radius
+
+        while radius>=yy {
+            horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, color)
+            horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, color)
+            horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, color)
+            horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, color)
+            yy++
+            if decisionOver2<=0
+                decisionOver2 += (yy as word)*2+1
+            else {
+                radius--
+                decisionOver2 += (yy as word -radius)*2+1
+            }
+        }
+    }
+
+    sub plot(uword @zp x, uword y, ubyte color) {
+        ubyte[8] bits = [128, 64, 32, 16, 8, 4, 2, 1]
+        uword addr
+        ubyte value
+
+        when active_mode {
+            0 -> {
+                %asm {{
+                    lda  x
+                    eor  y
+                    ora  monochrome_dont_stipple_flag
+                    and  #1
+                }}
+                if_nz {
+                    addr = x/8 + y*(320/8)
+                    value = bits[lsb(x)&7]
+                    if color
+                        cx16.vpoke_or(0, addr, value)
+                    else {
+                        value = ~value
+                        cx16.vpoke_and(0, addr, value)
+                    }
+                }
+            }
+            128 -> {
+                %asm {{
+                    lda  x
+                    eor  y
+                    ora  monochrome_dont_stipple_flag
+                    and  #1
+                }}
+                if_nz {
+                    addr = x/8 + y*(640/8)
+                    value = bits[lsb(x)&7]
+                    if color
+                        cx16.vpoke_or(0, addr, value)
+                    else {
+                        value = ~value
+                        cx16.vpoke_and(0, addr, value)
+                    }
+                }
+            }
+            1 -> {
+                void addr_mul_320_add_24(y, x)      ; 24 bits result is in r0 and r1L
+                value = lsb(cx16.r1)
+                cx16.vpoke(value, cx16.r0, color)
+                ; activate vera auto-increment mode so next_pixel() can be used after this
+                cx16.VERA_ADDR_H = (cx16.VERA_ADDR_H & %00000111) | %00010000
+                color = cx16.VERA_DATA0
+            }
+        }
+    }
+
+    sub position(uword @zp x, uword y) {
+        when active_mode {
+            0 -> {
+                cx16.r0 = y*(320/8) + x/8
+                cx16.vaddr(0, cx16.r0, 0, 1)
+            }
+            128 -> {
+                cx16.r0 = y*(640/8) + x/8
+                cx16.vaddr(0, cx16.r0, 0, 1)
+            }
+            1 -> {
+                void addr_mul_320_add_24(y, x)      ; 24 bits result is in r0 and r1L
+                ubyte bank = lsb(cx16.r1)
+                cx16.vaddr(bank, cx16.r0, 0, 1)
+            }
+        }
+    }
+
+    inline asmsub next_pixel(ubyte color @A) {
+        ; -- sets the next pixel byte to the graphics chip.
+        ;    for 8 bpp screens this will plot 1 pixel.
+        ;    for 1 bpp screens it will plot 8 pixels at once (color = bit pattern).
+        %asm {{
+            sta  cx16.VERA_DATA0
+        }}
+    }
+
+    asmsub next_pixels(uword pixels @AY, uword amount @R0) clobbers(A, Y)  {
+        ; -- sets the next bunch of pixels from a prepared array of bytes.
+        ;    for 8 bpp screens this will plot 1 pixel per byte.
+        ;    for 1 bpp screens it will plot 8 pixels at once (colors are the bit patterns per byte).
+        %asm {{
+            phx
+            sta  P8ZP_SCRATCH_W1
+            sty  P8ZP_SCRATCH_W1+1
+            ldx  cx16.r0+1
+            beq  +
+            ldy  #0
+-           lda  (P8ZP_SCRATCH_W1),y
+            sta  cx16.VERA_DATA0
+            iny
+            bne  -
+            inc  P8ZP_SCRATCH_W1+1       ; next page of 256 pixels
+            dex
+            bne  -
+
++           ldx  cx16.r0           ; remaining pixels
+            beq  +
+            ldy  #0
+-           lda  (P8ZP_SCRATCH_W1),y
+            sta  cx16.VERA_DATA0
+            iny
+            dex
+            bne  -
++           plx
+        }}
+    }
+
+    asmsub set_8_pixels_from_bits(ubyte bits @R0, ubyte oncolor @A, ubyte offcolor @Y) {
+        ; this is only useful in 256 color mode where one pixel equals one byte value.
+        %asm {{
+            phx
+            ldx  #8
+-           asl  cx16.r0
+            bcc  +
+            sta  cx16.VERA_DATA0
+            bra  ++
++           sty  cx16.VERA_DATA0
++           dex
+            bne  -
+            plx
+            rts
+        }}
+    }
+
+    const ubyte charset_orig_bank = $0
+    const uword charset_orig_addr = $f800        ; in bank 0, so $0f800
+    const ubyte charset_bank = $1
+    const uword charset_addr = $f000       ; in bank 1, so $1f000
+
+    sub text_charset(ubyte charset) {
+        ; -- make a copy of the selected character set to use with text()
+        ;    the charset number is the same as for the cx16.screen_set_charset() ROM function.
+        ;    1 = ISO charset, 2 = PETSCII uppercase+graphs, 3= PETSCII uppercase+lowercase.
+        cx16.screen_set_charset(charset, 0)
+        cx16.vaddr(charset_orig_bank, charset_orig_addr, 0, 1)
+        cx16.vaddr(charset_bank, charset_addr, 1, 1)
+        repeat 256*8 {
+            cx16.VERA_DATA1 = cx16.VERA_DATA0
+        }
+    }
+
+    sub text(uword @zp x, uword y, ubyte color, uword sctextptr) {
+        ; -- Write some text at the given pixel position. The text string must be in screencode encoding (not petscii!).
+        ;    You must also have called text_charset() first to select and prepare the character set to use.
+        ;    NOTE: in monochrome (1bpp) screen modes, x position is currently constrained to mulitples of 8 !
+        uword chardataptr
+        when active_mode {
+            0, 128 -> {
+                ; 1-bitplane modes
+                cx16.r2 = 40
+                if active_mode>=128
+                    cx16.r2 = 80
+                while @(sctextptr) {
+                    chardataptr = charset_addr + (@(sctextptr) as uword)*8
+                    cx16.vaddr(charset_bank, chardataptr, 1, 1)
+                    position(x,y)
+                    %asm {{
+                        lda  cx16.VERA_ADDR_H
+                        and  #%111              ; don't auto-increment, we have to do that manually because of the ora
+                        sta  cx16.VERA_ADDR_H
+                        lda  color
+                        sta  P8ZP_SCRATCH_B1
+                        ldy  #8
+-                       lda  P8ZP_SCRATCH_B1
+                        bne  +                  ; white color, plot normally
+                        lda  cx16.VERA_DATA1
+                        eor  #255               ; black color, keep only the other pixels
+                        and  cx16.VERA_DATA0
+                        bra  ++
++                       lda  cx16.VERA_DATA0
+                        ora  cx16.VERA_DATA1
++                       sta  cx16.VERA_DATA0
+                        lda  cx16.VERA_ADDR_L
+                        clc
+                        adc  cx16.r2
+                        sta  cx16.VERA_ADDR_L
+                        bcc  +
+                        inc  cx16.VERA_ADDR_M
++                       lda  x
+                        clc
+                        adc  #1
+                        sta  x
+                        bcc  +
+                        inc  x+1
++                       dey
+                        bne  -
+                    }}
+                    sctextptr++
+                }
+            }
+            1 -> {
+                ; 320 x 240 x 256c
+                while @(sctextptr) {
+                    chardataptr = charset_addr + (@(sctextptr) as uword)*8
+                    cx16.vaddr(charset_bank, chardataptr, 1, 1)
+                    repeat 8 {
+                        position(x,y)
+                        y++
+                        %asm {{
+                            phx
+                            ldx  #1
+                            lda  cx16.VERA_DATA1
+                            sta  P8ZP_SCRATCH_B1
+                            ldy  #8
+-                           asl  P8ZP_SCRATCH_B1
+                            bcc  +
+                            stx  cx16.VERA_DATA0    ; write a pixel
+                            bra  ++
++                           lda  cx16.VERA_DATA0    ; don't write a pixel, but do advance to the next address
++                           dey
+                            bne  -
+                            plx
+                        }}
+                    }
+                    x+=8
+                    y-=8
+                    sctextptr++
+                }
+            }
+        }
+    }
+
+    asmsub cs_innerloop640() clobbers(Y) {
+        %asm {{
+            ldy  #80
+-           stz  cx16.VERA_DATA0
+            stz  cx16.VERA_DATA0
+            stz  cx16.VERA_DATA0
+            stz  cx16.VERA_DATA0
+            stz  cx16.VERA_DATA0
+            stz  cx16.VERA_DATA0
+            stz  cx16.VERA_DATA0
+            stz  cx16.VERA_DATA0
+            dey
+            bne  -
+            rts
+        }}
+    }
+
+    asmsub addr_mul_320_add_24(uword address @R0, uword value @AY) clobbers(A) -> uword @R0, ubyte @R1  {
+            %asm {{
+                sta  P8ZP_SCRATCH_W1
+                sty  P8ZP_SCRATCH_W1+1
+                lda  cx16.r0
+                sta  P8ZP_SCRATCH_B1
+                lda  cx16.r0+1
+                sta  cx16.r1
+                sta  P8ZP_SCRATCH_REG
+                lda  cx16.r0
+                asl  a
+                rol  P8ZP_SCRATCH_REG
+                asl  a
+                rol  P8ZP_SCRATCH_REG
+                asl  a
+                rol  P8ZP_SCRATCH_REG
+                asl  a
+                rol  P8ZP_SCRATCH_REG
+                asl  a
+                rol  P8ZP_SCRATCH_REG
+                asl  a
+                rol  P8ZP_SCRATCH_REG
+                sta  cx16.r0
+                lda  P8ZP_SCRATCH_B1
+                clc
+                adc  P8ZP_SCRATCH_REG
+                sta  cx16.r0+1
+                bcc  +
+                inc  cx16.r1
++		        ; now add the value to this 24-bits number
+                lda  cx16.r0
+                clc
+                adc  P8ZP_SCRATCH_W1
+                sta  cx16.r0
+                lda  cx16.r0+1
+                adc  P8ZP_SCRATCH_W1+1
+                sta  cx16.r0+1
+                bcc  +
+                inc  cx16.r1
++               lda  cx16.r1
+                rts
+            }}
+        }
+
+}

compiler/res/prog8lib/cx16/graphics.p8

@@ -2,9 +2,12 @@
 %import syslib
 %import textio
 
-; bitmap pixel graphics module for the CommanderX16
+; Bitmap pixel graphics module for the CommanderX16
 ; wraps the graphics functions that are in ROM.
-; only black/white monchrome 320x200 for now.
+; only black/white monchrome 320x200 for now. (i.e. truncated at the bottom)
+; For full-screen 640x480 or 320x240 graphics, use the "gfx2" module instead. (but that is Cx16-specific)
+; Note: there is no color palette manipulation here, you have to do that yourself or use the "palette" module.
+
 
 graphics {
     const uword WIDTH = 320
@@ -13,15 +16,14 @@ graphics {
     sub enable_bitmap_mode() {
         ; enable bitmap screen, erase it and set colors to black/white.
         void cx16.screen_set_mode($80)
-        cx16.r0 = 0
-        cx16.GRAPH_init()
+        cx16.GRAPH_init(0)
         clear_screen(1, 0)
     }
 
     sub disable_bitmap_mode() {
         ; enables text mode, erase the text screen, color white
         void cx16.screen_set_mode(2)
-        txt.fill_screen(' ', 1)     ; TODO doesn't seem to fully clear the text screen after returning from gfx mode
+        txt.fill_screen(' ', 1)     ; doesn't seem to fully clear the text screen after returning from gfx mode
     }
 
 
@@ -31,11 +33,25 @@ graphics {
     }
 
     sub line(uword @zp x1, ubyte @zp y1, uword @zp x2, ubyte @zp y2) {
-        cx16.r0 = x1
-        cx16.r1 = y1
-        cx16.r2 = x2
-        cx16.r3 = y2
-        cx16.GRAPH_draw_line()
+        cx16.GRAPH_draw_line(x1, y1, x2, y2)
+    }
+
+    sub fillrect(uword x, uword y, uword width, uword height) {
+        cx16.GRAPH_draw_rect(x, y, width, height, 0, 1)
+    }
+
+    sub rect(uword x, uword y, uword width, uword height) {
+        cx16.GRAPH_draw_rect(x, y, width, height, 0, 0)
+    }
+
+    sub horizontal_line(uword x, uword y, uword length) {
+        if length
+            cx16.GRAPH_draw_line(x, y, x+length-1, y)
+    }
+
+    sub vertical_line(uword x, uword y, uword height) {
+        if height
+            cx16.GRAPH_draw_line(x, y, x, y+height-1)
     }
 
     sub circle(uword xcenter, ubyte ycenter, ubyte radius) {
@@ -43,122 +59,80 @@ graphics {
         ;cx16.r1 = ycenter - radius/2
         ;cx16.r2 = radius*2
         ;cx16.r3 = radius*2
-        ;cx16.GRAPH_draw_oval(false)          ; TODO  currently is not implemented on cx16, does a BRK
+        ;cx16.GRAPH_draw_oval(false)          ; currently this call is not implemented on cx16, does a BRK
 
         ; Midpoint algorithm
+        if radius==0
+            return
         ubyte @zp xx = radius
         ubyte @zp yy = 0
-        byte @zp decisionOver2 = 1-xx as byte
+        word @zp decisionOver2 = (1 as word)-xx
 
         while xx>=yy {
             cx16.r0 = xcenter + xx
             cx16.r1 = ycenter + yy
-            cx16.FB_cursor_position()
+            cx16.FB_cursor_position2()
             cx16.FB_set_pixel(1)
             cx16.r0 = xcenter - xx
-            cx16.FB_cursor_position()
+            cx16.FB_cursor_position2()
             cx16.FB_set_pixel(1)
             cx16.r0 = xcenter + xx
             cx16.r1 = ycenter - yy
-            cx16.FB_cursor_position()
+            cx16.FB_cursor_position2()
             cx16.FB_set_pixel(1)
             cx16.r0 = xcenter - xx
-            cx16.FB_cursor_position()
+            cx16.FB_cursor_position2()
             cx16.FB_set_pixel(1)
             cx16.r0 = xcenter + yy
             cx16.r1 = ycenter + xx
-            cx16.FB_cursor_position()
+            cx16.FB_cursor_position2()
             cx16.FB_set_pixel(1)
             cx16.r0 = xcenter - yy
-            cx16.FB_cursor_position()
+            cx16.FB_cursor_position2()
             cx16.FB_set_pixel(1)
             cx16.r0 = xcenter + yy
             cx16.r1 = ycenter - xx
-            cx16.FB_cursor_position()
+            cx16.FB_cursor_position2()
             cx16.FB_set_pixel(1)
             cx16.r0 = xcenter - yy
-            cx16.FB_cursor_position()
+            cx16.FB_cursor_position2()
             cx16.FB_set_pixel(1)
             yy++
             if decisionOver2<=0 {
-                decisionOver2 += 2*yy+1
+                decisionOver2 += (yy as word)*2+1
             } else {
                 xx--
-                decisionOver2 += 2*(yy-xx)+1
+                decisionOver2 += (yy as word -xx)*2+1
             }
         }
     }
 
     sub disc(uword xcenter, ubyte ycenter, ubyte radius) {
-;        cx16.r0 = xcenter - radius/2
-;        cx16.r1 = ycenter - radius/2
-;        cx16.r2 = radius*2
-;        cx16.r3 = radius*2
-;        cx16.GRAPH_draw_oval(true)          ; TODO  currently is not implemented on cx16, does a BRK
+        if radius==0
+            return
+        ubyte @zp yy = 0
+        word decisionOver2 = (1 as word)-radius
 
-        ubyte xx = radius
-        ubyte yy = 0
-        byte decisionOver2 = 1-xx as byte
-
-        while xx>=yy {
-            ubyte ycenter_plus_yy = ycenter + yy
-            ubyte ycenter_min_yy = ycenter - yy
-            ubyte ycenter_plus_xx = ycenter + xx
-            ubyte ycenter_min_xx = ycenter - xx
-            uword @zp plotx
-
-            for plotx in xcenter to xcenter+xx {
-                cx16.r0 = plotx
-                cx16.r1 = ycenter_plus_yy
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-                cx16.r1 = ycenter_min_yy
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-            }
-            for plotx in xcenter-xx to xcenter-1 {
-                cx16.r0 = plotx
-                cx16.r1 = ycenter_plus_yy
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-                cx16.r1 = ycenter_min_yy
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-            }
-            for plotx in xcenter to xcenter+yy {
-                cx16.r0 = plotx
-                cx16.r1 = ycenter_plus_xx
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-                cx16.r1 = ycenter_min_xx
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-            }
-            for plotx in xcenter-yy to xcenter {
-                cx16.r0 = plotx
-                cx16.r1 = ycenter_plus_xx
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-                cx16.r1 = ycenter_min_xx
-                cx16.FB_cursor_position()
-                cx16.FB_set_pixel(1)
-            }
+        while radius>=yy {
+            horizontal_line(xcenter-radius, ycenter+yy, radius*2+1)
+            horizontal_line(xcenter-radius, ycenter-yy, radius*2+1)
+            horizontal_line(xcenter-yy, ycenter+radius, yy*2+1)
+            horizontal_line(xcenter-yy, ycenter-radius, yy*2+1)
             yy++
             if decisionOver2<=0
-                decisionOver2 += 2*yy+1
+                decisionOver2 += (yy as word)*2+1
             else {
-                xx--
-                decisionOver2 += 2*(yy-xx)+1
+                radius--
+                decisionOver2 += (yy as word -radius)*2+1
             }
         }
     }
 
-    sub  plot(uword plotx, ubyte ploty) {
-        cx16.r0 = plotx
-        cx16.r1 = ploty
-        cx16.FB_cursor_position()
-        cx16.FB_set_pixel(1)
+    inline asmsub  plot(uword plotx @R0, uword ploty @R1) clobbers(A, X, Y) {
+        %asm {{
+            jsr  cx16.FB_cursor_position
+            lda  #1
+            jsr  cx16.FB_set_pixel
+        }}
     }
 }
-
-

compiler/res/prog8lib/cx16/palette.p8

@@ -0,0 +1,171 @@
+%target cx16
+
+; Manipulate the Commander X16's display color palette.
+; Should you want to restore the default palette, you have to reinitialize the Vera yourself.
+
+palette {
+
+    uword vera_palette_ptr
+    ubyte c
+
+    sub set_color(ubyte index, uword color) {
+        cx16.vpoke(1, $fa00+index*2, lsb(color))
+        cx16.vpoke(1, $fa01+index*2, msb(color))
+    }
+
+    sub set_rgb4(uword palletteptr, uword num_colors) {
+        ; 2 bytes per color entry, the Vera uses this, but the R/GB bytes order is swapped
+        vera_palette_ptr = $fa00
+        repeat num_colors {
+            cx16.vpoke(1, vera_palette_ptr+1, @(palletteptr))
+            palletteptr++
+            cx16.vpoke(1, vera_palette_ptr, @(palletteptr))
+            palletteptr++
+            vera_palette_ptr+=2
+        }
+    }
+
+    sub set_rgb8(uword palletteptr, uword num_colors) {
+        ; 3 bytes per color entry, adjust color depth from 8 to 4 bits per channel.
+        vera_palette_ptr = $fa00
+        ubyte red
+        ubyte greenblue
+        repeat num_colors {
+            red = @(palletteptr) >> 4
+            palletteptr++
+            greenblue = @(palletteptr) & %11110000
+            palletteptr++
+            greenblue |= @(palletteptr) >> 4    ; add Blue
+            palletteptr++
+            cx16.vpoke(1, vera_palette_ptr, greenblue)
+            vera_palette_ptr++
+            cx16.vpoke(1, vera_palette_ptr, red)
+            vera_palette_ptr++
+        }
+    }
+
+    sub set_monochrome() {
+        vera_palette_ptr = $fa00
+        cx16.vpoke(1, vera_palette_ptr, 0)
+        vera_palette_ptr++
+        cx16.vpoke(1, vera_palette_ptr, 0)
+        vera_palette_ptr++
+        repeat 255 {
+            cx16.vpoke(1, vera_palette_ptr, 255)
+            vera_palette_ptr++
+            cx16.vpoke(1, vera_palette_ptr, 255)
+            vera_palette_ptr++
+        }
+    }
+
+    sub set_grayscale() {
+        vera_palette_ptr = $fa00
+        repeat 16 {
+            c=0
+            repeat 16 {
+                cx16.vpoke(1, vera_palette_ptr, c)
+                vera_palette_ptr++
+                cx16.vpoke(1, vera_palette_ptr, c)
+                vera_palette_ptr++
+                c += $11
+            }
+        }
+    }
+
+    uword[] C64_colorpalette_dark = [   ; this is a darker palette with more contrast
+        $000,  ; 0 = black
+        $FFF,  ; 1 = white
+        $632,  ; 2 = red
+        $7AB,  ; 3 = cyan
+        $638,  ; 4 = purple
+        $584,  ; 5 = green
+        $327,  ; 6 = blue
+        $BC6,  ; 7 = yellow
+        $642,  ; 8 = orange
+        $430,  ; 9 = brown
+        $965,  ; 10 = light red
+        $444,  ; 11 = dark grey
+        $666,  ; 12 = medium grey
+        $9D8,  ; 13 = light green
+        $65B,  ; 14 = light blue
+        $999  ; 15 = light grey
+    ]
+
+    uword[] C64_colorpalette_pepto = [  ; # this is Pepto's Commodore-64 palette  http://www.pepto.de/projects/colorvic/
+        $000,  ; 0 = black
+        $FFF,  ; 1 = white
+        $833,  ; 2 = red
+        $7cc,  ; 3 = cyan
+        $839,  ; 4 = purple
+        $5a4,  ; 5 = green
+        $229,  ; 6 = blue
+        $ef7,  ; 7 = yellow
+        $852,  ; 8 = orange
+        $530,  ; 9 = brown
+        $c67,  ; 10 = light red
+        $444,  ; 11 = dark grey
+        $777,  ; 12 = medium grey
+        $af9,  ; 13 = light green
+        $76e,  ; 14 = light blue
+        $bbb  ; 15 = light grey
+    ]
+
+    uword[] C64_colorpalette_light = [  ; this is a lighter palette
+        $000,  ; 0 = black
+        $FFF,  ; 1 = white
+        $944,  ; 2 = red
+        $7CC,  ; 3 = cyan
+        $95A,  ; 4 = purple
+        $6A5,  ; 5 = green
+        $549,  ; 6 = blue
+        $CD8,  ; 7 = yellow
+        $963,  ; 8 = orange
+        $650,  ; 9 = brown
+        $C77,  ; 10 = light red
+        $666,  ; 11 = dark grey
+        $888,  ; 12 = medium grey
+        $AE9,  ; 13 = light green
+        $87C,  ; 14 = light blue
+        $AAA   ; 15 = light grey
+    ]
+
+    sub set_c64pepto() {
+        vera_palette_ptr = $fa00
+        repeat 16 {
+            for c in 0 to 15 {
+                uword cc = C64_colorpalette_pepto[c]
+                cx16.vpoke(1, vera_palette_ptr, lsb(cc))     ; G, B
+                vera_palette_ptr++
+                cx16.vpoke(1, vera_palette_ptr, msb(cc))     ; R
+                vera_palette_ptr++
+            }
+        }
+    }
+
+    sub set_c64light() {
+        vera_palette_ptr = $fa00
+        repeat 16 {
+            for c in 0 to 15 {
+                uword cc = C64_colorpalette_light[c]
+                cx16.vpoke(1, vera_palette_ptr, lsb(cc))     ; G, B
+                vera_palette_ptr++
+                cx16.vpoke(1, vera_palette_ptr, msb(cc))     ; R
+                vera_palette_ptr++
+            }
+        }
+    }
+
+    sub set_c64dark() {
+        vera_palette_ptr = $fa00
+        repeat 16 {
+            for c in 0 to 15 {
+                uword cc = C64_colorpalette_dark[c]
+                cx16.vpoke(1, vera_palette_ptr, lsb(cc))     ; G, B
+                vera_palette_ptr++
+                cx16.vpoke(1, vera_palette_ptr, msb(cc))     ; R
+                vera_palette_ptr++
+            }
+        }
+    }
+
+}

compiler/res/prog8lib/cx16/syslib.p8

@@ -24,7 +24,7 @@ romsub $FF8D = VECTOR(uword userptr @ XY, ubyte dir @ Pc) clobbers(A,Y)     ; re
 romsub $FF90 = SETMSG(ubyte value @ A)                          ; set Kernal message control flag
 romsub $FF93 = SECOND(ubyte address @ A) clobbers(A)            ; (alias: LSTNSA) send secondary address after LISTEN
 romsub $FF96 = TKSA(ubyte address @ A) clobbers(A)              ; (alias: TALKSA) send secondary address after TALK
-romsub $FF99 = MEMTOP(uword address @ XY, ubyte dir @ Pc) -> uword @ XY     ; read/set top of memory  pointer
+romsub $FF99 = MEMTOP(uword address @ XY, ubyte dir @ Pc) -> uword @ XY     ; read/set top of memory  pointer.   NOTE: as a Cx16 extension, also returns the number of RAM memory banks in register A !  See MEMTOP2
 romsub $FF9C = MEMBOT(uword address @ XY, ubyte dir @ Pc) -> uword @ XY     ; read/set bottom of memory  pointer
 romsub $FF9F = SCNKEY() clobbers(A,X,Y)                         ; scan the keyboard
 romsub $FFA2 = SETTMO(ubyte timeout @ A)                        ; set time-out flag for IEEE bus
@@ -56,6 +56,48 @@ romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; read number of
 romsub $FFF0 = PLOT(ubyte col @ Y, ubyte row @ X, ubyte dir @ Pc) -> ubyte @ X, ubyte @ Y       ; read/set position of cursor on screen.  Use txt.plot for a 'safe' wrapper that preserves X.
 romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base address of I/O devices
 
+; ---- utility
+
+asmsub STOP2() -> ubyte @A  {
+    ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the carry status flag.
+    %asm {{
+        phx
+        jsr  c64.STOP
+        beq  +
+        plx
+        lda  #0
+        rts
++       plx
+        lda  #1
+        rts
+    }}
+}
+
+asmsub RDTIM16() -> uword @AY {
+    ; --  like RDTIM() but only returning the lower 16 bits for convenience
+    %asm {{
+        phx
+        jsr  c64.RDTIM
+        pha
+        txa
+        tay
+        pla
+        plx
+        rts
+    }}
+}
+
+asmsub MEMTOP2() -> ubyte @A {
+    ; -- uses MEMTOP's cx16 extension to query the number of available RAM banks.
+    %asm {{
+        phx
+        sec
+        jsr  c64.MEMTOP
+        plx
+        rts
+    }}
+}
+
 }
 
 cx16 {
@@ -148,22 +190,22 @@ cx16 {
     &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
+    &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 ----
@@ -190,61 +232,210 @@ romsub $ff6b = mouse_get(ubyte zpdataptr @X)  clobbers(A)
 romsub $ff71 = mouse_scan()  clobbers(A, X, Y)
 romsub $ff53 = joystick_scan()  clobbers(A, X, Y)
 romsub $ff56 = joystick_get(ubyte joynr @A) -> ubyte @A, ubyte @X, ubyte @Y
-romsub $ff4d = clock_set_date_time()  clobbers(A, X, Y)      ; args: r0, r1, r2, r3L
-romsub $ff50 = clock_get_date_time()  clobbers(A, X, Y)      ; outout args: r0, r1, r2, r3L
+romsub $ff4d = clock_set_date_time(uword yearmonth @R0, uword dayhours @R1, uword minsecs @R2, ubyte jiffies @R3)  clobbers(A, X, Y)
+romsub $ff50 = clock_get_date_time()  clobbers(A, X, Y)  -> uword @R0, uword @R1, uword @R2, ubyte @R3   ; result registers see clock_set_date_time()
 
 ; TODO specify the correct clobbers for alle these functions below, we now assume all 3 regs are clobbered
 
 ; high level graphics & fonts
-romsub $ff20 = GRAPH_init()  clobbers(A,X,Y)           ; uses vectors=r0
+romsub $ff20 = GRAPH_init(uword vectors @R0)  clobbers(A,X,Y)
 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 $ff26 = GRAPH_set_window(uword x @R0, uword y @R1, uword width @R2, uword height @R3)  clobbers(A,X,Y)
 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 $ff2c = GRAPH_draw_line(uword x1 @R0, uword y1 @R1, uword x2 @R2, uword y2 @R3)  clobbers(A,X,Y)
+romsub $ff2f = GRAPH_draw_rect(uword x @R0, uword y @R1, uword width @R2, uword height @R3, uword cornerradius @R4, ubyte fill @Pc)  clobbers(A,X,Y)
+romsub $ff32 = GRAPH_move_rect(uword sx @R0, uword sy @R1, uword tx @R2, uword ty @R3, uword width @R4, uword height @R5)  clobbers(A,X,Y)
+romsub $ff35 = GRAPH_draw_oval(uword x @R0, uword y @R1, uword width @R2, uword height @R3, ubyte fill @Pc)  clobbers(A,X,Y)
+romsub $ff38 = GRAPH_draw_image(uword x @R0, uword y @R1, uword ptr @R2, uword width @R3, uword height @R4)  clobbers(A,X,Y)
+romsub $ff3b = GRAPH_set_font(uword fontptr @R0)  clobbers(A,X,Y)
 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
+romsub $ff41 = GRAPH_put_char(uword x @R0, uword y @R1, ubyte char @A)  clobbers(A,X,Y)
+romsub $ff41 = GRAPH_put_next_char(ubyte char @A)  clobbers(A,X,Y)     ; alias for the routine above that doesn't reset the position of the initial character
 
 ; 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 $fef9 = FB_get_info()  clobbers(X,Y) -> byte @A, uword @R0, uword @R1    ; width=r0, height=r1
+romsub $fefc = FB_set_palette(uword pointer @R0, ubyte index @A, ubyte bytecount @X)  clobbers(A,X,Y)
+romsub $feff = FB_cursor_position(uword x @R0, uword y @R1)  clobbers(A,X,Y)
+romsub $feff = FB_cursor_position2()  clobbers(A,X,Y)           ;  alias for the previous routine, but avoiding having to respecify both x and y every time
+romsub $ff02 = FB_cursor_next_line(uword x @R0)  clobbers(A,X,Y)
 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 $ff08 = FB_get_pixels(uword pointer @R0, uword count @R1)  clobbers(A,X,Y)
 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 $ff0e = FB_set_pixels(uword pointer @R0, uword count @R1)  clobbers(A,X,Y)
 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 $ff14 = FB_set_8_pixels_opaque(ubyte pattern @R0, ubyte mask @A, ubyte color1 @X, ubyte color2 @Y)  clobbers(A,X,Y)
+romsub $ff17 = FB_fill_pixels(uword count @R0, uword pstep @R1, ubyte color @A)  clobbers(A,X,Y)
+romsub $ff1a = FB_filter_pixels(uword pointer @ R0, uword count @R1)  clobbers(A,X,Y)
+romsub $ff1d = FB_move_pixels(uword sx @R0, uword sy @R1, uword tx @R2, uword ty @R3, uword count @R4)  clobbers(A,X,Y)
 
 ; 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 $fef0 = sprite_set_image(uword pixels @R0, uword mask @R1, ubyte bpp @R2, ubyte number @A, ubyte width @X, ubyte height @Y, ubyte apply_mask @Pc)  clobbers(A,X,Y) -> ubyte @Pc
+romsub $fef3 = sprite_set_position(uword x @R0, uword y @R1, ubyte number @A)  clobbers(A,X,Y)
+romsub $fee4 = memory_fill(uword address @R0, uword num_bytes @R1, ubyte value @A)  clobbers(A,X,Y)
+romsub $fee7 = memory_copy(uword source @R0, uword target @R1, uword num_bytes @R2)  clobbers(A,X,Y)
+romsub $feea = memory_crc(uword address @R0, uword num_bytes @R1)  clobbers(A,X,Y) -> uword @R2
+romsub $feed = memory_decompress(uword input @R0, uword output @R1)  clobbers(A,X,Y) -> uword @R1       ; last address +1 is result in R1
+romsub $fedb = console_init(uword x @R0, uword y @R1, uword width @R2, uword height @R3)  clobbers(A,X,Y)
 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 $fed8 = console_put_image(uword pointer @R0, uword width @R1, uword height @R2)  clobbers(A,X,Y)
+romsub $fed5 = console_set_paging_message(uword msgptr @R0)  clobbers(A,X,Y)
 romsub $fed2 = kbdbuf_put(ubyte key @A)  clobbers(A,X,Y)
 romsub $fecf = entropy_get() -> ubyte @A, ubyte @X, ubyte @Y
 romsub $fecc = monitor()  clobbers(A,X,Y)
 
-
-
 ; ---- end of kernal routines ----
 
+
+; ---- utilities -----
+asmsub vpeek(ubyte bank @A, uword address @XY) -> ubyte @A {
+        ; -- get a byte from VERA's video memory
+        ;    note: inefficient when reading multiple sequential bytes!
+        %asm {{
+                pha
+                lda  #1
+                sta  cx16.VERA_CTRL
+                pla
+                and  #1
+                sta  cx16.VERA_ADDR_H
+                sty  cx16.VERA_ADDR_M
+                stx  cx16.VERA_ADDR_L
+                lda  cx16.VERA_DATA1
+                rts
+            }}
+}
+
+asmsub vaddr(ubyte bank @A, uword address @R0, ubyte addrsel @R1, byte autoIncrOrDecrByOne @Y) clobbers(A) {
+        ; -- setup the VERA's data address register 0 or 1
+        %asm {{
+            and  #1
+            pha
+            lda  cx16.r1
+            and  #1
+            sta  cx16.VERA_CTRL
+            lda  cx16.r0
+            sta  cx16.VERA_ADDR_L
+            lda  cx16.r0+1
+            sta  cx16.VERA_ADDR_M
+            pla
+            cpy  #0
+            bmi  ++
+            beq  +
+            ora  #%00010000
++           sta  cx16.VERA_ADDR_H
+            rts
++           ora  #%00011000
+            sta  cx16.VERA_ADDR_H
+            rts
+        }}
+}
+
+asmsub vpoke(ubyte bank @A, uword address @R0, ubyte value @Y) clobbers(A) {
+        ; -- write a single byte to VERA's video memory
+        ;    note: inefficient when writing multiple sequential bytes!
+        %asm {{
+            stz  cx16.VERA_CTRL
+            and  #1
+            sta  cx16.VERA_ADDR_H
+            lda  cx16.r0
+            sta  cx16.VERA_ADDR_L
+            lda  cx16.r0+1
+            sta  cx16.VERA_ADDR_M
+            sty  cx16.VERA_DATA0
+            rts
+        }}
+}
+
+asmsub vpoke_or(ubyte bank @A, uword address @R0, ubyte value @Y) clobbers (A) {
+        ; -- or a single byte to the value already in the VERA's video memory at that location
+        ;    note: inefficient when writing multiple sequential bytes!
+        %asm {{
+            stz  cx16.VERA_CTRL
+            and  #1
+            sta  cx16.VERA_ADDR_H
+            lda  cx16.r0
+            sta  cx16.VERA_ADDR_L
+            lda  cx16.r0+1
+            sta  cx16.VERA_ADDR_M
+            tya
+            ora  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            rts
+        }}
+}
+
+asmsub vpoke_and(ubyte bank @A, uword address @R0, ubyte value @Y) clobbers(A) {
+        ; -- and a single byte to the value already in the VERA's video memory at that location
+        ;    note: inefficient when writing multiple sequential bytes!
+        %asm {{
+            stz  cx16.VERA_CTRL
+            and  #1
+            sta  cx16.VERA_ADDR_H
+            lda  cx16.r0
+            sta  cx16.VERA_ADDR_L
+            lda  cx16.r0+1
+            sta  cx16.VERA_ADDR_M
+            tya
+            and  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            rts
+        }}
+}
+
+asmsub vpoke_xor(ubyte bank @A, uword address @R0, ubyte value @Y) clobbers (A) {
+        ; -- xor a single byte to the value already in the VERA's video memory at that location
+        ;    note: inefficient when writing multiple sequential bytes!
+        %asm {{
+            stz  cx16.VERA_CTRL
+            and  #1
+            sta  cx16.VERA_ADDR_H
+            lda  cx16.r0
+            sta  cx16.VERA_ADDR_L
+            lda  cx16.r0+1
+            sta  cx16.VERA_ADDR_M
+            tya
+            eor  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            rts
+        }}
+}
+
+sub FB_set_pixels_from_buf(uword buffer, uword count) {
+    %asm {{
+            ; -- This is replacement code for the normal FB_set_pixels subroutine in ROM
+            ;    However that routine contains a bug in the current v38 ROM that makes it crash when count > 255.
+            ;    So the code below replaces that. Once the ROM is patched this routine is no longer necessary.
+            ;    See https://github.com/commanderx16/x16-rom/issues/179
+            phx
+            lda  buffer
+            ldy  buffer+1
+            sta  P8ZP_SCRATCH_W1
+            sty  P8ZP_SCRATCH_W1+1
+            jsr  _pixels
+            plx
+            rts
+
+_pixels     lda  count+1
+            beq  +
+            ldx  #0
+-           jsr  _loop
+            inc  P8ZP_SCRATCH_W1+1
+            dec  count+1
+            bne  -
+
++           ldx  count
+_loop       ldy  #0
+-           lda  (P8ZP_SCRATCH_W1),y
+            sta  cx16.VERA_DATA0
+            iny
+            dex
+            bne  -
+            rts
+        }}
+}
+
+; ---- system stuff -----
 asmsub init_system()  {
     ; Initializes the machine to a sane starting state.
     ; Called automatically by the loader program logic.
@@ -277,15 +468,129 @@ asmsub init_system()  {
     }}
 }
 
-asmsub  reset_system()  {
-    ; Soft-reset the system back to Basic prompt.
-    %asm {{
-        sei
-        lda  #14
-        sta  $01
-        stz  cx16.d1prb         ; bank the kernal in
-        jmp  (cx16.RESET_VEC)
-    }}
 }
 
+sys {
+    ; ------- lowlevel system routines --------
+
+    const ubyte target = 16         ;  compilation target specifier.  64 = C64,  16 = CommanderX16.
+
+
+    asmsub reset_system() {
+        ; Soft-reset the system back to Basic prompt.
+        %asm {{
+            sei
+            lda  #14
+            sta  $01
+            stz  cx16.d1prb         ; bank the kernal in
+            jmp  (cx16.RESET_VEC)
+        }}
+    }
+
+    sub wait(uword jiffies) {
+        ; --- wait approximately the given number of jiffies (1/60th seconds)
+        repeat jiffies {
+            ubyte jiff = lsb(c64.RDTIM16())
+            while jiff==lsb(c64.RDTIM16()) {
+                ; wait until 1 jiffy has passed
+            }
+        }
+    }
+
+    inline asmsub memcopy(uword source @R0, uword target @R1, uword count @AY) clobbers(A,X,Y) {
+        %asm {{
+            sta  cx16.r2
+            sty  cx16.r2+1
+            jsr  cx16.memory_copy
+        }}
+    }
+
+    inline asmsub memset(uword mem @R0, uword numbytes @R1, ubyte value @A) clobbers(A,X,Y) {
+        %asm {{
+            jsr  cx16.memory_fill
+        }}
+    }
+
+    asmsub memsetw(uword mem @R0, uword numwords @R1, uword value @AY) clobbers (A,X,Y) {
+        %asm {{
+            ldx  cx16.r0
+            stx  P8ZP_SCRATCH_W1
+            ldx  cx16.r0+1
+            stx  P8ZP_SCRATCH_W1+1
+            ldx  cx16.r1
+            stx  P8ZP_SCRATCH_W2
+            ldx  cx16.r1+1
+            stx  P8ZP_SCRATCH_W2+1
+            jmp  prog8_lib.memsetw
+        }}
+    }
+
+    inline asmsub rsave() {
+        ; save cpu status flag and all registers A, X, Y.
+        ; see http://6502.org/tutorials/register_preservation.html
+        %asm {{
+            php
+            pha
+            phy
+            phx
+        }}
+    }
+
+    inline asmsub rrestore() {
+        ; restore all registers and cpu status flag
+        %asm {{
+            plx
+            ply
+            pla
+            plp
+        }}
+    }
+
+    inline asmsub read_flags() -> ubyte @A {
+        %asm {{
+            php
+            pla
+        }}
+    }
+
+    inline asmsub clear_carry() {
+        %asm {{
+            clc
+        }}
+    }
+
+    inline asmsub set_carry() {
+        %asm {{
+            sec
+        }}
+    }
+
+    inline asmsub clear_irqd() {
+        %asm {{
+            cli
+        }}
+    }
+
+    inline asmsub set_irqd() {
+        %asm {{
+            sei
+        }}
+    }
+
+    inline asmsub exit(ubyte returnvalue @A) {
+        ; -- immediately exit the program with a return code in the A register
+        %asm {{
+            jsr  c64.CLRCHN		; reset i/o channels
+            ldx  prog8_lib.orig_stackpointer
+            txs
+            rts		; return to original caller
+        }}
+    }
+
+    inline asmsub progend() -> uword @AY {
+        %asm {{
+            lda  #<prog8_program_end
+            ldy  #>prog8_program_end
+        }}
+    }
 }

compiler/res/prog8lib/cx16/textio.p8

@@ -15,8 +15,16 @@ const ubyte DEFAULT_WIDTH = 80
 const ubyte DEFAULT_HEIGHT = 60
 
 
-sub  clear_screen() {
-    clear_screenchars(' ')
+sub clear_screen() {
+    txt.chrout(147)
+}
+
+sub nl() {
+    txt.chrout('\n')
+}
+
+sub home() {
+    txt.chrout(19)
 }
 
 asmsub  fill_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
@@ -154,10 +162,9 @@ sub uppercase() {
     cx16.screen_set_charset(2, 0)  ; uppercase charset
 }
 
-asmsub  scroll_left  (ubyte dummy @ Pc) clobbers(A, Y)  {
+asmsub  scroll_left() clobbers(A, Y)  {
 	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
-	;      Carry flag is a dummy on the cx16
 	%asm {{
 	    phx
 	    jsr  c64.SCREEN
@@ -198,10 +205,9 @@ _lx     ldx  #0                ; modified
 	}}
 }
 
-asmsub  scroll_right  (ubyte dummy @ Pc) clobbers(A)  {
+asmsub  scroll_right() clobbers(A)  {
 	; ---- scroll the whole screen 1 character to the right
 	;      contents of the leftmost column are unchanged, you should clear/refill this yourself
-	;      Carry flag is a dummy on the cx16
 	%asm {{
 	    phx
 	    jsr  c64.SCREEN
@@ -250,10 +256,9 @@ _lx     ldx  #0                 ; modified
 	}}
 }
 
-asmsub  scroll_up  (ubyte dummy @ Pc) clobbers(A, Y)  {
+asmsub  scroll_up() clobbers(A, Y)  {
 	; ---- scroll the whole screen 1 character up
 	;      contents of the bottom row are unchanged, you should refill/clear this yourself
-	;      Carry flag is a dummy on the cx16
 	%asm {{
 	    phx
 	    jsr  c64.SCREEN
@@ -300,10 +305,9 @@ _nextline
 	}}
 }
 
-asmsub  scroll_down  (ubyte dummy @ Pc) clobbers(A, Y)  {
+asmsub  scroll_down() clobbers(A, Y)  {
 	; ---- scroll the whole screen 1 character down
 	;      contents of the top row are unchanged, you should refill/clear this yourself
-	;      Carry flag is a dummy on the cx16
 	%asm {{
 	    phx
 	    jsr  c64.SCREEN

compiler/res/prog8lib/cx16logo.p8

@@ -1,3 +1,5 @@
+; routine to draw the Commander X16's log in petscii.
+
 %import textio
 
 cx16logo {
@@ -14,7 +16,7 @@ cx16logo {
         uword strptr
         for strptr in logo_lines
             txt.print(strptr)
-        txt.chrout('\n')
+        txt.nl()
     }
 
     str[] logo_lines = [

compiler/res/prog8lib/diskio.p8

@@ -1,20 +1,22 @@
-%import textio
-%import syslib
+; C64 and Cx16 disk drive I/O routines.
+;
+; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
 
-; Note: this code is compatible with C64 and CX16.
+%import textio
+%import string
+%import syslib
 
 diskio {
 
-
-    sub directory(ubyte drivenumber) -> byte {
-        ; -- Shows the directory contents of disk drive 8-11 (provide as argument).
+    sub directory(ubyte drivenumber) -> ubyte {
+        ; -- Prints the directory contents of disk drive 8-11 to the screen. Returns success.
 
         c64.SETNAM(1, "$")
-        c64.SETLFS(1, drivenumber, 0)
-        void c64.OPEN()          ; open 1,8,0,"$"
+        c64.SETLFS(13, drivenumber, 0)
+        void c64.OPEN()          ; open 13,8,0,"$"
         if_cs
             goto io_error
-        void c64.CHKIN(1)        ; use #1 as input channel
+        void c64.CHKIN(13)        ; use #13 as input channel
         if_cs
             goto io_error
 
@@ -25,31 +27,34 @@ diskio {
         ; while not key pressed / EOF encountered, read data.
         ubyte status = c64.READST()
         while not status {
-            txt.print_uw(mkword(c64.CHRIN(), c64.CHRIN()))
+            ubyte low = c64.CHRIN()
+            ubyte high = c64.CHRIN()
+            txt.print_uw(mkword(high, low))
             txt.chrout(' ')
             ubyte @zp char
-            do {
+            repeat {
                 char = c64.CHRIN()
+                if char==0
+                    break
                 txt.chrout(char)
-            } until char==0
-            txt.chrout('\n')
+            }
+            txt.nl()
             void c64.CHRIN()     ; skip 2 bytes
             void c64.CHRIN()
             status = c64.READST()
-            void c64.STOP()
-            if_nz
+            if c64.STOP2()
                 break
         }
 
 io_error:
         status = c64.READST()
         c64.CLRCHN()        ; restore default i/o devices
-        c64.CLOSE(1)
+        c64.CLOSE(13)
 
-        if status and status != 64 {            ; 64=end of file
+        if status and status & $40 == 0 {            ; bit 6=end of file
             txt.print("\ni/o error, status: ")
             txt.print_ub(status)
-            txt.chrout('\n')
+            txt.nl()
             return false
         }
 
@@ -57,9 +62,283 @@ io_error:
     }
 
 
-    sub status(ubyte drivenumber) {
-        ; -- display the disk drive's current status message
-        c64.SETNAM(0, $0000)
+    ; internal variables for the iterative file lister / loader
+    ubyte list_skip_disk_name
+    uword list_pattern
+    uword list_blocks
+    ubyte iteration_in_progress = false
+    ubyte @zp first_byte
+    ubyte have_first_byte
+    str   list_filename = "?" * 32
+
+
+    ; ----- get a list of files (uses iteration functions internally -----
+
+    sub list_files(ubyte drivenumber, uword pattern_ptr, uword name_ptrs, ubyte max_names) -> ubyte {
+        ; -- fill the array 'name_ptrs' with (pointers to) the names of the files requested.
+        uword names_buffer = memory("filenames", 512)
+        uword buffer_start = names_buffer
+        ubyte files_found = 0
+        if lf_start_list(drivenumber, pattern_ptr) {
+            while lf_next_entry() {
+                @(name_ptrs) = lsb(names_buffer)
+                name_ptrs++
+                @(name_ptrs) = msb(names_buffer)
+                name_ptrs++
+                names_buffer += string.copy(diskio.list_filename, names_buffer) + 1
+                files_found++
+                if names_buffer - buffer_start > 512-18
+                    break
+                if files_found == max_names
+                    break
+            }
+            lf_end_list()
+        }
+        return files_found
+    }
+
+    ; ----- iterative file lister functions (uses io channel 12) -----
+
+    sub lf_start_list(ubyte drivenumber, uword pattern_ptr) -> ubyte {
+        ; -- start an iterative file listing with optional pattern matching.
+        ;    note: only a single iteration loop can be active at a time!
+        lf_end_list()
+        list_pattern = pattern_ptr
+        list_skip_disk_name = true
+        iteration_in_progress = true
+
+        c64.SETNAM(1, "$")
+        c64.SETLFS(12, drivenumber, 0)
+        void c64.OPEN()          ; open 12,8,0,"$"
+        if_cs
+            goto io_error
+        void c64.CHKIN(12)        ; use #12 as input channel
+        if_cs
+            goto io_error
+
+        repeat 4 {
+            void c64.CHRIN()     ; skip the 4 prologue bytes
+        }
+
+        if c64.READST()==0
+            return true
+
+io_error:
+        lf_end_list()
+        return false
+    }
+
+    sub lf_next_entry() -> ubyte {
+        ; -- retrieve the next entry from an iterative file listing session.
+        ;    results will be found in list_blocks and list_filename.
+        ;    if it returns false though, there are no more entries (or an error occurred).
+
+        if not iteration_in_progress
+            return false
+
+        repeat {
+            void c64.CHKIN(12)        ; use #12 as input channel again
+
+            uword nameptr = &list_filename
+            ubyte blocks_lsb = c64.CHRIN()
+            ubyte blocks_msb = c64.CHRIN()
+
+            if c64.READST()
+                goto close_end
+
+            list_blocks = mkword(blocks_msb, blocks_lsb)
+
+            ; read until the filename starts after the first "
+            while c64.CHRIN()!='\"'  {
+                if c64.READST()
+                    goto close_end
+            }
+
+            ; read the filename
+            repeat {
+                ubyte char = c64.CHRIN()
+                if char==0
+                    break
+                if char=='\"'
+                    break
+                @(nameptr) = char
+                nameptr++
+            }
+
+            @(nameptr) = 0
+
+            while c64.CHRIN() {
+                ; read the rest of the entry until the end
+            }
+
+            void c64.CHRIN()     ; skip 2 bytes
+            void c64.CHRIN()
+
+            if not list_skip_disk_name {
+                if not list_pattern
+                    return true
+                if prog8_lib.pattern_match(list_filename, list_pattern)
+                    return true
+            }
+            list_skip_disk_name = false
+        }
+
+close_end:
+        lf_end_list()
+        return false
+    }
+
+    sub lf_end_list() {
+        ; -- end an iterative file listing session (close channels).
+        if iteration_in_progress {
+            c64.CLRCHN()
+            c64.CLOSE(12)
+            iteration_in_progress = false
+        }
+    }
+
+
+    ; ----- iterative file loader functions (uses io channel 11) -----
+
+    sub f_open(ubyte drivenumber, uword filenameptr) -> ubyte {
+        ; -- open a file for iterative reading with f_read
+        ;    note: only a single iteration loop can be active at a time!
+        f_close()
+
+        c64.SETNAM(string.length(filenameptr), filenameptr)
+        c64.SETLFS(11, drivenumber, 0)
+        void c64.OPEN()          ; open 11,8,0,"filename"
+        if_cc {
+            iteration_in_progress = true
+            have_first_byte = false
+            void c64.CHKIN(11)        ; use #11 as input channel
+            if_cc {
+                first_byte = c64.CHRIN()   ; read first byte to test for file not found
+                if not c64.READST() {
+                    have_first_byte = true
+                    return true
+                }
+            }
+        }
+        f_close()
+        return false
+    }
+
+    sub f_read(uword bufferpointer, uword num_bytes) -> uword {
+        ; -- read from the currently open file, up to the given number of bytes.
+        ;    returns the actual number of bytes read.  (checks for End-of-file and error conditions)
+        if not iteration_in_progress or not num_bytes
+            return 0
+
+        list_blocks = 0     ; we reuse this variable for the total number of bytes read
+        if have_first_byte {
+            have_first_byte=false
+            @(bufferpointer) = first_byte
+            bufferpointer++
+            list_blocks++
+            num_bytes--
+        }
+
+        void c64.CHKIN(11)        ; use #11 as input channel again
+        %asm {{
+            lda  bufferpointer
+            sta  _in_buffer+1
+            lda  bufferpointer+1
+            sta  _in_buffer+2
+        }}
+        repeat num_bytes {
+            %asm {{
+                jsr  c64.CHRIN
+                sta  cx16.r5
+_in_buffer      sta  $ffff
+                inc  _in_buffer+1
+                bne  +
+                inc  _in_buffer+2
++               inc  list_blocks
+                bne  +
+                inc  list_blocks+1
++
+            }}
+
+            if cx16.r5==$0d {   ; chance on I/o error status?
+                first_byte = c64.READST()
+                if first_byte & $40
+                    f_close()       ; end of file, close it
+                if first_byte
+                    return list_blocks
+            }
+        }
+        return list_blocks
+    }
+
+    sub f_read_all(uword bufferpointer) -> uword {
+        ; -- read the full contents of the file, returns number of bytes read.
+        if not iteration_in_progress
+            return 0
+
+        list_blocks = 0     ; we reuse this variable for the total number of bytes read
+        if have_first_byte {
+            have_first_byte=false
+            @(bufferpointer) = first_byte
+            bufferpointer++
+            list_blocks++
+        }
+
+        while not c64.READST() {
+            list_blocks += f_read(bufferpointer, 256)
+            bufferpointer += 256
+        }
+        return list_blocks
+    }
+
+    asmsub f_readline(uword bufptr @AY) clobbers(X) -> ubyte @Y {
+        ; Routine to read text lines from a text file. Lines must be less than 255 characters.
+        ; Reads characters from the input file UNTIL a newline or return character (or EOF).
+        ; The line read will be 0-terminated in the buffer (and not contain the end of line character).
+        ; The length of the line is returned in Y.
+        %asm {{
+            sta  P8ZP_SCRATCH_W1
+            sty  P8ZP_SCRATCH_W1+1
+            ldx  #11
+            jsr  c64.CHKIN              ; use channel 11 again for input
+            ldy  #0
+            lda  have_first_byte
+            beq  _loop
+            lda  #0
+            sta  have_first_byte
+            lda  first_byte
+            sta  (P8ZP_SCRATCH_W1),y
+            iny
+_loop       jsr  c64.CHRIN
+            sta  (P8ZP_SCRATCH_W1),y
+            beq  _end
+            iny
+            cmp  #$0a
+            beq  _line_end
+            cmp  #$0d
+            bne  _loop
+_line_end   dey     ; get rid of the trailing end-of-line char
+            lda  #0
+            sta  (P8ZP_SCRATCH_W1),y
+_end        rts
+        }}
+    }
+
+
+    sub f_close() {
+        ; -- end an iterative file loading session (close channels).
+        if iteration_in_progress {
+            c64.CLRCHN()
+            c64.CLOSE(11)
+            iteration_in_progress = false
+        }
+    }
+
+
+    sub status(ubyte drivenumber) -> uword {
+        ; -- retrieve the disk drive's current status message
+        uword messageptr = &filename
+        c64.SETNAM(0, filename)
         c64.SETLFS(15, drivenumber, 15)
         void c64.OPEN()          ; open 15,8,15
         if_cs
@@ -68,17 +347,21 @@ io_error:
         if_cs
             goto io_error
 
-        while not c64.READST()
-            txt.chrout(c64.CHRIN())
+        while not c64.READST() {
+            @(messageptr) = c64.CHRIN()
+            messageptr++
+        }
 
 io_error:
+        @(messageptr) = 0
         c64.CLRCHN()        ; restore default i/o devices
         c64.CLOSE(15)
+        return filename
     }
 
 
-    sub save(ubyte drivenumber, uword filenameptr, uword address, uword size) -> byte {
-        c64.SETNAM(strlen(filenameptr), filenameptr)
+    sub save(ubyte drivenumber, uword filenameptr, uword address, uword size) -> ubyte {
+        c64.SETNAM(string.length(filenameptr), filenameptr)
         c64.SETLFS(1, drivenumber, 0)
         uword end_address = address + size
 
@@ -97,14 +380,18 @@ io_error:
             plp
         }}
 
+        first_byte = 0      ; result var reuse
         if_cc
-            return c64.READST()==0
+            first_byte = c64.READST()==0
 
-        return false
+        c64.CLRCHN()
+        c64.CLOSE(1)
+
+        return first_byte
     }
 
     sub load(ubyte drivenumber, uword filenameptr, uword address_override) -> uword {
-        c64.SETNAM(strlen(filenameptr), filenameptr)
+        c64.SETNAM(string.length(filenameptr), filenameptr)
         ubyte secondary = 1
         uword end_of_load = 0
         if address_override
@@ -122,6 +409,9 @@ io_error:
 +           ldx  P8ZP_SCRATCH_REG
         }}
 
+        c64.CLRCHN()
+        c64.CLOSE(1)
+
         if end_of_load
             return end_of_load - address_override
 
@@ -133,10 +423,10 @@ io_error:
 
     sub delete(ubyte drivenumber, uword filenameptr) {
         ; -- delete a file on the drive
-        ubyte flen = strlen(filenameptr)
+        ubyte flen = string.length(filenameptr)
         filename[0] = 's'
         filename[1] = ':'
-        memcopy(filenameptr, &filename+2, flen+1)
+        sys.memcopy(filenameptr, &filename+2, flen+1)
         c64.SETNAM(flen+2, filename)
         c64.SETLFS(1, drivenumber, 15)
         void c64.OPEN()
@@ -146,13 +436,13 @@ io_error:
 
     sub rename(ubyte drivenumber, uword oldfileptr, uword newfileptr) {
         ; -- rename a file on the drive
-        ubyte flen_old = strlen(oldfileptr)
-        ubyte flen_new = strlen(newfileptr)
+        ubyte flen_old = string.length(oldfileptr)
+        ubyte flen_new = string.length(newfileptr)
         filename[0] = 'r'
         filename[1] = ':'
-        memcopy(newfileptr, &filename+2, flen_new)
+        sys.memcopy(newfileptr, &filename+2, flen_new)
         filename[flen_new+2] = '='
-        memcopy(oldfileptr, &filename+3+flen_new, flen_old+1)
+        sys.memcopy(oldfileptr, &filename+3+flen_new, flen_old+1)
         c64.SETNAM(3+flen_new+flen_old, filename)
         c64.SETLFS(1, drivenumber, 15)
         void c64.OPEN()

compiler/res/prog8lib/math.asm

@@ -1,11 +1,8 @@
-; Prog8 internal Math library routines - always included by the compiler
+; Internal Math library routines - always included by the compiler
 ; Generic machine independent 6502 code.
 ;
 ; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
 ;
-; indent format: TABS, size=8
-
-
 ;  some more interesting routines can be found here:
 ;	http://6502org.wikidot.com/software-math
 ;	http://codebase64.org/doku.php?id=base:6502_6510_maths
@@ -774,6 +771,31 @@ stack_mul_word_100	.proc
 		rts
 		.pend
 
+stack_mul_word_320	.proc
+		; stackW = stackLo * 256 + stackLo * 64	 (stackHi doesn't matter)
+		ldy  P8ESTACK_LO+1,x
+		lda  #0
+		sta  P8ESTACK_HI+1,x
+		tya
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		asl  a
+		rol  P8ESTACK_HI+1,x
+		sta  P8ESTACK_LO+1,x
+		tya
+		clc
+		adc  P8ESTACK_HI+1,x
+		sta  P8ESTACK_HI+1,x
+		rts
+		.pend
 
 ; ----------- optimized multiplications (in-place A (byte) and ?? (word)) : ---------
 mul_byte_3	.proc
@@ -1178,8 +1200,6 @@ mul_word_40	.proc
 		rol  a
 		asl  P8ZP_SCRATCH_W1
 		rol  a
-		asl  P8ZP_SCRATCH_W1
-		rol  a
 		tay
 		lda  P8ZP_SCRATCH_W1
 		rts
@@ -1241,6 +1261,32 @@ mul_word_100	.proc
 		rts
 		.pend
 
+mul_word_320	.proc
+		; AY = A * 256 + A * 64	 (msb doesn't matter)
+		sta  P8ZP_SCRATCH_B1
+		ldy  #0
+		sty  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		asl  a
+		rol  P8ZP_SCRATCH_REG
+		pha
+		clc
+		lda  P8ZP_SCRATCH_B1
+		adc  P8ZP_SCRATCH_REG
+		tay
+		pla
+		rts
+		.pend
+
 ; ----------- end optimized multiplications -----------
 
 
@@ -1301,6 +1347,33 @@ shift_left_w_3	.proc
 		jmp  shift_left_w_7._shift3
 		.pend
 
+
+shift_left_w	.proc
+		; -- variable number of shifts left
+		inx
+		ldy  P8ESTACK_LO,x
+		bne  _shift
+		rts
+_shift		asl  P8ESTACK_LO+1,x
+		rol  P8ESTACK_HI+1,x
+		dey
+		bne  _shift
+		rts
+		.pend
+
+shift_right_uw	.proc
+		; -- uword variable number of shifts right
+		inx
+		ldy  P8ESTACK_LO,x
+		bne  _shift
+		rts
+_shift		lsr  P8ESTACK_HI+1,x
+		ror  P8ESTACK_LO+1,x
+		dey
+		bne  _shift
+		rts
+		.pend
+
 shift_right_uw_7	.proc
 		lda  P8ESTACK_LO+1,x
 		sta  P8ZP_SCRATCH_B1
@@ -1431,6 +1504,21 @@ shift_right_w_3	.proc
 		.pend
 
 
+shift_right_w	.proc
+		; -- signed word variable number of shifts right
+		inx
+		ldy  P8ESTACK_LO,x
+		bne  _shift
+		rts
+_shift		lda  P8ESTACK_HI+1,x
+		asl  a
+		ror  P8ESTACK_HI+1,x
+		ror  P8ESTACK_LO+1,x
+		dey
+		bne  _shift
+		rts
+		.pend
+
 
 ; support for bit shifting that is too large to be unrolled:
 

compiler/res/prog8lib/math.p8

@@ -1,8 +1,6 @@
-; Prog8 internal Math library routines - always included by the compiler
+; Internal Math library routines - always included by the compiler
 ;
 ; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8
 
 math {
 	%asminclude "library:math.asm", ""

compiler/res/prog8lib/prog8_funcs.asm

@@ -1078,271 +1078,3 @@ _loop_hi	ldy  _index_first
 		.pend
 
 
-func_exit	.proc
-		; -- immediately exit the program with a return code in the A register
-		ldx  orig_stackpointer
-		txs
-		rts		; return to original caller
-		.pend
-
-
-func_read_flags_stack	.proc
-		; -- put the processor status register on the stack
-		php
-		pla
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-
-func_memset	.proc
-	; note: clobbers A,Y
-		txa
-		pha
-		lda  _arg_address
-		sta  P8ZP_SCRATCH_W1
-		lda  _arg_address+1
-		sta  P8ZP_SCRATCH_W1+1
-		ldx  _arg_numbytes
-		ldy  _arg_numbytes+1
-		lda  _arg_bytevalue
-		jsr  memset
-		pla
-		tax
-		rts
-_arg_address	.word  0
-_arg_numbytes	.word  0
-_arg_bytevalue	.byte  0
-		.pend
-
-
-func_memsetw	.proc
-	; note: clobbers A,Y
-		txa
-		pha
-		lda  _arg_address
-		sta  P8ZP_SCRATCH_W1
-		lda  _arg_address+1
-		sta  P8ZP_SCRATCH_W1+1
-		lda  _arg_numwords
-		sta  P8ZP_SCRATCH_W2
-		lda  _arg_numwords+1
-		sta  P8ZP_SCRATCH_W2+1
-		lda  _arg_wordvalue
-		ldy  _arg_wordvalue+1
-		jsr  memsetw
-		pla
-		tax
-		rts
-_arg_address	.word  0
-_arg_numwords	.word  0
-_arg_wordvalue	.word  0
-		.pend
-
-
-func_memcopy	.proc
-	; memcopy of any number of bytes, note: clobbers A,Y
-		stx  P8ZP_SCRATCH_REG
-		lda  _arg_from
-		sta  P8ZP_SCRATCH_W1
-		lda  _arg_from+1
-		sta  P8ZP_SCRATCH_W1+1
-		lda  _arg_to
-		sta  P8ZP_SCRATCH_W2
-		lda  _arg_to+1
-		sta  P8ZP_SCRATCH_W2+1
-
-		ldy  #0
-		ldx  _arg_numbytes+1
-		beq  _remain
--		lda  (P8ZP_SCRATCH_W1),y	; move a page at a time
-		sta  (P8ZP_SCRATCH_W2),y
-		iny
-		bne  -
-		inc  P8ZP_SCRATCH_W1+1
-		inc  P8ZP_SCRATCH_W2+1
-		dex
-		bne  -
-_remain		ldx  _arg_numbytes
-		beq  _done
--		lda (P8ZP_SCRATCH_W1),y		; move the remaining bytes
-		sta (P8ZP_SCRATCH_W2),y
-		iny
-		dex
-		bne  -
-
-_done		ldx  P8ZP_SCRATCH_REG
-		rts
-
-_arg_from	.word  0
-_arg_to		.word  0
-_arg_numbytes	.word  0
-		.pend
-
-
-func_memcopy255	.proc
-	; fast memcopy of up to 255 bytes, note: clobbers A,Y
-	;  note: also uses the _arg variables from regular func_memcopy
-		stx  P8ZP_SCRATCH_REG
-		lda  func_memcopy._arg_from
-		sta  P8ZP_SCRATCH_W1
-		lda  func_memcopy._arg_from+1
-		sta  P8ZP_SCRATCH_W1+1
-		lda  func_memcopy._arg_to
-		sta  P8ZP_SCRATCH_W2
-		lda  func_memcopy._arg_to+1
-		sta  P8ZP_SCRATCH_W2+1
-		ldx  func_memcopy._arg_numbytes
-		ldy  #0
--		lda  (P8ZP_SCRATCH_W1), y
-		sta  (P8ZP_SCRATCH_W2), y
-		iny
-		dex
-		bne  -
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-
-func_leftstr	.proc
-		; leftstr(source, target, length)
-		lda  _arg_source
-		ldy  _arg_source+1
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		lda  _arg_target
-		ldy  _arg_target+1
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		ldy  _arg_length
-		lda  #0
-		sta  (P8ZP_SCRATCH_W2),y
-		cpy  #0
-		bne  _loop
-		rts
-_loop		dey
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  (P8ZP_SCRATCH_W2),y
-		cpy  #0
-		bne  _loop
-+		rts
-
-_arg_source	.word  0
-_arg_target	.word  0
-_arg_length	.byte  0
-		.pend
-
-
-func_rightstr	.proc
-		; rightstr(source, target, length)
-		lda  _arg_source
-		ldy  _arg_source+1
-		jsr  func_strlen_into_A
-		sec
-		sbc  _arg_length
-		sta  P8ZP_SCRATCH_B1
-		lda  _arg_source
-		ldy  _arg_source+1
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		lda  _arg_target
-		ldy  _arg_target+1
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		ldy  #0
-		sty  P8ZP_SCRATCH_REG
--		ldy  P8ZP_SCRATCH_B1
-		lda  (P8ZP_SCRATCH_W1),y
-		inc  P8ZP_SCRATCH_B1
-		ldy  P8ZP_SCRATCH_REG
-		sta  (P8ZP_SCRATCH_W2),y
-		inc  P8ZP_SCRATCH_REG
-		cmp  #0
-		bne  -
-		rts
-
-_arg_source	.word  0
-_arg_target	.word  0
-_arg_length	.byte  0
-		.pend
-
-
-func_strlen_into_A		.proc
-	; -- put length of 0-terminated string in A/Y into A
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #0
--		lda  (P8ZP_SCRATCH_W1),y
-		beq  +
-		iny
-		bne  -
-+		tya
-		rts
-		.pend
-
-func_strlen_stack	.proc
-		jsr  func_strlen_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-
-func_substr	.proc
-		; substr(source, target, start, length)
-		lda  _arg_source
-		ldy  _arg_source+1
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		lda  _arg_target
-		ldy  _arg_target+1
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		ldy  _arg_length
-		lda  _arg_start
-		sta  P8ZP_SCRATCH_B1
-
-		; adjust src location
-		clc
-		lda  P8ZP_SCRATCH_W1
-		adc  P8ZP_SCRATCH_B1
-		sta  P8ZP_SCRATCH_W1
-		bcc  +
-		inc  P8ZP_SCRATCH_W1+1
-+		lda  #0
-		sta  (P8ZP_SCRATCH_W2),y
-		jmp  _startloop
--		lda  (P8ZP_SCRATCH_W1),y
-		sta  (P8ZP_SCRATCH_W2),y
-_startloop	dey
-		cpy  #$ff
-		bne  -
-		rts
-
-_arg_source	.word  0
-_arg_target	.word  0
-_arg_start	.byte  0
-_arg_length	.byte  0
-		.pend
-
-
-func_strcmp	.proc
-		; -- compare 2 strings -> A
-		lda  _arg_s2
-		ldy  _arg_s2+1
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		lda  _arg_s1
-		ldy  _arg_s1+1
-		jmp  strcmp_mem
-_arg_s1		.word  0
-_arg_s2		.word  0
-		.pend
-
-func_strcmp_stack	.proc
-		jsr	func_strcmp
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend

compiler/res/prog8lib/prog8_lib.asm

@@ -1,9 +1,7 @@
-; Prog8 internal library routines - always included by the compiler
+; Internal library routines - always included by the compiler
 ; Generic machine independent 6502 code.
 ;
 ; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8
 
 
 read_byte_from_address_on_stack	.proc
@@ -993,6 +991,7 @@ _arg_index	.byte  0
 strcpy		.proc
 		; copy a string (must be 0-terminated) from A/Y to (P8ZP_SCRATCH_W1)
 		; it is assumed the target string is large enough.
+		; returns the length of the string that was copied in Y.
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		ldy  #$ff
@@ -1020,33 +1019,33 @@ _arg_s2		.word  0
 strcmp_mem	.proc
 		; --   compares strings in s1 (AY) and s2 (P8ZP_SCRATCH_W2).
 		;      Returns -1,0,1 in A, depeding on the ordering. Clobbers Y.
-            sta  P8ZP_SCRATCH_W1
-            sty  P8ZP_SCRATCH_W1+1
-_loop       ldy  #0
-            lda  (P8ZP_SCRATCH_W1),y
-            bne  +
-            lda  (P8ZP_SCRATCH_W2),y
-            bne  _return_minusone
-            beq  _return
-+           lda  (P8ZP_SCRATCH_W2),y
-            sec
-            sbc  (P8ZP_SCRATCH_W1),y
-            bmi  _return_one
-            bne  _return_minusone
-            inc  P8ZP_SCRATCH_W1
-            bne  +
-            inc  P8ZP_SCRATCH_W1+1
-+           inc  P8ZP_SCRATCH_W2
-            bne  _loop
-            inc  P8ZP_SCRATCH_W2+1
-            bne  _loop
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+_loop		ldy  #0
+		lda  (P8ZP_SCRATCH_W1),y
+		bne  +
+		lda  (P8ZP_SCRATCH_W2),y
+		bne  _return_minusone
+		beq  _return
++		lda  (P8ZP_SCRATCH_W2),y
+		sec
+		sbc  (P8ZP_SCRATCH_W1),y
+		bmi  _return_one
+		bne  _return_minusone
+		inc  P8ZP_SCRATCH_W1
+		bne  +
+		inc  P8ZP_SCRATCH_W1+1
++		inc  P8ZP_SCRATCH_W2
+		bne  _loop
+		inc  P8ZP_SCRATCH_W2+1
+		bne  _loop
 _return_one
-            lda  #1
-_return     rts
+		lda  #1
+_return		rts
 _return_minusone
-            lda  #-1
-            rts
-            .pend
+		lda  #-1
+		rts
+		.pend
 
 
 sign_extend_stack_byte	.proc

compiler/res/prog8lib/prog8_lib.p8

@@ -1,10 +1,84 @@
-; Prog8 internal library routines - always included by the compiler
+; Internal library routines - always included by the compiler
 ;
 ; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8
 
 prog8_lib {
 	%asminclude "library:prog8_lib.asm", ""
 	%asminclude "library:prog8_funcs.asm", ""
+
+	uword @zp retval_interm_uw      ; to store intermediary expression results for return values (hopefully allocated on ZP to reduce code size)
+	word @zp retval_interm_w        ; to store intermediary expression results for return values (hopefully allocated on ZP to reduce code size)
+	ubyte @zp retval_interm_ub      ; to store intermediary expression results for return values (hopefully allocated on ZP to reduce code size)
+	byte @zp retval_interm_b        ; to store intermediary expression results for return values (hopefully allocated on ZP to reduce code size)
+
+	asmsub pattern_match(str string @AY, str pattern @R0) clobbers(Y) -> ubyte @A {
+		%asm {{
+; pattern matching of a string.
+; Input:  cx16.r0:  A NUL-terminated, <255-length pattern
+;              AY:  A NUL-terminated, <255-length string
+;
+; Output: A = 1 if the string matches the pattern, A = 0 if not.
+;
+; Notes:  Clobbers A, X, Y. Each * in the pattern uses 4 bytes of stack.
+;
+; see http://6502.org/source/strings/patmatch.htm
+
+str = P8ZP_SCRATCH_W1
+
+	stx  P8ZP_SCRATCH_REG
+	sta  str
+	sty  str+1
+	lda  cx16.r0
+	sta  modify_pattern1+1
+	sta  modify_pattern2+1
+	lda  cx16.r0+1
+	sta  modify_pattern1+2
+	sta  modify_pattern2+2
+	jsr  _match
+	lda  #0
+	adc  #0
+	ldx  P8ZP_SCRATCH_REG
+	rts
+
+
+_match
+	ldx #$00        ; x is an index in the pattern
+	ldy #$ff        ; y is an index in the string
+modify_pattern1
+next    lda $ffff,x   ; look at next pattern character    MODIFIED
+	cmp #'*'     ; is it a star?
+	beq star        ; yes, do the complicated stuff
+	iny             ; no, let's look at the string
+	cmp #'?'     ; is the pattern caracter a ques?
+	bne reg         ; no, it's a regular character
+	lda (str),y     ; yes, so it will match anything
+	beq fail        ;  except the end of string
+reg     cmp (str),y     ; are both characters the same?
+	bne fail        ; no, so no match
+	inx             ; yes, keep checking
+	cmp #0          ; are we at end of string?
+	bne next        ; not yet, loop
+found   rts             ; success, return with c=1
+
+star    inx             ; skip star in pattern
+modify_pattern2
+	cmp $ffff,x   	; string of stars equals one star	MODIFIED
+	beq star        ;  so skip them also
+stloop  txa             ; we first try to match with * = ""
+	pha             ;  and grow it by 1 character every
+	tya             ;  time we loop
+	pha             ; save x and y on stack
+	jsr next        ; recursive call
+	pla             ; restore x and y
+	tay
+	pla
+	tax
+	bcs found       ; we found a match, return with c=1
+	iny             ; no match yet, try to grow * string
+	lda (str),y     ; are we at the end of string?
+	bne stloop      ; not yet, add a character
+fail    clc             ; yes, no match found, return with c=0
+	rts
+		}}
+	}
 }

compiler/res/prog8lib/string.p8

@@ -0,0 +1,235 @@
+; 0-terminated string manipulation routines.
+;
+; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
+
+
+string {
+
+    asmsub length(uword string @AY) clobbers(A) -> ubyte @Y {
+        ; Returns the number of bytes in the string.
+        ; This value is determined during runtime and counts upto the first terminating 0 byte in the string,
+        ; regardless of the size of the string during compilation time. Don’t confuse this with len and sizeof!
+
+        %asm {{
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		ldy  #0
+-		lda  (P8ZP_SCRATCH_W1),y
+		beq  +
+		iny
+		bne  -
++		rts
+        }}
+    }
+
+    asmsub left(uword source @R0, ubyte length @A, uword target @R1) clobbers(A, Y) {
+        ; Copies the left side of the source string of the given length to target string.
+        ; It is assumed the target string buffer is large enough to contain the result.
+        ; Also, you have to make sure yourself that length is smaller or equal to the length of the source string.
+        ; Modifies in-place, doesn’t return a value (so can’t be used in an expression).
+        %asm {{
+                ; need to copy the the cx16 virtual registers to zeropage to be compatible with C64...
+		ldy  cx16.r0
+		sty  P8ZP_SCRATCH_W1
+		ldy  cx16.r0+1
+		sty  P8ZP_SCRATCH_W1+1
+		ldy  cx16.r1
+		sty  P8ZP_SCRATCH_W2
+		ldy  cx16.r1+1
+		sty  P8ZP_SCRATCH_W2+1
+		tay
+		lda  #0
+		sta  (P8ZP_SCRATCH_W2),y
+		cpy  #0
+		bne  _loop
+		rts
+_loop		dey
+		lda  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		cpy  #0
+		bne  _loop
++		rts
+        }}
+;                asmgen.out("  jsr  prog8_lib.func_leftstr")
+    }
+
+    asmsub right(uword source @R0, ubyte length @A, uword target @R1) clobbers(A,Y) {
+        ; Copies the right side of the source string of the given length to target string.
+        ; It is assumed the target string buffer is large enough to contain the result.
+        ; Also, you have to make sure yourself that length is smaller or equal to the length of the source string.
+        ; Modifies in-place, doesn’t return a value (so can’t be used in an expression).
+        %asm {{
+                ; need to copy the the cx16 virtual registers to zeropage to be compatible with C64...
+                sta  P8ZP_SCRATCH_B1
+                lda  cx16.r0
+                ldy  cx16.r0+1
+                jsr  string.length
+                tya
+                sec
+                sbc  P8ZP_SCRATCH_B1
+                clc
+                adc  cx16.r0
+		sta  P8ZP_SCRATCH_W1
+		lda  cx16.r0+1
+		adc  #0
+		sta  P8ZP_SCRATCH_W1+1
+		ldy  cx16.r1
+		sty  P8ZP_SCRATCH_W2
+		ldy  cx16.r1+1
+		sty  P8ZP_SCRATCH_W2+1
+		ldy  P8ZP_SCRATCH_B1
+		lda  #0
+		sta  (P8ZP_SCRATCH_W2),y
+		cpy  #0
+		bne  _loop
+		rts
+_loop		dey
+		lda  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		cpy  #0
+		bne  _loop
++		rts
+        }}
+    }
+
+    asmsub slice(uword source @R0, ubyte start @A, ubyte length @Y, uword target @R1) clobbers(A, Y) {
+        ; Copies a segment from the source string, starting at the given index,
+        ;  and of the given length to target string.
+        ; It is assumed the target string buffer is large enough to contain the result.
+        ; Also, you have to make sure yourself that start and length are within bounds of the strings.
+        ; Modifies in-place, doesn’t return a value (so can’t be used in an expression).
+        %asm {{
+                ; need to copy the the cx16 virtual registers to zeropage to be compatible with C64...
+		; substr(source, target, start, length)
+		sta  P8ZP_SCRATCH_B1
+		lda  cx16.r0
+		sta  P8ZP_SCRATCH_W1
+		lda  cx16.r0+1
+		sta  P8ZP_SCRATCH_W1+1
+		lda  cx16.r1
+		sta  P8ZP_SCRATCH_W2
+		lda  cx16.r1+1
+		sta  P8ZP_SCRATCH_W2+1
+
+		; adjust src location
+		clc
+		lda  P8ZP_SCRATCH_W1
+		adc  P8ZP_SCRATCH_B1
+		sta  P8ZP_SCRATCH_W1
+		bcc  +
+		inc  P8ZP_SCRATCH_W1+1
++		lda  #0
+		sta  (P8ZP_SCRATCH_W2),y
+		beq  _startloop
+-		lda  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+_startloop	dey
+		cpy  #$ff
+		bne  -
+		rts
+        }}
+    }
+
+    asmsub find(uword string @R0, ubyte character @A) -> uword @AY {
+        ; Locates the first position of the given character in the string,
+        ;  returns the string starting with this character or $0000 if the character is not found.
+        %asm {{
+                ; need to copy the the cx16 virtual registers to zeropage to be compatible with C64...
+                sta  P8ZP_SCRATCH_B1
+		lda  cx16.r0
+		ldy  cx16.r0+1
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		ldy  #0
+-		lda  (P8ZP_SCRATCH_W1),y
+		beq  _notfound
+		cmp  P8ZP_SCRATCH_B1
+		beq  _found
+		iny
+		bne  -
+_notfound	lda  #0
+		ldy  #0
+		rts
+_found		sty  P8ZP_SCRATCH_B1
+		ldy  P8ZP_SCRATCH_W1+1
+		lda  P8ZP_SCRATCH_W1
+		clc
+		adc  P8ZP_SCRATCH_B1
+		bcc  +
+		iny
++		rts
+
+        }}
+    }
+
+    asmsub copy(uword source @R0, uword target @AY) clobbers(A) -> ubyte @Y {
+        ; Copy a string to another, overwriting that one.
+        ; Returns the length of the string that was copied.
+        ; Often you don’t have to call this explicitly and can just write string1 = string2
+        ; but this function is useful if you’re dealing with addresses for instance.
+        %asm {{
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		lda  cx16.r0
+		ldy  cx16.r0+1
+		jmp  prog8_lib.strcpy
+        }}
+    }
+
+    asmsub compare(uword string1 @R0, uword string2 @AY) clobbers(Y) -> byte @A {
+        ; Compares two strings for sorting.
+        ; Returns -1 (255), 0 or 1 depeding on wether string1 sorts before, equal or after string2.
+        ; Note that you can also directly compare strings and string values with eachother using
+        ; comparison operators ==, < etcetera (it will use strcmp for you under water automatically).
+        %asm {{
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		lda  cx16.r0
+		ldy  cx16.r0+1
+		jmp  prog8_lib.strcmp_mem
+        }}
+    }
+
+    asmsub lower(uword st @AY) {
+        ; Lowercases the petscii string in-place.
+        ; (for efficiency, non-letter characters > 128 will also not be left intact,
+        ;  but regular text doesn't usually contain those characters anyway.)
+        %asm {{
+            sta  P8ZP_SCRATCH_W1
+            sty  P8ZP_SCRATCH_W1+1
+            ldy  #0
+-           lda  (P8ZP_SCRATCH_W1),y
+            beq  _done
+            and  #$7f
+            cmp  #97
+            bcc  +
+            cmp  #123
+            bcs  +
+            and  #%11011111
++           sta  (P8ZP_SCRATCH_W1),y
+            iny
+            bne  -
+_done       rts
+        }}
+    }
+
+    asmsub upper(uword st @AY) {
+        ; Uppercases the petscii string in-place.
+        %asm {{
+            sta  P8ZP_SCRATCH_W1
+            sty  P8ZP_SCRATCH_W1+1
+            ldy  #0
+-           lda  (P8ZP_SCRATCH_W1),y
+            beq  _done
+            cmp  #65
+            bcc  +
+            cmp  #91
+            bcs  +
+            ora  #%00100000
++           sta  (P8ZP_SCRATCH_W1),y
+            iny
+            bne  -
+_done       rts
+        }}
+    }
+}

compiler/res/prog8lib/test_stack.p8

@@ -1,48 +1,50 @@
+; utility debug code to print the X (evalstack) and SP (cpu stack) registers.
+
 %import textio
 
 test_stack {
 
     asmsub test() {
         %asm {{
-            stx  _saveX
-            lda  #13
-            jsr  txt.chrout
-            lda  #'-'
-            ldy  #12
--           jsr  txt.chrout
-            dey
-            bne  -
-            lda  #13
-            jsr  txt.chrout
-            lda  #'x'
-            jsr  txt.chrout
-            lda  #'='
-            jsr  txt.chrout
-            lda  _saveX
-            jsr  txt.print_ub
-            lda  #' '
-            jsr  txt.chrout
-            lda  #'s'
-            jsr  txt.chrout
-            lda  #'p'
-            jsr  txt.chrout
-            lda  #'='
-            jsr  txt.chrout
-            tsx
-            txa
-            jsr  txt.print_ub
-            lda  #13
-            jsr  txt.chrout
-            lda  #'-'
-            ldy  #12
--           jsr  txt.chrout
-            dey
-            bne  -
-            lda  #13
-            jsr  txt.chrout
-            ldx  _saveX
-            rts
-_saveX   .byte 0
+	stx  _saveX
+	lda  #13
+	jsr  txt.chrout
+	lda  #'-'
+	ldy  #12
+-	jsr  txt.chrout
+	dey
+	bne  -
+	lda  #13
+	jsr  txt.chrout
+	lda  #'x'
+	jsr  txt.chrout
+	lda  #'='
+	jsr  txt.chrout
+	lda  _saveX
+	jsr  txt.print_ub
+	lda  #' '
+	jsr  txt.chrout
+	lda  #'s'
+	jsr  txt.chrout
+	lda  #'p'
+	jsr  txt.chrout
+	lda  #'='
+	jsr  txt.chrout
+	tsx
+	txa
+	jsr  txt.print_ub
+	lda  #13
+	jsr  txt.chrout
+	lda  #'-'
+	ldy  #12
+-	jsr  txt.chrout
+	dey
+	bne  -
+	lda  #13
+	jsr  txt.chrout
+	ldx  _saveX
+	rts
+_saveX	.byte 0
         }}
     }
 }

compiler/res/version.txt

@@ -1 +1 @@
-5.2
+6.0-BETA

compiler/src/prog8/CompilerMain.kt

@@ -32,20 +32,20 @@ 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 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 slowCodegenWarnings by cli.flagArgument("-slowwarn", "show debug warnings about slow/problematic assembly code generation")
-    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)
+    val cli = ArgParser("prog8compiler")
+    val startEmulator by cli.option(ArgType.Boolean, shortName="emu", description = "auto-start emulator after successful compilation")
+    val outputDir by cli.option(ArgType.String, shortName = "out", description = "directory for output files instead of current directory").default(".")
+    val dontWriteAssembly by cli.option(ArgType.Boolean, shortName = "noasm", description="don't create assembly code")
+    val dontOptimize by cli.option(ArgType.Boolean, shortName = "noopt", description = "don't perform any optimizations")
+    val watchMode by cli.option(ArgType.Boolean, shortName = "watch", description = "continuous compilation mode (watches for file changes), greatly increases compilation speed")
+    val slowCodegenWarnings by cli.option(ArgType.Boolean, shortName = "slowwarn", description="show debug warnings about slow/problematic assembly code generation")
+    val compilationTarget by cli.option(ArgType.String, shortName = "target", description = "target output of the compiler, currently '${C64Target.name}' and '${Cx16Target.name}' available").default(C64Target.name)
+    val moduleFiles by cli.argument(ArgType.String, fullName = "modules", description = "main module file(s) to compile").multiple(999)
 
     try {
         cli.parse(args)
-    } catch (e: Exception) {
+    } catch (e: IllegalStateException) {
+        System.err.println(e.message)
         exitProcess(1)
     }
 
@@ -55,19 +55,22 @@ private fun compileMain(args: Array<String>) {
         exitProcess(1)
     }
 
-    if(watchMode) {
+    if(watchMode==true) {
         val watchservice = FileSystems.getDefault().newWatchService()
+        val allImportedFiles = mutableSetOf<Path>()
 
         while(true) {
             println("Continuous watch mode active. Modules: $moduleFiles")
             val results = mutableListOf<CompilationResult>()
             for(filepathRaw in moduleFiles) {
                 val filepath = pathFrom(filepathRaw).normalize()
-                val compilationResult = compileProgram(filepath, !dontOptimize, !dontWriteAssembly, slowCodegenWarnings, compilationTarget, outputPath)
+                val compilationResult = compileProgram(filepath, dontOptimize!=true, dontWriteAssembly!=true, slowCodegenWarnings==true, compilationTarget, outputPath)
                 results.add(compilationResult)
             }
 
-            val allImportedFiles = results.flatMap { it.importedFiles }
+            val allNewlyImportedFiles = results.flatMap { it.importedFiles }
+            allImportedFiles.addAll(allNewlyImportedFiles)
+
             println("Imported files (now watching:)")
             for (importedFile in allImportedFiles) {
                 print("  ")
@@ -98,7 +101,7 @@ private fun compileMain(args: Array<String>) {
             val filepath = pathFrom(filepathRaw).normalize()
             val compilationResult: CompilationResult
             try {
-                compilationResult = compileProgram(filepath, !dontOptimize, !dontWriteAssembly, slowCodegenWarnings, compilationTarget, outputPath)
+                compilationResult = compileProgram(filepath, dontOptimize!=true, dontWriteAssembly!=true, slowCodegenWarnings==true, compilationTarget, outputPath)
                 if(!compilationResult.success)
                     exitProcess(1)
             } catch (x: ParsingFailedError) {
@@ -107,10 +110,10 @@ private fun compileMain(args: Array<String>) {
                 exitProcess(1)
             }
 
-            if (startEmulator) {
+            if (startEmulator==true) {
                 if (compilationResult.programName.isEmpty())
                     println("\nCan't start emulator because no program was assembled.")
-                else if(startEmulator) {
+                else {
                     CompilationTarget.instance.machine.launchEmulator(compilationResult.programName)
                 }
             }

compiler/src/prog8/ast/AstToSourceCode.kt

@@ -172,8 +172,19 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
             output(") ")
         }
         if(subroutine.returntypes.any()) {
-            val rt = subroutine.returntypes.single()
-            output("-> ${datatypeString(rt)} ")
+            if(subroutine.asmReturnvaluesRegisters.isNotEmpty()) {
+                val rts = subroutine.returntypes.zip(subroutine.asmReturnvaluesRegisters).joinToString(", ") {
+                    val dtstr = datatypeString(it.first)
+                    if(it.second.registerOrPair!=null)
+                        "$dtstr @${it.second.registerOrPair}"
+                    else
+                        "$dtstr @${it.second.statusflag}"
+                }
+                output("-> $rts ")
+            } else {
+                val rts = subroutine.returntypes.joinToString(", ") { datatypeString(it) }
+                output("-> $rts ")
+            }
         }
         if(subroutine.asmAddress!=null)
             outputln("= ${subroutine.asmAddress.toHex()}")

compiler/src/prog8/ast/AstToplevel.kt

@@ -175,6 +175,7 @@ interface INameScope {
         }
     }
 
+    fun containsDefinedVariables() = statements.any { it is VarDecl && (it !is ParameterVarDecl) }
     fun containsCodeOrVars() = statements.any { it !is Directive || it.directive == "%asminclude" || it.directive == "%asm"}
     fun containsNoCodeNorVars() = !containsCodeOrVars()
 

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

@@ -225,11 +225,12 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
 }
 
 private fun prog8Parser.AsmsubroutineContext.toAst(): Subroutine {
+    val inline = this.inline()!=null
     val subdecl = asmsub_decl().toAst()
     val statements = statement_block()?.toAst() ?: mutableListOf()
     return Subroutine(subdecl.name, subdecl.parameters, subdecl.returntypes,
             subdecl.asmParameterRegisters, subdecl.asmReturnvaluesRegisters,
-            subdecl.asmClobbers, null, true, statements, toPosition())
+            subdecl.asmClobbers, null, true, inline, statements, toPosition())
 }
 
 private fun prog8Parser.RomsubroutineContext.toAst(): Subroutine {
@@ -237,7 +238,8 @@ private fun prog8Parser.RomsubroutineContext.toAst(): Subroutine {
     val address = integerliteral().toAst().number.toInt()
     return Subroutine(subdecl.name, subdecl.parameters, subdecl.returntypes,
             subdecl.asmParameterRegisters, subdecl.asmReturnvaluesRegisters,
-            subdecl.asmClobbers, address, true, mutableListOf(), toPosition())
+            subdecl.asmClobbers, address, true, inline = false, statements = mutableListOf(), position = toPosition()
+    )
 }
 
 private class AsmsubDecl(val name: String,
@@ -272,13 +274,13 @@ private class AsmSubroutineReturn(val type: DataType,
 
 private fun prog8Parser.Asmsub_returnsContext.toAst(): List<AsmSubroutineReturn>
         = asmsub_return().map {
-            val register = it.identifier()?.toAst()
+            val register = it.register().text
             var registerorpair: RegisterOrPair? = null
             var statusregister: Statusflag? = null
             if(register!=null) {
-                when (val name = register.nameInSource.single()) {
-                    in RegisterOrPair.names -> registerorpair = RegisterOrPair.valueOf(name)
-                    in Statusflag.names -> statusregister = Statusflag.valueOf(name)
+                when (register) {
+                    in RegisterOrPair.names -> registerorpair = RegisterOrPair.valueOf(register)
+                    in Statusflag.names -> statusregister = Statusflag.valueOf(register)
                     else -> throw FatalAstException("invalid register or status flag in $it")
                 }
             }
@@ -293,14 +295,14 @@ private fun prog8Parser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParamete
         = asmsub_param().map {
     val vardecl = it.vardecl()
     val datatype = vardecl.datatype()?.toAst() ?: DataType.STRUCT
-    val register = it.identifier()?.toAst()
+    val register = it.register().text
     var registerorpair: RegisterOrPair? = null
     var statusregister: Statusflag? = null
     if(register!=null) {
-        when (val name = register.nameInSource.single()) {
-            in RegisterOrPair.names -> registerorpair = RegisterOrPair.valueOf(name)
-            in Statusflag.names -> statusregister = Statusflag.valueOf(name)
-            else -> throw FatalAstException("invalid register or status flag '$name'")
+        when (register) {
+            in RegisterOrPair.names -> registerorpair = RegisterOrPair.valueOf(register)
+            in Statusflag.names -> statusregister = Statusflag.valueOf(register)
+            else -> throw FatalAstException("invalid register or status flag '$register'")
         }
     }
     AsmSubroutineParameter(vardecl.varname.text, datatype, registerorpair, statusregister, toPosition())
@@ -341,11 +343,13 @@ private fun prog8Parser.LabeldefContext.toAst(): Statement =
 
 private fun prog8Parser.SubroutineContext.toAst() : Subroutine {
     // non-asm subroutine
+    val inline = inline()!=null
     val returntypes = sub_return_part()?.toAst() ?: emptyList()
     return Subroutine(identifier().text,
             sub_params()?.toAst() ?: emptyList(),
             returntypes,
             statement_block()?.toAst() ?: mutableListOf(),
+            inline,
             toPosition())
 }
 
@@ -371,7 +375,7 @@ private fun prog8Parser.Assign_targetContext.toAst() : AssignTarget {
 }
 
 private fun prog8Parser.ClobberContext.toAst() : Set<CpuRegister> {
-    val names = this.identifier().map { it.toAst().nameInSource.single() }
+    val names = this.cpuregister().map { it.text }
     return names.map { CpuRegister.valueOf(it) }.toSet()
 }
 
@@ -623,7 +627,7 @@ private fun prog8Parser.When_choiceContext.toAst(): WhenChoice {
     if(stmt!=null)
         stmtBlock.add(stmt)
     val scope = AnonymousScope(stmtBlock, toPosition())
-    return WhenChoice(values, scope, toPosition())
+    return WhenChoice(values?.toMutableList(), scope, toPosition())
 }
 
 private fun prog8Parser.VardeclContext.toAst(): VarDecl {

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

@@ -30,8 +30,8 @@ enum class DataType {
                 UWORD -> targetType in setOf(UWORD, FLOAT)
                 WORD -> targetType in setOf(WORD, FLOAT)
                 FLOAT -> targetType == FLOAT
-                STR -> targetType == STR || targetType == UWORD
-                in ArrayDatatypes -> targetType == this || targetType == UWORD
+                STR -> targetType == STR
+                in ArrayDatatypes -> targetType == this
                 else -> false
             }
 
@@ -82,7 +82,10 @@ enum class RegisterOrPair {
     AY,
     XY,
     FAC1,
-    FAC2;
+    FAC2,
+    // cx16 virtual registers:
+    R0, R1, R2, R3, R4, R5, R6, R7,
+    R8, R9, R10, R11, R12, R13, R14, R15;
 
     companion object {
         val names by lazy { values().map { it.toString()} }
@@ -92,9 +95,9 @@ enum class RegisterOrPair {
 
 enum class Statusflag {
     Pc,
-    Pz,
+    Pz,     // don't use
     Pv,
-    Pn;
+    Pn;     // don't use
 
     companion object {
         val names by lazy { values().map { it.toString()} }
@@ -127,6 +130,7 @@ val WordDatatypes = setOf(DataType.UWORD, DataType.WORD)
 val IntegerDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
 val NumericDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
 val ArrayDatatypes = setOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F)
+val StringlyDatatypes = setOf(DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B, DataType.UWORD)
 val IterableDatatypes = setOf(
         DataType.STR,
         DataType.ARRAY_UB, DataType.ARRAY_B,
@@ -148,6 +152,11 @@ val ElementArrayTypes = mapOf(
         DataType.UWORD to DataType.ARRAY_UW,
         DataType.FLOAT to DataType.ARRAY_F
 )
+val Cx16VirtualRegisters = listOf(RegisterOrPair.R0, RegisterOrPair.R1, RegisterOrPair.R2, RegisterOrPair.R3,
+    RegisterOrPair.R4, RegisterOrPair.R5, RegisterOrPair.R6, RegisterOrPair.R7,
+    RegisterOrPair.R8, RegisterOrPair.R9, RegisterOrPair.R10, RegisterOrPair.R11,
+    RegisterOrPair.R12, RegisterOrPair.R13, RegisterOrPair.R14, RegisterOrPair.R15)
+
 
 // find the parent node of a specific type or interface
 // (useful to figure out in what namespace/block something is defined, etc)

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

@@ -11,6 +11,7 @@ import prog8.compiler.target.C64Target
 import prog8.compiler.target.CompilationTarget
 import prog8.compiler.target.Cx16Target
 import prog8.functions.BuiltinFunctions
+import prog8.functions.builtinFunctionReturnType
 import java.io.File
 
 internal class AstChecker(private val program: Program,
@@ -34,24 +35,6 @@ internal class AstChecker(private val program: Program,
                 if (startSub.parameters.isNotEmpty() || startSub.returntypes.isNotEmpty())
                     errors.err("program entrypoint subroutine can't have parameters and/or return values", startSub.position)
             }
-
-            // the main module cannot contain 'regular' statements (they will never be executed!)
-            for (statement in mainBlock.statements) {
-                val ok = when (statement) {
-                    is Block -> true
-                    is Directive -> true
-                    is Label -> true
-                    is VarDecl -> true
-                    is InlineAssembly -> true
-                    is INameScope -> true
-                    is NopStatement -> true
-                    else -> false
-                }
-                if (!ok) {
-                    errors.err("main block contains regular statements, this is not allowed (they'll never get executed). Use subroutines.", statement.position)
-                    break
-                }
-            }
         }
 
         // there can be an optional single 'irq' block with a 'irq' subroutine in it,
@@ -185,6 +168,23 @@ internal class AstChecker(private val program: Program,
             errors.err("block memory address must be valid integer 0..\$ffff", block.position)
         }
 
+        for (statement in block.statements) {
+            val ok = when (statement) {
+                is Block,
+                is Directive,
+                is Label,
+                is VarDecl,
+                is InlineAssembly,
+                is INameScope,
+                is NopStatement -> true
+                else -> false
+            }
+            if (!ok) {
+                errors.err("statement occurs in a block, where it will never be executed. Use it in a subroutine instead.", statement.position)
+                break
+            }
+        }
+
         super.visit(block)
     }
 
@@ -202,10 +202,20 @@ internal class AstChecker(private val program: Program,
         if(subroutine.name in BuiltinFunctions)
             err("cannot redefine a built-in function")
 
+        if(subroutine.parameters.size>16)
+            err("subroutines are limited to 16 parameters")
+
         val uniqueNames = subroutine.parameters.asSequence().map { it.name }.toSet()
         if(uniqueNames.size!=subroutine.parameters.size)
             err("parameter names must be unique")
 
+        if(subroutine.inline) {
+            if (subroutine.containsDefinedVariables())
+                err("can't inline a subroutine that defines variables")
+            if (!subroutine.isAsmSubroutine && subroutine.parameters.isNotEmpty())
+                err("can't inline a non-asm subroutine that has parameters")
+        }
+
         super.visit(subroutine)
 
         // user-defined subroutines can only have zero or one return type
@@ -219,8 +229,8 @@ internal class AstChecker(private val program: Program,
             if (subroutine.amountOfRtsInAsm() == 0) {
                 if (subroutine.returntypes.isNotEmpty()) {
                     // for asm subroutines with an address, no statement check is possible.
-                    if (subroutine.asmAddress == null)
-                        err("subroutine has result value(s) and thus must have at least one 'return' or 'goto' in it (or 'rts' / 'jmp' in case of %asm)")
+                    if (subroutine.asmAddress == null && !subroutine.inline)
+                        err("non-inline subroutine has result value(s) and thus must have at least one 'return' or 'goto' in it (or 'rts' / 'jmp' in case of %asm)")
                 }
             }
         }
@@ -289,6 +299,22 @@ internal class AstChecker(private val program: Program,
                             regCounts[CpuRegister.Y]=regCounts.getValue(CpuRegister.Y)+1
                         }
                         RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> { /* no sensible way to count this */ }
+                        RegisterOrPair.R0,
+                        RegisterOrPair.R1,
+                        RegisterOrPair.R2,
+                        RegisterOrPair.R3,
+                        RegisterOrPair.R4,
+                        RegisterOrPair.R5,
+                        RegisterOrPair.R6,
+                        RegisterOrPair.R7,
+                        RegisterOrPair.R8,
+                        RegisterOrPair.R9,
+                        RegisterOrPair.R10,
+                        RegisterOrPair.R11,
+                        RegisterOrPair.R12,
+                        RegisterOrPair.R13,
+                        RegisterOrPair.R14,
+                        RegisterOrPair.R15 -> { /* no sensible way to count this */ }
                         null ->
                             if(p.statusflag!=null)
                                 statusflagCounts[p.statusflag] = statusflagCounts.getValue(p.statusflag) + 1
@@ -341,6 +367,13 @@ internal class AstChecker(private val program: Program,
         super.visit(whileLoop)
     }
 
+    override fun visit(repeatLoop: RepeatLoop) {
+        val iterations = repeatLoop.iterations?.constValue(program)
+        if(iterations != null && iterations.number.toInt() > 65535)
+            errors.err("repeat cannot go over 65535 iterations", iterations.position)
+        super.visit(repeatLoop)
+    }
+
     override fun visit(assignment: Assignment) {
         if(assignment.value is FunctionCall) {
             val stmt = (assignment.value as FunctionCall).target.targetStatement(program.namespace)
@@ -384,7 +417,7 @@ internal class AstChecker(private val program: Program,
         if(valueDt.isKnown && !(valueDt isAssignableTo targetDt)) {
             if(targetDt.typeOrElse(DataType.STRUCT) in IterableDatatypes)
                 errors.err("cannot assign value to string or array", assignment.value.position)
-            else
+            else if(!(valueDt.istype(DataType.STR) && targetDt.istype(DataType.UWORD)))
                 errors.err("value's type doesn't match target", assignment.value.position)
         }
 
@@ -455,15 +488,12 @@ internal class AstChecker(private val program: Program,
 
     override fun visit(addressOf: AddressOf) {
         val variable=addressOf.identifier.targetVarDecl(program.namespace)
-        if(variable==null)
-            errors.err("pointer-of operand must be the name of a heap variable", addressOf.position)
-        else {
-            if(variable.datatype !in ArrayDatatypes
-                    && variable.type!=VarDeclType.MEMORY
-                    && variable.struct == null
-                    && variable.datatype != DataType.STR && variable.datatype!=DataType.STRUCT)
+        if(variable!=null
+            && variable.datatype !in ArrayDatatypes
+            && variable.type!=VarDeclType.MEMORY
+            && variable.struct == null
+            && variable.datatype != DataType.STR && variable.datatype!=DataType.STRUCT)
                 errors.err("invalid pointer-of operand type", addressOf.position)
-        }
         super.visit(addressOf)
     }
 
@@ -585,7 +615,7 @@ internal class AstChecker(private val program: Program,
                         err("memory address must be valid integer 0..\$ffff", decl.value?.position)
                     }
                 } else {
-                    err("value of memory mapped variable can only be a number, perhaps you meant to use an address pointer type instead?", decl.value?.position)
+                    err("value of memory mapped variable can only be a fixed number, perhaps you meant to use an address pointer type instead?", decl.value?.position)
                 }
             }
         }
@@ -604,23 +634,28 @@ internal class AstChecker(private val program: Program,
             }
         }
 
-        // array length limits
+        // array length limits and constant lenghts
         if(decl.isArray) {
-            val length = decl.arraysize!!.constIndex() ?: 1
-            when (decl.datatype) {
-                DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B -> {
-                    if(length==0 || length>256)
-                        err("string and byte array length must be 1-256")
+            val length = decl.arraysize!!.constIndex()
+            if(length==null)
+                err("array length must be a constant")
+            else {
+                when (decl.datatype) {
+                    DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                        if (length == 0 || length > 256)
+                            err("string and byte array length must be 1-256")
+                    }
+                    DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                        if (length == 0 || length > 128)
+                            err("word array length must be 1-128")
+                    }
+                    DataType.ARRAY_F -> {
+                        if (length == 0 || length > 51)
+                            err("float array length must be 1-51")
+                    }
+                    else -> {
+                    }
                 }
-                DataType.ARRAY_UW, DataType.ARRAY_W -> {
-                    if(length==0 || length>128)
-                        err("word array length must be 1-128")
-                }
-                DataType.ARRAY_F -> {
-                    if(length==0 || length>51)
-                        err("float array length must be 1-51")
-                }
-                else -> {}
             }
         }
 
@@ -844,6 +879,10 @@ internal class AstChecker(private val program: Program,
     override fun visit(typecast: TypecastExpression) {
         if(typecast.type in IterableDatatypes)
             errors.err("cannot type cast to string or array type", typecast.position)
+
+        if(!typecast.expression.inferType(program).isKnown)
+            errors.err("this expression doesn't return a value", typecast.expression.position)
+
         super.visit(typecast)
     }
 
@@ -929,11 +968,19 @@ internal class AstChecker(private val program: Program,
         val targetStatement = checkFunctionOrLabelExists(functionCallStatement.target, functionCallStatement)
         if(targetStatement!=null)
             checkFunctionCall(targetStatement, functionCallStatement.args, functionCallStatement.position)
-        if(!functionCallStatement.void && targetStatement is Subroutine && targetStatement.returntypes.isNotEmpty()) {
-            if(targetStatement.returntypes.size==1)
-                errors.warn("result value of subroutine call is discarded (use void?)", functionCallStatement.position)
-            else
-                errors.warn("result values of subroutine call are discarded (use void?)", functionCallStatement.position)
+        if (!functionCallStatement.void) {
+            // check for unused return values
+            if (targetStatement is Subroutine && targetStatement.returntypes.isNotEmpty()) {
+                if(targetStatement.returntypes.size==1)
+                    errors.warn("result value of subroutine call is discarded (use void?)", functionCallStatement.position)
+                else
+                    errors.warn("result values of subroutine call are discarded (use void?)", functionCallStatement.position)
+            }
+            else if(targetStatement is BuiltinFunctionStatementPlaceholder) {
+                val rt = builtinFunctionReturnType(targetStatement.name, functionCallStatement.args, program)
+                if(rt.isKnown)
+                    errors.warn("result value of a function call is discarded (use void?)", functionCallStatement.position)
+            }
         }
 
         if(functionCallStatement.target.nameInSource.last() == "sort") {
@@ -986,8 +1033,6 @@ internal class AstChecker(private val program: Program,
                 }
             }
         } else if(target is Subroutine) {
-            if(target.regXasResult())
-                errors.warn("subroutine call return value in X register is discarded and replaced by 0", position)
             if(target.isAsmSubroutine) {
                 for (arg in args.zip(target.parameters)) {
                     val argIDt = arg.first.inferType(program)

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

@@ -31,6 +31,13 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
         else
             blocks[block.name] = block
 
+        if(!block.isInLibrary) {
+            val libraries = program.modules.filter { it.isLibraryModule }
+            val libraryBlockNames = libraries.flatMap { it.statements.filterIsInstance<Block>().map { b -> b.name } }
+            if(block.name in libraryBlockNames)
+                errors.err("block is already defined in an included library module", block.position)
+        }
+
         super.visit(block)
     }
 
@@ -112,9 +119,12 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
                 val labelOrVar = subroutine.getLabelOrVariable(name)
                 if(labelOrVar!=null && labelOrVar.position != subroutine.position)
                     nameError(name, labelOrVar.position, subroutine)
-                val sub = subroutine.statements.singleOrNull { it is Subroutine && it.name==name}
+                val sub = subroutine.statements.firstOrNull { it is Subroutine && it.name==name}
                 if(sub!=null)
-                    nameError(name, sub.position, subroutine)
+                    nameError(name, subroutine.position, sub)
+                val block = program.allBlocks().firstOrNull { it.name==name }
+                if(block!=null)
+                    nameError(name, subroutine.position, block)
             }
 
             if(subroutine.isAsmSubroutine && subroutine.statements.any{it !is InlineAssembly}) {

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

@@ -4,6 +4,7 @@ import prog8.ast.*
 import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
+import prog8.functions.BuiltinFunctions
 
 
 internal class StatementReorderer(val program: Program, val errors: ErrorReporter) : AstWalker() {
@@ -68,6 +69,14 @@ internal class StatementReorderer(val program: Program, val errors: ErrorReporte
                 )
             }
         }
+
+        val subs = subroutine.statements.filterIsInstance<Subroutine>()
+        if(subs.isNotEmpty()) {
+            // all subroutines defined within this subroutine are moved to the end
+            return subs.map { IAstModification.Remove(it, subroutine) } +
+                    subs.map { IAstModification.InsertLast(it, subroutine) }
+        }
+
         return noModifications
     }
 
@@ -91,6 +100,55 @@ internal class StatementReorderer(val program: Program, val errors: ErrorReporte
         }
     }
 
+    override fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
+        // when using a simple bit shift and assigning it to a variable of a different type,
+        // try to make the bit shifting 'wide enough' to fall into the variable's type.
+        // with this, for instance, uword x = 1 << 10  will result in 1024 rather than 0 (the ubyte result).
+        if(expr.operator=="<<" || expr.operator==">>") {
+            val leftDt = expr.left.inferType(program)
+            when (parent) {
+                is Assignment -> {
+                    val targetDt = parent.target.inferType(program)
+                    if(leftDt != targetDt) {
+                        val cast = TypecastExpression(expr.left, targetDt.typeOrElse(DataType.STRUCT), true, parent.position)
+                        return listOf(IAstModification.ReplaceNode(expr.left, cast, expr))
+                    }
+                }
+                is VarDecl -> {
+                    if(!leftDt.istype(parent.datatype)) {
+                        val cast = TypecastExpression(expr.left, parent.datatype, true, parent.position)
+                        return listOf(IAstModification.ReplaceNode(expr.left, cast, expr))
+                    }
+                }
+                is IFunctionCall -> {
+                    val argnum = parent.args.indexOf(expr)
+                    when (val callee = parent.target.targetStatement(program.namespace)) {
+                        is Subroutine -> {
+                            val paramType = callee.parameters[argnum].type
+                            if(leftDt isAssignableTo paramType) {
+                                val cast = TypecastExpression(expr.left, paramType, true, parent.position)
+                                return listOf(IAstModification.ReplaceNode(expr.left, cast, expr))
+                            }
+                        }
+                        is BuiltinFunctionStatementPlaceholder -> {
+                            val func = BuiltinFunctions.getValue(callee.name)
+                            val paramTypes = func.parameters[argnum].possibleDatatypes
+                            for(type in paramTypes) {
+                                if(leftDt isAssignableTo type) {
+                                    val cast = TypecastExpression(expr.left, type, true, parent.position)
+                                    return listOf(IAstModification.ReplaceNode(expr.left, cast, expr))
+                                }
+                            }
+                        }
+                        else -> throw FatalAstException("weird callee")
+                    }
+                }
+                else -> return noModifications
+            }
+        }
+        return noModifications
+    }
+
     private fun getAutoIndexerVarFor(expr: ArrayIndexedExpression): MutableList<IAstModification> {
         val modifications = mutableListOf<IAstModification>()
         val subroutine = expr.definingSubroutine()!!
@@ -98,28 +156,22 @@ internal class StatementReorderer(val program: Program, val errors: ErrorReporte
         val indexerVarPrefix = "prog8_autovar_index_"
         val repo = subroutine.asmGenInfo.usedAutoArrayIndexerForStatements
 
-        // TODO make this even smarter so that an indexerVar can be reused for a different following statement...  requires updating the partOfStatement?
-        var indexerVar = repo.firstOrNull { it.replaces isSameAs expr.indexer }
-        if(indexerVar==null) {
-            // add another loop index var to be used for this expression
-            val indexerVarName = "$indexerVarPrefix${expr.indexer.hashCode()}"
-            indexerVar = AsmGenInfo.ArrayIndexerInfo(indexerVarName, expr.indexer, statement)
-            repo.add(indexerVar)
-            // create the indexer var at block level scope
-            val vardecl = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.PREFER_ZEROPAGE,
-                    null, indexerVarName, null, null, isArray = false, autogeneratedDontRemove = true, position = expr.position)
-            modifications.add(IAstModification.InsertFirst(vardecl, subroutine))
-        }
-        indexerVar.used++       // keep track of how many times it it used, to avoid assigning it multiple times
+        // TODO make this a bit smarter so it can reuse indexer variables. BUT BEWARE of scoping+initialization problems then
+        // add another loop index var to be used for this expression
+        val indexerVarName = "$indexerVarPrefix${expr.indexer.hashCode()}"
+        val indexerVar = AsmGenInfo.ArrayIndexerInfo(indexerVarName, expr.indexer)
+        repo.add(indexerVar)
+        // create the indexer var at block level scope
+        val vardecl = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.PREFER_ZEROPAGE,
+                null, indexerVarName, null, null, isArray = false, autogeneratedDontRemove = true, position = expr.position)
+        modifications.add(IAstModification.InsertFirst(vardecl, subroutine))
 
         // replace the indexer with just the variable
         // assign the indexing expression to the helper variable, but only if that hasn't been done already
         val indexerExpression = expr.indexer.origExpression!!
         val target = AssignTarget(IdentifierReference(listOf(indexerVar.name), indexerExpression.position), null, null, indexerExpression.position)
-        if(indexerVar.used==1) {
-            val assign = Assignment(target, indexerExpression, indexerExpression.position)
-            modifications.add(IAstModification.InsertBefore(statement, assign, statement.definingScope()))
-        }
+        val assign = Assignment(target, indexerExpression, indexerExpression.position)
+        modifications.add(IAstModification.InsertBefore(statement, assign, statement.definingScope()))
         modifications.add(IAstModification.SetExpression( {
             expr.indexer.indexVar = it as IdentifierReference
             expr.indexer.indexNum = null

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

@@ -4,9 +4,9 @@ import prog8.ast.IFunctionCall
 import prog8.ast.INameScope
 import prog8.ast.Program
 import prog8.ast.base.DataType
-import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.Expression
 import prog8.ast.expressions.FunctionCall
+import prog8.ast.expressions.TypecastExpression
 import prog8.ast.statements.*
 import prog8.compiler.CompilerException
 import prog8.functions.BuiltinFunctions
@@ -41,8 +41,9 @@ class VerifyFunctionArgTypes(val program: Program) : IAstVisitor {
 
         fun checkTypes(call: IFunctionCall, scope: INameScope, program: Program): String? {
             val argITypes = call.args.map { it.inferType(program) }
-            if(argITypes.any { !it.isKnown })
-                throw FatalAstException("unknown dt")
+            val firstUnknownDt = argITypes.indexOfFirst { it.isUnknown }
+            if(firstUnknownDt>=0)
+                return "argument ${firstUnknownDt+1} invalid argument type"
             val argtypes = argITypes.map { it.typeOrElse(DataType.STRUCT) }
             val target = call.target.targetStatement(scope)
             if (target is Subroutine) {
@@ -60,8 +61,15 @@ class VerifyFunctionArgTypes(val program: Program) : IAstVisitor {
                         // multiple return values will NOT work inside an expression.
                         // they MIGHT work in a regular assignment or just a function call statement.
                         val parent = if(call is Statement) call.parent else if(call is Expression) call.parent else null
-                        if(call !is FunctionCallStatement && parent !is Assignment && parent !is VarDecl) {
-                            return "can't use subroutine call that returns multiple return values here (try moving it into a separate assignment)"
+                        if (call !is FunctionCallStatement) {
+                            val checkParent =
+                                if(parent is TypecastExpression)
+                                    parent.parent
+                                else
+                                    parent
+                            if (checkParent !is Assignment && checkParent !is VarDecl) {
+                                return "can't use subroutine call that returns multiple return values here"
+                            }
                         }
                     }
                 }

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

@@ -200,7 +200,7 @@ open class VarDecl(val type: VarDeclType,
         fun defaultZero(dt: DataType, position: Position) = when(dt) {
             DataType.UBYTE -> NumericLiteralValue(DataType.UBYTE, 0,  position)
             DataType.BYTE -> NumericLiteralValue(DataType.BYTE, 0,  position)
-            DataType.UWORD -> NumericLiteralValue(DataType.UWORD, 0, position)
+            DataType.UWORD, DataType.STR -> NumericLiteralValue(DataType.UWORD, 0, position)
             DataType.WORD -> NumericLiteralValue(DataType.WORD, 0, position)
             DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, 0.0, position)
             else -> throw FatalAstException("can only determine default zero value for a numeric type")
@@ -698,7 +698,7 @@ class AsmGenInfo {
     var usedFloatEvalResultVar1 = false
     var usedFloatEvalResultVar2 = false
 
-    class ArrayIndexerInfo(val name: String, val replaces: ArrayIndex, val partOfStatement: Statement, var used: Int=0)
+    class ArrayIndexerInfo(val name: String, val replaces: ArrayIndex)
 }
 
 // the subroutine class covers both the normal user-defined subroutines,
@@ -712,11 +712,12 @@ class Subroutine(override val name: String,
                  val asmClobbers: Set<CpuRegister>,
                  val asmAddress: Int?,
                  val isAsmSubroutine: Boolean,
+                 val inline: Boolean,
                  override var statements: MutableList<Statement>,
                  override val position: Position) : Statement(), INameScope {
 
-    constructor(name: String, parameters: List<SubroutineParameter>, returntypes: List<DataType>, statements: MutableList<Statement>, position: Position)
-            : this(name, parameters, returntypes, emptyList(), determineReturnRegisters(returntypes), emptySet(), null, false, statements, position)
+    constructor(name: String, parameters: List<SubroutineParameter>, returntypes: List<DataType>, statements: MutableList<Statement>, inline: Boolean, position: Position)
+            : this(name, parameters, returntypes, emptyList(), determineReturnRegisters(returntypes), emptySet(), null, false, inline, statements, position)
 
     companion object {
         private fun determineReturnRegisters(returntypes: List<DataType>): List<RegisterOrStatusflag> {
@@ -724,7 +725,7 @@ class Subroutine(override val name: String,
             return when(returntypes.singleOrNull()) {
                 in ByteDatatypes -> listOf(RegisterOrStatusflag(RegisterOrPair.A, null))
                 in WordDatatypes -> listOf(RegisterOrStatusflag(RegisterOrPair.AY, null))
-                DataType.FLOAT -> listOf(RegisterOrStatusflag(RegisterOrPair.AY, null))
+                DataType.FLOAT -> listOf(RegisterOrStatusflag(RegisterOrPair.FAC1, null))
                 null -> emptyList()
                 else -> listOf(RegisterOrStatusflag(RegisterOrPair.AY, null))
             }
@@ -757,6 +758,17 @@ 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 shouldSaveX() = CpuRegister.X in asmClobbers || regXasResult() || regXasParam()
+    fun shouldKeepA(): Pair<Boolean, Boolean> {
+        // determine if A's value should be kept when preparing for calling the subroutine, and when returning from it
+        if(!isAsmSubroutine)
+            return Pair(false, false)
+
+        // it seems that we never have to save A when calling? will be loaded correctly after setup.
+        // but on return it depends on wether the routine returns something in A.
+        val saveAonReturn = asmReturnvaluesRegisters.any { it.registerOrPair==RegisterOrPair.A || it.registerOrPair==RegisterOrPair.AY || it.registerOrPair==RegisterOrPair.AX }
+        return Pair(false, saveAonReturn)
+    }
 
     fun amountOfRtsInAsm(): Int = statements
             .asSequence()
@@ -979,7 +991,7 @@ class WhenStatement(var condition: Expression,
     override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 }
 
-class WhenChoice(var values: List<Expression>?,           // if null,  this is the 'else' part
+class WhenChoice(var values: MutableList<Expression>?,           // if null,  this is the 'else' part
                  var statements: AnonymousScope,
                  override val position: Position) : Node {
     override lateinit var parent: Node
@@ -996,7 +1008,9 @@ class WhenChoice(var values: List<Expression>?,           // if null,  this is t
             statements = replacement
             replacement.parent = this
         } else if(choiceValues!=null && node in choiceValues) {
-            throw FatalAstException("cannot replace choice values")
+            val idx = choiceValues.indexOf(node)
+            choiceValues[idx] = replacement as Expression
+            replacement.parent = this
         } else {
             throw FatalAstException("invalid replacement")
         }

compiler/src/prog8/compiler/BeforeAsmGenerationAstChanger.kt

@@ -111,6 +111,7 @@ internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: E
         val mods = mutableListOf<IAstModification>()
         val returnStmt = Return(null, subroutine.position)
         if (subroutine.asmAddress == null
+                && !subroutine.inline
                 && subroutine.statements.isNotEmpty()
                 && subroutine.amountOfRtsInAsm() == 0
                 && subroutine.statements.lastOrNull { it !is VarDecl } !is Return

compiler/src/prog8/compiler/Compiler.kt

@@ -30,6 +30,7 @@ data class CompilationOptions(val output: OutputType,
                               val floats: Boolean,
                               val noSysInit: Boolean) {
     var slowCodegenWarnings = false
+    var optimize = false
 }
 
 

compiler/src/prog8/compiler/Main.kt

@@ -51,17 +51,18 @@ fun compileProgram(filepath: Path,
             // import main module and everything it needs
             val (ast, compilationOptions, imported) = parseImports(filepath, errors)
             compilationOptions.slowCodegenWarnings = slowCodegenWarnings
+            compilationOptions.optimize = optimize
             programAst = ast
             importedFiles = imported
             processAst(programAst, errors, compilationOptions)
-            if (optimize)
+            if (compilationOptions.optimize)
                 optimizeAst(programAst, errors)
             postprocessAst(programAst, errors, compilationOptions)
 
             // printAst(programAst)
 
             if(writeAssembly)
-                programName = writeAssembly(programAst, errors, outputDir, optimize, compilationOptions)
+                programName = writeAssembly(programAst, errors, outputDir, compilationOptions)
         }
         System.out.flush()
         System.err.flush()
@@ -218,7 +219,7 @@ private fun postprocessAst(programAst: Program, errors: ErrorReporter, compilerO
 }
 
 private fun writeAssembly(programAst: Program, errors: ErrorReporter, outputDir: Path,
-                          optimize: Boolean, compilerOptions: CompilationOptions): String {
+                          compilerOptions: CompilationOptions): String {
     // asm generation directly from the Ast,
     programAst.processAstBeforeAsmGeneration(errors)
     errors.handle()
@@ -231,7 +232,7 @@ private fun writeAssembly(programAst: Program, errors: ErrorReporter, outputDir:
             errors,
             CompilationTarget.instance.machine.zeropage,
             compilerOptions,
-            outputDir).compileToAssembly(optimize)
+            outputDir).compileToAssembly()
     assembly.assemble(compilerOptions)
     errors.handle()
     return assembly.name

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

@@ -3,7 +3,7 @@ package prog8.compiler.target
 import prog8.compiler.CompilationOptions
 
 internal interface IAssemblyGenerator {
-    fun compileToAssembly(optimize: Boolean): IAssemblyProgram
+    fun compileToAssembly(): IAssemblyProgram
 }
 
 internal const val generatedLabelPrefix = "_prog8_label_"

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

@@ -32,7 +32,6 @@ internal interface IMachineDefinition {
 
     fun initializeZeropage(compilerOptions: CompilationOptions)
     fun getFloat(num: Number): IMachineFloat
-    fun getFloatRomConst(number: Double): String?
     fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program)
     fun launchEmulator(programName: String)
     fun isRegularRAMaddress(address: Int): Boolean

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

@@ -7,7 +7,6 @@ import prog8.compiler.target.IMachineDefinition
 import prog8.compiler.target.IMachineFloat
 import prog8.parser.ModuleImporter
 import java.io.IOException
-import java.math.RoundingMode
 import kotlin.math.absoluteValue
 import kotlin.math.pow
 
@@ -24,7 +23,6 @@ internal object C64MachineDefinition: IMachineDefinition {
     override val RAW_LOAD_ADDRESS = 0xc000
 
     // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-    // and some heavily used string constants derived from the two values above
     override val ESTACK_LO = 0xce00        //  $ce00-$ceff inclusive
     override val ESTACK_HI = 0xcf00        //  $ce00-$ceff inclusive
 
@@ -32,41 +30,6 @@ internal object C64MachineDefinition: IMachineDefinition {
 
     override fun getFloat(num: Number) = Mflpt5.fromNumber(num)
 
-    override fun getFloatRomConst(number: Double): String? {
-        // try to match the ROM float constants to save memory
-        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 "floats.FL_ZERO_const"        // not a ROM const
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_ONE_const"        // not a ROM const
-            floatbytes.contentEquals(shortArrayOf(0x82, 0x49, 0x0f, 0xda, 0xa1)) -> return "floats.FL_PIVAL"
-            floatbytes.contentEquals(shortArrayOf(0x90, 0x80, 0x00, 0x00, 0x00)) -> return "floats.FL_N32768"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_FONE"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x35, 0x04, 0xf3, 0x34)) -> return "floats.FL_SQRHLF"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x35, 0x04, 0xf3, 0x34)) -> return "floats.FL_SQRTWO"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x80, 0x00, 0x00, 0x00)) -> return "floats.FL_NEGHLF"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x31, 0x72, 0x17, 0xf8)) -> return "floats.FL_LOG2"
-            floatbytes.contentEquals(shortArrayOf(0x84, 0x20, 0x00, 0x00, 0x00)) -> return "floats.FL_TENC"
-            floatbytes.contentEquals(shortArrayOf(0x9e, 0x6e, 0x6b, 0x28, 0x00)) -> return "floats.FL_NZMIL"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_FHALF"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x38, 0xaa, 0x3b, 0x29)) -> return "floats.FL_LOGEB2"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x49, 0x0f, 0xda, 0xa2)) -> return "floats.FL_PIHALF"
-            floatbytes.contentEquals(shortArrayOf(0x83, 0x49, 0x0f, 0xda, 0xa2)) -> return "floats.FL_TWOPI"
-            floatbytes.contentEquals(shortArrayOf(0x7f, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_FR4"
-            else -> {
-                // attempt to correct for a few rounding issues
-                when (number.toBigDecimal().setScale(10, RoundingMode.HALF_DOWN).toDouble()) {
-                    3.1415926536 -> return "floats.FL_PIVAL"
-                    1.4142135624 -> return "floats.FL_SQRTWO"
-                    0.7071067812 -> return "floats.FL_SQRHLF"
-                    0.6931471806 -> return "floats.FL_LOG2"
-                    else -> {}
-                }
-            }
-        }
-        return null
-    }
-
     override fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program) {
         if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG)
             importer.importLibraryModule(program, "syslib")

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

@@ -1,5 +1,6 @@
 package prog8.compiler.target.c64.codegen
 
+import prog8.ast.IFunctionCall
 import prog8.ast.INameScope
 import prog8.ast.Node
 import prog8.ast.Program
@@ -36,7 +37,7 @@ internal class AsmGen(private val program: Program,
 
     // for expressions and augmented assignments:
     val optimizedByteMultiplications = setOf(3,5,6,7,9,10,11,12,13,14,15,20,25,40,50,80,100)
-    val optimizedWordMultiplications = setOf(3,5,6,7,9,10,12,15,20,25,40,50,80,100)
+    val optimizedWordMultiplications = setOf(3,5,6,7,9,10,12,15,20,25,40,50,80,100,320)
 
     private val assemblyLines = mutableListOf<String>()
     private val globalFloatConsts = mutableMapOf<Double, String>()     // all float values in the entire program (value -> varname)
@@ -50,8 +51,10 @@ internal class AsmGen(private val program: Program,
     private val assignmentAsmGen = AssignmentAsmGen(program, this, expressionsAsmGen)
     internal val loopEndLabels = ArrayDeque<String>()
     private val blockLevelVarInits = mutableMapOf<Block, MutableSet<VarDecl>>()
+    internal val slabs = mutableMapOf<String, Int>()
+    internal val removals = mutableListOf<Pair<Statement, INameScope>>()
 
-    override fun compileToAssembly(optimize: Boolean): IAssemblyProgram {
+    override fun compileToAssembly(): IAssemblyProgram {
         assemblyLines.clear()
         loopEndLabels.clear()
 
@@ -63,6 +66,13 @@ internal class AsmGen(private val program: Program,
             throw AssemblyError("first block should be 'main'")
         for(b in program.allBlocks())
             block2asm(b)
+
+        for(removal in removals.toList()) {
+            removal.second.remove(removal.first)
+            removals.remove(removal)
+        }
+
+        slaballocations()
         footer()
 
         val outputFile = outputDir.resolve("${program.name}.asm").toFile()
@@ -70,7 +80,7 @@ internal class AsmGen(private val program: Program,
             for (line in assemblyLines) { it.println(line) }
         }
 
-        if(optimize) {
+        if(options.optimize) {
             assemblyLines.clear()
             assemblyLines.addAll(outputFile.readLines())
             var optimizationsDone = 1
@@ -143,15 +153,23 @@ internal class AsmGen(private val program: Program,
         if(options.zeropage !in setOf(ZeropageType.BASICSAFE, ZeropageType.DONTUSE)) {
             out("""
                 ; zeropage is clobbered so we need to reset the machine at exit
-                lda  #>${CompilationTarget.instance.name}.reset_system
+                lda  #>sys.reset_system
                 pha
-                lda  #<${CompilationTarget.instance.name}.reset_system
+                lda  #<sys.reset_system
                 pha""")
         }
 
         out("  jmp  main.start  ; start program / force start proc to be included")
     }
 
+    private fun slaballocations() {
+        out("; memory slabs")
+        out("prog8_slabs\t.block")
+        for((name, size) in slabs)
+            out("$name\t.fill  $size")
+        out("\t.bend")
+    }
+
     private fun footer() {
         // the global list of all floating point constants for the whole program
         out("; global float constants")
@@ -160,6 +178,7 @@ internal class AsmGen(private val program: Program,
             val floatvalue = flt.key
             out("${flt.value}\t.byte  $floatFill  ; float $floatvalue")
         }
+        out("prog8_program_end\t; end of program label for progend()")
     }
 
     private fun block2asm(block: Block) {
@@ -469,16 +488,13 @@ internal class AsmGen(private val program: Program,
     }
 
     internal fun getFloatAsmConst(number: Double): String {
-        var asmName = CompilationTarget.instance.machine.getFloatRomConst(number)
-        if(asmName.isNullOrEmpty()) {
-            // no ROM float const for this value, create our own
-            asmName = globalFloatConsts[number]
-            if(asmName==null) {
-                asmName = "prog8_float_const_${globalFloatConsts.size}"
-                globalFloatConsts[number] = asmName
-            }
-        }
-        return asmName
+        val asmName = globalFloatConsts[number]
+        if(asmName!=null)
+            return asmName
+
+        val newName = "prog8_float_const_${globalFloatConsts.size}"
+        globalFloatConsts[number] = newName
+        return newName
     }
 
     internal fun asmSymbolName(identifier: IdentifierReference): String {
@@ -549,12 +565,19 @@ internal class AsmGen(private val program: Program,
 
     private  fun fixNameSymbols(name: String) = name.replace("<", "prog8_").replace(">", "")     // take care of the autogenerated invalid (anon) label names
 
-    internal fun saveRegister(register: CpuRegister, dontUseStack: Boolean, scope: Subroutine) {
-        if(dontUseStack) {
+    internal fun saveRegisterLocal(register: CpuRegister, scope: Subroutine) {
+        if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+            // just use the cpu's stack for all registers, shorter code
+            when (register) {
+                CpuRegister.A -> out("  pha")
+                CpuRegister.X -> out("  phx")
+                CpuRegister.Y -> out("  phy")
+            }
+        } else {
             when (register) {
                 CpuRegister.A -> {
-                    out("  sta  _prog8_regsaveA")
-                    scope.asmGenInfo.usedRegsaveA = true
+                    // just use the stack, only for A
+                    out("  pha")
                 }
                 CpuRegister.X -> {
                     out("  stx  _prog8_regsaveX")
@@ -565,52 +588,79 @@ internal class AsmGen(private val program: Program,
                     scope.asmGenInfo.usedRegsaveY = true
                 }
             }
+        }
+    }
 
-        } else {
-            when (register) {
-                CpuRegister.A -> out("  pha")
-                CpuRegister.X -> {
-                    if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phx")
-                    else {
-                        out("  stx  _prog8_regsaveX")
-                        scope.asmGenInfo.usedRegsaveX = true
-                    }
+    internal fun saveRegisterStack(register: CpuRegister, keepA: Boolean) {
+        when (register) {
+            CpuRegister.A -> out("  pha")
+            CpuRegister.X -> {
+                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phx")
+                else {
+                    if(keepA)
+                        out("  sta  P8ZP_SCRATCH_REG |  txa |  pha  |  lda  P8ZP_SCRATCH_REG")
+                    else
+                        out("  txa |  pha")
                 }
-                CpuRegister.Y -> {
-                    if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phy")
-                    else {
-                        out("  sty  _prog8_regsaveY")
-                        scope.asmGenInfo.usedRegsaveY = true
-                    }
+            }
+            CpuRegister.Y -> {
+                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phy")
+                else {
+                    if(keepA)
+                        out("  sta  P8ZP_SCRATCH_REG |  tya |  pha  |  lda  P8ZP_SCRATCH_REG")
+                    else
+                        out("  tya |  pha")
                 }
             }
         }
     }
 
-    internal fun restoreRegister(register: CpuRegister, dontUseStack: Boolean) {
-        if(dontUseStack) {
+    internal fun restoreRegisterLocal(register: CpuRegister) {
+        if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
             when (register) {
-                CpuRegister.A -> out("  sta  _prog8_regsaveA")
+                // this just used the stack, for all registers. Shorter code.
+                CpuRegister.A -> out("  pla")
+                CpuRegister.X -> out("  plx")
+                CpuRegister.Y -> out("  ply")
+            }
+
+        } else {
+            when (register) {
+                CpuRegister.A -> out("  pla")   // this just used the stack but only for A
                 CpuRegister.X -> out("  ldx  _prog8_regsaveX")
                 CpuRegister.Y -> out("  ldy  _prog8_regsaveY")
             }
+        }
+    }
 
-        } else {
-            when (register) {
-                CpuRegister.A -> out("  pla")
-                CpuRegister.X -> {
-                    if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  plx")
-                    else out("  ldx  _prog8_regsaveX")
+    internal fun restoreRegisterStack(register: CpuRegister, keepA: Boolean) {
+        when (register) {
+            CpuRegister.A -> {
+                if(keepA)
+                    throw AssemblyError("can't set keepA if A is restored")
+                out("  pla")
+            }
+            CpuRegister.X -> {
+                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  plx")
+                else {
+                    if(keepA)
+                        out("  sta  P8ZP_SCRATCH_REG |  pla |  tax |  lda  P8ZP_SCRATCH_REG")
+                    else
+                        out("  pla |  tax")
                 }
-                CpuRegister.Y -> {
-                    if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  ply")
-                    else out("  ldy  _prog8_regsaveY")
+            }
+            CpuRegister.Y -> {
+                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  ply")
+                else {
+                    if(keepA)
+                        out("  sta  P8ZP_SCRATCH_REG |  pla |  tay |  lda  P8ZP_SCRATCH_REG")
+                    else
+                        out("  pla |  tay")
                 }
             }
         }
     }
 
-
     internal fun translate(stmt: Statement) {
         outputSourceLine(stmt)
         when(stmt) {
@@ -740,8 +790,14 @@ internal class AsmGen(private val program: Program,
     internal fun translateBuiltinFunctionCallExpression(functionCall: FunctionCall, signature: FSignature, resultToStack: Boolean) =
             builtinFunctionsAsmGen.translateFunctioncallExpression(functionCall, signature, resultToStack)
 
-    internal fun translateFunctionCall(functionCall: FunctionCall, preserveStatusRegisterAfterCall: Boolean) =
-            functioncallAsmGen.translateFunctionCall(functionCall, preserveStatusRegisterAfterCall)
+    internal fun translateFunctionCall(functionCall: FunctionCall) =
+            functioncallAsmGen.translateFunctionCall(functionCall)
+
+    internal fun saveXbeforeCall(functionCall: IFunctionCall)  =
+            functioncallAsmGen.saveXbeforeCall(functionCall)
+
+    internal fun restoreXafterCall(functionCall: IFunctionCall) =
+            functioncallAsmGen.restoreXafterCall(functionCall)
 
     internal fun translateNormalAssignment(assign: AsmAssignment) =
             assignmentAsmGen.translateNormalAssignment(assign)
@@ -757,9 +813,19 @@ internal class AsmGen(private val program: Program,
 
 
     private fun translateSubroutine(sub: Subroutine) {
+        if(sub.inline) {
+            if(options.optimize)
+                return      // inline subroutines don't exist anymore on their own
+            else if(sub.amountOfRtsInAsm()==0) {
+                // make sure the NOT INLINED subroutine actually does an rts at the end
+                sub.statements.add(Return(null, Position.DUMMY))
+            }
+        }
+
         out("")
         outputSourceLine(sub)
 
+
         if(sub.isAsmSubroutine) {
             if(sub.asmAddress!=null)
                 return  // already done at the memvars section
@@ -784,7 +850,7 @@ internal class AsmGen(private val program: Program,
                 }
                 out("""
                     tsx
-                    stx  prog8_lib.orig_stackpointer    ; required for func_exit                    
+                    stx  prog8_lib.orig_stackpointer    ; required for sys.exit()                    
                     ldx  #255       ; init estack ptr
                     clv
                     clc""")
@@ -792,6 +858,14 @@ internal class AsmGen(private val program: Program,
 
             out("; statements")
             sub.statements.forEach{ translate(it) }
+
+            for(removal in removals.toList()) {
+                if(removal.second==sub) {
+                    removal.second.remove(removal.first)
+                    removals.remove(removal)
+                }
+            }
+
             out("; variables")
             out("; register saves")
             if(sub.asmGenInfo.usedRegsaveA)
@@ -814,12 +888,12 @@ internal class AsmGen(private val program: Program,
                 when (condition) {
                     BranchCondition.CS -> "bcc"
                     BranchCondition.CC -> "bcs"
-                    BranchCondition.EQ, BranchCondition.Z -> "beq"
-                    BranchCondition.NE, BranchCondition.NZ -> "bne"
+                    BranchCondition.EQ, BranchCondition.Z -> "bne"
+                    BranchCondition.NE, BranchCondition.NZ -> "beq"
                     BranchCondition.VS -> "bvc"
                     BranchCondition.VC -> "bvs"
-                    BranchCondition.MI, BranchCondition.NEG -> "bmi"
-                    BranchCondition.PL, BranchCondition.POS -> "bpl"
+                    BranchCondition.MI, BranchCondition.NEG -> "bpl"
+                    BranchCondition.PL, BranchCondition.POS -> "bmi"
                 }
             } else {
                 when (condition) {
@@ -878,7 +952,7 @@ internal class AsmGen(private val program: Program,
             }
             is NumericLiteralValue -> {
                 val iterations = (stmt.iterations as NumericLiteralValue).number.toInt()
-                if(iterations<0 || iterations > 65536)
+                if(iterations<0 || iterations > 65535)
                     throw AssemblyError("invalid number of iterations")
                 when {
                     iterations == 0 -> {}
@@ -1071,26 +1145,48 @@ $counterVar    .byte  0""")
 
         val jump = stmt.truepart.statements.first() as? Jump
         if(jump!=null) {
-            // branch with only a jump
+            // branch with only a jump (goto)
             val instruction = branchInstruction(stmt.condition, false)
             out("  $instruction  ${getJumpTarget(jump)}")
             translate(stmt.elsepart)
         } else {
+            val truePartIsJustBreak = stmt.truepart.statements.firstOrNull() is Break
+            val elsePartIsJustBreak = stmt.elsepart.statements.firstOrNull() is Break
             if(stmt.elsepart.containsNoCodeNorVars()) {
+                if(truePartIsJustBreak) {
+                    // branch with just a break (jump out of loop)
+                    val instruction = branchInstruction(stmt.condition, false)
+                    val loopEndLabel = loopEndLabels.peek()
+                    out("  $instruction  $loopEndLabel")
+                } else {
+                    val instruction = branchInstruction(stmt.condition, true)
+                    val elseLabel = makeLabel("branch_else")
+                    out("  $instruction  $elseLabel")
+                    translate(stmt.truepart)
+                    out(elseLabel)
+                }
+            }
+            else if(truePartIsJustBreak) {
+                // branch with just a break (jump out of loop)
+                val instruction = branchInstruction(stmt.condition, false)
+                val loopEndLabel = loopEndLabels.peek()
+                out("  $instruction  $loopEndLabel")
+                translate(stmt.elsepart)
+            } else if(elsePartIsJustBreak) {
+                // branch with just a break (jump out of loop) but true/false inverted
+                val instruction = branchInstruction(stmt.condition, true)
+                val loopEndLabel = loopEndLabels.peek()
+                out("  $instruction  $loopEndLabel")
+                translate(stmt.truepart)
+            } else {
                 val instruction = branchInstruction(stmt.condition, true)
                 val elseLabel = makeLabel("branch_else")
+                val endLabel = makeLabel("branch_end")
                 out("  $instruction  $elseLabel")
                 translate(stmt.truepart)
-                out(elseLabel)
-            } else {
-                val instruction = branchInstruction(stmt.condition, false)
-                val trueLabel = makeLabel("branch_true")
-                val endLabel = makeLabel("branch_end")
-                out("  $instruction  $trueLabel")
-                translate(stmt.elsepart)
                 out("  jmp  $endLabel")
-                out(trueLabel)
-                translate(stmt.truepart)
+                out(elseLabel)
+                translate(stmt.elsepart)
                 out(endLabel)
             }
         }
@@ -1122,10 +1218,10 @@ $counterVar    .byte  0""")
             "%asminclude" -> {
                 val sourcecode = loadAsmIncludeFile(stmt.args[0].str!!, stmt.definingModule().source)
                 val scopeprefix = stmt.args[1].str ?: ""
-                if(!scopeprefix.isBlank())
+                if(scopeprefix.isNotBlank())
                     out("$scopeprefix\t.proc")
                 assemblyLines.add(sourcecode.trimEnd().trimStart('\n'))
-                if(!scopeprefix.isBlank())
+                if(scopeprefix.isNotBlank())
                     out("  .pend\n")
             }
             "%asmbinary" -> {
@@ -1172,12 +1268,8 @@ $label              nop""")
                 throw AssemblyError("normal subroutines can't return value in status register directly")
 
             when (returnType) {
-                in IntegerDatatypes -> {
-                    assignmentAsmGen.assignExpressionToRegister(returnvalue, returnReg.registerOrPair)
-                }
-                DataType.FLOAT -> {
-                    // return the float value via FAC1
-                    assignExpressionToRegister(returnvalue, RegisterOrPair.FAC1)
+                in NumericDatatypes -> {
+                    assignExpressionToRegister(returnvalue, returnReg.registerOrPair)
                 }
                 else -> {
                     // all else take its address and assign that also to AY register pair
@@ -1206,7 +1298,12 @@ $label              nop""")
     internal fun signExtendStackLsb(valueDt: DataType) {
         // sign extend signed byte on stack to signed word on stack
         when(valueDt) {
-            DataType.UBYTE -> out("  lda  #0 |  sta  P8ESTACK_HI+1,x")
+            DataType.UBYTE -> {
+                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    out("  stz  P8ESTACK_HI+1,x")
+                else
+                    out("  lda  #0 |  sta  P8ESTACK_HI+1,x")
+            }
             DataType.BYTE -> out("  jsr  prog8_lib.sign_extend_stack_byte")
             else -> throw AssemblyError("need byte type")
         }
@@ -1216,7 +1313,10 @@ $label              nop""")
         // sign extend signed byte in a var to a full word in that variable
         when(valueDt) {
             DataType.UBYTE -> {
-                out("  lda  #0 |  sta  $asmvar+1")
+                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    out("  stz  $asmvar+1")
+                else
+                    out("  lda  #0 |  sta  $asmvar+1")
             }
             DataType.BYTE -> {
                 out("""

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

@@ -75,11 +75,11 @@ private fun getLinesBy(lines: MutableList<String>, windowSize: Int) =
 
 private fun optimizeCmpSequence(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
     // the when statement (on bytes) generates a sequence of:
-    //	 lda $ce01,x
-    //	 cmp #$20
+    //	 lda  $ce01,x
+    //	 cmp  #$20
     //	 beq  check_prog8_s72choice_32
-    //	 lda $ce01,x
-    //	 cmp #$21
+    //	 lda  $ce01,x
+    //	 cmp  #$21
     //	 beq  check_prog8_s73choice_33
     // the repeated lda can be removed
     val mods = mutableListOf<Modification>()
@@ -179,7 +179,7 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
 }
 
 private fun optimizeStoreLoadSame(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
-    // sta X + lda X,  sty X + ldy X,   stx X + ldx X  -> the second instruction can be eliminated
+    // sta X + lda X,  sty X + ldy X,   stx X + ldx X  -> the second instruction can OFTEN be eliminated
     // TODO this is not true if X is not a regular RAM memory address (but instead mapped I/O or ROM)
     val mods = mutableListOf<Modification>()
     for (pair in linesByFour) {
@@ -196,10 +196,14 @@ private fun optimizeStoreLoadSame(linesByFour: List<List<IndexedValue<String>>>)
                 (first.startsWith("sty ") && second.startsWith("ldy ")) ||
                 (first.startsWith("stx ") && second.startsWith("ldx "))
         ) {
-            val firstLoc = first.substring(4).trimStart()
-            val secondLoc = second.substring(4).trimStart()
-            if (firstLoc == secondLoc) {
-                mods.add(Modification(pair[1].index, true, null))
+            val third = pair[2].value.trimStart()
+            if(!third.startsWith("b")) {
+                // no branch instruction follows, we can potentiall remove the load instruction
+                val firstLoc = first.substring(4).trimStart()
+                val secondLoc = second.substring(4).trimStart()
+                if (firstLoc == secondLoc) {
+                    mods.add(Modification(pair[1].index, true, null))
+                }
             }
         }
     }

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

@@ -5,13 +5,8 @@ import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
-import prog8.ast.statements.ArrayIndex
-import prog8.ast.statements.DirectMemoryWrite
-import prog8.ast.statements.FunctionCallStatement
-import prog8.ast.statements.Subroutine
+import prog8.ast.statements.*
 import prog8.compiler.AssemblyError
-import prog8.compiler.target.CompilationTarget
-import prog8.compiler.target.Cx16Target
 import prog8.compiler.target.c64.codegen.assignment.AsmAssignSource
 import prog8.compiler.target.c64.codegen.assignment.AsmAssignTarget
 import prog8.compiler.target.c64.codegen.assignment.AsmAssignment
@@ -38,126 +33,66 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
         if(discardResult && resultToStack)
             throw AssemblyError("cannot both discard the result AND put it onto stack")
 
-        val scope = (fcall as Node).definingSubroutine()!!
+        val sscope = (fcall as Node).definingSubroutine()
         when (func.name) {
             "msb" -> funcMsb(fcall, resultToStack)
             "lsb" -> funcLsb(fcall, resultToStack)
             "mkword" -> funcMkword(fcall, resultToStack)
-            "abs" -> funcAbs(fcall, func, resultToStack, scope)
+            "abs" -> funcAbs(fcall, func, resultToStack, sscope)
             "swap" -> funcSwap(fcall)
             "min", "max" -> funcMinMax(fcall, func, resultToStack)
             "sum" -> funcSum(fcall, resultToStack)
             "any", "all" -> funcAnyAll(fcall, func, resultToStack)
             "sin8", "sin8u", "sin16", "sin16u",
-            "cos8", "cos8u", "cos16", "cos16u" -> funcSinCosInt(fcall, func, resultToStack, scope)
-            "sgn" -> funcSgn(fcall, func, resultToStack, scope)
+            "cos8", "cos8u", "cos16", "cos16u" -> funcSinCosInt(fcall, func, resultToStack, sscope)
+            "sgn" -> funcSgn(fcall, func, resultToStack, sscope)
             "sin", "cos", "tan", "atan",
             "ln", "log2", "sqrt", "rad",
             "deg", "round", "floor", "ceil",
-            "rndf" -> funcVariousFloatFuncs(fcall, func, resultToStack, scope)
+            "rndf" -> funcVariousFloatFuncs(fcall, func, resultToStack, sscope)
             "rnd", "rndw" -> funcRnd(func, resultToStack)
-            "sqrt16" -> funcSqrt16(fcall, func, resultToStack, scope)
+            "sqrt16" -> funcSqrt16(fcall, func, resultToStack, sscope)
             "rol" -> funcRol(fcall)
             "rol2" -> funcRol2(fcall)
             "ror" -> funcRor(fcall)
             "ror2" -> funcRor2(fcall)
             "sort" -> funcSort(fcall)
             "reverse" -> funcReverse(fcall)
-            "rsave" -> {
-                // save cpu status flag and all registers A, X, Y.
-                // see http://6502.org/tutorials/register_preservation.html
-                asmgen.out(" php |  sta  P8ZP_SCRATCH_REG | pha  | txa  | pha  | tya  | pha  | lda  P8ZP_SCRATCH_REG")
-            }
-            "rrestore" -> {
-                // restore all registers and cpu status flag
-                asmgen.out(" pla |  tay |  pla |  tax |  pla |  plp")
-            }
-            "read_flags" -> {
-                if(resultToStack)
-                    asmgen.out("  jsr  prog8_lib.func_read_flags_stack")
-                else
-                    asmgen.out("  php |  pla")
-            }
-            "clear_carry" -> asmgen.out("  clc")
-            "set_carry" -> asmgen.out("  sec")
-            "clear_irqd" -> asmgen.out("  cli")
-            "set_irqd" -> asmgen.out("  sei")
-            "strlen" -> funcStrlen(fcall, resultToStack)
-            "strcmp" -> funcStrcmp(fcall, func, resultToStack, scope)
-            "memcopy", "memset", "memsetw" -> funcMemSetCopy(fcall, func, scope)
-            "substr", "leftstr", "rightstr" -> {
-                translateArguments(fcall.args, func, scope)
-                asmgen.out("  jsr  prog8_lib.func_${func.name}")
-            }
-            "exit" -> {
-                translateArguments(fcall.args, func, scope)
-                asmgen.out("  jmp  prog8_lib.func_exit")
-            }
+            "memory" -> funcMemory(fcall, discardResult, resultToStack)
             else -> TODO("missing asmgen for builtin func ${func.name}")
         }
     }
 
-    private fun funcMemSetCopy(fcall: IFunctionCall, func: FSignature, scope: Subroutine) {
-        if(CompilationTarget.instance is Cx16Target) {
-            when(func.name) {
-                "memset" -> {
-                    // use the ROM function of the Cx16
-                    asmgen.assignExpressionToVariable(fcall.args[0], "cx16.r0", DataType.UWORD, scope)
-                    asmgen.assignExpressionToVariable(fcall.args[1], "cx16.r1", DataType.UWORD, scope)
-                    asmgen.assignExpressionToRegister(fcall.args[2], RegisterOrPair.A)
-                    val sub = (fcall as FunctionCallStatement).definingSubroutine()!!
-                    asmgen.saveRegister(CpuRegister.X, false, sub)
-                    asmgen.out("  jsr  cx16.memory_fill")
-                    asmgen.restoreRegister(CpuRegister.X, false)
-                }
-                "memcopy" -> {
-                    val count = fcall.args[2].constValue(program)?.number?.toInt()
-                    val countDt = fcall.args[2].inferType(program)
-                    if((count!=null && count <= 255) || countDt.istype(DataType.UBYTE) || countDt.istype(DataType.BYTE)) {
-                        // fast memcopy of up to 255
-                        translateArguments(fcall.args, func, scope)
-                        asmgen.out("  jsr  prog8_lib.func_memcopy255")
-                        return
-                    }
+    private fun funcMemory(fcall: IFunctionCall, discardResult: Boolean, resultToStack: Boolean) {
+        if(discardResult || fcall !is FunctionCall)
+            throw AssemblyError("should not discard result of memory allocation at $fcall")
+        val scope = fcall.definingScope()
+        val nameRef = fcall.args[0] as IdentifierReference
+        val name = (nameRef.targetVarDecl(program.namespace)!!.value as StringLiteralValue).value
+        val size = (fcall.args[1] as NumericLiteralValue).number.toInt()
 
-                    // use the ROM function of the Cx16
-                    asmgen.assignExpressionToVariable(fcall.args[0], "cx16.r0", DataType.UWORD, scope)
-                    asmgen.assignExpressionToVariable(fcall.args[1], "cx16.r1", DataType.UWORD, scope)
-                    asmgen.assignExpressionToVariable(fcall.args[2], "cx16.r2", DataType.UWORD, scope)
-                    val sub = (fcall as FunctionCallStatement).definingSubroutine()!!
-                    asmgen.saveRegister(CpuRegister.X, false, sub)
-                    asmgen.out("  jsr  cx16.memory_copy")
-                    asmgen.restoreRegister(CpuRegister.X, false)
-                }
-                "memsetw" -> {
-                    translateArguments(fcall.args, func, scope)
-                    asmgen.out("  jsr  prog8_lib.func_memsetw")
-                }
-            }
-        } else {
-            if(func.name=="memcopy") {
-                val count = fcall.args[2].constValue(program)?.number?.toInt()
-                val countDt = fcall.args[2].inferType(program)
-                if((count!=null && count <= 255) || countDt.istype(DataType.UBYTE) || countDt.istype(DataType.BYTE)) {
-                    translateArguments(fcall.args, func, scope)
-                    asmgen.out("  jsr  prog8_lib.func_memcopy255")
-                    return
-                }
-            }
-            translateArguments(fcall.args, func, scope)
-            asmgen.out("  jsr  prog8_lib.func_${func.name}")
-        }
+        val existingSize = asmgen.slabs[name]
+        if(existingSize!=null && existingSize!=size)
+            throw AssemblyError("memory slab '$name' already exists with a different size ($size) at ${fcall.position}")
+
+        val slabname = IdentifierReference(listOf("prog8_slabs", name), fcall.position)
+        slabname.linkParents(fcall)
+        val src = AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, DataType.UWORD, expression = AddressOf(slabname, fcall.position))
+        val target =
+            if(resultToStack)
+                AsmAssignTarget(TargetStorageKind.STACK, program, asmgen, DataType.UWORD, null)
+            else
+                AsmAssignTarget.fromRegisters(RegisterOrPair.AY, null, program, asmgen)
+        val assign = AsmAssignment(src, target, false, fcall.position)
+        asmgen.translateNormalAssignment(assign)
+
+        // remove the variable for the name, it's not used as a variable only as a tag for the assembler.
+        val nameDecl = scope.statements.single { it is VarDecl && it.name==nameRef.nameInSource.single() }
+        asmgen.removals.add(Pair(nameDecl, scope))
+        asmgen.slabs[name] = size
     }
 
-    private fun funcStrcmp(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine) {
-        translateArguments(fcall.args, func, scope)
-        if(resultToStack)
-            asmgen.out("  jsr  prog8_lib.func_strcmp_stack")
-        else
-            asmgen.out("  jsr  prog8_lib.func_strcmp")
-    }
-
-    private fun funcSqrt16(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine) {
+    private fun funcSqrt16(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine?) {
         translateArguments(fcall.args, func, scope)
         if(resultToStack)
             asmgen.out("  jsr  prog8_lib.func_sqrt16_stack")
@@ -165,7 +100,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             asmgen.out("  jsr  prog8_lib.func_sqrt16_into_A")
     }
 
-    private fun funcSinCosInt(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine) {
+    private fun funcSinCosInt(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine?) {
         translateArguments(fcall.args, func, scope)
         if(resultToStack)
             asmgen.out("  jsr  prog8_lib.func_${func.name}_stack")
@@ -431,7 +366,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
         asmgen.assignExpressionToVariable(indexerExpr, "prog8_lib.${operation}_array_u${dt}._arg_index", DataType.UBYTE, null)
     }
 
-    private fun funcVariousFloatFuncs(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine) {
+    private fun funcVariousFloatFuncs(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine?) {
         translateArguments(fcall.args, func, scope)
         if(resultToStack)
             asmgen.out("  jsr  floats.func_${func.name}_stack")
@@ -439,7 +374,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             asmgen.out("  jsr  floats.func_${func.name}_fac1")
     }
 
-    private fun funcSgn(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine) {
+    private fun funcSgn(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine?) {
         translateArguments(fcall.args, func, scope)
         val dt = fcall.args.single().inferType(program)
         if(resultToStack) {
@@ -531,20 +466,6 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
         }
     }
 
-    private fun funcStrlen(fcall: IFunctionCall, resultToStack: Boolean) {
-        val name = asmgen.asmVariableName(fcall.args[0] as IdentifierReference)
-        val type = fcall.args[0].inferType(program)
-        when {
-            type.istype(DataType.STR) -> asmgen.out("  lda  #<$name |  ldy  #>$name")
-            type.istype(DataType.UWORD) -> asmgen.out("  lda  $name |  ldy  $name+1")
-            else -> throw AssemblyError("strlen requires str or uword arg")
-        }
-        if(resultToStack)
-            asmgen.out("  jsr  prog8_lib.func_strlen_stack")
-        else
-            asmgen.out("  jsr  prog8_lib.func_strlen_into_A")
-    }
-
     private fun funcSwap(fcall: IFunctionCall) {
         val first = fcall.args[0]
         val second = fcall.args[1]
@@ -922,7 +843,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
         }
     }
 
-    private fun funcAbs(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine) {
+    private fun funcAbs(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, scope: Subroutine?) {
         translateArguments(fcall.args, func, scope)
         val dt = fcall.args.single().inferType(program).typeOrElse(DataType.STRUCT)
         if(resultToStack) {
@@ -1001,6 +922,9 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                 asmgen.out("  sta  P8ESTACK_LO,x |  dex")
         } else {
             asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
+            // NOTE: we rely on the fact that the above assignment to AY, assigns the Lsb to A as the last instruction.
+            //       this is required because the compiler assumes the status bits are set according to what A is (lsb)
+            //       and will not generate another cmp when lsb() is directly used inside a comparison expression.
             if (resultToStack)
                 asmgen.out("  sta  P8ESTACK_LO,x |  dex")
         }
@@ -1020,7 +944,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     """)
     }
 
-    private fun translateArguments(args: MutableList<Expression>, signature: FSignature, scope: Subroutine) {
+    private fun translateArguments(args: MutableList<Expression>, signature: FSignature, scope: Subroutine?) {
         val callConv = signature.callConvention(args.map { it.inferType(program).typeOrElse(DataType.STRUCT) })
 
         fun getSourceForFloat(value: Expression): AsmAssignSource {
@@ -1033,6 +957,9 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     throw AssemblyError("float literals should have been converted into autovar")
                 }
                 else -> {
+                    if(scope==null)
+                        throw AssemblyError("cannot use float arguments outside of a subroutine scope")
+
                     scope.asmGenInfo.usedFloatEvalResultVar2 = true
                     val variable = IdentifierReference(listOf(subroutineFloatEvalResultVar2), value.position)
                     val addr = AddressOf(variable, value.position)

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

@@ -74,6 +74,8 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                         is FunctionCall -> {
                             if(dt in ByteDatatypes) {
                                 asmgen.assignExpressionToRegister(left, RegisterOrPair.A)
+                                if(left is FunctionCall)
+                                    asmgen.out("  cmp  #0")
                                 asmgen.out("  bne  $jumpIfFalseLabel")
                                 return
                             }
@@ -112,6 +114,8 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                         is FunctionCall -> {
                             if(dt in ByteDatatypes) {
                                 asmgen.assignExpressionToRegister(left, RegisterOrPair.A)
+                                if(left is FunctionCall)
+                                    asmgen.out("  cmp  #0")
                                 asmgen.out("  beq  $jumpIfFalseLabel")
                                 return
                             }
@@ -1320,52 +1324,60 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
 +""")
     }
 
-    private fun translateFunctionCallResultOntoStack(expression: FunctionCall) {
+    private fun translateFunctionCallResultOntoStack(call: FunctionCall) {
         // only for use in nested expression evaluation
 
-        val sub = expression.target.targetStatement(program.namespace)
+        val sub = call.target.targetStatement(program.namespace)
         if(sub is BuiltinFunctionStatementPlaceholder) {
             val builtinFunc = BuiltinFunctions.getValue(sub.name)
-            asmgen.translateBuiltinFunctionCallExpression(expression, builtinFunc, true)
+            asmgen.translateBuiltinFunctionCallExpression(call, builtinFunc, true)
         } else {
             sub as Subroutine
-            val preserveStatusRegisterAfterCall = sub.asmReturnvaluesRegisters.any {it.statusflag!=null}
-            asmgen.translateFunctionCall(expression, preserveStatusRegisterAfterCall)
+            asmgen.saveXbeforeCall(call)
+            asmgen.translateFunctionCall(call)
+            if(sub.regXasResult()) {
+                // store the return value in X somewhere that we can acces again below
+                asmgen.out("  stx  P8ZP_SCRATCH_REG")
+            }
+            asmgen.restoreXafterCall(call)
+
             val returns = sub.returntypes.zip(sub.asmReturnvaluesRegisters)
             for ((_, reg) in returns) {
-                // result value in cpu or status registers, put it on the stack
+                // result value is in cpu or status registers, put it on the stack instead (as we're evaluating an expression tree)
                 if (reg.registerOrPair != null) {
                     when (reg.registerOrPair) {
                         RegisterOrPair.A -> asmgen.out("  sta  P8ESTACK_LO,x |  dex")
                         RegisterOrPair.Y -> asmgen.out("  tya |  sta  P8ESTACK_LO,x |  dex")
                         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
-                            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")
-                            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
-                            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")
-                        }
+                        RegisterOrPair.X -> asmgen.out("  lda  P8ZP_SCRATCH_REG |  sta  P8ESTACK_LO,x |  dex")
+                        RegisterOrPair.AX -> asmgen.out("  sta  P8ESTACK_LO,x |  lda  P8ZP_SCRATCH_REG |  sta  P8ESTACK_HI,x |  dex")
+                        RegisterOrPair.XY -> asmgen.out("  tya |  sta  P8ESTACK_HI,x |  lda  P8ZP_SCRATCH_REG |  sta  P8ESTACK_LO,x |  dex")
                         RegisterOrPair.FAC1 -> asmgen.out("  jsr  floats.push_fac1")
                         RegisterOrPair.FAC2 -> asmgen.out("  jsr  floats.push_fac2")
+                        RegisterOrPair.R0,
+                        RegisterOrPair.R1,
+                        RegisterOrPair.R2,
+                        RegisterOrPair.R3,
+                        RegisterOrPair.R4,
+                        RegisterOrPair.R5,
+                        RegisterOrPair.R6,
+                        RegisterOrPair.R7,
+                        RegisterOrPair.R8,
+                        RegisterOrPair.R9,
+                        RegisterOrPair.R10,
+                        RegisterOrPair.R11,
+                        RegisterOrPair.R12,
+                        RegisterOrPair.R13,
+                        RegisterOrPair.R14,
+                        RegisterOrPair.R15 -> {
+                            asmgen.out("""
+                                lda  cx16.${reg.registerOrPair.toString().toLowerCase()}
+                                sta  P8ESTACK_LO,x
+                                lda  cx16.${reg.registerOrPair.toString().toLowerCase()}+1
+                                sta  P8ESTACK_HI,x
+                                dex
+                            """)
+                        }
                     }
                 }
                 else if(reg.statusflag!=null) {
@@ -1947,24 +1959,29 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
         }
     }
 
-    private fun translateBinaryOperatorWords(operator: String, types: DataType) {
+    private fun translateBinaryOperatorWords(operator: String, dt: DataType) {
         when(operator) {
             "**" -> throw AssemblyError("** operator requires floats")
             "*" -> asmgen.out("  jsr  prog8_lib.mul_word")
-            "/" -> asmgen.out(if(types==DataType.UWORD) "  jsr  prog8_lib.idiv_uw" else "  jsr  prog8_lib.idiv_w")
+            "/" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.idiv_uw" else "  jsr  prog8_lib.idiv_w")
             "%" -> {
-                if(types==DataType.WORD)
+                if(dt==DataType.WORD)
                     throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
                 asmgen.out("  jsr prog8_lib.remainder_uw")
             }
             "+" -> asmgen.out("  jsr  prog8_lib.add_w")
             "-" -> asmgen.out("  jsr  prog8_lib.sub_w")
-            "<<" -> throw AssemblyError("<< should not operate via stack")
-            ">>" -> throw AssemblyError(">> should not operate via stack")
-            "<" -> asmgen.out(if(types==DataType.UWORD) "  jsr  prog8_lib.less_uw" else "  jsr  prog8_lib.less_w")
-            ">" -> asmgen.out(if(types==DataType.UWORD) "  jsr  prog8_lib.greater_uw" else "  jsr  prog8_lib.greater_w")
-            "<=" -> asmgen.out(if(types==DataType.UWORD) "  jsr  prog8_lib.lesseq_uw" else "  jsr  prog8_lib.lesseq_w")
-            ">=" -> asmgen.out(if(types==DataType.UWORD) "  jsr  prog8_lib.greatereq_uw" else "  jsr  prog8_lib.greatereq_w")
+            "<<" -> asmgen.out("  jsr  math.shift_left_w")
+            ">>" -> {
+                if(dt==DataType.UWORD)
+                    asmgen.out("  jsr  math.shift_right_uw")
+                else
+                    asmgen.out("  jsr  math.shift_right_w")
+            }
+            "<" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.less_uw" else "  jsr  prog8_lib.less_w")
+            ">" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.greater_uw" else "  jsr  prog8_lib.greater_w")
+            "<=" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.lesseq_uw" else "  jsr  prog8_lib.lesseq_w")
+            ">=" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.greatereq_uw" else "  jsr  prog8_lib.greatereq_w")
             "==" -> asmgen.out("  jsr  prog8_lib.equal_w")
             "!=" -> asmgen.out("  jsr  prog8_lib.notequal_w")            "&" -> asmgen.out("  jsr  prog8_lib.bitand_w")
             "^" -> asmgen.out("  jsr  prog8_lib.bitxor_w")

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

@@ -5,33 +5,54 @@ import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
-import prog8.ast.statements.RegisterOrStatusflag
-import prog8.ast.statements.Subroutine
-import prog8.ast.statements.SubroutineParameter
+import prog8.ast.statements.*
 import prog8.compiler.AssemblyError
+import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.CpuType
 import prog8.compiler.target.c64.codegen.assignment.*
 
 
 internal class FunctionCallAsmGen(private val program: Program, private val asmgen: AsmGen) {
 
     internal fun translateFunctionCallStatement(stmt: IFunctionCall) {
-        val sub = stmt.target.targetSubroutine(program.namespace)!!
-        val preserveStatusRegisterAfterCall = sub.asmReturnvaluesRegisters.any {it.statusflag!=null}
-        translateFunctionCall(stmt, preserveStatusRegisterAfterCall)
-        // functioncalls no longer return results on the stack, so simply ignore the results in the registers
-        if(preserveStatusRegisterAfterCall)
-            asmgen.out("  plp\t; restore status flags from call")
+        saveXbeforeCall(stmt)
+        translateFunctionCall(stmt)
+        restoreXafterCall(stmt)
+        // just ignore any result values from the function call.
     }
 
-
-    internal fun translateFunctionCall(stmt: IFunctionCall, preserveStatusRegisterAfterCall: Boolean) {
-        // output the code to setup the parameters and perform the actual call
-        // does NOT output the code to deal with the result values!
+    internal fun saveXbeforeCall(stmt: IFunctionCall) {
         val sub = stmt.target.targetSubroutine(program.namespace) ?: throw AssemblyError("undefined subroutine ${stmt.target}")
-        val saveX = CpuRegister.X in sub.asmClobbers || sub.regXasResult() || sub.regXasParam()
-        if(saveX)
-            asmgen.saveRegister(CpuRegister.X, preserveStatusRegisterAfterCall, (stmt as Node).definingSubroutine()!!)
+        if(sub.shouldSaveX()) {
+            val regSaveOnStack = sub.asmAddress==null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
+            val (keepAonEntry: Boolean, keepAonReturn: Boolean) = sub.shouldKeepA()
+            if(regSaveOnStack)
+                asmgen.saveRegisterStack(CpuRegister.X, keepAonEntry)
+            else
+                asmgen.saveRegisterLocal(CpuRegister.X, (stmt as Node).definingSubroutine()!!)
+        }
+    }
 
+    internal fun restoreXafterCall(stmt: IFunctionCall) {
+        val sub = stmt.target.targetSubroutine(program.namespace) ?: throw AssemblyError("undefined subroutine ${stmt.target}")
+        if(sub.shouldSaveX()) {
+            val regSaveOnStack = sub.asmAddress==null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
+            val (keepAonEntry: Boolean, keepAonReturn: Boolean) = sub.shouldKeepA()
+
+            if(regSaveOnStack)
+                asmgen.restoreRegisterStack(CpuRegister.X, keepAonReturn)
+            else
+                asmgen.restoreRegisterLocal(CpuRegister.X)
+        }
+    }
+
+    internal fun translateFunctionCall(stmt: IFunctionCall) {
+        // Output only the code to setup the parameters and perform the actual call
+        // NOTE: does NOT output the code to deal with the result values!
+        // NOTE: does NOT output code to save/restore the X register for this call! Every caller should deal with this in their own way!!
+        //       (you can use subroutine.shouldSaveX() and saveX()/restoreX() routines as a help for this)
+
+        val sub = stmt.target.targetSubroutine(program.namespace) ?: throw AssemblyError("undefined subroutine ${stmt.target}")
         val subName = asmgen.asmSymbolName(stmt.target)
         if(stmt.args.isNotEmpty()) {
             if(sub.asmParameterRegisters.isEmpty()) {
@@ -45,37 +66,43 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                     // just a single parameter, no risk of clobbering registers
                     argumentViaRegister(sub, IndexedValue(0, sub.parameters.single()), stmt.args[0])
                 } else {
-                    // multiple register arguments, risk of register clobbering.
-                    // evaluate arguments onto the stack, and load the registers from the evaluated values on the stack.
                     when {
                         stmt.args.all {it is AddressOf ||
                                 it is NumericLiteralValue ||
                                 it is StringLiteralValue ||
                                 it is ArrayLiteralValue ||
                                 it is IdentifierReference} -> {
-                            // no risk of clobbering for these simple argument types. Optimize the register loading.
-                            for(arg in sub.parameters.withIndex().zip(stmt.args)) {
-                                argumentViaRegister(sub, arg.first, arg.second)
-                            }
+                            // There's no risk of clobbering for these simple argument types. Optimize the register loading directly from these values.
+                            val argsInfo = sub.parameters.withIndex().zip(stmt.args).zip(sub.asmParameterRegisters)
+                            val (vregsArgsInfo, otherRegsArgsInfo) = argsInfo.partition { it.second.registerOrPair in Cx16VirtualRegisters }
+                            for(arg in vregsArgsInfo)
+                                argumentViaRegister(sub, arg.first.first, arg.first.second)
+                            for(arg in otherRegsArgsInfo)
+                                argumentViaRegister(sub, arg.first.first, arg.first.second)
                         }
                         else -> {
-                            // Risk of clobbering due to complex expression args. Work via the stack.
+                            // Risk of clobbering due to complex expression args. Evaluate first, then assign registers.
                             registerArgsViaStackEvaluation(stmt, sub)
                         }
                     }
                 }
             }
         }
-        asmgen.out("  jsr  $subName")
 
-        if(preserveStatusRegisterAfterCall) {
-            asmgen.out("  php\t; save status flags from call")
-            // note: the containing statement (such as the FunctionCallStatement or the Assignment or the Expression)
-            //       must take care of popping this value again at the end!
+        if(sub.inline && asmgen.options.optimize) {
+            if(sub.containsDefinedVariables())
+                throw AssemblyError("can't inline sub with vars")
+            if(!sub.isAsmSubroutine && sub.parameters.isNotEmpty())
+                throw AssemblyError("can't inline a non-asm subroutine with parameters")
+            asmgen.out("  \t; inlined routine follows: ${sub.name} from ${sub.position}")
+            val statements = sub.statements.filter { it !is ParameterVarDecl && it !is Directive }
+            statements.forEach { asmgen.translate(it) }
+        }
+        else {
+            asmgen.out("  jsr  $subName")
         }
 
-        if(saveX)
-            asmgen.restoreRegister(CpuRegister.X, preserveStatusRegisterAfterCall)
+        // remember: dealing with the X register and/or dealing with return values is the responsibility of the caller
     }
 
     private fun registerArgsViaStackEvaluation(stmt: IFunctionCall, sub: Subroutine) {
@@ -96,6 +123,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         asmgen.out("  inx")     // align estack pointer
 
         for(argi in stmt.args.zip(sub.asmParameterRegisters).withIndex()) {
+            val plusIdxStr = if(argi.index==0) "" else "+${argi.index}"
             when {
                 argi.value.second.statusflag == Statusflag.Pc -> {
                     require(argForCarry == null)
@@ -111,15 +139,40 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                     argForAregister = argi
                 }
                 argi.value.second.registerOrPair == RegisterOrPair.Y -> {
-                    asmgen.out("  ldy  P8ESTACK_LO+${argi.index},x")
+                    asmgen.out("  ldy  P8ESTACK_LO$plusIdxStr,x")
+                }
+                argi.value.second.registerOrPair in Cx16VirtualRegisters -> {
+                    // immediately output code to load the virtual register, to avoid clobbering the A register later
+                    when (sub.parameters[argi.index].type) {
+                        in ByteDatatypes -> {
+                            // only load the lsb of the virtual register
+                            asmgen.out("""
+                                lda  P8ESTACK_LO$plusIdxStr,x
+                                sta  cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}
+                            """)
+                            if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                asmgen.out("  stz  cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}+1")
+                            else
+                                asmgen.out("  lda  #0 |  sta  cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}+1")
+                        }
+                        in WordDatatypes ->
+                            asmgen.out("""
+                                lda  P8ESTACK_LO$plusIdxStr,x
+                                sta  cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}
+                                lda  P8ESTACK_HI$plusIdxStr,x
+                                sta  cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}+1
+                            """)
+                        else -> throw AssemblyError("weird dt")
+                    }
                 }
                 else -> throw AssemblyError("weird argument")
             }
         }
 
         if(argForCarry!=null) {
+            val plusIdxStr = if(argForCarry.index==0) "" else "+${argForCarry.index}"
             asmgen.out("""
-                lda  P8ESTACK_LO+${argForCarry.index},x
+                lda  P8ESTACK_LO$plusIdxStr,x
                 beq  +
                 sec
                 bcs  ++
@@ -128,21 +181,23 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         }
 
         if(argForAregister!=null) {
+            val plusIdxStr = if(argForAregister.index==0) "" else "+${argForAregister.index}"
             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")
+                RegisterOrPair.A -> asmgen.out("  lda  P8ESTACK_LO$plusIdxStr,x")
+                RegisterOrPair.AY -> asmgen.out("  lda  P8ESTACK_LO$plusIdxStr,x |  ldy  P8ESTACK_HI$plusIdxStr,x")
                 else -> throw AssemblyError("weird arg")
             }
         }
 
         if(argForXregister!=null) {
+            val plusIdxStr = if(argForXregister.index==0) "" else "+${argForXregister.index}"
 
             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")
+                RegisterOrPair.X -> asmgen.out("  lda  P8ESTACK_LO$plusIdxStr,x |  tax")
+                RegisterOrPair.AX -> asmgen.out("  ldy  P8ESTACK_LO$plusIdxStr,x |  lda  P8ESTACK_HI$plusIdxStr,x |  tax |  tya")
+                RegisterOrPair.XY -> asmgen.out("  ldy  P8ESTACK_HI$plusIdxStr,x |  lda  P8ESTACK_LO$plusIdxStr,x |  tax")
                 else -> throw AssemblyError("weird arg")
             }
             if(argForAregister!=null)
@@ -233,7 +288,11 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                     asmgen.assignVariableToRegister(scratchVar, register)
                 }
                 else {
-                    val target = AsmAssignTarget.fromRegisters(register, sub, program, asmgen)
+                    val target: AsmAssignTarget =
+                        if(parameter.value.type in ByteDatatypes && (register==RegisterOrPair.AX || register == RegisterOrPair.AY || register==RegisterOrPair.XY || register in Cx16VirtualRegisters))
+                            AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, parameter.value.type, sub, register = register)
+                        else
+                            AsmAssignTarget.fromRegisters(register, sub, program, asmgen)
                     val src = if(valueDt in PassByReferenceDatatypes) {
                         if(value is IdentifierReference) {
                             val addr = AddressOf(value, Position.DUMMY)

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

@@ -91,7 +91,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                 else
                 {
                     asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, elementDt, CpuRegister.A)
-                    asmgen.saveRegister(CpuRegister.X, false, scope!!)
+                    asmgen.saveRegisterLocal(CpuRegister.X, scope!!)
                     asmgen.out("  tax")
                     when(elementDt) {
                         in ByteDatatypes -> {
@@ -105,7 +105,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
     lda  $asmArrayvarname,x
     bne  +
     dec  $asmArrayvarname+1,x
-+       dec  $asmArrayvarname 
++       dec  $asmArrayvarname,x 
 """)
                         }
                         DataType.FLOAT -> {
@@ -119,7 +119,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                         }
                         else -> throw AssemblyError("weird array elt dt")
                     }
-                    asmgen.restoreRegister(CpuRegister.X, false)
+                    asmgen.restoreRegisterLocal(CpuRegister.X)
                 }
             }
         }

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

@@ -77,6 +77,22 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
                     RegisterOrPair.XY -> AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.UWORD, scope, register = registers)
                     RegisterOrPair.FAC1,
                     RegisterOrPair.FAC2 -> AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.FLOAT, scope, register = registers)
+                    RegisterOrPair.R0,
+                    RegisterOrPair.R1,
+                    RegisterOrPair.R2,
+                    RegisterOrPair.R3,
+                    RegisterOrPair.R4,
+                    RegisterOrPair.R5,
+                    RegisterOrPair.R6,
+                    RegisterOrPair.R7,
+                    RegisterOrPair.R8,
+                    RegisterOrPair.R9,
+                    RegisterOrPair.R10,
+                    RegisterOrPair.R11,
+                    RegisterOrPair.R12,
+                    RegisterOrPair.R13,
+                    RegisterOrPair.R14,
+                    RegisterOrPair.R15 -> AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.UWORD, scope, register = registers)
                 }
     }
 }
@@ -134,7 +150,7 @@ internal class AsmAssignSource(val kind: SourceStorageKind,
                 is FunctionCall -> {
                     when (val sub = value.target.targetStatement(program.namespace)) {
                         is Subroutine -> {
-                            val returnType = sub.returntypes.zip(sub.asmReturnvaluesRegisters).firstOrNull { rr -> rr.second.registerOrPair != null }?.first
+                            val returnType = sub.returntypes.zip(sub.asmReturnvaluesRegisters).firstOrNull { rr -> rr.second.registerOrPair != null || rr.second.statusflag!=null }?.first
                                     ?: throw AssemblyError("can't translate zero return values in assignment")
 
                             AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, returnType, expression = value)

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

@@ -142,11 +142,13 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     is FunctionCall -> {
                         when (val sub = value.target.targetStatement(program.namespace)) {
                             is Subroutine -> {
-                                val preserveStatusRegisterAfterCall = sub.asmReturnvaluesRegisters.any { it.statusflag != null }
-                                asmgen.translateFunctionCall(value, preserveStatusRegisterAfterCall)
-                                val returnValue = sub.returntypes.zip(sub.asmReturnvaluesRegisters).single { it.second.registerOrPair!=null }
+                                asmgen.saveXbeforeCall(value)
+                                asmgen.translateFunctionCall(value)
+                                val returnValue = sub.returntypes.zip(sub.asmReturnvaluesRegisters).singleOrNull { it.second.registerOrPair!=null } ?:
+                                    sub.returntypes.zip(sub.asmReturnvaluesRegisters).single { it.second.statusflag!=null }
                                 when (returnValue.first) {
                                     DataType.STR -> {
+                                        asmgen.restoreXafterCall(value)
                                         when(assign.target.datatype) {
                                             DataType.UWORD -> {
                                                 // assign the address of the string result value
@@ -168,9 +170,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                                     }
                                     DataType.FLOAT -> {
                                         // float result from function sits in FAC1
+                                        asmgen.restoreXafterCall(value)
                                         assignFAC1float(assign.target)
                                     }
                                     else -> {
+                                        // do NOT restore X register before assigning the result values first
                                         when (returnValue.second.registerOrPair) {
                                             RegisterOrPair.A -> assignRegisterByte(assign.target, CpuRegister.A)
                                             RegisterOrPair.X -> assignRegisterByte(assign.target, CpuRegister.X)
@@ -178,12 +182,18 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                                             RegisterOrPair.AX -> assignRegisterpairWord(assign.target, RegisterOrPair.AX)
                                             RegisterOrPair.AY -> assignRegisterpairWord(assign.target, RegisterOrPair.AY)
                                             RegisterOrPair.XY -> assignRegisterpairWord(assign.target, RegisterOrPair.XY)
-                                            else -> throw AssemblyError("should be just one register byte result value")
+                                            else -> {
+                                                val sflag = returnValue.second.statusflag
+                                                if(sflag!=null)
+                                                    assignStatusFlagByte(assign.target, sflag)
+                                                else
+                                                    throw AssemblyError("should be just one register byte result value")
+                                            }
                                         }
+                                        // we've processed the result value in the X register by now, so it's now finally safe to restore it
+                                        asmgen.restoreXafterCall(value)
                                     }
                                 }
-                                if (preserveStatusRegisterAfterCall)
-                                    asmgen.out("  plp\t; restore status flags from call")
                             }
                             is BuiltinFunctionStatementPlaceholder -> {
                                 val signature = BuiltinFunctions.getValue(sub.name)
@@ -194,7 +204,22 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                                 when(returntype.typeOrElse(DataType.STRUCT)) {
                                     in ByteDatatypes -> assignRegisterByte(assign.target, CpuRegister.A)            // function's byte result is in A
                                     in WordDatatypes -> assignRegisterpairWord(assign.target, RegisterOrPair.AY)    // function's word result is in AY
-                                    DataType.STR -> throw AssemblyError("missing code for assign string from builtin func => copy string or assign string address")
+                                    DataType.STR -> {
+                                        when (assign.target.datatype) {
+                                            DataType.STR -> {
+                                                asmgen.out("""
+                                                    pha
+                                                    lda  #<${assign.target.asmVarname}
+                                                    sta  P8ZP_SCRATCH_W1
+                                                    lda  #>${assign.target.asmVarname}
+                                                    sta  P8ZP_SCRATCH_W1+1
+                                                    pla
+                                                    jsr  prog8_lib.strcpy""")
+                                            }
+                                            DataType.UWORD -> assignRegisterpairWord(assign.target, RegisterOrPair.AY)
+                                            else -> throw AssemblyError("str return value type mismatch with target")
+                                        }
+                                    }
                                     DataType.FLOAT -> {
                                         // float result from function sits in FAC1
                                         assignFAC1float(assign.target)
@@ -211,12 +236,12 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         // Everything else just evaluate via the stack.
                         // (we can't use the assignment helper functions to do it via registers here,
                         // because the code here is the implementation of exactly that...)
-                        if(value.parent is Return) {
+                        if (value.parent is Return) {
                             if (this.asmgen.options.slowCodegenWarnings)
                                 println("warning: slow stack evaluation used for return: $value  target=${assign.target.kind} at ${value.position}")
                         }
-                        asmgen.translateExpression(value)
-                        if(assign.target.datatype in WordDatatypes && assign.source.datatype in ByteDatatypes)
+                        exprAsmgen.translateExpression(value)
+                        if (assign.target.datatype in WordDatatypes && assign.source.datatype in ByteDatatypes)
                             asmgen.signExtendStackLsb(assign.source.datatype)
                         assignStackValue(assign.target)
                     }
@@ -231,6 +256,24 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
+    private fun assignStatusFlagByte(target: AsmAssignTarget, statusflag: Statusflag) {
+        when(statusflag) {
+            Statusflag.Pc -> {
+                asmgen.out("  lda  #0 |  rol  a")
+            }
+            Statusflag.Pv -> {
+                asmgen.out("""
+                    bvs  +
+                    lda  #0
+                    beq  ++
++                   lda  #1
++""")
+            }
+            else -> throw AssemblyError("can't use Z or N flags as return 'values'")
+        }
+        assignRegisterByte(target, CpuRegister.A)
+    }
+
     private fun assignTypeCastedValue(target: AsmAssignTarget, targetDt: DataType, value: Expression, origTypeCastExpression: TypecastExpression) {
         val valueIDt = value.inferType(program)
         if(!valueIDt.isKnown)
@@ -297,6 +340,52 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             return
         }
 
+        if(origTypeCastExpression.type == DataType.UBYTE) {
+            val parentTc = origTypeCastExpression.parent as? TypecastExpression
+            if(parentTc!=null && parentTc.type==DataType.UWORD) {
+                // typecast something to ubyte and directly back to uword
+                // generate code for lsb(value) here instead of the ubyte typecast
+                return assignCastViaLsbFunc(value, target)
+            }
+        }
+
+        if(valueDt==DataType.UBYTE) {
+            when(target.register) {
+                RegisterOrPair.A,
+                RegisterOrPair.X,
+                RegisterOrPair.Y -> {
+                    // 'cast' a ubyte value to a byte register; no cast needed at all
+                    return assignExpressionToRegister(value, target.register)
+                }
+                RegisterOrPair.AX,
+                RegisterOrPair.AY,
+                RegisterOrPair.XY,
+                in Cx16VirtualRegisters -> {
+                    // cast an ubyte value to a 16 bits register, just assign it and make use of the value extension
+                    return assignExpressionToRegister(value, target.register!!)
+                }
+                else -> {}
+            }
+        } else if(valueDt==DataType.UWORD) {
+            when(target.register) {
+                RegisterOrPair.A,
+                RegisterOrPair.X,
+                RegisterOrPair.Y -> {
+                    // cast an uword to a byte register, do this via lsb(value)
+                    // generate code for lsb(value) here instead of the ubyte typecast
+                    return assignCastViaLsbFunc(value, target)
+                }
+                RegisterOrPair.AX,
+                RegisterOrPair.AY,
+                RegisterOrPair.XY,
+                in Cx16VirtualRegisters -> {
+                    // 'cast' uword into a 16 bits register, just assign it
+                    return assignExpressionToRegister(value, target.register!!)
+                }
+                else -> {}
+            }
+        }
+
         // give up, do it via eval stack
         // TODO optimize typecasts for more special cases?
         // note: cannot use assignTypeCastedValue because that is ourselves :P
@@ -306,6 +395,14 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         assignStackValue(target)
     }
 
+    private fun assignCastViaLsbFunc(value: Expression, target: AsmAssignTarget) {
+        val lsb = FunctionCall(IdentifierReference(listOf("lsb"), value.position), mutableListOf(value), value.position)
+        lsb.linkParents(value.parent)
+        val src = AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, DataType.UBYTE, expression = lsb)
+        val assign = AsmAssignment(src, target, false, value.position)
+        translateNormalAssignment(assign)
+    }
+
     private fun assignTypecastedFloatFAC1(targetAsmVarName: String, targetDt: DataType) {
 
         if(targetDt==DataType.FLOAT)
@@ -686,16 +783,34 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                             RegisterOrPair.A -> asmgen.out(" inx |  lda  P8ESTACK_LO,x")
                             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")
-                            RegisterOrPair.AX -> asmgen.out(" inx |  lda  P8ESTACK_LO,x |  ldx  #0")
-                            RegisterOrPair.AY -> asmgen.out(" inx |  lda  P8ESTACK_LO,x |  ldy  #0")
+                            RegisterOrPair.AX -> asmgen.out(" inx |  txy |  ldx  #0 |  lda  P8ESTACK_LO,y")
+                            RegisterOrPair.AY -> asmgen.out(" inx |  ldy  #0 |  lda  P8ESTACK_LO,x")
+                            in Cx16VirtualRegisters -> {
+                                asmgen.out("""
+                                    inx
+                                    lda  P8ESTACK_LO,x
+                                    sta  cx16.${target.register.toString().toLowerCase()}
+                                    lda  #0
+                                    sta  cx16.${target.register.toString().toLowerCase()}+1
+                                """)
+                            }
                             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 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.AY-> asmgen.out(" inx |  ldy  P8ESTACK_HI,x |  lda  P8ESTACK_LO,x")
                             RegisterOrPair.XY-> throw AssemblyError("can't load X from stack here - use intermediary var? ${target.origAstTarget?.position}")
+                            in Cx16VirtualRegisters -> {
+                                asmgen.out("""
+                                    inx
+                                    lda  P8ESTACK_LO,x
+                                    sta  cx16.${target.register.toString().toLowerCase()}
+                                    lda  P8ESTACK_HI,x
+                                    sta  cx16.${target.register.toString().toLowerCase()}+1
+                                """)
+                            }
                             else -> throw AssemblyError("can't assign word to single byte register")
                         }
                     }
@@ -725,16 +840,25 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     """)
             }
             TargetStorageKind.MEMORY -> {
-                throw AssemblyError("no asm gen for assign address $sourceName to memory word $target")
+                throw AssemblyError("can't store word into memory byte")
             }
             TargetStorageKind.ARRAY -> {
-                throw AssemblyError("no asm gen for assign address $sourceName to array ${target.asmVarname}")
+                asmgen.out("  lda  #<$sourceName |  ldy #>$sourceName")
+                assignRegisterpairWord(target, RegisterOrPair.AY)
             }
             TargetStorageKind.REGISTER -> {
                 when(target.register!!) {
-                    RegisterOrPair.AX -> asmgen.out("  lda  #<$sourceName |  ldx  #>$sourceName")
-                    RegisterOrPair.AY -> asmgen.out("  lda  #<$sourceName |  ldy  #>$sourceName")
-                    RegisterOrPair.XY -> asmgen.out("  ldx  #<$sourceName |  ldy  #>$sourceName")
+                    RegisterOrPair.AX -> asmgen.out("  ldx  #>$sourceName |  lda  #<$sourceName")
+                    RegisterOrPair.AY -> asmgen.out("  ldy  #>$sourceName |  lda  #<$sourceName")
+                    RegisterOrPair.XY -> asmgen.out("  ldy  #>$sourceName |  ldx  #<$sourceName")
+                    in Cx16VirtualRegisters -> {
+                        asmgen.out("""
+                            lda  #<$sourceName
+                            sta  cx16.${target.register.toString().toLowerCase()}
+                            lda  #>$sourceName
+                            sta  cx16.${target.register.toString().toLowerCase()}+1
+                        """)
+                    }
                     else -> throw AssemblyError("can't load address in a single 8-bit register")
                 }
             }
@@ -755,10 +879,10 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 when(target.datatype) {
                     DataType.UWORD -> {
                         asmgen.out("""
-                            lda #<$sourceName
-                            ldy #>$sourceName
-                            sta ${target.asmVarname}
-                            sty ${target.asmVarname}+1
+                            lda  #<$sourceName
+                            ldy  #>$sourceName
+                            sta  ${target.asmVarname}
+                            sty  ${target.asmVarname}+1
                         """)
                     }
                     DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B -> {
@@ -865,9 +989,17 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             }
             TargetStorageKind.REGISTER -> {
                 when(target.register!!) {
-                    RegisterOrPair.AX -> asmgen.out("  lda  $sourceName |  ldx  $sourceName+1")
-                    RegisterOrPair.AY -> asmgen.out("  lda  $sourceName |  ldy  $sourceName+1")
-                    RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName |  ldy  $sourceName+1")
+                    RegisterOrPair.AX -> asmgen.out("  ldx  $sourceName+1 |  lda  $sourceName")
+                    RegisterOrPair.AY -> asmgen.out("  ldy  $sourceName+1 |  lda  $sourceName")
+                    RegisterOrPair.XY -> asmgen.out("  ldy  $sourceName+1 |  ldx  $sourceName")
+                    in Cx16VirtualRegisters -> {
+                        asmgen.out("""
+                            lda  $sourceName
+                            sta  cx16.${target.register.toString().toLowerCase()}
+                            lda  $sourceName+1
+                            sta  cx16.${target.register.toString().toLowerCase()}+1
+                        """)
+                    }
                     else -> throw AssemblyError("can't load word in a single 8-bit register")
                 }
             }
@@ -1029,10 +1161,19 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     RegisterOrPair.A -> asmgen.out("  lda  $sourceName")
                     RegisterOrPair.X -> asmgen.out("  ldx  $sourceName")
                     RegisterOrPair.Y -> asmgen.out("  ldy  $sourceName")
-                    RegisterOrPair.AX -> asmgen.out("  lda  $sourceName |  ldx  #0")
-                    RegisterOrPair.AY -> asmgen.out("  lda  $sourceName |  ldy  #0")
-                    RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName |  ldy  #0")
+                    RegisterOrPair.AX -> asmgen.out("  ldx  #0 |  lda  $sourceName")
+                    RegisterOrPair.AY -> asmgen.out("  ldy  #0 |  lda  $sourceName")
+                    RegisterOrPair.XY -> asmgen.out("  ldy  #0 |  ldx  $sourceName")
                     RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
+                    in Cx16VirtualRegisters -> {
+                        asmgen.out("""
+                            lda  $sourceName
+                            sta  cx16.${target.register.toString().toLowerCase()}
+                            lda  #0
+                            sta  cx16.${target.register.toString().toLowerCase()}+1
+                            """)
+                    }
+                    else -> throw AssemblyError("weird register")
                 }
             }
             TargetStorageKind.STACK -> {
@@ -1110,45 +1251,54 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         val sourceName = asmgen.asmVariableName(bytevar)
         when(wordtarget.kind) {
             TargetStorageKind.VARIABLE -> {
-                asmgen.out("""
-                    lda  $sourceName
-                    sta  ${wordtarget.asmVarname}
-                    lda  #0
-                    sta  ${wordtarget.asmVarname}+1
-                    """)
+                asmgen.out("  lda  $sourceName |  sta  ${wordtarget.asmVarname}")
+                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    asmgen.out("  stz  ${wordtarget.asmVarname}+1")
+                else
+                    asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
             }
             TargetStorageKind.ARRAY -> {
                 if (wordtarget.constArrayIndexValue!=null) {
                     val scaledIdx = wordtarget.constArrayIndexValue!! * 2
-                    asmgen.out(" lda  $sourceName  | sta  ${wordtarget.asmVarname}+$scaledIdx |  lda  #0  | sta  ${wordtarget.asmVarname}+$scaledIdx+1")
+                    asmgen.out("  lda  $sourceName  | sta  ${wordtarget.asmVarname}+$scaledIdx")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  ${wordtarget.asmVarname}+$scaledIdx+1")
+                    else
+                        asmgen.out("  lda  #0  | sta  ${wordtarget.asmVarname}+$scaledIdx+1")
                 }
                 else {
                     asmgen.loadScaledArrayIndexIntoRegister(wordtarget.array!!, wordtarget.datatype, CpuRegister.Y)
-                    asmgen.out(" lda  $sourceName |  sta  ${wordtarget.asmVarname},y |  lda  #0 |  iny |  sta  ${wordtarget.asmVarname},y")
+                    asmgen.out("""
+                        lda  $sourceName
+                        sta  ${wordtarget.asmVarname},y
+                        iny
+                        lda  #0
+                        sta  ${wordtarget.asmVarname},y""")
                 }
             }
             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")
+                    RegisterOrPair.AX -> asmgen.out("  ldx  #0 |  lda  $sourceName")
+                    RegisterOrPair.AY -> asmgen.out("  ldy  #0 |  lda  $sourceName")
+                    RegisterOrPair.XY -> asmgen.out("  ldy  #0 |  ldx  $sourceName")
                     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""")
+                asmgen.out("  lda  $sourceName |  sta  P8ESTACK_LO,x")
+                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    asmgen.out("  stz  P8ESTACK_HI,x |  dex")
+                else
+                    asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
             }
             else -> throw AssemblyError("target type isn't word")
         }
     }
 
     internal fun assignRegisterByte(target: AsmAssignTarget, register: CpuRegister) {
-        require(target.datatype in ByteDatatypes)
+        if(target.register !in Cx16VirtualRegisters)
+            require(target.datatype in ByteDatatypes)
+
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
                 asmgen.out("  st${register.name.toLowerCase()}  ${target.asmVarname}")
@@ -1157,22 +1307,20 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 storeRegisterInMemoryAddress(register, target.memory!!)
             }
             TargetStorageKind.ARRAY -> {
-                when {
-                    target.constArrayIndexValue!=null -> {
-                        when (register) {
-                            CpuRegister.A -> asmgen.out("  sta  ${target.asmVarname}+${target.constArrayIndexValue}")
-                            CpuRegister.X -> asmgen.out("  stx  ${target.asmVarname}+${target.constArrayIndexValue}")
-                            CpuRegister.Y -> asmgen.out("  sty  ${target.asmVarname}+${target.constArrayIndexValue}")
-                        }
+                if (target.constArrayIndexValue!=null) {
+                    when (register) {
+                        CpuRegister.A -> asmgen.out("  sta  ${target.asmVarname}+${target.constArrayIndexValue}")
+                        CpuRegister.X -> asmgen.out("  stx  ${target.asmVarname}+${target.constArrayIndexValue}")
+                        CpuRegister.Y -> asmgen.out("  sty  ${target.asmVarname}+${target.constArrayIndexValue}")
                     }
-                    else -> {
-                        when (register) {
-                            CpuRegister.A -> {}
-                            CpuRegister.X -> asmgen.out(" txa")
-                            CpuRegister.Y -> asmgen.out(" tya")
-                        }
-                        asmgen.out(" ldy  ${asmgen.asmVariableName(target.array!!.indexer.indexVar!!)} |  sta  ${target.asmVarname},y")
+                }
+                else {
+                    when (register) {
+                        CpuRegister.A -> {}
+                        CpuRegister.X -> asmgen.out(" txa")
+                        CpuRegister.Y -> asmgen.out(" tya")
                     }
+                    asmgen.out(" ldy  ${asmgen.asmVariableName(target.array!!.indexer.indexVar!!)} |  sta  ${target.asmVarname},y")
                 }
             }
             TargetStorageKind.REGISTER -> {
@@ -1185,6 +1333,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AX -> { asmgen.out("  ldx  #0") }
                         RegisterOrPair.XY -> { asmgen.out("  tax |  ldy  #0") }
                         RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected type cast to float")
+                        in Cx16VirtualRegisters -> {
+                            // only assign a single byte to the virtual register's Lsb
+                            asmgen.out("  sta  cx16.${target.register.toString().toLowerCase()}")
+                        }
+                        else -> throw AssemblyError("weird register")
                     }
                     CpuRegister.X -> when(target.register!!) {
                         RegisterOrPair.A -> { asmgen.out("  txa") }
@@ -1194,6 +1347,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AX -> { asmgen.out("  txa |  ldx  #0") }
                         RegisterOrPair.XY -> { asmgen.out("  ldy  #0") }
                         RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected type cast to float")
+                        in Cx16VirtualRegisters -> {
+                            // only assign a single byte to the virtual register's Lsb
+                            asmgen.out("  stx  cx16.${target.register.toString().toLowerCase()}")
+                        }
+                        else -> throw AssemblyError("weird register")
                     }
                     CpuRegister.Y -> when(target.register!!) {
                         RegisterOrPair.A -> { asmgen.out("  tya") }
@@ -1203,6 +1361,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AX -> { asmgen.out("  tya |  ldx  #0") }
                         RegisterOrPair.XY -> { asmgen.out("  tya |  tax |  ldy  #0") }
                         RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected type cast to float")
+                        in Cx16VirtualRegisters -> {
+                            // only assign a single byte to the virtual register's Lsb
+                            asmgen.out("  sty  cx16.${target.register.toString().toLowerCase()}")
+                        }
+                        else -> throw AssemblyError("weird register")
                     }
                 }
             }
@@ -1231,20 +1394,30 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 }
             }
             TargetStorageKind.ARRAY -> {
-                // TODO can be a bit more optimized if the array indexer is a number
-                when(regs) {
-                    RegisterOrPair.AX -> asmgen.out("  pha |  txa |  pha")
-                    RegisterOrPair.AY -> asmgen.out("  pha |  tya |  pha")
-                    RegisterOrPair.XY -> asmgen.out("  txa |  pha |  tya |  pha")
-                    else -> throw AssemblyError("expected reg pair")
+                if (target.constArrayIndexValue!=null) {
+                    val idx = target.constArrayIndexValue!! * 2
+                    when (regs) {
+                        RegisterOrPair.AX -> asmgen.out("  sta  ${target.asmVarname}+$idx |  stx  ${target.asmVarname}+$idx+1")
+                        RegisterOrPair.AY -> asmgen.out("  sta  ${target.asmVarname}+$idx |  sty  ${target.asmVarname}+$idx+1")
+                        RegisterOrPair.XY -> asmgen.out("  stx  ${target.asmVarname}+$idx |  sty  ${target.asmVarname}+$idx+1")
+                        else -> throw AssemblyError("expected reg pair")
+                    }
                 }
-                asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UWORD, CpuRegister.Y, true)
-                asmgen.out("""
-                    pla
-                    sta  ${target.asmVarname},y
-                    dey
-                    pla
-                    sta  ${target.asmVarname},y""")
+                else {
+                    when(regs) {
+                        RegisterOrPair.AX -> asmgen.out("  pha |  txa |  pha")
+                        RegisterOrPair.AY -> asmgen.out("  pha |  tya |  pha")
+                        RegisterOrPair.XY -> asmgen.out("  txa |  pha |  tya |  pha")
+                        else -> throw AssemblyError("expected reg pair")
+                    }
+                    asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UWORD, CpuRegister.Y, true)
+                    asmgen.out("""
+                        pla
+                        sta  ${target.asmVarname},y
+                        dey
+                        pla
+                        sta  ${target.asmVarname},y""")
+                    }
             }
             TargetStorageKind.REGISTER -> {
                 when(regs) {
@@ -1252,18 +1425,36 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AY -> { asmgen.out("  stx  P8ZP_SCRATCH_REG |  ldy  P8ZP_SCRATCH_REG") }
                         RegisterOrPair.AX -> { }
                         RegisterOrPair.XY -> { asmgen.out("  stx  P8ZP_SCRATCH_REG |  ldy  P8ZP_SCRATCH_REG |  tax") }
+                        in Cx16VirtualRegisters -> {
+                            asmgen.out("""
+                                    sta  cx16.${target.register.toString().toLowerCase()}
+                                    stx  cx16.${target.register.toString().toLowerCase()}+1
+                                """)
+                        }
                         else -> throw AssemblyError("expected reg pair")
                     }
                     RegisterOrPair.AY -> when(target.register!!) {
                         RegisterOrPair.AY -> { }
                         RegisterOrPair.AX -> { asmgen.out("  sty  P8ZP_SCRATCH_REG |  ldx  P8ZP_SCRATCH_REG") }
                         RegisterOrPair.XY -> { asmgen.out("  tax") }
+                        in Cx16VirtualRegisters -> {
+                            asmgen.out("""
+                                    sta  cx16.${target.register.toString().toLowerCase()}
+                                    sty  cx16.${target.register.toString().toLowerCase()}+1
+                                """)
+                        }
                         else -> throw AssemblyError("expected reg pair")
                     }
                     RegisterOrPair.XY -> when(target.register!!) {
                         RegisterOrPair.AY -> { asmgen.out("  txa") }
                         RegisterOrPair.AX -> { asmgen.out("  txa |  sty  P8ZP_SCRATCH_REG |  ldx  P8ZP_SCRATCH_REG") }
                         RegisterOrPair.XY -> { }
+                        in Cx16VirtualRegisters -> {
+                            asmgen.out("""
+                                    stx  cx16.${target.register.toString().toLowerCase()}
+                                    sty  cx16.${target.register.toString().toLowerCase()}+1
+                                """)
+                        }
                         else -> throw AssemblyError("expected reg pair")
                     }
                     else -> throw AssemblyError("expected reg pair")
@@ -1281,6 +1472,43 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
     }
 
     private fun assignConstantWord(target: AsmAssignTarget, word: Int) {
+        if(word==0 && CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+            // optimize setting zero value for this processor
+            when(target.kind) {
+                TargetStorageKind.VARIABLE -> {
+                    asmgen.out("  stz  ${target.asmVarname} |  stz  ${target.asmVarname}+1")
+                }
+                TargetStorageKind.MEMORY -> {
+                    throw AssemblyError("no asm gen for assign word $word to memory ${target.memory}")
+                }
+                TargetStorageKind.ARRAY -> {
+                    asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UWORD, CpuRegister.Y)
+                    asmgen.out("""
+                        lda  #0
+                        sta  ${target.asmVarname},y
+                        sta  ${target.asmVarname}+1,y
+                    """)
+                }
+                TargetStorageKind.REGISTER -> {
+                    when(target.register!!) {
+                        RegisterOrPair.AX -> asmgen.out("  lda  #0 |  tax")
+                        RegisterOrPair.AY -> asmgen.out("  lda  #0 |  tay")
+                        RegisterOrPair.XY -> asmgen.out("  ldx  #0 |  ldy  #0")
+                        in Cx16VirtualRegisters -> {
+                            asmgen.out("  stz  cx16.${target.register.toString().toLowerCase()} |  stz  cx16.${target.register.toString().toLowerCase()}+1")
+                        }
+                        else -> throw AssemblyError("invalid register for word value")
+                    }
+                }
+                TargetStorageKind.STACK -> {
+                    asmgen.out("  stz  P8ESTACK_LO,x |  stz  P8ESTACK_HI,x |  dex")
+                }
+            }
+
+            return
+        }
+
+
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
                 if (word ushr 8 == word and 255) {
@@ -1313,10 +1541,18 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             }
             TargetStorageKind.REGISTER -> {
                 when(target.register!!) {
-                    RegisterOrPair.AX -> asmgen.out("  lda  #<${word.toHex()} |  ldx  #>${word.toHex()}")
-                    RegisterOrPair.AY -> asmgen.out("  lda  #<${word.toHex()} |  ldy  #>${word.toHex()}")
-                    RegisterOrPair.XY -> asmgen.out("  ldx  #<${word.toHex()} |  ldy  #>${word.toHex()}")
-                    else -> throw AssemblyError("can't assign word to single byte register")
+                    RegisterOrPair.AX -> asmgen.out("  ldx  #>${word.toHex()} |  lda  #<${word.toHex()}")
+                    RegisterOrPair.AY -> asmgen.out("  ldy  #>${word.toHex()} |  lda  #<${word.toHex()}")
+                    RegisterOrPair.XY -> asmgen.out("  ldy  #>${word.toHex()} |  ldx  #<${word.toHex()}")
+                    in Cx16VirtualRegisters -> {
+                        asmgen.out("""
+                            lda  #<${word.toHex()}
+                            sta  cx16.${target.register.toString().toLowerCase()}
+                            lda  #>${word.toHex()}
+                            sta  cx16.${target.register.toString().toLowerCase()}+1
+                            """)
+                    }
+                    else -> throw AssemblyError("invalid register for word value")
                 }
             }
             TargetStorageKind.STACK -> {
@@ -1331,6 +1567,47 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
     }
 
     private fun assignConstantByte(target: AsmAssignTarget, byte: Short) {
+        if(byte==0.toShort() && CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+            // optimize setting zero value for this cpu
+            when(target.kind) {
+                TargetStorageKind.VARIABLE -> {
+                    asmgen.out("  stz  ${target.asmVarname} ")
+                }
+                TargetStorageKind.MEMORY -> {
+                    storeByteViaRegisterAInMemoryAddress("#${byte.toHex()}", target.memory!!)
+                }
+                TargetStorageKind.ARRAY -> {
+                    if (target.constArrayIndexValue!=null) {
+                        val indexValue = target.constArrayIndexValue!!
+                        asmgen.out("  stz  ${target.asmVarname}+$indexValue")
+                    }
+                    else {
+                        asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UBYTE, CpuRegister.Y)
+                        asmgen.out("  lda  #0 |  sta  ${target.asmVarname},y")
+                    }
+                }
+                TargetStorageKind.REGISTER -> when(target.register!!) {
+                    RegisterOrPair.A -> asmgen.out("  lda  #0")
+                    RegisterOrPair.X -> asmgen.out("  ldx  #0")
+                    RegisterOrPair.Y -> asmgen.out("  ldy  #0")
+                    RegisterOrPair.AX -> asmgen.out("  lda  #0 |  tax")
+                    RegisterOrPair.AY -> asmgen.out("  lda  #0 |  tay")
+                    RegisterOrPair.XY -> asmgen.out("  ldx  #0 |  ldy  #0")
+                    RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
+                    in Cx16VirtualRegisters -> {
+                        asmgen.out("  stz  cx16.${target.register.toString().toLowerCase()} |  stz  cx16.${target.register.toString().toLowerCase()}+1")
+                    }
+                    else -> throw AssemblyError("weird register")
+                }
+                TargetStorageKind.STACK -> {
+                    asmgen.out("  stz  P8ESTACK_LO,x |  dex")
+                }
+            }
+
+            return
+        }
+
+
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
                 asmgen.out("  lda  #${byte.toHex()} |  sta  ${target.asmVarname} ")
@@ -1352,10 +1629,18 @@ 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()}")
-                RegisterOrPair.AX -> asmgen.out("  lda  #${byte.toHex()} |  ldx  #0")
-                RegisterOrPair.AY -> asmgen.out("  lda  #${byte.toHex()} |  ldy  #0")
-                RegisterOrPair.XY -> asmgen.out("  ldx  #${byte.toHex()} |  ldy  #0")
+                RegisterOrPair.AX -> asmgen.out("  ldx  #0 |  lda  #${byte.toHex()}")
+                RegisterOrPair.AY -> asmgen.out("  ldy  #0 |  lda  #${byte.toHex()}")
+                RegisterOrPair.XY -> asmgen.out("  ldy  #0 |  ldx  #${byte.toHex()}")
                 RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
+                in Cx16VirtualRegisters -> {
+                    asmgen.out("  lda  #${byte.toHex()} |  sta  cx16.${target.register.toString().toLowerCase()}")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  cx16.${target.register.toString().toLowerCase()}+1\n")
+                    else
+                        asmgen.out("  lda  #0 |  sta  cx16.${target.register.toString().toLowerCase()}+1\n")
+                }
+                else -> throw AssemblyError("weird register")
             }
             TargetStorageKind.STACK -> {
                 asmgen.out("""
@@ -1392,14 +1677,23 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 TargetStorageKind.ARRAY -> {
                     if (target.array!!.indexer.indexNum!=null) {
                         val indexValue = target.array.indexer.constIndex()!! * DataType.FLOAT.memorySize()
-                        asmgen.out("""
-                            lda  #0
-                            sta  ${target.asmVarname}+$indexValue
-                            sta  ${target.asmVarname}+$indexValue+1
-                            sta  ${target.asmVarname}+$indexValue+2
-                            sta  ${target.asmVarname}+$indexValue+3
-                            sta  ${target.asmVarname}+$indexValue+4
-                        """)
+                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            asmgen.out("""
+                                stz  ${target.asmVarname}+$indexValue
+                                stz  ${target.asmVarname}+$indexValue+1
+                                stz  ${target.asmVarname}+$indexValue+2
+                                stz  ${target.asmVarname}+$indexValue+3
+                                stz  ${target.asmVarname}+$indexValue+4
+                            """)
+                        else
+                            asmgen.out("""
+                                lda  #0
+                                sta  ${target.asmVarname}+$indexValue
+                                sta  ${target.asmVarname}+$indexValue+1
+                                sta  ${target.asmVarname}+$indexValue+2
+                                sta  ${target.asmVarname}+$indexValue+3
+                                sta  ${target.asmVarname}+$indexValue+4
+                            """)
                     } else {
                         val asmvarname = asmgen.asmVariableName(target.array.indexer.indexVar!!)
                         asmgen.out("""
@@ -1512,10 +1806,19 @@ 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()}")
-                    RegisterOrPair.AX -> asmgen.out("  lda  ${address.toHex()} |  ldx  #0")
-                    RegisterOrPair.AY -> asmgen.out("  lda  ${address.toHex()} |  ldy  #0")
-                    RegisterOrPair.XY -> asmgen.out("  ldy  ${address.toHex()} |  ldy  #0")
+                    RegisterOrPair.AX -> asmgen.out("  ldx  #0 |  lda  ${address.toHex()}")
+                    RegisterOrPair.AY -> asmgen.out("  ldy  #0 |  lda  ${address.toHex()}")
+                    RegisterOrPair.XY -> asmgen.out("  ldy  #0 |  ldy  ${address.toHex()}")
                     RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
+                    in Cx16VirtualRegisters -> {
+                        asmgen.out("""
+                            lda  ${address.toHex()}
+                            sta  cx16.${target.register.toString().toLowerCase()}
+                            lda  #0
+                            sta  cx16.${target.register.toString().toLowerCase()}+1
+                        """)
+                    }
+                    else -> throw AssemblyError("weird register")
                 }
                 TargetStorageKind.STACK -> {
                     asmgen.out("""
@@ -1547,6 +1850,14 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AY -> asmgen.out("  ldy  #0")
                         RegisterOrPair.XY -> asmgen.out("  tax |  ldy  #0")
                         RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
+                        in Cx16VirtualRegisters -> {
+                            asmgen.out("""
+                                sta  cx16.${target.register.toString().toLowerCase()}
+                                lda  #0
+                                sta  cx16.${target.register.toString().toLowerCase()}+1
+                            """)
+                        }
+                        else -> throw AssemblyError("weird register")
                     }
                 }
                 TargetStorageKind.STACK -> {
@@ -1561,29 +1872,27 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         if (address != null) {
             when(wordtarget.kind) {
                 TargetStorageKind.VARIABLE -> {
-                    asmgen.out("""
-                        lda  ${address.toHex()}
-                        sta  ${wordtarget.asmVarname}
-                        lda  #0
-                        sta  ${wordtarget.asmVarname}+1
-                        """)
+                    asmgen.out("  lda  ${address.toHex()} |  sta  ${wordtarget.asmVarname}")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  ${wordtarget.asmVarname}+1")
+                    else
+                        asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
                 }
                 TargetStorageKind.ARRAY -> {
                     throw AssemblyError("no asm gen for assign memory byte at $address to array ${wordtarget.asmVarname}")
                 }
                 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")
+                    RegisterOrPair.AX -> asmgen.out("  ldx  #0 |  lda  ${address.toHex()}")
+                    RegisterOrPair.AY -> asmgen.out("  ldy  #0 |  lda  ${address.toHex()}")
+                    RegisterOrPair.XY -> asmgen.out("  ldy  #0 |  ldy  ${address.toHex()}")
                     else -> throw AssemblyError("word regs can only be pair")
                 }
                 TargetStorageKind.STACK -> {
-                    asmgen.out("""
-                        lda  ${address.toHex()}
-                        sta  P8ESTACK_LO,x
-                        lda  #0
-                        sta  P8ESTACK_HI,x
-                        dex""")
+                    asmgen.out("  lda  ${address.toHex()} |  sta  P8ESTACK_LO,x")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  P8ESTACK_HI,x |  dex")
+                    else
+                        asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
                 }
                 else -> throw AssemblyError("other types aren't word")
             }
@@ -1591,7 +1900,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             when(wordtarget.kind) {
                 TargetStorageKind.VARIABLE -> {
                     asmgen.loadByteFromPointerIntoA(identifier)
-                    asmgen.out(" sta  ${wordtarget.asmVarname} |  lda  #0 |  sta ${wordtarget.asmVarname}+1")
+                    asmgen.out(" sta  ${wordtarget.asmVarname}")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  ${wordtarget.asmVarname}+1")
+                    else
+                        asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
                 }
                 TargetStorageKind.ARRAY -> {
                     throw AssemblyError("no asm gen for assign memory byte $identifier to array ${wordtarget.asmVarname} ")
@@ -1607,7 +1920,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 }
                 TargetStorageKind.STACK -> {
                     asmgen.loadByteFromPointerIntoA(identifier)
-                    asmgen.out(" sta  P8ESTACK_LO,x |  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
+                    asmgen.out("  sta  P8ESTACK_LO,x")
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  P8ESTACK_HI,x |  dex")
+                    else
+                        asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
                 }
                 else -> throw AssemblyError("other types aren't word")
             }
@@ -1619,7 +1936,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         val addressLv = addressExpr as? NumericLiteralValue
         when {
             addressLv != null -> {
-                asmgen.out("  lda $ldaInstructionArg |  sta  ${addressLv.number.toHex()}")
+                asmgen.out("  lda  $ldaInstructionArg |  sta  ${addressLv.number.toHex()}")
             }
             addressExpr is IdentifierReference -> {
                 asmgen.storeByteIntoPointer(addressExpr, ldaInstructionArg)
@@ -1649,9 +1966,9 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 asmgen.storeByteIntoPointer(addressExpr, null)
             }
             else -> {
-                asmgen.saveRegister(register, false, memoryAddress.definingSubroutine()!!)
+                asmgen.saveRegisterStack(register, false)
                 assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
-                asmgen.restoreRegister(CpuRegister.A, false)
+                asmgen.restoreRegisterStack(CpuRegister.A, false)
                 asmgen.out("  ldy  #0 |  sta  (P8ZP_SCRATCH_W2),y")
             }
         }

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

@@ -7,6 +7,7 @@ import prog8.ast.statements.Subroutine
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.CompilationTarget
 import prog8.compiler.target.CpuType
+import prog8.compiler.target.Cx16Target
 import prog8.compiler.target.c64.codegen.AsmGen
 import prog8.compiler.target.c64.codegen.ExpressionsAsmGen
 import prog8.compiler.toHex
@@ -317,9 +318,10 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     bne  -
 +""")
             }
-            "&" -> asmgen.out(" and  P8ZP_SCRATCH_B1")
-            "^" -> asmgen.out(" eor  P8ZP_SCRATCH_B1")
-            "|" -> asmgen.out(" ora  P8ZP_SCRATCH_B1")
+            "&", "and" -> asmgen.out(" and  P8ZP_SCRATCH_B1")
+            "|", "or" -> asmgen.out(" ora  P8ZP_SCRATCH_B1")
+            "^", "xor" -> asmgen.out(" eor  P8ZP_SCRATCH_B1")
+            in comparisonOperators -> TODO("in-place modification for $operator")
             else -> throw AssemblyError("invalid operator for in-place modification $operator")
         }
         if(ptrOnZp)
@@ -357,9 +359,10 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         bne  -
 +""")
             }
-            "&" -> asmgen.out(" and  $otherName")
-            "^" -> asmgen.out(" eor  $otherName")
-            "|" -> asmgen.out(" ora  $otherName")
+            "&", "and" -> asmgen.out(" and  $otherName")
+            "|", "or" -> asmgen.out(" ora  $otherName")
+            "^", "xor" -> asmgen.out(" eor  $otherName")
+            in comparisonOperators -> TODO("in-place modification for $operator")
             else -> throw AssemblyError("invalid operator for in-place modification $operator")
         }
         if(ptrOnZp)
@@ -438,7 +441,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
                 }
             }
-            "&" -> {
+            "&", "and" -> {
                 val (ptrOnZp, sourceName) = asmgen.loadByteFromPointerIntoA(pointervar)
                 asmgen.out(" and  #$value")
                 if(ptrOnZp)
@@ -446,15 +449,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 else
                     asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
             }
-            "^" -> {
-                val (ptrOnZp, sourceName) = asmgen.loadByteFromPointerIntoA(pointervar)
-                asmgen.out(" eor  #$value")
-                if(ptrOnZp)
-                    asmgen.out("  sta  ($sourceName),y")
-                else
-                    asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
-            }
-            "|" -> {
+            "|", "or" -> {
                 val (ptrOnZp, sourceName) = asmgen.loadByteFromPointerIntoA(pointervar)
                 asmgen.out(" ora  #$value")
                 if(ptrOnZp)
@@ -462,6 +457,15 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 else
                     asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
             }
+            "^", "xor" -> {
+                val (ptrOnZp, sourceName) = asmgen.loadByteFromPointerIntoA(pointervar)
+                asmgen.out(" eor  #$value")
+                if(ptrOnZp)
+                    asmgen.out("  sta  ($sourceName),y")
+                else
+                    asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
+            }
+            in comparisonOperators -> TODO("in-place modification for $operator")
             else -> throw AssemblyError("invalid operator for in-place modification $operator")
         }
     }
@@ -525,18 +529,19 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 +""")
                 }
             }
-            "&" -> {
+            "&", "and" -> {
                 asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                 asmgen.out("  and  $name |  sta  $name")
             }
-            "^" -> {
-                asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
-                asmgen.out("  eor  $name |  sta  $name")
-            }
-            "|" -> {
+            "|", "or" -> {
                 asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                 asmgen.out("  ora  $name |  sta  $name")
             }
+            "^", "xor" -> {
+                asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                asmgen.out("  eor  $name |  sta  $name")
+            }
+            in comparisonOperators -> TODO("in-place modification for $operator")
             else -> throw AssemblyError("invalid operator for in-place modification $operator")
         }
     }
@@ -591,27 +596,10 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 +""")
                 }
             }
-            "&" -> asmgen.out(" lda  $name |  and  $otherName |  sta  $name")
-            "^" -> asmgen.out(" lda  $name |  eor  $otherName |  sta  $name")
-            "|" -> asmgen.out(" lda  $name |  ora  $otherName |  sta  $name")
-            "and" -> asmgen.out("""
-                lda  $name
-                and  $otherName
-                beq  +
-                lda  #1
-+               sta  $name""")
-            "or" -> asmgen.out("""
-                lda  $name
-                ora  $otherName
-                beq  +
-                lda  #1
-+               sta  $name""")
-            "xor" -> asmgen.out("""
-                lda  $name
-                eor  $otherName
-                beq  +
-                lda  #1
-+               sta  $name""")
+            "&", "and" -> asmgen.out(" lda  $name |  and  $otherName |  sta  $name")
+            "|", "or" -> asmgen.out(" lda  $name |  ora  $otherName |  sta  $name")
+            "^", "xor" -> asmgen.out(" lda  $name |  eor  $otherName |  sta  $name")
+            in comparisonOperators -> TODO("in-place modification for $operator")
             else -> throw AssemblyError("invalid operator for in-place modification $operator")
         }
     }
@@ -643,14 +631,24 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     sta  $name""")
             }
             "<<" -> {
-                if(value>=8) asmgen.out(" lda  #0 |  sta  $name")
-                else repeat(value) { asmgen.out(" asl  $name") }
+                if(value>=8) {
+                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        asmgen.out("  stz  $name")
+                    else
+                        asmgen.out("  lda  #0 |  sta  $name")
+                }
+                else repeat(value) { asmgen.out("  asl  $name") }
             }
             ">>" -> {
                 if(value>0) {
                     if (dt == DataType.UBYTE) {
-                        if(value>=8) asmgen.out(" lda  #0 |  sta  $name")
-                        else repeat(value) { asmgen.out(" lsr  $name") }
+                        if(value>=8) {
+                            if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                asmgen.out("  stz  $name")
+                            else
+                                asmgen.out("  lda  #0 |  sta  $name")
+                        }
+                        else repeat(value) { asmgen.out("  lsr  $name") }
                     } else {
                         when {
                             value>=8 -> asmgen.out("""
@@ -665,14 +663,15 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                 ldy  #$value
                                 jsr  math.lsr_byte_A
                                 sta  $name""")
-                            else -> repeat(value) { asmgen.out(" lda  $name | asl  a |  ror  $name") }
+                            else -> repeat(value) { asmgen.out("  lda  $name | asl  a |  ror  $name") }
                         }
                     }
                 }
             }
-            "&" -> asmgen.out(" lda  $name |  and  #$value |  sta  $name")
-            "^" -> asmgen.out(" lda  $name |  eor  #$value |  sta  $name")
-            "|" -> asmgen.out(" lda  $name |  ora  #$value |  sta  $name")
+            "&", "and" -> asmgen.out(" lda  $name |  and  #$value |  sta  $name")
+            "|", "or" -> asmgen.out(" lda  $name |  ora  #$value |  sta  $name")
+            "^", "xor" -> asmgen.out(" lda  $name |  eor  #$value |  sta  $name")
+            in comparisonOperators -> TODO("in-place modification for $operator")
             else -> throw AssemblyError("invalid operator for in-place modification $operator")
         }
     }
@@ -851,16 +850,27 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     ldy  #>$value
                     jsr  math.divmod_uw_asm
                     lda  P8ZP_SCRATCH_W2
+                    ldy  P8ZP_SCRATCH_W2+1
                     sta  $name
-                    lda  P8ZP_SCRATCH_W2+2
                     sty  $name+1
                 """)
             }
             "<<" -> {
                 when {
-                    value>=16 -> asmgen.out(" lda  #0 |  sta  $name |  sta  $name+1")
-                    value==8 -> asmgen.out(" lda  $name |  sta  $name+1 |  lda  #0 |  sta  $name")
-                    value>2 -> asmgen.out("""
+                    value>=16 -> {
+                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            asmgen.out("  stz  $name |  stz  $name+1")
+                        else
+                            asmgen.out("  lda  #0 |  sta  $name |  sta  $name+1")
+                    }
+                    value==8 -> {
+                        asmgen.out("  lda  $name |  sta  $name+1")
+                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            asmgen.out("  stz  $name")
+                        else
+                            asmgen.out("  lda  #0 |  sta  $name")
+                    }
+                    value>3 -> asmgen.out("""
                         ldy  #$value
 -                       asl  $name
                         rol  $name+1
@@ -874,8 +884,19 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 if (value > 0) {
                     if(dt==DataType.UWORD) {
                         when {
-                            value>=16 -> asmgen.out(" lda  #0 |  sta  $name |  sta  $name+1")
-                            value==8 -> asmgen.out(" lda  $name+1 |  sta  $name |  lda  #0 |  sta  $name+1")
+                            value>=16 -> {
+                                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                    asmgen.out("  stz  $name |  stz  $name+1")
+                                else
+                                    asmgen.out("  lda  #0 |  sta  $name |  sta  $name+1")
+                            }
+                            value==8 -> {
+                                asmgen.out("  lda  $name+1 |  sta  $name")
+                                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                    asmgen.out("  stz  $name+1")
+                                else
+                                    asmgen.out("  lda  #0 |  sta  $name+1")
+                            }
                             value>2 -> asmgen.out("""
                                 ldy  #$value
 -                               lsr  $name+1
@@ -917,47 +938,48 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     }
                 }
             }
-            "&" -> {
+            "&", "and" -> {
                 when {
                     value == 0 -> {
                         if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
-                            asmgen.out(" stz  $name |  stz  $name+1")
+                            asmgen.out("  stz  $name |  stz  $name+1")
                         else
-                            asmgen.out(" lda  #0 |  sta  $name |  sta  $name+1")
+                            asmgen.out("  lda  #0 |  sta  $name |  sta  $name+1")
                     }
                     value and 255 == 0 -> {
                         if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
-                            asmgen.out(" stz  $name")
+                            asmgen.out("  stz  $name")
                         else
-                            asmgen.out(" lda  #0 |  sta  $name")
-                        asmgen.out(" lda  $name+1 |  and  #>$value |  sta  $name+1")
+                            asmgen.out("  lda  #0 |  sta  $name")
+                        asmgen.out("  lda  $name+1 |  and  #>$value |  sta  $name+1")
                     }
                     value < 0x0100 -> {
-                        asmgen.out(" lda  $name |  and  #$value |  sta  $name")
+                        asmgen.out("  lda  $name |  and  #$value |  sta  $name")
                         if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("  stz  $name+1")
                         else
                             asmgen.out("  lda  #0 |  sta  $name+1")
                     }
-                    else -> asmgen.out(" lda  $name |  and  #<$value |  sta  $name |  lda  $name+1 |  and  #>$value |  sta  $name+1")
+                    else -> asmgen.out("  lda  $name |  and  #<$value |  sta  $name |  lda  $name+1 |  and  #>$value |  sta  $name+1")
                 }
             }
-            "^" -> {
+            "|", "or" -> {
                 when {
                     value == 0 -> {}
-                    value and 255 == 0 -> asmgen.out(" lda  $name+1 |  eor  #>$value |  sta  $name+1")
-                    value < 0x0100 -> asmgen.out(" lda  $name |  eor  #$value |  sta  $name")
-                    else -> asmgen.out(" lda  $name |  eor  #<$value |  sta  $name |  lda  $name+1 |  eor  #>$value |  sta  $name+1")
+                    value and 255 == 0 -> asmgen.out("  lda  $name+1 |  ora  #>$value |  sta  $name+1")
+                    value < 0x0100 -> asmgen.out("  lda  $name |  ora  #$value |  sta  $name")
+                    else -> asmgen.out("  lda  $name |  ora  #<$value |  sta  $name |  lda  $name+1 |  ora  #>$value |  sta  $name+1")
                 }
             }
-            "|" -> {
+            "^", "xor" -> {
                 when {
                     value == 0 -> {}
-                    value and 255 == 0 -> asmgen.out(" lda  $name+1 |  ora  #>$value |  sta  $name+1")
-                    value < 0x0100 -> asmgen.out(" lda  $name |  ora  #$value |  sta  $name")
-                    else -> asmgen.out(" lda  $name |  ora  #<$value |  sta  $name |  lda  $name+1 |  ora  #>$value |  sta  $name+1")
+                    value and 255 == 0 -> asmgen.out("  lda  $name+1 |  eor  #>$value |  sta  $name+1")
+                    value < 0x0100 -> asmgen.out("  lda  $name |  eor  #$value |  sta  $name")
+                    else -> asmgen.out("  lda  $name |  eor  #<$value |  sta  $name |  lda  $name+1 |  eor  #>$value |  sta  $name+1")
                 }
             }
+            in comparisonOperators -> TODO("in-place modification for $operator")
             else -> throw AssemblyError("invalid operator for in-place modification $operator")
         }
     }
@@ -1019,11 +1041,12 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                 sta  $name+1""")
                     }
                     "*" -> {
+                        asmgen.out("  lda  $otherName |  sta  P8ZP_SCRATCH_W1")
+                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            asmgen.out("  stz  P8ZP_SCRATCH_W1+1")
+                        else
+                            asmgen.out("  lda  #0 |  sta  P8ZP_SCRATCH_W1+1")
                         asmgen.out("""
-                            lda  $otherName
-                            sta  P8ZP_SCRATCH_W1
-                            lda  #0
-                            sta  P8ZP_SCRATCH_W1+1
                             lda  $name
                             ldy  $name+1
                             jsr  math.multiply_words
@@ -1067,13 +1090,18 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 +""")
                         }
                     }
-                    "&" -> {
-                        asmgen.out(" lda  $otherName |  and  $name |  sta  $name")
-                        if(dt in WordDatatypes)
-                            asmgen.out(" lda  #0 |  sta  $name+1")
+                    "&", "and" -> {
+                        asmgen.out("  lda  $otherName |  and  $name |  sta  $name")
+                        if(dt in WordDatatypes) {
+                            if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                asmgen.out("  stz  $name+1")
+                            else
+                                asmgen.out("  lda  #0 |  sta  $name+1")
+                        }
                     }
-                    "^" -> asmgen.out(" lda  $otherName |  eor  $name |  sta  $name")
-                    "|" -> asmgen.out(" lda  $otherName |  ora  $name |  sta  $name")
+                    "|", "or" -> asmgen.out("  lda  $otherName |  ora  $name |  sta  $name")
+                    "^", "xor" -> asmgen.out("  lda  $otherName |  eor  $name |  sta  $name")
+                    in comparisonOperators -> TODO("in-place modification for $operator")
                     else -> throw AssemblyError("invalid operator for in-place modification $operator")
                 }
             }
@@ -1081,8 +1109,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 // the value is a proper 16-bit word, so use both bytes of it.
                 when (operator) {
                     // note: ** (power) operator requires floats.
-                    "+" -> asmgen.out(" lda  $name |  clc |  adc  $otherName |  sta  $name |  lda  $name+1 |  adc  $otherName+1 |  sta  $name+1")
-                    "-" -> asmgen.out(" lda  $name |  sec |  sbc  $otherName |  sta  $name |  lda  $name+1 |  sbc  $otherName+1 |  sta  $name+1")
+                    "+" -> asmgen.out("  lda  $name |  clc |  adc  $otherName |  sta  $name |  lda  $name+1 |  adc  $otherName+1 |  sta  $name+1")
+                    "-" -> asmgen.out("  lda  $name |  sec |  sbc  $otherName |  sta  $name |  lda  $name+1 |  sbc  $otherName+1 |  sta  $name+1")
                     "*" -> {
                         asmgen.out("""
                             lda  $otherName
@@ -1144,9 +1172,10 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         """)
                     }
                     "<<", ">>" -> throw AssemblyError("shift by a word value not supported, max is a byte")
-                    "&" -> asmgen.out(" lda  $name |  and  $otherName |  sta  $name |  lda  $name+1 |  and  $otherName+1 |  sta  $name+1")
-                    "^" -> asmgen.out(" lda  $name |  eor  $otherName |  sta  $name |  lda  $name+1 |  eor  $otherName+1 |  sta  $name+1")
-                    "|" -> asmgen.out(" lda  $name |  ora  $otherName |  sta  $name |  lda  $name+1 |  ora  $otherName+1 |  sta  $name+1")
+                    "&", "and" -> asmgen.out(" lda  $name |  and  $otherName |  sta  $name |  lda  $name+1 |  and  $otherName+1 |  sta  $name+1")
+                    "|", "or" -> asmgen.out(" lda  $name |  ora  $otherName |  sta  $name |  lda  $name+1 |  ora  $otherName+1 |  sta  $name+1")
+                    "^", "xor" -> asmgen.out(" lda  $name |  eor  $otherName |  sta  $name |  lda  $name+1 |  eor  $otherName+1 |  sta  $name+1")
+                    in comparisonOperators -> TODO("in-place modification for $operator")
                     else -> throw AssemblyError("invalid operator for in-place modification $operator")
                 }
             }
@@ -1319,20 +1348,25 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                             bne  -
 +""")
                     }
-                    "&" -> {
+                    "&", "and" -> {
                         asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                         asmgen.out("  and  $name |  sta  $name")
-                        if(dt in WordDatatypes)
-                            asmgen.out(" lda  #0 |  sta  $name+1")
+                        if(dt in WordDatatypes) {
+                            if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                asmgen.out("  stz  $name+1")
+                            else
+                                asmgen.out("  lda  #0 |  sta  $name+1")
+                        }
                     }
-                    "^" -> {
-                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
-                        asmgen.out("  eor  $name |  sta  $name")
-                    }
-                    "|" -> {
+                    "|", "or" -> {
                         asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                         asmgen.out("  ora  $name |  sta  $name")
                     }
+                    "^", "xor" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                        asmgen.out("  eor  $name |  sta  $name")
+                    }
+                    in comparisonOperators -> TODO("in-place modification for $operator")
                     else -> throw AssemblyError("invalid operator for in-place modification $operator")
                 }
             }
@@ -1361,18 +1395,19 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         remainderVarByWordInAY()
                     }
                     "<<", ">>" -> throw AssemblyError("shift by a word value not supported, max is a byte")
-                    "&" -> {
+                    "&", "and" -> {
                         asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
                         asmgen.out("  and  $name |  sta  $name |  tya |  and  $name+1 |  sta  $name+1")
                     }
-                    "^" -> {
-                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
-                        asmgen.out("  eor  $name |  sta  $name |  tya |  eor  $name+1 |  sta  $name+1")
-                    }
-                    "|" -> {
+                    "|", "or" -> {
                         asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
                         asmgen.out("  ora  $name |  sta  $name |  tya |  ora  $name+1 |  sta  $name+1")
                     }
+                    "^", "xor" -> {
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        asmgen.out("  eor  $name |  sta  $name |  tya |  eor  $name+1 |  sta  $name+1")
+                    }
+                    in comparisonOperators -> TODO("in-place modification for $operator")
                     else -> throw AssemblyError("invalid operator for in-place modification $operator")
                 }
             }
@@ -1382,7 +1417,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 
     private fun inplaceModification_float_value_to_variable(name: String, operator: String, value: Expression, scope: Subroutine) {
         asmgen.assignExpressionToRegister(value, RegisterOrPair.FAC1)
-        asmgen.saveRegister(CpuRegister.X, false, scope)
+        asmgen.saveRegisterLocal(CpuRegister.X, scope)
         when (operator) {
             "**" -> {
                 asmgen.out("""
@@ -1420,6 +1455,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     jsr  floats.FDIV
                 """)
             }
+            in comparisonOperators -> TODO("in-place float modification for $operator")
             else -> throw AssemblyError("invalid operator for in-place float modification $operator")
         }
         asmgen.out("""
@@ -1427,7 +1463,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             ldy  #>$name
             jsr  floats.MOVMF
         """)
-        asmgen.restoreRegister(CpuRegister.X, false)
+        asmgen.restoreRegisterLocal(CpuRegister.X)
     }
 
     private fun inplaceModification_float_variable_to_variable(name: String, operator: String, ident: IdentifierReference, scope: Subroutine) {
@@ -1436,17 +1472,29 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             throw AssemblyError("float variable expected")
 
         val otherName = asmgen.asmVariableName(ident)
-        asmgen.saveRegister(CpuRegister.X, false, scope)
+        asmgen.saveRegisterLocal(CpuRegister.X, scope)
         when (operator) {
             "**" -> {
-                asmgen.out("""
-                    lda  #<$name
-                    ldy  #>$name
-                    jsr  floats.CONUPK
-                    lda  #<$otherName
-                    ldy  #>$otherName
-                    jsr  floats.FPWR
-                """)
+                if(CompilationTarget.instance is Cx16Target) {
+                    // cx16 doesn't have FPWR() only FPWRT()
+                    asmgen.out("""
+                        lda  #<$name
+                        ldy  #>$name
+                        jsr  floats.CONUPK
+                        lda  #<$otherName
+                        ldy  #>$otherName
+                        jsr  floats.MOVFM
+                        jsr  floats.FPWRT
+                    """)
+                } else
+                    asmgen.out("""
+                        lda  #<$name
+                        ldy  #>$name
+                        jsr  floats.CONUPK
+                        lda  #<$otherName
+                        ldy  #>$otherName
+                        jsr  floats.FPWR
+                    """)
             }
             "+" -> {
                 asmgen.out("""
@@ -1488,6 +1536,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     jsr  floats.FDIV
                 """)
             }
+            in comparisonOperators -> TODO("in-place float modification for $operator")
             else -> throw AssemblyError("invalid operator for in-place float modification $operator")
         }
         // store Fac1 back into memory
@@ -1496,22 +1545,34 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             ldy  #>$name
             jsr  floats.MOVMF
         """)
-        asmgen.restoreRegister(CpuRegister.X, false)
+        asmgen.restoreRegisterLocal(CpuRegister.X)
     }
 
     private fun inplaceModification_float_litval_to_variable(name: String, operator: String, value: Double, scope: Subroutine) {
         val constValueName = asmgen.getFloatAsmConst(value)
-        asmgen.saveRegister(CpuRegister.X, false, scope)
+        asmgen.saveRegisterLocal(CpuRegister.X, scope)
         when (operator) {
             "**" -> {
-                asmgen.out("""
-                    lda  #<$name
-                    ldy  #>$name
-                    jsr  floats.CONUPK
-                    lda  #<$constValueName
-                    ldy  #>$constValueName
-                    jsr  floats.FPWR
-                """)
+                if(CompilationTarget.instance is Cx16Target) {
+                    // cx16 doesn't have FPWR() only FPWRT()
+                    asmgen.out("""
+                        lda  #<$name
+                        ldy  #>$name
+                        jsr  floats.CONUPK
+                        lda  #<$constValueName
+                        ldy  #>$constValueName
+                        jsr  floats.MOVFM
+                        jsr  floats.FPWRT
+                    """)
+                } else
+                    asmgen.out("""
+                        lda  #<$name
+                        ldy  #>$name
+                        jsr  floats.CONUPK
+                        lda  #<$constValueName
+                        ldy  #>$constValueName
+                        jsr  floats.FPWR
+                    """)
             }
             "+" -> {
                 if (value == 0.0)
@@ -1560,6 +1621,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     jsr  floats.FDIV
                 """)
             }
+            in comparisonOperators -> TODO("in-place float modification for $operator")
             else -> throw AssemblyError("invalid operator for in-place float modification $operator")
         }
         // store Fac1 back into memory
@@ -1568,7 +1630,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             ldy  #>$name
             jsr  floats.MOVMF
         """)
-        asmgen.restoreRegister(CpuRegister.X, false)
+        asmgen.restoreRegisterLocal(CpuRegister.X)
     }
 
     private fun inplaceCast(target: AsmAssignTarget, cast: TypecastExpression, position: Position) {
@@ -1590,10 +1652,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                 }
                                 TargetStorageKind.ARRAY -> {
                                     asmgen.loadScaledArrayIndexIntoRegister(target.array!!, target.datatype, CpuRegister.Y, true)
-                                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
-                                        asmgen.out("  stz  ${target.asmVarname},y")
-                                    else
-                                        asmgen.out("  lda  #0 |  sta  ${target.asmVarname},y")
+                                    asmgen.out("  lda  #0 |  sta  ${target.asmVarname},y")
                                 }
                                 TargetStorageKind.STACK -> {
                                     if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)

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

@@ -21,7 +21,6 @@ internal object CX16MachineDefinition: IMachineDefinition {
     override val RAW_LOAD_ADDRESS = 0x8000
 
     // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-    // and some heavily used string constants derived from the two values above
     override val ESTACK_LO = 0x0400        //  $0400-$04ff inclusive
     override val ESTACK_HI = 0x0500        //  $0500-$05ff inclusive
 
@@ -29,7 +28,6 @@ internal object CX16MachineDefinition: IMachineDefinition {
 
     override fun getFloat(num: Number) = C64MachineDefinition.Mflpt5.fromNumber(num)
 
-    override fun getFloatRomConst(number: Double): String? = null       // Cx16 has no pulblic ROM float locations
     override fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program) {
         if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG)
             importer.importLibraryModule(program, "syslib")
@@ -38,8 +36,7 @@ internal object CX16MachineDefinition: IMachineDefinition {
     override fun launchEmulator(programName: String) {
         for(emulator in listOf("x16emu")) {
             println("\nStarting Commander X16 emulator $emulator...")
-            val cmdline = listOf(emulator, "-rom", "/usr/share/x16-rom/rom.bin", "-scale", "2",
-                    "-run", "-prg", programName + ".prg")
+            val cmdline = listOf(emulator, "-scale", "2", "-run", "-prg", "$programName.prg")
             val processb = ProcessBuilder(cmdline).inheritIO()
             val process: Process
             try {
@@ -74,8 +71,8 @@ internal object CX16MachineDefinition: IMachineDefinition {
 
     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, must be B1+1
+        override val SCRATCH_B1 = 0x7a      // temp storage for a single byte
+        override val SCRATCH_REG = 0x7b     // temp storage for a register, must be B1+1
         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
 

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -133,42 +133,9 @@ private val functionSignatures: List<FSignature> = listOf(
     FSignature("rnd"         , false, emptyList(), DataType.UBYTE),
     FSignature("rndw"        , false, emptyList(), DataType.UWORD),
     FSignature("rndf"        , false, emptyList(), DataType.FLOAT),
-    FSignature("exit"        , false, listOf(FParam("returnvalue", setOf(DataType.UBYTE))), null),
-    FSignature("rsave"       , false, emptyList(), null),
-    FSignature("rrestore"    , false, emptyList(), null),
-    FSignature("set_carry"   , false, emptyList(), null),
-    FSignature("clear_carry" , false, emptyList(), null),
-    FSignature("set_irqd"    , false, emptyList(), null),
-    FSignature("clear_irqd"  , false, emptyList(), null),
-    FSignature("read_flags"  , false, emptyList(), DataType.UBYTE),
+    FSignature("memory"      , true, listOf(FParam("name", setOf(DataType.STR)), FParam("size", setOf(DataType.UWORD))), DataType.UWORD),
     FSignature("swap"        , false, listOf(FParam("first", NumericDatatypes), FParam("second", NumericDatatypes)), null),
-    FSignature("memcopy"     , false, listOf(
-                            FParam("from", IterableDatatypes + DataType.UWORD),
-                            FParam("to", IterableDatatypes + DataType.UWORD),
-                            FParam("numbytes", setOf(DataType.UBYTE, DataType.UWORD))), null),
-    FSignature("memset"      , false, listOf(
-                            FParam("address", IterableDatatypes + DataType.UWORD),
-                            FParam("numbytes", setOf(DataType.UWORD)),
-                            FParam("bytevalue", ByteDatatypes)), null),
-    FSignature("memsetw"     , false, listOf(
-                            FParam("address", IterableDatatypes + DataType.UWORD),
-                            FParam("numwords", setOf(DataType.UWORD)),
-                            FParam("wordvalue", setOf(DataType.UWORD, DataType.WORD))), null),
-    FSignature("strlen"      , true, listOf(FParam("string", setOf(DataType.STR))), DataType.UBYTE, ::builtinStrlen),
-    FSignature("substr"      , false, listOf(
-            FParam("source", IterableDatatypes + DataType.UWORD),
-            FParam("target", IterableDatatypes + DataType.UWORD),
-            FParam("start", setOf(DataType.UBYTE)),
-            FParam("length", setOf(DataType.UBYTE))), null),
-    FSignature("leftstr"     , false, listOf(
-            FParam("source", IterableDatatypes + DataType.UWORD),
-            FParam("target", IterableDatatypes + DataType.UWORD),
-            FParam("length", setOf(DataType.UBYTE))), null),
-    FSignature("rightstr"    , false, listOf(
-            FParam("source", IterableDatatypes + DataType.UWORD),
-            FParam("target", IterableDatatypes + DataType.UWORD),
-            FParam("length", setOf(DataType.UBYTE))), null),
-    FSignature("strcmp"      , false, listOf(FParam("s1", IterableDatatypes + DataType.UWORD), FParam("s2", IterableDatatypes + DataType.UWORD)), DataType.BYTE, null)
+
 )
 
 val BuiltinFunctions = functionSignatures.associateBy { it.name }
@@ -347,23 +314,6 @@ private fun builtinSizeof(args: List<Expression>, position: Position, program: P
     }
 }
 
-private fun builtinStrlen(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
-    if (args.size != 1)
-        throw SyntaxError("strlen requires one argument", position)
-    val argument=args[0]
-    if(argument is StringLiteralValue)
-        return NumericLiteralValue.optimalInteger(argument.value.length, argument.position)
-    val vardecl = (argument as IdentifierReference).targetVarDecl(program.namespace)
-    if(vardecl!=null) {
-        if(vardecl.datatype!=DataType.STR && vardecl.datatype!=DataType.UWORD)
-            throw SyntaxError("strlen must have string argument", position)
-        if(vardecl.autogeneratedDontRemove && vardecl.value!=null) {
-            return NumericLiteralValue.optimalInteger((vardecl.value as StringLiteralValue).value.length, argument.position)
-        }
-    }
-    throw NotConstArgumentException()
-}
-
 private fun builtinLen(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     // note: in some cases the length is > 255 and then we have to return a UWORD type instead of a UBYTE.
     if(args.size!=1)

compiler/src/prog8/optimizer/CallGraph.kt

@@ -117,12 +117,9 @@ class CallGraph(private val program: Program) : IAstVisitor {
     }
 
     override fun visit(decl: VarDecl) {
-        if (decl.autogeneratedDontRemove || decl.definingModule().isLibraryModule) {
-            // make sure autogenerated vardecls are in the used symbols and are never removed as 'unused'
+        if (decl.autogeneratedDontRemove || decl.datatype==DataType.STRUCT)
             addNodeAndParentScopes(decl)
-        }
-
-        if (decl.datatype == DataType.STRUCT)
+        else if(decl.parent is Block && decl.definingModule().isLibraryModule)
             addNodeAndParentScopes(decl)
 
         super.visit(decl)

compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt

@@ -7,6 +7,7 @@ import prog8.ast.expressions.*
 import prog8.ast.processing.AstWalker
 import prog8.ast.processing.IAstModification
 import prog8.ast.statements.*
+import kotlin.math.pow
 
 
 internal class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
@@ -97,21 +98,63 @@ internal class ConstantFoldingOptimizer(private val program: Program) : AstWalke
     override fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
         val leftconst = expr.left.constValue(program)
         val rightconst = expr.right.constValue(program)
+        val modifications = mutableListOf<IAstModification>()
 
-        val subExpr: BinaryExpression? = when {
-            leftconst!=null -> expr.right as? BinaryExpression
-            rightconst!=null -> expr.left as? BinaryExpression
-            else -> null
+        if(expr.operator == "**" && leftconst!=null) {
+            // optimize various simple cases of ** :
+            //  optimize away 1 ** x into just 1 and 0 ** x into just 0
+            //  optimize 2 ** x into (1<<x)  if both operands are integer.
+            val leftDt = leftconst.inferType(program).typeOrElse(DataType.STRUCT)
+            when (leftconst.number.toDouble()) {
+                0.0 -> {
+                    val value = NumericLiteralValue(leftDt, 0, expr.position)
+                    modifications += IAstModification.ReplaceNode(expr, value, parent)
+                }
+                1.0 -> {
+                    val value = NumericLiteralValue(leftDt, 1, expr.position)
+                    modifications += IAstModification.ReplaceNode(expr, value, parent)
+                }
+                2.0 -> {
+                    if(rightconst!=null) {
+                        val value = NumericLiteralValue(leftDt, 2.0.pow(rightconst.number.toDouble()), expr.position)
+                        modifications += IAstModification.ReplaceNode(expr, value, parent)
+                    } else {
+                        val rightDt = expr.right.inferType(program).typeOrElse(DataType.STRUCT)
+                        if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
+                            val targetDt =
+                                when (parent) {
+                                    is Assignment -> parent.target.inferType(program).typeOrElse(DataType.STRUCT)
+                                    is VarDecl -> parent.datatype
+                                    else -> leftDt
+                                }
+                            val one = NumericLiteralValue(targetDt, 1, expr.position)
+                            val shift = BinaryExpression(one, "<<", expr.right, expr.position)
+                            modifications += IAstModification.ReplaceNode(expr, shift, parent)
+                        }
+                    }
+                }
+            }
         }
-        if(subExpr!=null) {
-            val subleftconst = subExpr.left.constValue(program)
-            val subrightconst = subExpr.right.constValue(program)
-            if ((subleftconst != null && subrightconst == null) || (subleftconst==null && subrightconst!=null)) {
-                // try reordering.
-                val change = groupTwoConstsTogether(expr, subExpr,
+
+        if(expr.inferType(program).istype(DataType.FLOAT)) {
+            val subExpr: BinaryExpression? = when {
+                leftconst != null -> expr.right as? BinaryExpression
+                rightconst != null -> expr.left as? BinaryExpression
+                else -> null
+            }
+            if (subExpr != null) {
+                val subleftconst = subExpr.left.constValue(program)
+                val subrightconst = subExpr.right.constValue(program)
+                if ((subleftconst != null && subrightconst == null) || (subleftconst == null && subrightconst != null)) {
+                    // try reordering.
+                    val change = groupTwoFloatConstsTogether(
+                        expr, subExpr,
                         leftconst != null, rightconst != null,
-                        subleftconst != null, subrightconst != null)
-                return change?.let { listOf(it) } ?: noModifications
+                        subleftconst != null, subrightconst != null
+                    )
+                    if (change != null)
+                        modifications += change
+                }
             }
         }
 
@@ -119,10 +162,10 @@ internal class ConstantFoldingOptimizer(private val program: Program) : AstWalke
         if(leftconst != null && rightconst != null) {
             val evaluator = ConstExprEvaluator()
             val result = evaluator.evaluate(leftconst, expr.operator, rightconst)
-            return listOf(IAstModification.ReplaceNode(expr, result, parent))
+            modifications += IAstModification.ReplaceNode(expr, result, parent)
         }
 
-        return noModifications
+        return modifications
     }
 
     override fun after(array: ArrayLiteralValue, parent: Node): Iterable<IAstModification> {
@@ -187,7 +230,8 @@ internal class ConstantFoldingOptimizer(private val program: Program) : AstWalke
         val rangeTo = iterableRange.to as? NumericLiteralValue
         if(rangeFrom==null || rangeTo==null) return noModifications
 
-        val loopvar = forLoop.loopVar.targetVarDecl(program.namespace)!!
+        val loopvar = forLoop.loopVar.targetVarDecl(program.namespace) ?: throw UndefinedSymbolError(forLoop.loopVar)
+
         val stepLiteral = iterableRange.step as? NumericLiteralValue
         when(loopvar.datatype) {
             DataType.UBYTE -> {
@@ -258,13 +302,15 @@ internal class ConstantFoldingOptimizer(private val program: Program) : AstWalke
         }
     }
 
-    private fun groupTwoConstsTogether(expr: BinaryExpression,
-                                       subExpr: BinaryExpression,
-                                       leftIsConst: Boolean,
-                                       rightIsConst: Boolean,
-                                       subleftIsConst: Boolean,
-                                       subrightIsConst: Boolean): IAstModification?
+    private fun groupTwoFloatConstsTogether(expr: BinaryExpression,
+       subExpr: BinaryExpression,
+       leftIsConst: Boolean,
+       rightIsConst: Boolean,
+       subleftIsConst: Boolean,
+       subrightIsConst: Boolean): IAstModification?
     {
+        // NOTE: THIS IS ONLY VALID ON FLOATING POINT CONSTANTS
+
         // todo: this implements only a small set of possible reorderings at this time
         if(expr.operator==subExpr.operator) {
             // both operators are the same.

compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -13,18 +13,23 @@ import prog8.ast.statements.VarDecl
 import prog8.compiler.target.CompilationTarget
 
 // Fix up the literal value's type to match that of the vardecl
-internal class VarConstantValueTypeAdjuster(private val program: Program) : AstWalker() {
+internal class VarConstantValueTypeAdjuster(private val program: Program, private val errors: ErrorReporter) : AstWalker() {
     private val noModifications = emptyList<IAstModification>()
 
     override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
-        val declConstValue = decl.value?.constValue(program)
-        if(declConstValue!=null && (decl.type==VarDeclType.VAR || decl.type==VarDeclType.CONST)
+        try {
+            val declConstValue = decl.value?.constValue(program)
+            if(declConstValue!=null && (decl.type==VarDeclType.VAR || decl.type==VarDeclType.CONST)
                 && !declConstValue.inferType(program).istype(decl.datatype)) {
-            // cast the numeric literal to the appropriate datatype of the variable
-            val cast = declConstValue.cast(decl.datatype)
-            if(cast.isValid)
-                return listOf(IAstModification.ReplaceNode(decl.value!!, cast.valueOrZero(), decl))
+                // cast the numeric literal to the appropriate datatype of the variable
+                val cast = declConstValue.cast(decl.datatype)
+                if(cast.isValid)
+                    return listOf(IAstModification.ReplaceNode(decl.value!!, cast.valueOrZero(), decl))
+            }
+        } catch (x: UndefinedSymbolError) {
+            errors.err(x.message, x.position)
         }
+
         return noModifications
     }
 }
@@ -47,11 +52,22 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
         if(forloop!=null && identifier===forloop.loopVar)
             return noModifications
 
-        val cval = identifier.constValue(program) ?: return noModifications
-        return when (cval.type) {
-            in NumericDatatypes -> listOf(IAstModification.ReplaceNode(identifier, NumericLiteralValue(cval.type, cval.number, identifier.position), identifier.parent))
-            in PassByReferenceDatatypes -> throw FatalAstException("pass-by-reference type should not be considered a constant")
-            else -> noModifications
+        try {
+            val cval = identifier.constValue(program) ?: return noModifications
+            return when (cval.type) {
+                in NumericDatatypes -> listOf(
+                    IAstModification.ReplaceNode(
+                        identifier,
+                        NumericLiteralValue(cval.type, cval.number, identifier.position),
+                        identifier.parent
+                    )
+                )
+                in PassByReferenceDatatypes -> throw FatalAstException("pass-by-reference type should not be considered a constant")
+                else -> noModifications
+            }
+        } catch (x: UndefinedSymbolError) {
+            errors.err(x.message, x.position)
+            return noModifications
         }
     }
 
@@ -78,11 +94,16 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                     }
                 } else if(arraysize.constIndex()==null) {
                     // see if we can calculate the size from other fields
-                    val cval = arraysize.indexVar?.constValue(program) ?: arraysize.origExpression?.constValue(program)
-                    if(cval!=null) {
-                        arraysize.indexVar = null
-                        arraysize.origExpression = null
-                        arraysize.indexNum = cval
+                    try {
+                        val cval =  arraysize.indexVar?.constValue(program) ?: arraysize.origExpression?.constValue(program)
+                        if (cval != null) {
+                            arraysize.indexVar = null
+                            arraysize.origExpression = null
+                            arraysize.indexNum = cval
+                        }
+                    } catch (x: UndefinedSymbolError) {
+                        errors.err(x.message, x.position)
+                        return noModifications
                     }
                 }
             }

compiler/src/prog8/optimizer/ExpressionSimplifier.kt

@@ -6,6 +6,7 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.processing.AstWalker
 import prog8.ast.processing.IAstModification
+import prog8.ast.statements.Assignment
 import kotlin.math.abs
 import kotlin.math.log2
 import kotlin.math.pow
@@ -98,6 +99,12 @@ internal class ExpressionSimplifier(private val program: Program) : AstWalker()
         if (leftVal != null && expr.operator in associativeOperators && rightVal == null)
             return listOf(IAstModification.SwapOperands(expr))
 
+        // NonBinaryExpression  <associativeoperator>  BinaryExpression  -->  BinaryExpression  <associativeoperator>  NonBinaryExpression
+        if (expr.operator in associativeOperators && expr.left !is BinaryExpression && expr.right is BinaryExpression) {
+            if(parent !is Assignment || !(expr.left isSameAs parent.target))
+                return listOf(IAstModification.SwapOperands(expr))
+        }
+
         // X + (-A)  -->  X - A
         if (expr.operator == "+" && (expr.right as? PrefixExpression)?.operator == "-") {
             return listOf(IAstModification.ReplaceNode(
@@ -338,7 +345,7 @@ internal class ExpressionSimplifier(private val program: Program) : AstWalker()
         if (leftVal == null && rightVal == null)
             return null
 
-        val (expr2, _, rightVal2) = reorderAssociative(expr, leftVal)
+        val (expr2, _, rightVal2) = reorderAssociativeWithConstant(expr, leftVal)
         if (rightVal2 != null) {
             // right value is a constant, see if we can optimize
             val rightConst: NumericLiteralValue = rightVal2
@@ -562,7 +569,7 @@ internal class ExpressionSimplifier(private val program: Program) : AstWalker()
         if (leftVal == null && rightVal == null)
             return null
 
-        val (expr2, _, rightVal2) = reorderAssociative(expr, leftVal)
+        val (expr2, _, rightVal2) = reorderAssociativeWithConstant(expr, leftVal)
         if (rightVal2 != null) {
             // right value is a constant, see if we can optimize
             val leftValue: Expression = expr2.left
@@ -662,12 +669,15 @@ internal class ExpressionSimplifier(private val program: Program) : AstWalker()
             DataType.UWORD -> {
                 if (amount >= 16) {
                     return NumericLiteralValue.optimalInteger(0, expr.position)
-                } else if (amount >= 8) {
+                }
+                else if (amount >= 8) {
                     val msb = FunctionCall(IdentifierReference(listOf("msb"), expr.position), mutableListOf(expr.left), expr.position)
                     if (amount == 8) {
-                        return TypecastExpression(msb, DataType.UWORD, true, expr.position)
+                        // mkword(0, msb(v))
+                        val zero = NumericLiteralValue(DataType.UBYTE, 0, expr.position)
+                        return FunctionCall(IdentifierReference(listOf("mkword"), expr.position), mutableListOf(zero, msb), expr.position)
                     }
-                    return BinaryExpression(msb, ">>", NumericLiteralValue.optimalInteger(amount - 8, expr.position), expr.position)
+                    return TypecastExpression(BinaryExpression(msb, ">>", NumericLiteralValue.optimalInteger(amount - 8, expr.position), expr.position), DataType.UWORD, true, expr.position)
                 }
             }
             DataType.WORD -> {
@@ -682,17 +692,17 @@ internal class ExpressionSimplifier(private val program: Program) : AstWalker()
         return null
     }
 
-    private fun reorderAssociative(expr: BinaryExpression, leftVal: NumericLiteralValue?): ReorderedAssociativeBinaryExpr {
+    private fun reorderAssociativeWithConstant(expr: BinaryExpression, leftVal: NumericLiteralValue?): BinExprWithConstants {
         if (expr.operator in associativeOperators && leftVal != null) {
             // swap left and right so that right is always the constant
             val tmp = expr.left
             expr.left = expr.right
             expr.right = tmp
-            return ReorderedAssociativeBinaryExpr(expr, expr.right.constValue(program), leftVal)
+            return BinExprWithConstants(expr, expr.right.constValue(program), leftVal)
         }
-        return ReorderedAssociativeBinaryExpr(expr, leftVal, expr.right.constValue(program))
+        return BinExprWithConstants(expr, leftVal, expr.right.constValue(program))
     }
 
-    private data class ReorderedAssociativeBinaryExpr(val expr: BinaryExpression, val leftVal: NumericLiteralValue?, val rightVal: NumericLiteralValue?)
+    private data class BinExprWithConstants(val expr: BinaryExpression, val leftVal: NumericLiteralValue?, val rightVal: NumericLiteralValue?)
 
 }

compiler/src/prog8/optimizer/Extensions.kt

@@ -5,7 +5,7 @@ import prog8.ast.base.ErrorReporter
 
 
 internal fun Program.constantFold(errors: ErrorReporter) {
-    val valuetypefixer = VarConstantValueTypeAdjuster(this)
+    val valuetypefixer = VarConstantValueTypeAdjuster(this, errors)
     valuetypefixer.visit(this)
     if(errors.isEmpty()) {
         valuetypefixer.applyModifications()

compiler/src/prog8/optimizer/StatementOptimizer.kt

@@ -39,7 +39,7 @@ internal class StatementOptimizer(private val program: Program,
     override fun after(subroutine: Subroutine, parent: Node): Iterable<IAstModification> {
         val forceOutput = "force_output" in subroutine.definingBlock().options()
         if(subroutine.asmAddress==null && !forceOutput) {
-            if(subroutine.containsNoCodeNorVars()) {
+            if(subroutine.containsNoCodeNorVars() && !subroutine.inline) {
                 errors.warn("removing empty subroutine '${subroutine.name}'", subroutine.position)
                 val removals = callgraph.calledBy.getValue(subroutine).map {
                     IAstModification.Remove(it, it.definingScope())
@@ -323,7 +323,7 @@ internal class StatementOptimizer(private val program: Program,
                     val op1 = binExpr.operator
                     val op2 = rExpr.operator
 
-                    if(rExpr.left is NumericLiteralValue && op2 in setOf("+", "*", "&", "|")) {
+                    if(rExpr.left is NumericLiteralValue && op2 in associativeOperators) {
                         // associative operator, make sure the constant numeric value is second (right)
                         return listOf(IAstModification.SwapOperands(rExpr))
                     }
@@ -441,6 +441,47 @@ internal class StatementOptimizer(private val program: Program,
         return noModifications
     }
 
+    override fun after(returnStmt: Return, parent: Node): Iterable<IAstModification> {
+        fun returnViaIntermediary(value: Expression): Iterable<IAstModification>? {
+            val returnDt = returnStmt.definingSubroutine()!!.returntypes.single()
+            if (returnDt in IntegerDatatypes) {
+                // first assign to intermediary, then return that register
+                val returnValueIntermediary =
+                    when(returnDt) {
+                        DataType.UBYTE -> IdentifierReference(listOf("prog8_lib", "retval_interm_ub"), returnStmt.position)
+                        DataType.BYTE -> IdentifierReference(listOf("prog8_lib", "retval_interm_b"), returnStmt.position)
+                        DataType.UWORD -> IdentifierReference(listOf("prog8_lib", "retval_interm_uw"), returnStmt.position)
+                        DataType.WORD -> IdentifierReference(listOf("prog8_lib", "retval_interm_w"), returnStmt.position)
+                        else -> throw FatalAstException("weird return dt")
+                    }
+                val tgt = AssignTarget(returnValueIntermediary, null, null, returnStmt.position)
+                val assign = Assignment(tgt, value, returnStmt.position)
+                val returnReplacement = Return(returnValueIntermediary, returnStmt.position)
+                return listOf(
+                    IAstModification.InsertBefore(returnStmt, assign, parent as INameScope),
+                    IAstModification.ReplaceNode(returnStmt, returnReplacement, parent)
+                )
+            }
+            return null
+        }
+
+        when(returnStmt.value) {
+            is PrefixExpression -> {
+                val mod = returnViaIntermediary(returnStmt.value!!)
+                if(mod!=null)
+                    return mod
+            }
+            is BinaryExpression -> {
+                val mod = returnViaIntermediary(returnStmt.value!!)
+                if(mod!=null)
+                    return mod
+            }
+            else -> {}
+        }
+
+        return super.after(returnStmt, parent)
+    }
+
     private fun hasBreak(scope: INameScope): Boolean {
 
         class Searcher: IAstVisitor

compiler/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -4,6 +4,7 @@ import prog8.ast.INameScope
 import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.base.ErrorReporter
+import prog8.ast.expressions.*
 import prog8.ast.processing.AstWalker
 import prog8.ast.processing.IAstModification
 import prog8.ast.statements.*
@@ -93,7 +94,14 @@ internal class UnusedCodeRemover(private val program: Program, private val error
             if (assign1 != null && assign2 != null && !assign2.isAugmentable) {
                 if (assign1.target.isSameAs(assign2.target, program) && assign1.target.isInRegularRAM(program.namespace))  {
                     if(assign2.target.identifier==null || !assign2.value.referencesIdentifier(*(assign2.target.identifier!!.nameInSource.toTypedArray())))
-                        linesToRemove.add(assign1)
+                        // only remove the second assignment if its value is a simple expression!
+                        when(assign2.value) {
+                            is PrefixExpression,
+                            is BinaryExpression,
+                            is TypecastExpression,
+                            is FunctionCall -> { /* don't remove */ }
+                            else -> linesToRemove.add(assign1)
+                        }
                 }
             }
         }

compiler/src/prog8/parser/ModuleParsing.kt

@@ -100,9 +100,53 @@ internal class ModuleImporter {
         return moduleAst
     }
 
-    private fun discoverImportedModuleFile(name: String, source: Path, position: Position?): Path {
+    private fun executeImportDirective(program: Program, import: Directive, source: Path): Module? {
+        if(import.directive!="%import" || import.args.size!=1 || import.args[0].name==null)
+            throw SyntaxError("invalid import directive", import.position)
+        val moduleName = import.args[0].name!!
+        if("$moduleName.p8" == import.position.file)
+            throw SyntaxError("cannot import self", import.position)
+
+        val existing = program.modules.singleOrNull { it.name == moduleName }
+        if(existing!=null)
+            return null
+
+        val rsc = tryGetModuleFromResource("$moduleName.p8")
+        val importedModule =
+                if(rsc!=null) {
+                    // load the module from the embedded resource
+                    val (resource, resourcePath) = rsc
+                    resource.use {
+                        println("importing '$moduleName' (library)")
+                        importModule(program, CharStreams.fromStream(it), Paths.get("@embedded@/$resourcePath"), true)
+                    }
+                } else {
+                    val modulePath = tryGetModuleFromFile(moduleName, source, import.position)
+                    importModule(program, modulePath)
+                }
+
+        importedModule.checkImportedValid()
+        return importedModule
+    }
+
+    private fun tryGetModuleFromResource(name: String): Pair<InputStream, String>? {
+        val target = CompilationTarget.instance.name
+        val targetSpecificPath = "/prog8lib/$target/$name"
+        val targetSpecificResource = object{}.javaClass.getResourceAsStream(targetSpecificPath)
+        if(targetSpecificResource!=null)
+            return Pair(targetSpecificResource, targetSpecificPath)
+
+        val generalPath = "/prog8lib/$name"
+        val generalResource = object{}.javaClass.getResourceAsStream(generalPath)
+        if(generalResource!=null)
+            return Pair(generalResource, generalPath)
+
+        return null
+    }
+
+    private fun tryGetModuleFromFile(name: String, source: Path, position: Position?): Path {
         val fileName = "$name.p8"
-        val locations = if(source.toString().isEmpty()) mutableListOf<Path>() else mutableListOf(source.parent)
+        val locations = if(source.toString().isEmpty()) mutableListOf<Path>() else mutableListOf(source.parent ?: Path.of("."))
 
         val propPath = System.getProperty("prog8.libdir")
         if(propPath!=null)
@@ -119,48 +163,4 @@ internal class ModuleImporter {
 
         throw ParsingFailedError("$position Import: no module source file '$fileName' found  (I've looked in: embedded libs and $locations)")
     }
-
-    private fun executeImportDirective(program: Program, import: Directive, source: Path): Module? {
-        if(import.directive!="%import" || import.args.size!=1 || import.args[0].name==null)
-            throw SyntaxError("invalid import directive", import.position)
-        val moduleName = import.args[0].name!!
-        if("$moduleName.p8" == import.position.file)
-            throw SyntaxError("cannot import self", import.position)
-
-        val existing = program.modules.singleOrNull { it.name == moduleName }
-        if(existing!=null)
-            return null
-
-        val rsc = tryGetEmbeddedResource("$moduleName.p8")
-        val importedModule =
-                if(rsc!=null) {
-                    // load the module from the embedded resource
-                    val (resource, resourcePath) = rsc
-                    resource.use {
-                        println("importing '$moduleName' (library)")
-                        importModule(program, CharStreams.fromStream(it), Paths.get("@embedded@/$resourcePath"), true)
-                    }
-                } else {
-                    val modulePath = discoverImportedModuleFile(moduleName, source, import.position)
-                    importModule(program, modulePath)
-                }
-
-        importedModule.checkImportedValid()
-        return importedModule
-    }
-
-    private fun tryGetEmbeddedResource(name: String): Pair<InputStream, String>? {
-        val target = CompilationTarget.instance.name
-        val targetSpecificPath = "/prog8lib/$target/$name"
-        val targetSpecificResource = object{}.javaClass.getResourceAsStream(targetSpecificPath)
-        if(targetSpecificResource!=null)
-            return Pair(targetSpecificResource, targetSpecificPath)
-
-        val generalPath = "/prog8lib/$name"
-        val generalResource = object{}.javaClass.getResourceAsStream(generalPath)
-        if(generalResource!=null)
-            return Pair(generalResource, generalPath)
-
-        return null
-    }
 }

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

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

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

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

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

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

compiler/test/UnitTests.kt

@@ -477,7 +477,7 @@ class TestMemory {
         val memexpr = IdentifierReference(listOf("address"), Position.DUMMY)
         val target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
-        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         subroutine.linkParents(ParentSentinel)
         return target
     }
@@ -497,7 +497,7 @@ class TestMemory {
         val decl = VarDecl(VarDeclType.VAR, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", null, null, false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
-        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         subroutine.linkParents(ParentSentinel)
         assertTrue(target.isInRegularRAM(target.definingScope()))
     }
@@ -509,7 +509,7 @@ class TestMemory {
         val decl = VarDecl(VarDeclType.MEMORY, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", null, NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
-        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         subroutine.linkParents(ParentSentinel)
         assertTrue(target.isInRegularRAM(target.definingScope()))
     }
@@ -521,7 +521,7 @@ class TestMemory {
         val decl = VarDecl(VarDeclType.MEMORY, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", null, NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
-        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         subroutine.linkParents(ParentSentinel)
         assertFalse(target.isInRegularRAM(target.definingScope()))
     }
@@ -533,7 +533,7 @@ class TestMemory {
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
-        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         subroutine.linkParents(ParentSentinel)
         assertTrue(target.isInRegularRAM(target.definingScope()))
     }
@@ -546,7 +546,7 @@ class TestMemory {
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
-        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         subroutine.linkParents(ParentSentinel)
         assertTrue(target.isInRegularRAM(target.definingScope()))
     }
@@ -559,7 +559,7 @@ class TestMemory {
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
-        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, mutableListOf(decl, assignment), Position.DUMMY)
+        val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         subroutine.linkParents(ParentSentinel)
         assertFalse(target.isInRegularRAM(target.definingScope()))
     }

dbusCompilerService/build.gradle

@@ -0,0 +1,96 @@
+
+plugins {
+    id 'java'
+    id 'application'
+    id "org.jetbrains.kotlin.jvm" version "1.4.21"
+    id 'com.github.johnrengelman.shadow' version '6.1.0'
+}
+
+targetCompatibility = 11
+sourceCompatibility = 11
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+    maven { url "https://kotlin.bintray.com/kotlinx" }
+}
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    // implementation "org.jetbrains.kotlin:kotlin-reflect"
+    implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.1'
+    implementation "com.github.hypfvieh:dbus-java:3.2.4"
+    implementation "org.slf4j:slf4j-simple:1.7.30"
+
+    testImplementation "org.jetbrains.kotlin:kotlin-test-junit5"
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.2'
+    testImplementation 'org.hamcrest:hamcrest-junit:2.0.0.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.2'
+}
+
+compileKotlin {
+    kotlinOptions {
+        jvmTarget = "11"
+        // verbose = true
+        // freeCompilerArgs += "-XXLanguage:+NewInference"
+    }
+}
+
+compileTestKotlin {
+    kotlinOptions {
+        jvmTarget = "11"
+    }
+}
+
+sourceSets {
+    main {
+        java {
+            srcDirs = ["${project.projectDir}/src"]
+        }
+        resources {
+            srcDirs = ["${project.projectDir}/res"]
+        }
+    }
+    test {
+        java {
+            srcDirs = ["${project.projectDir}/test"]
+        }
+    }
+}
+
+startScripts.enabled = true
+
+application {
+    mainClass = 'prog8.dbus.TestdbusKt'
+    mainClassName = 'prog8.dbus.TestdbusKt'  // deprecated
+    applicationName = 'testdbus'
+}
+
+artifacts {
+    archives shadowJar
+}
+
+
+shadowJar {
+    archiveBaseName = 'prog8compilerservicedbus'
+    archiveVersion = '1.0'
+    // minimize()
+}
+
+
+test {
+    // Enable JUnit 5 (Gradle 4.6+).
+    useJUnitPlatform()
+
+    // Always run tests, even when nothing changed.
+    dependsOn 'cleanTest'
+
+    // Show test results.
+    testLogging {
+        events "skipped", "failed"
+    }
+}
+
+task wrapper(type: Wrapper) {
+    gradleVersion = '6.7'
+}

dbusCompilerService/dbusCompilerService.iml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$/../dbusCompilerService">
+      <sourceFolder url="file://$MODULE_DIR$/../dbusCompilerService/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="11" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
+    <orderEntry type="library" name="kotlinx-cli-jvm" level="project" />
+    <orderEntry type="library" name="dbus-java-3.2.4" level="project" />
+  </component>
+</module>

dbusCompilerService/src/prog8/dbus/IrmenDbusTest.kt

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

dbusCompilerService/src/prog8/dbus/clientmain.kt

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

dbusCompilerService/src/prog8/dbus/testdbus.kt

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

docs/source/index.rst

@@ -10,10 +10,10 @@ Prog8 documentation - |version|
 What is Prog8?
 --------------
 
-This is an experimental compiled programming language targeting the 8-bit
+This is a 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.
+`6510 <https://en.wikipedia.org/wiki/MOS_Technology_6510>`_ /
+`65c02 <https://en.wikipedia.org/wiki/MOS_Technology_65C02>`_ microprocessors.
 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>`_.
 The language aims to provide many conveniences over raw assembly code (even when using a macro assembler),
@@ -55,7 +55,8 @@ Language features
 - Nested subroutines can access variables from outer scopes to avoids the overhead to pass everything via parameters
 - Variable data types include signed and unsigned bytes and words, arrays, strings and floats.
 - High-level code optimizations, such as const-folding, expression and statement simplifications/rewriting.
-- Many built-in functions, such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``substr``, ``sort`` and ``reverse`` (and others)
+- Many built-in functions, such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``sort`` and ``reverse``
+- Supports the sixteen 'virtual' 16-bit registers R0 .. R15 from the Commander X16, also on the C64.
 - If you only use standard kernel and prog8 library routines, it is possible to compile the *exact same program* for both machines (just change the compiler target flag)!
 
 
@@ -73,7 +74,7 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
 
         sub start() {
             ; clear the sieve, to reset starting situation on subsequent runs
-            memset(sieve, 256, false)
+            sys.memset(sieve, 256, false)
             ; calculate primes
             txt.print("prime numbers up to 255:\n\n")
             ubyte amount=0
@@ -85,10 +86,10 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
                 txt.print(", ")
                 amount++
             }
-            txt.chrout('\n')
+            txt.nl()
             txt.print("number of primes (expected 54): ")
             txt.print_ub(amount)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         sub find_next_prime() -> ubyte {
@@ -132,7 +133,7 @@ Required tools
 
 `64tass <https://sourceforge.net/projects/tass64/>`_ - cross assembler. Install this on your shell path.
 It's very easy to compile yourself.
-A recent precompiled .exe for Windows can be obtained from my `clone <https://github.com/irmen/64tass/releases>`_ of this project.
+A recent precompiled .exe (only for Windows) can be obtained from my `clone <https://github.com/irmen/64tass/releases>`_ of this project.
 *You need at least version 1.55.2257 of this assembler to correctly use the breakpoints feature.*
 It's possible to use older versions, but it is very likely that the automatic Vice breakpoints won't work with them.
 
@@ -165,6 +166,7 @@ If you're targeting the CommanderX16 instead, there's the `x16emu <https://githu
     programming.rst
     syntaxreference.rst
     libraries.rst
+    technical.rst
     todo.rst
 
 

docs/source/libraries.rst

@@ -16,6 +16,10 @@ with Prog8 are written like this.
 You can ``%import`` and use these modules explicitly, but the compiler may also import one or more
 of these library modules automatically as required.
 
+For full details on what is available in the libraries, look at their source code here:
+https://github.com/irmen/prog8/tree/master/compiler/res/prog8lib
+
+
 .. caution::
     The resulting compiled binary program *only works on the target machine it was compiled for*.
     You must recompile the program for every target you want to run it on.
@@ -30,6 +34,72 @@ as ROM/kernal subroutine definitions, memory location constants, and utility sub
 Many of these definitions overlap for the C64 and Commander X16 targets so it is still possible
 to write programs that work on both targets without modifications.
 
+sys (part of syslib)
+--------------------
+``target``
+    A constant ubyte value designating the target machine that the program is compiled for.
+    Notice that this is a compile-time constant value and is not determined on the
+    system when the program is running.
+    The following return values are currently defined:
+
+    - 16 = compiled for CommanderX16 with 65C02 CPU
+    - 64 = compiled for Commodore-64 with 6502/6510 CPU
+
+``exit(returncode)``
+    Immediately stops the program and exits it, with the returncode in the A register.
+    Note: custom interrupt handlers remain active unless manually cleared first!
+
+``memcopy(from, to, numbytes)``
+    Efficiently copy a number of bytes from a memory location to another.
+    NOTE: 'to' must NOT overlap with 'from', unless it is *before* 'from'.
+    Because this function imposes some overhead to handle the parameters,
+    it is only faster if the number of bytes is larger than a certain threshold.
+    Compare the generated code to see if it was beneficial or not.
+    The most efficient will often be to write a specialized copy routine in assembly yourself!
+
+``memset(address, numbytes, bytevalue)``
+    Efficiently set a part of memory to the given (u)byte value.
+    But the most efficient will always be to write a specialized fill routine in assembly yourself!
+    Note that for clearing the screen, very fast specialized subroutines are
+    available in the ``textio`` and ``graphics`` library modules.
+
+``memsetw(address, numwords, wordvalue)``
+    Efficiently set a part of memory to the given (u)word value.
+    But the most efficient will always be to write a specialized fill routine in assembly yourself!
+
+``rsave()``
+    Saves the CPU registers and the status flags.
+    You can now more or less 'safely' use the registers directly, until you
+    restore them again so the generated code can carry on normally.
+    Note: it's not needed to rsave() before an asm subroutine that clobbers the X register
+    (which is used as the internal evaluation stack pointer).
+    The compiler will take care of this situation automatically.
+    Note: the 16 bit 'virtual' registers of the Commander X16 are *not* saved.
+
+``rrestore()``
+    Restores the CPU registers and the status flags from previously saved values.
+    Note: the 16 bit 'virtual' registers of the Commander X16 are *not* restored.
+
+``read_flags() -> ubyte``
+    Returns the current value of the CPU status register.
+
+``set_carry()``
+    Sets the CPU status register Carry flag.
+
+``clear_carry()``
+    Clears the CPU status register Carry flag.
+
+``set_irqd()``
+    Sets the CPU status register Interrupt Disable flag.
+
+``clear_irqd()``
+    Clears the CPU status register Interrupt Disable flag.
+
+``progend()``
+    Returns the last address of the program in memory + 1.
+    Can be used to load dynamic data after the program, instead of hardcoding something.
+
+
 conv
 ----
 Routines to convert strings to numbers or vice versa.
@@ -54,12 +124,62 @@ diskio
 ------
 Provides several routines that deal with disk drive I/O, such as:
 
-- show directory
+- list files on disk, optionally filtering by a simple pattern with ? and *
+- show disk directory as-is
 - display disk drive status
 - load and save data from and to the disk
 - delete and rename files on the disk
 
 
+string
+------
+Provides string manipulation routines.
+
+``length(str) -> ubyte length``
+    Number of bytes in the string. This value is determined during runtime and counts upto
+    the first terminating 0 byte in the string, regardless of the size of the string during compilation time.
+    Don't confuse this with ``len`` and ``sizeof``
+
+``left(source, length, target)``
+    Copies the left side of the source string of the given length to target string.
+    It is assumed the target string buffer is large enough to contain the result.
+    Also, you have to make sure yourself that length is smaller or equal to the length of the source string.
+    Modifies in-place, doesn't return a value (so can't be used in an expression).
+
+``right(source, length, target)``
+    Copies the right side of the source string of the given length to target string.
+    It is assumed the target string buffer is large enough to contain the result.
+    Also, you have to make sure yourself that length is smaller or equal to the length of the source string.
+    Modifies in-place, doesn't return a value (so can't be used in an expression).
+
+``slice(source, start, length, target)``
+    Copies a segment from the source string, starting at the given index,
+    and of the given length to target string.
+    It is assumed the target string buffer is large enough to contain the result.
+    Also, you have to make sure yourself that start and length are within bounds of the strings.
+    Modifies in-place, doesn't return a value (so can't be used in an expression).
+
+``find(string, char) -> uword address``
+    Locates the first position of the given character in the string, returns the string starting
+    with this character or $0000 if the character is not found.
+
+``compare(string1, string2) -> ubyte result``
+    Returns -1, 0 or 1 depeding on wether string1 sorts before, equal or after string2.
+    Note that you can also directly compare strings and string values with eachother
+    using ``==``, ``<`` etcetera (it will use string.compare for you under water automatically).
+
+``copy(from, to) -> ubyte length``
+    Copy a string to another, overwriting that one. Returns the length of the string that was copied.
+    Often you don't have to call this explicitly and can just write ``string1 = string2``
+    but this function is useful if you're dealing with addresses for instance.
+
+``lower(string)``
+    Lowercases the petscii-string in place.
+
+``upper(string)``
+    Uppercases the petscii-string in place.
+
+
 floats
 ------
 Provides definitions for the ROM/kernel subroutines and utility routines dealing with floating
@@ -68,12 +188,36 @@ point variables.  This includes ``print_f``, the routine used to print floating
 
 graphics
 --------
-High-res monochrome bitmap graphics routines:
+Monochrome bitmap graphics routines, fixed 320*200 resolution:
 
 - clearing the screen
-- drawing lines
-- drawing circles and discs (filled circles)
-- plotting individual pixels
+- drawing individual pixels
+- drawing lines, rectangles, filled rectangles, circles, discs
+
+This library is available both on the C64 and the Cx16.
+It uses the ROM based graphics routines on the latter, and it is a very small library because of that.
+That also means though that it is constrained to 320*200 resolution on the Cx16 as well.
+Use the ``gfx2`` library if you want full-screen graphics or non-monochrome drawing.
+
+
+gfx2  (cx16 only)
+-----------------
+Full-screen multicolor bitmap graphics routines, available on the Cx16 machine only.
+
+- multiple full-screen resolutions: 640 * 480 monochrome, and 320 * 240 monochrome and 256 colors
+- clearing screen, switching screen mode, also back to text mode is possible.
+- drawing individual pixels
+- drawing lines, rectangles, filled rectangles, circles, discs
+- drawing text inside the bitmap
+- in monochrome mode, it's possible to use a stippled drawing pattern to simulate a shade of gray.
+
+
+palette  (cx16 only)
+--------------------
+Available for the Cx16 target. Various routines to set the display color palette.
+There are also a few better looking Commodore-64 color palettes available here,
+because the Commander X16's default colors for this (the first 16 colors) are too saturated
+and are quite different than how they looked on a VIC-II chip in a C-64.
 
 
 math

docs/source/programming.rst

@@ -309,18 +309,21 @@ read the syntax reference on strings.
 
 
 .. hint::
-    Strings and uwords (=memory address) can often be interchanged.
+    Strings/arrays and uwords (=memory address) can often be interchanged.
     An array of strings is actually an array of uwords where every element is the memory
     address of the string. You can pass a memory address to assembly functions
     that require a string as an argument.
+    For regular assignments you still need to use an explicit ``&`` (address-of) to take
+    the address of the string or array.
 
 .. caution::
-    It's probably best to avoid changing strings after they've been created. This
-    includes changing certain letters by index, or by assigning a new value, or by
+    It's probably best to avoid changing the contents in strings and treat them as static.
+    This includes changing certain letters by index, or by assigning a new value, or by
     modifying the string via other means for example ``substr`` function and its cousins.
-    This is because if your program exits and is restarted (without loading it again),
-    it will then start working with the changed strings instead of the original ones!
-    The same is true for arrays.
+    This is because the changes persist in memory. If your program exits and is restarted
+    (without reloading it from disk), it will then start working with the modified strings
+    instead of the original ones!
+    The same is true for arrays! So be careful to (re)initialize them if needed.
 
 
 Structs
@@ -373,6 +376,19 @@ address you specified, and setting the varible will directly modify that memory
 	&word  SCREENCOLORS = $d020             ; a 16-bit word at the addres $d020-$d021
 
 
+Direct access to memory locations
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Normally memory locations are accessed by a *memory mapped* name, such as ``c64.BGCOL0`` that is defined
+as the memory mapped address $d021.
+
+If you want to access a memory location directly (by using the address itself), without defining
+a memory mapped location, you can do so by enclosing the address in ``@(...)``::
+
+    color = @($d020)  ; set the variable 'color' to the current c64 screen border color ("peek(53280)")
+    @($d020) = 0      ; set the c64 screen border to black ("poke 53280,0")
+    @(vic+$20) = 6    ; you can also use expressions to 'calculate' the address
+
+
 Converting types into other types
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -478,6 +494,12 @@ condition              meaning
 
 So ``if_cc goto target`` will directly translate into the single CPU instruction ``BCC target``.
 
+.. caution::
+    These special ``if_XX`` branching statements are only useful in certain specific situations where you are *certain*
+    that the status register (still) contains the correct status bits.
+    This is not always the case after a fuction call or other operations!
+    If in doubt, check the generated assembly code!
+
 .. note::
     For now, the symbols used or declared in the statement block(s) are shared with
     the same scope the if statement itself is in.
@@ -527,18 +549,6 @@ a fixed amount of memory which will not change.  (You *can* change the value of
     that there is a loss of precision. You can use builtin functions such as ``round`` and ``lsb`` to convert
     to a smaller datatype, or revert to integer arithmetic.
 
-Direct access to memory locations
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Normally memory locations are accessed by a *memory mapped* name, such as ``c64.BGCOL0`` that is defined
-as the memory mapped address $d021.
-
-If you want to access a memory location directly (by using the address itself), without defining
-a memory mapped location, you can do so by enclosing the address in ``@(...)``::
-
-    color = @($d020)  ; set the variable 'color' to the current c64 screen border color ("peek(53280)")
-    @($d020) = 0      ; set the c64 screen border to black ("poke 53280,0")
-    @(vic+$20) = 6    ; you can also use expressions to 'calculate' the address
-
 
 Expressions
 -----------
@@ -622,6 +632,13 @@ Defining a subroutine
 Subroutines are parts of the code that can be repeatedly invoked using a subroutine call from elsewhere.
 Their definition, using the ``sub`` statement, includes the specification of the required parameters and return value.
 Subroutines can be defined in a Block, but also nested inside another subroutine. Everything is scoped accordingly.
+With ``asmsub`` you can define a low-level subroutine that is implemented in inline assembly and takes any parameters
+in registers directly.
+
+Trivial subroutines can be tagged as inline to tell the compiler to copy their code
+in-place to the locations where the subroutine is called, rather than inserting an actual call and return to the
+subroutine. This may increase code size significantly and can only be used in limited scenarios, so YMMV.
+
 
 Calling a subroutine
 ^^^^^^^^^^^^^^^^^^^^
@@ -762,61 +779,8 @@ sort(array)
     Sorting strings alphabetically has to be programmed yourself if you need it.
 
 
-Strings and memory blocks
-^^^^^^^^^^^^^^^^^^^^^^^^^
-memcopy(from, to, numbytes)
-    Efficiently copy a number of bytes from a memory location to another.
-    NOTE: 'to' must NOT overlap with 'from', unless it is *before* 'from'.
-    Because this function imposes some overhead to handle the parameters,
-    it is only faster if the number of bytes is larger than a certain threshold.
-    Compare the generated code to see if it was beneficial or not.
-    The most efficient will often be to write a specialized copy routine in assembly yourself!
-
-memset(address, numbytes, bytevalue)
-    Efficiently set a part of memory to the given (u)byte value.
-    But the most efficient will always be to write a specialized fill routine in assembly yourself!
-    Note that for clearing the screen, very fast specialized subroutines are
-    available in the ``textio`` and ``graphics`` library modules.
-
-memsetw(address, numwords, wordvalue)
-    Efficiently set a part of memory to the given (u)word value.
-    But the most efficient will always be to write a specialized fill routine in assembly yourself!
-
-leftstr(source, target, length)
-    Copies the left side of the source string of the given length to target string.
-    It is assumed the target string buffer is large enough to contain the result.
-    Also, you have to make sure yourself that length is smaller or equal to the length of the source string.
-    Modifies in-place, doesn't return a value (so can't be used in an expression).
-
-rightstr(source, target, length)
-    Copies the right side of the source string of the given length to target string.
-    It is assumed the target string buffer is large enough to contain the result.
-    Also, you have to make sure yourself that length is smaller or equal to the length of the source string.
-    Modifies in-place, doesn't return a value (so can't be used in an expression).
-
-strlen(str)
-    Number of bytes in the string. This value is determined during runtime and counts upto
-    the first terminating 0 byte in the string, regardless of the size of the string during compilation time.
-    Don't confuse this with ``len`` and ``sizeof``
-
-strcmp(string1, string2)
-    Returns -1, 0 or 1 depeding on wether string1 sorts before, equal or after string2.
-    Note that you can also directly compare strings and string values with eachother
-    using ``==``, ``<`` etcetera (it will use strcmp for you under water automatically).
-
-substr(source, target, start, length)
-    Copies a segment from the source string, starting at the given index,
-    and of the given length to target string.
-    It is assumed the target string buffer is large enough to contain the result.
-    Also, you have to make sure yourself that start and length are within bounds of the strings.
-    Modifies in-place, doesn't return a value (so can't be used in an expression).
-
 Miscellaneous
 ^^^^^^^^^^^^^
-exit(returncode)
-    Immediately stops the program and exits it, with the returncode in the A register.
-    Note: custom interrupt handlers remain active unless manually cleared first!
-
 lsb(x)
     Get the least significant byte of the word x. Equivalent to the cast "x as ubyte".
 
@@ -827,6 +791,12 @@ mkword(msb, lsb)
     Efficiently create a word value from two bytes (the msb and the lsb). Avoids multiplication and shifting.
     So mkword($80, $22) results in $8022.
 
+    .. note::
+        The arguments to the mkword() function are in 'natural' order that is first the msb then the lsb.
+        Don't get confused by how the system actually stores this 16-bit word value in memory (which is
+        in little-endian format, so lsb first then msb)
+
+
 rnd()
     returns a pseudo-random byte from 0..255
 
@@ -860,37 +830,26 @@ ror2(x)
     It uses some extra logic to not consider the carry flag as extra rotation bit.
     Modifies in-place, doesn't return a value (so can't be used in an expression).
 
-rsave()
-    Saves the CPU registers and the status flags.
-    You can now more or less 'safely' use the registers directly, until you
-    restore them again so the generated code can carry on normally.
-    Note: it's not needed to rsave() before an asm subroutine that clobbers the X register
-    (which is used as the internal evaluation stack pointer).
-    The compiler will take care of this situation automatically.
-
-rrestore()
-    Restores the CPU registers and the status flags from previously saved values.
-
-read_flags()
-    Returns the current value of the CPU status register.
-
 sizeof(name)
     Number of bytes that the object 'name' occupies in memory. This is a constant determined by the data type of
     the object. For instance, for a variable of type uword, the sizeof is 2.
     For an 10 element array of floats, it is 50 (on the C-64, where a float is 5 bytes).
     Note: usually you will be interested in the number of elements in an array, use len() for that.
 
-set_carry()  /  clear_carry()
-    Set (or clear) the CPU status register Carry flag. No result value.
-    (translated into ``SEC`` or ``CLC`` cpu instruction)
-
-set_irqd()  /  clear_irqd()
-    Set (or clear) the CPU status register Interrupt Disable flag. No result value.
-    (translated into ``SEI`` or ``CLI`` cpu instruction)
-
 swap(x, y)
     Swap the values of numerical variables (or memory locations) x and y in a fast way.
 
+memory(name, size)
+    Returns the address of the first location of a statically "reserved" block of memory of the given size in bytes,
+    with the given name. Requesting the address of such a named memory block again later with
+    the same name, will result in the same address as before.
+    When reusing blocks in that way, it is required that the size argument is the same,
+    otherwise you'll get a compilation error.
+    This routine can be used to "reserve" parts of the memory where a normal byte array variable would
+    not suffice; for instance if you need more than 256 consecutive bytes.
+    The return value is just a simple uword address so it cannot be used as an array in your program.
+    You can only treat it as a pointer or use it in inline assembly.
+
 
 Library routines
 ----------------

docs/source/syntaxreference.rst

@@ -517,11 +517,11 @@ You can still call the subroutine and not store the results.
 
 **There is an exception:** if there's just one return value in a register, and one or more others that are returned
 as bits in the status register (such as the Carry bit), the compiler allows you to call the subroutine.
-It will then store the result value in a variable if required, and *keep the status register untouched
-after the call* so you can use a conditional branch statement for that.
-Note that this makes no sense inside an expression, so the compiler will still give an error for that.
+It will then store the result value in a variable if required, and *try to keep the status register untouched
+after the call* so you can often use a conditional branch statement for that. But the latter is tricky,
+make sure you check the generated assembly code.
 
-If there really are multiple return values (other than a combined 16 bit return value in 2 registers),
+If there really are multiple relevant return values (other than a combined 16 bit return value in 2 registers),
 you'll have to write a small block of custom inline assembly that does the call and stores the values
 appropriately. Don't forget to save/restore any registers that are modified.
 
@@ -531,7 +531,7 @@ Subroutine definitions
 
 The syntax is::
 
-        sub   <identifier>  ( [parameters] )  [ -> returntype ]  {
+        [inline]  sub   <identifier>  ( [parameters] )  [ -> returntype ]  {
                 ... statements ...
         }
 
@@ -544,6 +544,9 @@ The open curly brace must immediately follow the subroutine result specification
 and can have nothing following it. The close curly brace must be on its own line as well.
 The parameters is a (possibly empty) comma separated list of "<datatype> <parametername>" pairs specifying the input parameters.
 The return type has to be specified if the subroutine returns a value.
+The ``inline`` keyword makes their code copied in-place to the locations where the subroutine is called,
+rather than having an actual call and return to the subroutine. This is meant for trivial subroutines only
+as it can increase code size significantly.
 
 
 Assembly /  ROM subroutines
@@ -557,7 +560,6 @@ This defines the ``LOAD`` subroutine at ROM memory address $FFD5, taking argumen
 and returning stuff in several registers as well. The ``clobbers`` clause is used to signify to the compiler
 what CPU registers are clobbered by the call instead of being unchanged or returning a meaningful result value.
 
-
 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::
 
@@ -576,6 +578,26 @@ the parameters are strictly passed via cpu registers), are defined with ``asmsub
 
 the statement body of such a subroutine should consist of just an inline assembly block.
 
+The ``@ <register>`` part is required for rom and assembly-subroutines, as it specifies for the compiler
+what cpu registers should take the routine's arguments.  You can use the regular set of registers
+(A, X, Y), the special 16-bit register pairs to take word values (AX, AY and XY) and even a processor status
+flag such as Carry (Pc).
+
+.. note::
+    Asmsubs can also be tagged as ``inline asmsub`` to make trivial pieces of assembly inserted
+    directly instead of a call to them. Note that it is literal copy-paste of code that is done,
+    so make sure the assembly is actually written to behave like such - which probably means you
+    don't want a ``rts`` or ``jmp`` in it!
+
+
+.. note::
+    The 'virtual' 16-bit registers from the Commander X16 can also be used as ``R0`` .. ``R15`` .
+    This means you don't have to set them up manually before calling a subroutine that takes
+    one or more parameters in those 'registers'. You can just list the arguments directly.
+    *This also works on the Commodore-64!*  (however they are not as efficient there because they're not in zeropage)
+    In prog8 and assembly code these 'registers' are directly accessible too via
+    ``cx16.r0`` .. ``cx16.r15``  (they're memory mapped uword values)
+
 
 Expressions
 -----------
@@ -721,6 +743,13 @@ The XX corresponds to one of the eigth branching instructions so the possibiliti
 ``if_cs``, ``if_cc``, ``if_eq``, ``if_ne``, ``if_pl``, ``if_mi``, ``if_vs`` and ``if_vc``.
 It can also be one of the four aliases that are easier to read: ``if_z``, ``if_nz``, ``if_pos`` and ``if_neg``.
 
+.. caution::
+    These special ``if_XX`` branching statements are only useful in certain specific situations where you are *certain*
+    that the status register (still) contains the correct status bits.
+    This is not always the case after a fuction call or other operations!
+    If in doubt, check the generated assembly code!
+
+
 when statement ('jump table')
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 The structure of a when statement is like this::

docs/source/targetsystem.rst

@@ -11,8 +11,8 @@ Prog8 targets the following hardware:
 
 Currently there are two machines that are supported as compiler target (selectable via the ``-target`` compiler argument):
 
-- 'c64': the well-known Commodore-64, premium support
-- 'cx16': the `CommanderX16 <https://www.commanderx16.com/>`_ a project from the 8-Bit Guy. Support for this is still experimental.
+- 'c64': the well-known Commodore-64
+- 'cx16': the `CommanderX16 <https://www.commanderx16.com/>`_ conceived by the 8-Bit Guy.
 
 This chapter explains the relevant system details of these machines.
 
@@ -131,21 +131,8 @@ The status register (P) carry flag and interrupt disable flag can be written via
 builtin functions (``set_carry()``, ``clear_carry()``, ``set_irqd()``,  ``clear_irqd()``),
 and read via the ``read_flags()`` function.
 
-
-Subroutine Calling Conventions
-------------------------------
-
-**Kernel/assembly subroutines:**
-Arguments and results are passed via registers.
-Sometimes the status register's Carry flag is used as well (as a boolean flag).
-Special care should be taken when the subroutine clobbers the X register.
-If it does, X must be saved before and restored after the call.
-
-**Normal user defined subroutines:**
-Arguments and result values are passed via global variables stored in memory
-*These are not allocated on a stack* so it is not possible to create recursive calls!
-The result value(s) of a subroutine are returned on the evaluation stack,
-to make it possible to use subroutines in expressions.
+The 16 'virtual' 16-bit registers that are defined on the Commander X16 machine are not real hardware
+registers and are just 16 memory-mapped word values that you *can* access directly.
 
 
 IRQ Handling

docs/source/technical.rst

@@ -0,0 +1,85 @@
+===============
+Technical stuff
+===============
+
+All variables are static in memory
+----------------------------------
+
+All variables are allocated statically, there is no concept of dynamic heap or stack frames.
+Essentially all variables are global (but scoped) and can be accessed and modified anywhere,
+but care should be taken ofcourse to avoid unexpected side effects.
+
+Especially when you're dealing with interrupts or re-entrant routines: don't modify variables
+that you not own or else you will break stuff.
+
+
+Software stack for expression evaluation
+----------------------------------------
+
+Prog8 uses a software stack to evaluate complex expressions that it can't calculate in-place or
+directly into the target variable, register, or memory location.
+
+'software stack' means: seperated and not using the processor's hardware stack.
+
+The software stack is implemented as follows:
+
+- 2 pages of memory are allocated for this, exact locations vary per machine target.
+  For the C-64 they are set at $ce00 and $cf00 (so $ce00-$cfff is reserved).
+  For the Commander X16 they are set at $0400 and $0500 (so $0400-$05ff are reserved).
+- these are the high and low bytes of the values on the stack (it's a 'split 16 bit word stack')
+- for byte values just the lsb page is used, for word values both pages
+- float values (5 bytes) are chopped up into 2 words and 1 byte on this stack.
+- the X register is permanently allocated to be the stack pointer in the software stack.
+- you can use the X register as long as you're not using the software stack.
+  But you *must* make sure it is saved and restored after the code that modifies it,
+  otherwise the evaluation stack gets corrupted.
+
+Subroutine Calling Convention
+-----------------------------
+
+Calling a subroutine requires three steps:
+
+#. preparing the arguments (if any) and passing them to the routine
+#. calling the routine
+#. preparig the return value (if any) and returning that from the call.
+
+
+Calling the routine is just a simple JSR instruction, but the other two work like this:
+
+
+``asmsub`` routines
+^^^^^^^^^^^^^^^^^^^
+
+These are usually declarations of kernel (ROM) routines or low-level assembly only routines,
+that have their arguments solely passed into specific registers.
+Sometimes even via a processor status flag such as the Carry flag.
+Return values also via designated registers.
+The processor status flag is preserved on returning so you can immediately act on that for instance
+via a special branch instruction such as ``if_z`` or ``if_cs`` etc.
+
+
+regular subroutines
+^^^^^^^^^^^^^^^^^^^
+
+- subroutine parameters are just variables scoped to the subroutine.
+- the arguments passed in a call are evaluated (using the eval-stack if needed) and then
+  copied into those variables.
+  This sometimes can seem inefficient but it's required to allow subroutines to work locally
+  with their parameters and allow them to modify them as required, without changing the
+  variables used in the call's arguments.  If you want to get rid of this overhead you'll
+  have to make an ``asmsub`` routine in assembly instead.
+- the return value is passed back to the caller via cpu register(s):
+  Byte values will be put in ``A`` .
+  Word values will be put in ``A`` + ``Y`` register pair.
+  Float values will be put in the ``FAC1`` float 'register' (Basic allocated this somewhere in ram).
+
+
+Calls to builtin functions are treated in a special way:
+Generally if they have a single argument it's passed in a register or register pair.
+Multiple arguments are passed like a normal subroutine, into variables.
+Some builtin functions have a fully custom implementation.
+
+
+The compiler will warn about routines that are called and that return a value, if you're not
+doing something with that returnvalue. This can be on purpuse if you're simply not interested in it.
+Use the ``void`` keyword in front of the subroutine call to get rid of the warning in that case.

docs/source/todo.rst

@@ -2,11 +2,15 @@
 TODO
 ====
 
-- see if we can group some errors together for instance the (now single) errors about unidentified symbols
-- Cx16 target: support full-screen 640x480 and 320x240 graphics? That requires our own custom graphics routines though to draw lines.
+- use (zp) addressing mode on 65c02 specific code rather than ldy#0 / lda (zp),y
+- optimize pointer access code @(pointer)? use a subroutine? macro?  65c02 vs 6502?
+- can we get rid of the --longOptionName command line options and only keep the short versions? https://github.com/Kotlin/kotlinx-cli/issues/50
+- add a compiler option to generate a symbol listing at the end
+- optimizer: detect variables that are written but never read - mark those as unused too and remove them, such as uword unused = memory("unused222", 20) - also remove the memory slab allocation
+- hoist all variable declarations up to the subroutine scope *before* even the constant folding takes place (to avoid undefined symbol errors when referring to a variable from another nested scope in the subroutine)
 - make it possible to use cpu opcodes such as 'nop' as variable names by prefixing all asm vars with something such as '_'
 - option to load the built-in library files from a directory instead of the embedded ones (for easier library development/debugging)
-- use VIC banking to move up the graphics bitmap memory location. Move it to $e000 under the kernal rom?
+- c64: use VIC banking to move up the graphics bitmap memory location. Move it to $e000 under the kernal rom?
 - some support for recursive subroutines?
     - via %option recursive?: allocate all params and local vars on estack, don't allow nested subroutines, can begin by first not allowing any local variables just fixing the parameters
     - Or via a special recursive call operation that copies the current values of all local vars (including arguments) to the stack, replaces the arguments, jsr subroutine, and after returning copy the stack back to the local variables
@@ -19,10 +23,8 @@ Add more compiler optimizations to the existing ones.
 
 - further optimize assignment codegeneration, such as the following:
 - binexpr splitting (beware self-referencing expressions and asm code ballooning though)
-- detect var->var argument passing to subroutines and avoid the second variable and copying of the value
 - more optimizations on the language AST level
 - more optimizations on the final assembly source level
-- note: subroutine inlining is abandoned because of problems referencing non-local stuff. Can't move everything around.
 
 
 Eval stack redesign? (lot of work)

examples/.editorconfig

@@ -0,0 +1,20 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+max_line_length = 120
+tab_width = 8
+trim_trailing_whitespace = true
+ij_smart_tabs = true
+
+[*.p8]
+indent_size = 4
+indent_style = space
+
+[*.asm]
+indent_size = 8
+indent_style = tab

examples/arithmetic/aggregates.p8

@@ -1,5 +1,6 @@
 %import floats
 %import textio
+%import string
 %zeropage basicsafe
 
 main {
@@ -22,10 +23,10 @@ main {
         if length!=5 txt.print("error len1\n")
         length = len(uwarr)
         if length!=5 txt.print("error len2\n")
-        length=strlen(name)
+        length=string.length(name)
         if length!=5 txt.print("error strlen1\n")
         name[3] = 0
-        length=strlen(name)
+        length=string.length(name)
         if length!=3 txt.print("error strlen2\n")
 
         ; MAX

examples/arithmetic/bitshift.p8

@@ -5,72 +5,72 @@
 main {
 
     sub start() {
-        ubyte A
+        ubyte a
 
         txt.print("ubyte shift left\n")
-        A = shiftlb0()
-        txt.print_ubbin(A, true)
+        a = shiftlb0()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftlb1()
-        txt.print_ubbin(A, true)
+        a = shiftlb1()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftlb2()
-        txt.print_ubbin(A, true)
+        a = shiftlb2()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftlb3()
-        txt.print_ubbin(A, true)
+        a = shiftlb3()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftlb4()
-        txt.print_ubbin(A, true)
+        a = shiftlb4()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftlb5()
-        txt.print_ubbin(A, true)
+        a = shiftlb5()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftlb6()
-        txt.print_ubbin(A, true)
+        a = shiftlb6()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftlb7()
-        txt.print_ubbin(A, true)
+        a = shiftlb7()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftlb8()
-        txt.print_ubbin(A, true)
+        a = shiftlb8()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftlb9()
-        txt.print_ubbin(A, true)
+        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)
+        a = shiftrb0()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftrb1()
-        txt.print_ubbin(A, true)
+        a = shiftrb1()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftrb2()
-        txt.print_ubbin(A, true)
+        a = shiftrb2()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftrb3()
-        txt.print_ubbin(A, true)
+        a = shiftrb3()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftrb4()
-        txt.print_ubbin(A, true)
+        a = shiftrb4()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftrb5()
-        txt.print_ubbin(A, true)
+        a = shiftrb5()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftrb6()
-        txt.print_ubbin(A, true)
+        a = shiftrb6()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftrb7()
-        txt.print_ubbin(A, true)
+        a = shiftrb7()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftrb8()
-        txt.print_ubbin(A, true)
+        a = shiftrb8()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
-        A = shiftrb9()
-        txt.print_ubbin(A, true)
+        a = shiftrb9()
+        txt.print_ubbin(a, true)
         c64.CHROUT('\n')
         txt.print("enter to continue:\n")
         void c64.CHRIN()
@@ -474,10 +474,6 @@ main {
         return (q >> 17)
     }
 
-
-
-
-
     sub shiftrsw0() -> word {
         word q = -12345
         return q >> 0

examples/arithmetic/postincrdecr.p8

@@ -8,7 +8,7 @@ main {
 
         txt.plot(0,24)
 
-        ubyte Y
+        ubyte y
         ubyte ub=200
         byte bb=-100
         uword uw = 2000
@@ -33,9 +33,9 @@ main {
         flarr[1] ++
 
         check_ub(ub, 201)
-        Y=100
-        Y++
-        check_ub(Y, 101)
+        y=100
+        y++
+        check_ub(y, 101)
         check_fl(fl, 1000.99)
         check_b(bb, -99)
         check_uw(uw, 2001)
@@ -64,9 +64,9 @@ main {
         flarr[1] --
         check_ub(ub, 200)
 
-        Y=100
-        Y--
-        check_ub(Y, 99)
+        y=100
+        y--
+        check_ub(y, 99)
         check_fl(fl, 999.99)
         check_b(bb, -100)
         check_uw(uw, 2000)

examples/arithmetic/wordbyte.p8

@@ -6,7 +6,7 @@
 main {
     sub start() {
         repeat 25 {
-            txt.chrout('\n')
+            txt.nl()
         }
 
         ubyte ub
@@ -25,7 +25,7 @@ main {
         else {
             txt.print("1 fail:")
             txt.print_uw(uwsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         wsum  = -30000
@@ -39,7 +39,7 @@ main {
         else {
             txt.print("2 fail:")
             txt.print_w(wsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         uwsum = 50000
@@ -53,7 +53,7 @@ main {
         else {
             txt.print("3 fail:")
             txt.print_uw(uwsum)
-            txt.chrout('\n')
+            txt.nl()
         }
         wsum  = -30000
         bb = 100
@@ -90,7 +90,7 @@ main {
         else {
             txt.print("6 fail:")
             txt.print_uw(uwsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         wsum  = -30000
@@ -104,7 +104,7 @@ main {
         else {
             txt.print("7 fail:")
             txt.print_w(wsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         wsum  = -30000
@@ -118,10 +118,10 @@ main {
         else {
             txt.print("8 fail:")
             txt.print_w(wsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
-        txt.chrout('\n')
+        txt.nl()
 
 
 
@@ -135,7 +135,7 @@ main {
         else {
             txt.print("1b fail:")
             txt.print_uw(uwsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         bb = 0
@@ -148,7 +148,7 @@ main {
         else {
             txt.print("2b fail:")
             txt.print_w(wsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         uwsum = 50000
@@ -160,7 +160,7 @@ main {
         else {
             txt.print("3b fail:")
             txt.print_uw(uwsum)
-            txt.chrout('\n')
+            txt.nl()
         }
         wsum  = -30000
         wsum -= (100+bb)
@@ -190,7 +190,7 @@ main {
         else {
             txt.print("6b fail:")
             txt.print_uw(uwsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         wsum  = -30000
@@ -202,7 +202,7 @@ main {
         else {
             txt.print("7b fail:")
             txt.print_w(wsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         wsum  = -30000
@@ -214,10 +214,10 @@ main {
         else {
             txt.print("8b fail:")
             txt.print_w(wsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
-        txt.chrout('\n')
+        txt.nl()
 
 
 
@@ -230,7 +230,7 @@ main {
         else {
             txt.print("1c fail:")
             txt.print_uw(uwsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         wsum  = -30000
@@ -242,7 +242,7 @@ main {
         else {
             txt.print("2c fail:")
             txt.print_w(wsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         uwsum = 50000
@@ -254,7 +254,7 @@ main {
         else {
             txt.print("3c fail:")
             txt.print_uw(uwsum)
-            txt.chrout('\n')
+            txt.nl()
         }
         wsum  = -30000
         wsum -= 100
@@ -284,7 +284,7 @@ main {
         else {
             txt.print("6c fail:")
             txt.print_uw(uwsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         wsum  = -30000
@@ -296,7 +296,7 @@ main {
         else {
             txt.print("7c fail:")
             txt.print_w(wsum)
-            txt.chrout('\n')
+            txt.nl()
         }
 
         wsum  = -30000
@@ -308,7 +308,7 @@ main {
         else {
             txt.print("8c fail:")
             txt.print_w(wsum)
-            txt.chrout('\n')
+            txt.nl()
         }
     }
 

examples/assembler/gen_opcodes.py

@@ -0,0 +1,496 @@
+from collections import Counter
+from enum import IntEnum
+
+
+class AddrMode(IntEnum):
+    Imp = 1,
+    Acc = 2,
+    Imm = 3,
+    Zp = 4,
+    ZpX = 5,
+    ZpY = 6,
+    Rel = 7,
+    Abs = 8,
+    AbsX = 9,
+    AbsY = 10,
+    Ind = 11,
+    IzX = 12,
+    IzY = 13,
+    Zpr = 14,
+    Izp = 15,
+    IaX = 16
+
+
+AllInstructions = [
+    (0x00, "brk", AddrMode.Imp),
+    (0x01, "ora", AddrMode.IzX),
+    (0x02, "nop", AddrMode.Imm),
+    (0x03, "nop", AddrMode.Imp),
+    (0x04, "tsb", AddrMode.Zp),
+    (0x05, "ora", AddrMode.Zp),
+    (0x06, "asl", AddrMode.Zp),
+    (0x07, "rmb0", AddrMode.Zp),
+    (0x08, "php", AddrMode.Imp),
+    (0x09, "ora", AddrMode.Imm),
+    (0x0a, "asl", AddrMode.Acc),
+    (0x0b, "nop", AddrMode.Imp),
+    (0x0c, "tsb", AddrMode.Abs),
+    (0x0d, "ora", AddrMode.Abs),
+    (0x0e, "asl", AddrMode.Abs),
+    (0x0f, "bbr0", AddrMode.Zpr),
+    (0x10, "bpl", AddrMode.Rel),
+    (0x11, "ora", AddrMode.IzY),
+    (0x12, "ora", AddrMode.Izp),
+    (0x13, "nop", AddrMode.Imp),
+    (0x14, "trb", AddrMode.Zp),
+    (0x15, "ora", AddrMode.ZpX),
+    (0x16, "asl", AddrMode.ZpX),
+    (0x17, "rmb1", AddrMode.Zp),
+    (0x18, "clc", AddrMode.Imp),
+    (0x19, "ora", AddrMode.AbsY),
+    (0x1a, "inc", AddrMode.Acc),
+    (0x1b, "nop", AddrMode.Imp),
+    (0x1c, "trb", AddrMode.Abs),
+    (0x1d, "ora", AddrMode.AbsX),
+    (0x1e, "asl", AddrMode.AbsX),
+    (0x1f, "bbr1", AddrMode.Zpr),
+    (0x20, "jsr", AddrMode.Abs),
+    (0x21, "and", AddrMode.IzX),
+    (0x22, "nop", AddrMode.Imm),
+    (0x23, "nop", AddrMode.Imp),
+    (0x24, "bit", AddrMode.Zp),
+    (0x25, "and", AddrMode.Zp),
+    (0x26, "rol", AddrMode.Zp),
+    (0x27, "rmb2", AddrMode.Zp),
+    (0x28, "plp", AddrMode.Imp),
+    (0x29, "and", AddrMode.Imm),
+    (0x2a, "rol", AddrMode.Acc),
+    (0x2b, "nop", AddrMode.Imp),
+    (0x2c, "bit", AddrMode.Abs),
+    (0x2d, "and", AddrMode.Abs),
+    (0x2e, "rol", AddrMode.Abs),
+    (0x2f, "bbr2", AddrMode.Zpr),
+    (0x30, "bmi", AddrMode.Rel),
+    (0x31, "and", AddrMode.IzY),
+    (0x32, "and", AddrMode.Izp),
+    (0x33, "nop", AddrMode.Imp),
+    (0x34, "bit", AddrMode.ZpX),
+    (0x35, "and", AddrMode.ZpX),
+    (0x36, "rol", AddrMode.ZpX),
+    (0x37, "rmb3", AddrMode.Zp),
+    (0x38, "sec", AddrMode.Imp),
+    (0x39, "and", AddrMode.AbsY),
+    (0x3a, "dec", AddrMode.Acc),
+    (0x3b, "nop", AddrMode.Imp),
+    (0x3c, "bit", AddrMode.AbsX),
+    (0x3d, "and", AddrMode.AbsX),
+    (0x3e, "rol", AddrMode.AbsX),
+    (0x3f, "bbr3", AddrMode.Zpr),
+    (0x40, "rti", AddrMode.Imp),
+    (0x41, "eor", AddrMode.IzX),
+    (0x42, "nop", AddrMode.Imm),
+    (0x43, "nop", AddrMode.Imp),
+    (0x44, "nop", AddrMode.Zp),
+    (0x45, "eor", AddrMode.Zp),
+    (0x46, "lsr", AddrMode.Zp),
+    (0x47, "rmb4", AddrMode.Zp),
+    (0x48, "pha", AddrMode.Imp),
+    (0x49, "eor", AddrMode.Imm),
+    (0x4a, "lsr", AddrMode.Acc),
+    (0x4b, "nop", AddrMode.Imp),
+    (0x4c, "jmp", AddrMode.Abs),
+    (0x4d, "eor", AddrMode.Abs),
+    (0x4e, "lsr", AddrMode.Abs),
+    (0x4f, "bbr4", AddrMode.Zpr),
+    (0x50, "bvc", AddrMode.Rel),
+    (0x51, "eor", AddrMode.IzY),
+    (0x52, "eor", AddrMode.Izp),
+    (0x53, "nop", AddrMode.Imp),
+    (0x54, "nop", AddrMode.ZpX),
+    (0x55, "eor", AddrMode.ZpX),
+    (0x56, "lsr", AddrMode.ZpX),
+    (0x57, "rmb5", AddrMode.Zp),
+    (0x58, "cli", AddrMode.Imp),
+    (0x59, "eor", AddrMode.AbsY),
+    (0x5a, "phy", AddrMode.Imp),
+    (0x5b, "nop", AddrMode.Imp),
+    (0x5c, "nop", AddrMode.Abs),
+    (0x5d, "eor", AddrMode.AbsX),
+    (0x5e, "lsr", AddrMode.AbsX),
+    (0x5f, "bbr5", AddrMode.Zpr),
+    (0x60, "rts", AddrMode.Imp),
+    (0x61, "adc", AddrMode.IzX),
+    (0x62, "nop", AddrMode.Imm),
+    (0x63, "nop", AddrMode.Imp),
+    (0x64, "stz", AddrMode.Zp),
+    (0x65, "adc", AddrMode.Zp),
+    (0x66, "ror", AddrMode.Zp),
+    (0x67, "rmb6", AddrMode.Zp),
+    (0x68, "pla", AddrMode.Imp),
+    (0x69, "adc", AddrMode.Imm),
+    (0x6a, "ror", AddrMode.Acc),
+    (0x6b, "nop", AddrMode.Imp),
+    (0x6c, "jmp", AddrMode.Ind),
+    (0x6d, "adc", AddrMode.Abs),
+    (0x6e, "ror", AddrMode.Abs),
+    (0x6f, "bbr6", AddrMode.Zpr),
+    (0x70, "bvs", AddrMode.Rel),
+    (0x71, "adc", AddrMode.IzY),
+    (0x72, "adc", AddrMode.Izp),
+    (0x73, "nop", AddrMode.Imp),
+    (0x74, "stz", AddrMode.ZpX),
+    (0x75, "adc", AddrMode.ZpX),
+    (0x76, "ror", AddrMode.ZpX),
+    (0x77, "rmb7", AddrMode.Zp),
+    (0x78, "sei", AddrMode.Imp),
+    (0x79, "adc", AddrMode.AbsY),
+    (0x7a, "ply", AddrMode.Imp),
+    (0x7b, "nop", AddrMode.Imp),
+    (0x7c, "jmp", AddrMode.IaX),
+    (0x7d, "adc", AddrMode.AbsX),
+    (0x7e, "ror", AddrMode.AbsX),
+    (0x7f, "bbr7", AddrMode.Zpr),
+    (0x80, "bra", AddrMode.Rel),
+    (0x81, "sta", AddrMode.IzX),
+    (0x82, "nop", AddrMode.Imm),
+    (0x83, "nop", AddrMode.Imp),
+    (0x84, "sty", AddrMode.Zp),
+    (0x85, "sta", AddrMode.Zp),
+    (0x86, "stx", AddrMode.Zp),
+    (0x87, "smb0", AddrMode.Zp),
+    (0x88, "dey", AddrMode.Imp),
+    (0x89, "bit", AddrMode.Imm),
+    (0x8a, "txa", AddrMode.Imp),
+    (0x8b, "nop", AddrMode.Imp),
+    (0x8c, "sty", AddrMode.Abs),
+    (0x8d, "sta", AddrMode.Abs),
+    (0x8e, "stx", AddrMode.Abs),
+    (0x8f, "bbs0", AddrMode.Zpr),
+    (0x90, "bcc", AddrMode.Rel),
+    (0x91, "sta", AddrMode.IzY),
+    (0x92, "sta", AddrMode.Izp),
+    (0x93, "nop", AddrMode.Imp),
+    (0x94, "sty", AddrMode.ZpX),
+    (0x95, "sta", AddrMode.ZpX),
+    (0x96, "stx", AddrMode.ZpY),
+    (0x97, "smb1", AddrMode.Zp),
+    (0x98, "tya", AddrMode.Imp),
+    (0x99, "sta", AddrMode.AbsY),
+    (0x9a, "txs", AddrMode.Imp),
+    (0x9b, "nop", AddrMode.Imp),
+    (0x9c, "stz", AddrMode.Abs),
+    (0x9d, "sta", AddrMode.AbsX),
+    (0x9e, "stz", AddrMode.AbsX),
+    (0x9f, "bbs1", AddrMode.Zpr),
+    (0xa0, "ldy", AddrMode.Imm),
+    (0xa1, "lda", AddrMode.IzX),
+    (0xa2, "ldx", AddrMode.Imm),
+    (0xa3, "nop", AddrMode.Imp),
+    (0xa4, "ldy", AddrMode.Zp),
+    (0xa5, "lda", AddrMode.Zp),
+    (0xa6, "ldx", AddrMode.Zp),
+    (0xa7, "smb2", AddrMode.Zp),
+    (0xa8, "tay", AddrMode.Imp),
+    (0xa9, "lda", AddrMode.Imm),
+    (0xaa, "tax", AddrMode.Imp),
+    (0xab, "nop", AddrMode.Imp),
+    (0xac, "ldy", AddrMode.Abs),
+    (0xad, "lda", AddrMode.Abs),
+    (0xae, "ldx", AddrMode.Abs),
+    (0xaf, "bbs2", AddrMode.Zpr),
+    (0xb0, "bcs", AddrMode.Rel),
+    (0xb1, "lda", AddrMode.IzY),
+    (0xb2, "lda", AddrMode.Izp),
+    (0xb3, "nop", AddrMode.Imp),
+    (0xb4, "ldy", AddrMode.ZpX),
+    (0xb5, "lda", AddrMode.ZpX),
+    (0xb6, "ldx", AddrMode.ZpY),
+    (0xb7, "smb3", AddrMode.Zp),
+    (0xb8, "clv", AddrMode.Imp),
+    (0xb9, "lda", AddrMode.AbsY),
+    (0xba, "tsx", AddrMode.Imp),
+    (0xbb, "nop", AddrMode.Imp),
+    (0xbc, "ldy", AddrMode.AbsX),
+    (0xbd, "lda", AddrMode.AbsX),
+    (0xbe, "ldx", AddrMode.AbsY),
+    (0xbf, "bbs3", AddrMode.Zpr),
+    (0xc0, "cpy", AddrMode.Imm),
+    (0xc1, "cmp", AddrMode.IzX),
+    (0xc2, "nop", AddrMode.Imm),
+    (0xc3, "nop", AddrMode.Imp),
+    (0xc4, "cpy", AddrMode.Zp),
+    (0xc5, "cmp", AddrMode.Zp),
+    (0xc6, "dec", AddrMode.Zp),
+    (0xc7, "smb4", AddrMode.Zp),
+    (0xc8, "iny", AddrMode.Imp),
+    (0xc9, "cmp", AddrMode.Imm),
+    (0xca, "dex", AddrMode.Imp),
+    (0xcb, "wai", AddrMode.Imp),
+    (0xcc, "cpy", AddrMode.Abs),
+    (0xcd, "cmp", AddrMode.Abs),
+    (0xce, "dec", AddrMode.Abs),
+    (0xcf, "bbs4", AddrMode.Zpr),
+    (0xd0, "bne", AddrMode.Rel),
+    (0xd1, "cmp", AddrMode.IzY),
+    (0xd2, "cmp", AddrMode.Izp),
+    (0xd3, "nop", AddrMode.Imp),
+    (0xd4, "nop", AddrMode.ZpX),
+    (0xd5, "cmp", AddrMode.ZpX),
+    (0xd6, "dec", AddrMode.ZpX),
+    (0xd7, "smb5", AddrMode.Zp),
+    (0xd8, "cld", AddrMode.Imp),
+    (0xd9, "cmp", AddrMode.AbsY),
+    (0xda, "phx", AddrMode.Imp),
+    (0xdb, "stp", AddrMode.Imp),
+    (0xdc, "nop", AddrMode.Abs),
+    (0xdd, "cmp", AddrMode.AbsX),
+    (0xde, "dec", AddrMode.AbsX),
+    (0xdf, "bbs5", AddrMode.Zpr),
+    (0xe0, "cpx", AddrMode.Imm),
+    (0xe1, "sbc", AddrMode.IzX),
+    (0xe2, "nop", AddrMode.Imm),
+    (0xe3, "nop", AddrMode.Imp),
+    (0xe4, "cpx", AddrMode.Zp),
+    (0xe5, "sbc", AddrMode.Zp),
+    (0xe6, "inc", AddrMode.Zp),
+    (0xe7, "smb6", AddrMode.Zp),
+    (0xe8, "inx", AddrMode.Imp),
+    (0xe9, "sbc", AddrMode.Imm),
+    (0xea, "nop", AddrMode.Imp),
+    (0xeb, "nop", AddrMode.Imp),
+    (0xec, "cpx", AddrMode.Abs),
+    (0xed, "sbc", AddrMode.Abs),
+    (0xee, "inc", AddrMode.Abs),
+    (0xef, "bbs6", AddrMode.Zpr),
+    (0xf0, "beq", AddrMode.Rel),
+    (0xf1, "sbc", AddrMode.IzY),
+    (0xf2, "sbc", AddrMode.Izp),
+    (0xf3, "nop", AddrMode.Imp),
+    (0xf4, "nop", AddrMode.ZpX),
+    (0xf5, "sbc", AddrMode.ZpX),
+    (0xf6, "inc", AddrMode.ZpX),
+    (0xf7, "smb7", AddrMode.Zp),
+    (0xf8, "sed", AddrMode.Imp),
+    (0xf9, "sbc", AddrMode.AbsY),
+    (0xfa, "plx", AddrMode.Imp),
+    (0xfb, "nop", AddrMode.Imp),
+    (0xfc, "nop", AddrMode.AbsX),
+    (0xfd, "sbc", AddrMode.AbsX),
+    (0xfe, "inc", AddrMode.AbsX),
+    (0xff, "bbs7", AddrMode.Zpr)
+]
+
+# NOP is weird, it is all over the place.
+# For the 'common' immediate NOP, keep only the $EA opcode (this was the original NOP on the 6502)
+Instructions = [ins for ins in AllInstructions if ins[1] != "nop"] + [(0xea, "nop", AddrMode.Imp)]
+
+
+InstructionsByName = {}
+for ins in Instructions:
+    if ins[1] not in InstructionsByName:
+        InstructionsByName[ins[1]] = {ins[2]: ins[0]}
+    else:
+        InstructionsByName[ins[1]][ins[2]] = ins[0]
+
+InstructionsByMode = {}
+for ins in Instructions:
+    if ins[2] not in InstructionsByMode:
+        InstructionsByMode[ins[2]] = [(ins[1], ins[0])]
+    else:
+        InstructionsByMode[ins[2]].append((ins[1], ins[0]))
+
+# build the name->modes table
+
+print("; generated by opcodes.py")
+print("; addressing modes:")
+for mode in AddrMode:
+    print(";", mode.value, "=", mode.name)
+print()
+
+print("""
+    .enc "petscii"  ;define an ascii to petscii encoding
+    .cdef " @", 32  ;characters
+    .cdef "AZ", $c1
+    .cdef "az", $41
+    .cdef "[[", $5b
+    .cdef "]]", $5d
+    .edef "<nothing>", [];replace with no bytes
+""")
+
+for instr in sorted(InstructionsByName.items()):
+    print("i_" + instr[0] + ":\n\t.byte  ", end="")
+    if len(instr[1]) == 1:
+        # many instructions have just 1 addressing mode, save space for those
+        info = instr[1].popitem()
+        print("1,", info[0].value,",", info[1])
+    else:
+        print("0, ", end='')
+        mode_opcodes = []
+        for mode in AddrMode:
+            if mode in instr[1]:
+                mode_opcodes.append(instr[1][mode])
+            else:
+                mode_opcodes.append(0)
+        print(",".join(str(o) for o in mode_opcodes), end="")
+        print()
+
+
+def determine_mnemonics():
+    mnemonics = list(sorted(set(ins[1] for ins in Instructions)))
+
+    # opcodes histogram (ordered by occurrence)  (in kernal + basic roms of the c64):
+    opcode_occurrences = [
+        (32, 839), (133, 502), (165, 488), (0, 429), (208, 426), (169, 390), (76, 324), (240, 322), (2, 314), (160, 245),
+        (96, 228), (3, 201), (1, 191), (255, 186), (144, 182), (170, 175), (162, 169), (177, 165), (104, 159), (164, 158),
+        (132, 157), (201, 156), (72, 151), (141, 150), (200, 146), (173, 144), (166, 139), (176, 139), (16, 138),
+        (134, 138), (73, 127), (24, 119), (101, 113), (69, 109), (13, 107), (34, 104), (145, 103), (4, 102), (168, 101),
+        (221, 98), (230, 93), (48, 91), (189, 87), (41, 86), (6, 86), (9, 86), (8, 85), (79, 85), (138, 80), (10, 80),
+        (7, 79), (185, 77), (56, 75), (44, 75), (78, 74), (105, 73), (5, 73), (174, 73), (220, 71), (198, 69), (232, 69),
+        (36, 69), (202, 67), (152, 67), (95, 67), (100, 65), (102, 65), (247, 65), (188, 64), (136, 64), (84, 64),
+        (122, 62), (128, 61), (80, 61), (186, 60), (82, 59), (97, 58), (15, 57), (70, 57), (229, 56), (19, 55), (40, 54),
+        (183, 54), (65, 54), (233, 53), (180, 53), (12, 53), (171, 53), (197, 53), (83, 52), (248, 52), (112, 51),
+        (237, 51), (89, 50), (11, 50), (158, 50), (74, 49), (224, 48), (20, 47), (238, 47), (108, 46), (234, 46),
+        (251, 46), (254, 46), (184, 45), (14, 44), (163, 44), (226, 43), (211, 43), (88, 43), (98, 42), (17, 42),
+        (153, 42), (243, 41), (228, 41), (99, 41), (253, 41), (209, 41), (187, 39), (123, 39), (67, 39), (196, 38),
+        (68, 38), (35, 38), (172, 38), (175, 38), (161, 38), (85, 38), (191, 37), (113, 37), (182, 37), (151, 37),
+        (71, 36), (181, 35), (214, 35), (121, 35), (157, 35), (178, 35), (77, 35), (42, 34), (212, 33), (18, 33),
+        (127, 33), (241, 33), (21, 33), (249, 32), (23, 31), (245, 30), (142, 30), (55, 29), (140, 29), (46, 29),
+        (192, 29), (179, 29), (252, 29), (115, 29), (22, 29), (43, 28), (215, 28), (45, 28), (246, 28), (38, 28),
+        (86, 27), (225, 27), (25, 26), (239, 26), (58, 26), (167, 26), (147, 26), (217, 26), (149, 25), (30, 25),
+        (206, 25), (28, 24), (47, 24), (37, 24), (155, 24), (129, 23), (148, 23), (111, 23), (29, 23), (39, 23),
+        (51, 22), (193, 22), (236, 22), (120, 22), (64, 22), (204, 21), (210, 21), (244, 21), (52, 21), (66, 21),
+        (114, 20), (250, 20), (106, 20), (93, 19), (199, 19), (218, 19), (154, 19), (205, 19), (50, 19), (159, 19),
+        (194, 19), (49, 19), (190, 19), (103, 18), (216, 18), (213, 18), (107, 18), (131, 18), (63, 18), (94, 18),
+        (91, 17), (242, 17), (109, 17), (53, 16), (227, 16), (139, 16), (31, 16), (75, 16), (60, 16), (195, 15),
+        (231, 15), (62, 15), (59, 15), (87, 14), (207, 14), (27, 14), (90, 14), (110, 13), (223, 13), (57, 13),
+        (118, 12), (26, 12), (203, 12), (81, 12), (156, 12), (54, 12), (235, 12), (146, 11), (135, 11), (126, 11),
+        (150, 11), (130, 11), (143, 10), (61, 10), (219, 10), (124, 9), (222, 9), (125, 9), (119, 7), (137, 7),
+        (33, 7), (117, 5), (92, 4), (116, 3)
+    ]
+
+    cnt = Counter()
+    for opcode, amount in opcode_occurrences:
+        cnt[AllInstructions[opcode][1]] += amount
+    cnt["nop"] = 13
+    cnt["tsb"] = 13
+
+    four_letter_mnemonics = list(sorted([ins[1] for ins in AllInstructions if len(ins[1])>3]))
+    for ins4 in four_letter_mnemonics:
+        del cnt[ins4]
+        cnt[ins4] = 1
+    mnem2 = [c[0] for c in cnt.most_common()]
+    if len(mnem2)!=len(mnemonics):
+        raise ValueError("mnem count mismatch")
+    return mnem2
+
+
+mnemonics = determine_mnemonics()
+
+
+def first_letters():
+    firstletters = {m[0]: 0 for m in mnemonics}
+    return firstletters.keys()
+
+
+def second_letters(firstletter):
+    secondletters = {m[1]: 0 for m in mnemonics if m[0] == firstletter}
+    return secondletters.keys()
+
+
+def third_letters(firstletter, secondletter):
+    thirdletters = {m[2]: 0 for m in mnemonics if m[0] == firstletter and m[1] == secondletter}
+    return thirdletters.keys()
+
+
+def fourth_letters(firstletter, secondletter, thirdletter):
+    longmnem = [m for m in mnemonics if len(m) > 3]
+    fourthletters = {m[3]: 0 for m in longmnem if m[0] == firstletter and m[1] == secondletter and m[2] == thirdletter}
+    return fourthletters.keys()
+
+
+def make_tree():
+    tree = {}
+    for first in first_letters():
+        tree[first] = {
+            secondletter: {
+                thirdletter: {
+                    fourthletter: {}
+                    for fourthletter in fourth_letters(first, secondletter, thirdletter)
+                }
+                for thirdletter in third_letters(first, secondletter)
+            }
+            for secondletter in second_letters(first)
+        }
+    return tree
+
+
+tree = make_tree()
+
+
+print("get_opcode_info    .proc")
+print("_mnem_fourth_letter = cx16.r4")
+print("_mnem_fifth_letter = cx16.r5")
+for first in tree:
+    print("    cmp  #'%s'" % first)
+    print("    bne  _not_%s" % first)
+    for second in tree[first]:
+        print("    cpx  #'%s'" % second)
+        print("    bne  _not_%s%s" % (first,second))
+        for third in tree[first][second]:
+            print("    cpy  #'%s'" % third)
+            print("    bne  _not_%s%s%s" % (first, second, third))
+            fourth = tree[first][second][third]
+            if fourth:
+                if "".join(fourth.keys()) != "01234567":
+                    raise ValueError("fourth", fourth.keys())
+                print("    bra  _check_%s%s%s" % (first, second, third))
+            else:
+                print("    lda  _mnem_fourth_letter")   # check that the fourth letter is not present
+                print("    bne  _invalid")
+                print("    lda  #<i_%s%s%s" % (first, second, third))
+                print("    ldy  #>i_%s%s%s" % (first, second, third))
+                print("    rts")
+            print("_not_%s%s%s:" % (first, second, third))
+        print("_not_%s%s:" % (first, second))
+    print("_not_%s:" % first)
+print("_invalid:")
+print("    lda  #0")
+print("    ldy  #0")
+print("    rts")
+
+# the 4-letter mnemonics are:
+# smb[0-7]
+# bbr[0-7]
+# rmb[0-7]
+# bbs[0-7]
+for fourlettermnemonic in ["smb", "bbr", "rmb", "bbs"]:
+    print("_check_%s" % fourlettermnemonic)
+    print("    lda  #<_tab_%s" % fourlettermnemonic)
+    print("    ldy  #>_tab_%s" % fourlettermnemonic)
+    print("""    sta  P8ZP_SCRATCH_W2
+    sty  P8ZP_SCRATCH_W2+1    
+    bra  _check4""")
+
+print("""_check4
+    lda  _mnem_fourth_letter
+    cmp  #'0'
+    bcc  _invalid
+    cmp  #'8'
+    bcs  _invalid
+    lda  _mnem_fifth_letter     ; must have no fifth letter
+    bne  _invalid
+    tay
+    lda  (P8ZP_SCRATCH_W2),y
+    pha
+    iny
+    lda  (P8ZP_SCRATCH_W2),y
+    tay
+    pla
+    rts""")
+
+for fourlettermnemonic in ["smb", "bbr", "rmb", "bbs"]:
+    print("_tab_%s" % fourlettermnemonic)
+    for ii in "01234567":
+        print("    .word   i_%s%s" % (fourlettermnemonic, ii))
+
+print("    .pend")