improved repeat counter vars allocation (re-use var if possible)

(string deduplication is the default again but only for known-const strings, i.e. string literals)

.gitignore

@@ -30,4 +30,4 @@ parsetab.py
 .gradle
 /prog8compiler.jar
 sd*.img
-
+*.d64

compiler/build.gradle

@@ -1,7 +1,7 @@
 plugins {
     id 'java'
     id 'application'
-    id "org.jetbrains.kotlin.jvm" version "1.5.0"
+    id "org.jetbrains.kotlin.jvm" version "1.5.10"
     id 'com.github.johnrengelman.shadow' version '6.1.0'
 }
 

compiler/res/prog8lib/c64/floats.p8

@@ -195,7 +195,7 @@ sub  print_f  (float value) {
 	}}
 }
 
-%asminclude "library:c64/floats.asm", ""
-%asminclude "library:c64/floats_funcs.asm", ""
+%asminclude "library:c64/floats.asm"
+%asminclude "library:c64/floats_funcs.asm"
 
 }

compiler/res/prog8lib/cx16/floats.p8

@@ -158,7 +158,7 @@ sub  print_f  (float value) {
 	}}
 }
 
-%asminclude "library:c64/floats.asm", ""
-%asminclude "library:c64/floats_funcs.asm", ""
+%asminclude "library:c64/floats.asm"
+%asminclude "library:c64/floats_funcs.asm"
 
 }

compiler/res/prog8lib/cx16/palette.p8

@@ -70,6 +70,14 @@ palette {
         }
     }
 
+    inline sub set_all_black() {
+        set_monochrome($000, $000)
+    }
+
+    inline sub set_all_white() {
+        set_monochrome($fff, $fff)
+    }
+
     sub set_grayscale() {
         vera_palette_ptr = $fa00
         repeat 16 {

compiler/res/prog8lib/cx16/syslib.p8

@@ -759,28 +759,28 @@ sys {
         }}
     }
 
