version 5.2

.idea/misc.xml

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

README.md

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

compiler/build.gradle

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

compiler/res/prog8lib/c64/floats.asm

@@ -89,17 +89,27 @@ cast_from_b	.proc
 
 cast_as_uw_into_ya	.proc               ; also used for float 2 ub
 		; -- cast float at A/Y to uword into Y/A
-		stx  P8ZP_SCRATCH_REG
 		jsr  MOVFM
+		jmp  cast_FAC1_as_uw_into_ya
+		.pend
+
+cast_as_w_into_ay	.proc               ; also used for float 2 b
+		; -- cast float at A/Y to word into A/Y
+		jsr  MOVFM
+		jmp  cast_FAC1_as_w_into_ay
+		.pend
+
+cast_FAC1_as_uw_into_ya	.proc               ; also used for float 2 ub
+		; -- cast fac1 to uword into Y/A
+		stx  P8ZP_SCRATCH_REG
 		jsr  GETADR     ; into Y/A
 		ldx  P8ZP_SCRATCH_REG
 		rts
 		.pend
 
-cast_as_w_into_ay	.proc               ; also used for float 2 b
-		; -- cast float at A/Y to word into A/Y
+cast_FAC1_as_w_into_ay	.proc               ; also used for float 2 b
+		; -- cast fac1 to word into A/Y
 		stx  P8ZP_SCRATCH_REG
-		jsr  MOVFM
 		jsr  AYINT
 		ldy  $64
 		lda  $65
@@ -380,6 +390,69 @@ neg_f		.proc
 		rts
 		.pend
 
+var_fac1_less_f	.proc
+		; -- is the float in FAC1 < the variable AY?
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		cmp  #255
+		beq  +
+		lda  #0
+		rts
++		lda  #1
+		rts
+		.pend
+
+var_fac1_lesseq_f	.proc
+		; -- is the float in FAC1 <= the variable AY?
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		cmp  #0
+		beq  +
+		cmp  #255
+		beq  +
+		lda  #0
+		rts
++		lda  #1
+		rts
+		.pend
+
+var_fac1_greater_f	.proc
+		; -- is the float in FAC1 > the variable AY?
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		cmp  #1
+		beq  +
+		lda  #0
++		rts
+		.pend
+
+var_fac1_greatereq_f	.proc
+		; -- is the float in FAC1 >= the variable AY?
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		cmp  #0
+		beq  +
+		cmp  #1
+		beq  +
+		lda  #0
+		rts
++		lda  #1
+		rts
+		.pend
+
+var_fac1_notequal_f	.proc
+		; -- are the floats numbers in FAC1 and the variable AY *not* identical?
+		stx  P8ZP_SCRATCH_REG
+		jsr  FCOMP
+		ldx  P8ZP_SCRATCH_REG
+		and  #1
+		rts
+		.pend
+
 vars_equal_f	.proc
 		; -- are the mflpt5 numbers in P8ZP_SCRATCH_W1 and AY identical?
 		sta  P8ZP_SCRATCH_W2

compiler/res/prog8lib/c64/graphics.p8

