From d9ab2f8b906fd1eb43132d71851902b79f66caa6 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Fri, 3 Sep 2021 23:00:00 +0200
Subject: [PATCH 01/17] upgrade to kotlin 1.5.30

---
 build.gradle                        | 2 +-
 compilerAst/test/TestAntlrParser.kt | 9 ++++++---
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/build.gradle b/build.gradle
index c122ddb22..b048f783a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,3 +1,3 @@
 plugins {
-    id "org.jetbrains.kotlin.jvm" version "1.5.20" apply false
+    id "org.jetbrains.kotlin.jvm" version "1.5.30" apply false
 }
diff --git a/compilerAst/test/TestAntlrParser.kt b/compilerAst/test/TestAntlrParser.kt
index bb90bfb34..9a7868a3d 100644
--- a/compilerAst/test/TestAntlrParser.kt
+++ b/compilerAst/test/TestAntlrParser.kt
@@ -6,7 +6,6 @@ import org.junit.jupiter.api.Test
 import prog8.ast.IBuiltinFunctions
 import prog8.ast.IMemSizer
 import prog8.ast.IStringEncoding
-import prog8.ast.Program
 import prog8.ast.antlr.toAst
 import prog8.ast.base.DataType
 import prog8.ast.base.Position
@@ -14,9 +13,13 @@ import prog8.ast.expressions.Expression
 import prog8.ast.expressions.InferredTypes
 import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.statements.Block
-import prog8.parser.*
+import prog8.parser.ParsingFailedError
+import prog8.parser.prog8Lexer
+import prog8.parser.prog8Parser
 import java.nio.file.Path