-    sub wait(uword jiffies) {
-        ; --- wait approximately the given number of jiffies (1/60th seconds)
-        repeat jiffies {
-            ubyte jiff = lsb(c64.RDTIM16())
-            while jiff==lsb(c64.RDTIM16()) {
-                ; wait until 1 jiffy has passed
-            }
-        }
+    asmsub wait(uword jiffies @AY) {
+        ; --- wait approximately the given number of jiffies (1/60th seconds) (N or N+1)
+        ;     note: regular system vsync irq handler must be running, and no nother irqs
+        %asm {{
+-           wai             ; wait for irq (assume it was vsync)
+            cmp  #0
+            bne  +
+            dey
++           dec  a
+            bne  -
+            cpy  #0
+            bne  -
+            rts
+        }}
     }
 
-    asmsub waitvsync() clobbers(A, X, Y) {
-        ; --- busy wait till the next vsync has occurred (approximately), without depending on custom irq handling.
-        ;     note: system vsync irq handler has to be active for this routine to work.
-        ;     note 2: a more accurate way to wait for vsync is to set up a vsync irq handler instead.
+    inline asmsub waitvsync()  {
+        ; --- suspend execution until the next vsync has occurred, without depending on custom irq handling.
+        ;     note: system vsync irq handler has to be active for this routine to work (and no other irqs).
+        ;     note: a more accurate way to wait for vsync is to set up a vsync irq handler instead.
         %asm {{
-            jsr  c64.RDTIM
-            sta  _mod + 1
-            inc  _mod + 1
-_loop       jsr  c64.RDTIM
-_mod        cmp  #255       ; modified
-            bne  _loop
-            rts
+            wai
         }}
     }
 

compiler/res/prog8lib/math.p8

@@ -3,5 +3,5 @@
 ; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
 
 math {
-	%asminclude "library:math.asm", ""
+	%asminclude "library:math.asm"
 }

compiler/res/prog8lib/prog8_lib.p8

@@ -3,8 +3,8 @@
 ; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
 
 prog8_lib {
-	%asminclude "library:prog8_lib.asm", ""
-	%asminclude "library:prog8_funcs.asm", ""
+	%asminclude "library:prog8_lib.asm"
+	%asminclude "library:prog8_funcs.asm"
 
 	uword @zp retval_interm_uw      ; to store intermediary expression results for return values (hopefully allocated on ZP to reduce code size)
 	word @zp retval_interm_w        ; to store intermediary expression results for return values (hopefully allocated on ZP to reduce code size)

compiler/res/version.txt

@@ -1 +1 @@
-7.0-BETA
+7.0-BETA2

compiler/src/prog8/CompilerMain.kt

@@ -40,8 +40,8 @@ private fun compileMain(args: Array<String>) {
     val watchMode by cli.option(ArgType.Boolean, fullName = "watch", description = "continuous compilation mode (watches for file changes), greatly increases compilation speed")
     val slowCodegenWarnings by cli.option(ArgType.Boolean, fullName = "slowwarn", description="show debug warnings about slow/problematic assembly code generation")
     val compilationTarget by cli.option(ArgType.String, fullName = "target", description = "target output of the compiler, currently '${C64Target.name}' and '${Cx16Target.name}' available").default(C64Target.name)
-    val moduleFiles by cli.argument(ArgType.String, fullName = "modules", description = "main module file(s) to compile").multiple(999)
     val libDirs by cli.option(ArgType.String, fullName="libdirs", description = "list of extra paths to search in for imported modules").multiple().delimiter(File.pathSeparator)
+    val moduleFiles by cli.argument(ArgType.String, fullName = "modules", description = "main module file(s) to compile").multiple(999)
 
     try {
         cli.parse(args)
@@ -56,6 +56,12 @@ private fun compileMain(args: Array<String>) {
         exitProcess(1)
     }
 
+    val faultyOption = moduleFiles.firstOrNull { it.startsWith('-') }
+    if(faultyOption!=null) {
+        System.err.println("Unknown command line option given: $faultyOption")
+        exitProcess(1)
+    }
+
     val libdirs = libDirs.toMutableList()
     if(libdirs.firstOrNull()!=".")
         libdirs.add(0, ".")

compiler/src/prog8/compiler/Compiler.kt

@@ -166,7 +166,10 @@ private class BuiltinFunctionsFacade(functions: Map<String, FSignature>): IBuilt
         builtinFunctionReturnType(name, args, program)
 }
 
-private fun parseImports(filepath: Path, errors: IErrorReporter, compTarget: ICompilationTarget, libdirs: List<String>): Triple<Program, CompilationOptions, List<Path>> {
+private fun parseImports(filepath: Path,
+                         errors: IErrorReporter,
+                         compTarget: ICompilationTarget,
+                         libdirs: List<String>): Triple<Program, CompilationOptions, List<Path>> {
     val compilationTargetName = compTarget.name
     println("Compiler target: $compilationTargetName. Parsing...")
     val bf = BuiltinFunctionsFacade(BuiltinFunctions)
@@ -248,7 +251,7 @@ private fun determineCompilationOptions(program: Program, compTarget: ICompilati
 private fun processAst(programAst: Program, errors: IErrorReporter, compilerOptions: CompilationOptions) {
     // perform initial syntax checks and processings
     println("Processing for target ${compilerOptions.compTarget.name}...")
-    programAst.checkIdentifiers(errors, compilerOptions.compTarget)
+    programAst.checkIdentifiers(errors, compilerOptions)
     errors.report()
     programAst.constantFold(errors, compilerOptions.compTarget)
     errors.report()
@@ -260,7 +263,7 @@ private fun processAst(programAst: Program, errors: IErrorReporter, compilerOpti
     errors.report()
     programAst.checkValid(compilerOptions, errors, compilerOptions.compTarget)
     errors.report()
-    programAst.checkIdentifiers(errors, compilerOptions.compTarget)
+    programAst.checkIdentifiers(errors, compilerOptions)
     errors.report()
 }
 

compiler/src/prog8/compiler/Zeropage.kt

@@ -19,7 +19,29 @@ abstract class Zeropage(protected val options: CompilationOptions) {
 
     val allowedDatatypes = NumericDatatypes
 
-    fun available() = if(options.zeropage==ZeropageType.DONTUSE) 0 else free.size
+    fun availableBytes() = if(options.zeropage==ZeropageType.DONTUSE) 0 else free.size
+    fun hasByteAvailable() = if(options.zeropage==ZeropageType.DONTUSE) false else free.isNotEmpty()
+    fun availableWords(): Int {
+        if(options.zeropage==ZeropageType.DONTUSE)
+            return 0
+
+        val words = free.windowed(2).filter { it[0] == it[1]-1 }
+        var nonOverlappingWordsCount = 0
+        var prevMsbLoc = -1
+        for(w in words) {
+            if(w[0]!=prevMsbLoc) {
+                nonOverlappingWordsCount++
+                prevMsbLoc = w[1]
+            }
+        }
+        return nonOverlappingWordsCount
+    }
+    fun hasWordAvailable(): Boolean {
+        if(options.zeropage==ZeropageType.DONTUSE)
+            return false
+
+        return free.windowed(2).any { it[0] == it[1] - 1 }
+    }
 
     fun allocate(scopedname: String, datatype: DataType, position: Position?, errors: IErrorReporter): Int {
         assert(scopedname.isEmpty() || !allocations.values.any { it.first==scopedname } ) {"scopedname can't be allocated twice"}

compiler/src/prog8/compiler/astprocessing/AstChecker.kt

@@ -15,6 +15,7 @@ import prog8.compiler.functions.builtinFunctionReturnType
 import prog8.compiler.target.C64Target
 import prog8.compiler.target.Cx16Target
 import prog8.compiler.target.ICompilationTarget
+import java.io.CharConversionException
 import java.io.File
 import java.util.*
 
@@ -683,20 +684,20 @@ internal class AstChecker(private val program: Program,
             }
             "%breakpoint" -> {
                 if(directive.parent !is INameScope || directive.parent is Module)
-                    err("this directive may only occur in a block")
+                    err("this directive can't be used here")
                 if(directive.args.isNotEmpty())
                     err("invalid breakpoint directive, expected no arguments")
             }
             "%asminclude" -> {
                 if(directive.parent !is INameScope || directive.parent is Module)
-                    err("this directive may only occur in a block")
-                if(directive.args.size!=2 || directive.args[0].str==null || directive.args[1].str==null)
-                    err("invalid asminclude directive, expected arguments: \"filename\", \"scopelabel\"")
+                    err("this directive can't be used here")
+                if(directive.args.size!=1 || directive.args[0].str==null)
+                    err("invalid asminclude directive, expected argument: \"filename\"")
                 checkFileExists(directive, directive.args[0].str!!)
             }
             "%asmbinary" -> {
                 if(directive.parent !is INameScope || directive.parent is Module)
-                    err("this directive may only occur in a block")
+                    err("this directive can't be used here")
                 val errormsg = "invalid asmbinary directive, expected arguments: \"filename\" [, offset [, length ] ]"
                 if(directive.args.isEmpty()) err(errormsg)
                 else if(directive.args.isNotEmpty() && directive.args[0].str==null) err(errormsg)
@@ -764,6 +765,13 @@ internal class AstChecker(private val program: Program,
 
     override fun visit(string: StringLiteralValue) {
         checkValueTypeAndRangeString(DataType.STR, string)
+
+        try {
+            compTarget.encodeString(string.value, string.altEncoding)
+        } catch (cx: CharConversionException) {
+            errors.err(cx.message ?: "can't encode string", string.position)
+        }
+
         super.visit(string)
     }
 

compiler/src/prog8/compiler/astprocessing/AstExtensions.kt

@@ -44,9 +44,9 @@ internal fun Program.verifyFunctionArgTypes() {
     fixer.visit(this)
 }
 
-internal fun Program.checkIdentifiers(errors: IErrorReporter, compTarget: ICompilationTarget) {
+internal fun Program.checkIdentifiers(errors: IErrorReporter, options: CompilationOptions) {
 
-    val checker2 = AstIdentifiersChecker(this, errors, compTarget)
+    val checker2 = AstIdentifiersChecker(this, errors, options.compTarget)
     checker2.visit(this)
 
     if(errors.noErrors()) {

compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt

@@ -89,7 +89,7 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
             if (existing != null && existing !== subroutine)
                 nameError(subroutine.name, subroutine.position, existing)
 
-            // check that there are no local variables, labels, or other subs that redefine the subroutine's parameters
+            // check that there are no local variables, labels, or other subs that redefine the subroutine's parameters. Blocks are okay.
             val symbolsInSub = subroutine.allDefinedSymbols()
             val namesInSub = symbolsInSub.map{ it.first }.toSet()
             val paramNames = subroutine.parameters.map { it.name }.toSet()
@@ -101,9 +101,6 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
                 val sub = subroutine.statements.firstOrNull { it is Subroutine && it.name==name}
                 if(sub!=null)
                     nameError(name, subroutine.position, sub)
-                val block = program.allBlocks().firstOrNull { it.name==name }
-                if(block!=null)
-                    nameError(name, subroutine.position, block)
             }
 
             if(subroutine.isAsmSubroutine && subroutine.statements.any{it !is InlineAssembly}) {

compiler/src/prog8/compiler/target/ICompilationTarget.kt

@@ -7,7 +7,6 @@ import prog8.ast.base.*
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.statements.AssignTarget
-import prog8.compiler.AssemblyError
 import prog8.compiler.CompilationOptions
 import prog8.compiler.IErrorReporter
 import prog8.compiler.Zeropage
@@ -75,13 +74,13 @@ internal object C64Target: ICompilationTarget {
         try {
             if (altEncoding) Petscii.encodeScreencode(str, true) else Petscii.encodePetscii(str, true)
         } catch (x: CharConversionException) {
-            throw AssemblyError("There was a problem converting a string to the target machine's char encoding: ${x.message}")
+            throw CharConversionException("can't convert string to target machine's char encoding: ${x.message}")
         }
     override fun decodeString(bytes: List<Short>, altEncoding: Boolean) =
         try {
             if (altEncoding) Petscii.decodeScreencode(bytes, true) else Petscii.decodePetscii(bytes, true)
         } catch (x: CharConversionException) {
-            throw AssemblyError("There was a problem decoding to a string: ${x.message}")
+            throw CharConversionException("can't decode string: ${x.message}")
         }
 
     override fun memorySize(dt: DataType): Int {
@@ -102,13 +101,13 @@ internal object Cx16Target: ICompilationTarget {
         try {
             if (altEncoding) Petscii.encodeScreencode(str, true) else Petscii.encodePetscii(str, true)
         } catch (x: CharConversionException) {
-            throw AssemblyError("There was a problem converting a string to the target machine's char encoding: ${x.message}")
+            throw CharConversionException("can't convert string to target machine's char encoding: ${x.message}")
         }
     override fun decodeString(bytes: List<Short>, altEncoding: Boolean) =
         try {
             if (altEncoding) Petscii.decodeScreencode(bytes, true) else Petscii.decodePetscii(bytes, true)
         } catch (x: CharConversionException) {
-            throw AssemblyError("There was a problem decoding to a string: ${x.message}")
+            throw CharConversionException("can't decode string: ${x.message}")
         }
 
     override fun memorySize(dt: DataType): Int {

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

@@ -39,7 +39,7 @@ internal object C64MachineDefinition: IMachineDefinition {
         for(emulator in listOf("x64sc", "x64")) {
             println("\nStarting C-64 emulator $emulator...")
             val cmdline = listOf(emulator, "-silent", "-moncommands", "$programName.vice-mon-list",
-                    "-autostartprgmode", "1", "-autostart-warp", "-autostart", programName + ".prg")
+                    "-autostartprgmode", "1", "-autostart-warp", "-autostart", "$programName.prg")
             val processb = ProcessBuilder(cmdline).inheritIO()
             val process: Process
             try {

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

@@ -1,5 +1,6 @@
 package prog8.compiler.target.cbm
 
+import prog8.ast.antlr.escape
 import java.io.CharConversionException
 
 object Petscii {
@@ -1073,7 +1074,7 @@ object Petscii {
                 }
                 else -> {
                     val case = if (lowercase) "lower" else "upper"
-                    throw CharConversionException("no ${case}Petscii character for '$chr' (${chr.code})")
+                    throw CharConversionException("no ${case}Petscii character for '${escape(chr.toString())}' (${chr.code})")
                 }
             }
         }
@@ -1110,7 +1111,7 @@ object Petscii {
                 }
                 else -> {
                     val case = if (lowercase) "lower" else "upper"
-                    throw CharConversionException("no ${case}Screencode character for '$chr' (${chr.code})")
+                    throw CharConversionException("no ${case}Screencode character for '${escape(chr.toString())}' (${chr.code})")
                 }
             }
         }

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

@@ -381,18 +381,14 @@ internal class AsmGen(private val program: Program,
         out("\n; non-zeropage variables")
         val vars = statements.filterIsInstance<VarDecl>().filter { it.type==VarDeclType.VAR }
 
-        // special treatment for string types: merge strings that are identical
         val encodedstringVars = vars
                 .filter {it.datatype == DataType.STR }
                 .map {
                     val str = it.value as StringLiteralValue
                     it to compTarget.encodeString(str.value, str.altEncoding).plus(0)
                 }
-                .groupBy({it.second}, {it.first})
-        for((encoded, variables) in encodedstringVars) {
-            variables.dropLast(1).forEach { out(it.name) }
-            val lastvar = variables.last()
-            outputStringvar(lastvar, encoded)
+        for((decl, variables) in encodedstringVars) {
+            outputStringvar(decl, variables)
         }
 
         // non-string variables
@@ -402,11 +398,11 @@ internal class AsmGen(private val program: Program,
         }
     }
 
-    private fun outputStringvar(lastvar: VarDecl, encoded: List<Short>) {
-        val sv = lastvar.value as StringLiteralValue
+    private fun outputStringvar(strdecl: VarDecl, bytes: List<Short>) {
+        val sv = strdecl.value as StringLiteralValue
         val altEncoding = if(sv.altEncoding) "@" else ""
-        out("${lastvar.name}\t; ${lastvar.datatype} $altEncoding\"${escape(sv.value).replace("\u0000", "<NULL>")}\"")
-        val outputBytes = encoded.map { "$" + it.toString(16).padStart(2, '0') }
+        out("${strdecl.name}\t; ${strdecl.datatype} $altEncoding\"${escape(sv.value).replace("\u0000", "<NULL>")}\"")
+        val outputBytes = bytes.map { "$" + it.toString(16).padStart(2, '0') }
         for (chunk in outputBytes.chunked(16))
             out("  .byte  " + chunk.joinToString())
     }
@@ -497,8 +493,11 @@ internal class AsmGen(private val program: Program,
         return newName
     }
 
-    internal fun asmSymbolName(identifier: IdentifierReference) =
-        fixNameSymbols(identifier.nameInSource.joinToString("."))
+    internal fun asmSymbolName(identifier: IdentifierReference): String {
+        val target = identifier.targetStatement(program)
+        val prefix = if(target is Label) "_" else ""
+        return fixNameSymbols(prefix+identifier.nameInSource.joinToString("."))
+    }
 
     internal fun asmSymbolName(regs: RegisterOrPair): String =
         if (regs in Cx16VirtualRegisters)
@@ -881,7 +880,15 @@ internal class AsmGen(private val program: Program,
             }
 
             out("; variables")
-            out("; register saves")
+            for((dt, name, addr) in sub.asmGenInfo.extraVars) {
+                if(addr!=null)
+                    out("$name = $addr")
+                else when(dt) {
+                    DataType.UBYTE -> out("$name    .byte  0")
+                    DataType.UWORD -> out("$name    .word  0")
+                    else -> throw AssemblyError("weird dt")
+                }
+            }
             if(sub.asmGenInfo.usedRegsaveA)
                 out("_prog8_regsaveA     .byte  0")
             if(sub.asmGenInfo.usedRegsaveX)
@@ -889,9 +896,9 @@ internal class AsmGen(private val program: Program,
             if(sub.asmGenInfo.usedRegsaveY)
                 out("_prog8_regsaveY     .byte  0")
             if(sub.asmGenInfo.usedFloatEvalResultVar1)
-                out("$subroutineFloatEvalResultVar1    .byte 0,0,0,0,0")
+                out("$subroutineFloatEvalResultVar1    .byte  0,0,0,0,0")
             if(sub.asmGenInfo.usedFloatEvalResultVar2)
-                out("$subroutineFloatEvalResultVar2    .byte 0,0,0,0,0")
+                out("$subroutineFloatEvalResultVar2    .byte  0,0,0,0,0")
             vardecls2asm(sub.statements)
             out("  .pend\n")
         }
@@ -976,11 +983,11 @@ internal class AsmGen(private val program: Program,
                     iterations == 0 -> {}
                     iterations <= 256 -> {
                         out("  lda  #${iterations and 255}")
-                        repeatByteCountInA(iterations, repeatLabel, endLabel, stmt.body)
+                        repeatByteCountInA(iterations, repeatLabel, endLabel, stmt)
                     }
                     else -> {
                         out("  lda  #<${iterations} |  ldy  #>${iterations}")
-                        repeatWordCountInAY(iterations, repeatLabel, endLabel, stmt.body)
+                        repeatWordCountInAY(iterations, repeatLabel, endLabel, stmt)
                     }
                 }
             }
@@ -990,11 +997,11 @@ internal class AsmGen(private val program: Program,
                 when(vardecl.datatype) {
                     DataType.UBYTE, DataType.BYTE -> {
                         assignVariableToRegister(name, RegisterOrPair.A)
-                        repeatByteCountInA(null, repeatLabel, endLabel, stmt.body)
+                        repeatByteCountInA(null, repeatLabel, endLabel, stmt)
                     }
                     DataType.UWORD, DataType.WORD -> {
                         assignVariableToRegister(name, RegisterOrPair.AY)
-                        repeatWordCountInAY(null, repeatLabel, endLabel, stmt.body)
+                        repeatWordCountInAY(null, repeatLabel, endLabel, stmt)
                     }
                     else -> throw AssemblyError("invalid loop variable datatype $vardecl")
                 }
@@ -1006,11 +1013,11 @@ internal class AsmGen(private val program: Program,
                 when (dt.typeOrElse(DataType.UNDEFINED)) {
                     in ByteDatatypes -> {
                         assignExpressionToRegister(stmt.iterations!!, RegisterOrPair.A)
-                        repeatByteCountInA(null, repeatLabel, endLabel, stmt.body)
+                        repeatByteCountInA(null, repeatLabel, endLabel, stmt)
                     }
                     in WordDatatypes -> {
                         assignExpressionToRegister(stmt.iterations!!, RegisterOrPair.AY)
-                        repeatWordCountInAY(null, repeatLabel, endLabel, stmt.body)
+                        repeatWordCountInAY(null, repeatLabel, endLabel, stmt)
                     }
                     else -> throw AssemblyError("invalid loop expression datatype $dt")
                 }
@@ -1020,13 +1027,13 @@ internal class AsmGen(private val program: Program,
         loopEndLabels.pop()
     }
 
-    private fun repeatWordCountInAY(constIterations: Int?, repeatLabel: String, endLabel: String, body: AnonymousScope) {
+    private fun repeatWordCountInAY(constIterations: Int?, repeatLabel: String, endLabel: String, stmt: RepeatLoop) {
         // note: A/Y must have been loaded with the number of iterations!
         if(constIterations==0)
             return
         // no need to explicitly test for 0 iterations as this is done in the count down logic below
 
-        val counterVar = makeLabel("repeatcounter")
+        val counterVar: String = createRepeatCounterVar(DataType.UWORD, constIterations, stmt)
         out("""
                 sta  $counterVar
                 sty  $counterVar+1
@@ -1039,44 +1046,67 @@ $repeatLabel    lda  $counterVar
                 dec  $counterVar+1
 +               dec  $counterVar
 """)
-        translate(body)
+        translate(stmt.body)
         jmp(repeatLabel)
-
-        if(constIterations!=null && constIterations>=16 && zeropage.available() > 1) {
-            // allocate count var on ZP  TODO can be shared with countervars from other subroutines
-            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(constIterations: Int?, repeatLabel: String, endLabel: String, body: AnonymousScope) {
+    private fun repeatByteCountInA(constIterations: Int?, repeatLabel: String, endLabel: String, stmt: RepeatLoop) {
         // note: A must have been loaded with the number of iterations!
         if(constIterations==0)
             return
+
         if(constIterations==null)
             out("  beq  $endLabel   ; skip loop if zero iters")
-        val counterVar = makeLabel("repeatcounter")
+        val counterVar = createRepeatCounterVar(DataType.UBYTE, constIterations, stmt)
         out("  sta  $counterVar")
         out(repeatLabel)
-        translate(body)
-        out("""
-             dec  $counterVar
-             bne  $repeatLabel
-             beq  $endLabel""")
+        translate(stmt.body)
+        out("  dec  $counterVar |  bne  $repeatLabel")
+        if(constIterations==null)
+            out(endLabel)
+    }
 
-        if(constIterations!=null && constIterations>=16 && zeropage.available() > 0) {
-            // allocate count var on ZP  TODO can be shared with countervars from other subroutines
-            val zpAddr = zeropage.allocate(counterVar, DataType.UBYTE, body.position, errors)
-            out("$counterVar = $zpAddr  ; auto zp UBYTE")
-        } else {
-            out("$counterVar    .byte  0")
+    private fun createRepeatCounterVar(dt: DataType, constIterations: Int?, stmt: RepeatLoop): String {
+        val asmInfo = stmt.definingSubroutine()!!.asmGenInfo
+        var parent = stmt.parent
+        while(parent !is ParentSentinel) {
+            if(parent is RepeatLoop)
+                break
+            parent = parent.parent
+        }
+        val isNested = parent is RepeatLoop
+
+        if(!isNested) {
+            // we can re-use a counter var from the subroutine if it already has one for that datatype
+            val existingVar = asmInfo.extraVars.firstOrNull { it.first==dt }
+            if(existingVar!=null)
+                return existingVar.second
         }
 
-        out(endLabel)
+        val counterVar = makeLabel("repeatcounter")
+        when(dt) {
+            DataType.UBYTE -> {
+                if(constIterations!=null && constIterations>=16 && zeropage.hasByteAvailable()) {
+                    // allocate count var on ZP
+                    val zpAddr = zeropage.allocate(counterVar, DataType.UBYTE, stmt.position, errors)
+                    asmInfo.extraVars.add(Triple(DataType.UBYTE, counterVar, zpAddr))
+                } else {
+                    asmInfo.extraVars.add(Triple(DataType.UBYTE, counterVar, null))
+                }
+            }
+            DataType.UWORD -> {
+                if(constIterations!=null && constIterations>=16 && zeropage.hasWordAvailable()) {
+                    // allocate count var on ZP
+                    val zpAddr = zeropage.allocate(counterVar, DataType.UWORD, stmt.position, errors)
+                    asmInfo.extraVars.add(Triple(DataType.UWORD, counterVar, zpAddr))
+                } else {
+                    asmInfo.extraVars.add(Triple(DataType.UWORD, counterVar, null))
+                }
+            }
+            else -> throw AssemblyError("invalidt dt")
+        }
+        return counterVar
     }
 
     private fun translate(stmt: WhileLoop) {
@@ -1237,12 +1267,7 @@ $repeatLabel    lda  $counterVar
         when(stmt.directive) {
             "%asminclude" -> {
                 val sourcecode = loadAsmIncludeFile(stmt.args[0].str!!, stmt.definingModule().source)
-                val scopeprefix = stmt.args[1].str ?: ""
-                if(scopeprefix.isNotBlank())
-                    out("$scopeprefix\t.proc")
                 assemblyLines.add(sourcecode.trimEnd().trimStart('\n'))
-                if(scopeprefix.isNotBlank())
-                    out("  .pend\n")
             }
             "%asmbinary" -> {
                 val offset = if(stmt.args.size>1) ", ${stmt.args[1].int}" else ""
@@ -1268,14 +1293,7 @@ $label              nop""")
         val label = jump.generatedLabel
         val addr = jump.address
         return when {
-            ident!=null -> {
-                val target = ident.targetStatement(program)
-                val asmName = asmSymbolName(ident)
-                if(target is Label)
-                    "_$asmName"  // prefix with underscore to jump to local label
-                else
-                    asmName
-            }
+            ident!=null -> asmSymbolName(ident)
             label!=null -> label
             addr!=null -> addr.toHex()
             else -> "????"

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

@@ -750,7 +750,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
 
         // optimized simple case: swap two memory locations
         if(first is DirectMemoryRead && second is DirectMemoryRead) {
-            // TODO optimize swap of two memread values with index, using the same pointer expression/variable, like swap(@(ptr+1), @(ptr+2))
+            // TODO optimize swap of two memread values with index, using the same pointer expression/variable, like swap(@(ptr+i1), @(ptr+i2))
             val addr1 = (first.addressExpression as? NumericLiteralValue)?.number?.toHex()
             val addr2 = (second.addressExpression as? NumericLiteralValue)?.number?.toHex()
             val name1 = if(first.addressExpression is IdentifierReference) asmgen.asmVariableName(first.addressExpression as IdentifierReference) else null

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

@@ -288,7 +288,7 @@ $loopLabel          sty  $indexVar
                         bne  $loopLabel
                         beq  $endLabel""")
                 }
-                if(length>=16 && asmgen.zeropage.available() > 0) {
+                if(length>=16 && asmgen.zeropage.hasByteAvailable()) {
                     // allocate index var on ZP
                     val zpAddr = asmgen.zeropage.allocate(indexVar, DataType.UBYTE, stmt.position, asmgen.errors)
                     asmgen.out("""$indexVar = $zpAddr  ; auto zp UBYTE""")
@@ -327,7 +327,7 @@ $loopLabel          sty  $indexVar
                         bne  $loopLabel
                         beq  $endLabel""")
                 }
-                if(length>=16 && asmgen.zeropage.available() > 0) {
+                if(length>=16 && asmgen.zeropage.hasByteAvailable()) {
                     // allocate index var on ZP
                     val zpAddr = asmgen.zeropage.allocate(indexVar, DataType.UBYTE, stmt.position, asmgen.errors)
                     asmgen.out("""$indexVar = $zpAddr  ; auto zp UBYTE""")

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

@@ -145,7 +145,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             SourceStorageKind.EXPRESSION -> {
                 when(val value = assign.source.expression!!) {
                     is AddressOf -> {
-                        val sourceName = asmgen.asmVariableName(value.identifier)
+                        val sourceName = asmgen.asmSymbolName(value.identifier)
                         assignAddressOf(assign.target, sourceName)
                     }
                     is NumericLiteralValue -> throw AssemblyError("source kind should have been literalnumber")

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

@@ -1361,21 +1361,21 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     }
                     "*" -> {
                         // stack contains (u) byte value, sign extend that and proceed with regular 16 bit operation
-                        // TODO use an optimized word * byte multiplication routine
+                        // TODO use an optimized word * byte multiplication routine?
                         asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                         asmgen.signExtendAYlsb(valueDt)
                         multiplyVarByWordInAY()
                     }
                     "/" -> {
                         // stack contains (u) byte value, sign extend that and proceed with regular 16 bit operation
-                        // TODO use an optimized word / byte divmod routine
+                        // TODO use an optimized word / byte divmod routine?
                         asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                         asmgen.signExtendAYlsb(valueDt)
                         divideVarByWordInAY()
                     }
                     "%" -> {
                         // stack contains (u) byte value, sign extend that and proceed with regular 16 bit operation
-                        // TODO use an optimized word / byte divmod routine
+                        // TODO use an optimized word / byte divmod routine?
                         asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                         asmgen.signExtendAYlsb(valueDt)
                         remainderVarByWordInAY()

compiler/src/prog8/optimizer/CallGraph.kt

@@ -174,7 +174,7 @@ class CallGraph(private val program: Program) : IAstVisitor {
     }
 
     fun unused(decl: VarDecl): Boolean {
-        if(decl.type!=VarDeclType.VAR || decl.autogeneratedDontRemove)
+        if(decl.type!=VarDeclType.VAR || decl.autogeneratedDontRemove || decl.sharedWithAsm)
             return false
 
         if(decl.definingBlock() !in usedBlocks)

compiler/src/prog8/optimizer/StatementOptimizer.kt

@@ -27,7 +27,12 @@ internal class StatementOptimizer(private val program: Program,
 
     override fun after(subroutine: Subroutine, parent: Node): Iterable<IAstModification> {
         for(returnvar in subsThatNeedReturnVariable) {
-            val decl = VarDecl(VarDeclType.VAR, returnvar.second, ZeropageWish.DONTCARE, null, retvarName, null, false, true, returnvar.third)
+            val decl = VarDecl(VarDeclType.VAR, returnvar.second, ZeropageWish.DONTCARE, null, retvarName, null,
+                isArray = false,
+                autogeneratedDontRemove = true,
+                sharedWithAsm = false,
+                position = returnvar.third
+            )
             returnvar.first.statements.add(0, decl)
         }
         subsThatNeedReturnVariable.clear()
@@ -43,6 +48,48 @@ internal class StatementOptimizer(private val program: Program,
             }
         }
 
+        // printing a literal string of just 2 or 1 characters is replaced by directly outputting those characters
+        // only do this optimization if the arg is a known-constant string literal instead of a user defined variable.
+        if(functionCallStatement.target.nameInSource==listOf("txt", "print")) {
+            val arg = functionCallStatement.args.single()
+            val stringVar: IdentifierReference? = if(arg is AddressOf) {
+                arg.identifier
+            } else {
+                arg as? IdentifierReference
+            }
+            if(stringVar!=null && stringVar.wasStringLiteral(program)) {
+                val string = stringVar.targetVarDecl(program)?.value as? StringLiteralValue
+                if(string!=null) {
+                    val pos = functionCallStatement.position
+                    if (string.value.length == 1) {
+                        val firstCharEncoded = compTarget.encodeString(string.value, string.altEncoding)[0]
+                        val chrout = FunctionCallStatement(
+                            IdentifierReference(listOf("txt", "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 = compTarget.encodeString(string.value.take(2), string.altEncoding)
+                        val chrout1 = FunctionCallStatement(
+                            IdentifierReference(listOf("txt", "chrout"), pos),
+                            mutableListOf(NumericLiteralValue(DataType.UBYTE, firstTwoCharsEncoded[0].toInt(), pos)),
+                            functionCallStatement.void, pos
+                        )
+                        val chrout2 = FunctionCallStatement(
+                            IdentifierReference(listOf("txt", "chrout"), pos),
+                            mutableListOf(NumericLiteralValue(DataType.UBYTE, firstTwoCharsEncoded[1].toInt(), pos)),
+                            functionCallStatement.void, pos
+                        )
+                        return listOf(
+                            IAstModification.InsertBefore(functionCallStatement, chrout1, parent as INameScope),
+                            IAstModification.ReplaceNode(functionCallStatement, chrout2, parent)
+                        )
+                    }
+                }
+            }
+        }
+
         // if the first instruction in the called subroutine is a return statement, remove the jump altogeter
         val subroutine = functionCallStatement.target.targetSubroutine(program)
         if(subroutine!=null) {

compiler/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -1,9 +1,6 @@
 package prog8.optimizer
 
-import prog8.ast.INameScope
-import prog8.ast.Module
-import prog8.ast.Node
-import prog8.ast.Program
+import prog8.ast.*
 import prog8.ast.base.VarDeclType
 import prog8.ast.expressions.BinaryExpression
 import prog8.ast.expressions.FunctionCall
@@ -65,7 +62,7 @@ internal class UnusedCodeRemover(private val program: Program,
     override fun after(block: Block, parent: Node): Iterable<IAstModification> {
         if("force_output" !in block.options()) {
             if (block.containsNoCodeNorVars()) {
-                if(block.name != program.internedStringsModuleName)
+                if(block.name != internedStringsModuleName)
                     errors.warn("removing unused block '${block.name}'", block.position)
                 return listOf(IAstModification.Remove(block, parent as INameScope))
             }
@@ -106,7 +103,7 @@ internal class UnusedCodeRemover(private val program: Program,
     override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
         if(decl.type==VarDeclType.VAR) {
             val forceOutput = "force_output" in decl.definingBlock().options()
-            if (!forceOutput && !decl.autogeneratedDontRemove && !decl.definingBlock().isInLibrary) {
+            if (!forceOutput && !decl.autogeneratedDontRemove && !decl.sharedWithAsm && !decl.definingBlock().isInLibrary) {
                 if (callgraph.unused(decl)) {
                     errors.warn("removing unused variable '${decl.name}'", decl.position)
                     return listOf(IAstModification.Remove(decl, decl.definingScope()))

compiler/test/UnitTests.kt

@@ -179,28 +179,48 @@ class TestC64Zeropage {
     fun testZpDontuse() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), false, false, C64Target))
         println(zp.free)
-        assertEquals(0, zp.available())
+        assertEquals(0, zp.availableBytes())
         assertFailsWith<CompilerException> {
             zp.allocate("", DataType.BYTE, null, errors)
         }
     }
 
     @Test
-    fun testFreeSpaces() {
+    fun testFreeSpacesBytes() {
         val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, C64Target))
-        assertEquals(18, zp1.available())
+        assertEquals(18, zp1.availableBytes())
         val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false, false, C64Target))
-        assertEquals(85, zp2.available())
+        assertEquals(85, zp2.availableBytes())
         val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false, C64Target))
-        assertEquals(125, zp3.available())
+        assertEquals(125, zp3.availableBytes())
         val zp4 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, C64Target))
-        assertEquals(238, zp4.available())
+        assertEquals(238, zp4.availableBytes())
+        zp4.allocate("test", DataType.UBYTE, null, errors)
+        assertEquals(237, zp4.availableBytes())
+        zp4.allocate("test2", DataType.UBYTE, null, errors)
+        assertEquals(236, zp4.availableBytes())
+    }
+
+    @Test
+    fun testFreeSpacesWords() {
+        val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, C64Target))
+        assertEquals(6, zp1.availableWords())
+        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false, false, C64Target))
+        assertEquals(38, zp2.availableWords())
+        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false, C64Target))
+        assertEquals(57, zp3.availableWords())
+        val zp4 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, C64Target))
+        assertEquals(116, zp4.availableWords())
+        zp4.allocate("test", DataType.UWORD, null, errors)
+        assertEquals(115, zp4.availableWords())
+        zp4.allocate("test2", DataType.UWORD, null, errors)
+        assertEquals(114, zp4.availableWords())
     }
 
     @Test
     fun testReservedSpace() {
         val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, C64Target))
-        assertEquals(238, zp1.available())
+        assertEquals(238, zp1.availableBytes())
         assertTrue(50 in zp1.free)
         assertTrue(100 in zp1.free)
         assertTrue(49 in zp1.free)
@@ -209,7 +229,7 @@ class TestC64Zeropage {
         assertTrue(255 in zp1.free)
         assertTrue(199 in zp1.free)
         val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, listOf(50 .. 100, 200..255), false, false, C64Target))
-        assertEquals(139, zp2.available())
+        assertEquals(139, zp2.availableBytes())
         assertFalse(50 in zp2.free)
         assertFalse(100 in zp2.free)
         assertTrue(49 in zp2.free)
@@ -222,18 +242,22 @@ class TestC64Zeropage {
     @Test
     fun testBasicsafeAllocation() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, C64Target))
-        assertEquals(18, zp.available())
+        assertEquals(18, zp.availableBytes())
+        assertTrue(zp.hasByteAvailable())
+        assertTrue(zp.hasWordAvailable())
 
         assertFailsWith<ZeropageDepletedError> {
             // in regular zp there aren't 5 sequential bytes free
             zp.allocate("", DataType.FLOAT, null, errors)
         }
 
-        for (i in 0 until zp.available()) {
+        for (i in 0 until zp.availableBytes()) {
             val loc = zp.allocate("", DataType.UBYTE, null, errors)
             assertTrue(loc > 0)
         }
-        assertEquals(0, zp.available())
+        assertEquals(0, zp.availableBytes())
+        assertFalse(zp.hasByteAvailable())
+        assertFalse(zp.hasWordAvailable())
         assertFailsWith<ZeropageDepletedError> {
             zp.allocate("", DataType.UBYTE, null, errors)
         }
@@ -245,16 +269,18 @@ class TestC64Zeropage {
     @Test
     fun testFullAllocation() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, C64Target))
-        assertEquals(238, zp.available())
+        assertEquals(238, zp.availableBytes())
+        assertTrue(zp.hasByteAvailable())
+        assertTrue(zp.hasWordAvailable())
         val loc = zp.allocate("", DataType.UWORD, null, errors)
         assertTrue(loc > 3)
         assertFalse(loc in zp.free)
-        val num = zp.available() / 2
+        val num = zp.availableBytes() / 2
 
         for(i in 0..num-4) {
             zp.allocate("", DataType.UWORD, null, errors)
         }
-        assertEquals(6,zp.available())
+        assertEquals(6,zp.availableBytes())
 
         assertFailsWith<ZeropageDepletedError> {
             // can't allocate because no more sequential bytes, only fragmented
@@ -265,7 +291,9 @@ class TestC64Zeropage {
             zp.allocate("", DataType.UBYTE, null, errors)
         }
 
-        assertEquals(0, zp.available())
+        assertEquals(0, zp.availableBytes())
+        assertFalse(zp.hasByteAvailable())
+        assertFalse(zp.hasWordAvailable())
         assertFailsWith<ZeropageDepletedError> {
             // no more space
             zp.allocate("", DataType.UBYTE, null, errors)
@@ -275,7 +303,7 @@ class TestC64Zeropage {
     @Test
     fun testEfficientAllocation() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(),  true, false, C64Target))
-        assertEquals(18, zp.available())
+        assertEquals(18, zp.availableBytes())
         assertEquals(0x04, zp.allocate("", DataType.WORD, null, errors))
         assertEquals(0x06, zp.allocate("", DataType.UBYTE, null, errors))
         assertEquals(0x0a, zp.allocate("", DataType.UBYTE, null, errors))
@@ -288,7 +316,7 @@ class TestC64Zeropage {
         assertEquals(0x92, zp.allocate("", DataType.UBYTE, null, errors))
         assertEquals(0x96, zp.allocate("", DataType.UBYTE, null, errors))
         assertEquals(0xf9, zp.allocate("", DataType.UBYTE, null, errors))
-        assertEquals(0, zp.available())
+        assertEquals(0, zp.availableBytes())
     }
 
     @Test
@@ -301,6 +329,8 @@ class TestC64Zeropage {
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class TestCx16Zeropage {
+    private val errors = ErrorReporter()
+
     @Test
     fun testReservedLocations() {
         val zp = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, false, Cx16Target))
@@ -308,19 +338,37 @@ class TestCx16Zeropage {
     }
 
     @Test
-    fun testFreeSpaces() {
+    fun testFreeSpacesBytes() {
         val zp1 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, Cx16Target))
-        assertEquals(88, zp1.available())
-        val zp3 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false, Cx16Target))
-        assertEquals(175, zp3.available())
-        val zp4 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, Cx16Target))
-        assertEquals(216, zp4.available())
+        assertEquals(88, zp1.availableBytes())
+        val zp2 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false, Cx16Target))
+        assertEquals(175, zp2.availableBytes())
+        val zp3 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, Cx16Target))
+        assertEquals(216, zp3.availableBytes())
+        zp3.allocate("test", DataType.UBYTE, null, errors)
+        assertEquals(215, zp3.availableBytes())
+        zp3.allocate("test2", DataType.UBYTE, null, errors)
+        assertEquals(214, zp3.availableBytes())
+    }
+
+    @Test
+    fun testFreeSpacesWords() {
+        val zp1 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, Cx16Target))
+        assertEquals(108, zp1.availableWords())
+        val zp2 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false, Cx16Target))
+        assertEquals(87, zp2.availableWords())
+        val zp3 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, Cx16Target))
+        assertEquals(44, zp3.availableWords())
+        zp3.allocate("test", DataType.UWORD, null, errors)
+        assertEquals(43, zp3.availableWords())
+        zp3.allocate("test2", DataType.UWORD, null, errors)
+        assertEquals(42, zp3.availableWords())
     }
 
     @Test
     fun testReservedSpace() {
         val zp1 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, Cx16Target))
-        assertEquals(216, zp1.available())
+        assertEquals(216, zp1.availableBytes())
         assertTrue(0x22 in zp1.free)
         assertTrue(0x80 in zp1.free)
         assertTrue(0xff in zp1.free)
@@ -502,7 +550,7 @@ class TestMemory {
 
     @Test
     private fun createTestProgramForMemoryRefViaVar(address: Int, vartype: VarDeclType): AssignTarget {
-        val decl = VarDecl(vartype, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
+        val decl = VarDecl(vartype, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, false, Position.DUMMY)
         val memexpr = IdentifierReference(listOf("address"), Position.DUMMY)
         val target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
@@ -522,7 +570,7 @@ class TestMemory {
 
     @Test
     fun testInValidRamC64_variable() {
-        val decl = VarDecl(VarDeclType.VAR, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", null, false, false, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.VAR, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", null, false, false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
         val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
@@ -535,7 +583,7 @@ class TestMemory {
     @Test
     fun testInValidRamC64_memmap_variable() {
         val address = 0x1000
-        val decl = VarDecl(VarDeclType.MEMORY, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
         val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
@@ -548,7 +596,7 @@ class TestMemory {
     @Test
     fun testNotInValidRamC64_memmap_variable() {
         val address = 0xd020
-        val decl = VarDecl(VarDeclType.MEMORY, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
         val subroutine = Subroutine("test", emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
@@ -560,7 +608,7 @@ class TestMemory {
 
     @Test
     fun testInValidRamC64_array() {
-        val decl = VarDecl(VarDeclType.VAR, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, false, false, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.VAR, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, false, false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
@@ -574,7 +622,7 @@ class TestMemory {
     @Test
     fun testInValidRamC64_array_memmapped() {
         val address = 0x1000
-        val decl = VarDecl(VarDeclType.MEMORY, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
@@ -588,7 +636,7 @@ class TestMemory {
     @Test
     fun testNotValidRamC64_array_memmapped() {
         val address = 0xe000
-        val decl = VarDecl(VarDeclType.MEMORY, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)

compilerAst/build.gradle

@@ -1,7 +1,7 @@
 plugins {
     id 'antlr'
     id 'java'
-    id "org.jetbrains.kotlin.jvm" version "1.5.0"
+    id "org.jetbrains.kotlin.jvm" version "1.5.10"
 }
 
 targetCompatibility = 11

compilerAst/src/prog8/ast/AstToSourceCode.kt

@@ -7,7 +7,6 @@ import prog8.ast.base.VarDeclType
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.IAstVisitor
-import java.util.*
 
 
 class AstToSourceCode(val output: (text: String) -> Unit, val program: Program): IAstVisitor {

compilerAst/src/prog8/ast/AstToplevel.kt

@@ -8,6 +8,8 @@ import prog8.ast.walk.IAstVisitor
 import java.nio.file.Path
 import kotlin.math.abs
 
+const val internedStringsModuleName = "prog8_interned_strings"
+
 interface IStringEncoding {
     fun encodeString(str: String, altEncoding: Boolean): List<Short>
     fun decodeString(bytes: List<Short>, altEncoding: Boolean): String
@@ -256,8 +258,7 @@ class Program(val name: String,
         get() = mainModule.loadAddress
 
     var actualLoadAddress: Int = 0
-    private val internedStrings = mutableMapOf<Pair<String, Boolean>, List<String>>()
-    val internedStringsModuleName = "prog8_interned_strings"
+    private val internedStringsUnique = mutableMapOf<Pair<String, Boolean>, List<String>>()
 
     init {
         // insert a container module for all interned strings later
@@ -281,21 +282,40 @@ class Program(val name: String,
     }
 
     fun internString(string: StringLiteralValue): List<String> {
+        // Move a string literal into the internal, deduplicated, string pool
+        // replace it with a variable declaration that points to the entry in the pool.
+
+        if(string.parent is VarDecl) {
+            // deduplication can only be performed safely for known-const strings (=string literals OUTSIDE OF A VARDECL)!
+            throw FatalAstException("cannot intern a string literal that's part of a vardecl")
+        }
+
+        fun getScopedName(string: StringLiteralValue): List<String> {
+            val internedStringsBlock = modules
+                .first { it.name == internedStringsModuleName }.statements
+                .first { it is Block && it.name == internedStringsModuleName } as Block
+            val varName = "string_${internedStringsBlock.statements.size}"
+            val decl = VarDecl(
+                VarDeclType.VAR, DataType.STR, ZeropageWish.NOT_IN_ZEROPAGE, null, varName, string,
+                isArray = false, autogeneratedDontRemove = true, sharedWithAsm = false, position = string.position
+            )
+            internedStringsBlock.statements.add(decl)
+            decl.linkParents(internedStringsBlock)
+            return listOf(internedStringsModuleName, decl.name)
+        }
+
         val key = Pair(string.value, string.altEncoding)
-        val existing = internedStrings[key]
-        if(existing!=null)
+        val existing = internedStringsUnique[key]
+        if (existing != null)
             return existing
 
-        val decl = VarDecl(VarDeclType.VAR, DataType.STR, ZeropageWish.NOT_IN_ZEROPAGE, null, "string_${internedStrings.size}", string,
-            isArray = false, autogeneratedDontRemove = true, position = string.position)
-        val internedStringsBlock = modules.first { it.name==internedStringsModuleName }.statements.first { it is Block && it.name == internedStringsModuleName}
-        (internedStringsBlock as Block).statements.add(decl)
-        decl.linkParents(internedStringsBlock)
-        val scopedName = listOf(internedStringsModuleName, decl.name)
-        internedStrings[key] = scopedName
+        val scopedName = getScopedName(string)
+        internedStringsUnique[key] = scopedName
         return scopedName
     }
 
+
+
     fun allBlocks(): List<Block> = modules.flatMap { it.statements.filterIsInstance<Block>() }
 
     override val position: Position = Position.DUMMY

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

@@ -13,7 +13,6 @@ import prog8.parser.prog8Parser
 import java.io.CharConversionException
 import java.io.File
 import java.nio.file.Path
-import java.util.*
 
 
 /***************** Antlr Extension methods to create AST ****************/
@@ -70,6 +69,7 @@ private fun prog8Parser.VariabledeclarationContext.toAst(encoding: IStringEncodi
                 it.expression().toAst(encoding),
                 vd.ARRAYSIG() != null || vd.arrayindex() != null,
                 false,
+                vd.SHARED()!=null,
                 it.toPosition()
         )
     }
@@ -86,6 +86,7 @@ private fun prog8Parser.VariabledeclarationContext.toAst(encoding: IStringEncodi
                 cvarinit.expression().toAst(encoding),
                 vd.ARRAYSIG() != null || vd.arrayindex() != null,
                 false,
+                vd.SHARED() != null,
                 cvarinit.toPosition()
         )
     }
@@ -102,6 +103,7 @@ private fun prog8Parser.VariabledeclarationContext.toAst(encoding: IStringEncodi
                 mvarinit.expression().toAst(encoding),
                 vd.ARRAYSIG() != null || vd.arrayindex() != null,
                 false,
+                vd.SHARED()!=null,
                 mvarinit.toPosition()
         )
     }
@@ -604,6 +606,7 @@ private fun prog8Parser.VardeclContext.toAst(encoding: IStringEncoding): VarDecl
             null,
             ARRAYSIG() != null || arrayindex() != null,
             false,
+            SHARED()!=null,
             toPosition()
     )
 }

compilerAst/src/prog8/ast/antlr/EscapeChars.kt

@@ -10,9 +10,9 @@ fun escape(str: String): String {
             '\n' -> "\\n"
             '\r' -> "\\r"
             '"' -> "\\\""
-            in '\u8000'..'\u80ff' -> "\\x" + (it.toInt() - 0x8000).toString(16).padStart(2, '0')
+            in '\u8000'..'\u80ff' -> "\\x" + (it.code - 0x8000).toString(16).padStart(2, '0')
             in '\u0000'..'\u00ff' -> it.toString()
-            else -> "\\u" + it.toInt().toString(16).padStart(4, '0')
+            else -> "\\u" + it.code.toString(16).padStart(4, '0')
         }
     }
     return es.joinToString("")

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

@@ -6,7 +6,7 @@ import prog8.ast.base.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstVisitor
-import java.util.Objects
+import java.util.*
 import kotlin.math.abs
 
 
@@ -788,6 +788,15 @@ data class IdentifierReference(val nameInSource: List<String>, override val posi
             else -> InferredTypes.InferredType.unknown()
         }
     }
+
+    fun wasStringLiteral(program: Program): Boolean {
+        val decl = targetVarDecl(program)
+        if(decl == null || !decl.autogeneratedDontRemove)
+            return false
+
+        val scope=decl.definingModule()
+        return scope.name==internedStringsModuleName
+    }
 }
 
 class FunctionCall(override var target: IdentifierReference,

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

@@ -164,6 +164,7 @@ open class VarDecl(val type: VarDeclType,
                    var value: Expression?,
                    val isArray: Boolean,
                    val autogeneratedDontRemove: Boolean,
+                   val sharedWithAsm: Boolean,
                    override val position: Position) : Statement(), ISymbolStatement {
     override lateinit var parent: Node
     var allowInitializeWithZero = true
@@ -183,7 +184,7 @@ open class VarDecl(val type: VarDeclType,
             val declaredType = ArrayToElementTypes.getValue(arrayDt)
             val arraysize = ArrayIndex.forArray(array)
             return VarDecl(VarDeclType.VAR, declaredType, ZeropageWish.NOT_IN_ZEROPAGE, arraysize, autoVarName, array,
-                    isArray = true, autogeneratedDontRemove = true, position = array.position)
+                    isArray = true, autogeneratedDontRemove = true, sharedWithAsm = false, position = array.position)
         }
 
         fun defaultZero(dt: DataType, position: Position) = when(dt) {
@@ -239,7 +240,7 @@ open class VarDecl(val type: VarDeclType,
     }
 
     fun copy(): VarDecl {
-        val c = VarDecl(type, declaredDatatype, zeropage, arraysize, name, value, isArray, autogeneratedDontRemove, position)
+        val c = VarDecl(type, declaredDatatype, zeropage, arraysize, name, value, isArray, autogeneratedDontRemove, sharedWithAsm, position)
         c.allowInitializeWithZero = this.allowInitializeWithZero
         return c
     }
@@ -247,7 +248,7 @@ open class VarDecl(val type: VarDeclType,
 
 // a vardecl used only for subroutine parameters
 class ParameterVarDecl(name: String, declaredDatatype: DataType, position: Position)
-    : VarDecl(VarDeclType.VAR, declaredDatatype, ZeropageWish.DONTCARE, null, name, null, false, true, position)
+    : VarDecl(VarDeclType.VAR, declaredDatatype, ZeropageWish.DONTCARE, null, name, null, false, true, false, position)
 
 class ArrayIndex(var indexExpr: Expression,
                  override val position: Position) : Node {
@@ -537,7 +538,7 @@ class InlineAssembly(val assembly: String, override val position: Position) : St
 
 class AnonymousScope(override var statements: MutableList<Statement>,
                      override val position: Position) : INameScope, Statement() {
-    override val name: String
+    override val name: String = "<anon-$sequenceNumber>"
     override lateinit var parent: Node
 
     companion object {
@@ -545,7 +546,7 @@ class AnonymousScope(override var statements: MutableList<Statement>,
     }
 
     init {
-        name = "<anon-$sequenceNumber>"     // make sure it's an invalid soruce code identifier so user source code can never produce it
+        // make sure it's an invalid soruce code identifier so user source code can never produce it
         sequenceNumber++
     }
 
@@ -587,6 +588,8 @@ class AsmGenInfo {
     var usedRegsaveY = false
     var usedFloatEvalResultVar1 = false
     var usedFloatEvalResultVar2 = false
+
+    val extraVars = mutableListOf<Triple<DataType, String, Int?>>()
 }
 
 // the subroutine class covers both the normal user-defined subroutines,

compilerAst/src/prog8/ast/walk/AstWalker.kt

@@ -175,7 +175,7 @@ abstract class AstWalker {
     fun applyModifications(): Int {
         // check if there are double removes, keep only the last one
         val removals = modifications.filter { it.first is IAstModification.Remove }
-        if(removals.size>0) {
+        if(removals.isNotEmpty()) {
             val doubles = removals.groupBy { (it.first as IAstModification.Remove).node }.filter { it.value.size>1 }
             doubles.forEach {
                 for(doubleRemove in it.value.dropLast(1)) {

compilerAst/src/prog8/parser/ModuleParsing.kt

@@ -25,7 +25,10 @@ fun moduleName(fileName: Path) = fileName.toString().substringBeforeLast('.')
 internal fun pathFrom(stringPath: String, vararg rest: String): Path  = FileSystems.getDefault().getPath(stringPath, *rest)
 
 
-class ModuleImporter(val program: Program, val encoder: IStringEncoding, val compilationTargetName: String, val libdirs: List<String>) {
+class ModuleImporter(private val program: Program,
+                     private val encoder: IStringEncoding,
+                     private val compilationTargetName: String,
+                     private val libdirs: List<String>) {
 
     fun importModule(filePath: Path): Module {
         print("importing '${moduleName(filePath.fileName)}'")
@@ -41,7 +44,10 @@ class ModuleImporter(val program: Program, val encoder: IStringEncoding, val com
         if(!Files.isReadable(filePath))
             throw ParsingFailedError("No such file: $filePath")
 
-        val content = filePath.toFile().readText().replace("\r\n", "\n")
+        var content = filePath.toFile().readText().replace("\r\n", "\n")    // normalize line endings
+        if(content.last()!='\n')
+            content+='\n'   // grammar requires blocks (and thus module files) to end in an EOL
+
         return importModule(CharStreams.fromString(content), filePath, false)
     }
 

dbusCompilerService/build.gradle

@@ -2,7 +2,7 @@
 plugins {
     id 'java'
     id 'application'
-    id "org.jetbrains.kotlin.jvm" version "1.5.0"
+    id "org.jetbrains.kotlin.jvm" version "1.5.10"
     id 'com.github.johnrengelman.shadow' version '6.1.0'
 }
 

docs/source/programming.rst

@@ -67,8 +67,6 @@ Label
     This is a named position in your code where you can jump to from another place.
     You can jump to it with a jump statement elsewhere. It is also possible to use a
     subroutine call to a label (but without parameters and return value).
-    Labels can only be defined in a block or in another subroutine, so you can't define a label
-    inside a loop statement block for instance.
 
 Scope
 	Also known as 'namespace', this is a named box around the symbols defined in it.
@@ -204,6 +202,16 @@ Example::
     byte  @zp  zeropageCounter = 42
 
 
+*shared tag:*
+If you add the ``@shared`` tag to the variable declaration, the compiler will know that this variable
+is a prog8 variable shared with some assembly code elsewhere. This means that the assembly code can
+refer to the variable even if it's otherwise not used in prog8 code itself.
+(usually, these kinds of 'unused' variables are optimized away by the compiler, resulting in an error
+when assembling the rest of the code). Example::
+
+    byte  @shared  assemblyVariable = 42
+
+
 Integers
 ^^^^^^^^
 
@@ -320,14 +328,22 @@ read the syntax reference on strings.
     For regular assignments you still need to use an explicit ``&`` (address-of) to take
     the address of the string or array.
 
-.. caution::
-    It's probably best to avoid changing the contents in strings and treat them as static.
-    This includes changing certain letters by index, or by assigning a new value, or by
-    modifying the string via other means for example ``substr`` function and its cousins.
-    This is because the changes persist in memory. If your program exits and is restarted
-    (without reloading it from disk), it will then start working with the modified strings
-    instead of the original ones!
-    The same is true for arrays! So be careful to (re)initialize them if needed.
+.. note:: Strings and their (im)mutability
+
+    *String literals outside of a string variable's initialization value*,
+    are considered to be "constant", i.e. the string isn't going to change
+    during the execution of the program. The compiler takes advantage of this in certain
+    ways. For instance, multiple identical occurrences of a string literal are folded into
+    just one string allocation in memory. Examples of such strings are the string literals
+    passed to a subroutine as arguments.
+
+    *Strings that aren't such string literals are considered to be unique*, even if they
+    are the same as a string defined elsewhere. This includes the strings assigned to
+    a string variable in its declaration! These kind of strings are not deduplicated and
+    are just copied into the program in their own unique part of memory. This means that
+    it is okay to treat those strings as mutable; you can safely change the contents
+    of such a string without destroying other occurrences (as long as you stay within
+    the size of the allocated string!)
 
 
 Special types: const and memory-mapped

docs/source/syntaxreference.rst

@@ -108,7 +108,7 @@ Directives
 
 .. data:: %import <name>
 
-	Level: module, block.
+	Level: module.
 	This reads and compiles the named module source file as part of your current program.
 	Symbols from the imported module become available in your code,
 	without a module or filename prefix.
@@ -136,32 +136,32 @@ Directives
 
 .. data:: %asmbinary "<filename>" [, <offset>[, <length>]]
 
-    Level: block.
+    Level: not at module scope.
     This directive can only be used inside a block.
     The assembler will include the file as binary bytes at this point, prog8 will not process this at all.
     The optional offset and length can be used to select a particular piece of the file.
     The file is located relative to the current working directory!
 
-.. data:: %asminclude "<filename>", "scopelabel"
+.. data:: %asminclude "<filename>"
 
-    Level: block.
+    Level: not at module scope.
     This directive can only be used inside a block.
     The assembler will include the file as raw assembly source text at this point,
-    prog8 will not process this at all, with one exception: the labels.
-    The scopelabel argument will be used as a prefix to access the labels from the included source code,
-    otherwise you would risk symbol redefinitions or duplications.
-    If you know what you are doing you can leave it as an empty string to not have a scope prefix.
+    prog8 will not process this at all. Symbols defined in the included assembly can not be referenced
+    from prog8 code. However they can be referenced from other assembly code if properly prefixed.
+    Be careful: you risk symbol redefinitions or duplications if you include a piece of
+    assembly into a prog8 block that already defines symbols itself.
     The compiler first looks for the file relative to the same directory as the module containing this statement is in,
     if the file can't be found there it is searched relative to the current directory.
 
 .. data:: %breakpoint
 
-	Level: block, subroutine.
+    Level: not at module scope.
 	Defines a debugging breakpoint at this location. See :ref:`debugging`
 
 .. data:: %asm {{ ... }}
 
-	Level: block, subroutine.
+    Level: not at module scope.
 	Declares that there is *inline assembly code* in the lines enclosed by the curly braces.
 	This code will be written as-is into the generated output file.
 	The assembler syntax used should be for the 3rd party cross assembler tool that Prog8 uses.
@@ -235,9 +235,11 @@ for them. You can give them an initial value as well. That value can be a simple
 or an expression. If you don't provide an intial value yourself, zero will be used.
 You can add a ``@zp`` zeropage-tag, to tell the compiler to prioritize it
 when selecting variables to be put into zeropage.
+You can add a ``@shared`` shared-tag, to tell the compiler that the variable is shared
+with some assembly code and that it should not be optimized away if not used elsewhere.
 The syntax is::
 
-	<datatype>  [ @zp ]  <variable name>   [ = <initial value> ]
+	<datatype>  [ @shared ] [ @zp ]  <variable name>   [ = <initial value> ]
 
 Various examples::
 
@@ -252,7 +254,8 @@ Various examples::
     byte[5]     values                  ; array of 5 bytes, initially set to zero
     byte[5]     values  = 255           ; initialize with five 255 bytes
 
-    word  @zp   zpword = 9999           ; prioritize this when selecting vars for zeropage storage
+    word  @zp     zpword = 9999         ; prioritize this when selecting vars for zeropage storage
+    word  @shared asmvar                ; variable is used in assembly code but not elsewhere
 
 
 Data types

docs/source/todo.rst

@@ -2,11 +2,7 @@
 TODO
 ====
 
-- possible idea: option to mark vardecls 'shared' to indicate they should not be optimized away because they're shared with assembly code?
-  However: who even needs variables declared in prog8 code that are only used by assembly???
-- github issue: make strings no longer immutable? Deduplication selectable via command line switch?
-
-- test all examples before release of the new version
+- test all examples (including imgviewer, assembler and petaxian) before release of the new version
 
 - simplify cx16.joystick_get2() once this cx16 rom issue is resolved: https://github.com/commanderx16/x16-rom/issues/203
 - c64: make the graphics.BITMAP_ADDRESS configurable (VIC banking)

examples/cx16/colorbars.p8

@@ -0,0 +1,127 @@
+%import gfx2
+%import palette
+%import textio
+
+
+; TODO WORK IN PROGRESS...
+; want to make Amiga 'copper' bars color cycling effects
+
+
+main {
+    sub start() {
+        palette.set_all_black()
+        gfx2.screen_mode(4)
+
+        ubyte yy
+        for yy in 0 to 239
+            gfx2.horizontal_line(0, yy, 320, yy & 63)
+
+        repeat {
+            colors.random_bar()
+            colors.set_palette()
+            repeat 20
+                sys.waitvsync()
+        }
+
+        repeat {
+        }
+    }
+
+}
+
+colors {
+    ubyte cr
+    ubyte cg
+    ubyte cb
+    ubyte[48+16] reds
+    ubyte[48+16] greens
+    ubyte[48+16] blues
+    ubyte bar_size
+
+    sub random_rgb12() {
+        do {
+            uword rr = rndw()
+            cr = msb(rr) & 15
+            cg = lsb(rr)
+            cb = cg & 15
+            cg >>= 4
+        } until cr+cg+cb >= 12
+    }
+
+    sub random_bar() {
+        ; fade black -> color then fade color -> white
+        random_rgb12()
+        ubyte r=0
+        ubyte g=0
+        ubyte b=0
+        ubyte different
+        bar_size = 0
+
+        repeat {
+            different = false
+            if r != cr {
+                different = true
+                r++
+            }
+            if g != cg {
+                different = true
+                g++
+            }
+            if b != cb {
+                different = true
+                b++
+            }
+            if not different
+                break
+            reds[bar_size] = r
+            greens[bar_size] = g
+            blues[bar_size] = b
+            bar_size++
+        }
+        repeat {
+            different = false
+            if r != 15 {
+                different = true
+                r++
+            }
+            if g != 15 {
+                different = true
+                g++
+            }
+            if b != 15 {
+                different = true
+                b++
+            }
+            if not different
+                break
+            reds[bar_size] = r
+            greens[bar_size] = g
+            blues[bar_size] = b
+            bar_size++
+        }
+        ; mirror bottom half from top half
+        ubyte mi = bar_size-1
+        repeat mi {
+            reds[bar_size] = reds[mi]
+            greens[bar_size] = greens[mi]
+            blues[bar_size] = blues[mi]
+            bar_size++
+            mi--
+        }
+        ; make rest of bar black (bars are not always the same length using the simplistic algorithm above...)
+        while bar_size != 48+16 {
+            reds[bar_size] = $0
+            greens[bar_size] = $0
+            blues[bar_size] = $0
+            bar_size++
+        }
+    }
+
+    sub set_palette() {
+        ubyte ix
+        for ix in 0 to 48+15 {
+            uword color = mkword(reds[ix], (greens[ix] << 4) | blues[ix] )
+            palette.set_color(ix, color)
+        }
+    }
+}

examples/test.p8

@@ -1,23 +1,109 @@
 %import textio
 %zeropage basicsafe
-%option no_sysinit
 
 main {
 
-	byte[] xs1 = "foo1" ; <<<<<<<<<<<<
-	str xs2 = "foo2" ; <<<<<<<<<<<<
-	sub start() {
-	    txt.print(xs1)
-            stringopt()
-	}
+    ; test program for the optimization of repeat var allocation (asmgen.createRepeatCounterVar)
+    ; output must be:  60  6164  6224  12328
 
-        sub stringopt() {
-            str  message = "a"
+    uword xx
 
-            txt.print(message)
-            txt.nl()
-            message[0] = '@'
-            txt.print(message)
-            txt.nl()
+    sub start() {
+
+        xx=0
+
+        repeat 10 {
+            xx++
         }
+        repeat 10 {
+            xx++
+        }
+        repeat 10 {
+            xx++
+        }
+        repeat 10 {
+            xx++
+        }
+        repeat 5 {
+            repeat 4 {
+                xx++
+            }
+        }
+        txt.print_uw(xx)
+        txt.nl()
+
+        repeat 1000 {
+            xx++
+        }
+        repeat 1000 {
+            xx++
+        }
+        repeat 1000 {
+            xx++
+        }
+        repeat 260 {
+            repeat 4 {
+                xx++
+            }
+        }
+        repeat 260 {
+            repeat 260 {
+                xx++
+            }
+        }
+        txt.print_uw(xx)
+        txt.nl()
+
+        sub2()
+
+        if xx!=12328
+            txt.print("\n!fail!\n")
+        else
+            txt.print("\nok\n")
+    }
+
+    sub sub2() {
+
+        repeat 10 {
+            xx++
+        }
+        repeat 10 {
+            xx++
+        }
+        repeat 10 {
+            xx++
+        }
+        repeat 10 {
+            xx++
+        }
+        repeat 5 {
+            repeat 4 {
+                xx++
+            }
+        }
+        txt.print_uw(xx)
+        txt.nl()
+
+        repeat 1000 {
+            xx++
+        }
+        repeat 1000 {
+            xx++
+        }
+        repeat 1000 {
+            xx++
+        }
+        repeat 260 {
+            repeat 4 {
+                xx++
+            }
+        }
+        repeat 260 {
+            repeat 260 {
+                xx++
+            }
+        }
+        txt.print_uw(xx)
+        txt.nl()
+    }
 }

httpCompilerService/build.gradle

@@ -2,7 +2,7 @@
 plugins {
     id 'java'
     id 'application'
-    id "org.jetbrains.kotlin.jvm" version "1.5.0"
+    id "org.jetbrains.kotlin.jvm" version "1.5.10"
     id 'com.github.johnrengelman.shadow' version '6.1.0'
 }
 

parser/antlr/prog8.g4

@@ -62,11 +62,14 @@ ZEROPAGE :
     '@zp'
     ;
 
+SHARED :
+    '@shared'
+    ;
+
 ARRAYSIG :
     '[]'
     ;
 
-
 cpuregister: 'A' | 'X' | 'Y';
 register: 'A' | 'X' | 'Y' | 'AX' | 'AY' | 'XY' | 'Pc' | 'Pz' | 'Pn' | 'Pv' | 'R0' | 'R1' | 'R2' | 'R3' | 'R4' | 'R5' | 'R6' | 'R7' | 'R8' | 'R9' | 'R10' | 'R11' | 'R12' | 'R13' | 'R14' | 'R15';
 
@@ -134,7 +137,7 @@ directive :
 
 directivearg : stringliteral | identifier | integerliteral ;
 
-vardecl: datatype ZEROPAGE? (arrayindex | ARRAYSIG) ? varname=identifier ;
+vardecl: datatype SHARED? ZEROPAGE? (arrayindex | ARRAYSIG) ? varname=identifier ;
 
 varinitializer : vardecl '=' expression ;
 

syntax-files/IDEA/Prog8.xml

@@ -13,7 +13,7 @@
     </options>
     <keywords keywords="&amp;;-&gt;;@;\$;and;as;asmsub;break;clobbers;do;downto;else;false;for;goto;if;if_cc;if_cs;if_eq;if_mi;if_ne;if_neg;if_nz;if_pl;if_pos;if_vc;if_vs;if_z;in;inline;not;or;repeat;return;romsub;step;sub;to;true;until;when;while;xor;~" ignore_case="false" />
     <keywords2 keywords="%address;%asm;%asmbinary;%asminclude;%breakpoint;%import;%launcher;%option;%output;%target;%zeropage;%zpreserved" />
-    <keywords3 keywords="byte;const;float;str;ubyte;uword;void;word;zp" />
+    <keywords3 keywords="byte;const;float;shared;str;ubyte;uword;void;word;zp" />
     <keywords4 keywords="abs;acos;all;any;asin;atan;avg;callfar;callrom;ceil;cmp;cos;cos16;cos16u;cos8;cos8u;deg;floor;len;ln;log2;lsb;lsl;lsr;max;memory;min;mkword;msb;peek;peekw;poke;pokew;rad;reverse;rnd;rndf;rndw;rol;rol2;ror;ror2;round;sgn;sin;sin16;sin16u;sin8;sin8u;sizeof;sort;sqrt;sqrt16;sum;swap;tan" />
   </highlighting>
   <extensionMap>

syntax-files/NotepadPlusPlus/Prog8.xml

@@ -24,7 +24,7 @@
             <Keywords name="Folders in comment, open"></Keywords>
             <Keywords name="Folders in comment, middle"></Keywords>
             <Keywords name="Folders in comment, close"></Keywords>
-            <Keywords name="Keywords1">void const&#x000D;&#x000A;str&#x000D;&#x000A;byte ubyte&#x000D;&#x000A;word uword&#x000D;&#x000A;float&#x000D;&#x000A;zp</Keywords>
+            <Keywords name="Keywords1">void const&#x000D;&#x000A;str&#x000D;&#x000A;byte ubyte&#x000D;&#x000A;word uword&#x000D;&#x000A;float&#x000D;&#x000A;zp shared</Keywords>
             <Keywords name="Keywords2">%address&#x000D;&#x000A;%asm&#x000D;&#x000A;%asmbinary&#x000D;&#x000A;%asminclude&#x000D;&#x000A;%breakpoint&#x000D;&#x000A;%import&#x000D;&#x000A;%launcher&#x000D;&#x000A;%option&#x000D;&#x000A;%output&#x000D;&#x000A;%target&#x000D;&#x000A;%zeropage&#x000D;&#x000A;%zpreserved</Keywords>
             <Keywords name="Keywords3">inline sub asmsub romsub&#x000D;&#x000A;clobbers&#x000D;&#x000A;asm&#x000D;&#x000A;if&#x000D;&#x000A;when else&#x000D;&#x000A;if_cc if_cs if_eq if_mi if_neg if_nz if_pl if_pos if_vc if_vs if_z&#x000D;&#x000A;for in step do while repeat&#x000D;&#x000A;break return goto</Keywords>
             <Keywords name="Keywords4">abs acos all any asin atan avg callfar callrom ceil cmp cos cos16 cos16u cos8 cos8u deg floor len ln log2 lsb lsl lsr max memory min mkword msb peek peekw poke pokew rad reverse rnd rndf rndw rol rol2 ror ror2 round sgn sin sin16 sin16u sin8 sin8u sizeof sort sqrt sqrt16 sum swap tan&#x000D;&#x000A;</Keywords>

syntax-files/Vim/prog8.vim

@@ -43,7 +43,7 @@ syn region prog8ArrayType matchgroup=prog8Type
             \ start="\<\%(u\?byte\|u\?word\|float\|str\)\[" end="\]"
             \ transparent
 syn keyword prog8StorageClass const
-syn match prog8StorageClass "\(^\|\s\)@zp\>"
+syn match prog8StorageClass "\(^\|\s\)\(@zp\|@shared\)\>"
 
 syn region prog8Block start="{" end="}" transparent
 syn region prog8Expression start="(" end=")" transparent