@@ -12,7 +12,7 @@ graphics {
 
     sub enable_bitmap_mode() {
         ; enable bitmap screen, erase it and set colors to black/white.
-        c64.SCROLY = %00111000
+        c64.SCROLY = %00111011
         c64.SCROLX = %00001000
         c64.VMCSB = (c64.VMCSB & %11110000) | %00001000   ; $2000-$3fff
         clear_screen(1, 0)
@@ -20,7 +20,7 @@ graphics {
 
     sub disable_bitmap_mode() {
         ; enables text mode, erase the text screen, color white
-        c64.SCROLY = %00011000
+        c64.SCROLY = %00011011
         c64.SCROLX = %00001000
         c64.VMCSB = (c64.VMCSB & %11110000) | %00000100   ; $1000-$2fff
         txt.fill_screen(' ', 1)

compiler/res/prog8lib/prog8_lib.asm

@@ -470,27 +470,19 @@ less_uw		.proc
 
 reg_less_w	.proc
 		; -- AY < P8ZP_SCRATCH_W2?
-		sta  P8ZP_SCRATCH_B1
+		cmp  P8ZP_SCRATCH_W2
 		tya
-		sec
 		sbc  P8ZP_SCRATCH_W2+1
 		bvc  +
 		eor  #$80
 +		bmi  _true
-		bvc  +
-		eor  #$80
-+		bne  _false
-		lda  P8ZP_SCRATCH_B1
-		sbc  P8ZP_SCRATCH_W2
-		bcs  _false
-_true		lda  #1
+		lda  #0
 		rts
-_false		lda  #0
+_true		lda  #1
 		rts
 		.pend
 
 less_w		.proc
-		; TODO is this word comparison < correct? reg_less_w is a lot larger...
 		lda  P8ESTACK_LO+2,x
 		cmp  P8ESTACK_LO+1,x
 		lda  P8ESTACK_HI+2,x
@@ -549,7 +541,6 @@ _true		lda  #1
 		.pend
 
 lesseq_uw	.proc
-		; TODO is this comparison uword <= correct????
 		lda  P8ESTACK_HI+1,x
 		cmp  P8ESTACK_HI+2,x
 		bcc  equal_b._equal_b_false
@@ -561,29 +552,20 @@ lesseq_uw	.proc
 		.pend
 
 reg_lesseq_w	.proc
-		; -- AY <= P8ZP_SCRATCH_W2?
-		sta  P8ZP_SCRATCH_B1
+		; -- P8ZP_SCRATCH_W2 <= AY ?   (note: order different from other routines)
+		cmp  P8ZP_SCRATCH_W2
 		tya
-		sec
 		sbc  P8ZP_SCRATCH_W2+1
 		bvc  +
 		eor  #$80
-+		bmi  _true
-		bvc  +
-		eor  #$80
-+		bne  _false
-		lda  P8ZP_SCRATCH_B1
-		sbc  P8ZP_SCRATCH_W2
-		beq  _true			; TODO is this correct word compare <= for all cases?
-		bcs  _false
-_true		lda  #1
++		bpl  +
+		lda  #0
 		rts
-_false		lda  #0
++		lda  #1
 		rts
 		.pend
 
 lesseq_w	.proc
-		; TODO is this word compare <= correct? it is different from reg_lesseq_w
 		lda  P8ESTACK_LO+1,x
 		cmp  P8ESTACK_LO+2,x
 		lda  P8ESTACK_HI+1,x
@@ -671,8 +653,8 @@ greatereq_w	.proc
 		sbc  P8ESTACK_HI+1,x
 		bvc  +
 		eor  #$80
-+		bpl  equal_b._equal_b_true
-		bmi  equal_b._equal_b_false
++		bmi  equal_b._equal_b_false
+		bpl  equal_b._equal_b_true
 		.pend
 
 
@@ -1065,3 +1047,28 @@ _return_minusone
             lda  #-1
             rts
             .pend
+
+
+sign_extend_stack_byte	.proc
+	; -- sign extend the (signed) byte on the stack to full 16 bits
+		lda  P8ESTACK_LO+1,x
+		ora  #$7f
+		bmi  +
+		lda  #0
++		sta  P8ESTACK_HI+1,x
+		rts
+		.pend
+
+
+sign_extend_AY_byte	.proc
+	; -- sign extend the (signed) byte in AY to full 16 bits
+		pha
+		and  #$80
+		beq  +
+		ldy  #$ff
+		pla
+		rts
++		ldy  #0
+		pla
+		rts
+		.pend

compiler/res/version.txt

@@ -1 +1 @@
-5.1
+5.2

compiler/src/prog8/ast/AstToplevel.kt

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

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

@@ -80,7 +80,9 @@ enum class RegisterOrPair {
     Y,
     AX,
     AY,
-    XY;
+    XY,
+    FAC1,
+    FAC2;
 
     companion object {
         val names by lazy { values().map { it.toString()} }

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

@@ -288,6 +288,7 @@ internal class AstChecker(private val program: Program,
                             regCounts[CpuRegister.X]=regCounts.getValue(CpuRegister.X)+1
                             regCounts[CpuRegister.Y]=regCounts.getValue(CpuRegister.Y)+1
                         }
+                        RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> { /* no sensible way to count this */ }
                         null ->
                             if(p.statusflag!=null)
                                 statusflagCounts[p.statusflag] = statusflagCounts.getValue(p.statusflag) + 1

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

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

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

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

compiler/src/prog8/compiler/BeforeAsmGenerationAstChanger.kt

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

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

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

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

@@ -8,6 +8,7 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.compiler.*
+import prog8.compiler.target.*
 import prog8.compiler.target.CompilationTarget
 import prog8.compiler.target.CpuType
 import prog8.compiler.target.IAssemblyGenerator
@@ -799,8 +800,10 @@ internal class AsmGen(private val program: Program,
                 out("_prog8_regsaveX     .byte  0")
             if(sub.asmGenInfo.usedRegsaveY)
                 out("_prog8_regsaveY     .byte  0")
-            if(sub.asmGenInfo.usedFloatEvalResultVar)
-                out("_prog8_float_eval_result    .byte 0,0,0,0,0")
+            if(sub.asmGenInfo.usedFloatEvalResultVar1)
+                out("$subroutineFloatEvalResultVar1    .byte 0,0,0,0,0")
+            if(sub.asmGenInfo.usedFloatEvalResultVar2)
+                out("$subroutineFloatEvalResultVar2    .byte 0,0,0,0,0")
             vardecls2asm(sub.statements)
             out("  .pend\n")
         }
@@ -1174,18 +1177,7 @@ $label              nop""")
                 }
                 DataType.FLOAT -> {
                     // return the float value via FAC1
-                    when (returnvalue) {
-                        is NumericLiteralValue -> throw AssemblyError("float literal should have been changed to auto var")
-                        is IdentifierReference -> {
-                            val asmVar = asmVariableName(returnvalue)
-                            out("  lda  #<${asmVar} |  ldy  #>${asmVar} |  jsr  floats.MOVFM")
-                        }
-                        else -> {
-                            // todo evaluate directly into fac1 instead of via stack intermediate  (add RegisterOrPair.FAC1/FAC2 ??)
-                            translateExpression(returnvalue)
-                            out("  jsr  floats.pop_float_fac1")
-                        }
-                    }
+                    assignExpressionToRegister(returnvalue, RegisterOrPair.FAC1)
                 }
                 else -> {
                     // all else take its address and assign that also to AY register pair
@@ -1202,33 +1194,33 @@ $label              nop""")
         assemblyLines.add(assembly)
     }
 
-    internal fun signExtendStackLsb(valueDt: DataType) {
-        // sign extend signed byte on stack to signed word
+    internal fun signExtendAYlsb(valueDt: DataType) {
+        // sign extend signed byte in A to full word in AY
         when(valueDt) {
-            DataType.UBYTE -> {
-                out("  lda  #0 |  sta  P8ESTACK_HI+1,x")
-            }
-            DataType.BYTE -> {
-                out("""
-                    lda  P8ESTACK_LO+1,x
-                    ora  #$7f
-                    bmi  +
-                    lda  #0
-+                   sta  P8ESTACK_HI+1,x""")
-            }
+            DataType.UBYTE -> out("  ldy  #0")
+            DataType.BYTE -> out("  jsr  prog8_lib.sign_extend_AY_byte")
+            else -> throw AssemblyError("need byte type")
+        }
+    }
+
+    internal fun signExtendStackLsb(valueDt: DataType) {
+        // sign extend signed byte on stack to signed word on stack
+        when(valueDt) {
+            DataType.UBYTE -> out("  lda  #0 |  sta  P8ESTACK_HI+1,x")
+            DataType.BYTE -> out("  jsr  prog8_lib.sign_extend_stack_byte")
             else -> throw AssemblyError("need byte type")
         }
     }
 
     internal fun signExtendVariableLsb(asmvar: String, valueDt: DataType) {
-        // sign extend signed byte in a word variable
+        // sign extend signed byte in a var to a full word in that variable
         when(valueDt) {
             DataType.UBYTE -> {
                 out("  lda  #0 |  sta  $asmvar+1")
             }
             DataType.BYTE -> {
                 out("""
-                    lda  $asmvar+1
+                    lda  $asmvar
                     ora  #$7f
                     bmi  +
                     lda  #0

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

@@ -17,6 +17,7 @@ import prog8.compiler.target.c64.codegen.assignment.AsmAssignTarget
 import prog8.compiler.target.c64.codegen.assignment.AsmAssignment
 import prog8.compiler.target.c64.codegen.assignment.SourceStorageKind
 import prog8.compiler.target.c64.codegen.assignment.TargetStorageKind
+import prog8.compiler.target.subroutineFloatEvalResultVar2
 import prog8.compiler.toHex
 import prog8.functions.FSignature
 
@@ -1032,8 +1033,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     throw AssemblyError("float literals should have been converted into autovar")
                 }
                 else -> {
-                    scope.asmGenInfo.usedFloatEvalResultVar = true
-                    val variable = IdentifierReference(listOf("_prog8_float_eval_result"), value.position)
+                    scope.asmGenInfo.usedFloatEvalResultVar2 = true
+                    val variable = IdentifierReference(listOf(subroutineFloatEvalResultVar2), value.position)
                     val addr = AddressOf(variable, value.position)
                     addr.linkParents(value)
                     asmgen.assignExpressionToVariable(value, asmgen.asmVariableName(variable), DataType.FLOAT, scope)

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

@@ -9,6 +9,7 @@ import prog8.ast.statements.Subroutine
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.CompilationTarget
 import prog8.compiler.target.CpuType
+import prog8.compiler.target.subroutineFloatEvalResultVar1
 import prog8.compiler.toHex
 import prog8.functions.BuiltinFunctions
 import kotlin.math.absoluteValue
@@ -215,11 +216,15 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 jsr  floats.vars_less_f
                 beq  $jumpIfFalseLabel""")
         } else {
-            if (asmgen.options.slowCodegenWarnings)
-                println("warning: slow stack evaluation used (e1): '<' at ${left.position}") // TODO float via func args?
-            translateExpression(left)
-            translateExpression(right)
-            asmgen.out("  jsr  floats.less_f |  inx |  lda  P8ESTACK_LO,x |  beq  $jumpIfFalseLabel")
+            val subroutine = left.definingSubroutine()!!
+            subroutine.asmGenInfo.usedFloatEvalResultVar1 = true
+            asmgen.assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
+            asmgen.assignExpressionToRegister(left, RegisterOrPair.FAC1)
+            asmgen.out("""
+                lda  #<$subroutineFloatEvalResultVar1
+                ldy  #>$subroutineFloatEvalResultVar1
+                jsr  floats.var_fac1_less_f
+                beq  $jumpIfFalseLabel""")
         }
     }
 
@@ -256,11 +261,15 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 jsr  floats.vars_lesseq_f
                 beq  $jumpIfFalseLabel""")
         } else {
-            if (asmgen.options.slowCodegenWarnings)
-                println("warning: slow stack evaluation used (e1): '<=' at ${left.position}") // TODO float via func args?
-            translateExpression(left)
-            translateExpression(right)
-            asmgen.out("  jsr  floats.lesseq_f |  inx |  lda  P8ESTACK_LO,x |  beq  $jumpIfFalseLabel")
+            val subroutine = left.definingSubroutine()!!
+            subroutine.asmGenInfo.usedFloatEvalResultVar1 = true
+            asmgen.assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
+            asmgen.assignExpressionToRegister(left, RegisterOrPair.FAC1)
+            asmgen.out("""
+                lda  #<$subroutineFloatEvalResultVar1
+                ldy  #>$subroutineFloatEvalResultVar1
+                jsr  floats.var_fac1_lesseq_f
+                beq  $jumpIfFalseLabel""")
         }
     }
 
@@ -297,11 +306,15 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 jsr  floats.vars_less_f
                 beq  $jumpIfFalseLabel""")
         } else {
-            if (asmgen.options.slowCodegenWarnings)
-                println("warning: slow stack evaluation used (e1): '>' at ${left.position}") // TODO float via func args?
-            translateExpression(left)
-            translateExpression(right)
-            asmgen.out("  jsr  floats.greater_f |  inx |  lda  P8ESTACK_LO,x |  beq  $jumpIfFalseLabel")
+            val subroutine = left.definingSubroutine()!!
+            subroutine.asmGenInfo.usedFloatEvalResultVar1 = true
+            asmgen.assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
+            asmgen.assignExpressionToRegister(left, RegisterOrPair.FAC1)
+            asmgen.out("""
+                lda  #<$subroutineFloatEvalResultVar1
+                ldy  #>$subroutineFloatEvalResultVar1
+                jsr  floats.var_fac1_greater_f
+                beq  $jumpIfFalseLabel""")
         }
     }
 
@@ -338,11 +351,15 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 jsr  floats.vars_lesseq_f
                 beq  $jumpIfFalseLabel""")
         } else {
-            if (asmgen.options.slowCodegenWarnings)
-                println("warning: slow stack evaluation used (e1): '>=' at ${left.position}") // TODO float via func args
-            translateExpression(left)
-            translateExpression(right)
-            asmgen.out("  jsr  floats.greatereq_f |  inx |  lda  P8ESTACK_LO,x |  beq  $jumpIfFalseLabel")
+            val subroutine = left.definingSubroutine()!!
+            subroutine.asmGenInfo.usedFloatEvalResultVar1 = true
+            asmgen.assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
+            asmgen.assignExpressionToRegister(left, RegisterOrPair.FAC1)
+            asmgen.out("""
+                lda  #<$subroutineFloatEvalResultVar1
+                ldy  #>$subroutineFloatEvalResultVar1
+                jsr  floats.var_fac1_greatereq_f
+                beq  $jumpIfFalseLabel""")
         }
     }
 
@@ -772,8 +789,8 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
             }
         }
 
-        asmgen.assignExpressionToVariable(right, "P8ZP_SCRATCH_W2", DataType.UWORD, null)
-        asmgen.assignExpressionToRegister(left, RegisterOrPair.AY)
+        asmgen.assignExpressionToVariable(left, "P8ZP_SCRATCH_W2", DataType.UWORD, null)
+        asmgen.assignExpressionToRegister(right, RegisterOrPair.AY)
         asmgen.out("  jsr  prog8_lib.reg_lesseq_w |  beq  $jumpIfFalseLabel")
     }
 
@@ -899,8 +916,8 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
             }
         }
 
-        asmgen.assignExpressionToVariable(left, "P8ZP_SCRATCH_W2", DataType.UWORD, null)
-        asmgen.assignExpressionToRegister(right, RegisterOrPair.AY)
+        asmgen.assignExpressionToVariable(right, "P8ZP_SCRATCH_W2", DataType.UWORD, null)
+        asmgen.assignExpressionToRegister(left, RegisterOrPair.AY)
         asmgen.out("  jsr  prog8_lib.reg_lesseq_w |  beq  $jumpIfFalseLabel")
     }
 
@@ -1115,11 +1132,15 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 jsr  floats.vars_equal_f
                 beq  $jumpIfFalseLabel""")
         } else {
-            if (asmgen.options.slowCodegenWarnings)
-                println("warning: slow stack evaluation used (e22): '==' at ${left.position}") // TODO float via func args?
-            translateExpression(left)
-            translateExpression(right)
-            asmgen.out("  jsr  floats.equal_f |  inx |  lda  P8ESTACK_LO,x |  beq  $jumpIfFalseLabel")
+            val subroutine = left.definingSubroutine()!!
+            subroutine.asmGenInfo.usedFloatEvalResultVar1 = true
+            asmgen.assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
+            asmgen.assignExpressionToRegister(left, RegisterOrPair.FAC1)
+            asmgen.out("""
+                lda  #<$subroutineFloatEvalResultVar1
+                ldy  #>$subroutineFloatEvalResultVar1
+                jsr  floats.var_fac1_notequal_f
+                bne  $jumpIfFalseLabel""")
         }
     }
 