-import kotlin.test.*
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertIs
 
 class TestAntlrParser {
 

From fd1f30f92b8d02734c83c603d63ca90467b56161 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Sat, 4 Sep 2021 15:01:16 +0200
Subject: [PATCH 02/17] removed %target directive (didn't add much, too
 confusing, only supported single target)

---
 compiler/res/prog8lib/c64/floats.p8           |  1 -
 compiler/res/prog8lib/c64/graphics.p8         |  1 -
 compiler/res/prog8lib/c64/syslib.p8           |  2 -
 compiler/res/prog8lib/c64/textio.p8           |  1 -
 compiler/res/prog8lib/cx16/floats.p8          |  1 -
 compiler/res/prog8lib/cx16/gfx2.p8            |  2 -
 compiler/res/prog8lib/cx16/graphics.p8        |  1 -
 compiler/res/prog8lib/cx16/palette.p8         |  2 -
 compiler/res/prog8lib/cx16/syslib.p8          |  3 -
 compiler/res/prog8lib/cx16/textio.p8          |  1 -
 .../compiler/astprocessing/AstChecker.kt      |  8 ---
 .../astprocessing/AstIdentifiersChecker.kt    | 10 ---
 compilerAst/src/prog8/parser/ModuleParsing.kt |  2 +-
 docs/source/syntaxreference.rst               |  7 ---
 examples/balloonflight.p8                     |  1 -
 examples/bdmusic-irq.p8                       |  1 -
 examples/bdmusic.p8                           |  1 -
 examples/charset.p8                           |  1 -
 examples/cube3d-sprites.p8                    |  1 -
 examples/cube3d.p8                            |  1 -
 examples/cx16/amiga.p8                        |  1 -
 examples/cx16/bobs.p8                         |  1 -
 examples/cx16/cobramk3-gfx.p8                 |  1 -
 examples/cx16/cube3d.p8                       |  1 -
 examples/cx16/datetime.p8                     |  1 -
 examples/cx16/highresbitmap.p8                |  1 -
 examples/cx16/kefrenbars.p8                   |  1 -
 examples/cx16/mandelbrot-gfx-colors.p8        |  1 -
 examples/cx16/mandelbrot.p8                   |  1 -
 examples/cx16/multipalette.p8                 |  1 -
 examples/cx16/rasterbars.p8                   |  1 -
 examples/cx16/tehtriz.p8                      |  1 -
 examples/cx16/testgfx2.p8                     |  1 -
 examples/cx16/vtui/testvtui.p8                |  1 -
 examples/plasma.p8                            |  1 -
 examples/rasterbars.p8                        |  1 -
 examples/sprites.p8                           |  1 -
 examples/tehtriz.p8                           |  1 -
 examples/test.p8                              | 63 ++++++++++---------
 examples/turtle-gfx.p8                        |  1 -
 examples/wizzine.p8                           |  1 -
 parser/antlr/prog8.g4                         |  2 +-
 syntax-files/IDEA/Prog8.xml                   |  4 +-
 syntax-files/NotepadPlusPlus/Prog8.xml        |  2 +-
 syntax-files/NotepadPlusPlus/syntax-test.p8   |  1 -
 syntax-files/Vim/prog8.vim                    |  2 +-
 46 files changed, 40 insertions(+), 102 deletions(-)

diff --git a/compiler/res/prog8lib/c64/floats.p8 b/compiler/res/prog8lib/c64/floats.p8
index 7d8ee5d29..417e9faf5 100644
--- a/compiler/res/prog8lib/c64/floats.p8
+++ b/compiler/res/prog8lib/c64/floats.p8
@@ -4,7 +4,6 @@
 ;
 ; indent format: TABS, size=8
 
-%target c64
 %option enable_floats
 
 floats {
diff --git a/compiler/res/prog8lib/c64/graphics.p8 b/compiler/res/prog8lib/c64/graphics.p8
index 4593cf563..c41e3d6f4 100644
--- a/compiler/res/prog8lib/c64/graphics.p8
+++ b/compiler/res/prog8lib/c64/graphics.p8
@@ -1,4 +1,3 @@
-%target c64
 %import textio
 
 ; bitmap pixel graphics module for the C64
diff --git a/compiler/res/prog8lib/c64/syslib.p8 b/compiler/res/prog8lib/c64/syslib.p8
index 56cce7440..da7358b8c 100644
--- a/compiler/res/prog8lib/c64/syslib.p8
+++ b/compiler/res/prog8lib/c64/syslib.p8
@@ -5,8 +5,6 @@
 ;
 ; indent format: TABS, size=8
 
-%target c64
-
 c64 {
         &ubyte  TIME_HI         = $a0       ; software jiffy clock, hi byte
         &ubyte  TIME_MID        = $a1       ;  .. mid byte
diff --git a/compiler/res/prog8lib/c64/textio.p8 b/compiler/res/prog8lib/c64/textio.p8
index 661403f8e..118d3fa71 100644
--- a/compiler/res/prog8lib/c64/textio.p8
+++ b/compiler/res/prog8lib/c64/textio.p8
@@ -4,7 +4,6 @@
 ;
 ; indent format: TABS, size=8
 
-%target c64
 %import syslib
 %import conv
 
diff --git a/compiler/res/prog8lib/cx16/floats.p8 b/compiler/res/prog8lib/cx16/floats.p8
index 9400a2af2..a9a0df938 100644
--- a/compiler/res/prog8lib/cx16/floats.p8
+++ b/compiler/res/prog8lib/cx16/floats.p8
@@ -4,7 +4,6 @@
 ;
 ; indent format: TABS, size=8
 
-%target cx16
 %option enable_floats
 
 floats {
diff --git a/compiler/res/prog8lib/cx16/gfx2.p8 b/compiler/res/prog8lib/cx16/gfx2.p8
index 4842a2f02..37fdf6eba 100644
--- a/compiler/res/prog8lib/cx16/gfx2.p8
+++ b/compiler/res/prog8lib/cx16/gfx2.p8
@@ -1,5 +1,3 @@
-%target cx16
-
 ; Bitmap pixel graphics routines for the CommanderX16
 ; Custom routines to use the full-screen 640x480 and 320x240 screen modes.
 ; (These modes are not supported by the documented GRAPH_xxxx kernal routines)
diff --git a/compiler/res/prog8lib/cx16/graphics.p8 b/compiler/res/prog8lib/cx16/graphics.p8
index 09679bff0..f8cb55b1f 100644
--- a/compiler/res/prog8lib/cx16/graphics.p8
+++ b/compiler/res/prog8lib/cx16/graphics.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import syslib
 %import textio
 
diff --git a/compiler/res/prog8lib/cx16/palette.p8 b/compiler/res/prog8lib/cx16/palette.p8
index 4a4e184e0..75073f136 100644
--- a/compiler/res/prog8lib/cx16/palette.p8
+++ b/compiler/res/prog8lib/cx16/palette.p8
@@ -1,5 +1,3 @@
-%target cx16
-
 ; Manipulate the Commander X16's display color palette.
 ; Should you want to restore the default palette, you have to reinitialize the Vera yourself.
 
diff --git a/compiler/res/prog8lib/cx16/syslib.p8 b/compiler/res/prog8lib/cx16/syslib.p8
index e125f9a99..8fa4ea50b 100644
--- a/compiler/res/prog8lib/cx16/syslib.p8
+++ b/compiler/res/prog8lib/cx16/syslib.p8
@@ -5,9 +5,6 @@
 ;
 ; indent format: TABS, size=8
 
-%target cx16
-
-
 c64 {
 
 ; ---- kernal routines, these are the same as on the Commodore-64 (hence the same block name) ----
diff --git a/compiler/res/prog8lib/cx16/textio.p8 b/compiler/res/prog8lib/cx16/textio.p8
index 79c071ba8..9b2915264 100644
--- a/compiler/res/prog8lib/cx16/textio.p8
+++ b/compiler/res/prog8lib/cx16/textio.p8
@@ -4,7 +4,6 @@
 ;
 ; indent format: TABS, size=8
 
-%target cx16
 %import syslib
 %import conv
 
diff --git a/compiler/src/prog8/compiler/astprocessing/AstChecker.kt b/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
index ea184b71f..07259b4aa 100644
--- a/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
+++ b/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
@@ -714,14 +714,6 @@ internal class AstChecker(private val program: Program,
                 else if(directive.args.map{it.name in setOf("enable_floats", "force_output", "no_sysinit", "align_word", "align_page")}.any { !it })
                     err("invalid option directive argument(s)")
             }
-            "%target" -> {
-                if(directive.parent !is Block && directive.parent !is Module)
-                    err("this directive may only occur in a block or at module level")
-                if(directive.args.size != 1)
-                    err("directive requires one argument")
-                if(directive.args.single().name !in setOf(C64Target.name, Cx16Target.name))
-                    err("invalid compilation target")
-            }
             else -> throw SyntaxError("invalid directive ${directive.directive}", directive.position)
         }
         super.visit(directive)
diff --git a/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt b/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt
index f9f173ce2..00ba76541 100644
--- a/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt
+++ b/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt
@@ -33,16 +33,6 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
         super.visit(block)
     }
 
-    override fun visit(directive: Directive) {
-        if(directive.directive=="%target") {
-            val compatibleTarget = directive.args.single().name
-            if (compatibleTarget != compTarget.name)
-                errors.err("module's compilation target ($compatibleTarget) differs from active target (${compTarget.name})", directive.position)
-        }
-
-        super.visit(directive)
-    }
-
     override fun visit(decl: VarDecl) {
         decl.datatypeErrors.forEach { errors.err(it.message, it.position) }
 
diff --git a/compilerAst/src/prog8/parser/ModuleParsing.kt b/compilerAst/src/prog8/parser/ModuleParsing.kt
index 94faa6ee4..f927ae7ca 100644
--- a/compilerAst/src/prog8/parser/ModuleParsing.kt
+++ b/compilerAst/src/prog8/parser/ModuleParsing.kt
@@ -135,7 +135,7 @@ class ModuleImporter(private val program: Program,
 
     private fun removeDirectivesFromImportedModule(importedModule: Module) {
         // Most global directives don't apply for imported modules, so remove them
-        val moduleLevelDirectives = listOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address", "%target")
+        val moduleLevelDirectives = listOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address")
         var directives = importedModule.statements.filterIsInstance<Directive>()
         importedModule.statements.removeAll(directives)
         directives = directives.filter{ it.directive !in moduleLevelDirectives }
diff --git a/docs/source/syntaxreference.rst b/docs/source/syntaxreference.rst
index 2b1e52fb5..e403afe8b 100644
--- a/docs/source/syntaxreference.rst
+++ b/docs/source/syntaxreference.rst
@@ -33,13 +33,6 @@ This makes it easier to understand and relate the generated code. Examples::
 Directives
 -----------
 
-.. data:: %target <target>
-
-    Level: module.
-    Global setting, specifies that this module can only work for the given compiler target.
-    If compiled with a different target, compilation is aborted with an error message.
-
-
 .. data:: %output <type>
 
 	Level: module.
diff --git a/examples/balloonflight.p8 b/examples/balloonflight.p8
index a39eac281..eb82e46bb 100644
--- a/examples/balloonflight.p8
+++ b/examples/balloonflight.p8
@@ -1,4 +1,3 @@
-%target c64
 %import syslib
 %import textio
 %import test_stack
diff --git a/examples/bdmusic-irq.p8 b/examples/bdmusic-irq.p8
index 2bb1fb30c..6ed3b0e0f 100644
--- a/examples/bdmusic-irq.p8
+++ b/examples/bdmusic-irq.p8
@@ -1,4 +1,3 @@
-%target c64
 %import syslib
 %import textio
 %zeropage basicsafe
diff --git a/examples/bdmusic.p8 b/examples/bdmusic.p8
index 29b443e38..b96bb83c7 100644
--- a/examples/bdmusic.p8
+++ b/examples/bdmusic.p8
@@ -1,4 +1,3 @@
-%target c64
 %import textio
 %import syslib
 
diff --git a/examples/charset.p8 b/examples/charset.p8
index 84214def7..71f10e252 100644
--- a/examples/charset.p8
+++ b/examples/charset.p8
@@ -1,4 +1,3 @@
-%target c64
 %import syslib
 %import textio
 %zeropage basicsafe
diff --git a/examples/cube3d-sprites.p8 b/examples/cube3d-sprites.p8
index 843d6f81f..46091e3e3 100644
--- a/examples/cube3d-sprites.p8
+++ b/examples/cube3d-sprites.p8
@@ -1,4 +1,3 @@
-%target c64
 %import syslib
 %import textio
 %import test_stack
diff --git a/examples/cube3d.p8 b/examples/cube3d.p8
index 65fd9b2e0..44c6cb45b 100644
--- a/examples/cube3d.p8
+++ b/examples/cube3d.p8
@@ -1,4 +1,3 @@
-%target c64
 %import syslib
 %import test_stack
 %import textio
diff --git a/examples/cx16/amiga.p8 b/examples/cx16/amiga.p8
index ddaf57713..47cd11496 100644
--- a/examples/cx16/amiga.p8
+++ b/examples/cx16/amiga.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import textio
 %import palette
 %import string
diff --git a/examples/cx16/bobs.p8 b/examples/cx16/bobs.p8
index f4954e8c3..d15ed0f79 100644
--- a/examples/cx16/bobs.p8
+++ b/examples/cx16/bobs.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import palette
 %import conv
 %import textio
diff --git a/examples/cx16/cobramk3-gfx.p8 b/examples/cx16/cobramk3-gfx.p8
index 2884f0dc3..c72abbcf1 100644
--- a/examples/cx16/cobramk3-gfx.p8
+++ b/examples/cx16/cobramk3-gfx.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import syslib
 %import test_stack
 %import conv
diff --git a/examples/cx16/cube3d.p8 b/examples/cx16/cube3d.p8
index d4b8a3d37..149e0e7fb 100644
--- a/examples/cx16/cube3d.p8
+++ b/examples/cx16/cube3d.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import textio
 
 main {
diff --git a/examples/cx16/datetime.p8 b/examples/cx16/datetime.p8
index 0fa4887b4..8a4e40dd1 100644
--- a/examples/cx16/datetime.p8
+++ b/examples/cx16/datetime.p8
@@ -1,6 +1,5 @@
 ; CommanderX16 text datetime example!
 
-%target cx16
 %import textio
 %zeropage basicsafe
 
diff --git a/examples/cx16/highresbitmap.p8 b/examples/cx16/highresbitmap.p8
index 49d042e60..4a0f536d1 100644
--- a/examples/cx16/highresbitmap.p8
+++ b/examples/cx16/highresbitmap.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import gfx2
 %import floats
 %import textio
diff --git a/examples/cx16/kefrenbars.p8 b/examples/cx16/kefrenbars.p8
index a3c6ce6be..0b7b31306 100644
--- a/examples/cx16/kefrenbars.p8
+++ b/examples/cx16/kefrenbars.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import palette
 %option no_sysinit
 
diff --git a/examples/cx16/mandelbrot-gfx-colors.p8 b/examples/cx16/mandelbrot-gfx-colors.p8
index 844faaef5..b386ee7de 100644
--- a/examples/cx16/mandelbrot-gfx-colors.p8
+++ b/examples/cx16/mandelbrot-gfx-colors.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import textio
 %import floats
 %zeropage basicsafe
diff --git a/examples/cx16/mandelbrot.p8 b/examples/cx16/mandelbrot.p8
index a92e46529..58a1d5dba 100644
--- a/examples/cx16/mandelbrot.p8
+++ b/examples/cx16/mandelbrot.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import textio
 %import floats
 %zeropage basicsafe
diff --git a/examples/cx16/multipalette.p8 b/examples/cx16/multipalette.p8
index a4801d102..28fe57af8 100644
--- a/examples/cx16/multipalette.p8
+++ b/examples/cx16/multipalette.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import palette
 %import gfx2
 %option no_sysinit
diff --git a/examples/cx16/rasterbars.p8 b/examples/cx16/rasterbars.p8
index df73756bc..94b2bf4b2 100644
--- a/examples/cx16/rasterbars.p8
+++ b/examples/cx16/rasterbars.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import textio
 %import palette
 
diff --git a/examples/cx16/tehtriz.p8 b/examples/cx16/tehtriz.p8
index a33473236..32cfc5ff7 100644
--- a/examples/cx16/tehtriz.p8
+++ b/examples/cx16/tehtriz.p8
@@ -8,7 +8,6 @@
 ;   simplistic sound effects (Vera PSG)
 
 
-%target cx16
 %import syslib
 %import textio
 %import test_stack
diff --git a/examples/cx16/testgfx2.p8 b/examples/cx16/testgfx2.p8
index be8b2a8d9..6317aaa76 100644
--- a/examples/cx16/testgfx2.p8
+++ b/examples/cx16/testgfx2.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import gfx2
 %import textio
 %import test_stack
diff --git a/examples/cx16/vtui/testvtui.p8 b/examples/cx16/vtui/testvtui.p8
index b161e1503..9eb1f6440 100644
--- a/examples/cx16/vtui/testvtui.p8
+++ b/examples/cx16/vtui/testvtui.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import textio
 %option no_sysinit
 %zeropage basicsafe
diff --git a/examples/plasma.p8 b/examples/plasma.p8
index 9c1eaf37e..094765a82 100644
--- a/examples/plasma.p8
+++ b/examples/plasma.p8
@@ -1,4 +1,3 @@
-%target c64
 %import syslib
 %import test_stack
 %import textio
diff --git a/examples/rasterbars.p8 b/examples/rasterbars.p8
index 6057810de..505cc1d16 100644
--- a/examples/rasterbars.p8
+++ b/examples/rasterbars.p8
@@ -1,4 +1,3 @@
-%target c64
 %import syslib
 
 main {
diff --git a/examples/sprites.p8 b/examples/sprites.p8
index d336e6a65..b15f92efd 100644
--- a/examples/sprites.p8
+++ b/examples/sprites.p8
@@ -1,4 +1,3 @@
-%target c64
 %import textio
 %import syslib
 %zeropage basicsafe
diff --git a/examples/tehtriz.p8 b/examples/tehtriz.p8
index 3fdffd868..5f75d330f 100644
--- a/examples/tehtriz.p8
+++ b/examples/tehtriz.p8
@@ -8,7 +8,6 @@
 ;   some simple sound effects
 
 
-%target c64
 %import syslib
 %import textio
 %import test_stack
diff --git a/examples/test.p8 b/examples/test.p8
index 860fab040..d84387a30 100644
--- a/examples/test.p8
+++ b/examples/test.p8
@@ -5,38 +5,43 @@ main {
 
 label:
     sub start() {
-        sub2(&label)
-        sub2(&label_local)
-        sub2(&main.sub2.label_in_sub2)
-        uword xx = &label_local
-        txt.print_uwhex(xx, true)
-        txt.nl()
-        xx = &label
-        txt.print_uwhex(xx, true)
-        txt.nl()
-        xx = &main.label
-        txt.print_uwhex(xx, true)
-        txt.nl()
-        xx = &main.sub2.label_in_sub2
-        txt.print_uwhex(xx, true)
-        txt.nl()
-        xx = main.sub2.sub2var
-        txt.print_uwhex(xx, true)
-        txt.nl()
-        xx = &main.start.label_local
-        txt.print_uwhex(xx, true)
-        txt.nl()
+
+        txt.print("hey\n")
+        %breakpoint
+        txt.print("hey2\n")
+
+;        sub2(&label)
+;        sub2(&label_local)
+;        sub2(&main.sub2.label_in_sub2)
+;        uword xx = &label_local
+;        txt.print_uwhex(xx, true)
+;        txt.nl()
+;        xx = &label
+;        txt.print_uwhex(xx, true)
+;        txt.nl()
+;        xx = &main.label
+;        txt.print_uwhex(xx, true)
+;        txt.nl()
+;        xx = &main.sub2.label_in_sub2
+;        txt.print_uwhex(xx, true)
+;        txt.nl()
+;        xx = main.sub2.sub2var
+;        txt.print_uwhex(xx, true)
+;        txt.nl()
+;        xx = &main.start.label_local
+;        txt.print_uwhex(xx, true)
+;        txt.nl()
 
 label_local:
         return
     }
 
-    sub sub2(uword ad) {
-        uword sub2var = 42
-
-        txt.print_uwhex(ad,true)
-        txt.nl()
-label_in_sub2:
-        txt.nl()
-    }
+;    sub sub2(uword ad) {
+;        uword sub2var = 42
+;
+;        txt.print_uwhex(ad,true)
+;        txt.nl()
+;label_in_sub2:
+;        txt.nl()
+;    }
 }
diff --git a/examples/turtle-gfx.p8 b/examples/turtle-gfx.p8
index bfefa7115..f3bf3224c 100644
--- a/examples/turtle-gfx.p8
+++ b/examples/turtle-gfx.p8
@@ -1,4 +1,3 @@
-%target c64
 %import floats
 %import graphics
 %import test_stack
diff --git a/examples/wizzine.p8 b/examples/wizzine.p8
index f50946f07..0af5abb4e 100644
--- a/examples/wizzine.p8
+++ b/examples/wizzine.p8
@@ -1,4 +1,3 @@
-%target c64
 %import syslib
 %zeropage basicsafe
 
diff --git a/parser/antlr/prog8.g4 b/parser/antlr/prog8.g4
index 9a2cc4fe4..e43e8f81b 100644
--- a/parser/antlr/prog8.g4
+++ b/parser/antlr/prog8.g4
@@ -135,7 +135,7 @@ unconditionaljump :  'goto'  (integerliteral | scoped_identifier) ;
 
 directive :
 	directivename=('%output' | '%launcher' | '%zeropage' | '%zpreserved' | '%address' | '%import' |
-                       '%breakpoint' | '%asminclude' | '%asmbinary' | '%option' | '%target' )
+                       '%breakpoint' | '%asminclude' | '%asmbinary' | '%option' )
         (directivearg? | directivearg (',' directivearg)*)
         ;
 
diff --git a/syntax-files/IDEA/Prog8.xml b/syntax-files/IDEA/Prog8.xml
index 0b5629951..6b7feb46e 100644
--- a/syntax-files/IDEA/Prog8.xml
+++ b/syntax-files/IDEA/Prog8.xml
@@ -12,7 +12,7 @@
       <option name="HAS_STRING_ESCAPES" value="true" />
     </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" />
+    <keywords2 keywords="%address;%asm;%asmbinary;%asminclude;%breakpoint;%import;%launcher;%option;%output;%zeropage;%zpreserved" />
     <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>
@@ -20,4 +20,4 @@
     <mapping ext="p8" />
     <mapping ext="prog8" />
   </extensionMap>
-</filetype>
\ No newline at end of file
+</filetype>
diff --git a/syntax-files/NotepadPlusPlus/Prog8.xml b/syntax-files/NotepadPlusPlus/Prog8.xml
index 4b5afe75d..317befee7 100644
--- a/syntax-files/NotepadPlusPlus/Prog8.xml
+++ b/syntax-files/NotepadPlusPlus/Prog8.xml
@@ -25,7 +25,7 @@
             <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 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="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;%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>
             <Keywords name="Keywords5">true false&#x000D;&#x000A;not and or xor&#x000D;&#x000A;as to downto</Keywords>
diff --git a/syntax-files/NotepadPlusPlus/syntax-test.p8 b/syntax-files/NotepadPlusPlus/syntax-test.p8
index 9435d9f53..a64982a25 100644
--- a/syntax-files/NotepadPlusPlus/syntax-test.p8
+++ b/syntax-files/NotepadPlusPlus/syntax-test.p8
@@ -1,4 +1,3 @@
-%target cx16
 %import textio
 %zeropage basicsafe
 %option no_sysinit
diff --git a/syntax-files/Vim/prog8.vim b/syntax-files/Vim/prog8.vim
index 4401d27a9..57afc410a 100644
--- a/syntax-files/Vim/prog8.vim
+++ b/syntax-files/Vim/prog8.vim
@@ -33,7 +33,7 @@ syn keyword prog8Repeat for while in do until repeat
 syn match prog8Label "\<\w\+\>:"
 syn keyword prog8Operator and or to downto as void
 
-syn match prog8Directive "\(^\|\s\)%\(target\|output\|launcher\|zeropage\)\>"
+syn match prog8Directive "\(^\|\s\)%\(output\|launcher\|zeropage\)\>"
 syn match prog8Directive "\(^\|\s\)%\(zpreserved\|address\|import\|option\)\>"
 syn match prog8Directive "\(^\|\s\)%\(asmbinary\|asminclude\|breakpoint\)\>"
 syn match prog8Directive "\(^\|\s\)%asm\>"

From af99173cd78357c35c1927eb74e617cabbdf5bbb Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Mon, 6 Sep 2021 21:52:14 +0200
Subject: [PATCH 03/17] range expressions are on integers only

---
 .../optimizer/ConstantIdentifierReplacer.kt   | 30 +++++++++++++++++++
 docs/source/syntaxreference.rst               |  4 +--
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt b/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt
index aae516238..17d34933d 100644
--- a/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt
+++ b/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt
@@ -12,6 +12,7 @@ import prog8.compiler.IErrorReporter
 import prog8.compiler.target.ICompilationTarget
 
 // Fix up the literal value's type to match that of the vardecl
+//   (also check range literal operands types before they get expanded to arrays for instance)
 internal class VarConstantValueTypeAdjuster(private val program: Program, private val errors: IErrorReporter) : AstWalker() {
 
     override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
@@ -52,6 +53,35 @@ internal class VarConstantValueTypeAdjuster(private val program: Program, privat
         }
         return noModifications
     }
+
+    override fun after(range: RangeExpr, parent: Node): Iterable<IAstModification> {
+        val from = range.from.constValue(program)?.number?.toDouble()
+        val to = range.to.constValue(program)?.number?.toDouble()
+        val step = range.step.constValue(program)?.number?.toDouble()
+
+        if(from==null) {
+            if(!range.from.inferType(program).isInteger())
+                errors.err("range expression from value must be integer", range.from.position)
+        } else if(from-from.toInt()>0) {
+            errors.err("range expression from value must be integer", range.from.position)
+        }
+
+        if(to==null) {
+            if(!range.to.inferType(program).isInteger())
+                errors.err("range expression to value must be integer", range.to.position)
+        } else if(to-to.toInt()>0) {
+            errors.err("range expression to value must be integer", range.to.position)
+        }
+
+        if(step==null) {
+            if(!range.step.inferType(program).isInteger())
+                errors.err("range expression step value must be integer", range.step.position)
+        } else if(step-step.toInt()>0) {
+            errors.err("range expression step value must be integer", range.step.position)
+        }
+
+        return noModifications
+    }
 }
 
 
diff --git a/docs/source/syntaxreference.rst b/docs/source/syntaxreference.rst
index e403afe8b..e97adb971 100644
--- a/docs/source/syntaxreference.rst
+++ b/docs/source/syntaxreference.rst
@@ -396,7 +396,7 @@ The following names are reserved, they have a special meaning::
 Range expression
 ^^^^^^^^^^^^^^^^
 
-A special value is the *range expression* which represents a range of numbers or characters,
+A special value is the *range expression* which represents a range of integer numbers or characters,
 from the starting value to (and including) the ending value::
 
     <start>  to  <end>   [ step  <step> ]
@@ -406,7 +406,7 @@ You an provide a step value if you need something else than the default incremen
 in case of downto, a decrement of one).   Because a step of minus one is so common you can just use
 the downto variant to avoid having to specify the step as well.
 
-If used in the place of a literal value, it expands into the actual array of values::
+If used in the place of a literal value, it expands into the actual array of integer values::
 
 	byte[] array = 100 to 199     ; initialize array with [100, 101, ..., 198, 199]
 

From 754664aefa16b705d1020e338b67a46b32370771 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Mon, 6 Sep 2021 23:22:43 +0200
Subject: [PATCH 04/17] correctly allow codegen to proceed for byte->word
 register assignment. Fixes crash #58

---
 .../target/cpu6502/codegen/assignment/AssignmentAsmGen.kt   | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/compiler/src/prog8/compiler/target/cpu6502/codegen/assignment/AssignmentAsmGen.kt b/compiler/src/prog8/compiler/target/cpu6502/codegen/assignment/AssignmentAsmGen.kt
index 5b80f89c5..a0f14d766 100644
--- a/compiler/src/prog8/compiler/target/cpu6502/codegen/assignment/AssignmentAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/cpu6502/codegen/assignment/AssignmentAsmGen.kt
@@ -1359,8 +1359,10 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
     }
 
     internal fun assignRegisterByte(target: AsmAssignTarget, register: CpuRegister) {
-        // we make an exception in the type check for assigning something to a cx16 virtual register
-        if(target.register !in Cx16VirtualRegisters) {
+        // we make an exception in the type check for assigning something to a cx16 virtual register, or a register pair
+        // these will be correctly typecasted from a byte to a word value
+        if(target.register !in Cx16VirtualRegisters &&
+            target.register!=RegisterOrPair.AX && target.register!=RegisterOrPair.AY && target.register!=RegisterOrPair.XY) {
             if(target.kind==TargetStorageKind.VARIABLE) {
                 val parts = target.asmVarname.split('.')
                 if (parts.size != 2 || parts[0] != "cx16")

From 8388adcd1d784b6f72807d195882a70d7ac81502 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Tue, 28 Sep 2021 22:54:58 +0200
Subject: [PATCH 05/17] changed to fixed point math to always generate bars of
 32 lines height

---
 examples/cx16/colorbars.p8 | 146 +++++++++++++++++--------------------
 1 file changed, 68 insertions(+), 78 deletions(-)

diff --git a/examples/cx16/colorbars.p8 b/examples/cx16/colorbars.p8
index d78eb727e..2cc974416 100644
--- a/examples/cx16/colorbars.p8
+++ b/examples/cx16/colorbars.p8
@@ -14,10 +14,11 @@ main {
 
         ubyte yy
         for yy in 0 to 239
-            gfx2.horizontal_line(0, yy, 320, yy & 63)
+            gfx2.horizontal_line(0, yy, 320, yy & 31)
 
         repeat {
-            colors.random_bar()
+            colors.random_half_bar()
+            colors.mirror_bar()
             colors.set_palette()
             repeat 20
                 sys.waitvsync()
@@ -30,96 +31,85 @@ main {
 }
 
 colors {
-    ubyte cr
-    ubyte cg
-    ubyte cb
-    ubyte[48+16] reds
-    ubyte[48+16] greens
-    ubyte[48+16] blues
+    ubyte target_red
+    ubyte target_green
+    ubyte target_blue
+    ubyte[32] reds
+    ubyte[32] greens
+    ubyte[32] 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
+            target_red = msb(rr) & 15
+            target_green = lsb(rr)
+            target_blue = target_green & 15
+            target_green >>= 4
+        } until target_red+target_green+target_blue >= 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
+    sub mirror_bar() {
+        ; mirror the top half bar into the bottom half
+        ubyte ix=14
+        ubyte mix=16
+        do {
+            reds[mix] = reds[ix]
+            greens[mix] = greens[ix]
+            blues[mix] = blues[ix]
+            mix++
+            ix--
+        } until ix==255
+        reds[mix] = 0
+        greens[mix] = 0
+        blues[mix] = 0
+    }
 
-        repeat {
-            different = false
-            if r != cr {
-                different = true
-                r++
+    sub random_half_bar() {
+        ; fade black -> color then fade color -> white
+        ; gradient calculations in 8.8 bits fixed-point
+        ; could theoretically be 4.12 bits for even more fractional accuracy
+        random_rgb12()
+        uword r = $000
+        uword g = $000
+        uword b = $000
+        uword dr = target_red
+        uword dg = target_green
+        uword db = target_blue
+        ubyte ix = 1
+
+        ; gradient from black to halfway color
+        reds[0] = 0
+        greens[0] = 0
+        blues[0] = 0
+        dr <<= 5
+        dg <<= 5
+        db <<= 5
+        continue_gradient()
+
+        ; gradient from halfway color to white
+        dr = (($f00 - r) >> 3) - 1
+        dg = (($f00 - g) >> 3) - 1
+        db = (($f00 - b) >> 3) - 1
+        continue_gradient()
+        return
+
+        sub continue_gradient() {
+            repeat 8 {
+                reds[ix] = msb(r)
+                greens[ix] = msb(g)
+                blues[ix] = msb(b)
+                r += dr
+                g += dg
+                b += db
+                ix++
             }
-            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 {
+        for ix in 0 to 31 {
             uword color = mkword(reds[ix], (greens[ix] << 4) | blues[ix] )
             palette.set_color(ix, color)
         }

From 9acec4d952e914d2c64c7d7c77f2bb590277fe4f Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Tue, 28 Sep 2021 23:12:16 +0200
Subject: [PATCH 06/17] changed to fixed point math to always generate bars of
 32 lines height

---
 examples/cx16/colorbars.p8 | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/examples/cx16/colorbars.p8 b/examples/cx16/colorbars.p8
index 2cc974416..c24e82fd6 100644
--- a/examples/cx16/colorbars.p8
+++ b/examples/cx16/colorbars.p8
@@ -1,6 +1,5 @@
 %import gfx2
 %import palette
-%import textio
 
 
 ; TODO WORK IN PROGRESS...
@@ -9,23 +8,25 @@
 
 main {
     sub start() {
-        palette.set_all_black()
+        ;palette.set_all_black()
         gfx2.screen_mode(4)
 
         ubyte yy
         for yy in 0 to 239
-            gfx2.horizontal_line(0, yy, 320, yy & 31)
+            gfx2.horizontal_line(0, yy, 320, yy)
 
         repeat {
-            colors.random_half_bar()
-            colors.mirror_bar()
-            colors.set_palette()
-            repeat 20
+            yy = 0
+            repeat 8 {
+                colors.random_half_bar()
+                colors.mirror_bar()
+                colors.set_palette(yy)
+                yy+=32
+            }
+
+            repeat 10
                 sys.waitvsync()
         }
-
-        repeat {
-        }
     }
 
 }
@@ -107,11 +108,11 @@ colors {
         }
     }
 
-    sub set_palette() {
+    sub set_palette(ubyte offset) {
         ubyte ix
         for ix in 0 to 31 {
             uword color = mkword(reds[ix], (greens[ix] << 4) | blues[ix] )
-            palette.set_color(ix, color)
+            palette.set_color(ix+offset, color)
         }
     }
 }

From 4bd4733e529a6aee89ef1cf0e229b32017192e11 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Tue, 28 Sep 2021 23:12:59 +0200
Subject: [PATCH 07/17] fix index calc bug in palette.set_color

---
 compiler/res/prog8lib/cx16/palette.p8 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/res/prog8lib/cx16/palette.p8 b/compiler/res/prog8lib/cx16/palette.p8
index 4a4e184e0..9efc6c9cd 100644
--- a/compiler/res/prog8lib/cx16/palette.p8
+++ b/compiler/res/prog8lib/cx16/palette.p8
@@ -9,7 +9,7 @@ palette {
     ubyte c
 
     sub set_color(ubyte index, uword color) {
-        vera_palette_ptr = $fa00+index*2
+        vera_palette_ptr = $fa00+(index as uword * 2)
         cx16.vpoke(1, vera_palette_ptr, lsb(color))
         vera_palette_ptr++
         cx16.vpoke(1, vera_palette_ptr, msb(color))

From 25677a41266c2a504ffd3dcde8d02d54884926b1 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Tue, 28 Sep 2021 23:27:32 +0200
Subject: [PATCH 08/17] remove unused var

---
 examples/cx16/colorbars.p8 | 1 -
 1 file changed, 1 deletion(-)

diff --git a/examples/cx16/colorbars.p8 b/examples/cx16/colorbars.p8
index c24e82fd6..2c7fca9a3 100644
--- a/examples/cx16/colorbars.p8
+++ b/examples/cx16/colorbars.p8
@@ -38,7 +38,6 @@ colors {
     ubyte[32] reds
     ubyte[32] greens
     ubyte[32] blues
-    ubyte bar_size
 
     sub random_rgb12() {
         do {

From fbef63e15066f0b66f30d681ad6faf5a88a70fac Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Thu, 30 Sep 2021 23:45:45 +0200
Subject: [PATCH 09/17] moving to raster lines via irq

---
 examples/cx16/colorbars.p8 | 75 +++++++++++++++++++++++++++-----------
 1 file changed, 53 insertions(+), 22 deletions(-)

diff --git a/examples/cx16/colorbars.p8 b/examples/cx16/colorbars.p8
index 2c7fca9a3..32ac2f111 100644
--- a/examples/cx16/colorbars.p8
+++ b/examples/cx16/colorbars.p8
@@ -1,5 +1,5 @@
-%import gfx2
 %import palette
+%import textio
 
 
 ; TODO WORK IN PROGRESS...
@@ -8,29 +8,52 @@
 
 main {
     sub start() {
-        ;palette.set_all_black()
-        gfx2.screen_mode(4)
+        txt.plot(5,5)
+        txt.print("amiga-like raster blinds effect (work in progress)")
 
-        ubyte yy
-        for yy in 0 to 239
-            gfx2.horizontal_line(0, yy, 320, yy)
+        irq.make_new_gradient()
+        cx16.set_rasterirq(&irq.irqhandler, 100)
 
         repeat {
-            yy = 0
-            repeat 8 {
-                colors.random_half_bar()
-                colors.mirror_bar()
-                colors.set_palette(yy)
-                yy+=32
-            }
-
-            repeat 10
-                sys.waitvsync()
         }
     }
 
 }
 
+irq {
+    ubyte color_ix = 0
+    uword next_irq_line = 100
+    ubyte gradient_counter = 0
+
+    sub irqhandler() {
+        palette.set_color(0, colors.get_colorword(color_ix))
+        color_ix++
+
+        if color_ix==32 {
+            next_irq_line = 100
+            color_ix = 0
+
+            ; just arbitrary mechanism for now, to change to a new gradient after a short while
+            gradient_counter++
+            if gradient_counter & 16 {
+                make_new_gradient()
+                gradient_counter = 0
+            }
+
+        } else {
+            next_irq_line += 2      ; code needs 2 scanlines per color transition
+        }
+
+        cx16.set_rasterline(next_irq_line)
+    }
+
+    sub make_new_gradient() {
+        colors.random_half_bar()
+        colors.mirror_bar()
+    }
+}
+
+
 colors {
     ubyte target_red
     ubyte target_green
@@ -107,11 +130,19 @@ colors {
         }
     }
 
-    sub set_palette(ubyte offset) {
-        ubyte ix
-        for ix in 0 to 31 {
-            uword color = mkword(reds[ix], (greens[ix] << 4) | blues[ix] )
-            palette.set_color(ix+offset, color)
-        }
+    asmsub get_colorword(ubyte color_ix @Y) -> uword @AY {
+        ; uword color = mkword(reds[ix], (greens[ix] << 4) | blues[ix] )
+        %asm {{
+            lda  colors.reds,y
+            pha
+            lda  colors.greens,y
+            asl  a
+            asl  a
+            asl  a
+            asl  a
+            ora  colors.blues,y
+            ply
+            rts
+        }}
     }
 }

From 06b3bf27b52bfbedb2131a72f1472061e13fedcc Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Sun, 3 Oct 2021 21:35:12 +0200
Subject: [PATCH 10/17] slightly improve sys.waitvsync() on c64

---
 compiler/res/prog8lib/c64/syslib.p8 | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/compiler/res/prog8lib/c64/syslib.p8 b/compiler/res/prog8lib/c64/syslib.p8
index 56cce7440..7461de07e 100644
--- a/compiler/res/prog8lib/c64/syslib.p8
+++ b/compiler/res/prog8lib/c64/syslib.p8
@@ -502,11 +502,9 @@ sys {
         ; --- busy wait till the next vsync has occurred (approximately), without depending on custom irq handling.
         ;     note: a more accurate way to wait for vsync is to set up a vsync irq handler instead.
         %asm {{
--           lda  c64.RASTER
-            beq  -
--           lda  c64.RASTER
-            bne  -
-            bit  c64.SCROLY
+-           bit  c64.SCROLY
+            bpl  -
+-           bit  c64.SCROLY
             bmi  -
             rts
         }}

From 91ae68c07e2e3a3897b83b458f8b4af6b5bbb0d0 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Mon, 4 Oct 2021 21:57:26 +0200
Subject: [PATCH 11/17] blinds effects done

---
 examples/cx16/colorbars.p8 | 114 +++++++++++++++++++++++++------------
 1 file changed, 78 insertions(+), 36 deletions(-)

diff --git a/examples/cx16/colorbars.p8 b/examples/cx16/colorbars.p8
index 32ac2f111..7bd6dd501 100644
--- a/examples/cx16/colorbars.p8
+++ b/examples/cx16/colorbars.p8
@@ -1,18 +1,24 @@
-%import palette
 %import textio
 
-
-; TODO WORK IN PROGRESS...
-; want to make Amiga 'copper' bars color cycling effects
+; Amiga 'copper' bars color cycling effect
 
 
 main {
     sub start() {
-        txt.plot(5,5)
-        txt.print("amiga-like raster blinds effect (work in progress)")
+        ; make palette color 1 black so we can print black letters over the background color 0
+        void cx16.screen_set_mode(0)
+        cx16.vpoke(1, $fa02, $0)
+        cx16.vpoke(1, $fa03, $0)
+        txt.color(1)
+        txt.plot(13,12)
+        txt.print("amiga-inspired")
+        txt.plot(10,14)
+        txt.print("raster blinds effect")
+        txt.plot(12,16)
+        txt.print("random gradients")
 
         irq.make_new_gradient()
-        cx16.set_rasterirq(&irq.irqhandler, 100)
+        cx16.set_rasterirq(&irq.irqhandler, irq.top_scanline)
 
         repeat {
         }
@@ -21,35 +27,87 @@ main {
 }
 
 irq {
+    const ubyte top_scanline = 0
+    ubyte blinds_start_ix = 0
     ubyte color_ix = 0
-    uword next_irq_line = 100
-    ubyte gradient_counter = 0
+    uword next_irq_line = top_scanline
+    ubyte shift_counter = 0
+
+    ubyte[32+32+16] blinds_lines_reds
+    ubyte[32+32+16] blinds_lines_greens
+    ubyte[32+32+16] blinds_lines_blues
+
 
     sub irqhandler() {
-        palette.set_color(0, colors.get_colorword(color_ix))
+        set_scanline_color(color_ix)
         color_ix++
 
-        if color_ix==32 {
-            next_irq_line = 100
+        next_irq_line += 2      ; code needs 2 scanlines per color transition
+
+        if next_irq_line == 480 {
+            ; start over at top
+            next_irq_line = top_scanline
+            blinds_start_ix = 0
             color_ix = 0
-
-            ; just arbitrary mechanism for now, to change to a new gradient after a short while
-            gradient_counter++
-            if gradient_counter & 16 {
+            shift_counter++
+            if shift_counter == 32+32+32 {
                 make_new_gradient()
-                gradient_counter = 0
+                shift_counter = 0
+            } else if shift_counter & 1 {
+                shift_gradient()
             }
-
-        } else {
-            next_irq_line += 2      ; code needs 2 scanlines per color transition
+        } else if next_irq_line & 15 == 0  {
+            ; start next blinds
+            blinds_start_ix++
+            color_ix = blinds_start_ix
         }
 
+
+
         cx16.set_rasterline(next_irq_line)
     }
 
     sub make_new_gradient() {
         colors.random_half_bar()
         colors.mirror_bar()
+        sys.memcopy(colors.reds, &blinds_lines_reds+32+16, len(colors.reds))
+        sys.memcopy(colors.greens, &blinds_lines_greens+32+16, len(colors.greens))
+        sys.memcopy(colors.blues, &blinds_lines_blues+32+16, len(colors.blues))
+    }
+
+    sub shift_gradient() {
+        sys.memcopy(&blinds_lines_reds+1, blinds_lines_reds, len(blinds_lines_reds)-1)
+        sys.memcopy(&blinds_lines_greens+1, blinds_lines_greens, len(blinds_lines_greens)-1)
+        sys.memcopy(&blinds_lines_blues+1, blinds_lines_blues, len(blinds_lines_blues)-1)
+    }
+
+    asmsub set_scanline_color(ubyte color_ix @Y) {
+        ; uword color = mkword(reds[ix], (greens[ix] << 4) | blues[ix] )
+        %asm {{
+            lda  blinds_lines_reds,y
+            pha
+            lda  blinds_lines_greens,y
+            asl  a
+            asl  a
+            asl  a
+            asl  a
+            ora  blinds_lines_blues,y
+            tay
+
+            stz  cx16.VERA_CTRL
+            lda  #%00010001
+            sta  cx16.VERA_ADDR_H
+            lda  #$fa
+            sta  cx16.VERA_ADDR_M
+            ; lda  #$02
+            ; sta  cx16.VERA_ADDR_L
+            stz  cx16.VERA_ADDR_L
+            sty  cx16.VERA_DATA0        ; gb
+            pla
+            sta  cx16.VERA_DATA0        ; r
+            stz  cx16.VERA_ADDR_H
+            rts
+        }}
     }
 }
 
@@ -129,20 +187,4 @@ colors {
             }
         }
     }
-
-    asmsub get_colorword(ubyte color_ix @Y) -> uword @AY {
-        ; uword color = mkword(reds[ix], (greens[ix] << 4) | blues[ix] )
-        %asm {{
-            lda  colors.reds,y
-            pha
-            lda  colors.greens,y
-            asl  a
-            asl  a
-            asl  a
-            asl  a
-            ora  colors.blues,y
-            ply
-            rts
-        }}
-    }
 }

From 0204002d9b8d06122f0b2c638323bf4f605cd684 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Fri, 8 Oct 2021 04:14:43 +0200
Subject: [PATCH 12/17] bugfix: non-existing asm function was sometimes called
 to swap floats

---
 .../cpu6502/codegen/BuiltinFunctionsAsmGen.kt |  8 +--
 examples/test.p8                              | 72 +++++++++----------
 2 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/compiler/src/prog8/compiler/target/cpu6502/codegen/BuiltinFunctionsAsmGen.kt b/compiler/src/prog8/compiler/target/cpu6502/codegen/BuiltinFunctionsAsmGen.kt
index 7ba1b61fa..1e2edf3ab 100644
--- a/compiler/src/prog8/compiler/target/cpu6502/codegen/BuiltinFunctionsAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/cpu6502/codegen/BuiltinFunctionsAsmGen.kt
@@ -888,7 +888,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     sta  P8ZP_SCRATCH_W2
                     lda  #>(${arrayVarName2}+$index2)
                     sta  P8ZP_SCRATCH_W2+1
-                    jsr  floats.swap_floats
+                    jsr  floats.func_swap_f
                 """)
             }
             else -> throw AssemblyError("invalid aray elt type")
@@ -961,7 +961,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     sta  P8ZP_SCRATCH_W2
                     bcc  +
                     inc  P8ZP_SCRATCH_W2+1
-+                   jsr  floats.swap_floats                                   
++                   jsr  floats.func_swap_f                                   
                 """)
             }
             else -> throw AssemblyError("invalid aray elt type")
@@ -1019,7 +1019,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     sta  P8ZP_SCRATCH_W1
                     bcc  +
                     inc  P8ZP_SCRATCH_W1+1
-+                   jsr  floats.swap_floats
++                   jsr  floats.func_swap_f
                 """)
             }
             else -> throw AssemblyError("invalid aray elt type")
@@ -1077,7 +1077,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     sta  P8ZP_SCRATCH_W2
                     lda  #>(${arrayVarName2}+$index2)
                     sta  P8ZP_SCRATCH_W2+1
-                    jsr  floats.swap_floats
+                    jsr  floats.func_swap_f
                 """)
             }
             else -> throw AssemblyError("invalid aray elt type")
diff --git a/examples/test.p8 b/examples/test.p8
index d84387a30..1bce15bdb 100644
--- a/examples/test.p8
+++ b/examples/test.p8
@@ -1,47 +1,47 @@
 %import textio
-%zeropage dontuse
+%import floats
+%import test_stack
+%zeropage basicsafe
 
 main {
 
 label:
     sub start() {
 
-        txt.print("hey\n")
-        %breakpoint
-        txt.print("hey2\n")
+        ubyte ub1
+        ubyte ub2
+        uword uw1
+        uword uw2
+        float fl1
+        float fl2
+        ubyte[10] ubarr
+        uword[10] uwarr
+        float[10] flarr
 
-;        sub2(&label)
-;        sub2(&label_local)
-;        sub2(&main.sub2.label_in_sub2)
-;        uword xx = &label_local
-;        txt.print_uwhex(xx, true)
-;        txt.nl()
-;        xx = &label
-;        txt.print_uwhex(xx, true)
-;        txt.nl()
-;        xx = &main.label
-;        txt.print_uwhex(xx, true)
-;        txt.nl()
-;        xx = &main.sub2.label_in_sub2
-;        txt.print_uwhex(xx, true)
-;        txt.nl()
-;        xx = main.sub2.sub2var
-;        txt.print_uwhex(xx, true)
-;        txt.nl()
-;        xx = &main.start.label_local
-;        txt.print_uwhex(xx, true)
-;        txt.nl()
+        swap(ub1, ub2)
+        swap(uw1, uw2)
+        swap(fl1, fl2)
+        swap(ubarr[1], ubarr[2])
+        swap(uwarr[1], uwarr[2])
+        swap(flarr[1], flarr[2])
 
-label_local:
-        return
+        ubyte ix1
+        ubyte ix2
+
+        swap(ubarr[ix1], ubarr[ix2])
+        swap(uwarr[ix1], uwarr[ix2])
+        swap(flarr[ix1], flarr[ix2])
+        swap(flarr[ix1], flarr[2])
+        swap(flarr[2], flarr[ix2])
+
+        swap(ubarr[ix1], ubarr[ix1+2])
+        swap(uwarr[ix1], uwarr[ix1+2])
+        swap(flarr[ix1], flarr[ix1+2])
+
+        uword ptr = $c000
+        swap(@(ptr+1), @(ptr+2))
+        swap(@(ptr+ub1), @(ptr+ub2))
+
+        test_stack.test()
     }
-
-;    sub sub2(uword ad) {
-;        uword sub2var = 42
-;
-;        txt.print_uwhex(ad,true)
-;        txt.nl()
-;label_in_sub2:
-;        txt.nl()
-;    }
 }

From 9c4582e2830ce5b5c3ba32a20ccab07f5776e43b Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Fri, 8 Oct 2021 18:19:16 +0200
Subject: [PATCH 13/17] optimized codegen of swap of two memread values with
 index on the same pointer; like swap(@(ptr+i1), @(ptr+i2))

---
 .../cpu6502/codegen/BuiltinFunctionsAsmGen.kt | 45 ++++++++++++++++++-
 1 file changed, 44 insertions(+), 1 deletion(-)

diff --git a/compiler/src/prog8/compiler/target/cpu6502/codegen/BuiltinFunctionsAsmGen.kt b/compiler/src/prog8/compiler/target/cpu6502/codegen/BuiltinFunctionsAsmGen.kt
index 1e2edf3ab..7ae882f5a 100644
--- a/compiler/src/prog8/compiler/target/cpu6502/codegen/BuiltinFunctionsAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/cpu6502/codegen/BuiltinFunctionsAsmGen.kt
@@ -750,7 +750,6 @@ 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+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
@@ -773,6 +772,50 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     asmgen.out("  ldy  $name1 |  lda  $name2 |  sta  $name1 |  sty  $name2")
                     return
                 }
+                addr1==null && addr2==null && name1==null && name2==null -> {
+                    val firstExpr = first.addressExpression as? BinaryExpression
+                    val secondExpr = second.addressExpression as? BinaryExpression
+                    if(firstExpr!=null && secondExpr!=null) {
+                        val pointerVariable = firstExpr.left as? IdentifierReference
+                        val firstOffset = firstExpr.right
+                        val secondOffset = secondExpr.right
+                        if(pointerVariable != null
+                            && pointerVariable isSameAs secondExpr.left
+                            && firstExpr.operator == "+" && secondExpr.operator == "+"
+                            && (firstOffset is NumericLiteralValue || firstOffset is IdentifierReference || firstOffset is TypecastExpression)
+                            && (secondOffset is NumericLiteralValue || secondOffset is IdentifierReference || secondOffset is TypecastExpression)
+                        ) {
+                            val pointerVar = firstExpr.left as IdentifierReference
+                            if(firstOffset is NumericLiteralValue && secondOffset is NumericLiteralValue) {
+                                if(firstOffset!=secondOffset) {
+                                    swapArrayValues(
+                                        DataType.UBYTE,
+                                        asmgen.asmVariableName(pointerVariable), firstOffset,
+                                        asmgen.asmVariableName(pointerVariable), secondOffset
+                                    )
+                                    return
+                                }
+                            } else if(firstOffset is TypecastExpression && secondOffset is TypecastExpression) {
+                                if(firstOffset.type in WordDatatypes && secondOffset.type in WordDatatypes) {
+                                    val firstOffsetVar = firstOffset.expression as? IdentifierReference
+                                    val secondOffsetVar = secondOffset.expression as? IdentifierReference
+                                    if(firstOffsetVar!=null && secondOffsetVar!=null) {
+                                        if(firstOffsetVar!=secondOffsetVar) {
+                                            swapArrayValues(
+                                                DataType.UBYTE,
+                                                asmgen.asmVariableName(pointerVariable), firstOffsetVar,
+                                                asmgen.asmVariableName(pointerVariable), secondOffsetVar
+                                            )
+                                            return
+                                        }
+                                    }
+                                }
+                            } else if(firstOffset is IdentifierReference || secondOffset is IdentifierReference) {
+                                throw AssemblyError("expected a typecast-to-word for index variable at ${firstOffset.position} and/or ${secondOffset.position}")
+                            }
+                        }
+                    }
+                }
             }
         }
 

From 07132a2c422fb2a8cd035b3ae5bb91f871ad5a17 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Fri, 8 Oct 2021 23:09:38 +0200
Subject: [PATCH 14/17] removed unreliable inlining of non-asmsub subroutines.
 Fixes #60

---
 compiler/res/prog8lib/cx16/palette.p8         |  4 +-
 compiler/src/prog8/compiler/Compiler.kt       | 11 ---
 .../compiler/astprocessing/AstChecker.kt      |  7 +-
 .../compiler/target/cpu6502/codegen/AsmGen.kt |  4 +-
 .../cpu6502/codegen/FunctionCallAsmGen.kt     | 16 ++--
 .../src/prog8/optimizer/SubroutineInliner.kt  | 96 -------------------
 docs/source/programming.rst                   |  6 +-
 docs/source/syntaxreference.rst               |  5 +-
 examples/test.p8                              | 43 +--------
 9 files changed, 25 insertions(+), 167 deletions(-)
 delete mode 100644 compiler/src/prog8/optimizer/SubroutineInliner.kt

diff --git a/compiler/res/prog8lib/cx16/palette.p8 b/compiler/res/prog8lib/cx16/palette.p8
index 669f028a7..b2a1a5dd9 100644
--- a/compiler/res/prog8lib/cx16/palette.p8
+++ b/compiler/res/prog8lib/cx16/palette.p8
@@ -68,11 +68,11 @@ palette {
         }
     }
 
-    inline sub set_all_black() {
+    sub set_all_black() {
         set_monochrome($000, $000)
     }
 
-    inline sub set_all_white() {
+    sub set_all_white() {
         set_monochrome($fff, $fff)
     }
 
diff --git a/compiler/src/prog8/compiler/Compiler.kt b/compiler/src/prog8/compiler/Compiler.kt
index c256f4850..bc34795d5 100644
--- a/compiler/src/prog8/compiler/Compiler.kt
+++ b/compiler/src/prog8/compiler/Compiler.kt
@@ -297,17 +297,6 @@ private fun optimizeAst(programAst: Program, errors: IErrorReporter, functions:
             break
     }
 
-    val inliner = SubroutineInliner(programAst, errors, options)
-    inliner.visit(programAst)
-    errors.report()
-    if(errors.noErrors()) {
-        inliner.applyModifications()
-        inliner.fixCallsToInlinedSubroutines()
-        val remover2 = UnusedCodeRemover(programAst, errors, compTarget)
-        remover2.visit(programAst)
-        remover2.applyModifications()
-    }
-
     errors.report()
 }
 
diff --git a/compiler/src/prog8/compiler/astprocessing/AstChecker.kt b/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
index 07259b4aa..fd5a88cc1 100644
--- a/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
+++ b/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
@@ -269,10 +269,11 @@ internal class AstChecker(private val program: Program,
             }
         }
 
-        // scope check
-        if(subroutine.parent !is Block && subroutine.parent !is Subroutine) {
+        if(subroutine.inline && !subroutine.isAsmSubroutine)
+            err("subroutine inlining is currently only supported on asmsub routines")
+
+        if(subroutine.parent !is Block && subroutine.parent !is Subroutine)
             err("subroutines can only be defined in the scope of a block or within another subroutine")
-        }
 
         if(subroutine.isAsmSubroutine) {
             if(subroutine.asmParameterRegisters.size != subroutine.parameters.size)
diff --git a/compiler/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt b/compiler/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt
index 212911571..8ae826bdf 100644
--- a/compiler/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt
+++ b/compiler/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt
@@ -864,7 +864,7 @@ internal class AsmGen(private val program: Program,
 
         if(sub.inline) {
             if(options.optimize) {
-                if(sub.isAsmSubroutine ||callGraph.unused(sub))
+                if(sub.isAsmSubroutine || callGraph.unused(sub))
                     return
 
                 // from an inlined subroutine only the local variables are generated,
@@ -873,7 +873,7 @@ internal class AsmGen(private val program: Program,
                 onlyVariables = true
             }
             else if(sub.amountOfRtsInAsm()==0) {
-                // make sure the NOT INLINED subroutine actually does an rts at the end
+                // make sure the NOT INLINED subroutine actually does a rts at the end
                 sub.statements.add(Return(null, Position.DUMMY))
             }
         }
diff --git a/compiler/src/prog8/compiler/target/cpu6502/codegen/FunctionCallAsmGen.kt b/compiler/src/prog8/compiler/target/cpu6502/codegen/FunctionCallAsmGen.kt
index f44866ef1..05fe27299 100644
--- a/compiler/src/prog8/compiler/target/cpu6502/codegen/FunctionCallAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/cpu6502/codegen/FunctionCallAsmGen.kt
@@ -118,16 +118,14 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
             // we do this by copying the subroutine's statements at the call site.
             // NOTE: *if* there is a return statement, it will be the only one, and the very last statement of the subroutine
             // (this condition has been enforced by an ast check earlier)
+
+            // note: for now, this is only reliably supported for asmsubs.
+            if(!sub.isAsmSubroutine)
+                throw AssemblyError("can only reliably inline asmsub routines at this time")
+
             asmgen.out("  \t; inlined routine follows: ${sub.name}")
-            val statements = sub.statements.filter { it !is ParameterVarDecl && it !is Directive }
-            statements.forEach {
-                if(it is Return) {
-                    asmgen.translate(it, false)     // don't use RTS for the inlined return statement
-                } else {
-                    if(!sub.inline || it !is VarDecl)
-                        asmgen.translate(it)
-                }
-            }
+            val assembly = sub.statements.single() as InlineAssembly
+            asmgen.translate(assembly)
             asmgen.out("  \t; inlined routine end: ${sub.name}")
         }
 
diff --git a/compiler/src/prog8/optimizer/SubroutineInliner.kt b/compiler/src/prog8/optimizer/SubroutineInliner.kt
deleted file mode 100644
index 8f45ead9a..000000000
--- a/compiler/src/prog8/optimizer/SubroutineInliner.kt
+++ /dev/null
@@ -1,96 +0,0 @@
-package prog8.optimizer
-
-import prog8.ast.IFunctionCall
-import prog8.ast.Node
-import prog8.ast.Program
-import prog8.ast.base.Position
-import prog8.ast.expressions.FunctionCall
-import prog8.ast.expressions.IdentifierReference
-import prog8.ast.statements.*
-import prog8.ast.walk.AstWalker
-import prog8.ast.walk.IAstModification
-import prog8.compiler.CompilationOptions
-import prog8.compiler.IErrorReporter
-
-
-internal class SubroutineInliner(private val program: Program, val errors: IErrorReporter, private val compilerOptions: CompilationOptions): AstWalker() {
-    private var callsToInlinedSubroutines = mutableListOf<Pair<IFunctionCall, Node>>()
-
-    fun fixCallsToInlinedSubroutines() {
-        for((call, parent) in callsToInlinedSubroutines) {
-            val sub = call.target.targetSubroutine(program)!!
-            val intermediateReturnValueVar = sub.statements.filterIsInstance<VarDecl>().singleOrNull { it.name.endsWith(retvarName) }
-            if(intermediateReturnValueVar!=null) {
-                val scope = parent.definingScope()
-                if(!scope.statements.filterIsInstance<VarDecl>().any { it.name==intermediateReturnValueVar.name}) {
-                    val decl = intermediateReturnValueVar.copy()
-                    scope.statements.add(0, decl)
-                    decl.linkParents(scope as Node)
-                }
-            }
-        }
-    }
-
-    override fun after(subroutine: Subroutine, parent: Node): Iterable<IAstModification> {
-        return if(compilerOptions.optimize && subroutine.inline && !subroutine.isAsmSubroutine)
-            annotateInlinedSubroutineIdentifiers(subroutine)
-        else
-            noModifications
-    }
-
-    override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
-        return after(functionCallStatement as IFunctionCall, parent, functionCallStatement.position)
-    }
-
-    override fun after(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> {
-        return after(functionCall as IFunctionCall, parent, functionCall.position)
-    }
-
-    private fun after(functionCall: IFunctionCall, parent: Node, position: Position): Iterable<IAstModification> {
-        val sub = functionCall.target.targetSubroutine(program)
-        if(sub != null && compilerOptions.optimize && sub.inline && !sub.isAsmSubroutine)
-            callsToInlinedSubroutines.add(Pair(functionCall, parent))
-
-        return noModifications
-    }
-
-    private fun annotateInlinedSubroutineIdentifiers(sub: Subroutine): List<IAstModification> {
-        // this adds name prefixes to the identifiers used in the subroutine,
-        // so that the statements can be inlined (=copied) in the call site and still reference
-        // the correct symbols as seen from the scope of the subroutine.
-
-        class Annotator: AstWalker() {
-            var numReturns=0
-
-            override fun before(identifier: IdentifierReference, parent: Node): Iterable<IAstModification> {
-                val stmt = identifier.targetStatement(program)!!
-                if(stmt is BuiltinFunctionStatementPlaceholder)
-                    return noModifications
-
-                val prefixed = stmt.makeScopedName(identifier.nameInSource.last()).split('.')
-                val withPrefix = IdentifierReference(prefixed, identifier.position)
-                return listOf(IAstModification.ReplaceNode(identifier, withPrefix, parent))
-            }
-
-            override fun before(returnStmt: Return, parent: Node): Iterable<IAstModification> {
-                numReturns++
-                if(parent !== sub || sub.indexOfChild(returnStmt)<sub.statements.size-1)
-                    errors.err("return statement must be the very last statement in the inlined subroutine", sub.position)
-                return noModifications
-            }
-
-            fun theModifications(): List<IAstModification> {
-                return this.modifications.map { it.first }.toList()
-            }
-        }
-
-        val annotator = Annotator()
-        sub.accept(annotator, sub.parent)
-        if(annotator.numReturns>1) {
-            errors.err("inlined subroutine can only have one return statement", sub.position)
-            return noModifications
-        }
-        return annotator.theModifications()
-    }
-
-}
diff --git a/docs/source/programming.rst b/docs/source/programming.rst
index ad6634869..153789229 100644
--- a/docs/source/programming.rst
+++ b/docs/source/programming.rst
@@ -641,9 +641,13 @@ Subroutines can be defined in a Block, but also nested inside another subroutine
 With ``asmsub`` you can define a low-level subroutine that is implemented in inline assembly and takes any parameters
 in registers directly.
 
-Trivial subroutines can be tagged as ``inline`` to tell the compiler to copy their code
+Trivial ``asmsub`` routines can be tagged as ``inline`` to tell the compiler to copy their code
 in-place to the locations where the subroutine is called, rather than inserting an actual call and return to the
 subroutine. This may increase code size significantly and can only be used in limited scenarios, so YMMV.
+Note that the routine's code is copied verbatim into the place of the subroutine call in this case,
+so pay attention to any jumps and rts instructions in the inlined code!
+
+At this time it is not yet possible to inline regular Prog8 subroutines, this may be added in the future.
 
 
 Calling a subroutine
diff --git a/docs/source/syntaxreference.rst b/docs/source/syntaxreference.rst
index e97adb971..8db69295c 100644
--- a/docs/source/syntaxreference.rst
+++ b/docs/source/syntaxreference.rst
@@ -552,7 +552,7 @@ Subroutine definitions
 
 The syntax is::
 
-        [inline]  sub   <identifier>  ( [parameters] )  [ -> returntype ]  {
+        sub   <identifier>  ( [parameters] )  [ -> returntype ]  {
                 ... statements ...
         }
 
@@ -565,9 +565,6 @@ The open curly brace must immediately follow the subroutine result specification
 and can have nothing following it. The close curly brace must be on its own line as well.
 The parameters is a (possibly empty) comma separated list of "<datatype> <parametername>" pairs specifying the input parameters.
 The return type has to be specified if the subroutine returns a value.
-The ``inline`` keyword makes their code copied in-place to the locations where the subroutine is called,
-rather than having an actual call and return to the subroutine. This is meant for very small subroutines only
-as it can increase code size significantly.
 
 
 Assembly /  ROM subroutines
diff --git a/examples/test.p8 b/examples/test.p8
index 1bce15bdb..75adb566b 100644
--- a/examples/test.p8
+++ b/examples/test.p8
@@ -1,47 +1,12 @@
-%import textio
-%import floats
+%import palette
 %import test_stack
 %zeropage basicsafe
 
 main {
 
-label:
     sub start() {
-
-        ubyte ub1
-        ubyte ub2
-        uword uw1
-        uword uw2
-        float fl1
-        float fl2
-        ubyte[10] ubarr
-        uword[10] uwarr
-        float[10] flarr
-
-        swap(ub1, ub2)
-        swap(uw1, uw2)
-        swap(fl1, fl2)
-        swap(ubarr[1], ubarr[2])
-        swap(uwarr[1], uwarr[2])
-        swap(flarr[1], flarr[2])
-
-        ubyte ix1
-        ubyte ix2
-
-        swap(ubarr[ix1], ubarr[ix2])
-        swap(uwarr[ix1], uwarr[ix2])
-        swap(flarr[ix1], flarr[ix2])
-        swap(flarr[ix1], flarr[2])
-        swap(flarr[2], flarr[ix2])
-
-        swap(ubarr[ix1], ubarr[ix1+2])
-        swap(uwarr[ix1], uwarr[ix1+2])
-        swap(flarr[ix1], flarr[ix1+2])
-
-        uword ptr = $c000
-        swap(@(ptr+1), @(ptr+2))
-        swap(@(ptr+ub1), @(ptr+ub2))
-
-        test_stack.test()
+        ; TODO inline a subroutine that only contains a direct call to another subroutine
+        palette.set_all_black()
+        palette.set_all_white()
     }
 }

From e8f308f654650424d3c2a6416029df7cf77a7ffa Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Sat, 9 Oct 2021 01:36:13 +0200
Subject: [PATCH 15/17] a few more inlinings of trivial return values

---
 .../src/prog8/optimizer/StatementOptimizer.kt | 61 ++++++++++++----
 .../prog8/ast/expressions/AstExpressions.kt   |  6 +-
 examples/test.p8                              | 70 +++++++++++++++++--
 3 files changed, 115 insertions(+), 22 deletions(-)

diff --git a/compiler/src/prog8/optimizer/StatementOptimizer.kt b/compiler/src/prog8/optimizer/StatementOptimizer.kt
index 413b6e2fd..41355daa8 100644
--- a/compiler/src/prog8/optimizer/StatementOptimizer.kt
+++ b/compiler/src/prog8/optimizer/StatementOptimizer.kt
@@ -39,6 +39,41 @@ internal class StatementOptimizer(private val program: Program,
         return noModifications
     }
 
+    override fun before(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> {
+        // if the first instruction in the called subroutine is a return statement with a simple value,
+        // remove the jump altogeter and inline the returnvalue directly.
+        val subroutine = functionCall.target.targetSubroutine(program)
+        if(subroutine!=null) {
+            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
+            if(first is Return && first.value?.isSimple==true) {
+                val orig = first.value!!
+                val copy = when(orig) {
+                    is AddressOf -> {
+                        val scoped = scopePrefix(orig.identifier, subroutine)
+                        AddressOf(scoped, orig.position)
+                    }
+                    is DirectMemoryRead -> {
+                        when(val expr = orig.addressExpression) {
+                            is NumericLiteralValue -> DirectMemoryRead(expr.copy(), orig.position)
+                            else -> return noModifications
+                        }
+                    }
+                    is IdentifierReference -> scopePrefix(orig, subroutine)
+                    is NumericLiteralValue -> orig.copy()
+                    is StringLiteralValue -> orig.copy()
+                    else -> return noModifications
+                }
+                return listOf(IAstModification.ReplaceNode(functionCall, copy, parent))
+            }
+        }
+        return noModifications
+    }
+
+    private fun scopePrefix(variable: IdentifierReference, subroutine: Subroutine): IdentifierReference {
+        val scoped = subroutine.makeScopedName(variable.nameInSource.last())
+        return IdentifierReference(scoped.split('.'), variable.position)
+    }
+
     override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
         if(functionCallStatement.target.nameInSource.size==1 && functionCallStatement.target.nameInSource[0] in functions.names) {
             val functionName = functionCallStatement.target.nameInSource[0]
@@ -101,19 +136,19 @@ internal class StatementOptimizer(private val program: Program,
         return noModifications
     }
 
-    override fun before(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> {
-        // if the first instruction in the called subroutine is a return statement with constant value, replace with the constant value
-        val subroutine = functionCall.target.targetSubroutine(program)
-        if(subroutine!=null) {
-            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
-            if(first is Return && first.value!=null) {
-                val constval = first.value?.constValue(program)
-                if(constval!=null)
-                    return listOf(IAstModification.ReplaceNode(functionCall, constval, parent))
-            }
-        }
-        return noModifications
-    }
+//    override fun before(functionCall: FunctionCall, parent: Node): Iterable<IAstModification> {
+//        // if the first instruction in the called subroutine is a return statement with constant value, replace with the constant value
+//        val subroutine = functionCall.target.targetSubroutine(program)
+//        if(subroutine!=null) {
+//            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
+//            if(first is Return && first.value!=null) {
+//                val constval = first.value?.constValue(program)
+//                if(constval!=null)
+//                    return listOf(IAstModification.ReplaceNode(functionCall, constval, parent))
+//            }
+//        }
+//        return noModifications
+//    }
 
     override fun after(ifStatement: IfStatement, parent: Node): Iterable<IAstModification> {
         // remove empty if statements
diff --git a/compilerAst/src/prog8/ast/expressions/AstExpressions.kt b/compilerAst/src/prog8/ast/expressions/AstExpressions.kt
index e4ea9097a..1d6d721c2 100644
--- a/compilerAst/src/prog8/ast/expressions/AstExpressions.kt
+++ b/compilerAst/src/prog8/ast/expressions/AstExpressions.kt
@@ -348,7 +348,7 @@ class DirectMemoryRead(var addressExpression: Expression, override val position:
         this.addressExpression.linkParents(this)
     }
 
-    override val isSimple = true
+    override val isSimple = addressExpression is NumericLiteralValue || addressExpression is IdentifierReference
 
     override fun replaceChildNode(node: Node, replacement: Node) {
         require(replacement is Expression && node===addressExpression)
@@ -366,8 +366,6 @@ class DirectMemoryRead(var addressExpression: Expression, override val position:
     override fun toString(): String {
         return "DirectMemoryRead($addressExpression)"
     }
-
-    fun copy() =  DirectMemoryRead(addressExpression, position)
 }
 
 class NumericLiteralValue(val type: DataType,    // only numerical types allowed
@@ -376,6 +374,7 @@ class NumericLiteralValue(val type: DataType,    // only numerical types allowed
     override lateinit var parent: Node
 
     override val isSimple = true
+    fun copy() = NumericLiteralValue(type, number, position)
 
     companion object {
         fun fromBoolean(bool: Boolean, position: Position) =
@@ -509,6 +508,7 @@ class StringLiteralValue(val value: String,
     }
 
     override val isSimple = true
+    fun copy() = StringLiteralValue(value, altEncoding, position)
 
     override fun replaceChildNode(node: Node, replacement: Node) {
         throw FatalAstException("can't replace here")
diff --git a/examples/test.p8 b/examples/test.p8
index 75adb566b..0475e7eeb 100644
--- a/examples/test.p8
+++ b/examples/test.p8
@@ -1,12 +1,70 @@
-%import palette
-%import test_stack
-%zeropage basicsafe
+%import textio
+%zeropage dontuse
 
 main {
 
     sub start() {
-        ; TODO inline a subroutine that only contains a direct call to another subroutine
-        palette.set_all_black()
-        palette.set_all_white()
+        uword v
+        v = test.get_value1()
+        txt.print_uw(v)
+        txt.nl()
+        v = test.get_value2()
+        txt.print_uw(v)
+        txt.nl()
+        v = test.get_value3()
+        txt.print_uw(v)
+        txt.nl()
+        v = test.get_value4()
+        txt.print_uw(v)
+        v = test.get_value4()
+        txt.print_uw(v)
+        v = test.get_value4()
+        txt.print_uw(v)
+        v = test.get_value4()
+        txt.print_uw(v)
+        v = test.get_value4()
+        txt.print_uw(v)
+        v = test.get_value4()
+        txt.print_uw(v)
+        v = test.get_value4()
+        txt.print_uw(v)
+        v = test.get_value4()
+        txt.print_uw(v)
+        v = test.get_value4()
+        txt.print_uw(v)
+        v = test.get_value4()
+        txt.print_uw(v)
+        txt.nl()
+        v = test.get_value5()
+        txt.print_uw(v)
+        txt.nl()
+        v = test.get_value6()
+        txt.print_uw(v)
+        txt.nl()
+    }
+}
+
+
+test {
+    uword[] arr = [1111,2222,3333]
+    uword value = 9999
+
+    sub get_value1() -> uword {
+        return &value
+    }
+    sub get_value2() -> uword {
+        return arr[2]
+    }
+    sub get_value3() -> ubyte {
+        return @($c000)
+    }
+    sub get_value4() -> uword {
+        return value
+    }
+    sub get_value5() -> uword {
+        return $c000
+    }
+    sub get_value6() -> uword {
+        return "string"
     }
 }

From 98987917710c678943799aed5038b51dec041c72 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Sat, 9 Oct 2021 16:32:44 +0200
Subject: [PATCH 16/17] clean test.p8

---
 examples/test.p8 | 68 +++---------------------------------------------
 1 file changed, 4 insertions(+), 64 deletions(-)

diff --git a/examples/test.p8 b/examples/test.p8
index 0475e7eeb..03f7faf6e 100644
--- a/examples/test.p8
+++ b/examples/test.p8
@@ -1,70 +1,10 @@
 %import textio
-%zeropage dontuse
+%import test_stack
+%zeropage basicsafe
 
 main {
-
     sub start() {
-        uword v
-        v = test.get_value1()
-        txt.print_uw(v)
-        txt.nl()
-        v = test.get_value2()
-        txt.print_uw(v)
-        txt.nl()
-        v = test.get_value3()
-        txt.print_uw(v)
-        txt.nl()
-        v = test.get_value4()
-        txt.print_uw(v)
-        v = test.get_value4()
-        txt.print_uw(v)
-        v = test.get_value4()
-        txt.print_uw(v)
-        v = test.get_value4()
-        txt.print_uw(v)
-        v = test.get_value4()
-        txt.print_uw(v)
-        v = test.get_value4()
-        txt.print_uw(v)
-        v = test.get_value4()
-        txt.print_uw(v)
-        v = test.get_value4()
-        txt.print_uw(v)
-        v = test.get_value4()
-        txt.print_uw(v)
-        v = test.get_value4()
-        txt.print_uw(v)
-        txt.nl()
-        v = test.get_value5()
-        txt.print_uw(v)
-        txt.nl()
-        v = test.get_value6()
-        txt.print_uw(v)
-        txt.nl()
-    }
-}
-
-
-test {
-    uword[] arr = [1111,2222,3333]
-    uword value = 9999
-
-    sub get_value1() -> uword {
-        return &value
-    }
-    sub get_value2() -> uword {
-        return arr[2]
-    }
-    sub get_value3() -> ubyte {
-        return @($c000)
-    }
-    sub get_value4() -> uword {
-        return value
-    }
-    sub get_value5() -> uword {
-        return $c000
-    }
-    sub get_value6() -> uword {
-        return "string"
+        txt.print("ok")
+        test_stack.test()
     }
 }

From 1625e4eb859847984297fcae2cfe5e68a64ea291 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Sat, 9 Oct 2021 16:56:39 +0200
Subject: [PATCH 17/17] rename prog8Parser (generated java) to Prog8ANTLRParser

---
 .idea/compiler.xml                            |   3 +-
 .idea/misc.xml                                |   6 +-
 .../src/prog8/ast/antlr/Antlr2Kotlin.kt       | 104 +++++++++---------
 .../parser/CommentHandlingTokenStream.kt      |   2 +-
 compilerAst/src/prog8/parser/ModuleParsing.kt |   6 +-
 compilerAst/test/TestAntlrParser.kt           |  18 +--
 parser/antlr/{prog8.g4 => Prog8ANTLR.g4}      |   4 +-
 7 files changed, 73 insertions(+), 70 deletions(-)
 rename parser/antlr/{prog8.g4 => Prog8ANTLR.g4} (98%)

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index a39e0f0fb..7f5cc8694 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -2,5 +2,6 @@
 <project version="4">
   <component name="CompilerConfiguration">
     <option name="BUILD_PROCESS_HEAP_SIZE" value="1200" />
+    <bytecodeTargetLevel target="11" />
   </component>
-</project>
\ No newline at end of file
+</project>
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 5455bfad2..d79c99176 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -4,7 +4,7 @@
     <option name="perGrammarGenerationSettings">
       <list>
         <PerGrammarGenerationSettings>
-          <option name="fileName" value="$PROJECT_DIR$/parser/antlr/prog8.g4" />
+          <option name="fileName" value="$PROJECT_DIR$/parser/antlr/Prog8ANTLR.g4" />
           <option name="autoGen" value="true" />
           <option name="outputDir" value="$PROJECT_DIR$/parser/src/prog8/parser" />
           <option name="libDir" value="" />
@@ -16,7 +16,7 @@
       </list>
     </option>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="false" project-jdk-name="Kotlin SDK" project-jdk-type="KotlinSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="Kotlin SDK" project-jdk-type="KotlinSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
-</project>
\ No newline at end of file
+</project>
diff --git a/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt b/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt
index fc07eece1..7240b95fe 100644
--- a/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt
+++ b/compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt
@@ -9,7 +9,7 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.parser.CustomLexer
-import prog8.parser.prog8Parser
+import prog8.parser.Prog8ANTLRParser
 import java.io.CharConversionException
 import java.io.File
 import java.nio.file.Path
@@ -19,7 +19,7 @@ import java.nio.file.Path
 
 private data class NumericLiteral(val number: Number, val datatype: DataType)
 
-internal fun prog8Parser.ModuleContext.toAst(name: String, source: Path, encoding: IStringEncoding) : Module {
+internal fun Prog8ANTLRParser.ModuleContext.toAst(name: String, source: Path, encoding: IStringEncoding) : Module {
     val nameWithoutSuffix = if(name.endsWith(".p8")) name.substringBeforeLast('.') else name
     val directives = this.directive().map { it.toAst() }
     val blocks = this.block().map { it.toAst(Module.isLibrary(source), encoding) }
@@ -38,7 +38,7 @@ private fun ParserRuleContext.toPosition() : Position {
     return Position(filename, start.line, start.charPositionInLine, stop.charPositionInLine + stop.text.length)
 }
 
-private fun prog8Parser.BlockContext.toAst(isInLibrary: Boolean, encoding: IStringEncoding) : Statement {
+private fun Prog8ANTLRParser.BlockContext.toAst(isInLibrary: Boolean, encoding: IStringEncoding) : Statement {
     val blockstatements = block_statement().map {
         when {
             it.variabledeclaration()!=null -> it.variabledeclaration().toAst(encoding)
@@ -52,10 +52,10 @@ private fun prog8Parser.BlockContext.toAst(isInLibrary: Boolean, encoding: IStri
     return Block(identifier().text, integerliteral()?.toAst()?.number?.toInt(), blockstatements.toMutableList(), isInLibrary, toPosition())
 }
 
-private fun prog8Parser.Statement_blockContext.toAst(encoding: IStringEncoding): MutableList<Statement> =
+private fun Prog8ANTLRParser.Statement_blockContext.toAst(encoding: IStringEncoding): MutableList<Statement> =
         statement().asSequence().map { it.toAst(encoding) }.toMutableList()
 
-private fun prog8Parser.VariabledeclarationContext.toAst(encoding: IStringEncoding) : Statement {
+private fun Prog8ANTLRParser.VariabledeclarationContext.toAst(encoding: IStringEncoding) : Statement {
     vardecl()?.let { return it.toAst(encoding) }
 
     varinitializer()?.let {
@@ -111,7 +111,7 @@ private fun prog8Parser.VariabledeclarationContext.toAst(encoding: IStringEncodi
     throw FatalAstException("weird variable decl $this")
 }
 
-private fun prog8Parser.SubroutinedeclarationContext.toAst(encoding: IStringEncoding) : Subroutine {
+private fun Prog8ANTLRParser.SubroutinedeclarationContext.toAst(encoding: IStringEncoding) : Subroutine {
     return when {
         subroutine()!=null -> subroutine().toAst(encoding)
         asmsubroutine()!=null -> asmsubroutine().toAst(encoding)
@@ -120,7 +120,7 @@ private fun prog8Parser.SubroutinedeclarationContext.toAst(encoding: IStringEnco
     }
 }
 
-private fun prog8Parser.StatementContext.toAst(encoding: IStringEncoding) : Statement {
+private fun Prog8ANTLRParser.StatementContext.toAst(encoding: IStringEncoding) : Statement {
     val vardecl = variabledeclaration()?.toAst(encoding)
     if(vardecl!=null) return vardecl
 
@@ -188,7 +188,7 @@ private fun prog8Parser.StatementContext.toAst(encoding: IStringEncoding) : Stat
     throw FatalAstException("unprocessed source text (are we missing ast conversion rules for parser elements?): $text")
 }
 
-private fun prog8Parser.AsmsubroutineContext.toAst(encoding: IStringEncoding): Subroutine {
+private fun Prog8ANTLRParser.AsmsubroutineContext.toAst(encoding: IStringEncoding): Subroutine {
     val inline = this.inline()!=null
     val subdecl = asmsub_decl().toAst()
     val statements = statement_block()?.toAst(encoding) ?: mutableListOf()
@@ -197,7 +197,7 @@ private fun prog8Parser.AsmsubroutineContext.toAst(encoding: IStringEncoding): S
             subdecl.asmClobbers, null, true, inline, statements, toPosition())
 }
 
-private fun prog8Parser.RomsubroutineContext.toAst(): Subroutine {
+private fun Prog8ANTLRParser.RomsubroutineContext.toAst(): Subroutine {
     val subdecl = asmsub_decl().toAst()
     val address = integerliteral().toAst().number.toInt()
     return Subroutine(subdecl.name, subdecl.parameters, subdecl.returntypes,
@@ -213,7 +213,7 @@ private class AsmsubDecl(val name: String,
                          val asmReturnvaluesRegisters: List<RegisterOrStatusflag>,
                          val asmClobbers: Set<CpuRegister>)
 
-private fun prog8Parser.Asmsub_declContext.toAst(): AsmsubDecl {
+private fun Prog8ANTLRParser.Asmsub_declContext.toAst(): AsmsubDecl {
     val name = identifier().text
     val params = asmsub_params()?.toAst() ?: emptyList()
     val returns = asmsub_returns()?.toAst() ?: emptyList()
@@ -236,7 +236,7 @@ private class AsmSubroutineReturn(val type: DataType,
                                   val statusflag: Statusflag?,
                                   val position: Position)
 
-private fun prog8Parser.Asmsub_returnsContext.toAst(): List<AsmSubroutineReturn>
+private fun Prog8ANTLRParser.Asmsub_returnsContext.toAst(): List<AsmSubroutineReturn>
         = asmsub_return().map {
             val register = it.register().text
             var registerorpair: RegisterOrPair? = null
@@ -255,7 +255,7 @@ private fun prog8Parser.Asmsub_returnsContext.toAst(): List<AsmSubroutineReturn>
                     toPosition())
         }
 
-private fun prog8Parser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParameter>
+private fun Prog8ANTLRParser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParameter>
         = asmsub_param().map {
     val vardecl = it.vardecl()
     val datatype = vardecl.datatype()?.toAst() ?: DataType.UNDEFINED
@@ -272,7 +272,7 @@ private fun prog8Parser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParamete
     AsmSubroutineParameter(vardecl.varname.text, datatype, registerorpair, statusregister, toPosition())
 }
 
-private fun prog8Parser.Functioncall_stmtContext.toAst(encoding: IStringEncoding): Statement {
+private fun Prog8ANTLRParser.Functioncall_stmtContext.toAst(encoding: IStringEncoding): Statement {
     val void = this.VOID() != null
     val location = scoped_identifier().toAst()
     return if(expression_list() == null)
@@ -281,7 +281,7 @@ private fun prog8Parser.Functioncall_stmtContext.toAst(encoding: IStringEncoding
         FunctionCallStatement(location, expression_list().toAst(encoding).toMutableList(), void, toPosition())
 }
 
-private fun prog8Parser.FunctioncallContext.toAst(encoding: IStringEncoding): FunctionCall {
+private fun Prog8ANTLRParser.FunctioncallContext.toAst(encoding: IStringEncoding): FunctionCall {
     val location = scoped_identifier().toAst()
     return if(expression_list() == null)
         FunctionCall(location, mutableListOf(), toPosition())
@@ -289,23 +289,23 @@ private fun prog8Parser.FunctioncallContext.toAst(encoding: IStringEncoding): Fu
         FunctionCall(location, expression_list().toAst(encoding).toMutableList(), toPosition())
 }
 
-private fun prog8Parser.InlineasmContext.toAst() =
+private fun Prog8ANTLRParser.InlineasmContext.toAst() =
         InlineAssembly(INLINEASMBLOCK().text, toPosition())
 
-private fun prog8Parser.ReturnstmtContext.toAst(encoding: IStringEncoding) : Return {
+private fun Prog8ANTLRParser.ReturnstmtContext.toAst(encoding: IStringEncoding) : Return {
     return Return(expression()?.toAst(encoding), toPosition())
 }
 
-private fun prog8Parser.UnconditionaljumpContext.toAst(): Jump {
+private fun Prog8ANTLRParser.UnconditionaljumpContext.toAst(): Jump {
     val address = integerliteral()?.toAst()?.number?.toInt()
     val identifier = scoped_identifier()?.toAst()
     return Jump(address, identifier, null, toPosition())
 }
 
-private fun prog8Parser.LabeldefContext.toAst(): Statement =
+private fun Prog8ANTLRParser.LabeldefContext.toAst(): Statement =
         Label(children[0].text, toPosition())
 
-private fun prog8Parser.SubroutineContext.toAst(encoding: IStringEncoding) : Subroutine {
+private fun Prog8ANTLRParser.SubroutineContext.toAst(encoding: IStringEncoding) : Subroutine {
     // non-asm subroutine
     val inline = inline()!=null
     val returntypes = sub_return_part()?.toAst() ?: emptyList()
@@ -317,18 +317,18 @@ private fun prog8Parser.SubroutineContext.toAst(encoding: IStringEncoding) : Sub
             toPosition())
 }
 
-private fun prog8Parser.Sub_return_partContext.toAst(): List<DataType> {
+private fun Prog8ANTLRParser.Sub_return_partContext.toAst(): List<DataType> {
     val returns = sub_returns() ?: return emptyList()
     return returns.datatype().map { it.toAst() }
 }
 
-private fun prog8Parser.Sub_paramsContext.toAst(): List<SubroutineParameter> =
+private fun Prog8ANTLRParser.Sub_paramsContext.toAst(): List<SubroutineParameter> =
         vardecl().map {
             val datatype = it.datatype()?.toAst() ?: DataType.UNDEFINED
             SubroutineParameter(it.varname.text, datatype, it.toPosition())
         }
 
-private fun prog8Parser.Assign_targetContext.toAst(encoding: IStringEncoding) : AssignTarget {
+private fun Prog8ANTLRParser.Assign_targetContext.toAst(encoding: IStringEncoding) : AssignTarget {
     val identifier = scoped_identifier()
     return when {
         identifier!=null -> AssignTarget(identifier.toAst(), null, null, toPosition())
@@ -338,20 +338,20 @@ private fun prog8Parser.Assign_targetContext.toAst(encoding: IStringEncoding) :
     }
 }
 
-private fun prog8Parser.ClobberContext.toAst() : Set<CpuRegister> {
+private fun Prog8ANTLRParser.ClobberContext.toAst() : Set<CpuRegister> {
     val names = this.cpuregister().map { it.text }
     return names.map { CpuRegister.valueOf(it) }.toSet()
 }
 
-private fun prog8Parser.DatatypeContext.toAst() = DataType.valueOf(text.uppercase())
+private fun Prog8ANTLRParser.DatatypeContext.toAst() = DataType.valueOf(text.uppercase())
 
-private fun prog8Parser.ArrayindexContext.toAst(encoding: IStringEncoding) : ArrayIndex =
+private fun Prog8ANTLRParser.ArrayindexContext.toAst(encoding: IStringEncoding) : ArrayIndex =
         ArrayIndex(expression().toAst(encoding), toPosition())
 
-private fun prog8Parser.DirectiveContext.toAst() : Directive =
+private fun Prog8ANTLRParser.DirectiveContext.toAst() : Directive =
         Directive(directivename.text, directivearg().map { it.toAst() }, toPosition())
 
-private fun prog8Parser.DirectiveargContext.toAst() : DirectiveArg {
+private fun Prog8ANTLRParser.DirectiveargContext.toAst() : DirectiveArg {
     val str = stringliteral()
     if(str?.ALT_STRING_ENCODING() != null)
         throw AstException("${toPosition()} can't use alternate string encodings for directive arguments")
@@ -359,7 +359,7 @@ private fun prog8Parser.DirectiveargContext.toAst() : DirectiveArg {
     return DirectiveArg(stringliteral()?.text, identifier()?.text, integerliteral()?.toAst()?.number?.toInt(), toPosition())
 }
 
-private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
+private fun Prog8ANTLRParser.IntegerliteralContext.toAst(): NumericLiteral {
     fun makeLiteral(text: String, radix: Int): NumericLiteral {
         val integer: Int
         var datatype = DataType.UBYTE
@@ -403,14 +403,14 @@ private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
     val terminal: TerminalNode = children[0] as TerminalNode
     val integerPart = this.intpart.text
     return when (terminal.symbol.type) {
-        prog8Parser.DEC_INTEGER -> makeLiteral(integerPart, 10)
-        prog8Parser.HEX_INTEGER -> makeLiteral(integerPart.substring(1), 16)
-        prog8Parser.BIN_INTEGER -> makeLiteral(integerPart.substring(1), 2)
+        Prog8ANTLRParser.DEC_INTEGER -> makeLiteral(integerPart, 10)
+        Prog8ANTLRParser.HEX_INTEGER -> makeLiteral(integerPart.substring(1), 16)
+        Prog8ANTLRParser.BIN_INTEGER -> makeLiteral(integerPart.substring(1), 2)
         else -> throw FatalAstException(terminal.text)
     }
 }
 
-private fun prog8Parser.ExpressionContext.toAst(encoding: IStringEncoding) : Expression {
+private fun Prog8ANTLRParser.ExpressionContext.toAst(encoding: IStringEncoding) : Expression {
 
     val litval = literalvalue()
     if(litval!=null) {
@@ -487,35 +487,35 @@ private fun prog8Parser.ExpressionContext.toAst(encoding: IStringEncoding) : Exp
     throw FatalAstException(text)
 }
 
-private fun prog8Parser.StringliteralContext.toAst(): StringLiteralValue =
+private fun Prog8ANTLRParser.StringliteralContext.toAst(): StringLiteralValue =
     StringLiteralValue(unescape(this.STRING().text, toPosition()), ALT_STRING_ENCODING()!=null, toPosition())
 
-private fun prog8Parser.ArrayindexedContext.toAst(encoding: IStringEncoding): ArrayIndexedExpression {
+private fun Prog8ANTLRParser.ArrayindexedContext.toAst(encoding: IStringEncoding): ArrayIndexedExpression {
     return ArrayIndexedExpression(scoped_identifier().toAst(),
             arrayindex().toAst(encoding),
             toPosition())
 }
 
-private fun prog8Parser.Expression_listContext.toAst(encoding: IStringEncoding) = expression().map{ it.toAst(encoding) }
+private fun Prog8ANTLRParser.Expression_listContext.toAst(encoding: IStringEncoding) = expression().map{ it.toAst(encoding) }
 
-private fun prog8Parser.IdentifierContext.toAst() : IdentifierReference =
+private fun Prog8ANTLRParser.IdentifierContext.toAst() : IdentifierReference =
         IdentifierReference(listOf(text), toPosition())
 
-private fun prog8Parser.Scoped_identifierContext.toAst() : IdentifierReference =
+private fun Prog8ANTLRParser.Scoped_identifierContext.toAst() : IdentifierReference =
         IdentifierReference(NAME().map { it.text }, toPosition())
 
-private fun prog8Parser.FloatliteralContext.toAst() = text.toDouble()
+private fun Prog8ANTLRParser.FloatliteralContext.toAst() = text.toDouble()
 
-private fun prog8Parser.BooleanliteralContext.toAst() = when(text) {
+private fun Prog8ANTLRParser.BooleanliteralContext.toAst() = when(text) {
     "true" -> true
     "false" -> false
     else -> throw FatalAstException(text)
 }
 
-private fun prog8Parser.ArrayliteralContext.toAst(encoding: IStringEncoding) : Array<Expression> =
+private fun Prog8ANTLRParser.ArrayliteralContext.toAst(encoding: IStringEncoding) : Array<Expression> =
         expression().map { it.toAst(encoding) }.toTypedArray()
 
-private fun prog8Parser.If_stmtContext.toAst(encoding: IStringEncoding): IfStatement {
+private fun Prog8ANTLRParser.If_stmtContext.toAst(encoding: IStringEncoding): IfStatement {
     val condition = expression().toAst(encoding)
     val trueStatements = statement_block()?.toAst(encoding) ?: mutableListOf(statement().toAst(encoding))
     val elseStatements = else_part()?.toAst(encoding) ?: mutableListOf()
@@ -525,11 +525,11 @@ private fun prog8Parser.If_stmtContext.toAst(encoding: IStringEncoding): IfState
     return IfStatement(condition, trueScope, elseScope, toPosition())
 }
 
-private fun prog8Parser.Else_partContext.toAst(encoding: IStringEncoding): MutableList<Statement> {
+private fun Prog8ANTLRParser.Else_partContext.toAst(encoding: IStringEncoding): MutableList<Statement> {
     return statement_block()?.toAst(encoding) ?: mutableListOf(statement().toAst(encoding))
 }
 
-private fun prog8Parser.Branch_stmtContext.toAst(encoding: IStringEncoding): BranchStatement {
+private fun Prog8ANTLRParser.Branch_stmtContext.toAst(encoding: IStringEncoding): BranchStatement {
     val branchcondition = branchcondition().toAst()
     val trueStatements = statement_block()?.toAst(encoding) ?: mutableListOf(statement().toAst(encoding))
     val elseStatements = else_part()?.toAst(encoding) ?: mutableListOf()
@@ -539,11 +539,11 @@ private fun prog8Parser.Branch_stmtContext.toAst(encoding: IStringEncoding): Bra
     return BranchStatement(branchcondition, trueScope, elseScope, toPosition())
 }
 
-private fun prog8Parser.BranchconditionContext.toAst() = BranchCondition.valueOf(
+private fun Prog8ANTLRParser.BranchconditionContext.toAst() = BranchCondition.valueOf(
     text.substringAfter('_').uppercase()
 )
 
-private fun prog8Parser.ForloopContext.toAst(encoding: IStringEncoding): ForLoop {
+private fun Prog8ANTLRParser.ForloopContext.toAst(encoding: IStringEncoding): ForLoop {
     val loopvar = identifier().toAst()
     val iterable = expression()!!.toAst(encoding)
     val scope =
@@ -554,9 +554,9 @@ private fun prog8Parser.ForloopContext.toAst(encoding: IStringEncoding): ForLoop
     return ForLoop(loopvar, iterable, scope, toPosition())
 }
 
-private fun prog8Parser.BreakstmtContext.toAst() = Break(toPosition())
+private fun Prog8ANTLRParser.BreakstmtContext.toAst() = Break(toPosition())
 
-private fun prog8Parser.WhileloopContext.toAst(encoding: IStringEncoding): WhileLoop {
+private fun Prog8ANTLRParser.WhileloopContext.toAst(encoding: IStringEncoding): WhileLoop {
     val condition = expression().toAst(encoding)
     val statements = statement_block()?.toAst(encoding) ?: mutableListOf(statement().toAst(encoding))
     val scope = AnonymousScope(statements, statement_block()?.toPosition()
@@ -564,7 +564,7 @@ private fun prog8Parser.WhileloopContext.toAst(encoding: IStringEncoding): While
     return WhileLoop(condition, scope, toPosition())
 }
 
-private fun prog8Parser.RepeatloopContext.toAst(encoding: IStringEncoding): RepeatLoop {
+private fun Prog8ANTLRParser.RepeatloopContext.toAst(encoding: IStringEncoding): RepeatLoop {
     val iterations = expression()?.toAst(encoding)
     val statements = statement_block()?.toAst(encoding) ?: mutableListOf(statement().toAst(encoding))
     val scope = AnonymousScope(statements, statement_block()?.toPosition()
@@ -572,7 +572,7 @@ private fun prog8Parser.RepeatloopContext.toAst(encoding: IStringEncoding): Repe
     return RepeatLoop(iterations, scope, toPosition())
 }
 
-private fun prog8Parser.UntilloopContext.toAst(encoding: IStringEncoding): UntilLoop {
+private fun Prog8ANTLRParser.UntilloopContext.toAst(encoding: IStringEncoding): UntilLoop {
     val untilCondition = expression().toAst(encoding)
     val statements = statement_block()?.toAst(encoding) ?: mutableListOf(statement().toAst(encoding))
     val scope = AnonymousScope(statements, statement_block()?.toPosition()
@@ -580,13 +580,13 @@ private fun prog8Parser.UntilloopContext.toAst(encoding: IStringEncoding): Until
     return UntilLoop(scope, untilCondition, toPosition())
 }
 
-private fun prog8Parser.WhenstmtContext.toAst(encoding: IStringEncoding): WhenStatement {
+private fun Prog8ANTLRParser.WhenstmtContext.toAst(encoding: IStringEncoding): WhenStatement {
     val condition = expression().toAst(encoding)
     val choices = this.when_choice()?.map { it.toAst(encoding) }?.toMutableList() ?: mutableListOf()
     return WhenStatement(condition, choices, toPosition())
 }
 
-private fun prog8Parser.When_choiceContext.toAst(encoding: IStringEncoding): WhenChoice {
+private fun Prog8ANTLRParser.When_choiceContext.toAst(encoding: IStringEncoding): WhenChoice {
     val values = expression_list()?.toAst(encoding)
     val stmt = statement()?.toAst(encoding)
     val stmtBlock = statement_block()?.toAst(encoding)?.toMutableList() ?: mutableListOf()
@@ -596,7 +596,7 @@ private fun prog8Parser.When_choiceContext.toAst(encoding: IStringEncoding): Whe
     return WhenChoice(values?.toMutableList(), scope, toPosition())
 }
 
-private fun prog8Parser.VardeclContext.toAst(encoding: IStringEncoding): VarDecl {
+private fun Prog8ANTLRParser.VardeclContext.toAst(encoding: IStringEncoding): VarDecl {
     return VarDecl(
             VarDeclType.VAR,
             datatype()?.toAst() ?: DataType.UNDEFINED,
diff --git a/compilerAst/src/prog8/parser/CommentHandlingTokenStream.kt b/compilerAst/src/prog8/parser/CommentHandlingTokenStream.kt
index efb769bf3..dd73a29cc 100644
--- a/compilerAst/src/prog8/parser/CommentHandlingTokenStream.kt
+++ b/compilerAst/src/prog8/parser/CommentHandlingTokenStream.kt
@@ -9,7 +9,7 @@ internal class CommentHandlingTokenStream(lexer: Lexer) : CommonTokenStream(lexe
 
     fun commentTokens() : List<Comment> {
         // extract the comments
-        val commentTokenChannel = prog8Lexer.channelNames.indexOf("HIDDEN")
+        val commentTokenChannel = Prog8ANTLRLexer.channelNames.indexOf("HIDDEN")
         val theLexer = tokenSource as Lexer
         return get(0, size())
                 .asSequence()
diff --git a/compilerAst/src/prog8/parser/ModuleParsing.kt b/compilerAst/src/prog8/parser/ModuleParsing.kt
index f927ae7ca..d71444989 100644
--- a/compilerAst/src/prog8/parser/ModuleParsing.kt
+++ b/compilerAst/src/prog8/parser/ModuleParsing.kt
@@ -18,7 +18,7 @@ import java.nio.file.Paths
 
 class ParsingFailedError(override var message: String) : Exception(message)
 
-internal class CustomLexer(val modulePath: Path, input: CharStream?) : prog8Lexer(input)
+internal class CustomLexer(val modulePath: Path, input: CharStream?) : Prog8ANTLRLexer(input)
 
 fun moduleName(fileName: Path) = fileName.toString().substringBeforeLast('.')
 
@@ -60,7 +60,7 @@ class ModuleImporter(private val program: Program,
             numberOfErrors++
             when (recognizer) {
                 is CustomLexer -> System.err.println("${recognizer.modulePath}:$line:$charPositionInLine: $msg")
-                is prog8Parser -> System.err.println("${recognizer.inputStream.sourceName}:$line:$charPositionInLine: $msg")
+                is Prog8ANTLRParser -> System.err.println("${recognizer.inputStream.sourceName}:$line:$charPositionInLine: $msg")
                 else -> System.err.println("$line:$charPositionInLine $msg")
             }
             if(numberOfErrors>=5)
@@ -75,7 +75,7 @@ class ModuleImporter(private val program: Program,
         val lexerErrors = MyErrorListener()
         lexer.addErrorListener(lexerErrors)
         val tokens = CommentHandlingTokenStream(lexer)
-        val parser = prog8Parser(tokens)
+        val parser = Prog8ANTLRParser(tokens)
         parser.removeErrorListeners()
         parser.addErrorListener(MyErrorListener())
         val parseTree = parser.module()
diff --git a/compilerAst/test/TestAntlrParser.kt b/compilerAst/test/TestAntlrParser.kt
index 9a7868a3d..085917bbb 100644
--- a/compilerAst/test/TestAntlrParser.kt
+++ b/compilerAst/test/TestAntlrParser.kt
@@ -14,8 +14,8 @@ import prog8.ast.expressions.InferredTypes
 import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.statements.Block
 import prog8.parser.ParsingFailedError
-import prog8.parser.prog8Lexer
-import prog8.parser.prog8Parser
+import prog8.parser.Prog8ANTLRLexer
+import prog8.parser.Prog8ANTLRParser
 import java.nio.file.Path
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
@@ -44,21 +44,21 @@ class TestAntlrParser {
         }
     }
 
-    private fun parseModule(srcText: String): prog8Parser.ModuleContext {
+    private fun parseModule(srcText: String): Prog8ANTLRParser.ModuleContext {
         return parseModule(CharStreams.fromString(srcText))
     }
 
-    private fun parseModule(srcFile: Path): prog8Parser.ModuleContext {
+    private fun parseModule(srcFile: Path): Prog8ANTLRParser.ModuleContext {
         return parseModule(CharStreams.fromPath(srcFile))
     }
 
-    private fun parseModule(srcStream: CharStream): prog8Parser.ModuleContext {
+    private fun parseModule(srcStream: CharStream): Prog8ANTLRParser.ModuleContext {
         val errorListener = MyErrorListener()
-        val lexer = prog8Lexer(srcStream)
+        val lexer = Prog8ANTLRLexer(srcStream)
         lexer.removeErrorListeners()
         lexer.addErrorListener(errorListener)
         val tokens = CommonTokenStream(lexer)
-        val parser = prog8Parser(tokens)
+        val parser = Prog8ANTLRParser(tokens)
         parser.errorHandler = MyErrorStrategy()
         parser.removeErrorListeners()
         parser.addErrorListener(errorListener)
@@ -245,9 +245,9 @@ main {
     }
 }
 """)
-        val lexer = prog8Lexer(charstream)
+        val lexer = Prog8ANTLRLexer(charstream)
         val tokens = CommonTokenStream(lexer)
-        val parser = prog8Parser(tokens)
+        val parser = Prog8ANTLRParser(tokens)
         parser.errorHandler = BailErrorStrategy()
 //        parser.removeErrorListeners()
 //        parser.addErrorListener(MyErrorListener())
diff --git a/parser/antlr/prog8.g4 b/parser/antlr/Prog8ANTLR.g4
similarity index 98%
rename from parser/antlr/prog8.g4
rename to parser/antlr/Prog8ANTLR.g4
index e43e8f81b..2d03cad97 100644
--- a/parser/antlr/prog8.g4
+++ b/parser/antlr/Prog8ANTLR.g4
@@ -8,7 +8,9 @@ NOTES:
 
 */
 
-grammar prog8;
+// -> java classes Prog8ANTLRParser and Prog8ANTLRLexer,
+// both NOT to be used from Kotlin code, but ONLY through Kotlin class Prog8Parser
+grammar Prog8ANTLR;
 
 @header {
 package prog8.parser;