From 8c617515ba222f4490389543092b02079813a471 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Fri, 23 Jun 2023 23:36:59 +0200
Subject: [PATCH] don't prefix 3-letter symbols too aggressively (could cause
 some compilation errors)

---
 compiler/res/prog8lib/cx16/syslib.p8          |  2 +-
 .../AsmInstructionNamesReplacer.kt            |  8 +++++
 .../compiler/astprocessing/AstExtensions.kt   |  1 +
 .../test/codegeneration/TestAsmGenSymbols.kt  | 23 +++++++++++++
 docs/source/todo.rst                          |  7 ++--
 examples/test.p8                              | 32 +++++++------------
 6 files changed, 48 insertions(+), 25 deletions(-)

diff --git a/compiler/res/prog8lib/cx16/syslib.p8 b/compiler/res/prog8lib/cx16/syslib.p8
index 387b626e3..4fa2c33b9 100644
--- a/compiler/res/prog8lib/cx16/syslib.p8
+++ b/compiler/res/prog8lib/cx16/syslib.p8
@@ -403,7 +403,7 @@ romsub $ff53 = joystick_scan()  clobbers(A, X, Y)
 romsub $ff56 = joystick_get(ubyte joynr @A) -> ubyte @A, ubyte @X, ubyte @Y
 romsub $ff56 = joystick_get2(ubyte joynr @A) clobbers(Y) -> uword @AX   ; alternative to above to not have the hassle to deal with multiple return values
 
-; Audio (bank 10)
+; Audio (rom bank 10)
 romsub $C04B = psg_init() clobbers(A,X,Y)
 romsub $C063 = ym_init() clobbers(A,X,Y) -> bool @Pc                   ; (re)init YM chip
 romsub $C066 = ym_loaddefpatches() clobbers(A,X,Y) -> bool @Pc         ; load default YM patches
diff --git a/compiler/src/prog8/compiler/astprocessing/AsmInstructionNamesReplacer.kt b/compiler/src/prog8/compiler/astprocessing/AsmInstructionNamesReplacer.kt
index 87138045c..90aa68894 100644
--- a/compiler/src/prog8/compiler/astprocessing/AsmInstructionNamesReplacer.kt
+++ b/compiler/src/prog8/compiler/astprocessing/AsmInstructionNamesReplacer.kt
@@ -1,18 +1,26 @@
 package prog8.compiler.astprocessing
 
 import prog8.ast.Node