@@ -1196,11 +1217,15 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 jsr  floats.vars_equal_f
                 bne  $jumpIfFalseLabel""")
         } else {
-            if (asmgen.options.slowCodegenWarnings)
-                println("warning: slow stack evaluation used (e23): '!=' at ${left.position}") // TODO float via func args?
-            translateExpression(left)
-            translateExpression(right)
-            asmgen.out("  jsr  floats.notequal_f |  inx |  lda  P8ESTACK_LO,x |  beq  $jumpIfFalseLabel")
+            val subroutine = left.definingSubroutine()!!
+            subroutine.asmGenInfo.usedFloatEvalResultVar1 = true
+            asmgen.assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
+            asmgen.assignExpressionToRegister(left, RegisterOrPair.FAC1)
+            asmgen.out("""
+                lda  #<$subroutineFloatEvalResultVar1
+                ldy  #>$subroutineFloatEvalResultVar1
+                jsr  floats.var_fac1_notequal_f
+                beq  $jumpIfFalseLabel""")
         }
     }
 
@@ -1339,6 +1364,8 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                                 asmgen.out("  lda  #0 |  sta  P8ESTACK_LO,x")
                             asmgen.out("  tya |  sta  P8ESTACK_HI,x |  dex")
                         }
+                        RegisterOrPair.FAC1 -> asmgen.out("  jsr  floats.push_fac1")
+                        RegisterOrPair.FAC2 -> asmgen.out("  jsr  floats.push_fac2")
                     }
                 }
                 else if(reg.statusflag!=null) {
@@ -1592,9 +1619,9 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 }
             }
             ">>" -> {
-                translateExpression(expr.left)
                 val amount = expr.right.constValue(program)?.number?.toInt()
                 if(amount!=null) {
+                    translateExpression(expr.left)
                     when (leftDt) {
                         DataType.UBYTE -> {
                             if (amount <= 2)
@@ -1615,6 +1642,13 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                             }
                         }
                         DataType.UWORD -> {
+                            if(amount>=16) {
+                                if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                                    asmgen.out("  stz  P8ESTACK_LO+1,x |  stz  P8ESTACK_HI+1,x")
+                                else
+                                    asmgen.out("  lda  #0 |  sta  P8ESTACK_LO+1,x |  sta  P8ESTACK_HI+1,x")
+                                return
+                            }
                             var left = amount
                             while (left >= 7) {
                                 asmgen.out(" jsr  math.shift_right_uw_7")
@@ -1626,6 +1660,20 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                                 asmgen.out(" jsr  math.shift_right_uw_$left")
                         }
                         DataType.WORD -> {
+                            if(amount>=16) {
+                                asmgen.out("""
+                                    lda  P8ESTACK_HI+1,x
+                                    bmi  +
+                                    lda  #0
+                                    sta  P8ESTACK_LO+1,x
+                                    sta  P8ESTACK_HI+1,x
+                                    beq  ++
++                                   lda  #255
+                                    sta  P8ESTACK_LO+1,x
+                                    sta  P8ESTACK_HI+1,x
++""")
+                                return
+                            }
                             var left = amount
                             while (left >= 7) {
                                 asmgen.out(" jsr  math.shift_right_w_7")
@@ -1642,9 +1690,9 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 }
             }
             "<<" -> {
-                translateExpression(expr.left)
                 val amount = expr.right.constValue(program)?.number?.toInt()
                 if(amount!=null) {
+                    translateExpression(expr.left)
                     if (leftDt in ByteDatatypes) {
                         if (amount <= 2)
                             repeat(amount) { asmgen.out("  asl  P8ESTACK_LO+1,x") }

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

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

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

@@ -122,7 +122,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         assignMemoryByte(assign.target, null, value.addressExpression as IdentifierReference)
                     }
                     else -> {
-                        asmgen.assignExpressionToVariable(value.addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, assign.target.scope)
+                        assignExpressionToVariable(value.addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, assign.target.scope)
                         asmgen.out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W2),y")
                         assignRegisterByte(assign.target, CpuRegister.A)
                     }
@@ -138,7 +138,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     is IdentifierReference -> throw AssemblyError("source kind should have been variable")
                     is ArrayIndexedExpression -> throw AssemblyError("source kind should have been array")
                     is DirectMemoryRead -> throw AssemblyError("source kind should have been memory")
-                    is TypecastExpression -> assignTypeCastedValue(assign.target, value.type, value.expression, assign)
+                    is TypecastExpression -> assignTypeCastedValue(assign.target, value.type, value.expression, value)
                     is FunctionCall -> {
                         when (val sub = value.target.targetStatement(program.namespace)) {
                             is Subroutine -> {
@@ -211,6 +211,10 @@ 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 (this.asmgen.options.slowCodegenWarnings)
+                                println("warning: slow stack evaluation used for return: $value  target=${assign.target.kind} at ${value.position}")
+                        }
                         asmgen.translateExpression(value)
                         if(assign.target.datatype in WordDatatypes && assign.source.datatype in ByteDatatypes)
                             asmgen.signExtendStackLsb(assign.source.datatype)
@@ -227,11 +231,14 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
-    private fun assignTypeCastedValue(target: AsmAssignTarget, targetDt: DataType, value: Expression, origAssign: AsmAssignment) {
+    private fun assignTypeCastedValue(target: AsmAssignTarget, targetDt: DataType, value: Expression, origTypeCastExpression: TypecastExpression) {
         val valueIDt = value.inferType(program)
         if(!valueIDt.isKnown)
             throw AssemblyError("unknown dt")
         val valueDt = valueIDt.typeOrElse(DataType.STRUCT)
+        if(valueDt==targetDt)
+            throw AssemblyError("type cast to identical dt should have been removed")
+
         when(value) {
             is IdentifierReference -> {
                 if(targetDt in WordDatatypes) {
@@ -262,37 +269,62 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             else -> {}
         }
 
-        when(value) {
-            is IdentifierReference -> {
-                if(target.kind==TargetStorageKind.VARIABLE) {
-                    val sourceDt = value.inferType(program).typeOrElse(DataType.STRUCT)
-                    if (sourceDt != DataType.STRUCT)
-                        return assignTypeCastedIdentifier(target.asmVarname, targetDt, asmgen.asmVariableName(value), sourceDt, origAssign.source.expression!!)
+
+        // special case optimizations
+        if(target.kind==TargetStorageKind.VARIABLE) {
+            if(value is IdentifierReference && valueDt != DataType.STRUCT)
+                return assignTypeCastedIdentifier(target.asmVarname, targetDt, asmgen.asmVariableName(value), valueDt)
+
+            when (valueDt) {
+                in ByteDatatypes -> {
+                    assignExpressionToRegister(value, RegisterOrPair.A)
+                    assignTypeCastedRegisters(target.asmVarname, targetDt, RegisterOrPair.A, valueDt)
                 }
+                in WordDatatypes -> {
+                    assignExpressionToRegister(value, RegisterOrPair.AY)
+                    assignTypeCastedRegisters(target.asmVarname, targetDt, RegisterOrPair.AY, valueDt)
+                }
+                DataType.FLOAT -> {
+                    assignExpressionToRegister(value, RegisterOrPair.FAC1)
+                    assignTypecastedFloatFAC1(target.asmVarname, targetDt)
+                }
+                in PassByReferenceDatatypes -> {
+                    // str/array value cast (most likely to UWORD, take address-of)
+                    assignExpressionToVariable(value, target.asmVarname, targetDt, null)
+                }
+                else -> throw AssemblyError("strange dt in typecast assign to var: $valueDt  -->  $targetDt")
             }
-            is PrefixExpression -> {}
-            is BinaryExpression -> {}
-            is ArrayIndexedExpression -> {}
-            is TypecastExpression -> {}
-            is RangeExpr -> {}
-            is FunctionCall -> {}
-            else -> {
-                // TODO optimize the others further?
-                if(this.asmgen.options.slowCodegenWarnings)
-                    println("warning: slow stack evaluation used for typecast: $value into $targetDt at ${value.position}")
-            }
+            return
         }
 
         // give up, do it via eval stack
-        asmgen.translateExpression(origAssign.source.expression!!)
+        // TODO optimize typecasts for more special cases?
+        // note: cannot use assignTypeCastedValue because that is ourselves :P
+        if(this.asmgen.options.slowCodegenWarnings)
+            println("warning: slow stack evaluation used for typecast: $value into $targetDt (target=${target.kind} at ${value.position}")
+        asmgen.translateExpression(origTypeCastExpression)      // this performs the actual type cast in translateExpression(Typecast)
         assignStackValue(target)
     }
 
+    private fun assignTypecastedFloatFAC1(targetAsmVarName: String, targetDt: DataType) {
+
+        if(targetDt==DataType.FLOAT)
+            throw AssemblyError("typecast to identical type")
+
+        when(targetDt) {
+            DataType.UBYTE -> asmgen.out("  jsr  floats.cast_FAC1_as_uw_into_ya |  sty  $targetAsmVarName")
+            DataType.BYTE -> asmgen.out("  jsr  floats.cast_FAC1_as_w_into_ay |  sta  $targetAsmVarName")
+            DataType.UWORD -> asmgen.out("  jsr  floats.cast_FAC1_as_uw_into_ya |  sty  $targetAsmVarName |  sta  $targetAsmVarName+1")
+            DataType.WORD -> asmgen.out("  jsr  floats.cast_FAC1_as_w_into_ay |  sta  $targetAsmVarName |  sty  $targetAsmVarName+1")
+            else -> throw AssemblyError("weird type")
+        }
+    }
+
+
     private fun assignTypeCastedIdentifier(targetAsmVarName: String, targetDt: DataType,
-                                           sourceAsmVarName: String, sourceDt: DataType,
-                                           origExpr: Expression) {
+                                           sourceAsmVarName: String, sourceDt: DataType) {
         if(sourceDt == targetDt)
-            throw AssemblyError("typecast to identical value")
+            throw AssemblyError("typecast to identical type")
 
         // also see: ExpressionAsmGen,   fun translateExpression(typecast: TypecastExpression)
         when(sourceDt) {
@@ -324,7 +356,13 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     DataType.UBYTE, DataType.BYTE -> {
                         asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
                     }
-                    DataType.UWORD, DataType.WORD -> {
+                    DataType.UWORD -> {
+                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                            asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  stz  $targetAsmVarName+1")
+                        else
+                            asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
+                    }
+                    DataType.WORD -> {
                         asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
                         asmgen.signExtendVariableLsb(targetAsmVarName, DataType.BYTE)
                     }
@@ -383,13 +421,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 }
             }
             DataType.FLOAT -> {
-                asmgen.out("""
-                            lda  #<$targetAsmVarName
-                            ldy  #>$targetAsmVarName
-                            sta  P8ZP_SCRATCH_W2
-                            sty  P8ZP_SCRATCH_W2+1
-                            lda  #<$sourceAsmVarName
-                            ldy  #>$sourceAsmVarName""")
+                asmgen.out("  lda  #<$sourceAsmVarName |  ldy  #>$sourceAsmVarName")
                 when(targetDt) {
                     DataType.UBYTE -> asmgen.out("  jsr  floats.cast_as_uw_into_ya |  sty  $targetAsmVarName")
                     DataType.BYTE -> asmgen.out("  jsr  floats.cast_as_w_into_ay |  sta  $targetAsmVarName")
@@ -401,6 +433,146 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             DataType.STR -> {
                 if (targetDt != DataType.UWORD && targetDt == DataType.STR)
                     throw AssemblyError("cannot typecast a string into another incompatitble type")
+                TODO("assign typecasted string into target var")
+            }
+            else -> throw AssemblyError("weird type")
+        }
+    }
+
+
+    private fun assignTypeCastedRegisters(targetAsmVarName: String, targetDt: DataType,
+                                          regs: RegisterOrPair, sourceDt: DataType) {
+        if(sourceDt == targetDt)
+            throw AssemblyError("typecast to identical type")
+
+        // also see: ExpressionAsmGen,   fun translateExpression(typecast: TypecastExpression)
+        when(sourceDt) {
+            DataType.UBYTE -> {
+                when(targetDt) {
+                    DataType.UBYTE, DataType.BYTE -> {
+                        asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName")
+                    }
+                    DataType.UWORD, DataType.WORD -> {
+                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                            asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  stz  $targetAsmVarName+1")
+                        else
+                            asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
+                    }
+                    DataType.FLOAT -> {
+                        when(regs) {
+                            RegisterOrPair.A -> asmgen.out("  tay")
+                            RegisterOrPair.X -> asmgen.out("  txa |  tay")
+                            RegisterOrPair.Y -> {}
+                            else -> throw AssemblyError("non-byte regs")
+                        }
+                        asmgen.out("""
+                            lda  #<$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2
+                            lda  #>$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2+1
+                            jsr  floats.cast_from_ub""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.BYTE -> {
+                when(targetDt) {
+                    DataType.UBYTE, DataType.BYTE -> {
+                        asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName")
+                    }
+                    DataType.UWORD -> {
+                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                            asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  stz  $targetAsmVarName+1")
+                        else
+                            asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
+                    }
+                    DataType.WORD -> {
+                        when(regs) {
+                            RegisterOrPair.A -> {}
+                            RegisterOrPair.X -> asmgen.out("  txa")
+                            RegisterOrPair.Y -> asmgen.out("  tya")
+                            else -> throw AssemblyError("non-byte regs")
+                        }
+                        asmgen.signExtendAYlsb(sourceDt)
+                        asmgen.out("  sta  $targetAsmVarName |  sty  $targetAsmVarName+1")
+                    }
+                    DataType.FLOAT -> {
+                        when(regs) {
+                            RegisterOrPair.A -> {}
+                            RegisterOrPair.X -> asmgen.out("  txa")
+                            RegisterOrPair.Y -> asmgen.out("  tya")
+                            else -> throw AssemblyError("non-byte regs")
+                        }
+                        asmgen.out("""
+                            ldy  #<$targetAsmVarName
+                            sty  P8ZP_SCRATCH_W2
+                            ldy  #>$targetAsmVarName
+                            sty  P8ZP_SCRATCH_W2+1
+                            jsr  floats.cast_from_b""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.UWORD -> {
+                when(targetDt) {
+                    DataType.BYTE, DataType.UBYTE -> {
+                        asmgen.out("  st${regs.toString().toLowerCase().first()}  $targetAsmVarName")
+                    }
+                    DataType.WORD, DataType.UWORD -> {
+                        when(regs) {
+                            RegisterOrPair.AX -> asmgen.out("  sta  $targetAsmVarName |  stx  $targetAsmVarName+1")
+                            RegisterOrPair.AY -> asmgen.out("  sta  $targetAsmVarName |  sty  $targetAsmVarName+1")
+                            RegisterOrPair.XY -> asmgen.out("  stx  $targetAsmVarName |  sty  $targetAsmVarName+1")
+                            else -> throw AssemblyError("non-word regs")
+                        }
+                    }
+                    DataType.FLOAT -> {
+                        if(regs!=RegisterOrPair.AY)
+                            throw AssemblyError("only supports AY here")
+                        asmgen.out("""
+                            pha
+                            lda  #<$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2
+                            lda  #>$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2+1
+                            pla
+                            jsr  floats.cast_from_uw""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.WORD -> {
+                when(targetDt) {
+                    DataType.BYTE, DataType.UBYTE -> {
+                        asmgen.out("  st${regs.toString().toLowerCase().first()}  $targetAsmVarName")
+                    }
+                    DataType.WORD, DataType.UWORD -> {
+                        when(regs) {
+                            RegisterOrPair.AX -> asmgen.out("  sta  $targetAsmVarName |  stx  $targetAsmVarName+1")
+                            RegisterOrPair.AY -> asmgen.out("  sta  $targetAsmVarName |  sty  $targetAsmVarName+1")
+                            RegisterOrPair.XY -> asmgen.out("  stx  $targetAsmVarName |  sty  $targetAsmVarName+1")
+                            else -> throw AssemblyError("non-word regs")
+                        }
+                    }
+                    DataType.FLOAT -> {
+                        if(regs!=RegisterOrPair.AY)
+                            throw AssemblyError("only supports AY here")
+                        asmgen.out("""
+                            pha
+                            lda  #<$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2
+                            lda  #>$targetAsmVarName
+                            sta  P8ZP_SCRATCH_W2+1
+                            pla
+                            jsr  floats.cast_from_w""")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.STR -> {
+                if (targetDt != DataType.UWORD && targetDt == DataType.STR)
+                    throw AssemblyError("cannot typecast a string into another incompatitble type")
+                TODO("assign typecasted string into target var")
             }
             else -> throw AssemblyError("weird type")
         }
@@ -527,6 +699,14 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                             else -> throw AssemblyError("can't assign word to single byte register")
                         }
                     }
+                    DataType.FLOAT -> {
+                        when(target.register!!) {
+                            RegisterOrPair.FAC1 -> asmgen.out("  jsr  floats.pop_float_fac1")
+                            RegisterOrPair.FAC2 -> asmgen.out("  jsr  floats.pop_float_fac2")
+                            else -> throw AssemblyError("can only assign float to Fac1 or 2")
+                        }
+                    }
+
                     else -> throw AssemblyError("weird dt")
                 }
             }
@@ -702,7 +882,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
-    private fun assignFAC1float(target: AsmAssignTarget) {
+    internal fun assignFAC1float(target: AsmAssignTarget) {
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
                 asmgen.out("""
@@ -729,7 +909,10 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 asmgen.out("  jsr  floats.set_array_float_from_fac1")
             }
             TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to mem byte")
-            TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
+            TargetStorageKind.REGISTER -> {
+                if (target.register!! != RegisterOrPair.FAC1)
+                    throw AssemblyError("can't assign Fac1 float to another fac register")
+            }
             TargetStorageKind.STACK -> asmgen.out("  jsr  floats.push_fac1")
         }
     }
@@ -762,7 +945,13 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 asmgen.out(" jsr  floats.set_array_float")
             }
             TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to mem byte")
-            TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
+            TargetStorageKind.REGISTER -> {
+                when(target.register!!) {
+                    RegisterOrPair.FAC1 -> asmgen.out("  jsr  floats.MOVFM")
+                    RegisterOrPair.FAC2 -> asmgen.out("  jsr  floats.CONUPK")
+                    else -> throw AssemblyError("can only assign float to Fac1 or 2")
+                }
+            }
             TargetStorageKind.STACK -> asmgen.out("  jsr  floats.push_float")
         }
     }
@@ -803,7 +992,13 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 asmgen.out(" jsr  floats.set_array_float")
             }
             TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to mem byte")
-            TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
+            TargetStorageKind.REGISTER -> {
+                when(target.register!!) {
+                    RegisterOrPair.FAC1 -> asmgen.out("  lda  #<$sourceName  | ldy  #>$sourceName |  jsr  floats.MOVFM")
+                    RegisterOrPair.FAC2 -> asmgen.out("  lda  #<$sourceName  | ldy  #>$sourceName |  jsr  floats.CONUPK")
+                    else -> throw AssemblyError("can only assign float to Fac1 or 2")
+                }
+            }
             TargetStorageKind.STACK -> asmgen.out("  lda  #<$sourceName |  ldy  #>$sourceName |  jsr  floats.push_float")
         }
     }
@@ -837,6 +1032,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     RegisterOrPair.AX -> asmgen.out("  lda  $sourceName |  ldx  #0")
                     RegisterOrPair.AY -> asmgen.out("  lda  $sourceName |  ldy  #0")
                     RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName |  ldy  #0")
+                    RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
                 }
             }
             TargetStorageKind.STACK -> {
@@ -951,7 +1147,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
-    private fun assignRegisterByte(target: AsmAssignTarget, register: CpuRegister) {
+    internal fun assignRegisterByte(target: AsmAssignTarget, register: CpuRegister) {
         require(target.datatype in ByteDatatypes)
         when(target.kind) {
             TargetStorageKind.VARIABLE -> {
@@ -988,6 +1184,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AY -> { asmgen.out("  ldy  #0") }
                         RegisterOrPair.AX -> { asmgen.out("  ldx  #0") }
                         RegisterOrPair.XY -> { asmgen.out("  tax |  ldy  #0") }
+                        RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected type cast to float")
                     }
                     CpuRegister.X -> when(target.register!!) {
                         RegisterOrPair.A -> { asmgen.out("  txa") }
@@ -996,6 +1193,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AY -> { asmgen.out("  txa |  ldy  #0") }
                         RegisterOrPair.AX -> { asmgen.out("  txa |  ldx  #0") }
                         RegisterOrPair.XY -> { asmgen.out("  ldy  #0") }
+                        RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected type cast to float")
                     }
                     CpuRegister.Y -> when(target.register!!) {
                         RegisterOrPair.A -> { asmgen.out("  tya") }
@@ -1004,6 +1202,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AY -> { asmgen.out("  tya |  ldy  #0") }
                         RegisterOrPair.AX -> { asmgen.out("  tya |  ldx  #0") }
                         RegisterOrPair.XY -> { asmgen.out("  tya |  tax |  ldy  #0") }
+                        RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected type cast to float")
                     }
                 }
             }
@@ -1017,7 +1216,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         }
     }
 
