version 3.2

.travis.yml

@@ -4,8 +4,8 @@ sudo: false
 # dist: xenial
 
 before_install:
-  - chmod +x gradlew
+  - chmod +x ./gradlew
 
 script:
-  - gradle test
+  - ./gradlew test
 

README.md

@@ -77,7 +77,7 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
 
             c64scr.print("prime numbers up to 255:\n\n")
             ubyte amount=0
-            while true {
+            repeat {
                 ubyte prime = find_next_prime()
                 if prime==0
                     break

compiler/build.gradle

@@ -1,11 +1,11 @@
 buildscript {
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.72"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.0"
     }
 }
 
 plugins {
-    // id "org.jetbrains.kotlin.jvm" version "1.3.72"
+    // id "org.jetbrains.kotlin.jvm" version "1.4.0"
     id 'application'
     id 'org.jetbrains.dokka' version "0.9.18"
     id 'com.github.johnrengelman.shadow' version '5.2.0'
@@ -110,3 +110,7 @@ dokka {
     outputFormat = 'html'
     outputDirectory = "$buildDir/kdoc"
 }
+
+task wrapper(type: Wrapper) {
+    gradleVersion = '6.1.1'
+}

compiler/res/prog8lib/c64floats.asm

@@ -201,6 +201,16 @@ pop_float_fac1	.proc
 		jmp  MOVFM
 		.pend
 
+pop_float_fac2	.proc
+		; -- pops float from stack into FAC2
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  pop_float
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jmp  CONUPK
+		.pend
+
 pop_float_to_indexed_var	.proc
 		; -- pop the float on the stack, to the memory in the array at A/Y indexed by the byte on stack
 		sta  c64.SCRATCH_ZPWORD1
@@ -215,23 +225,13 @@ pop_float_to_indexed_var	.proc
 copy_float	.proc
 		; -- copies the 5 bytes of the mflt value pointed to by SCRATCH_ZPWORD1,
 		;    into the 5 bytes pointed to by A/Y.  Clobbers A,Y.
-		sta  c64.SCRATCH_ZPWORD2
-		sty  c64.SCRATCH_ZPWORD2+1
-		ldy  #0
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  (c64.SCRATCH_ZPWORD2),y
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  (c64.SCRATCH_ZPWORD2),y
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  (c64.SCRATCH_ZPWORD2),y
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  (c64.SCRATCH_ZPWORD2),y
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  (c64.SCRATCH_ZPWORD2),y
+		sta  _target+1
+		sty  _target+2
+		ldy  #4
+_loop		lda  (c64.SCRATCH_ZPWORD1),y
+_target		sta  $ffff,y			; modified
+		dey
+		bpl  _loop
 		rts
 		.pend
 
@@ -772,7 +772,6 @@ set_array_float		.proc
 		asl  a
 		clc
 		adc  c64.ESTACK_LO,x
-		clc
 		adc  c64.SCRATCH_ZPWORD2
 		ldy  c64.SCRATCH_ZPWORD2+1
 		bcc  +

compiler/res/prog8lib/math.asm

@@ -52,6 +52,7 @@ multiply_words	.proc
 	; -- multiply two 16-bit words into a 32-bit result  (signed and unsigned)
 	;      input: A/Y = first 16-bit number, c64.SCRATCH_ZPWORD1 in ZP = second 16-bit number
 	;      output: multiply_words.result  4-bytes/32-bits product, LSB order (low-to-high)
+	;      clobbers: A
 
 		sta  c64.SCRATCH_ZPWORD2
 		sty  c64.SCRATCH_ZPWORD2+1

compiler/res/prog8lib/prog8lib.asm

@@ -36,13 +36,26 @@ init_system	.proc
 		.pend
 
 
-read_byte_from_address	.proc
+read_byte_from_address_on_stack	.proc
 	; -- read the byte from the memory address on the top of the stack, return in A (stack remains unchanged)
 		lda  c64.ESTACK_LO+1,x
 		ldy  c64.ESTACK_HI+1,x
-		sta  (+) +1
-		sty  (+) +2
-+		lda  $ffff		; modified
+		sta  c64.SCRATCH_ZPWORD2
+		sty  c64.SCRATCH_ZPWORD2+1
+		ldy  #0
+		lda  (c64.SCRATCH_ZPWORD2),y
+		rts
+		.pend
+
+
+write_byte_to_address_on_stack	.proc
+	; -- write the byte in A to the memory address on the top of the stack (stack remains unchanged)
+		ldy  c64.ESTACK_LO+1,x
+		sty  c64.SCRATCH_ZPWORD2
+		ldy  c64.ESTACK_HI+1,x
+		sty  c64.SCRATCH_ZPWORD2+1
+		ldy  #0
+		sta  (c64.SCRATCH_ZPWORD2),y
 		rts
 		.pend
 
@@ -330,9 +343,7 @@ mul_word	.proc
 		sta  c64.SCRATCH_ZPWORD1+1
 		lda  c64.ESTACK_LO+1,x
 		ldy  c64.ESTACK_HI+1,x
-		stx  c64.SCRATCH_ZPREGX
 		jsr  math.multiply_words
-		ldx  c64.SCRATCH_ZPREGX
 		lda  math.multiply_words.result
 		sta  c64.ESTACK_LO+1,x
 		lda  math.multiply_words.result+1
@@ -2079,7 +2090,7 @@ ror2_array_uw	.proc
 +		rts
 		.pend
 
-		
+
 strcpy		.proc
 		; copy a string (0-terminated) from A/Y to (ZPWORD1)
 		; it is assumed the target string is large enough.
@@ -2092,8 +2103,8 @@ strcpy		.proc
 		bne  -
 		rts
 		.pend
-		
-		
+
+
 func_leftstr	.proc
 		; leftstr(source, target, length) with params on stack
 		inx
@@ -2175,12 +2186,12 @@ func_substr	.proc
 		lda  c64.ESTACK_LO,x	; start
 		sta  c64.SCRATCH_ZPB1
 		inx
-		lda  c64.ESTACK_LO,x	
+		lda  c64.ESTACK_LO,x
 		sta  c64.SCRATCH_ZPWORD2
 		lda  c64.ESTACK_HI,x
 		sta  c64.SCRATCH_ZPWORD2+1
 		inx
-		lda  c64.ESTACK_LO,x	
+		lda  c64.ESTACK_LO,x
 		sta  c64.SCRATCH_ZPWORD1
 		lda  c64.ESTACK_HI,x
 		sta  c64.SCRATCH_ZPWORD1+1

compiler/res/version.txt

@@ -1 +1 @@
-3.0
+3.2

compiler/src/prog8/ast/AstToSourceCode.kt

@@ -287,12 +287,17 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
     }
 
     override fun visit(assignment: Assignment) {
-        assignment.target.accept(this)
-        if (assignment.aug_op != null && assignment.aug_op != "setvalue")
-            output(" ${assignment.aug_op} ")
-        else
+        val binExpr = assignment.value as? BinaryExpression
+        if(binExpr!=null && binExpr.left isSameAs assignment.target) {
+            // we only support the inplace assignments of the form A = A <operator> <value>
+            assignment.target.accept(this)
+            output(" ${binExpr.operator}= ")
+            binExpr.right.accept(this)
+        } else {
+            assignment.target.accept(this)
             output(" = ")
-        assignment.value.accept(this)
+            assignment.value.accept(this)
+        }
     }
 
     override fun visit(postIncrDecr: PostIncrDecr) {
@@ -300,10 +305,6 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
         output(postIncrDecr.operator)
     }
 
-    override fun visit(contStmt: Continue) {
-        output("continue")
-    }
-
     override fun visit(breakStmt: Break) {
         output("break")
     }

compiler/src/prog8/ast/AstToplevel.kt

@@ -314,9 +314,9 @@ class GlobalNamespace(val modules: List<Module>): Node, INameScope {
         }
         // lookup something from the module.
         return when (val stmt = localContext.definingModule().lookup(scopedName, localContext)) {
-            is Label, is VarDecl, is Block, is Subroutine -> stmt
+            is Label, is VarDecl, is Block, is Subroutine, is StructDecl -> stmt
             null -> null
-            else -> throw SyntaxError("wrong identifier target for $scopedName: $stmt", stmt.position)
+            else -> throw SyntaxError("invalid identifier target type", stmt.position)
         }
     }
 }

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