+import prog8.ast.Program
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 
 class AsmInstructionNamesReplacer(
+    val program: Program,
     val blocks: Set<Block>,
     val subroutines: Set<Subroutine>,
     val variables: Set<VarDecl>,
     val labels: Set<Label>): AstWalker() {
 
     override fun after(identifier: IdentifierReference, parent: Node): Iterable<IAstModification> {
+        if(identifier.nameInSource.size>1) {
+            val tgt = identifier.targetStatement(program)
+            if(tgt==null || tgt.definingModule.isLibrary)
+                return noModifications
+        }
+
         val newName = identifier.nameInSource.map { ident ->
             if(ident.length==3 && !identifier.definingModule.isLibrary) {
                 val blockTarget = blocks.firstOrNull { it.name==ident }
diff --git a/compiler/src/prog8/compiler/astprocessing/AstExtensions.kt b/compiler/src/prog8/compiler/astprocessing/AstExtensions.kt
index c26afced3..d655da571 100644
--- a/compiler/src/prog8/compiler/astprocessing/AstExtensions.kt
+++ b/compiler/src/prog8/compiler/astprocessing/AstExtensions.kt
@@ -33,6 +33,7 @@ internal fun Program.processAstBeforeAsmGeneration(compilerOptions: CompilationO
         finder.visit(this)
         if(finder.foundAny()) {
             val replacer = AsmInstructionNamesReplacer(
+                this,
                 finder.blocks,
                 finder.subroutines,
                 finder.variables,
diff --git a/compiler/test/codegeneration/TestAsmGenSymbols.kt b/compiler/test/codegeneration/TestAsmGenSymbols.kt
index 6a92ca16d..f79f1bd70 100644
--- a/compiler/test/codegeneration/TestAsmGenSymbols.kt
+++ b/compiler/test/codegeneration/TestAsmGenSymbols.kt
@@ -222,4 +222,27 @@ main {
         result2 shouldNotBe null
 
     }
+
+    "3 letter names not prefixed too aggressively" {
+        val text = """
+%import math
+main {
+
+    sub start() {
+        ubyte lda = getrandom()
+        lda++
+        cx16.r0 = (math.rnd() % 20) * ${'$'}0010
+        lda = math.rnd() % 5
+        lda++
+    }
+
+    sub getrandom() -> ubyte {
+        return cx16.r0L
+    }
+}"""
+        val result = compileText(C64Target(), false, text, writeAssembly = true)
+        result shouldNotBe null
+        val result2 = compileText(VMTarget(), false, text, writeAssembly = true)
+        result2 shouldNotBe null
+    }
 })
diff --git a/docs/source/todo.rst b/docs/source/todo.rst
index a1fa6e3d2..8ffdee148 100644
--- a/docs/source/todo.rst
+++ b/docs/source/todo.rst
@@ -1,6 +1,7 @@
 TODO
 ====
 
+- hiram bank 1 usage configurable or maybe even just keep whatever bank is active at program start?
 - replace all the string.compare calls in rockrunner with equalites
 
 ...
@@ -28,16 +29,16 @@ Compiler:
   global initialization values are simply a list of LOAD instructions.
   Variables replaced include all subroutine parameters!  So the only variables that remain as variables are arrays and strings.
 - ir: add more optimizations in IRPeepholeOptimizer
-- ir: the @split arrays are also split in _lsb/_msb arrays in the IR, and operations take multiple (byte) instructions that may lead to verbose and slow operation and machine code generation down the line.
+- ir: the @split arrays are currently also split in _lsb/_msb arrays in the IR, and operations take multiple (byte) instructions that may lead to verbose and slow operation and machine code generation down the line.
 - ir: for expressions with array indexes that occur multiple times, can we avoid loading them into new virtualregs everytime and just reuse a single virtualreg as indexer? (simple form of common subexpression elimination)
 - PtAst/IR: more complex common subexpression eliminations
-- generate WASM to eventually run prog8 on a browser canvas? Use binaryen toolkit or my binaryen kotlin library?
 - can we get rid of pieces of asmgen.AssignmentAsmGen by just reusing the AugmentableAssignment ? generated code should not suffer
 - [problematic due to using 64tass:] better support for building library programs, where unused .proc shouldn't be deleted from the assembly?
   Perhaps replace all uses of .proc/.pend/.endproc by .block/.bend will fix that with a compiler flag?
   But all library code written in asm uses .proc already..... (textual search/replace when writing the actual asm?)
   Once new codegen is written that is based on the IR, this point is mostly moot anyway as that will have its own dead code removal on the IR level.
 - Zig-like try-based error handling where the V flag could indicate error condition? and/or BRK to jump into monitor on failure? (has to set BRK vector for that) But the V flag is also set on certain normal instructions
+- generate WASM to eventually run prog8 on a browser canvas? Use binaryen toolkit or my binaryen kotlin library?
 
 
 Libraries:
@@ -46,7 +47,7 @@ Libraries:
 - c128 target: make syslib more complete (missing kernal routines)?
 - c64: make the graphics.BITMAP_ADDRESS configurable (VIC banking)
 - optimize several inner loops in gfx2 even further?
-- add modes 3 and perhaps even 2 to gfx2 (lores 16 color and 4 color)?
+- actually implement modes 3 and perhaps even 2 to gfx2 (lores 16 color and 4 color)
 
 
 Expressions:
diff --git a/examples/test.p8 b/examples/test.p8
index 411179e0e..c56fc11bb 100644
--- a/examples/test.p8
+++ b/examples/test.p8
@@ -1,32 +1,22 @@
+%import math
 %import textio
 %zeropage basicsafe
 
 main {
 
     sub start() {
-        str name = "name"
-        uword nameptr = &name
-
-        cx16.r0L= name=="foo"
-        cx16.r1L= name!="foo"
-        cx16.r2L= name<"foo"
-        cx16.r3L= name>"foo"
-
-        cx16.r0L= nameptr=="foo"
-        cx16.r1L= nameptr!="foo"
-        cx16.r2L= nameptr<"foo"
-        cx16.r3L= nameptr>"foo"
-
-        void compare(name, "foo")
-        void compare(name, "name")
-        void compare(nameptr, "foo")
-        void compare(nameptr, "name")
+        ubyte lda = getrandom()
+        lda++
+        cx16.r0 = (math.rnd() % 20) * $0010
+        lda = math.rnd() % 5
+        lda++
     }
 
-    sub compare(str s1, str s2) -> ubyte {
-        if s1==s2
-            return 42
-        return 0
+    sub getrandom() -> ubyte {
+        %asm {{
+            lda  #42
+            rts
+        }}
     }
 }