-    private fun assignRegisterpairWord(target: AsmAssignTarget, regs: RegisterOrPair) {
+    internal fun assignRegisterpairWord(target: AsmAssignTarget, regs: RegisterOrPair) {
         require(target.datatype in NumericDatatypes)
         if(target.datatype==DataType.FLOAT)
             throw AssemblyError("float value should be from FAC1 not from registerpair memory pointer")
@@ -1156,6 +1355,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 RegisterOrPair.AX -> asmgen.out("  lda  #${byte.toHex()} |  ldx  #0")
                 RegisterOrPair.AY -> asmgen.out("  lda  #${byte.toHex()} |  ldy  #0")
                 RegisterOrPair.XY -> asmgen.out("  ldx  #${byte.toHex()} |  ldy  #0")
+                RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
             }
             TargetStorageKind.STACK -> {
                 asmgen.out("""
@@ -1213,7 +1413,14 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     }
                 }
                 TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to memory byte")
-                TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
+                TargetStorageKind.REGISTER -> {
+                    val floatConst = asmgen.getFloatAsmConst(float)
+                    when(target.register!!) {
+                        RegisterOrPair.FAC1 -> asmgen.out("  lda  #<$floatConst  | ldy  #>$floatConst |  jsr  floats.MOVFM")
+                        RegisterOrPair.FAC2 -> asmgen.out("  lda  #<$floatConst  | ldy  #>$floatConst |  jsr  floats.CONUPK")
+                        else -> throw AssemblyError("can only assign float to Fac1 or 2")
+                    }
+                }
                 TargetStorageKind.STACK -> {
                     val floatConst = asmgen.getFloatAsmConst(float)
                     asmgen.out(" lda  #<$floatConst |  ldy  #>$floatConst |  jsr  floats.push_float")
@@ -1270,7 +1477,14 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     }
                 }
                 TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to memory byte")
-                TargetStorageKind.REGISTER -> throw AssemblyError("can't assign float to register")
+                TargetStorageKind.REGISTER -> {
+                    val floatConst = asmgen.getFloatAsmConst(float)
+                    when(target.register!!) {
+                        RegisterOrPair.FAC1 -> asmgen.out("  lda  #<$floatConst  | ldy  #>$floatConst |  jsr  floats.MOVFM")
+                        RegisterOrPair.FAC2 -> asmgen.out("  lda  #<$floatConst  | ldy  #>$floatConst |  jsr  floats.CONUPK")
+                        else -> throw AssemblyError("can only assign float to Fac1 or 2")
+                    }
+                }
                 TargetStorageKind.STACK -> {
                     val floatConst = asmgen.getFloatAsmConst(float)
                     asmgen.out(" lda  #<$floatConst |  ldy  #>$floatConst |  jsr  floats.push_float")
@@ -1301,6 +1515,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     RegisterOrPair.AX -> asmgen.out("  lda  ${address.toHex()} |  ldx  #0")
                     RegisterOrPair.AY -> asmgen.out("  lda  ${address.toHex()} |  ldy  #0")
                     RegisterOrPair.XY -> asmgen.out("  ldy  ${address.toHex()} |  ldy  #0")
+                    RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
                 }
                 TargetStorageKind.STACK -> {
                     asmgen.out("""
@@ -1331,6 +1546,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         RegisterOrPair.AX -> asmgen.out("  ldx  #0")
                         RegisterOrPair.AY -> asmgen.out("  ldy  #0")
                         RegisterOrPair.XY -> asmgen.out("  tax |  ldy  #0")
+                        RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
                     }
                 }
                 TargetStorageKind.STACK -> {
@@ -1409,7 +1625,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 asmgen.storeByteIntoPointer(addressExpr, ldaInstructionArg)
             }
             else -> {
-                asmgen.assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
+                assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
                 asmgen.out("  ldy  #0 |  lda  $ldaInstructionArg |  sta  (P8ZP_SCRATCH_W2),y")
             }
         }