@@ -161,14 +161,15 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
     if(vardecl!=null) return vardecl
 
     assignment()?.let {
-        return Assignment(it.assign_target().toAst(), null, it.expression().toAst(), it.toPosition())
+        return Assignment(it.assign_target().toAst(), it.expression().toAst(), it.toPosition())
     }
 
     augassignment()?.let {
-        return Assignment(it.assign_target().toAst(),
-                it.operator.text,
-                it.expression().toAst(),
-                it.toPosition())
+        // replace A += X  with  A = A + X
+        val target = it.assign_target().toAst()
+        val oper = it.operator.text.substringBefore('=')
+        val expression = BinaryExpression(target.toExpression(), oper, it.expression().toAst(), it.expression().toPosition())
+        return Assignment(it.assign_target().toAst(), expression, it.toPosition())
     }
 
     postincrdecr()?.let {
@@ -217,9 +218,6 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
     val breakstmt = breakstmt()?.toAst()
     if(breakstmt!=null) return breakstmt
 
-    val continuestmt = continuestmt()?.toAst()
-    if(continuestmt!=null) return continuestmt
-
     val whenstmt = whenstmt()?.toAst()
     if(whenstmt!=null) return whenstmt
 
@@ -304,7 +302,7 @@ private fun prog8Parser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParamete
         when (val name = register.nameInSource.single()) {
             in RegisterOrPair.names -> registerorpair = RegisterOrPair.valueOf(name)
             in Statusflag.names -> statusregister = Statusflag.valueOf(name)
-            else -> throw FatalAstException("invalid register or status flag in $it")
+            else -> throw FatalAstException("invalid register or status flag '$name'")
         }
     }
     AsmSubroutineParameter(vardecl.varname.text, datatype, registerorpair, statusregister,
@@ -593,8 +591,6 @@ private fun prog8Parser.ForloopContext.toAst(): ForLoop {
     return ForLoop(loopvar, iterable, scope, toPosition())
 }
 
-private fun prog8Parser.ContinuestmtContext.toAst() = Continue(toPosition())
-
 private fun prog8Parser.BreakstmtContext.toAst() = Break(toPosition())
 
 private fun prog8Parser.WhileloopContext.toAst(): WhileLoop {

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

@@ -58,7 +58,7 @@ enum class DataType {
             in ByteDatatypes -> 1
             in WordDatatypes -> 2
             FLOAT -> CompilationTarget.machine.FLOAT_MEM_SIZE
-            in PassByReferenceDatatypes -> 2
+            in PassByReferenceDatatypes -> CompilationTarget.machine.POINTER_MEM_SIZE
             else -> -9999999
         }
     }

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

@@ -5,7 +5,6 @@ import prog8.ast.Program
 import prog8.ast.processing.*
 import prog8.compiler.CompilationOptions
 import prog8.compiler.BeforeAsmGenerationAstChanger
-import prog8.optimizer.AssignmentTransformer
 
 
 internal fun Program.checkValid(compilerOptions: CompilationOptions, errors: ErrorReporter) {
@@ -36,17 +35,6 @@ internal fun Program.verifyFunctionArgTypes() {
     fixer.visit(this)
 }
 
-internal fun Program.transformAssignments(errors: ErrorReporter) {
-    val transform = AssignmentTransformer(this, errors)
-    transform.visit(this)
-    while(transform.optimizationsDone>0 && errors.isEmpty()) {
-        transform.applyModifications()
-        transform.optimizationsDone = 0
-        transform.visit(this)
-    }
-    transform.applyModifications()
-}
-
 internal fun Module.checkImportedValid() {
     val imr = ImportedModuleDirectiveRemover()
     imr.visit(this, this.parent)

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

@@ -25,6 +25,8 @@ sealed class Expression: Node {
     abstract fun referencesIdentifiers(vararg name: String): Boolean
     abstract fun inferType(program: Program): InferredTypes.InferredType
 
+    infix fun isSameAs(assigntarget: AssignTarget) = assigntarget.isSameAs(this)
+
     infix fun isSameAs(other: Expression): Boolean {
         if(this===other)
             return true
@@ -41,6 +43,23 @@ sealed class Expression: Node {
                 (other is ArrayIndexedExpression && other.identifier.nameInSource == identifier.nameInSource
                         && other.arrayspec.index isSameAs arrayspec.index)
             }
+            is DirectMemoryRead -> {
+                (other is DirectMemoryRead && other.addressExpression isSameAs addressExpression)
+            }
+            is TypecastExpression -> {
+                (other is TypecastExpression && other.implicit==implicit && other.type==type && other.expression isSameAs expression)
+            }
+            is AddressOf -> {
+                (other is AddressOf && other.identifier.nameInSource == identifier.nameInSource)
+            }
+            is RangeExpr -> {
+                (other is RangeExpr && other.from==from && other.to==to && other.step==step)
+            }
+            is FunctionCall -> {
+                (other is FunctionCall && other.target.nameInSource == target.nameInSource
+                        && other.args.size == args.size
+                        && other.args.zip(args).all { it.first isSameAs it.second } )
+            }
             else -> other==this
         }
     }
@@ -275,7 +294,7 @@ class TypecastExpression(var expression: Expression, var type: DataType, val imp
     override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(type)
     override fun constValue(program: Program): NumericLiteralValue? {
         val cv = expression.constValue(program) ?: return null
-        return cv.cast(type)
+        return cv.castNoCheck(type)
         // val value = RuntimeValue(cv.type, cv.asNumericValue!!).cast(type)
         // return LiteralValue.fromNumber(value.numericValue(), value.type, position).cast(type)
     }
@@ -396,7 +415,7 @@ class NumericLiteralValue(val type: DataType,    // only numerical types allowed
 
     operator fun compareTo(other: NumericLiteralValue): Int = number.toDouble().compareTo(other.number.toDouble())
 
-    fun cast(targettype: DataType): NumericLiteralValue {
+    fun castNoCheck(targettype: DataType): NumericLiteralValue {
         if(type==targettype)
             return this
         val numval = number.toDouble()
@@ -565,7 +584,7 @@ class ArrayLiteralValue(val type: InferredTypes.InferredType,     // inferred be
                     it
                 } else {
                     try {
-                        num.cast(elementType)
+                        num.castNoCheck(elementType)
                     } catch(x: ExpressionError) {
                         return null
                     }
@@ -714,11 +733,10 @@ data class IdentifierReference(val nameInSource: List<String>, override val posi
     override fun referencesIdentifiers(vararg name: String): Boolean = nameInSource.last() in name
 
     override fun inferType(program: Program): InferredTypes.InferredType {
-        val targetStmt = targetStatement(program.namespace)
-        return if(targetStmt is VarDecl) {
-            InferredTypes.knownFor(targetStmt.datatype)
-        } else {
-            InferredTypes.InferredType.unknown()
+        return when (val targetStmt = targetStatement(program.namespace)) {
+            is VarDecl -> InferredTypes.knownFor(targetStmt.datatype)
+            is StructDecl -> InferredTypes.knownFor(DataType.STRUCT)
+            else -> InferredTypes.InferredType.unknown()
         }
     }
 

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

@@ -304,13 +304,11 @@ internal class AstChecker(private val program: Program,
         } else {
             // Pass-by-reference datatypes can not occur as parameters to a subroutine directly
             // Instead, their reference (address) should be passed (as an UWORD).
-            // The language has no typed pointers at this time.
+            // TODO The language has no (typed) pointers at this time.  Should this be handled better?
             if(subroutine.parameters.any{it.type in PassByReferenceDatatypes }) {
-                err("Pass-by-reference types (str, array) cannot occur as a parameter type directly. Instead, use an uword for their address, or access the variable from the outer scope directly.")
+                err("Pass-by-reference types (str, array) cannot occur as a parameter type directly. Instead, use an uword to receive their address, or access the variable from the outer scope directly.")
             }
         }
-
-        visitStatements(subroutine.statements)
     }
 
     override fun visit(untilLoop: UntilLoop) {
@@ -362,9 +360,15 @@ internal class AstChecker(private val program: Program,
             }
         }
 
-        if(assignment.value.inferType(program) != assignment.target.inferType(program, assignment))
+        val targetDt = assignment.target.inferType(program, assignment)
+        if(assignment.value.inferType(program) != targetDt)
             errors.err("assignment value is of different type as the target", assignment.value.position)
 
+        if(assignment.value is TypecastExpression) {
+            if(assignment.isAugmentable && targetDt.istype(DataType.FLOAT))
+                errors.err("typecasting a float value in-place makes no sense", assignment.value.position)
+        }
+
         super.visit(assignment)
     }
 
@@ -434,7 +438,9 @@ internal class AstChecker(private val program: Program,
         if(variable==null)
             errors.err("pointer-of operand must be the name of a heap variable", addressOf.position)
         else {
-            if(variable.datatype !in ArrayDatatypes && variable.datatype != DataType.STR && variable.datatype!=DataType.STRUCT)
+            if(variable.datatype !in ArrayDatatypes
+                    && variable.type!=VarDeclType.MEMORY
+                    && variable.datatype != DataType.STR && variable.datatype!=DataType.STRUCT)
                 errors.err("invalid pointer-of operand type", addressOf.position)
         }
         super.visit(addressOf)
@@ -492,8 +498,7 @@ internal class AstChecker(private val program: Program,
 
                 when(decl.value) {
                     null -> {
-                        // a vardecl without an initial value, don't bother with the rest
-                        return super.visit(decl)
+                        // a vardecl without an initial value, don't bother with it
                     }
                     is RangeExpr -> throw FatalAstException("range expression should have been converted to a true array value")
                     is StringLiteralValue -> {
@@ -577,6 +582,26 @@ internal class AstChecker(private val program: Program,
             }
         }
 
+        // array length limits
+        if(decl.isArray) {
+            val length = decl.arraysize!!.size() ?: 1
+            when (decl.datatype) {
+                DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                    if(length==0 || length>256)
+                        err("string and byte array length must be 1-256")
+                }
+                DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                    if(length==0 || length>128)
+                        err("word array length must be 1-128")
+                }
+                DataType.ARRAY_F -> {
+                    if(length==0 || length>51)
+                        err("float array length must be 1-51")
+                }
+                else -> {}
+            }
+        }
+
         super.visit(decl)
     }
 
@@ -691,12 +716,20 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(expr: PrefixExpression) {
+        val dt = expr.inferType(program).typeOrElse(DataType.STRUCT)
         if(expr.operator=="-") {
-            val dt = expr.inferType(program).typeOrElse(DataType.STRUCT)
             if (dt != DataType.BYTE && dt != DataType.WORD && dt != DataType.FLOAT) {
                 errors.err("can only take negative of a signed number type", expr.position)
             }
         }
+        else if(expr.operator == "not") {
+            if(dt !in IntegerDatatypes)
+                errors.err("can only use boolean not on integer types", expr.position)
+        }
+        else if(expr.operator == "~") {
+            if(dt !in IntegerDatatypes)
+                errors.err("can only use bitwise invert on integer types", expr.position)
+        }
         super.visit(expr)
     }
 
@@ -739,7 +772,7 @@ internal class AstChecker(private val program: Program,
                     errors.err("bitwise operator can only be used on integer operands", expr.right.position)
             }
             "<<", ">>" -> {
-                // for now, bit-shifts can only shift by a constant number
+                // for now, bit-shifts can only shift by a constant number  TODO remove this restriction
                 val constRight = expr.right.constValue(program)
                 if(constRight==null)
                     errors.err("bit-shift can only be done by a constant number (for now)", expr.right.position)
@@ -810,6 +843,10 @@ internal class AstChecker(private val program: Program,
                 errors.warn("sgn() of unsigned type is always 0 or 1, this is perhaps not what was intended", functionCall.args.first().position)
         }
 
+        val error = VerifyFunctionArgTypes.checkTypes(functionCall, functionCall.definingScope(), program)
+        if(error!=null)
+            errors.err(error, functionCall.args.first().position)
+
         super.visit(functionCall)
     }
 
@@ -838,6 +875,12 @@ internal class AstChecker(private val program: Program,
                 errors.err("invalid argument to a in-place modifying function", functionCallStatement.args.first().position)
             }
         }
+
+        val error = VerifyFunctionArgTypes.checkTypes(functionCallStatement, functionCallStatement.definingScope(), program)
+        if(error!=null) {
+            errors.err(error, functionCallStatement.args.firstOrNull()?.position ?: functionCallStatement.position)
+        }
+
         super.visit(functionCallStatement)
     }
 
@@ -846,79 +889,38 @@ internal class AstChecker(private val program: Program,
             errors.err("cannot use arguments when calling a label", position)
 
         if(target is BuiltinFunctionStatementPlaceholder) {
-            // it's a call to a builtin function.
-            val func = BuiltinFunctions.getValue(target.name)
-            if(args.size!=func.parameters.size)
-                errors.err("invalid number of arguments", position)
-            else {
-                val paramTypesForAddressOf = PassByReferenceDatatypes + DataType.UWORD
-                for (arg in args.withIndex().zip(func.parameters)) {
-                    val argDt=arg.first.value.inferType(program)
-                    if (argDt.isKnown
-                            && !(argDt.typeOrElse(DataType.STRUCT) isAssignableTo arg.second.possibleDatatypes)
-                            && (argDt.typeOrElse(DataType.STRUCT) != DataType.UWORD || arg.second.possibleDatatypes.intersect(paramTypesForAddressOf).isEmpty())) {
-                        errors.err("builtin function '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.possibleDatatypes}", position)
-                    }
+            if(target.name=="swap") {
+                // swap() is a bit weird because this one is translated into a operations directly, instead of being a function call
+                val dt1 = args[0].inferType(program)
+                val dt2 = args[1].inferType(program)
+                if (dt1 != dt2)
+                    errors.err("swap requires 2 args of identical type", position)
+                else if (args[0].constValue(program) != null || args[1].constValue(program) != null)
+                    errors.err("swap requires 2 variables, not constant value(s)", position)
+                else if(args[0] isSameAs args[1])
+                    errors.err("swap should have 2 different args", position)
+                else if(dt1.typeOrElse(DataType.STRUCT) !in NumericDatatypes)
+                    errors.err("swap requires args of numerical type", position)
+            }
+            else if(target.name=="all" || target.name=="any") {
+                if((args[0] as? AddressOf)?.identifier?.targetVarDecl(program.namespace)?.datatype == DataType.STR) {
+                    errors.err("any/all on a string is useless (is always true unless the string is empty)", position)
                 }
-                if(target.name=="swap") {
-                    // swap() is a bit weird because this one is translated into a operations directly, instead of being a function call
-                    val dt1 = args[0].inferType(program)
-                    val dt2 = args[1].inferType(program)
-                    if (dt1 != dt2)
-                        errors.err("swap requires 2 args of identical type", position)
-                    else if (args[0].constValue(program) != null || args[1].constValue(program) != null)
-                        errors.err("swap requires 2 variables, not constant value(s)", position)
-                    else if(args[0] isSameAs args[1])
-                        errors.err("swap should have 2 different args", position)
-                    else if(dt1.typeOrElse(DataType.STRUCT) !in NumericDatatypes)
-                        errors.err("swap requires args of numerical type", position)
-                }
-                else if(target.name=="all" || target.name=="any") {
-                    if((args[0] as? AddressOf)?.identifier?.targetVarDecl(program.namespace)?.datatype == DataType.STR) {
-                        errors.err("any/all on a string is useless (is always true unless the string is empty)", position)
-                    }
-                    if(args[0].inferType(program).typeOrElse(DataType.STR) == DataType.STR) {
-                        errors.err("any/all on a string is useless (is always true unless the string is empty)", position)
-                    }
+                if(args[0].inferType(program).typeOrElse(DataType.STR) == DataType.STR) {
+                    errors.err("any/all on a string is useless (is always true unless the string is empty)", position)
                 }
             }
         } else if(target is Subroutine) {
             if(target.regXasResult())
                 errors.warn("subroutine call return value in X register is discarded and replaced by 0", position)
-            if(args.size!=target.parameters.size)
-                errors.err("invalid number of arguments", position)
-            else {
+            if(target.isAsmSubroutine) {
                 for (arg in args.withIndex().zip(target.parameters)) {
                     val argIDt = arg.first.value.inferType(program)
-                    if(!argIDt.isKnown) {
+                    if (!argIDt.isKnown)
                         return
-                    }
-                    val argDt=argIDt.typeOrElse(DataType.STRUCT)
-                    if(!(argDt isAssignableTo arg.second.type)) {
-                        // for asm subroutines having STR param it's okay to provide a UWORD (address value)
-                        if(!(target.isAsmSubroutine && arg.second.type == DataType.STR && argDt == DataType.UWORD))
-                            errors.err("subroutine '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.type}", position)
-                    }
-
-                    if(target.isAsmSubroutine) {
-                        if (target.asmParameterRegisters[arg.first.index].registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.XY, RegisterOrPair.X)) {
-                            if (arg.first.value !is NumericLiteralValue && arg.first.value !is IdentifierReference)
-                                errors.warn("calling a subroutine that expects X as a parameter is problematic. If you see a compiler error/crash about this later, try to change this call", position)
-                        }
-
-                        // check if the argument types match the register(pairs)
-                        val asmParamReg = target.asmParameterRegisters[arg.first.index]
-                        if(asmParamReg.statusflag!=null) {
-                            if(argDt !in ByteDatatypes)
-                                errors.err("subroutine '${target.name}' argument ${arg.first.index + 1} must be byte type for statusflag", position)
-                        } else if(asmParamReg.registerOrPair in setOf(RegisterOrPair.A, RegisterOrPair.X, RegisterOrPair.Y)) {
-                            if(argDt !in ByteDatatypes)
-                                errors.err("subroutine '${target.name}' argument ${arg.first.index + 1} must be byte type for single register", position)
-                        } else if(asmParamReg.registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY)) {
-                            if(argDt !in WordDatatypes + IterableDatatypes)
-                                errors.err("subroutine '${target.name}' argument ${arg.first.index + 1} must be word type for register pair", position)
-                        }
-                    }
+                    if (target.asmParameterRegisters[arg.first.index].registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.XY, RegisterOrPair.X)
+                            && arg.first.value !is NumericLiteralValue && arg.first.value !is IdentifierReference)
+                        errors.warn("calling a subroutine that expects X as a parameter is problematic. If you see a compiler error/crash about this later, try to change this call", position)
                 }
             }
         }
@@ -1039,30 +1041,6 @@ internal class AstChecker(private val program: Program,
         }
     }
 
-    override fun visit(scope: AnonymousScope) {
-        visitStatements(scope.statements)
-    }
-
-    private fun visitStatements(statements: List<Statement>) {
-        for((index, stmt) in statements.withIndex()) {
-            if(index < statements.lastIndex && statements[index+1] !is Subroutine) {
-                when {
-                    stmt is FunctionCallStatement && stmt.target.nameInSource.last() == "exit" -> {
-                        errors.warn("unreachable code, preceding exit call will never return", statements[index + 1].position)
-                    }
-                    stmt is Return && statements[index + 1] !is Subroutine -> {
-                        errors.warn("unreachable code, preceding return statement", statements[index + 1].position)
-                    }
-                    stmt is Jump && statements[index + 1] !is Subroutine -> {
-                        errors.warn("unreachable code, preceding jump statement", statements[index + 1].position)
-                    }
-                }
-            }
-
-            stmt.accept(this)
-        }
-    }
-
     private fun checkFunctionOrLabelExists(target: IdentifierReference, statement: Statement): Statement? {
         val targetStatement = target.targetStatement(program.namespace)
         if(targetStatement is Label || targetStatement is Subroutine || targetStatement is BuiltinFunctionStatementPlaceholder)
@@ -1237,7 +1215,7 @@ internal class AstChecker(private val program: Program,
                 is AddressOf -> it.identifier.heapId(program.namespace)
                 is TypecastExpression -> {
                     val constVal = it.expression.constValue(program)
-                    constVal?.cast(it.type)?.number?.toInt() ?: -9999999
+                    constVal?.castNoCheck(it.type)?.number?.toInt() ?: -9999999
                 }
                 else -> -9999999
             }

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

@@ -26,19 +26,16 @@ internal class AstVariousTransforms(private val program: Program) : AstWalker()
                 val tempvar = IdentifierReference(listOf(tempname), first.position)
                 val assignTemp = Assignment(
                         AssignTarget(tempvar, null, null, first.position),
-                        null,
                         first,
                         first.position
                 )
                 val assignFirst = Assignment(
                         AssignTarget.fromExpr(first),
-                        null,
                         second,
                         first.position
                 )
                 val assignSecond = Assignment(
                         AssignTarget.fromExpr(second),
-                        null,
                         tempvar,
                         first.position
                 )
@@ -50,18 +47,6 @@ internal class AstVariousTransforms(private val program: Program) : AstWalker()
         return noModifications
     }
 
-    override fun before(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> {
-        if(functionCall.target.nameInSource.size==1 && functionCall.target.nameInSource[0]=="lsb") {
-            // lsb(...) is just an alias for type cast to ubyte, so replace with "... as ubyte"
-            val typecast = TypecastExpression(functionCall.args.single(), DataType.UBYTE, false, functionCall.position)
-            return listOf(IAstModification.ReplaceNode(
-                    functionCall, typecast, parent
-            ))
-        }
-
-        return noModifications
-    }
-
     override fun before(decl: VarDecl, parent: Node): Iterable<IAstModification> {
         // is it a struct variable? then define all its struct members as mangled names,
         //    and include the original decl as well.

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

@@ -88,7 +88,6 @@ abstract class AstWalker {
     open fun before(branchStatement: BranchStatement, parent: Node): Iterable<IAstModification> = emptyList()
     open fun before(breakStmt: Break, parent: Node): Iterable<IAstModification> = emptyList()
     open fun before(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder, parent: Node): Iterable<IAstModification> = emptyList()
-    open fun before(contStmt: Continue, parent: Node): Iterable<IAstModification> = emptyList()
     open fun before(decl: VarDecl, parent: Node): Iterable<IAstModification> = emptyList()
     open fun before(directive: Directive, parent: Node): Iterable<IAstModification> = emptyList()
     open fun before(expr: BinaryExpression, parent: Node): Iterable<IAstModification> = emptyList()
@@ -130,7 +129,6 @@ abstract class AstWalker {
     open fun after(branchStatement: BranchStatement, parent: Node): Iterable<IAstModification> = emptyList()
     open fun after(breakStmt: Break, parent: Node): Iterable<IAstModification> = emptyList()
     open fun after(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder, parent: Node): Iterable<IAstModification> = emptyList()
-    open fun after(contStmt: Continue, parent: Node): Iterable<IAstModification> = emptyList()
     open fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> = emptyList()
     open fun after(directive: Directive, parent: Node): Iterable<IAstModification> = emptyList()
     open fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> = emptyList()
@@ -309,11 +307,6 @@ abstract class AstWalker {
         track(after(postIncrDecr, parent), postIncrDecr, parent)
     }
 
-    fun visit(contStmt: Continue, parent: Node) {
-        track(before(contStmt, parent), contStmt, parent)
-        track(after(contStmt, parent), contStmt, parent)
-    }
-
     fun visit(breakStmt: Break, parent: Node) {
         track(before(breakStmt, parent), breakStmt, parent)
         track(after(breakStmt, parent), breakStmt, parent)

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

@@ -95,9 +95,6 @@ interface IAstVisitor {
         postIncrDecr.target.accept(this)
     }
 
-    fun visit(contStmt: Continue) {
-    }
-
     fun visit(breakStmt: Break) {
     }
 

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

@@ -14,8 +14,8 @@ internal class StatementReorderer(val program: Program) : AstWalker() {
     // - in every scope, most directives and vardecls are moved to the top.
     // - the 'start' subroutine is moved to the top.
     // - (syntax desugaring) a vardecl with a non-const initializer value is split into a regular vardecl and an assignment statement.
-    // - (syntax desugaring) augmented assignment is turned into regular assignment.
     // - (syntax desugaring) struct value assignment is expanded into several struct member assignments.
+    // - in-place assignments are reordered a bit so that they are mostly of the form A = A <operator> <rest>
     // - sorts the choices in when statement.
     // - insert AddressOf (&) expression where required (string params to a UWORD function param etc).
 
@@ -79,7 +79,7 @@ internal class StatementReorderer(val program: Program) : AstWalker() {
                 // move the vardecl (without value) to the scope and replace this with a regular assignment
                 decl.value = null
                 val target = AssignTarget(IdentifierReference(listOf(decl.name), decl.position), null, null, decl.position)
-                val assign = Assignment(target, null, declValue, decl.position)
+                val assign = Assignment(target, declValue, decl.position)
                 return listOf(
                         IAstModification.ReplaceNode(decl, assign, parent),
                         IAstModification.InsertFirst(decl, decl.definingScope() as Node)
@@ -99,10 +99,6 @@ internal class StatementReorderer(val program: Program) : AstWalker() {
     }
 
     override fun before(assignment: Assignment, parent: Node): Iterable<IAstModification> {
-        if(assignment.aug_op!=null) {
-            return listOf(IAstModification.ReplaceNode(assignment, assignment.asDesugaredNonaugmented(), parent))
-        }
-
         val valueType = assignment.value.inferType(program)
         val targetType = assignment.target.inferType(program, assignment)
         if(valueType.istype(DataType.STRUCT) && targetType.istype(DataType.STRUCT)) {
@@ -122,6 +118,55 @@ internal class StatementReorderer(val program: Program) : AstWalker() {
         return noModifications
     }
 
+    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
+        // rewrite in-place assignment expressions a bit so that the assignment target usually is the leftmost operand
+        val binExpr = assignment.value as? BinaryExpression
+        if(binExpr!=null) {
+            if(binExpr.left isSameAs assignment.target) {
+                // A = A <operator> 5, unchanged
+                return noModifications
+            }
+
+            if(binExpr.operator in associativeOperators) {
+                if (binExpr.right isSameAs assignment.target) {
+                    // A = v <associative-operator> A  ==>  A = A <associative-operator> v
+                    return listOf(IAstModification.SwapOperands(binExpr))
+                }
+
+                val leftBinExpr = binExpr.left as? BinaryExpression
+                if(leftBinExpr?.operator == binExpr.operator) {
+                    return if(leftBinExpr.left isSameAs assignment.target) {
+                        // A = (A <associative-operator> x) <same-operator> y ==> A = A <associative-operator> (x <same-operator> y)
+                        val newRight = BinaryExpression(leftBinExpr.right, binExpr.operator, binExpr.right, binExpr.position)
+                        val newValue = BinaryExpression(leftBinExpr.left, binExpr.operator, newRight, binExpr.position)
+                        listOf(IAstModification.ReplaceNode(binExpr, newValue, assignment))
+                    } else {
+                        // A = (x <associative-operator> A) <same-operator> y ==> A = A <associative-operator> (x <same-operator> y)
+                        val newRight = BinaryExpression(leftBinExpr.left, binExpr.operator, binExpr.right, binExpr.position)
+                        val newValue = BinaryExpression(leftBinExpr.right, binExpr.operator, newRight, binExpr.position)
+                        listOf(IAstModification.ReplaceNode(binExpr, newValue, assignment))
+                    }
+                }
+                val rightBinExpr = binExpr.right as? BinaryExpression
+                if(rightBinExpr?.operator == binExpr.operator) {
+                    return if(rightBinExpr.left isSameAs assignment.target) {
+                        // A = x <associative-operator> (A <same-operator> y) ==> A = A <associative-operator> (x <same-operator> y)
+                        val newRight = BinaryExpression(binExpr.left, binExpr.operator, rightBinExpr.right, binExpr.position)
+                        val newValue = BinaryExpression(rightBinExpr.left, binExpr.operator, newRight, binExpr.position)
+                        listOf(IAstModification.ReplaceNode(binExpr, newValue, assignment))
+                    } else {
+                        // A = x <associative-operator> (y <same-operator> A) ==> A = A <associative-operator> (x <same-operator> y)
+                        val newRight = BinaryExpression(binExpr.left, binExpr.operator, rightBinExpr.left, binExpr.position)
+                        val newValue = BinaryExpression(rightBinExpr.right, binExpr.operator, newRight, binExpr.position)
+                        listOf(IAstModification.ReplaceNode(binExpr, newValue, assignment))
+                    }
+                }
+            }
+        }
+
+        return noModifications
+    }
+
     private fun flattenStructAssignmentFromStructLiteral(structAssignment: Assignment, program: Program): List<Assignment> {
         val identifier = structAssignment.target.identifier!!
         val identifierName = identifier.nameInSource.single()
@@ -137,7 +182,7 @@ internal class StatementReorderer(val program: Program) : AstWalker() {
             val mangled = mangledStructMemberName(identifierName, targetDecl.name)
             val idref = IdentifierReference(listOf(mangled), structAssignment.position)
             val assign = Assignment(AssignTarget(idref, null, null, structAssignment.position),
-                    null, sourceValue, sourceValue.position)
+                    sourceValue, sourceValue.position)
             assign.linkParents(structAssignment)
             assign
         }
@@ -168,8 +213,7 @@ internal class StatementReorderer(val program: Program) : AstWalker() {
                     val idref = IdentifierReference(listOf(mangled), structAssignment.position)
                     val sourcemangled = mangledStructMemberName(sourceVar.name, sourceDecl.name)
                     val sourceIdref = IdentifierReference(listOf(sourcemangled), structAssignment.position)
-                    val assign = Assignment(AssignTarget(idref, null, null, structAssignment.position),
-                            null, sourceIdref, member.second.position)
+                    val assign = Assignment(AssignTarget(idref, null, null, structAssignment.position), sourceIdref, member.second.position)
                     assign.linkParents(structAssignment)
                     assign
                 }

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

@@ -52,7 +52,7 @@ class TypecastsAdder(val program: Program, val errors: ErrorReporter) : AstWalke
                             assignment))
                 } else {
                     fun castLiteral(cvalue: NumericLiteralValue): List<IAstModification.ReplaceNode> =
-                        listOf(IAstModification.ReplaceNode(cvalue, cvalue.cast(targettype), cvalue.parent))
+                        listOf(IAstModification.ReplaceNode(cvalue, cvalue.castNoCheck(targettype), cvalue.parent))
                     val cvalue = assignment.value.constValue(program)
                     if(cvalue!=null) {
                         val number = cvalue.number.toDouble()
@@ -109,14 +109,16 @@ class TypecastsAdder(val program: Program, val errors: ErrorReporter) : AstWalke
                                         AddressOf(arg.second.value as IdentifierReference, arg.second.value.position),
                                         call as Node)
                             } else if(arg.second.value is NumericLiteralValue) {
-                                try {
-                                    val castedValue = (arg.second.value as NumericLiteralValue).cast(requiredType)
-                                    modifications += IAstModification.ReplaceNode(
-                                            call.args[arg.second.index],
-                                            castedValue,
-                                            call as Node)
-                                } catch (x: ExpressionError) {
-                                    // no cast possible
+                                if(argtype.isAssignableTo(requiredType)) {
+                                    try {
+                                        val castedValue = (arg.second.value as NumericLiteralValue).castNoCheck(requiredType)
+                                        modifications += IAstModification.ReplaceNode(
+                                                call.args[arg.second.index],
+                                                castedValue,
+                                                call as Node)
+                                    } catch (x: ExpressionError) {
+                                        // cast failed
+                                    }
                                 }
                             }
                         }
@@ -161,7 +163,7 @@ class TypecastsAdder(val program: Program, val errors: ErrorReporter) : AstWalke
         // make sure the memory address is an uword
         val dt = memread.addressExpression.inferType(program)
         if(dt.isKnown && dt.typeOrElse(DataType.UWORD)!=DataType.UWORD) {
-            val typecast = (memread.addressExpression as? NumericLiteralValue)?.cast(DataType.UWORD)
+            val typecast = (memread.addressExpression as? NumericLiteralValue)?.castNoCheck(DataType.UWORD)
                     ?: TypecastExpression(memread.addressExpression, DataType.UWORD, true, memread.addressExpression.position)
             return listOf(IAstModification.ReplaceNode(memread.addressExpression, typecast, memread))
         }
@@ -172,7 +174,7 @@ class TypecastsAdder(val program: Program, val errors: ErrorReporter) : AstWalke
         // make sure the memory address is an uword
         val dt = memwrite.addressExpression.inferType(program)
         if(dt.isKnown && dt.typeOrElse(DataType.UWORD)!=DataType.UWORD) {
-            val typecast = (memwrite.addressExpression as? NumericLiteralValue)?.cast(DataType.UWORD)
+            val typecast = (memwrite.addressExpression as? NumericLiteralValue)?.castNoCheck(DataType.UWORD)
                     ?: TypecastExpression(memwrite.addressExpression, DataType.UWORD, true, memwrite.addressExpression.position)
             return listOf(IAstModification.ReplaceNode(memwrite.addressExpression, typecast, memwrite))
         }
@@ -189,7 +191,7 @@ class TypecastsAdder(val program: Program, val errors: ErrorReporter) : AstWalke
                 if (returnValue.inferType(program).istype(subReturnType))
                     return noModifications
                 if (returnValue is NumericLiteralValue) {
-                    returnStmt.value = returnValue.cast(subroutine.returntypes.single())
+                    returnStmt.value = returnValue.castNoCheck(subroutine.returntypes.single())
                 } else {
                     return listOf(IAstModification.ReplaceNode(
                             returnValue,

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

@@ -34,7 +34,7 @@ internal class VariousCleanups: AstWalker() {
 
     override fun before(typecast: TypecastExpression, parent: Node): Iterable<IAstModification> {
         if(typecast.expression is NumericLiteralValue) {
-            val value = (typecast.expression as NumericLiteralValue).cast(typecast.type)
+            val value = (typecast.expression as NumericLiteralValue).castNoCheck(typecast.type)
             return listOf(IAstModification.ReplaceNode(typecast, value, parent))
         }
 

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

@@ -13,30 +13,49 @@ import prog8.functions.BuiltinFunctions
 
 class VerifyFunctionArgTypes(val program: Program) : IAstVisitor {
 
-    override fun visit(functionCall: FunctionCall)
-            = checkTypes(functionCall as IFunctionCall, functionCall.definingScope())
+    override fun visit(functionCall: FunctionCall) {
+        val error = checkTypes(functionCall as IFunctionCall, functionCall.definingScope(), program)
+        if(error!=null)
+            throw CompilerException(error)
+    }
 
-    override fun visit(functionCallStatement: FunctionCallStatement)
-            = checkTypes(functionCallStatement as IFunctionCall, functionCallStatement.definingScope())
+    override fun visit(functionCallStatement: FunctionCallStatement) {
+        val error = checkTypes(functionCallStatement as IFunctionCall, functionCallStatement.definingScope(), program)
+        if (error!=null)
+            throw CompilerException(error)
+    }
 
-    private fun checkTypes(call: IFunctionCall, scope: INameScope) {
-        val argtypes = call.args.map { it.inferType(program).typeOrElse(DataType.STRUCT) }
-        val target = call.target.targetStatement(scope)
-        when(target) {
-            is Subroutine -> {
+    companion object {
+        fun checkTypes(call: IFunctionCall, scope: INameScope, program: Program): String? {
+            val argtypes = call.args.map { it.inferType(program).typeOrElse(DataType.STRUCT) }
+            val target = call.target.targetStatement(scope)
+            if (target is Subroutine) {
+                // asmsub types are not checked specifically at this time
+                if(call.args.size != target.parameters.size)
+                    return "invalid number of arguments"
                 val paramtypes = target.parameters.map { it.type }
-                if(argtypes!=paramtypes)
-                    throw CompilerException("parameter type mismatch $call")
-            }
-            is BuiltinFunctionStatementPlaceholder -> {
-                val func = BuiltinFunctions.getValue(target.name)
-                val paramtypes = func.parameters.map { it.possibleDatatypes }
-                for(x in argtypes.zip(paramtypes)) {
-                    if(x.first !in x.second)
-                        throw CompilerException("parameter type mismatch $call")
+                val mismatch = argtypes.zip(paramtypes).indexOfFirst { it.first != it.second}
+                if(mismatch>=0) {
+                    val actual = argtypes[mismatch].toString()
+                    val expected = paramtypes[mismatch].toString()
+                    return "argument ${mismatch + 1} type mismatch, was: $actual expected: $expected"
                 }
             }
-            else -> {}
+            else if (target is BuiltinFunctionStatementPlaceholder) {
+                val func = BuiltinFunctions.getValue(target.name)
+                if(call.args.size != func.parameters.size)
+                    return "invalid number of arguments"
+                val paramtypes = func.parameters.map { it.possibleDatatypes }
+                for (x in argtypes.zip(paramtypes).withIndex()) {
+                    if (x.value.first !in x.value.second) {
+                        val actual = x.value.first.toString()
+                        val expected = x.value.second.toString()
+                        return "argument ${x.index + 1} type mismatch, was: $actual expected: $expected"
+                    }
+                }
+            }
+
+            return null
         }
     }
 }

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

@@ -139,27 +139,6 @@ open class Return(var value: Expression?, override val position: Position) : Sta
     }
 }
 
-class ReturnFromIrq(override val position: Position) : Return(null, position) {
-    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
-
-    override fun toString(): String {
-        return "ReturnFromIrq(pos=$position)"
-    }
-    override fun replaceChildNode(node: Node, replacement: Node) = throw FatalAstException("can't replace here")
-}
-
-class Continue(override val position: Position) : Statement() {
-    override lateinit var parent: Node
-
-    override fun linkParents(parent: Node) {
-        this.parent=parent
-    }
-
-    override fun replaceChildNode(node: Node, replacement: Node) = throw FatalAstException("can't replace here")
-    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
-    override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
-}
-
 class Break(override val position: Position) : Statement() {
     override lateinit var parent: Node
 
@@ -324,7 +303,7 @@ class ArrayIndex(var index: Expression, override val position: Position) : Node
     fun size() = (index as? NumericLiteralValue)?.number?.toInt()
 }
 
-open class Assignment(var target: AssignTarget, var aug_op : String?, var value: Expression, override val position: Position) : Statement() {
+open class Assignment(var target: AssignTarget, var value: Expression, override val position: Position) : Statement() {
     override lateinit var parent: Node
 
     override fun linkParents(parent: Node) {
@@ -346,31 +325,55 @@ open class Assignment(var target: AssignTarget, var aug_op : String?, var value:
     override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
 
     override fun toString(): String {
-        return("Assignment(augop: $aug_op, target: $target, value: $value, pos=$position)")
+        return("Assignment(target: $target, value: $value, pos=$position)")
     }
 
-    fun asDesugaredNonaugmented(): Assignment {
-        val augmented = aug_op ?: return this
+    /**
+     * Is the assigment value an expression that references the assignment target itself?
+     * The expression can be a BinaryExpression, PrefixExpression or TypecastExpression (possibly with one sub-cast).
+     */
+    val isAugmentable: Boolean
+        get() {
+            val binExpr = value as? BinaryExpression
+            if(binExpr!=null) {
+                if(binExpr.right !is BinaryExpression && binExpr.left isSameAs target)
+                    return true  // A = A <operator> v
 
-        val leftOperand: Expression =
-                when {
-                    target.identifier != null -> target.identifier!!
-                    target.arrayindexed != null -> target.arrayindexed!!
-                    target.memoryAddress != null -> DirectMemoryRead(target.memoryAddress!!.addressExpression, value.position)
-                    else -> throw FatalAstException("strange this")
+                if(binExpr.operator in associativeOperators) {
+                    if (binExpr.left !is BinaryExpression && binExpr.right isSameAs target)
+                        return true  // A = v <associative-operator> A
+
+                    val leftBinExpr = binExpr.left as? BinaryExpression
+                    if(leftBinExpr?.operator == binExpr.operator) {
+                        // one of these?
+                        // A = (A <associative-operator> x) <same-operator> y
+                        // A = (x <associative-operator> A) <same-operator> y
+                        // A = (x <associative-operator> y) <same-operator> A
+                        return leftBinExpr.left isSameAs target || leftBinExpr.right isSameAs target || binExpr.right isSameAs target
+                    }
+                    val rightBinExpr = binExpr.right as? BinaryExpression
+                    if(rightBinExpr?.operator == binExpr.operator) {
+                        // one of these?
+                        // A = y <associative-operator> (A <same-operator> x)
+                        // A = y <associative-operator> (x <same-operator> y)
+                        // A = A <associative-operator> (x <same-operator> y)
+                        return rightBinExpr.left isSameAs target || rightBinExpr.right isSameAs target || binExpr.left isSameAs target
+                    }
                 }
-
-        val assignment =
-            if(augmented=="setvalue") {
-                Assignment(target, null, value, position)
-            } else {
-                val expression = BinaryExpression(leftOperand, augmented.substringBeforeLast('='), value, position)
-                Assignment(target, null, expression, position)
             }
-        assignment.linkParents(parent)
 
-        return assignment
-    }
+            val prefixExpr = value as? PrefixExpression
+            if(prefixExpr!=null)
+                return prefixExpr.expression isSameAs target
+
+            val castExpr = value as? TypecastExpression
+            if(castExpr!=null) {
+                val subCast = castExpr.expression as? TypecastExpression
+                return if(subCast!=null) subCast.expression isSameAs target else castExpr.expression isSameAs target
+            }
+
+            return false
+        }
 }
 
 data class AssignTarget(var identifier: IdentifierReference?,
@@ -425,6 +428,15 @@ data class AssignTarget(var identifier: IdentifierReference?,
         return InferredTypes.unknown()
     }
 
+    fun toExpression(): Expression {
+        return when {
+            identifier!=null -> identifier!!
+            arrayindexed!=null -> arrayindexed!!
+            memoryAddress!=null -> DirectMemoryRead(memoryAddress.addressExpression, memoryAddress.position)
+            else -> throw FatalAstException("invalid assignmenttarget $this")
+        }
+    }
+
     infix fun isSameAs(value: Expression): Boolean {
         return when {
             this.memoryAddress!=null -> {
@@ -621,7 +633,6 @@ class Subroutine(override val name: String,
                  override var statements: MutableList<Statement>,
                  override val position: Position) : Statement(), INameScope {
 
-    var keepAlways: Boolean = false
     override lateinit var parent: Node
     val scopedname: String by lazy { makeScopedName(name) }
 

compiler/src/prog8/compiler/BeforeAsmGenerationAstChanger.kt

@@ -40,7 +40,7 @@ internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: E
                     val initValue = it.value!!  // assume here that value has always been set by now
                     it.value = null     // make sure no value init assignment for this vardecl will be created later (would be superfluous)
                     val target = AssignTarget(IdentifierReference(listOf(it.name), it.position), null, null, it.position)
-                    val assign = Assignment(target, null, initValue, it.position)
+                    val assign = Assignment(target, initValue, it.position)
                     initValue.parent = assign
                     IAstModification.InsertFirst(assign, scope)
                 } +  decls.map { IAstModification.ReplaceNode(it, NopStatement(it.position), scope) } +
@@ -89,7 +89,14 @@ internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: E
                 return listOf(IAstModification.ReplaceNode(typecast, typecast.expression, parent))
             }
         }
-        else if(sourceDt in PassByReferenceDatatypes) {
+
+
+        // Note: for various reasons (most importantly, code simplicity), the code generator assumes/requires
+        // that the types of assignment values and their target are the same,
+        // and that the types of both operands of a binaryexpression node are the same.
+        // So, it is not easily possible to remove the typecasts that are there to make these conditions true.
+
+        if(sourceDt in PassByReferenceDatatypes) {
             if(typecast.type==DataType.UWORD) {
                 return listOf(IAstModification.ReplaceNode(
                         typecast,

compiler/src/prog8/compiler/Main.kt

@@ -79,7 +79,7 @@ fun compileProgram(filepath: Path,
 
 private fun parseImports(filepath: Path, errors: ErrorReporter): Triple<Program, CompilationOptions, List<Path>> {
     println("Parsing...")
-    val importer = ModuleImporter(errors)
+    val importer = ModuleImporter()
     val programAst = Program(moduleName(filepath.fileName), mutableListOf())
     importer.importModule(programAst, filepath)
     errors.handle()
@@ -169,14 +169,13 @@ private fun optimizeAst(programAst: Program, errors: ErrorReporter) {
             break
     }
 
-    val remover = UnusedCodeRemover()
+    val remover = UnusedCodeRemover(errors)
     remover.visit(programAst)
     remover.applyModifications()
+    errors.handle()
 }
 
 private fun postprocessAst(programAst: Program, errors: ErrorReporter, compilerOptions: CompilationOptions) {
-    programAst.transformAssignments(errors)
-    errors.handle()
     programAst.addTypecasts(errors)
     errors.handle()
     programAst.variousCleanups()

compiler/src/prog8/compiler/Zeropage.kt

@@ -16,7 +16,7 @@ abstract class Zeropage(protected val options: CompilationOptions) {
     fun available() = if(options.zeropage==ZeropageType.DONTUSE) 0 else free.size
 
     fun allocate(scopedname: String, datatype: DataType, position: Position?, errors: ErrorReporter): Int {
-        assert(scopedname.isEmpty() || !allocations.values.any { it.first==scopedname } ) {"isSameAs scopedname can't be allocated twice"}
+        assert(scopedname.isEmpty() || !allocations.values.any { it.first==scopedname } ) {"scopedname can't be allocated twice"}
 
         if(options.zeropage==ZeropageType.DONTUSE)
             throw CompilerException("zero page usage has been disabled")
@@ -39,13 +39,13 @@ abstract class Zeropage(protected val options: CompilationOptions) {
 
         if(free.size > 0) {
             if(size==1) {
-                for(candidate in free.min()!! .. free.max()!!+1) {
+                for(candidate in free.minOrNull()!! .. free.maxOrNull()!!+1) {
                     if(loneByte(candidate))
                         return makeAllocation(candidate, 1, datatype, scopedname)
                 }
                 return makeAllocation(free[0], 1, datatype, scopedname)
             }
-            for(candidate in free.min()!! .. free.max()!!+1) {
+            for(candidate in free.minOrNull()!! .. free.maxOrNull()!!+1) {
                 if (sequentialFree(candidate, size))
                     return makeAllocation(candidate, size, datatype, scopedname)
             }

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

@@ -8,6 +8,7 @@ interface IMachineDefinition {
     val FLOAT_MAX_NEGATIVE: Double
     val FLOAT_MAX_POSITIVE: Double
     val FLOAT_MEM_SIZE: Int
+    val POINTER_MEM_SIZE: Int
 
     val opcodeNames: Set<String>
 

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

@@ -14,9 +14,9 @@ class AssemblyProgram(override val name: String, outputDir: Path) : IAssemblyPro
     private val viceMonListFile = outputDir.resolve("$name.vice-mon-list")
 
     override fun assemble(options: CompilationOptions) {
-        // add "-Wlong-branch"  to see warnings about conversion of branch instructions to jumps
+        // add "-Wlong-branch"  to see warnings about conversion of branch instructions to jumps (default = do this silently)
         val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
-                "-Wall", "-Wno-strict-bool", "-Wno-shadow", "-Werror", "-Wno-error=long-branch",
+                "-Wall", "-Wno-strict-bool", "-Wno-shadow", // "-Werror",
                 "--dump-labels", "--vice-labels", "-l", viceMonListFile.toString(), "--no-monitor")
 
         val outFile = when (options.output) {

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

@@ -14,6 +14,7 @@ object C64MachineDefinition: IMachineDefinition {
     override val FLOAT_MAX_POSITIVE = 1.7014118345e+38         // bytes: 255,127,255,255,255
     override val FLOAT_MAX_NEGATIVE = -1.7014118345e+38        // bytes: 255,255,255,255,255
     override val FLOAT_MEM_SIZE = 5
+    override val POINTER_MEM_SIZE = 2
     const val BASIC_LOAD_ADDRESS = 0x0801
     const val RAW_LOAD_ADDRESS = 0xc000
 

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

@@ -27,9 +27,9 @@ import kotlin.math.absoluteValue
 
 
 internal class AsmGen(private val program: Program,
-                      private val errors: ErrorReporter,
-                      private val zeropage: Zeropage,
-                      private val options: CompilationOptions,
+                      val errors: ErrorReporter,
+                      val zeropage: Zeropage,
+                      val options: CompilationOptions,
                       private val outputDir: Path): IAssemblyGenerator {
 
     private val assemblyLines = mutableListOf<String>()
@@ -40,16 +40,14 @@ internal class AsmGen(private val program: Program,
     private val forloopsAsmGen = ForLoopsAsmGen(program, this)
     private val postincrdecrAsmGen = PostIncrDecrAsmGen(program, this)
     private val functioncallAsmGen = FunctionCallAsmGen(program, this)
-    private val assignmentAsmGen = AssignmentAsmGen(program, errors, this)
+    private val assignmentAsmGen = AssignmentAsmGen(program, this)
     private val expressionsAsmGen = ExpressionsAsmGen(program, this)
     internal val loopEndLabels = ArrayDeque<String>()
-    internal val loopContinueLabels = ArrayDeque<String>()
     internal val blockLevelVarInits = mutableMapOf<Block, MutableSet<VarDecl>>()
 
     override fun compileToAssembly(optimize: Boolean): IAssemblyProgram {
         assemblyLines.clear()
         loopEndLabels.clear()
-        loopContinueLabels.clear()
 
         println("Generating assembly code... ")
 
@@ -185,7 +183,7 @@ internal class AsmGen(private val program: Program,
                 val scopedFullName = decl.makeScopedName(decl.name).split('.')
                 require(scopedFullName.first()==block.name)
                 val target = AssignTarget(IdentifierReference(scopedFullName.drop(1), decl.position), null, null, decl.position)
-                val assign = Assignment(target, null, decl.value!!, decl.position)
+                val assign = Assignment(target, decl.value!!, decl.position)
                 assign.linkParents(decl.parent)
                 assignmentAsmGen.translate(assign)
             }
@@ -638,8 +636,11 @@ internal class AsmGen(private val program: Program,
             is BranchStatement -> translate(stmt)
             is IfStatement -> translate(stmt)
             is ForLoop -> forloopsAsmGen.translate(stmt)
-            is Continue -> out("  jmp  ${loopContinueLabels.peek()}")
-            is Break -> out("  jmp  ${loopEndLabels.peek()}")
+            is Break -> {
+                if(loopEndLabels.isEmpty())
+                    throw AssemblyError("break statement out of context  ${stmt.position}")
+                out("  jmp  ${loopEndLabels.peek()}")
+            }
             is WhileLoop -> translate(stmt)
             is RepeatLoop -> translate(stmt)
             is UntilLoop -> translate(stmt)
@@ -676,9 +677,7 @@ internal class AsmGen(private val program: Program,
     private fun translate(stmt: RepeatLoop) {
         val repeatLabel = makeLabel("repeat")
         val endLabel = makeLabel("repeatend")
-        val counterLabel = makeLabel("repeatcounter")
         loopEndLabels.push(endLabel)
-        loopContinueLabels.push(repeatLabel)
 
         when (stmt.iterations) {
             null -> {
@@ -694,13 +693,13 @@ internal class AsmGen(private val program: Program,
                     throw AssemblyError("invalid number of iterations")
                 when {
                     iterations == 0 -> {}
-                    iterations <= 255 -> {
-                        out("  lda  #${iterations}")
-                        repeatByteCountInA(counterLabel, repeatLabel, endLabel, stmt.body)
+                    iterations <= 256 -> {
+                        out("  lda  #${iterations and 255}")
+                        repeatByteCountInA(iterations, repeatLabel, endLabel, stmt.body)
                     }
                     else -> {
                         out("  lda  #<${iterations} |  ldy  #>${iterations}")
-                        repeatWordCountInAY(counterLabel, repeatLabel, endLabel, stmt.body)
+                        repeatWordCountInAY(iterations, repeatLabel, endLabel, stmt.body)
                     }
                 }
             }
@@ -710,11 +709,11 @@ internal class AsmGen(private val program: Program,
                 when(vardecl.datatype) {
                     DataType.UBYTE, DataType.BYTE -> {
                         out("  lda  $name")
-                        repeatByteCountInA(counterLabel, repeatLabel, endLabel, stmt.body)
+                        repeatByteCountInA(null, repeatLabel, endLabel, stmt.body)
                     }
                     DataType.UWORD, DataType.WORD -> {
                         out("  lda  $name |  ldy  $name+1")
-                        repeatWordCountInAY(counterLabel, repeatLabel, endLabel, stmt.body)
+                        repeatWordCountInAY(null, repeatLabel, endLabel, stmt.body)
                     }
                     else -> throw AssemblyError("invalid loop variable datatype $vardecl")
                 }
@@ -725,11 +724,11 @@ internal class AsmGen(private val program: Program,
                 when (dt) {
                     in ByteDatatypes -> {
                         out("  inx |  lda  ${ESTACK_LO_HEX},x")
-                        repeatByteCountInA(counterLabel, repeatLabel, endLabel, stmt.body)
+                        repeatByteCountInA(null, repeatLabel, endLabel, stmt.body)
                     }
                     in WordDatatypes -> {
                         out("  inx |  lda  ${ESTACK_LO_HEX},x |  ldy  ${ESTACK_HI_HEX},x")
-                        repeatWordCountInAY(counterLabel, repeatLabel, endLabel, stmt.body)
+                        repeatWordCountInAY(null, repeatLabel, endLabel, stmt.body)
                     }
                     else -> throw AssemblyError("invalid loop expression datatype $dt")
                 }
@@ -737,49 +736,63 @@ internal class AsmGen(private val program: Program,
         }
 
         loopEndLabels.pop()
-        loopContinueLabels.pop()
     }
 
-    private fun repeatWordCountInAY(counterLabel: String, repeatLabel: String, endLabel: String, body: AnonymousScope) {
+    private fun repeatWordCountInAY(constIterations: Int?, repeatLabel: String, endLabel: String, body: AnonymousScope) {
         // note: A/Y must have been loaded with the number of iterations already!
+        val counterVar = makeLabel("repeatcounter")
         out("""
-                sta  $counterLabel
-                sty  $counterLabel+1
-$repeatLabel    lda  $counterLabel
+                sta  $counterVar
+                sty  $counterVar+1
+$repeatLabel    lda  $counterVar
                 bne  +
-                lda  $counterLabel+1
+                lda  $counterVar+1
                 beq  $endLabel
-+               lda  $counterLabel
++               lda  $counterVar
                 bne  +
-                dec  $counterLabel+1
-+               dec  $counterLabel
+                dec  $counterVar+1
++               dec  $counterVar
 """)
         translate(body)
-        out("""
-            jmp  $repeatLabel
-$counterLabel    .word  0
-$endLabel""")
+        out("  jmp  $repeatLabel")
+        if(constIterations!=null && constIterations>=16 && zeropage.available() > 1) {
+            // allocate count var on ZP
+            val zpAddr = zeropage.allocate(counterVar, DataType.UWORD, body.position, errors)
+            out("""$counterVar = $zpAddr  ; auto zp UWORD""")
+        } else {
+            out("""
+$counterVar    .word  0""")
+        }
+        out(endLabel)
+
     }
 
-    private fun repeatByteCountInA(counterLabel: String, repeatLabel: String, endLabel: String, body: AnonymousScope) {
+    private fun repeatByteCountInA(constIterations: Int?, repeatLabel: String, endLabel: String, body: AnonymousScope) {
         // note: A must have been loaded with the number of iterations already!
+        val counterVar = makeLabel("repeatcounter")
         out("""
-                sta  $counterLabel
-$repeatLabel    lda  $counterLabel
-                beq  $endLabel
-                dec  $counterLabel""")
+            sta  $counterVar
+$repeatLabel""")
         translate(body)
         out("""
-                jmp  $repeatLabel
-$counterLabel    .byte  0
-$endLabel""")
+             dec  $counterVar
+             bne  $repeatLabel
+             beq  $endLabel""")
+        if(constIterations!=null && constIterations>=16 && zeropage.available() > 0) {
+            // allocate count var on ZP
+            val zpAddr = zeropage.allocate(counterVar, DataType.UBYTE, body.position, errors)
+            out("""$counterVar = $zpAddr  ; auto zp UBYTE""")
+        } else {
+            out("""
+$counterVar    .byte  0""")
+        }
+        out(endLabel)
     }
 
     private fun translate(stmt: WhileLoop) {
         val whileLabel = makeLabel("while")
         val endLabel = makeLabel("whileend")
         loopEndLabels.push(endLabel)
-        loopContinueLabels.push(whileLabel)
         out(whileLabel)
         expressionsAsmGen.translateExpression(stmt.condition)
         val conditionDt = stmt.condition.inferType(program)
@@ -800,14 +813,12 @@ $endLabel""")
         out("  jmp  $whileLabel")
         out(endLabel)
         loopEndLabels.pop()
-        loopContinueLabels.pop()
     }
 
     private fun translate(stmt: UntilLoop) {
         val repeatLabel = makeLabel("repeat")
         val endLabel = makeLabel("repeatend")
         loopEndLabels.push(endLabel)
-        loopContinueLabels.push(repeatLabel)
         out(repeatLabel)
         translate(stmt.body)
         expressionsAsmGen.translateExpression(stmt.untilCondition)
@@ -827,7 +838,6 @@ $endLabel""")
         }
         out(endLabel)
         loopEndLabels.pop()
-        loopContinueLabels.pop()
     }
 
     private fun translate(stmt: WhenStatement) {
@@ -929,7 +939,7 @@ $endLabel""")
                 val next = (stmt.parent as INameScope).nextSibling(stmt)
                 if (next !is ForLoop || next.loopVar.nameInSource.single() != stmt.name) {
                     val target = AssignTarget(IdentifierReference(listOf(stmt.name), stmt.position), null, null, stmt.position)
-                    val assign = Assignment(target, null, stmt.value!!, stmt.position)
+                    val assign = Assignment(target, stmt.value!!, stmt.position)
                     assign.linkParents(stmt.parent)
                     translate(assign)
                 }
@@ -998,7 +1008,6 @@ $endLabel""")
                 val indexName = asmIdentifierName(index)
                 out("  lda  $indexName")
             }
-            // TODO optimize more cases
             else -> {
                 expressionsAsmGen.translateExpression(index)
                 out("  inx |  lda  $ESTACK_LO_HEX,x")
@@ -1006,21 +1015,6 @@ $endLabel""")
         }
     }
 
-    internal fun translateArrayIndexIntoY(expr: ArrayIndexedExpression) {
-        when (val index = expr.arrayspec.index) {
-            is NumericLiteralValue -> throw AssemblyError("this should be optimized directly")
-            is IdentifierReference -> {
-                val indexName = asmIdentifierName(index)
-                out("  ldy  $indexName")
-            }
-            // TODO optimize more cases, see translateArrayIndexIntoA
-            else -> {
-                expressionsAsmGen.translateExpression(index)
-                out("  inx |  ldy  $ESTACK_LO_HEX,x")
-            }
-        }
-    }
-
     internal fun translateExpression(expression: Expression) =
             expressionsAsmGen.translateExpression(expression)
 
@@ -1030,33 +1024,6 @@ $endLabel""")
     internal fun translateFunctionCall(functionCall: FunctionCall) =
             functioncallAsmGen.translateFunctionCall(functionCall)
 
-    internal fun assignFromEvalResult(target: AssignTarget) =
-            assignmentAsmGen.assignFromEvalResult(target)
-
-    fun assignFromByteConstant(target: AssignTarget, value: Short) =
-            assignmentAsmGen.assignFromByteConstant(target, value)
-
-    fun assignFromWordConstant(target: AssignTarget, value: Int) =
-            assignmentAsmGen.assignFromWordConstant(target, value)
-
-    fun assignFromFloatConstant(target: AssignTarget, value: Double) =
-            assignmentAsmGen.assignFromFloatConstant(target, value)
-
-    fun assignFromByteVariable(target: AssignTarget, variable: IdentifierReference) =
-            assignmentAsmGen.assignFromByteVariable(target, variable)
-
-    fun assignFromWordVariable(target: AssignTarget, variable: IdentifierReference) =
-            assignmentAsmGen.assignFromWordVariable(target, variable)
-
-    fun assignFromFloatVariable(target: AssignTarget, variable: IdentifierReference) =
-            assignmentAsmGen.assignFromFloatVariable(target, variable)
-
-    fun assignFromRegister(target: AssignTarget, register: CpuRegister) =
-            assignmentAsmGen.assignFromRegister(target, register)
-
-    fun assignFromMemoryByte(target: AssignTarget, address: Int?, identifier: IdentifierReference?) =
-            assignmentAsmGen.assignFromMemoryByte(target, address, identifier)
-
-    fun assignToRegister(reg: CpuRegister, value: Short?, identifier: IdentifierReference?) =
+    internal fun assignToRegister(reg: CpuRegister, value: Short?, identifier: IdentifierReference?) =
             assignmentAsmGen.assignToRegister(reg, value, identifier)
 }

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

@@ -35,6 +35,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
 
         when (functionName) {
             "msb" -> funcMsb(fcall)
+            "lsb" -> funcLsb(fcall)
             "mkword" -> funcMkword(fcall, func)
             "abs" -> funcAbs(fcall, func)
             "swap" -> funcSwap(fcall)
@@ -584,7 +585,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
         if (arg.inferType(program).typeOrElse(DataType.STRUCT) !in WordDatatypes)
             throw AssemblyError("msb required word argument")
         if (arg is NumericLiteralValue)
-            throw AssemblyError("should have been const-folded")
+            throw AssemblyError("msb(const) should have been const-folded away")
         if (arg is IdentifierReference) {
             val sourceName = asmgen.asmIdentifierName(arg)
             asmgen.out("  lda  $sourceName+1 |  sta  $ESTACK_LO_HEX,x |  dex")
@@ -594,6 +595,21 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
         }
     }
 
+    private fun funcLsb(fcall: IFunctionCall) {
+        val arg = fcall.args.single()
+        if (arg.inferType(program).typeOrElse(DataType.STRUCT) !in WordDatatypes)
+            throw AssemblyError("lsb required word argument")
+        if (arg is NumericLiteralValue)
+            throw AssemblyError("lsb(const) should have been const-folded away")
+        if (arg is IdentifierReference) {
+            val sourceName = asmgen.asmIdentifierName(arg)
+            asmgen.out("  lda  $sourceName |  sta  $ESTACK_LO_HEX,x |  dex")
+        } else {
+            asmgen.translateExpression(arg)
+            // just ignore any high-byte
+        }
+    }
+
     private fun outputPushAddressAndLenghtOfArray(arg: Expression) {
         arg as IdentifierReference
         val identifierName = asmgen.asmIdentifierName(arg)

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

@@ -140,16 +140,17 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 val sourceName = asmgen.asmIdentifierName(expr.addressExpression as IdentifierReference)
                 asmgen.out("""
         lda  $sourceName
-        sta  (+) +1
+        sta  ${C64MachineDefinition.C64Zeropage.SCRATCH_W1}
         lda  $sourceName+1
-        sta  (+) +2
-+       lda  ${'$'}ffff     ; modified
+        sta  ${C64MachineDefinition.C64Zeropage.SCRATCH_W1+1}
+        ldy  #0
+        lda  (${C64MachineDefinition.C64Zeropage.SCRATCH_W1}),y
         sta  $ESTACK_LO_HEX,x
         dex""")
             }
             else -> {
                 translateExpression(expr.addressExpression)
-                asmgen.out("  jsr  prog8_lib.read_byte_from_address")
+                asmgen.out("  jsr  prog8_lib.read_byte_from_address_on_stack")
                 asmgen.out("  sta  $ESTACK_LO_PLUS1_HEX,x")
             }
         }
@@ -194,7 +195,6 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
 
     private val optimizedByteMultiplications = setOf(3,5,6,7,9,10,11,12,13,14,15,20,25,40)
     private val optimizedWordMultiplications = setOf(3,5,6,7,9,10,12,15,20,25,40)
-    private val powersOfTwo = setOf(0,1,2,4,8,16,32,64,128,256)
 
     private fun translateExpression(expr: BinaryExpression) {
         val leftIDt = expr.left.inferType(program)

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

@@ -14,10 +14,6 @@ import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_PLUS1_HEX
 import prog8.compiler.toHex
 import kotlin.math.absoluteValue
 
-// todo choose more efficient comparisons to avoid needless lda's
-// todo optimize common case when step == 2 or -2
-
-
 internal class ForLoopsAsmGen(private val program: Program, private val asmgen: AsmGen) {
 
     internal fun translate(stmt: ForLoop) {
@@ -43,9 +39,9 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen:
     private fun translateForOverNonconstRange(stmt: ForLoop, iterableDt: DataType, range: RangeExpr) {
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
-        val continueLabel = asmgen.makeLabel("for_continue")
+        val modifiedLabel = asmgen.makeLabel("for_modified")
+        val modifiedLabel2 = asmgen.makeLabel("for_modifiedb")
         asmgen.loopEndLabels.push(endLabel)
-        asmgen.loopContinueLabels.push(continueLabel)
         val stepsize=range.step.constValue(program)!!.number.toInt()
         when(iterableDt) {
             DataType.ARRAY_B, DataType.ARRAY_UB -> {
@@ -60,19 +56,21 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen:
                     asmgen.translateExpression(range.from)
                     asmgen.out("""
                 inx
-                lda  ${ESTACK_LO_HEX},x
+                lda  $ESTACK_LO_HEX,x
                 sta  $varname
+                lda  $ESTACK_LO_PLUS1_HEX,x
+                sta  $modifiedLabel+1
 $loopLabel""")
                         asmgen.translate(stmt.body)
                         asmgen.out("""
-$continueLabel  lda  $varname
-                cmp  $ESTACK_LO_PLUS1_HEX,x
+                lda  $varname
+$modifiedLabel  cmp  #0         ; modified 
                 beq  $endLabel
                 $incdec  $varname
                 jmp  $loopLabel
 $endLabel       inx""")
-                }
-                else {
+
+                } else {
 
                     // bytes, step >= 2 or <= -2
 
@@ -82,18 +80,20 @@ $endLabel       inx""")
                     asmgen.translateExpression(range.from)
                     asmgen.out("""
                 inx
-                lda  ${ESTACK_LO_HEX},x
+                lda  $ESTACK_LO_HEX,x
                 sta  $varname
+                lda  $ESTACK_LO_PLUS1_HEX,x
+                sta  $modifiedLabel+1
 $loopLabel""")
                     asmgen.translate(stmt.body)
                     asmgen.out("""
-$continueLabel  lda  $varname""")
+                lda  $varname""")
                     if(stepsize>0) {
                         asmgen.out("""
                 clc
                 adc  #$stepsize
                 sta  $varname
-                cmp  $ESTACK_LO_PLUS1_HEX,x
+$modifiedLabel  cmp  #0    ; modified
                 bcc  $loopLabel
                 beq  $loopLabel""")
                     } else {
@@ -101,7 +101,7 @@ $continueLabel  lda  $varname""")
                 sec
                 sbc  #${stepsize.absoluteValue}
                 sta  $varname
-                cmp  $ESTACK_LO_PLUS1_HEX,x
+$modifiedLabel  cmp  #0     ; modified 
                 bcs  $loopLabel""")
                     }
                     asmgen.out("""
@@ -116,44 +116,53 @@ $endLabel       inx""")
                     stepsize == 1 || stepsize == -1 -> {
                         asmgen.translateExpression(range.to)
                         val varname = asmgen.asmIdentifierName(stmt.loopVar)
-                        val assignLoopvar = Assignment(AssignTarget(stmt.loopVar, null, null, stmt.loopVar.position),
-                                null, range.from, range.position)
+                        val assignLoopvar = Assignment(AssignTarget(stmt.loopVar, null, null, stmt.loopVar.position), range.from, range.position)
                         assignLoopvar.linkParents(stmt)
                         asmgen.translate(assignLoopvar)
-                        asmgen.out(loopLabel)
+                        asmgen.out("""
+                            lda  $ESTACK_HI_PLUS1_HEX,x
+                            sta  $modifiedLabel+1
+                            lda  $ESTACK_LO_PLUS1_HEX,x
+                            sta  $modifiedLabel2+1
+$loopLabel""")
                         asmgen.translate(stmt.body)
                         asmgen.out("""
                 lda  $varname+1
-                cmp  $ESTACK_HI_PLUS1_HEX,x
+$modifiedLabel  cmp  #0    ; modified 
                 bne  +
                 lda  $varname
-                cmp  $ESTACK_LO_PLUS1_HEX,x
+$modifiedLabel2 cmp  #0    ; modified 
                 beq  $endLabel""")
                         if(stepsize==1) {
                             asmgen.out("""
 +               inc  $varname
-                bne  +
-                inc  $varname+1            
+                bne  $loopLabel
+                inc  $varname+1
+                jmp  $loopLabel
                             """)
                         } else {
                             asmgen.out("""
 +               lda  $varname
                 bne  +
                 dec  $varname+1
-+               dec  $varname""")
++               dec  $varname
+                jmp  $loopLabel""")
                         }
-                        asmgen.out("""
-+               jmp  $loopLabel
-$endLabel       inx""")
+                        asmgen.out(endLabel)
+                        asmgen.out(" inx")
                     }
                     stepsize > 0 -> {
 
                         // (u)words, step >= 2
-
                         asmgen.translateExpression(range.to)
+                        asmgen.out("""
+                            lda  $ESTACK_HI_PLUS1_HEX,x
+                            sta  $modifiedLabel+1
+                            lda  $ESTACK_LO_PLUS1_HEX,x
+                            sta  $modifiedLabel2+1
+                        """)
                         val varname = asmgen.asmIdentifierName(stmt.loopVar)
-                        val assignLoopvar = Assignment(AssignTarget(stmt.loopVar, null, null, stmt.loopVar.position),
-                                null, range.from, range.position)
+                        val assignLoopvar = Assignment(AssignTarget(stmt.loopVar, null, null, stmt.loopVar.position), range.from, range.position)
                         assignLoopvar.linkParents(stmt)
                         asmgen.translate(assignLoopvar)
                         asmgen.out(loopLabel)
@@ -168,12 +177,11 @@ $endLabel       inx""")
                 lda  $varname+1
                 adc  #>$stepsize
                 sta  $varname+1
-                lda  $ESTACK_HI_PLUS1_HEX,x
-                cmp  $varname+1
-                bcc  $endLabel
-                bne  $loopLabel
-                lda  $varname
-                cmp  $ESTACK_LO_PLUS1_HEX,x
+$modifiedLabel  cmp  #0     ; modified
+                bcc  $loopLabel
+                bne  $endLabel
+$modifiedLabel2 lda  #0     ; modified
+                cmp  $varname
                 bcc  $endLabel
                 bcs  $loopLabel
 $endLabel       inx""")
@@ -186,9 +194,9 @@ $endLabel       inx""")
                 lda  $varname+1
                 adc  #>$stepsize
                 sta  $varname+1
-                lda  $ESTACK_LO_PLUS1_HEX,x
+$modifiedLabel2 lda  #0   ; modified
                 cmp  $varname
-                lda  $ESTACK_HI_PLUS1_HEX,x
+$modifiedLabel  lda  #0   ; modified
                 sbc  $varname+1
                 bvc  +
                 eor  #$80
@@ -200,9 +208,14 @@ $endLabel       inx""")
 
                         // (u)words, step <= -2
                         asmgen.translateExpression(range.to)
+                        asmgen.out("""
+                            lda  $ESTACK_HI_PLUS1_HEX,x
+                            sta  $modifiedLabel+1
+                            lda  $ESTACK_LO_PLUS1_HEX,x
+                            sta  $modifiedLabel2+1
+                        """)
                         val varname = asmgen.asmIdentifierName(stmt.loopVar)
-                        val assignLoopvar = Assignment(AssignTarget(stmt.loopVar, null, null, stmt.loopVar.position),
-                                null, range.from, range.position)
+                        val assignLoopvar = Assignment(AssignTarget(stmt.loopVar, null, null, stmt.loopVar.position), range.from, range.position)
                         assignLoopvar.linkParents(stmt)
                         asmgen.translate(assignLoopvar)
                         asmgen.out(loopLabel)
@@ -217,11 +230,11 @@ $endLabel       inx""")
                 lda  $varname+1
                 sbc  #>${stepsize.absoluteValue}
                 sta  $varname+1
-                cmp  $ESTACK_HI_PLUS1_HEX,x
+$modifiedLabel  cmp  #0    ; modified                
                 bcc  $endLabel
                 bne  $loopLabel
                 lda  $varname
-                cmp  $ESTACK_LO_PLUS1_HEX,x
+$modifiedLabel2 cmp  #0    ; modified 
                 bcs  $loopLabel
 $endLabel       inx""")
                         } else {
@@ -235,9 +248,9 @@ $endLabel       inx""")
                 sbc  #>${stepsize.absoluteValue}
                 sta  $varname+1
                 pla
-                cmp  $ESTACK_LO_PLUS1_HEX,x
+$modifiedLabel2 cmp  #0    ; modified 
                 lda  $varname+1
-                sbc  $ESTACK_HI_PLUS1_HEX,x
+$modifiedLabel  sbc  #0    ; modified
                 bvc  +
                 eor  #$80
 +               bpl  $loopLabel                
@@ -250,15 +263,12 @@ $endLabel       inx""")
         }
 
         asmgen.loopEndLabels.pop()
-        asmgen.loopContinueLabels.pop()
     }
 
     private fun translateForOverIterableVar(stmt: ForLoop, iterableDt: DataType, ident: IdentifierReference) {
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
-        val continueLabel = asmgen.makeLabel("for_continue")
         asmgen.loopEndLabels.push(endLabel)
-        asmgen.loopContinueLabels.push(continueLabel)
         val iterableName = asmgen.asmIdentifierName(ident)
         val decl = ident.targetVarDecl(program.namespace)!!
         when(iterableDt) {
@@ -269,72 +279,88 @@ $endLabel       inx""")
                     sta  $loopLabel+1
                     sty  $loopLabel+2
 $loopLabel          lda  ${65535.toHex()}       ; modified
-                    beq  $endLabel""")
-                asmgen.out("  sta  ${asmgen.asmIdentifierName(stmt.loopVar)}")
+                    beq  $endLabel
+                    sta  ${asmgen.asmIdentifierName(stmt.loopVar)}""")
                 asmgen.translate(stmt.body)
                 asmgen.out("""
-$continueLabel      inc  $loopLabel+1
+                    inc  $loopLabel+1
                     bne  $loopLabel
                     inc  $loopLabel+2
                     bne  $loopLabel
 $endLabel""")
             }
             DataType.ARRAY_UB, DataType.ARRAY_B -> {
-                // TODO: optimize loop code when the length of the array is < 256, don't need a separate counter var in such cases
                 val length = decl.arraysize!!.size()!!
-                val counterLabel = asmgen.makeLabel("for_counter")
-                val modifiedLabel = asmgen.makeLabel("for_modified")
+                val indexVar = asmgen.makeLabel("for_index")
                 asmgen.out("""
-                    lda  #<$iterableName
-                    ldy  #>$iterableName
-                    sta  $modifiedLabel+1
-                    sty  $modifiedLabel+2
                     ldy  #0
-$loopLabel          sty  $counterLabel
-$modifiedLabel      lda  ${65535.toHex()},y       ; modified""")
-                asmgen.out("  sta  ${asmgen.asmIdentifierName(stmt.loopVar)}")
+$loopLabel          sty  $indexVar
+                    lda  $iterableName,y
+                    sta  ${asmgen.asmIdentifierName(stmt.loopVar)}""")
                 asmgen.translate(stmt.body)
-                asmgen.out("""
-$continueLabel      ldy  $counterLabel
-                    iny
-                    cpy  #${length and 255}
-                    beq  $endLabel
-                    jmp  $loopLabel
-$counterLabel       .byte  0
-$endLabel""")
+                if(length<=255) {
+                    asmgen.out("""
+                        ldy  $indexVar
+                        iny
+                        cpy  #$length
+                        beq  $endLabel
+                        bne  $loopLabel""")
+                } else {
+                    // length is 256
+                    asmgen.out("""
+                        ldy  $indexVar
+                        iny
+                        bne  $loopLabel
+                        beq  $endLabel""")
+                }
+                if(length>=16 && asmgen.zeropage.available() > 0) {
+                    // allocate index var on ZP
+                    val zpAddr = asmgen.zeropage.allocate(indexVar, DataType.UBYTE, stmt.position, asmgen.errors)
+                    asmgen.out("""$indexVar = $zpAddr  ; auto zp UBYTE""")
+                } else {
+                    asmgen.out("""
+$indexVar           .byte  0""")
+                }
+                asmgen.out(endLabel)
             }
             DataType.ARRAY_W, DataType.ARRAY_UW -> {
-                // TODO: optimize loop code when the length of the array is < 256, don't need a separate counter var in such cases
                 val length = decl.arraysize!!.size()!! * 2
-                val counterLabel = asmgen.makeLabel("for_counter")
-                val modifiedLabel = asmgen.makeLabel("for_modified")
-                val modifiedLabel2 = asmgen.makeLabel("for_modified2")
+                val indexVar = asmgen.makeLabel("for_index")
                 val loopvarName = asmgen.asmIdentifierName(stmt.loopVar)
                 asmgen.out("""
-                    lda  #<$iterableName
-                    ldy  #>$iterableName
-                    sta  $modifiedLabel+1
-                    sty  $modifiedLabel+2
-                    lda  #<$iterableName+1
-                    ldy  #>$iterableName+1
-                    sta  $modifiedLabel2+1
-                    sty  $modifiedLabel2+2
                     ldy  #0
-$loopLabel          sty  $counterLabel
-$modifiedLabel      lda  ${65535.toHex()},y       ; modified
+$loopLabel          sty  $indexVar
+                    lda  $iterableName,y
                     sta  $loopvarName
-$modifiedLabel2     lda  ${65535.toHex()},y       ; modified
+                    lda  $iterableName+1,y
                     sta  $loopvarName+1""")
                 asmgen.translate(stmt.body)
-                asmgen.out("""
-$continueLabel      ldy  $counterLabel
-                    iny
-                    iny
-                    cpy  #${length and 255}
-                    beq  $endLabel
-                    jmp  $loopLabel
-$counterLabel       .byte  0
-$endLabel""")
+                if(length<=127) {
+                    asmgen.out("""
+                        ldy  $indexVar
+                        iny
+                        iny
+                        cpy  #$length
+                        beq  $endLabel
+                        bne  $loopLabel""")
+                } else {
+                    // length is 128 words, 256 bytes
+                    asmgen.out("""
+                        ldy  $indexVar
+                        iny
+                        iny
+                        bne  $loopLabel
+                        beq  $endLabel""")
+                }
+                if(length>=16 && asmgen.zeropage.available() > 0) {
+                    // allocate index var on ZP
+                    val zpAddr = asmgen.zeropage.allocate(indexVar, DataType.UBYTE, stmt.position, asmgen.errors)
+                    asmgen.out("""$indexVar = $zpAddr  ; auto zp UBYTE""")
+                } else {
+                    asmgen.out("""
+$indexVar           .byte  0""")
+                }
+                asmgen.out(endLabel)
             }
             DataType.ARRAY_F -> {
                 throw AssemblyError("for loop with floating point variables is not supported")
@@ -342,205 +368,123 @@ $endLabel""")
             else -> throw AssemblyError("can't iterate over $iterableDt")
         }
         asmgen.loopEndLabels.pop()
-        asmgen.loopContinueLabels.pop()
     }
 
     private fun translateForOverConstRange(stmt: ForLoop, iterableDt: DataType, range: IntProgression) {
-        // TODO: optimize loop code when the range is < 256 iterations, don't need a separate counter var in such cases
-        if (range.isEmpty())
-            throw AssemblyError("empty range")
+        if (range.isEmpty() || range.step==0)
+            throw AssemblyError("empty range or step 0")
+        if(iterableDt==DataType.ARRAY_B || iterableDt==DataType.ARRAY_UB) {
+            if(range.step==1 && range.last>range.first) return translateForSimpleByteRangeAsc(stmt, range)
+            if(range.step==-1 && range.last<range.first) return translateForSimpleByteRangeDesc(stmt, range)
+        }
+        else if(iterableDt==DataType.ARRAY_W || iterableDt==DataType.ARRAY_UW) {
+            if(range.step==1 && range.last>range.first) return translateForSimpleWordRangeAsc(stmt, range)
+            if(range.step==-1 && range.last<range.first) return translateForSimpleWordRangeDesc(stmt, range)
+        }
+
+        // not one of the easy cases, generate more complex code...
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
-        val continueLabel = asmgen.makeLabel("for_continue")
         asmgen.loopEndLabels.push(endLabel)
-        asmgen.loopContinueLabels.push(continueLabel)
         when(iterableDt) {
             DataType.ARRAY_B, DataType.ARRAY_UB -> {
-                val counterLabel = asmgen.makeLabel("for_counter")
-                // loop over byte range via loopvar
+                // loop over byte range via loopvar, step >= 2 or <= -2
                 val varname = asmgen.asmIdentifierName(stmt.loopVar)
-                when {
-                    range.step==1 -> {
-                        // step = 1
-                        asmgen.out("""
-                lda  #${range.first}
-                sta  $varname
-                lda  #${range.last-range.first+1 and 255}
-                sta  $counterLabel
+                asmgen.out("""
+                            lda  #${range.first}
+                            sta  $varname
 $loopLabel""")
-                            asmgen.translate(stmt.body)
+                asmgen.translate(stmt.body)
+                when (range.step) {
+                    0, 1, -1 -> {
+                        throw AssemblyError("step 0, 1 and -1 should have been handled specifically  $stmt")
+                    }
+                    2 -> {
+                        if(range.last==255) {
                             asmgen.out("""
-$continueLabel  dec  $counterLabel
-                beq  $endLabel
-                inc  $varname
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
+                                inc  $varname
+                                beq  $endLabel
+                                inc  $varname
+                                bne  $loopLabel""")
+                        } else {
+                            asmgen.out("""
+                                lda  $varname
+                                cmp  #${range.last}
+                                beq  $endLabel
+                                inc  $varname
+                                inc  $varname
+                                jmp  $loopLabel""")
+                        }
                     }
-                    range.step==-1 -> {
-                        // step = -1
-                        asmgen.out("""
-                lda  #${range.first}
-                sta  $varname
-                lda  #${range.first-range.last+1 and 255}
-                sta  $counterLabel
-$loopLabel""")
-                        asmgen.translate(stmt.body)
-                        asmgen.out("""
-$continueLabel  dec  $counterLabel
-                beq  $endLabel
-                dec  $varname
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
-                    }
-                    range.step >= 2 -> {
-                        // step >= 2
-                        asmgen.out("""
-                lda  #${(range.last-range.first) / range.step + 1}
-                sta  $counterLabel
-                lda  #${range.first}
-                sta  $varname
-$loopLabel""")
-                        asmgen.translate(stmt.body)
-                        asmgen.out("""
-$continueLabel  dec  $counterLabel
-                beq  $endLabel
-                lda  $varname
-                clc
-                adc  #${range.step}
-                sta  $varname
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
+                    -2 -> {
+                        when (range.last) {
+                            0 -> asmgen.out("""
+                                lda  $varname
+                                beq  $endLabel
+                                dec  $varname
+                                dec  $varname
+                                jmp  $loopLabel""")
+                            1 -> asmgen.out("""
+                                dec  $varname
+                                beq  $endLabel
+                                dec  $varname
+                                bne  $loopLabel""")
+                            else -> asmgen.out("""
+                                lda  $varname
+                                cmp  #${range.last}
+                                beq  $endLabel
+                                dec  $varname
+                                dec  $varname
+                                jmp  $loopLabel""")
+                        }
                     }
                     else -> {
-                        // step <= -2
+                        // step <= -3 or >= 3
                         asmgen.out("""
-                lda  #${(range.first-range.last) / range.step.absoluteValue + 1}
-                sta  $counterLabel
-                lda  #${range.first}
-                sta  $varname
-$loopLabel""")
-                        asmgen.translate(stmt.body)
-                        asmgen.out("""
-$continueLabel  dec  $counterLabel
-                beq  $endLabel
-                lda  $varname
-                sec
-                sbc  #${range.step.absoluteValue}
-                sta  $varname
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
+                            lda  $varname
+                            cmp  #${range.last}
+                            beq  $endLabel
+                            clc
+                            adc  #${range.step}
+                            sta  $varname
+                            jmp  $loopLabel""")
                     }
                 }
+                asmgen.out(endLabel)
             }
             DataType.ARRAY_W, DataType.ARRAY_UW -> {
-                // loop over word range via loopvar
+                // loop over word range via loopvar, step >= 2 or <= -2
                 val varname = asmgen.asmIdentifierName(stmt.loopVar)
-                when {
-                    range.step == 1 -> {
-                        // word, step = 1
-                        val lastValue = range.last+1
-                        asmgen.out("""
-                lda  #<${range.first}
-                ldy  #>${range.first}
-                sta  $varname
-                sty  $varname+1
-$loopLabel""")
-                        asmgen.translate(stmt.body)
-                        asmgen.out("""
-$continueLabel  inc  $varname
-                bne  +
-                inc  $varname+1
-+               lda  $varname
-                cmp  #<$lastValue
-                bne  +
-                lda  $varname+1
-                cmp  #>$lastValue
-                beq  $endLabel
-+               jmp  $loopLabel
-$endLabel""")
-                    }
-                    range.step == -1 -> {
-                        // word, step = 1
-                        val lastValue = range.last-1
-                        asmgen.out("""
-                lda  #<${range.first}
-                ldy  #>${range.first}
-                sta  $varname
-                sty  $varname+1
-$loopLabel""")
-                        asmgen.translate(stmt.body)
-                        asmgen.out("""
-$continueLabel  lda  $varname
-                bne  +
-                dec  $varname+1
-+               dec  $varname
-                lda  $varname
-                cmp  #<$lastValue
-                bne  +
-                lda  $varname+1
-                cmp  #>$lastValue
-                beq  $endLabel
-+               jmp  $loopLabel
-$endLabel""")
-                    }
-                    range.step >= 2 -> {
-                        // word, step >= 2
-                        // note: range.last has already been adjusted by kotlin itself to actually be the last value of the sequence
-                        val lastValue = range.last+range.step
-                        asmgen.out("""
-                lda  #<${range.first}
-                ldy  #>${range.first}
-                sta  $varname
-                sty  $varname+1
-$loopLabel""")
-                        asmgen.translate(stmt.body)
-                        asmgen.out("""
-$continueLabel  clc
-                lda  $varname
-                adc  #<${range.step}
-                sta  $varname
-                lda  $varname+1
-                adc  #>${range.step}
-                sta  $varname+1
-                lda  $varname
-                cmp  #<$lastValue
-                bne  +
-                lda  $varname+1
-                cmp  #>$lastValue
-                beq  $endLabel
-+               jmp  $loopLabel
-$endLabel""")
+                when (range.step) {
+                    0, 1, -1 -> {
+                        throw AssemblyError("step 0, 1 and -1 should have been handled specifically  $stmt")
                     }
                     else -> {
-                        // step <= -2
+                        // word, step >= 2 or <= -2
                         // note: range.last has already been adjusted by kotlin itself to actually be the last value of the sequence
-                        val lastValue = range.last+range.step
                         asmgen.out("""
-                lda  #<${range.first}
-                ldy  #>${range.first}
-                sta  $varname
-                sty  $varname+1
+                            lda  #<${range.first}
+                            ldy  #>${range.first}
+                            sta  $varname
+                            sty  $varname+1
 $loopLabel""")
                         asmgen.translate(stmt.body)
                         asmgen.out("""
-$continueLabel  sec
-                lda  $varname
-                sbc  #<${range.step.absoluteValue}
-                sta  $varname
-                lda  $varname+1
-                sbc  #>${range.step.absoluteValue}
-                sta  $varname+1
-                lda  $varname
-                cmp  #<$lastValue
-                bne  +
-                lda  $varname+1
-                cmp  #>$lastValue
-                beq  $endLabel
-+               jmp  $loopLabel
+                            lda  $varname
+                            cmp  #<${range.last}
+                            bne  +
+                            lda  $varname+1
+                            cmp  #>${range.last}
+                            bne  +
+                            beq  $endLabel
++                           lda  $varname
+                            clc
+                            adc  #<${range.step}
+                            sta  $varname
+                            lda  $varname+1
+                            adc  #>${range.step}
+                            sta  $varname+1
+                            jmp  $loopLabel
 $endLabel""")
                     }
                 }
@@ -548,7 +492,127 @@ $endLabel""")
             else -> throw AssemblyError("range expression can only be byte or word")
         }
         asmgen.loopEndLabels.pop()
-        asmgen.loopContinueLabels.pop()
     }
 
+    private fun translateForSimpleByteRangeAsc(stmt: ForLoop, range: IntProgression) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        asmgen.loopEndLabels.push(endLabel)
+        val varname = asmgen.asmIdentifierName(stmt.loopVar)
+        asmgen.out("""
+                lda  #${range.first}
+                sta  $varname
+$loopLabel""")
+        asmgen.translate(stmt.body)
+        if (range.last == 255) {
+            asmgen.out("""
+                inc  $varname
+                bne  $loopLabel
+$endLabel""")
+        } else {
+            asmgen.out("""
+                lda  $varname
+                cmp  #${range.last}
+                beq  $endLabel
+                inc  $varname
+                jmp  $loopLabel
+$endLabel""")
+        }
+        asmgen.loopEndLabels.pop()
+    }
+
+    private fun translateForSimpleByteRangeDesc(stmt: ForLoop, range: IntProgression) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        asmgen.loopEndLabels.push(endLabel)
+        val varname = asmgen.asmIdentifierName(stmt.loopVar)
+        asmgen.out("""
+                    lda  #${range.first}
+                    sta  $varname
+$loopLabel""")
+        asmgen.translate(stmt.body)
+        when (range.last) {
+            0 -> {
+                asmgen.out("""
+                    lda  $varname
+                    beq  $endLabel
+                    dec  $varname
+                    jmp  $loopLabel
+$endLabel""")
+            }
+            1 -> {
+                asmgen.out("""
+                    dec  $varname
+                    jmp  $loopLabel
+$endLabel""")
+            }
+            else -> {
+                asmgen.out("""
+                    lda  $varname
+                    cmp  #${range.last}
+                    beq  $endLabel
+                    dec  $varname
+                    jmp  $loopLabel
+$endLabel""")
+            }
+        }
+        asmgen.loopEndLabels.pop()
+    }
+
+    private fun translateForSimpleWordRangeAsc(stmt: ForLoop, range: IntProgression) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        asmgen.loopEndLabels.push(endLabel)
+        val varname = asmgen.asmIdentifierName(stmt.loopVar)
+        asmgen.out("""
+            lda  #<${range.first}
+            ldy  #>${range.first}
+            sta  $varname
+            sty  $varname+1
+$loopLabel""")
+        asmgen.translate(stmt.body)
+        asmgen.out("""
+            lda  $varname
+            cmp  #<${range.last}
+            bne  +
+            lda  $varname+1
+            cmp  #>${range.last}
+            bne  +
+            beq  $endLabel
++           inc  $varname
+            bne  $loopLabel
+            inc  $varname+1
+            jmp  $loopLabel
+$endLabel""")
+        asmgen.loopEndLabels.pop()
+    }
+
+    private fun translateForSimpleWordRangeDesc(stmt: ForLoop, range: IntProgression) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        asmgen.loopEndLabels.push(endLabel)
+        val varname = asmgen.asmIdentifierName(stmt.loopVar)
+        asmgen.out("""
+            lda  #<${range.first}
+            ldy  #>${range.first}
+            sta  $varname
+            sty  $varname+1
+$loopLabel""")
+        asmgen.translate(stmt.body)
+        asmgen.out("""
+            lda  $varname
+            cmp  #<${range.last}
+            bne  +
+            lda  $varname+1
+            cmp  #>${range.last}
+            bne  +
+            beq  $endLabel
++           lda  $varname
+            bne  +
+            dec  $varname+1
++           dec  $varname
+            jmp  $loopLabel
+$endLabel""")
+        asmgen.loopEndLabels.pop()
+    }
 }

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

@@ -5,6 +5,7 @@ import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.AssignTarget
+import prog8.ast.statements.Assignment
 import prog8.ast.statements.Subroutine
 import prog8.ast.statements.SubroutineParameter
 import prog8.compiler.AssemblyError
@@ -107,49 +108,9 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         val paramVar = parameter.value
         val scopedParamVar = (sub.scopedname+"."+paramVar.name).split(".")
         val target = AssignTarget(IdentifierReference(scopedParamVar, sub.position), null, null, sub.position)
-        target.linkParents(value.parent)
-        when (value) {
-            is NumericLiteralValue -> {
-                // optimize when the argument is a constant literal
-                when(parameter.value.type) {
-                    in ByteDatatypes -> asmgen.assignFromByteConstant(target, value.number.toShort())
-                    in WordDatatypes -> asmgen.assignFromWordConstant(target, value.number.toInt())
-                    DataType.FLOAT -> asmgen.assignFromFloatConstant(target, value.number.toDouble())
-                    in PassByReferenceDatatypes -> throw AssemblyError("can't pass string/array as argument via a variable?")    // TODO huh
-                    else -> throw AssemblyError("weird parameter datatype")
-                }
-            }
-            is IdentifierReference -> {
-                // optimize when the argument is a variable
-                when (parameter.value.type) {
-                    in ByteDatatypes -> asmgen.assignFromByteVariable(target, value)
-                    in WordDatatypes -> asmgen.assignFromWordVariable(target, value)
-                    DataType.FLOAT -> asmgen.assignFromFloatVariable(target, value)
-                    in PassByReferenceDatatypes -> throw AssemblyError("can't pass string/array as argument via a variable?")     // TODO huh
-                    else -> throw AssemblyError("weird parameter datatype")
-                }
-            }
-            is DirectMemoryRead -> {
-                when(value.addressExpression) {
-                    is NumericLiteralValue -> {
-                        val address = (value.addressExpression as NumericLiteralValue).number.toInt()
-                        asmgen.assignFromMemoryByte(target, address, null)
-                    }
-                    is IdentifierReference -> {
-                        asmgen.assignFromMemoryByte(target, null, value.addressExpression as IdentifierReference)
-                    }
-                    else -> {
-                        asmgen.translateExpression(value.addressExpression)
-                        asmgen.out("  jsr  prog8_lib.read_byte_from_address |  inx")
-                        asmgen.assignFromRegister(target, CpuRegister.A)
-                    }
-                }
-            }
-            else -> {
-                asmgen.translateExpression(value)
-                asmgen.assignFromEvalResult(target)
-            }
-        }
+        val assign = Assignment(target, value, value.position)
+        assign.linkParents(value.parent)
+        asmgen.translate(assign)
     }
 
     private fun argumentViaRegister(sub: Subroutine, parameter: IndexedValue<SubroutineParameter>, value: Expression) {
@@ -183,12 +144,13 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                         is IdentifierReference -> {
                             val sourceName = asmgen.asmIdentifierName(value)
                             asmgen.out("""
+            pha
             lda  $sourceName
             beq  +
             sec  
             bcs  ++
 +           clc
-+
++           pla
 """)
                         }
                         else -> {

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

@@ -7,6 +7,8 @@ import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.statements.PostIncrDecr
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.c64.C64MachineDefinition.C64Zeropage
+import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_HEX
+import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
 import prog8.compiler.toHex
 
 
@@ -53,7 +55,20 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                         else
                             asmgen.out("+\tdec  ${'$'}ffff\t; modified")
                     }
-                    else -> throw AssemblyError("weird target type $targetMemory")
+                    else -> {
+                        asmgen.translateExpression(addressExpr)
+                        asmgen.out("""
+                            inx
+                            lda  $ESTACK_LO_HEX,x
+                            sta  (+) + 1
+                            lda  $ESTACK_HI_HEX,x
+                            sta  (+) + 2
+                        """)
+                        if(incr)
+                            asmgen.out("+\tinc  ${'$'}ffff\t; modified")
+                        else
+                            asmgen.out("+\tdec  ${'$'}ffff\t; modified")
+                    }
                 }
             }
             targetArrayIdx!=null -> {

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -3,6 +3,8 @@ package prog8.functions
 import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
+import prog8.ast.statements.StructDecl
+import prog8.ast.statements.VarDecl
 import prog8.compiler.CompilerException
 import kotlin.math.*
 
@@ -35,6 +37,7 @@ val BuiltinFunctions = mapOf(
     "sum"         to FSignature(true, listOf(FParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinSum) },      // type depends on args
     "abs"         to FSignature(true, listOf(FParam("value", NumericDatatypes)), null, ::builtinAbs),      // type depends on argument
     "len"         to FSignature(true, listOf(FParam("values", IterableDatatypes)), null, ::builtinLen),    // type is UBYTE or UWORD depending on actual length
+    "sizeof"      to FSignature(true, listOf(FParam("object", DataType.values().toSet())), DataType.UBYTE, ::builtinSizeof),
         // normal functions follow:
     "sgn"         to FSignature(true, listOf(FParam("value", NumericDatatypes)), DataType.BYTE, ::builtinSgn ),
     "sin"         to FSignature(true, listOf(FParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sin) },
@@ -103,9 +106,9 @@ val BuiltinFunctions = mapOf(
             FParam("length", setOf(DataType.UBYTE))), null)
 )
 
-fun builtinMax(array: List<Number>): Number = array.maxBy { it.toDouble() }!!
+fun builtinMax(array: List<Number>): Number = array.maxByOrNull { it.toDouble() }!!
 
-fun builtinMin(array: List<Number>): Number = array.minBy { it.toDouble() }!!
+fun builtinMin(array: List<Number>): Number = array.minByOrNull { it.toDouble() }!!
 
 fun builtinSum(array: List<Number>): Number = array.sumByDouble { it.toDouble() }
 
@@ -240,6 +243,42 @@ private fun builtinAbs(args: List<Expression>, position: Position, program: Prog
     }
 }
 
+private fun builtinSizeof(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
+    // 1 arg, type = anything, result type = ubyte
+    if(args.size!=1)
+        throw SyntaxError("sizeof requires one argument", position)
+    if(args[0] !is IdentifierReference)
+        throw SyntaxError("sizeof argument should be an identifier", position)
+
+    val dt = args[0].inferType(program)
+    if(dt.isKnown) {
+        val target = (args[0] as IdentifierReference).targetStatement(program.namespace)
+                ?: throw CannotEvaluateException("sizeof", "no target")
+
+        fun structSize(target: StructDecl) =
+                NumericLiteralValue(DataType.UBYTE, target.statements.map { (it as VarDecl).datatype.memorySize() }.sum(), position)
+
+        return when {
+            dt.typeOrElse(DataType.STRUCT) in ArrayDatatypes -> {
+                val length = (target as VarDecl).arraysize!!.size() ?: throw CannotEvaluateException("sizeof", "unknown array size")
+                val elementDt = ArrayElementTypes.getValue(dt.typeOrElse(DataType.STRUCT))
+                numericLiteral(elementDt.memorySize() * length, position)
+            }
+            dt.istype(DataType.STRUCT) -> {
+                when (target) {
+                    is VarDecl -> structSize(target.struct!!)
+                    is StructDecl -> structSize(target)
+                    else -> throw CompilerException("weird struct type $target")
+                }
+            }
+            dt.istype(DataType.STR) -> throw SyntaxError("sizeof str is undefined, did you mean len?", position)
+            else -> NumericLiteralValue(DataType.UBYTE, dt.typeOrElse(DataType.STRUCT).memorySize(), position)
+        }
+    } else {
+        throw SyntaxError("sizeof invalid argument type", position)
+    }
+}
+
 private fun builtinStrlen(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     if (args.size != 1)
         throw SyntaxError("strlen requires one argument", position)
@@ -254,9 +293,6 @@ private fun builtinLen(args: List<Expression>, position: Position, program: Prog
     // note: in some cases the length is > 255 and then we have to return a UWORD type instead of a UBYTE.
     if(args.size!=1)
         throw SyntaxError("len requires one argument", position)
-    val constArg = args[0].constValue(program)
-    if(constArg!=null)
-        throw SyntaxError("len of weird argument ${args[0]}", position)
 
     val directMemVar = ((args[0] as? DirectMemoryRead)?.addressExpression as? IdentifierReference)?.targetVarDecl(program.namespace)
     var arraySize = directMemVar?.arraysize?.size()
@@ -265,34 +301,23 @@ private fun builtinLen(args: List<Expression>, position: Position, program: Prog
     if(args[0] is ArrayLiteralValue)
         return NumericLiteralValue.optimalInteger((args[0] as ArrayLiteralValue).value.size, position)
     if(args[0] !is IdentifierReference)
-        throw SyntaxError("len argument should be an identifier, but is ${args[0]}", position)
+        throw SyntaxError("len argument should be an identifier", position)
     val target = (args[0] as IdentifierReference).targetVarDecl(program.namespace)
             ?: throw CannotEvaluateException("len", "no target vardecl")
 
     return when(target.datatype) {
-        DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
+        DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F -> {
             arraySize = target.arraysize?.size()
             if(arraySize==null)
                 throw CannotEvaluateException("len", "arraysize unknown")
-            if(arraySize>256)
-                throw CompilerException("array length exceeds byte limit ${target.position}")
-            NumericLiteralValue.optimalInteger(arraySize, args[0].position)
-        }
-        DataType.ARRAY_F -> {
-            arraySize = target.arraysize?.size()
-            if(arraySize==null)
-                throw CannotEvaluateException("len", "arraysize unknown")
-            if(arraySize>256)
-                throw CompilerException("array length exceeds byte limit ${target.position}")
             NumericLiteralValue.optimalInteger(arraySize, args[0].position)
         }
         DataType.STR -> {
             val refLv = target.value as StringLiteralValue
-            if(refLv.value.length>255)
-                throw CompilerException("string length exceeds byte limit ${refLv.position}")
             NumericLiteralValue.optimalInteger(refLv.value.length, args[0].position)
         }
-        in NumericDatatypes -> throw SyntaxError("len of weird argument ${args[0]}", position)
+        DataType.STRUCT -> throw SyntaxError("cannot use len on struct, did you mean sizeof?", args[0].position)
+        in NumericDatatypes -> throw SyntaxError("cannot use len on numeric value, did you mean sizeof?", args[0].position)
         else -> throw CompilerException("weird datatype")
     }
 }
@@ -312,7 +337,7 @@ private fun builtinSin8(args: List<Expression>, position: Position, program: Pro
         throw SyntaxError("sin8 requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.number.toDouble() /256.0 * 2.0 * PI
-    return NumericLiteralValue(DataType.BYTE, (127.0 * sin(rad)).toShort(), position)
+    return NumericLiteralValue(DataType.BYTE, (127.0 * sin(rad)).toInt().toShort(), position)
 }
 
 private fun builtinSin8u(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
@@ -320,7 +345,7 @@ private fun builtinSin8u(args: List<Expression>, position: Position, program: Pr
         throw SyntaxError("sin8u requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.number.toDouble() /256.0 * 2.0 * PI
-    return NumericLiteralValue(DataType.UBYTE, (128.0 + 127.5 * sin(rad)).toShort(), position)
+    return NumericLiteralValue(DataType.UBYTE, (128.0 + 127.5 * sin(rad)).toInt().toShort(), position)
 }
 
 private fun builtinCos8(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
@@ -328,7 +353,7 @@ private fun builtinCos8(args: List<Expression>, position: Position, program: Pro
         throw SyntaxError("cos8 requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.number.toDouble() /256.0 * 2.0 * PI
-    return NumericLiteralValue(DataType.BYTE, (127.0 * cos(rad)).toShort(), position)
+    return NumericLiteralValue(DataType.BYTE, (127.0 * cos(rad)).toInt().toShort(), position)
 }
 
 private fun builtinCos8u(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
@@ -336,7 +361,7 @@ private fun builtinCos8u(args: List<Expression>, position: Position, program: Pr
         throw SyntaxError("cos8u requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.number.toDouble() /256.0 * 2.0 * PI
-    return NumericLiteralValue(DataType.UBYTE, (128.0 + 127.5 * cos(rad)).toShort(), position)
+    return NumericLiteralValue(DataType.UBYTE, (128.0 + 127.5 * cos(rad)).toInt().toShort(), position)
 }
 
 private fun builtinSin16(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
@@ -375,7 +400,7 @@ private fun builtinSgn(args: List<Expression>, position: Position, program: Prog
     if (args.size != 1)
         throw SyntaxError("sgn requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
-    return NumericLiteralValue(DataType.BYTE, constval.number.toDouble().sign.toShort(), position)
+    return NumericLiteralValue(DataType.BYTE, constval.number.toDouble().sign.toInt().toShort(), position)
 }
 
 private fun numericLiteral(value: Number, position: Position): NumericLiteralValue {
@@ -387,8 +412,8 @@ private fun numericLiteral(value: Number, position: Position): NumericLiteralVal
                 floatNum
 
     return when(tweakedValue) {
-        is Int -> NumericLiteralValue.optimalNumeric(value.toInt(), position)
-        is Short -> NumericLiteralValue.optimalNumeric(value.toInt(), position)
+        is Int -> NumericLiteralValue.optimalInteger(value.toInt(), position)
+        is Short -> NumericLiteralValue.optimalInteger(value.toInt(), position)
         is Byte -> NumericLiteralValue(DataType.UBYTE, value.toShort(), position)
         is Double -> NumericLiteralValue(DataType.FLOAT, value.toDouble(), position)
         is Float -> NumericLiteralValue(DataType.FLOAT, value.toDouble(), position)

compiler/src/prog8/optimizer/AssignmentTransformer.kt

@@ -1,157 +0,0 @@
-package prog8.optimizer
-
-import prog8.ast.Node
-import prog8.ast.Program
-import prog8.ast.base.ErrorReporter
-import prog8.ast.expressions.BinaryExpression
-import prog8.ast.processing.AstWalker
-import prog8.ast.processing.IAstModification
-import prog8.ast.statements.Assignment
-import prog8.ast.statements.PostIncrDecr
-
-
-
-internal class AssignmentTransformer(val program: Program, val errors: ErrorReporter) : AstWalker() {
-
-    var optimizationsDone: Int = 0
-    private val noModifications = emptyList<IAstModification>()
-
-    override fun before(assignment: Assignment, parent: Node): Iterable<IAstModification> {
-        // modify A = A + 5 back into augmented form A += 5 for easier code generation for optimized in-place assignments
-        // also to put code generation stuff together, single value assignment (A = 5) is converted to a special
-        // augmented form as wel (with the operator "setvalue")
-        if (assignment.aug_op == null) {
-            val binExpr = assignment.value as? BinaryExpression
-            if (binExpr != null) {
-                if (assignment.target.isSameAs(binExpr.left)) {
-                    assignment.value = binExpr.right
-                    assignment.aug_op = binExpr.operator + "="
-                    assignment.value.parent = assignment
-                    optimizationsDone++
-                    return noModifications
-                }
-            }
-            assignment.aug_op = "setvalue"
-            optimizationsDone++
-        } else if(assignment.aug_op == "+=") {
-            val binExpr = assignment.value as? BinaryExpression
-            if (binExpr != null) {
-                val leftnum = binExpr.left.constValue(program)?.number?.toDouble()
-                val rightnum = binExpr.right.constValue(program)?.number?.toDouble()
-                if(binExpr.operator == "+") {
-                    when {
-                        leftnum == 1.0 -> {
-                            optimizationsDone++
-                            return listOf(IAstModification.SwapOperands(binExpr))
-                        }
-                        leftnum == 2.0 -> {
-                            optimizationsDone++
-                            return listOf(IAstModification.SwapOperands(binExpr))
-                        }
-                        rightnum == 1.0 -> {
-                            // x += y + 1  -> x += y ,  x++
-                            return listOf(
-                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent)
-                            )
-                        }
-                        rightnum == 2.0 -> {
-                            // x += y + 2  -> x += y ,  x++,  x++
-                            return listOf(
-                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent)
-                            )
-                        }
-                    }
-                } else if(binExpr.operator == "-") {
-                    when {
-                        leftnum == 1.0 -> {
-                            optimizationsDone++
-                            return listOf(IAstModification.SwapOperands(binExpr))
-                        }
-                        leftnum == 2.0 -> {
-                            optimizationsDone++
-                            return listOf(IAstModification.SwapOperands(binExpr))
-                        }
-                        rightnum == 1.0 -> {
-                            // x += y - 1  -> x += y ,  x--
-                            return listOf(
-                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent)
-                            )
-                        }
-                        rightnum == 2.0 -> {
-                            // x += y - 2  -> x += y ,  x--,  x--
-                            return listOf(
-                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent)
-                            )
-                        }
-                    }
-                }
-            }
-        } else if(assignment.aug_op == "-=") {
-            val binExpr = assignment.value as? BinaryExpression
-            if (binExpr != null) {
-                val leftnum = binExpr.left.constValue(program)?.number?.toDouble()
-                val rightnum = binExpr.right.constValue(program)?.number?.toDouble()
-                if(binExpr.operator == "+") {
-                    when {
-                        leftnum == 1.0 -> {
-                            optimizationsDone++
-                            return listOf(IAstModification.SwapOperands(binExpr))
-                        }
-                        leftnum == 2.0 -> {
-                            optimizationsDone++
-                            return listOf(IAstModification.SwapOperands(binExpr))
-                        }
-                        rightnum == 1.0 -> {
-                            // x -= y + 1  -> x -= y ,  x--
-                            return listOf(
-                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent)
-                            )
-                        }
-                        rightnum == 2.0 -> {
-                            // x -= y + 2  -> x -= y ,  x--,  x--
-                            return listOf(
-                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "--", assignment.position), parent)
-                            )
-                        }
-                    }
-                } else if(binExpr.operator == "-") {
-                    when {
-                        leftnum == 1.0 -> {
-                            optimizationsDone++
-                            return listOf(IAstModification.SwapOperands(binExpr))
-                        }
-                        leftnum == 2.0 -> {
-                            optimizationsDone++
-                            return listOf(IAstModification.SwapOperands(binExpr))
-                        }
-                        rightnum == 1.0 -> {
-                            // x -= y - 1  -> x -= y ,  x++
-                            return listOf(
-                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent)
-                            )
-                        }
-                        rightnum == 2.0 -> {
-                            // x -= y - 2  -> x -= y ,  x++,  x++
-                            return listOf(
-                                    IAstModification.ReplaceNode(assignment.value, binExpr.left, assignment),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent),
-                                    IAstModification.InsertAfter(assignment, PostIncrDecr(assignment.target, "++", assignment.position), parent)
-                            )
-                        }
-                    }
-                }
-            }
-        }
-        return noModifications
-    }
-}

compiler/src/prog8/optimizer/ConstExprEvaluator.kt

@@ -132,11 +132,11 @@ class ConstExprEvaluator {
     private fun bitwiseand(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
         if(left.type== DataType.UBYTE) {
             if(right.type in IntegerDatatypes) {
-                return NumericLiteralValue(DataType.UBYTE, (left.number.toInt() or (right.number.toInt() and 255)).toShort(), left.position)
+                return NumericLiteralValue(DataType.UBYTE, (left.number.toInt() and (right.number.toInt() and 255)).toShort(), left.position)
             }
         } else if(left.type== DataType.UWORD) {
             if(right.type in IntegerDatatypes) {
-                return NumericLiteralValue(DataType.UWORD, left.number.toInt() or right.number.toInt(), left.position)
+                return NumericLiteralValue(DataType.UWORD, left.number.toInt() and right.number.toInt(), left.position)
             }
         }
         throw ExpressionError("cannot calculate $left & $right", left.position)
@@ -163,7 +163,7 @@ class ConstExprEvaluator {
         val error = "cannot add $left and $right"
         return when (left.type) {
             in IntegerDatatypes -> when (right.type) {
-                in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() + right.number.toInt(), left.position)
+                in IntegerDatatypes -> NumericLiteralValue.optimalInteger(left.number.toInt() + right.number.toInt(), left.position)
                 DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() + right.number.toDouble(), left.position)
                 else -> throw ExpressionError(error, left.position)
             }
@@ -180,7 +180,7 @@ class ConstExprEvaluator {
         val error = "cannot subtract $left and $right"
         return when (left.type) {
             in IntegerDatatypes -> when (right.type) {
-                in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() - right.number.toInt(), left.position)
+                in IntegerDatatypes -> NumericLiteralValue.optimalInteger(left.number.toInt() - right.number.toInt(), left.position)
                 DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() - right.number.toDouble(), left.position)
                 else -> throw ExpressionError(error, left.position)
             }
@@ -197,7 +197,7 @@ class ConstExprEvaluator {
         val error = "cannot multiply ${left.type} and ${right.type}"
         return when (left.type) {
             in IntegerDatatypes -> when (right.type) {
-                in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() * right.number.toInt(), left.position)
+                in IntegerDatatypes -> NumericLiteralValue.optimalInteger(left.number.toInt() * right.number.toInt(), left.position)
                 DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() * right.number.toDouble(), left.position)
                 else -> throw ExpressionError(error, left.position)
             }
@@ -220,7 +220,7 @@ class ConstExprEvaluator {
                 in IntegerDatatypes -> {
                     if(right.number.toInt()==0) divideByZeroError(right.position)
                     val result: Int = left.number.toInt() / right.number.toInt()
-                    NumericLiteralValue.optimalNumeric(result, left.position)
+                    NumericLiteralValue.optimalInteger(result, left.position)
                 }
                 DataType.FLOAT -> {
                     if(right.number.toDouble()==0.0) divideByZeroError(right.position)

compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt

@@ -171,7 +171,7 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
         if(declValue!=null && decl.type==VarDeclType.VAR
                 && declValue is NumericLiteralValue && !declValue.inferType(program).istype(decl.datatype)) {
             // cast the numeric literal to the appropriate datatype of the variable
-            return listOf(IAstModification.ReplaceNode(decl.value!!, declValue.cast(decl.datatype), decl))
+            return listOf(IAstModification.ReplaceNode(decl.value!!, declValue.castNoCheck(decl.datatype), decl))
         }
 
         return noModifications
@@ -179,7 +179,7 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
 }
 
 
-internal class ConstantFoldingOptimizer(private val program: Program, private val errors: ErrorReporter) : AstWalker() {
+internal class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
     private val noModifications = emptyList<IAstModification>()
 
     override fun before(memread: DirectMemoryRead, parent: Node): Iterable<IAstModification> {
@@ -203,7 +203,7 @@ internal class ConstantFoldingOptimizer(private val program: Program, private va
                 "-" -> when (subexpr.type) {
                     in IntegerDatatypes -> {
                         listOf(IAstModification.ReplaceNode(expr,
-                                NumericLiteralValue.optimalNumeric(-subexpr.number.toInt(), subexpr.position),
+                                NumericLiteralValue.optimalInteger(-subexpr.number.toInt(), subexpr.position),
                                 parent))
                     }
                     DataType.FLOAT -> {
@@ -216,7 +216,7 @@ internal class ConstantFoldingOptimizer(private val program: Program, private va
                 "~" -> when (subexpr.type) {
                     in IntegerDatatypes -> {
                         listOf(IAstModification.ReplaceNode(expr,
-                                NumericLiteralValue.optimalNumeric(subexpr.number.toInt().inv(), subexpr.position),
+                                NumericLiteralValue.optimalInteger(subexpr.number.toInt().inv(), subexpr.position),
                                 parent))
                     }
                     else -> throw ExpressionError("can only take bitwise inversion of int", subexpr.position)
@@ -273,11 +273,8 @@ internal class ConstantFoldingOptimizer(private val program: Program, private va
         // const fold when both operands are a const
         if(leftconst != null && rightconst != null) {
             val evaluator = ConstExprEvaluator()
-            return listOf(IAstModification.ReplaceNode(
-                    expr,
-                    evaluator.evaluate(leftconst, expr.operator, rightconst),
-                    parent
-            ))
+            val result = evaluator.evaluate(leftconst, expr.operator, rightconst)
+            return listOf(IAstModification.ReplaceNode(expr, result, parent))
         }
 
         return noModifications
@@ -323,13 +320,13 @@ internal class ConstantFoldingOptimizer(private val program: Program, private va
             val newFrom: NumericLiteralValue
             val newTo: NumericLiteralValue
             try {
-                newFrom = rangeFrom.cast(targetDt)
-                newTo = rangeTo.cast(targetDt)
+                newFrom = rangeFrom.castNoCheck(targetDt)
+                newTo = rangeTo.castNoCheck(targetDt)
             } catch (x: ExpressionError) {
                 return range
             }
             val newStep: Expression = try {
-                stepLiteral?.cast(targetDt)?: range.step
+                stepLiteral?.castNoCheck(targetDt)?: range.step
             } catch(ee: ExpressionError) {
                 range.step
             }
@@ -379,6 +376,18 @@ internal class ConstantFoldingOptimizer(private val program: Program, private va
         return noModifications
     }
 
+    override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
+        val numval = decl.value as? NumericLiteralValue
+        if(decl.type== VarDeclType.CONST && numval!=null) {
+            val valueDt = numval.inferType(program)
+            if(!valueDt.istype(decl.datatype)) {
+                val adjustedVal = numval.castNoCheck(decl.datatype)
+                return listOf(IAstModification.ReplaceNode(numval, adjustedVal, decl))
+            }
+        }
+        return noModifications
+    }
+
     private class ShuffleOperands(val expr: BinaryExpression,
                                   val exprOperator: String?,
                                   val subExpr: BinaryExpression,

compiler/src/prog8/optimizer/ExpressionSimplifier.kt

@@ -6,7 +6,6 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.processing.AstWalker
 import prog8.ast.processing.IAstModification
-import prog8.ast.statements.Assignment
 import kotlin.math.abs
 import kotlin.math.log2
 import kotlin.math.pow
@@ -24,32 +23,29 @@ internal class ExpressionSimplifier(private val program: Program) : AstWalker()
     private val negativePowersOfTwo = powersOfTwo.map { -it }.toSet()
     private val noModifications = emptyList<IAstModification>()
 
-    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
-        if (assignment.aug_op != null)
-            throw FatalAstException("augmented assignments should have been converted to normal assignments before this optimizer: $assignment")
-        return noModifications
-    }
-
     override fun after(typecast: TypecastExpression, parent: Node): Iterable<IAstModification> {
         val mods = mutableListOf<IAstModification>()
 
         // try to statically convert a literal value into one of the desired type
         val literal = typecast.expression as? NumericLiteralValue
         if (literal != null) {
-            val newLiteral = literal.cast(typecast.type)
+            val newLiteral = literal.castNoCheck(typecast.type)
             if (newLiteral !== literal)
                 mods += IAstModification.ReplaceNode(typecast.expression, newLiteral, typecast)
         }
 
-        // remove redundant nested typecasts:
-        // if the typecast casts a value to the same type, remove the cast.
-        // if the typecast contains another typecast, remove the inner typecast.
+        // remove redundant nested typecasts
         val subTypecast = typecast.expression as? TypecastExpression
         if (subTypecast != null) {
-            mods += IAstModification.ReplaceNode(typecast.expression, subTypecast.expression, typecast)
+            // remove the sub-typecast if its datatype is larger than the outer typecast
+            if(subTypecast.type largerThan typecast.type) {
+                mods += IAstModification.ReplaceNode(typecast.expression, subTypecast.expression, typecast)
+            }
         } else {
-            if (typecast.expression.inferType(program).istype(typecast.type))
+            if (typecast.expression.inferType(program).istype(typecast.type)) {
+                // remove duplicate cast
                 mods += IAstModification.ReplaceNode(typecast, typecast.expression, parent)
+            }
         }
 
         return mods

compiler/src/prog8/optimizer/Extensions.kt

@@ -10,7 +10,7 @@ internal fun Program.constantFold(errors: ErrorReporter) {
     if(errors.isEmpty()) {
         replacer.applyModifications()
 
-        val optimizer = ConstantFoldingOptimizer(this, errors)
+        val optimizer = ConstantFoldingOptimizer(this)
         optimizer.visit(this)
         while (errors.isEmpty() && optimizer.applyModifications() > 0) {
             optimizer.visit(this)

compiler/src/prog8/optimizer/StatementOptimizer.kt

@@ -14,11 +14,6 @@ import prog8.functions.BuiltinFunctions
 import kotlin.math.floor
 
 
-/*
-    TODO: remove unreachable code after return and exit()
-*/
-
-
 internal class StatementOptimizer(private val program: Program,
                                   private val errors: ErrorReporter) : AstWalker() {
 
@@ -105,32 +100,34 @@ internal class StatementOptimizer(private val program: Program,
             }
             if(stringVar!=null) {
                 val vardecl = stringVar.targetVarDecl(program.namespace)!!
-                val string = vardecl.value!! as StringLiteralValue
-                val pos = functionCallStatement.position
-                if(string.value.length==1) {
-                    val firstCharEncoded = CompilationTarget.encodeString(string.value, string.altEncoding)[0]
-                    val chrout = FunctionCallStatement(
-                            IdentifierReference(listOf("c64", "CHROUT"), pos),
-                            mutableListOf(NumericLiteralValue(DataType.UBYTE, firstCharEncoded.toInt(), pos)),
-                            functionCallStatement.void, pos
-                    )
-                    return listOf(IAstModification.ReplaceNode(functionCallStatement, chrout, parent))
-                } else if(string.value.length==2) {
-                    val firstTwoCharsEncoded = CompilationTarget.encodeString(string.value.take(2), string.altEncoding)
-                    val chrout1 = FunctionCallStatement(
-                            IdentifierReference(listOf("c64", "CHROUT"), pos),
-                            mutableListOf(NumericLiteralValue(DataType.UBYTE, firstTwoCharsEncoded[0].toInt(), pos)),
-                            functionCallStatement.void, pos
-                    )
-                    val chrout2 = FunctionCallStatement(
-                            IdentifierReference(listOf("c64", "CHROUT"), pos),
-                            mutableListOf(NumericLiteralValue(DataType.UBYTE, firstTwoCharsEncoded[1].toInt(), pos)),
-                            functionCallStatement.void, pos
-                    )
-                    val anonscope = AnonymousScope(mutableListOf(), pos)
-                    anonscope.statements.add(chrout1)
-                    anonscope.statements.add(chrout2)
-                    return listOf(IAstModification.ReplaceNode(functionCallStatement, anonscope, parent))
+                val string = vardecl.value as? StringLiteralValue
+                if(string!=null) {
+                    val pos = functionCallStatement.position
+                    if (string.value.length == 1) {
+                        val firstCharEncoded = CompilationTarget.encodeString(string.value, string.altEncoding)[0]
+                        val chrout = FunctionCallStatement(
+                                IdentifierReference(listOf("c64", "CHROUT"), pos),
+                                mutableListOf(NumericLiteralValue(DataType.UBYTE, firstCharEncoded.toInt(), pos)),
+                                functionCallStatement.void, pos
+                        )
+                        return listOf(IAstModification.ReplaceNode(functionCallStatement, chrout, parent))
+                    } else if (string.value.length == 2) {
+                        val firstTwoCharsEncoded = CompilationTarget.encodeString(string.value.take(2), string.altEncoding)
+                        val chrout1 = FunctionCallStatement(
+                                IdentifierReference(listOf("c64", "CHROUT"), pos),
+                                mutableListOf(NumericLiteralValue(DataType.UBYTE, firstTwoCharsEncoded[0].toInt(), pos)),
+                                functionCallStatement.void, pos
+                        )
+                        val chrout2 = FunctionCallStatement(
+                                IdentifierReference(listOf("c64", "CHROUT"), pos),
+                                mutableListOf(NumericLiteralValue(DataType.UBYTE, firstTwoCharsEncoded[1].toInt(), pos)),
+                                functionCallStatement.void, pos
+                        )
+                        val anonscope = AnonymousScope(mutableListOf(), pos)
+                        anonscope.statements.add(chrout1)
+                        anonscope.statements.add(chrout2)
+                        return listOf(IAstModification.ReplaceNode(functionCallStatement, anonscope, parent))
+                    }
                 }
             }
         }
@@ -139,7 +136,7 @@ internal class StatementOptimizer(private val program: Program,
         val subroutine = functionCallStatement.target.targetSubroutine(program.namespace)
         if(subroutine!=null) {
             val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
-            if(first is ReturnFromIrq || first is Return)
+            if(first is Return)
                 return listOf(IAstModification.Remove(functionCallStatement, parent))
         }
 
@@ -211,7 +208,7 @@ internal class StatementOptimizer(private val program: Program,
                 // for loop over a (constant) range of just a single value-- optimize the loop away
                 // loopvar/reg = range value , follow by block
                 val scope = AnonymousScope(mutableListOf(), forLoop.position)
-                scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), null, range.from, forLoop.position))
+                scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), range.from, forLoop.position))
                 scope.statements.addAll(forLoop.body.statements)
                 return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
             }
@@ -226,7 +223,7 @@ internal class StatementOptimizer(private val program: Program,
                     val character = CompilationTarget.encodeString(sv.value, sv.altEncoding)[0]
                     val byte = NumericLiteralValue(DataType.UBYTE, character, iterable.position)
                     val scope = AnonymousScope(mutableListOf(), forLoop.position)
-                    scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), null, byte, forLoop.position))
+                    scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), byte, forLoop.position))
                     scope.statements.addAll(forLoop.body.statements)
                     return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
                 }
@@ -239,7 +236,7 @@ internal class StatementOptimizer(private val program: Program,
                     if(av!=null) {
                         val scope = AnonymousScope(mutableListOf(), forLoop.position)
                         scope.statements.add(Assignment(
-                                AssignTarget(forLoop.loopVar, null, null, forLoop.position), null, NumericLiteralValue.optimalInteger(av.toInt(), iterable.position),
+                                AssignTarget(forLoop.loopVar, null, null, forLoop.position), NumericLiteralValue.optimalInteger(av.toInt(), iterable.position),
                                 forLoop.position))
                         scope.statements.addAll(forLoop.body.statements)
                         return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
@@ -255,9 +252,9 @@ internal class StatementOptimizer(private val program: Program,
         val constvalue = untilLoop.untilCondition.constValue(program)
         if(constvalue!=null) {
             if(constvalue.asBooleanValue) {
-                // always true -> keep only the statement block (if there are no continue and break statements)
+                // always true -> keep only the statement block (if there are no break statements)
                 errors.warn("condition is always true", untilLoop.untilCondition.position)
-                if(!hasContinueOrBreak(untilLoop.body))
+                if(!hasBreak(untilLoop.body))
                     return listOf(IAstModification.ReplaceNode(untilLoop, untilLoop.body, parent))
             } else {
                 // always false
@@ -296,8 +293,10 @@ internal class StatementOptimizer(private val program: Program,
                 errors.warn("iterations is always 0, removed loop", iter.position)
                 return listOf(IAstModification.Remove(repeatLoop, parent))
             }
-            if (iterations == 1)
+            if (iterations == 1) {
                 errors.warn("iterations is always 1", iter.position)
+                return listOf(IAstModification.ReplaceNode(repeatLoop, repeatLoop.body, parent))
+            }
         }
         return noModifications
     }
@@ -324,21 +323,74 @@ internal class StatementOptimizer(private val program: Program,
         return noModifications
     }
 
-    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
-        if(assignment.aug_op!=null)
-            throw FatalAstException("augmented assignments should have been converted to normal assignments before this optimizer: $assignment")
+    override fun before(assignment: Assignment, parent: Node): Iterable<IAstModification> {
 
-        // remove assignments to self
+        val binExpr = assignment.value as? BinaryExpression
+        if(binExpr!=null) {
+            if(binExpr.left isSameAs assignment.target) {
+                val rExpr = binExpr.right as? BinaryExpression
+                if(rExpr!=null) {
+                    val op1 = binExpr.operator
+                    val op2 = rExpr.operator
+
+                    if(rExpr.left is NumericLiteralValue && op2 in setOf("+", "*", "&", "|")) {
+                        // associative operator, make sure the constant numeric value is second (right)
+                        return listOf(IAstModification.SwapOperands(rExpr))
+                    }
+
+                    val rNum = (rExpr.right as? NumericLiteralValue)?.number
+                    if(rNum!=null) {
+                        if (op1 == "+" || op1 == "-") {
+                            if (op2 == "+") {
+                                // A = A +/- B + N
+                                val expr2 = BinaryExpression(binExpr.left, binExpr.operator, rExpr.left, binExpr.position)
+                                val addConstant = Assignment(
+                                        assignment.target,
+                                        BinaryExpression(binExpr.left, "+", rExpr.right, rExpr.position),
+                                        assignment.position
+                                )
+                                return listOf(
+                                        IAstModification.ReplaceNode(binExpr, expr2, binExpr.parent),
+                                        IAstModification.InsertAfter(assignment, addConstant, parent))
+                            } else if (op2 == "-") {
+                                // A = A +/- B - N
+                                val expr2 = BinaryExpression(binExpr.left, binExpr.operator, rExpr.left, binExpr.position)
+                                val subConstant = Assignment(
+                                        assignment.target,
+                                        BinaryExpression(binExpr.left, "-", rExpr.right, rExpr.position),
+                                        assignment.position
+                                )
+                                return listOf(
+                                        IAstModification.ReplaceNode(binExpr, expr2, binExpr.parent),
+                                        IAstModification.InsertAfter(assignment, subConstant, parent))
+                            }
+                        }
+                    }
+                }
+            }
+
+            if(binExpr.operator in associativeOperators && binExpr.right isSameAs assignment.target) {
+                // associative operator, swap the operands so that the assignment target is first (left)
+                // unless the other operand is the same in which case we don't swap (endless loop!)
+                if (!(binExpr.left isSameAs binExpr.right))
+                    return listOf(IAstModification.SwapOperands(binExpr))
+            }
+
+        }
+
+        return noModifications
+    }
+
+    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
         if(assignment.target isSameAs assignment.value) {
-            if(assignment.target.isNotMemory(program.namespace))
-                return listOf(IAstModification.Remove(assignment, parent))
+            // remove assignment to self
+            return listOf(IAstModification.Remove(assignment, parent))
         }
 
         val targetIDt = assignment.target.inferType(program, assignment)
         if(!targetIDt.isKnown)
             throw FatalAstException("can't infer type of assignment target")
 
-
         // optimize binary expressions a bit
         val targetDt = targetIDt.typeOrElse(DataType.STRUCT)
         val bexpr=assignment.value as? BinaryExpression
@@ -354,8 +406,8 @@ internal class StatementOptimizer(private val program: Program,
                         if (cv == 0.0) {
                             return listOf(IAstModification.Remove(assignment, parent))
                         } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
-                            if ((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt != VarDeclType.MEMORY && cv in 1.0..8.0)) {
-                                // replace by several INCs (a bit less when dealing with memory targets)
+                            if (vardeclDt != VarDeclType.MEMORY && cv in 1.0..4.0) {
+                                // replace by several INCs if it's not a memory address (inc on a memory mapped register doesn't work very well)
                                 val incs = AnonymousScope(mutableListOf(), assignment.position)
                                 repeat(cv.toInt()) {
                                     incs.statements.add(PostIncrDecr(assignment.target, "++", assignment.position))
@@ -368,8 +420,8 @@ internal class StatementOptimizer(private val program: Program,
                         if (cv == 0.0) {
                             return listOf(IAstModification.Remove(assignment, parent))
                         } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
-                            if ((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt != VarDeclType.MEMORY && cv in 1.0..8.0)) {
-                                // replace by several DECs (a bit less when dealing with memory targets)
+                            if (vardeclDt != VarDeclType.MEMORY && cv in 1.0..4.0) {
+                                // replace by several DECs if it's not a memory address (dec on a memory mapped register doesn't work very well)
                                 val decs = AnonymousScope(mutableListOf(), assignment.position)
                                 repeat(cv.toInt()) {
                                     decs.statements.add(PostIncrDecr(assignment.target, "--", assignment.position))
@@ -441,7 +493,7 @@ internal class StatementOptimizer(private val program: Program,
         return linesToRemove
     }
 
-    private fun hasContinueOrBreak(scope: INameScope): Boolean {
+    private fun hasBreak(scope: INameScope): Boolean {
 
         class Searcher: IAstVisitor
         {
@@ -450,10 +502,6 @@ internal class StatementOptimizer(private val program: Program,
             override fun visit(breakStmt: Break) {
                 count++
             }
-
-            override fun visit(contStmt: Continue) {
-                count++
-            }
         }
 
         val s=Searcher()

compiler/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -1,13 +1,14 @@
 package prog8.optimizer
 
+import prog8.ast.INameScope
 import prog8.ast.Node
 import prog8.ast.Program
+import prog8.ast.base.ErrorReporter
 import prog8.ast.processing.AstWalker
 import prog8.ast.processing.IAstModification
-import prog8.ast.statements.Block
+import prog8.ast.statements.*
 
-
-internal class UnusedCodeRemover: AstWalker() {
+internal class UnusedCodeRemover(private val errors: ErrorReporter): AstWalker() {
 
     override fun before(program: Program, parent: Node): Iterable<IAstModification> {
         val callgraph = CallGraph(program)
@@ -17,8 +18,9 @@ internal class UnusedCodeRemover: AstWalker() {
         val entrypoint = program.entrypoint()
         program.modules.forEach {
             callgraph.forAllSubroutines(it) { sub ->
-                if (sub !== entrypoint && !sub.keepAlways && (callgraph.calledBy[sub].isNullOrEmpty() || (sub.containsNoCodeNorVars() && !sub.isAsmSubroutine)))
+                if (sub !== entrypoint && !sub.isAsmSubroutine && (callgraph.calledBy[sub].isNullOrEmpty() || sub.containsNoCodeNorVars())) {
                     removals.add(IAstModification.Remove(sub, sub.definingScope() as Node))
+                }
             }
         }
 
@@ -35,4 +37,33 @@ internal class UnusedCodeRemover: AstWalker() {
 
         return removals
     }
+
+
+    override fun before(breakStmt: Break, parent: Node): Iterable<IAstModification> {
+        reportUnreachable(breakStmt, parent as INameScope)
+        return emptyList()
+    }
+
+    override fun before(jump: Jump, parent: Node): Iterable<IAstModification> {
+        reportUnreachable(jump, parent as INameScope)
+        return emptyList()
+    }
+
+    override fun before(returnStmt: Return, parent: Node): Iterable<IAstModification> {
+        reportUnreachable(returnStmt, parent as INameScope)
+        return emptyList()
+    }
+
+    override fun before(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
+        if(functionCallStatement.target.nameInSource.last() == "exit")
+            reportUnreachable(functionCallStatement, parent as INameScope)
+        return emptyList()
+    }
+
+    private fun reportUnreachable(stmt: Statement, parent: INameScope) {
+        when(val next = parent.nextSibling(stmt)) {
+            null, is Label, is Directive, is VarDecl, is InlineAssembly, is Subroutine, is StructDecl -> {}
+            else -> errors.warn("unreachable code", next.position)
+        }
+    }
 }

compiler/src/prog8/parser/ModuleParsing.kt

@@ -34,7 +34,7 @@ internal class CustomLexer(val modulePath: Path, input: CharStream?) : prog8Lexe
 internal fun moduleName(fileName: Path) = fileName.toString().substringBeforeLast('.')
 
 
-internal class ModuleImporter(private val errors: ErrorReporter) {
+internal class ModuleImporter() {
 
     internal fun importModule(program: Program, filePath: Path): Module {
         print("importing '${moduleName(filePath.fileName)}'")

docs/source/index.rst

@@ -55,7 +55,7 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
 
             c64scr.print("prime numbers up to 255:\n\n")
             ubyte amount=0
-            while true {
+            repeat {
                 ubyte prime = find_next_prime()
                 if prime==0
                     break

docs/source/programming.rst

@@ -257,6 +257,16 @@ Note that the various keywords for the data type and variable type (``byte``, ``
 can't be used as *identifiers* elsewhere. You can't make a variable, block or subroutine with the name ``byte``
 for instance.
 
+**Arrays at a specific memory location:**
+Using the memory-mapped syntax it is possible to define an array to be located at a specific memory location.
+For instance to reference the first 5 rows of the Commodore 64's screen matrix as an array, you can define::
+
+    &ubyte[5*40]  top5screenrows = $0400
+
+This way you can set the second character on the second row from the top like this::
+
+    top5screenrows[41] = '!'
+
 
 Strings
 ^^^^^^^
@@ -397,6 +407,8 @@ The *repeat* loop is used as a short notation of a for loop where the loop varia
 
 You can also create loops by using the ``goto`` statement, but this should usually be avoided.
 
+Breaking out of a loop prematurely is possible with the ``break`` statement.
+
 .. attention::
     The value of the loop variable after executing the loop *is undefined*. Don't use it immediately
     after the loop without first assigning a new value to it!
@@ -712,11 +724,17 @@ reverse(array)
 
 len(x)
     Number of values in the array value x, or the number of characters in a string (excluding the size or 0-byte).
-    Note: this can be different from the number of *bytes* in memory if the datatype isn't a byte.
+    Note: this can be different from the number of *bytes* in memory if the datatype isn't a byte. See sizeof().
     Note: lengths of strings and arrays are determined at compile-time! If your program modifies the actual
     length of the string during execution, the value of len(string) may no longer be correct!
     (use strlen function if you want to dynamically determine the length)
 
+sizeof(name)
+    Number of bytes that the object 'name' occupies in memory. This is a constant determined by the data type of
+    the object. For instance, for a variable of type uword, the sizeof is 2.
+    For an 10 element array of floats, it is 50 (on the C-64, where a float is 5 bytes).
+    Note: usually you will be interested in the number of elements in an array, use len() for that.
+
 strlen(str)
     Number of bytes in the string. This value is determined during runtime and counts upto
     the first terminating 0 byte in the string, regardless of the size of the string during compilation time.

docs/source/syntaxreference.rst

@@ -306,6 +306,7 @@ should be allocated by the compiler. Instead, the (mandatory) value assigned to
 should be the *memory address* where the value is located::
 
 	&byte BORDERCOLOR = $d020
+    &ubyte[5*40]  top5screenrows = $0400        ; works for array as well
 
 
 Direct access to memory locations
@@ -404,7 +405,7 @@ assignment: ``=``
     Note that an assignment sometimes is not possible or supported.
 
 augmented assignment: ``+=``  ``-=``  ``*=``  ``/=``  ``**=``  ``&=``  ``|=``  ``^=``  ``<<=``  ``>>=``
-	Syntactic sugar; ``aa += xx`` is equivalent to ``aa = aa + xx``
+	This is syntactic sugar; ``aa += xx`` is equivalent to ``aa = aa + xx``
 
 postfix increment and decrement: ``++``  ``--``
 	Syntactic sugar; ``aa++`` is equivalent to ``aa = aa + 1``, and ``aa--`` is equivalent to ``aa = aa - 1``.
@@ -559,7 +560,6 @@ You can use a single statement, or a statement block like in the example below::
 	for <loopvar>  in  <expression>  [ step <amount> ]   {
 		; do something...
 		break		; break out of the loop
-		continue	; immediately enter next iteration
 	}
 
 For example, this is a for loop using a byte variable ``i``, defined before, to loop over a certain range of numbers::
@@ -592,7 +592,6 @@ You can use a single statement, or a statement block like in the example below::
 	while  <condition>  {
 		; do something...
 		break		; break out of the loop
-		continue	; immediately enter next iteration
 	}
 
 
@@ -605,7 +604,6 @@ You can use a single statement, or a statement block like in the example below::
 	do  {
 		; do something...
 		break		; break out of the loop
-		continue	; immediately enter next iteration
 	} until  <condition>
 
 

docs/source/todo.rst

@@ -2,9 +2,10 @@
 TODO
 ====
 
-- finalize (most) of the still missing "new" assignment asm code generation
-- aliases for imported symbols for example perhaps '%alias print = c64scr.print'
-- option to load library files from a directory instead of the embedded ones (easier library development/debugging)
+- optimize assignment codegeneration
+- get rid of all TODO's ;-)
+- option to load the built-in library files from a directory instead of the embedded ones (for easier library development/debugging)
+- aliases for imported symbols for example perhaps '%alias print = c64scr.print' ?
 - investigate support for 8bitguy's Commander X16 platform https://www.commanderx16.com  and https://github.com/commanderx16/x16-docs
 - see if we can group some errors together for instance the (now single) errors about unidentified symbols
 

examples/bdmusic.p8

@@ -37,8 +37,9 @@ sub start() {
 }
 
 sub delay() {
-    repeat 32 {
-        while c64.RASTER {
+    repeat 8 {
+        ubyte jiffy = c64.TIME_LO
+        while c64.TIME_LO==jiffy {
         }
     }
 }

examples/line-circle-gfx.p8

@@ -1,9 +1,6 @@
 %import c64lib
 %import c64graphics
 
-; TODO fix compiler errors when compiling without optimizations
-
-
 main {
 
     sub start() {

examples/mandelbrot-gfx.p8

@@ -7,9 +7,6 @@
 ; NOTE: this will take an eternity to draw on a real c64.
 ; even in Vice in warp mode (700% speed on my machine) it's slow, but you can see progress
 
-; TODO fix compiler errors when compiling without optimizations
-
-
 main {
     const ubyte width = 255
     const ubyte height = 200

examples/plasma.p8

@@ -0,0 +1,101 @@
+%import c64lib
+
+
+;/*****************************************************************************\
+;** plasma test program for cc65.                                             **
+;**                                                                           **
+;** (w)2001 by groepaz/hitmen                                                 **
+;**                                                                           **
+;** Cleanup and porting by Ullrich von Bassewitz.                             **
+;** Converted to prog8 by Irmen de Jong                                       **
+;**                                                                           **
+;\*****************************************************************************/
+
+main {
+    const uword SCREEN1 = $E000
+    const uword SCREEN2 = $E400
+    const uword CHARSET = $E800
+
+    const ubyte PAGE1 = ((SCREEN1 >> 6) & $F0) | ((CHARSET >> 10) & $0E)
+    const ubyte PAGE2 = ((SCREEN2 >> 6) & $F0) | ((CHARSET >> 10) & $0E)
+
+    sub start() {
+        c64.COLOR = 1
+        c64scr.print("creating charset...\n")
+        makechar()
+
+        ubyte block = c64.CIA2PRA
+        ; ubyte v = c64.VMCSB
+        c64.CIA2PRA = (block & $FC) | (lsb(SCREEN1 >> 14) ^ $03)
+
+        repeat {
+            doplasma(SCREEN1)
+            c64.VMCSB = PAGE1
+            doplasma(SCREEN2)
+            c64.VMCSB = PAGE2
+        }
+
+        ; restore screen (if you want)
+        ;c64.VMCSB = v
+        ;c64.CIA2PRA = block
+        ;c64scr.print("done!\n")
+    }
+
+    ; several variables outside of doplasma to make them retain their value
+    ubyte c1A
+    ubyte c1B
+    ubyte c2A
+    ubyte c2B
+
+    sub doplasma(uword screen) {
+        ubyte[40] xbuf
+        ubyte[25] ybuf
+        ubyte c1a = c1A
+        ubyte c1b = c1B
+        ubyte c2a = c2A
+        ubyte c2b = c2B
+        ubyte @zp x
+        ubyte @zp y
+
+        for y in 0 to 24 {
+            ybuf[y] = sin8u(c1a) + sin8u(c1b)
+            c1a += 4
+            c1b += 9
+        }
+        c1A += 3
+        c1B -= 5
+        for x in 0 to 39 {
+            xbuf[x] = sin8u(c2a) + sin8u(c2b)
+            c2a += 3
+            c2b += 7
+        }
+        c2A += 2
+        c2B -= 3
+        for y in 0 to 24 {
+            for x in 0 to 39 {
+                @(screen) = xbuf[x] + ybuf[y]
+                screen++
+            }
+        }
+    }
+
+    sub makechar() {
+        ubyte[8] bittab = [ $01, $02, $04, $08, $10, $20, $40, $80 ]
+        ubyte c
+        for c in 0 to 255 {
+            ubyte @zp s = sin8u(c)
+            ubyte i
+            for i in 0 to 7 {
+                ubyte b=0
+                ubyte @zp ii
+                for ii in 0 to 7 {
+                    ; use 16 bit rng for a bit more randomness instead of the 8-bit rng
+                    if lsb(rndw()) > s {
+                        b |= bittab[ii]
+                    }
+                }
+                @(CHARSET + i + c*8.w) = b
+            }
+        }
+    }
+}

examples/structs.p8

@@ -1,9 +1,6 @@
 %import c64utils
 %zeropage basicsafe
 
-; TODO fix compiler errors when compiling without optimization ( /= )
-
-
 main {
 
     struct Color {

examples/test.p8

@@ -2,45 +2,10 @@
 %import c64utils
 %import c64flt
 %zeropage basicsafe
-%option enable_floats
-
 
 main {
 
     sub start() {
 
-        repeat 10 {
-            c64.CHROUT('*')
-        }
-        c64.CHROUT('\n')
-
-        ubyte ub = 9
-        repeat ub {
-            c64.CHROUT('*')
-        }
-        c64.CHROUT('\n')
-
-        repeat 320 {
-            c64.CHROUT('+')
-        }
-        c64.CHROUT('\n')
-
-        uword uw = 320
-        repeat uw {
-            c64.CHROUT('-')
-        }
-        c64.CHROUT('\n')
-
-        ub = 7
-        repeat ub+2 {
-            c64.CHROUT('*')
-        }
-        c64.CHROUT('\n')
-
-        uw = 318
-        repeat uw+2 {
-            c64.CHROUT('*')
-        }
-        c64.CHROUT('\n')
     }
 }

examples/turtle-gfx.p8

@@ -3,8 +3,6 @@
 %import c64graphics
 %option enable_floats
 
-; TODO fix compiler errors when compiling without optimizations
-
 main {
 
     sub start() {
@@ -48,7 +46,7 @@ turtle {
         uword xx = xpos as uword
         c64.SPXY[0] = lsb(xx) + 12
         c64.MSIGX = msb(xx) > 0
-        c64.SPXY[1] = lsb(ypos) + 40
+        c64.SPXY[1] = ypos as ubyte + 40
     }
 
     sub pos(float x, float y) {
@@ -68,7 +66,7 @@ turtle {
         ypos -= flen * cos(angle)
         update_turtle_sprite()
         if pendown {
-            graphics.line(sx as uword, lsb(sy), xpos as uword, lsb(ypos))
+            graphics.line(sx as uword, sy as ubyte, xpos as uword, ypos as ubyte)
         }
     }
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -82,6 +82,7 @@ esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
@@ -129,6 +130,7 @@ fi
 if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    
     JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath

gradlew.bat

@@ -29,6 +29,9 @@ if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
@@ -81,6 +84,7 @@ set CMD_LINE_ARGS=%*
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
 "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
 

parser/antlr/prog8.g4

@@ -98,7 +98,6 @@ statement :
 	| repeatloop
 	| whenstmt
 	| breakstmt
-	| continuestmt
 	| labeldef
 	;
 
@@ -214,8 +213,6 @@ returnstmt : 'return' expression? ;
 
 breakstmt : 'break';
 
-continuestmt: 'continue';
-
 identifier :  NAME ;
 
 scoped_identifier :  NAME ('.' NAME)* ;

parser/build.gradle

@@ -47,3 +47,7 @@ sourceSets {
         }
     }
 }
+
+task wrapper(type: Wrapper) {
+    gradleVersion = '6.1.1'
+}