@@ -1434,7 +1650,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             }
             else -> {
                 asmgen.saveRegister(register, false, memoryAddress.definingSubroutine()!!)
-                asmgen.assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
+                assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
                 asmgen.restoreRegister(CpuRegister.A, false)
                 asmgen.out("  ldy  #0 |  sta  (P8ZP_SCRATCH_W2),y")
             }

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

@@ -160,7 +160,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         when {
                             valueLv != null -> inplaceModification_byte_litval_to_variable(addr.toHex(), DataType.UBYTE, operator, valueLv.toInt())
                             ident != null -> inplaceModification_byte_variable_to_variable(addr.toHex(), DataType.UBYTE, operator, ident)
-                            // TODO more specialized code for types such as memory read etc.
+                            // TODO more specialized code for types such as memory read etc.  -> inplaceModification_byte_memread_to_variable()
                             value is TypecastExpression -> {
                                 if (tryRemoveRedundantCast(value, target, operator)) return
                                 inplaceModification_byte_value_to_variable(addr.toHex(), DataType.UBYTE, operator, value)
@@ -173,7 +173,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         when {
                             valueLv != null -> inplaceModification_byte_litval_to_pointer(pointer, operator, valueLv.toInt())
                             ident != null -> inplaceModification_byte_variable_to_pointer(pointer, operator, ident)
-                            // TODO more specialized code for types such as memory read etc.
                             value is TypecastExpression -> {
                                 if (tryRemoveRedundantCast(value, target, operator)) return
                                 inplaceModification_byte_value_to_pointer(pointer, operator, value)
@@ -182,29 +181,92 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         }
                     }
                     else -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (1): ${memory.addressExpression::class.simpleName} at ${memory.addressExpression.position}") // TODO optimize...
-                        asmgen.translateExpression(memory.addressExpression)  // TODO directly into P8ZP_SCRATCH_W2?
+                        asmgen.translateExpression(memory.addressExpression)
                         asmgen.out("  jsr  prog8_lib.read_byte_from_address_on_stack |  sta  P8ZP_SCRATCH_B1")
-                        val zp = CompilationTarget.instance.machine.zeropage
                         when {
-                            valueLv != null -> inplaceModification_byte_litval_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, valueLv.toInt())
-                            ident != null -> inplaceModification_byte_variable_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, ident)
-                            memread != null -> inplaceModification_byte_memread_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, memread)
+                            valueLv != null -> inplaceModification_byte_litval_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, valueLv.toInt())
+                            ident != null -> inplaceModification_byte_variable_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, ident)
+                            memread != null -> inplaceModification_byte_memread_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, memread)
                             value is TypecastExpression -> {
                                 if (tryRemoveRedundantCast(value, target, operator)) return
-                                inplaceModification_byte_value_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, value)
+                                inplaceModification_byte_value_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, value)
                             }
-                            else -> inplaceModification_byte_value_to_variable(zp.SCRATCH_B1.toHex(), DataType.UBYTE, operator, value)
+                            else -> inplaceModification_byte_value_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, value)
                         }
                         asmgen.out("  lda  P8ZP_SCRATCH_B1 |  jsr  prog8_lib.write_byte_to_address_on_stack | inx")
                     }
                 }
             }
             TargetStorageKind.ARRAY -> {
-                if(asmgen.options.slowCodegenWarnings)
-                    println("*** TODO optimize simple inplace array assignment ${target.array}  $operator=  $value")
-                assignmentAsmGen.translateNormalAssignment(target.origAssign) // TODO get rid of this fallback for the most common cases here
+                with(target.array!!.indexer) {
+                    when {
+                        indexNum!=null -> {
+                            val targetVarName = "${target.asmVarname} + ${indexNum!!.number.toInt()*target.datatype.memorySize()}"
+                            when(target.datatype) {
+                                in ByteDatatypes -> {
+                                    when {
+                                        valueLv != null -> inplaceModification_byte_litval_to_variable(targetVarName, target.datatype, operator, valueLv.toInt())
+                                        ident != null -> inplaceModification_byte_variable_to_variable(targetVarName, target.datatype, operator, ident)
+                                        memread != null -> inplaceModification_byte_memread_to_variable(targetVarName, target.datatype, operator, memread)
+                                        value is TypecastExpression -> {
+                                            if (tryRemoveRedundantCast(value, target, operator)) return
+                                            inplaceModification_byte_value_to_variable(targetVarName, target.datatype, operator, value)
+                                        }
+                                        else -> inplaceModification_byte_value_to_variable(targetVarName, target.datatype, operator, value)
+                                    }
+                                }
+                                in WordDatatypes -> {
+                                    when {
+                                        valueLv != null -> inplaceModification_word_litval_to_variable(targetVarName, target.datatype, operator, valueLv.toInt())
+                                        ident != null -> inplaceModification_word_variable_to_variable(targetVarName, target.datatype, operator, ident)
+                                        memread != null -> inplaceModification_word_memread_to_variable(targetVarName, target.datatype, operator, memread)
+                                        value is TypecastExpression -> {
+                                            if (tryRemoveRedundantCast(value, target, operator)) return
+                                            inplaceModification_word_value_to_variable(targetVarName, target.datatype, operator, value)
+                                        }
+                                        else -> inplaceModification_word_value_to_variable(targetVarName, target.datatype, operator, value)
+                                    }
+                                }
+                                DataType.FLOAT -> {
+                                    when {
+                                        valueLv != null -> inplaceModification_float_litval_to_variable(targetVarName, operator, valueLv.toDouble(), target.scope!!)
+                                        ident != null -> inplaceModification_float_variable_to_variable(targetVarName, operator, ident, target.scope!!)
+                                        value is TypecastExpression -> {
+                                            if (tryRemoveRedundantCast(value, target, operator)) return
+                                            inplaceModification_float_value_to_variable(targetVarName, operator, value, target.scope!!)
+                                        }
+                                        else -> inplaceModification_float_value_to_variable(targetVarName, operator, value, target.scope!!)
+                                    }
+                                }
+                                else -> throw AssemblyError("weird type to do in-place modification on ${target.datatype}")
+                            }
+                        }
+                        indexVar!=null -> {
+                            when(target.datatype) {
+                                in ByteDatatypes -> {
+                                    val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.A, null, program, asmgen)
+                                    val assign = AsmAssignment(target.origAssign.source, tgt, false, value.position)
+                                    assignmentAsmGen.translateNormalAssignment(assign)
+                                    assignmentAsmGen.assignRegisterByte(target, CpuRegister.A)
+                                }
+                                in WordDatatypes -> {
+                                    val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.AY, null, program, asmgen)
+                                    val assign = AsmAssignment(target.origAssign.source, tgt, false, value.position)
+                                    assignmentAsmGen.translateNormalAssignment(assign)
+                                    assignmentAsmGen.assignRegisterpairWord(target, RegisterOrPair.AY)
+                                }
+                                DataType.FLOAT -> {
+                                    val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.FAC1, null, program, asmgen)
+                                    val assign = AsmAssignment(target.origAssign.source, tgt, false, value.position)
+                                    assignmentAsmGen.translateNormalAssignment(assign)
+                                    assignmentAsmGen.assignFAC1float(target)
+                                }
+                                else -> throw AssemblyError("weird type to do in-place modification on ${target.datatype}")
+                            }
+                        }
+                        else -> throw AssemblyError("indexer expression should have been replaced by auto indexer var")
+                    }
+                }
             }
             TargetStorageKind.REGISTER -> TODO("reg in-place modification")
             TargetStorageKind.STACK -> TODO("stack in-place modification")
@@ -228,26 +290,19 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
     }
 
     private fun inplaceModification_byte_value_to_pointer(pointervar: IdentifierReference, operator: String, value: Expression) {
-        if(asmgen.options.slowCodegenWarnings)
-            println("warning: slow stack evaluation used (3):  @(${pointervar.nameInSource.last()}) $operator= ${value::class.simpleName} at ${value.position}") // TODO
-        asmgen.translateExpression(value)
+        asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_B1", DataType.UBYTE, null)
         val (ptrOnZp, sourceName) = asmgen.loadByteFromPointerIntoA(pointervar)
         when (operator) {
             // note: ** (power) operator requires floats.
-            "+" -> asmgen.out("  clc |  adc  P8ESTACK_LO+1,x")
-            "-" -> asmgen.out("  sec |  sbc  P8ESTACK_LO+1,x")
-            "*" -> asmgen.out("  pha |  lda  P8ESTACK_LO+1,x |  tay |  pla |  jsr  math.multiply_bytes |  ldy  #0")
-            "/" -> asmgen.out("  pha |  lda  P8ESTACK_LO+1,x |  tay |  pla |  jsr  math.divmod_ub_asm |  tya |  ldy  #0")
-            "%" -> asmgen.out("  pha |  lda  P8ESTACK_LO+1,x |  tay |  pla |  jsr  math.divmod_ub_asm |  ldy  #0")
+            "+" -> asmgen.out("  clc |  adc  P8ZP_SCRATCH_B1")
+            "-" -> asmgen.out("  sec |  sbc  P8ZP_SCRATCH_B1")
+            "*" -> asmgen.out("  ldy  P8ZP_SCRATCH_B1 |  jsr  math.multiply_bytes |  ldy  #0")
+            "/" -> asmgen.out("  ldy  P8ZP_SCRATCH_B1 |  jsr  math.divmod_ub_asm |  tya |  ldy  #0")
+            "%" -> asmgen.out("  ldy  P8ZP_SCRATCH_B1 |  jsr  math.divmod_ub_asm |  ldy  #0")
             "<<" -> {
                 asmgen.out("""
-                    pha
-                    lda  P8ESTACK_LO+1,x
-                    bne  +
-                    pla
-                    rts
-+                   tay
-                    pla 
+                    ldy  P8ZP_SCRATCH_B1
+                    beq  +
 -                   asl  a
                     dey
                     bne  -
@@ -255,28 +310,22 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             ">>" -> {
                 asmgen.out("""
-                    pha
-                    lda  P8ESTACK_LO+1,x
-                    bne  +
-                    pla
-                    rts
-+                   tay
-                    pla 
+                    ldy  P8ZP_SCRATCH_B1
+                    beq  +
 -                   lsr  a
                     dey
                     bne  -
 +""")
             }
-            "&" -> asmgen.out(" and  P8ESTACK_LO+1,x")
-            "^" -> asmgen.out(" eor  P8ESTACK_LO+1,x")
-            "|" -> asmgen.out(" ora  P8ESTACK_LO+1,x")
+            "&" -> asmgen.out(" and  P8ZP_SCRATCH_B1")
+            "^" -> asmgen.out(" eor  P8ZP_SCRATCH_B1")
+            "|" -> asmgen.out(" ora  P8ZP_SCRATCH_B1")
             else -> throw AssemblyError("invalid operator for in-place modification $operator")
         }
         if(ptrOnZp)
             asmgen.out("  sta  ($sourceName),y")
         else
             asmgen.out("  sta  (P8ZP_SCRATCH_W1),y")
-        asmgen.out(" inx")
     }
 
     private fun inplaceModification_byte_variable_to_pointer(pointervar: IdentifierReference, operator: String, value: IdentifierReference) {
@@ -1116,11 +1165,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             throw AssemblyError("unknown dt")
         val valueDt = valueiDt.typeOrElse(DataType.STRUCT)
 
-        // TODO can use registers instead of stack value?
-        fun multiplyWord() {
+        fun multiplyVarByWordInAY() {
             asmgen.out("""
-                lda  P8ESTACK_LO+1,x
-                ldy  P8ESTACK_HI+1,x
                 sta  P8ZP_SCRATCH_W1
                 sty  P8ZP_SCRATCH_W1+1
                 lda  $name
@@ -1133,51 +1179,36 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             """)
         }
 
-        // TODO can use registers instead of stack value?
-        fun divideWord() {
-            if (dt == DataType.WORD) {
-                asmgen.out("""
+        fun divideVarByWordInAY() {
+            asmgen.out("""
+                    pha
                     lda  $name
-                    ldy  $name+1
                     sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  P8ESTACK_LO+1,x
-                    ldy  P8ESTACK_HI+1,x
-                    jsr  math.divmod_w_asm
-                    sta  $name
-                    sty  $name+1
-                """)
-            } else {
-                asmgen.out("""
-                    lda  $name
-                    ldy  $name+1
-                    sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  P8ESTACK_LO+1,x
-                    ldy  P8ESTACK_HI+1,x
-                    jsr  math.divmod_uw_asm
-                    sta  $name
-                    sty  $name+1
-                """)
-            }
+                    lda  $name+1
+                    sta  P8ZP_SCRATCH_W1+1
+                    pla""")
+            if (dt == DataType.WORD)
+                asmgen.out("  jsr  math.divmod_w_asm")
+            else
+                asmgen.out("  jsr  math.divmod_uw_asm")
+            asmgen.out("  sta  $name |  sty  $name+1")
         }
 
-        // TODO can use registers instead of stack value?
-        fun remainderWord() {
+        fun remainderVarByWordInAY() {
             if(dt==DataType.WORD)
                 throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
             asmgen.out("""
+                pha
                 lda  $name
-                ldy  $name+1
                 sta  P8ZP_SCRATCH_W1
-                sty  P8ZP_SCRATCH_W1+1
-                lda  P8ESTACK_LO+1,x
-                ldy  P8ESTACK_HI+1,x
+                lda  $name+1
+                sta  P8ZP_SCRATCH_W1+1
+                pla
                 jsr  math.divmod_uw_asm
                 lda  P8ZP_SCRATCH_W2
+                ldy  P8ZP_SCRATCH_W2+1
                 sta  $name
-                lda  P8ZP_SCRATCH_W2+1
-                sta  $name+1
+                sty  $name+1
             """)
         }
 
@@ -1187,14 +1218,12 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 when (operator) {
                     // note: ** (power) operator requires floats.
                     "+" -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
+                        asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_B1", valueDt, null)
                         if(valueDt==DataType.UBYTE)
                             asmgen.out("""
                                 lda  $name
                                 clc
-                                adc  P8ESTACK_LO+1,x
+                                adc  P8ZP_SCRATCH_B1
                                 sta  $name
                                 bcc  +
                                 inc  $name+1
@@ -1202,7 +1231,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         else
                             asmgen.out("""
                                 ldy  #0
-                                lda  P8ESTACK_LO+1,x
+                                lda  P8ZP_SCRATCH_B1
                                 bpl  +
                                 dey         ; sign extend
 +                               clc
@@ -1211,63 +1240,53 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                 tya
                                 adc  $name+1
                                 sta  $name+1""")
-                        asmgen.out(" inx")
                     }
                     "-" -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
+                        asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_REG", valueDt, null)
                         if(valueDt==DataType.UBYTE)
                             asmgen.out("""
                                 lda  $name
                                 sec
-                                sbc  P8ESTACK_LO+1,x
+                                sbc  P8ZP_SCRATCH_REG
                                 sta  $name
-                                bcc  +
+                                bcs  +
                                 dec  $name+1
 +""")
                         else
                             asmgen.out("""
                                 ldy  #0
-                                lda  P8ESTACK_LO+1,x
+                                lda  P8ZP_SCRATCH_REG
                                 bpl  +
                                 dey         ; sign extend
 +                               sty  P8ZP_SCRATCH_B1
                                 lda  $name
                                 sec
-                                sbc  P8ESTACK_LO+1,x
+                                sbc  P8ZP_SCRATCH_REG
                                 sta  $name
                                 lda  $name+1
                                 sbc  P8ZP_SCRATCH_B1
                                 sta  $name+1""")
-                        asmgen.out(" inx")
                     }
                     "*" -> {
                         // stack contains (u) byte value, sign extend that and proceed with regular 16 bit operation
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
-                        asmgen.signExtendStackLsb(valueDt)
-                        multiplyWord()
-                        asmgen.out(" inx")
+                        // TODO use an optimized word * byte multiplication routine
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                        asmgen.signExtendAYlsb(valueDt)
+                        multiplyVarByWordInAY()
                     }
                     "/" -> {
                         // stack contains (u) byte value, sign extend that and proceed with regular 16 bit operation
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
-                        asmgen.signExtendStackLsb(valueDt)
-                        divideWord()
-                        asmgen.out(" inx")
+                        // TODO use an optimized word / byte divmod routine
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                        asmgen.signExtendAYlsb(valueDt)
+                        divideVarByWordInAY()
                     }
                     "%" -> {
                         // stack contains (u) byte value, sign extend that and proceed with regular 16 bit operation
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
-                        asmgen.signExtendStackLsb(valueDt)
-                        remainderWord()
-                        asmgen.out(" inx")
+                        // TODO use an optimized word / byte divmod routine
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
+                        asmgen.signExtendAYlsb(valueDt)
+                        remainderVarByWordInAY()
                     }
                     "<<" -> {
                         asmgen.assignExpressionToRegister(value, RegisterOrPair.Y)
@@ -1322,56 +1341,37 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 when (operator) {
                     // note: ** (power) operator requires floats.
                     "+" -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
-                        asmgen.out(" lda  $name |  clc |  adc  P8ESTACK_LO+1,x |  sta  $name |  lda  $name+1 |  adc  P8ESTACK_HI+1,x |  sta  $name+1 |  inx")
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        asmgen.out("  clc |  adc  $name |  sta  $name |  tya |  adc  $name+1 |  sta  $name+1")
                     }
                     "-" -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
-                        asmgen.out(" lda  $name |  sec |  sbc  P8ESTACK_LO+1,x |  sta  $name |  lda  $name+1 |  sbc  P8ESTACK_HI+1,x |  sta  $name+1 |  inx")
+                        asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_W1", valueDt, null)
+                        asmgen.out(" lda  $name |  sec |  sbc  P8ZP_SCRATCH_W1 |  sta  $name |  lda  $name+1 |  sbc  P8ZP_SCRATCH_W1+1 |  sta  $name+1")
                     }
                     "*" -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
-                        multiplyWord()
-                        asmgen.out(" inx")
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        multiplyVarByWordInAY()
                     }
                     "/" -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
-                        divideWord()
-                        asmgen.out(" inx")
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        divideVarByWordInAY()
                     }
                     "%" -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
-                        remainderWord()
-                        asmgen.out(" inx")
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        remainderVarByWordInAY()
                     }
                     "<<", ">>" -> throw AssemblyError("shift by a word value not supported, max is a byte")
                     "&" -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
-                        asmgen.out(" lda  $name |  and  P8ESTACK_LO+1,x |  sta  $name | lda  $name+1 |  and  P8ESTACK_HI+1,x  |  sta  $name+1 |  inx")
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        asmgen.out("  and  $name |  sta  $name |  tya |  and  $name+1 |  sta  $name+1")
                     }
                     "^" -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
-                        asmgen.out(" lda  $name |  eor  P8ESTACK_LO+1,x |  sta  $name | lda  $name+1 |  eor  P8ESTACK_HI+1,x  |  sta  $name+1 |  inx")
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        asmgen.out("  eor  $name |  sta  $name |  tya |  eor  $name+1 |  sta  $name+1")
                     }
                     "|" -> {
-                        if(asmgen.options.slowCodegenWarnings)
-                            println("warning: slow stack evaluation used (4):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-                        asmgen.translateExpression(value)
-                        asmgen.out(" lda  $name |  ora  P8ESTACK_LO+1,x |  sta  $name | lda  $name+1 |  ora  P8ESTACK_HI+1,x  |  sta  $name+1 |  inx")
+                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
+                        asmgen.out("  ora  $name |  sta  $name |  tya |  ora  $name+1 |  sta  $name+1")
                     }
                     else -> throw AssemblyError("invalid operator for in-place modification $operator")
                 }
@@ -1381,12 +1381,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
     }
 
     private fun inplaceModification_float_value_to_variable(name: String, operator: String, value: Expression, scope: Subroutine) {
-        // this should be the last resort for code generation for this,
-        // because the value is evaluated onto the eval stack (=slow).
-        if(asmgen.options.slowCodegenWarnings)
-            println("warning: slow stack evaluation used (2):  $name $operator= ${value::class.simpleName} at ${value.position}") // TODO
-        asmgen.translateExpression(value)
-        asmgen.out("  jsr  floats.pop_float_fac1")
+        asmgen.assignExpressionToRegister(value, RegisterOrPair.FAC1)
         asmgen.saveRegister(CpuRegister.X, false, scope)
         when (operator) {
             "**" -> {

docs/source/index.rst

@@ -38,6 +38,27 @@ This software is licensed under the GNU GPL 3.0, see https://www.gnu.org/license
     :alt: Fully playable tetris clone
 
 
+Language features
+-----------------
+
+- It is a cross-compiler running on modern machines (Linux, MacOS, Windows, ...)
+  The generated output is a machine code program runnable on actual 8-bit 6502 hardware.
+- Provide a very convenient edit/compile/run cycle by being able to directly launch
+  the compiled program in an emulator and provide debugging information to this emulator.
+- Based on simple and familiar imperative structured programming (it looks like a mix of C and Python)
+- Modular programming and scoping via modules, code blocks, and subroutines.
+- Provide high level programming constructs but at the same time stay close to the metal;
+  still able to directly use memory addresses and ROM subroutines,
+  and inline assembly to have full control when every register, cycle or byte matters
+- Arbitrary number of subroutine parameters, Complex nested expressions are possible
+- No stack frame allocations because parameters and local variables are automatically allocated statically
+- Nested subroutines can access variables from outer scopes to avoids the overhead to pass everything via parameters
+- Variable data types include signed and unsigned bytes and words, arrays, strings and floats.
+- High-level code optimizations, such as const-folding, expression and statement simplifications/rewriting.
+- Many built-in functions, such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``substr``, ``sort`` and ``reverse`` (and others)
+- If you only use standard kernel and prog8 library routines, it is possible to compile the *exact same program* for both machines (just change the compiler target flag)!
+
+
 Code example
 ------------
 
@@ -104,37 +125,6 @@ when the exact same program is compiled for the Commander X16 target, and run on
 
 
 
-Design principles and features
-------------------------------
-
-- It is a cross-compiler running on modern machines (Linux, MacOS, Windows, ...)
-  The generated output is a machine code program runnable on actual 8-bit 6502 hardware.
-- Based on simple and familiar imperative structured programming (it looks like a mix of C and Python)
-- 'One statement per line' code, resulting in clear readable programs.
-- Modular programming and scoping via modules, code blocks, and subroutines.
-- Provide high level programming constructs but at the same time stay close to the metal;
-  still able to directly use memory addresses and ROM subroutines,
-  and inline assembly to have full control when every register, cycle or byte matters
-- Arbitrary number of subroutine parameters
-- Complex nested expressions are possible
-- Nested subroutines can access variables from outer scopes to avoids the overhead to pass everything via parameters
-- Values are typed. Available data types include signed and unsigned bytes and words, arrays, strings and floats.
-- No dynamic memory allocation or sizing! All variables stay fixed size as determined at compile time.
-- Provide various quality of life language features and library subroutines specifically for the target platform.
-- Provide a very convenient edit/compile/run cycle by being able to directly launch
-  the compiled program in an emulator and provide debugging information to this emulator.
-- Arbitrary control flow jumps and branches are possible,
-  and will usually translate directly into the appropriate single 6502 jump/branch instruction.
-- There are no complicated built-in error handling or overflow checks, you'll have to take care
-  of this yourself if required. This keeps the language and code simple and efficient.
-- The compiler tries to optimize the program and generated code a bit, but hand-tuning of the
-  performance or space-critical parts will likely still be required. This is supported by
-  the ability to easily write embedded assembly code directly in the program source code.
-- There are many built-in functions, such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``substr``, ``sort`` and ``reverse`` (and others)
-- Assembling the generated code into a program wil be done by an external cross-assembler tool.
-- If you only use standard kernel and prog8 library routines, it is possible to compile the *exact same program* for both machines (just change the compiler target flag)!
-
-
 .. _requirements:
 
 Required tools
@@ -146,7 +136,7 @@ A recent precompiled .exe for Windows can be obtained from my `clone <https://gi
 *You need at least version 1.55.2257 of this assembler to correctly use the breakpoints feature.*
 It's possible to use older versions, but it is very likely that the automatic Vice breakpoints won't work with them.
 
-A **Java runtime (jre or jdk), version 8 or newer**  is required to run the prog8 compiler itself.
+A **Java runtime (jre or jdk), version 11 or newer**  is required to run the prog8 compiler itself.
 If you're scared of Oracle's licensing terms, most Linux distributions ship OpenJDK in their packages repository instead.
 For Windows it's possible to get that as well; check out `AdoptOpenJDK <https://adoptopenjdk.net/>`_ .
 For MacOS you can use the Homebrew system to install a recent version of OpenJDK.

docs/source/todo.rst

@@ -2,9 +2,10 @@
 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.
 - make it possible to use cpu opcodes such as 'nop' as variable names by prefixing all asm vars with something such as '_'
 - option to load the built-in library files from a directory instead of the embedded ones (for easier library development/debugging)
-- see if we can group some errors together for instance the (now single) errors about unidentified symbols
 - use VIC banking to move up the graphics bitmap memory location. Move it to $e000 under the kernal rom?
 - some support for recursive subroutines?
     - via %option recursive?: allocate all params and local vars on estack, don't allow nested subroutines, can begin by first not allowing any local variables just fixing the parameters

examples/arithmetic/minus.p8

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

examples/cmp/word_comps.p8

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

examples/cube3d-sprites.p8

@@ -3,6 +3,7 @@
 %import textio
 %import test_stack
 
+
 spritedata $2000 {
     ; this memory block contains the sprite data
     ; it must start on an address aligned to 64 bytes.

examples/cube3d.p8

@@ -3,6 +3,7 @@
 %import test_stack
 %import textio
 
+
 main {
 
     ; vertices

examples/mandelbrot-gfx.p8

@@ -45,6 +45,7 @@ main {
             }
         }
 
+        ; graphics.disable_bitmap_mode()
         ; test_stack.test()
 
         repeat {

examples/plasma.p8

@@ -10,6 +10,7 @@
 ;  Converted to prog8 by Irmen de Jong.
 
 
+
 main {
     const uword SCREEN1 = $E000
     const uword SCREEN2 = $E400
@@ -27,7 +28,7 @@ main {
         ; ubyte v = c64.VMCSB
         c64.CIA2PRA = (block & $FC) | (lsb(SCREEN1 >> 14) ^ $03)
 
-        repeat 100 {
+        repeat {
             doplasma(SCREEN1)
             c64.VMCSB = PAGE1
             doplasma(SCREEN2)

examples/test.p8

@@ -6,43 +6,6 @@
 main {
 
     sub start() {
-
-        ubyte[]  ubarray = [1,2,3,4]
-        byte[]  barray = [1,2,3,4]
-        uword[]  uwarray = [1,2,3,4]
-        word[]  warray = [1,2,3,4]
-        float[]  farray = [1.1,2.2,3.3,4.4]
-
-        ubyte ub
-        byte bb
-        uword uw
-        word ww
-        float fl
-
-        const ubyte i = 2
-        const ubyte j = 3
-
-        ub = ubarray[i]
-        txt.print_ub(ub)
-        txt.chrout('\n')
-
-        bb = barray[i]
-        txt.print_b(bb)
-        txt.chrout('\n')
-
-        uw = uwarray[i]
-        txt.print_uw(uw)
-        txt.chrout('\n')
-
-        ww = warray[i]
-        txt.print_w(ww)
-        txt.chrout('\n')
-
-        fl = farray[i]
-        floats.print_f(fl)
-        txt.chrout('\n')
-
-        test_stack.test()
-        txt.chrout('\n')
     }
+
 }

examples/turtle-gfx.p8

@@ -49,7 +49,7 @@ turtle {
         uword xx = xpos as uword
         c64.SPXY[0] = lsb(xx) + 12
         c64.MSIGX = msb(xx) > 0
-        c64.SPXY[1] = ypos as ubyte + 37
+        c64.SPXY[1] = ypos as ubyte + 40
     }
 
     sub pos(float x, float y) {

parser/build.gradle

@@ -3,8 +3,8 @@ plugins {
     id 'java'
 }
 
-targetCompatibility = 1.8
-sourceCompatibility = 1.8
+targetCompatibility = 11
+sourceCompatibility = 11
 
 repositories {
     mavenCentral()