From ef12be062bf4b7a94a2c40f3079877da4acea7aa Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Sat, 19 Jan 2019 18:34:22 +0100
Subject: [PATCH] fixed swap()

---
 build_the_compiler.cmd                        |  12 -
 compiler/src/prog8/compiler/Compiler.kt       |  39 +-
 .../src/prog8/compiler/target/c64/AsmGen.kt   | 190 +++-
 examples/assignments.p8                       | 860 ------------------
 examples/compiled/cube3d-float.prg            | Bin 0 -> 2531 bytes
 examples/compiled/cube3d-sprites.prg          | Bin 0 -> 7071 bytes
 examples/compiled/cube3d.prg                  | Bin 0 -> 4255 bytes
 examples/compiled/hello.prg                   | Bin 0 -> 233 bytes
 examples/compiled/mandelbrot.prg              | Bin 0 -> 1328 bytes
 examples/compiled/numbergame.prg              | Bin 0 -> 1106 bytes
 examples/compiled/rasterbars.prg              | Bin 0 -> 708 bytes
 examples/compiled/readme.txt                  |   6 +
 examples/compiled/sprites.prg                 | Bin 0 -> 924 bytes
 examples/compiled/swirl-float.prg             | Bin 0 -> 673 bytes
 examples/compiled/swirl.prg                   | Bin 0 -> 876 bytes
 examples/compiled/wizzine.prg                 | Bin 0 -> 1307 bytes
 examples/numbergame-lowlevel.p8               |  78 --
 examples/test.p8                              |  47 +-
 18 files changed, 230 insertions(+), 1002 deletions(-)
 delete mode 100644 build_the_compiler.cmd
 delete mode 100644 examples/assignments.p8
 create mode 100644 examples/compiled/cube3d-float.prg
 create mode 100644 examples/compiled/cube3d-sprites.prg
 create mode 100644 examples/compiled/cube3d.prg
 create mode 100644 examples/compiled/hello.prg
 create mode 100644 examples/compiled/mandelbrot.prg
 create mode 100644 examples/compiled/numbergame.prg
 create mode 100644 examples/compiled/rasterbars.prg
 create mode 100644 examples/compiled/readme.txt
 create mode 100644 examples/compiled/sprites.prg
 create mode 100644 examples/compiled/swirl-float.prg
 create mode 100644 examples/compiled/swirl.prg
 create mode 100644 examples/compiled/wizzine.prg
 delete mode 100644 examples/numbergame-lowlevel.p8

diff --git a/build_the_compiler.cmd b/build_the_compiler.cmd
deleted file mode 100644
index e4b12bb6a..000000000
--- a/build_the_compiler.cmd
+++ /dev/null
@@ -1,12 +0,0 @@
-mkdir compiled_java
-
-java -jar ../antlr/lib/antlr-4.7.2-complete.jar -o ./prog8/parser -Xexact-output-dir -no-listener -no-visitor -package prog8.parser ../antlr/prog8.g4
-
-@dir /b /S src *.java > sources.txt
-javac  -verbose -d compiled_java -cp ../antlr/lib/antlr-runtime-4.7.2.jar @sources.txt
-@del sources.txt
-jar cf parser.jar -C compiled_java prog8
-
-set KOTLINC=%USERPROFILE%\.IdeaIC2018.3\config\plugins\kotlin\kotlinc\bin\kotlinc.bat
-
-%KOTLINC% -verbose -include-runtime -d prog8_kotlin.jar -cp ../antlr/lib/antlr-runtime-4.7.2.jar;parser.jar prog8
diff --git a/compiler/src/prog8/compiler/Compiler.kt b/compiler/src/prog8/compiler/Compiler.kt
index fe3c29376..9aec7d2e8 100644
--- a/compiler/src/prog8/compiler/Compiler.kt
+++ b/compiler/src/prog8/compiler/Compiler.kt
@@ -946,43 +946,14 @@ private class StatementTranslator(private val prog: IntermediateProgram,
             throw AstException("swap requires args of numerical type")
         // @todo implement these errors as nice AstChecker expression errors.
 
-        // eor trick:  Swap(X,Y) :=
-        //        X ^= Y
-        //        Y ^= X
-        //        X ^= Y
-        // this trick is used when we're dealing with: (u)byte or (u)word variables, ... @todo
-
-        if(useEorTrickForSwap(dt1, args[0], args[1])) {
-            val xEorY = BinaryExpression(args[0], "^", args[1], args[0].position)
-            val yEorX = BinaryExpression(args[1], "^", args[0], args[1].position)
-            val xIsXeorY = Assignment(listOf(AssignTarget.fromExpr(args[0])), null, xEorY, args[0].position)
-            val yIsYeorX = Assignment(listOf(AssignTarget.fromExpr(args[1])), null, yEorX, args[1].position)
-            xIsXeorY.linkParents(args[0].parent)
-            yIsYeorX.linkParents(args[0].parent)
-            translate(xIsXeorY)
-            translate(yIsYeorX)
-            translate(xIsXeorY)
-        } else {
-            translate(args[0])
-            translate(args[1])
-            // pop in reverse order
-            popValueIntoTarget(AssignTarget.fromExpr(args[0]), dt1)
-            popValueIntoTarget(AssignTarget.fromExpr(args[1]), dt2)
-        }
+        translate(args[0])
+        translate(args[1])
+        // pop in reverse order
+        popValueIntoTarget(AssignTarget.fromExpr(args[0]), dt1)
+        popValueIntoTarget(AssignTarget.fromExpr(args[1]), dt2)
         return
     }
 
-    private fun useEorTrickForSwap(dt: DataType, expr1: IExpression, expr2: IExpression): Boolean {
-        if(dt in IntegerDatatypes) {
-            if (expr1 is IdentifierReference && expr2 is IdentifierReference)
-                return true
-            if(expr1 is ArrayIndexedExpression && expr2 is ArrayIndexedExpression) {
-                return expr1.arrayspec.x is LiteralValue && expr2.arrayspec.x is LiteralValue
-            }
-        }
-        return false
-    }
-
     private fun translateSubroutineCall(subroutine: Subroutine, arguments: List<IExpression>, callPosition: Position) {
         // evaluate the arguments and assign them into the subroutine's argument variables.
         var restoreX = Register.X in subroutine.asmClobbers
diff --git a/compiler/src/prog8/compiler/target/c64/AsmGen.kt b/compiler/src/prog8/compiler/target/c64/AsmGen.kt
index 63219043e..514155d16 100644
--- a/compiler/src/prog8/compiler/target/c64/AsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/AsmGen.kt
@@ -195,7 +195,7 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
         vardecls2asm(block)
         out("")
 
-        val instructionPatternWindowSize = 7        // increase once patterns occur longer than this.
+        val instructionPatternWindowSize = 8        // increase once patterns occur longer than this.
         var processed = 0
 
         if(trace) println("BLOCK: ${block.scopedname}  ${block.address ?: ""}")
@@ -3312,8 +3312,196 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
                     val value = hexVal(segment[0])
                     " lda  #<$value |  sta  ${ESTACK_LO.toHex()},x |  lda  #>$value |  sta  ${ESTACK_HI.toHex()},x |  dex |  jsr  prog8_lib.mul_word"
                 }
+            },
+
+            // various variable or memory swaps
+            AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.PUSH_VAR_BYTE, Opcode.POP_VAR_BYTE, Opcode.POP_VAR_BYTE)) { segment ->
+                val var1 = segment[0].callLabel
+                val var2 = segment[1].callLabel
+                val var3 = segment[2].callLabel
+                val var4 = segment[3].callLabel
+                if(var1==var3 && var2==var4) {
+                    """
+                    lda  $var1
+                    tay
+                    lda  $var2
+                    sta  $var1
+                    sty  $var2
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_VAR_WORD, Opcode.PUSH_VAR_WORD, Opcode.POP_VAR_WORD, Opcode.POP_VAR_WORD)) { segment ->
+                val var1 = segment[0].callLabel
+                val var2 = segment[1].callLabel
+                val var3 = segment[2].callLabel
+                val var4 = segment[3].callLabel
+                if(var1==var3 && var2==var4) {
+                    """
+                    lda  $var1
+                    tay
+                    lda  $var2
+                    sta  $var1
+                    sty  $var2
+                    lda  $var1+1
+                    tay
+                    lda  $var2+1
+                    sta  $var1+1
+                    sty  $var2+1
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_MEM_B, Opcode.PUSH_MEM_B, Opcode.POP_MEM_BYTE, Opcode.POP_MEM_BYTE),
+                    listOf(Opcode.PUSH_MEM_UB, Opcode.PUSH_MEM_UB, Opcode.POP_MEM_BYTE, Opcode.POP_MEM_BYTE)) { segment ->
+                val addr1 = segment[0].arg!!.integerValue()
+                val addr2 = segment[1].arg!!.integerValue()
+                val addr3 = segment[2].arg!!.integerValue()
+                val addr4 = segment[3].arg!!.integerValue()
+                if(addr1==addr3 && addr2==addr4) {
+                    """
+                    lda  ${addr1.toHex()}
+                    tay
+                    lda  ${addr2.toHex()}
+                    sta  ${addr1.toHex()}
+                    sty  ${addr2.toHex()}
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_MEM_W, Opcode.PUSH_MEM_W, Opcode.POP_MEM_WORD, Opcode.POP_MEM_WORD),
+                    listOf(Opcode.PUSH_MEM_UW, Opcode.PUSH_MEM_UW, Opcode.POP_MEM_WORD, Opcode.POP_MEM_WORD)) { segment ->
+                val addr1 = segment[0].arg!!.integerValue()
+                val addr2 = segment[1].arg!!.integerValue()
+                val addr3 = segment[2].arg!!.integerValue()
+                val addr4 = segment[3].arg!!.integerValue()
+                if(addr1==addr3 && addr2==addr4) {
+                    """
+                    lda  ${addr1.toHex()}
+                    tay
+                    lda  ${addr2.toHex()}
+                    sta  ${addr1.toHex()}
+                    sty  ${addr2.toHex()}
+                    lda  ${(addr1+1).toHex()}
+                    tay
+                    lda  ${(addr2+1).toHex()}
+                    sta  ${(addr1+1).toHex()}
+                    sty  ${(addr2+1).toHex()}
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE,
+                    Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE, Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE)) { segment ->
+                val i1 = segment[0].arg!!.integerValue()
+                val i2 = segment[2].arg!!.integerValue()
+                val i3 = segment[4].arg!!.integerValue()
+                val i4 = segment[6].arg!!.integerValue()
+                val array1 = segment[1].callLabel
+                val array2 = segment[3].callLabel
+                val array3 = segment[5].callLabel
+                val array4 = segment[7].callLabel
+                if(i1==i3 && i2==i4 && array1==array3 && array2==array4) {
+                    """
+                    lda  $array1+$i1
+                    tay
+                    lda  $array2+$i2
+                    sta  $array1+$i1
+                    sty  $array2+$i2
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_BYTE,
+                    Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE)) { segment ->
+                val vi1 = segment[0].callLabel
+                val vi2 = segment[2].callLabel
+                val vi3 = segment[4].callLabel
+                val vi4 = segment[6].callLabel
+                val array1 = segment[1].callLabel
+                val array2 = segment[3].callLabel
+                val array3 = segment[5].callLabel
+                val array4 = segment[7].callLabel
+                if(vi1==vi3 && vi2==vi4 && array1==array3 && array2==array4) {
+                    val load1 = loadAFromIndexedByVar(segment[0], segment[1])
+                    val load2 = loadAFromIndexedByVar(segment[2], segment[3])
+                    val storeIn1 = storeAToIndexedByVar(segment[0], segment[1])
+                    val storeIn2 = storeAToIndexedByVar(segment[2], segment[3])
+                    """
+                    $load1
+                    pha
+                    $load2
+                    $storeIn1
+                    pla
+                    $storeIn2
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD,
+                    Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_WORD, Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
+                val i1 = segment[0].arg!!.integerValue()*2
+                val i2 = segment[2].arg!!.integerValue()*2
+                val i3 = segment[4].arg!!.integerValue()*2
+                val i4 = segment[6].arg!!.integerValue()*2
+                val array1 = segment[1].callLabel
+                val array2 = segment[3].callLabel
+                val array3 = segment[5].callLabel
+                val array4 = segment[7].callLabel
+                if(i1==i3 && i2==i4 && array1==array3 && array2==array4) {
+                    """
+                    lda  $array1+$i1
+                    tay
+                    lda  $array2+$i2
+                    sta  $array1+$i1
+                    sty  $array2+$i2
+                    lda  $array1+${i1+1}
+                    tay
+                    lda  $array2+${i2+1}
+                    sta  $array1+${i1+1}
+                    sty  $array2+${i2+1}
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_WORD,
+                    Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
+                val vi1 = segment[0].callLabel
+                val vi2 = segment[2].callLabel
+                val vi3 = segment[4].callLabel
+                val vi4 = segment[6].callLabel
+                val array1 = segment[1].callLabel
+                val array2 = segment[3].callLabel
+                val array3 = segment[5].callLabel
+                val array4 = segment[7].callLabel
+                if(vi1==vi3 && vi2==vi4 && array1==array3 && array2==array4) {
+                    //  SCRATCH_B1 = index1
+                    //  SCRATCH_REG = index2
+                    //  SCRATCH_W1 = temp storage of array[index2]
+                    """
+                    lda  ${segment[0].callLabel}
+                    asl  a
+                    sta  ${C64Zeropage.SCRATCH_B1}
+                    lda  ${segment[2].callLabel}
+                    asl  a
+                    sta  ${C64Zeropage.SCRATCH_REG}
+                    stx  ${C64Zeropage.SCRATCH_REG_X}
+                    tax
+                    lda  ${segment[3].callLabel},x
+                    ldy  ${segment[3].callLabel}+1,x
+                    sta  ${C64Zeropage.SCRATCH_W1}
+                    sty  ${C64Zeropage.SCRATCH_W1}+1
+                    ldx  ${C64Zeropage.SCRATCH_B1}
+                    lda  ${segment[1].callLabel},x
+                    ldy  ${segment[1].callLabel}+1,x
+                    ldx  ${C64Zeropage.SCRATCH_REG}
+                    sta  ${segment[3].callLabel},x
+                    tya
+                    sta  ${segment[3].callLabel}+1,x
+                    ldx  ${C64Zeropage.SCRATCH_B1}
+                    lda  ${C64Zeropage.SCRATCH_W1}
+                    sta  ${segment[1].callLabel},x
+                    lda  ${C64Zeropage.SCRATCH_W1}+1
+                    sta  ${segment[1].callLabel}+1,x
+                    ldx  ${C64Zeropage.SCRATCH_REG_X}
+                    """
+                } else null
             }
 
+
     )
 
 }
diff --git a/examples/assignments.p8 b/examples/assignments.p8
deleted file mode 100644
index 91adfbe2f..000000000
--- a/examples/assignments.p8
+++ /dev/null
@@ -1,860 +0,0 @@
-%import c64utils
-%import c64flt
-%output raw
-%launcher none
-%address $4000
-
-~ main {
-
-sub start() {
-
-    byte b = 99
-    byte b2 = 100
-    ubyte ub = 255
-    ubyte ub2 = 0
-    word w = 999
-    word w2 = 3
-    uword uw = 40000
-    uword uw2 = 3434
-    float fl1 = 1.1
-    float fl2 = 2.2
-
-    byte[5] barr1
-    byte[5] barr2
-    ubyte[5] ubarr1
-    ubyte[5] ubarr2
-    word[5] warr1
-    word[5] warr2
-    uword[5] uwarr1
-    uword[5] uwarr2
-    float[5] farr1
-    float[5] farr2
-
-    memory byte mbyte = $c000
-    memory byte mbyte2 = $d000
-    memory ubyte mubyte = $c001
-    memory ubyte mubyte2 = $d001
-    memory word mword = $c002
-    memory word mword2 = $d002
-    memory uword muword = $c004
-    memory uword muword2 = $d004
-    memory float mfloat = $c006
-    memory float mfloat2 = $d006
-    memory byte[mubyte2] mbarr1 = $e000
-    memory ubyte[mubyte2] mubarr1 = $e100
-    memory word[mubyte2] mwarr1 = $e100
-    memory uword[mubyte2] muwarr1 = $e100
-
-    str  string = "hello"
-    str_p stringp = "hello"
-
-
-; some string assignments
-
-        str   stringvar   = "??????????\n\n\nnext line\r\r\rnext line after carriagereturn"
-        ubyte  secretnumber = 0
-        memory uword freadstr_arg = $22		; argument for FREADSTR
-        uword testword
-        ubyte char1 = '@'
-        ubyte char2 = '\n'
-        ubyte char3 = '\r'
-        ubyte char1b = '@'
-        ubyte char2b = '\n'
-        ubyte char3b = '\r'
-
-        testword = '@'
-        testword = '\n'
-        freadstr_arg = '@'
-        freadstr_arg = '\n'
-        secretnumber = '@'
-        secretnumber = '\r'
-
-        testword  = stringvar
-        testword = "stringstring"
-        freadstr_arg = stringvar
-        freadstr_arg = "stringstring"
-
-
-; all possible assignments to a BYTE VARIABLE (not array)
-
-
-ubyte_assignment_to_register:
-    A = 42
-    A = X
-    A = ub2
-    A = mubyte2
-    A = string[4]
-    A = string[X]
-    A = string[b]
-    A = string[ub]
-    A = string[mbyte2]
-    A = string[mubyte2]
-    A = ubarr1[2]
-    A = ubarr1[X]
-    A = ubarr1[b]
-    A = ubarr1[ub]
-    A = ubarr1[mbyte2]
-    A = ubarr1[mubyte2]
-
-ubyte_assignment_to_ubytevar:
-    ub = 42
-    ub = X
-    ub = ub2
-    ub = mubyte2
-    ub = string[4]
-    ub = string[X]
-    ub = string[b]
-    ub = string[ub]
-    ub = string[mbyte2]
-    ub = string[mubyte2]
-    ub = ubarr1[2]
-    ub = ubarr1[X]
-    ub = ubarr1[b]
-    ub = ubarr1[ub]
-    ub = ubarr1[mbyte2]
-    ub = ubarr1[mubyte2]
-
-
-ubyte_assignment_to_ubytemem:
-    mubyte = 42
-    mubyte = X
-    mubyte = ub2
-    mubyte = mubyte2
-    mubyte = string[4]
-    mubyte = string[X]
-    mubyte = string[b]
-    mubyte = string[ub]
-    mubyte = string[mbyte2]
-    mubyte = string[mubyte2]
-    mubyte = ubarr1[2]
-    mubyte = ubarr1[X]
-    mubyte = ubarr1[b]
-    mubyte = ubarr1[ub]
-    mubyte = ubarr1[mbyte2]
-    mubyte = ubarr1[mubyte2]
-
-byte_assignment_to_bytevar:
-    b = -42
-    b = b2
-    b = mbyte2
-    b = barr1[2]
-    b = barr1[X]
-    b = barr1[b]
-    b = barr1[ub]
-    b = barr1[mbyte2]
-    b = barr1[mubyte2]
-
-
-byte_assignment_to_bytemem:
-    mbyte = -42
-    mbyte = b2
-    mbyte = mbyte2
-    mbyte = barr1[2]
-    mbyte = barr1[X]
-    mbyte = barr1[b]
-    mbyte = barr1[ub]
-    mbyte = barr1[mbyte2]
-    mbyte = barr1[mubyte2]
-
-
-ubyte_assignment_to_ubytearray:
-    ubarr2[3] = 42
-    ubarr2[3] = X
-    ubarr2[3] = ub2
-    ubarr2[3] = mubyte2
-    ubarr2[3] = string[4]
-    ubarr2[3] = string[X]
-    ubarr2[3] = string[b]
-    ubarr2[3] = string[ub]
-    ubarr2[3] = string[mbyte2]
-    ubarr2[3] = string[mubyte2]
-    ubarr2[3] = ubarr1[2]
-    ubarr2[3] = ubarr1[X]
-    ubarr2[3] = ubarr1[b]
-    ubarr2[3] = ubarr1[ub]
-    ubarr2[3] = ubarr1[mbyte2]
-    ubarr2[3] = ubarr1[mubyte2]
-    string[4] = 42
-    string[4] = 'B'
-    string[4] = X
-    string[4] = ub2
-    string[4] = mubyte2
-    string[4] = ubarr1[2]
-    string[4] = ubarr1[X]
-    string[4] = ubarr1[ub]
-    string[4] = ubarr1[mubyte2]
-    string[4] = string[3]
-    string[4] = string[Y]
-    string[4] = string[ub2]
-    string[4] = string[mbyte2]
-    string[4] = string[mubyte2]
-
-
-    ubarr2[Y] = 42
-    ubarr2[Y] = X
-    ubarr2[Y] = ub2
-    ubarr2[Y] = mubyte2
-    ubarr2[Y] = string[4]
-    ubarr2[Y] = string[X]
-    ubarr2[Y] = string[b]
-    ubarr2[Y] = string[ub]
-    ubarr2[Y] = string[mbyte2]
-    ubarr2[Y] = string[mubyte2]
-    ubarr2[Y] = ubarr1[2]
-    ubarr2[Y] = ubarr1[X]
-    ubarr2[Y] = ubarr1[b]
-    ubarr2[Y] = ubarr1[ub]
-    ubarr2[Y] = ubarr1[mbyte2]
-    ubarr2[Y] = ubarr1[mubyte2]
-    string[Y] = 42
-    string[Y] = 'B'
-    string[Y] = X
-    string[Y] = ub2
-    string[Y] = mubyte2
-    string[Y] = ubarr1[2]
-    string[Y] = ubarr1[Y]
-    string[Y] = ubarr1[ub2]
-    string[Y] = ubarr1[mubyte2]
-    string[Y] = string[Y]
-    string[Y] = string[ub2]
-    string[Y] = string[mbyte2]
-    string[Y] = string[mubyte2]
-
-
-        ubarr2[ub2] = 42
-        ubarr2[ub2] = X
-        ubarr2[ub2] = ub2
-        ubarr2[ub2] = mubyte2
-        ubarr2[ub2] = string[4]
-        ubarr2[ub2] = string[X]
-        ubarr2[ub2] = string[b]
-        ubarr2[ub2] = string[ub]
-        ubarr2[ub2] = string[mbyte2]
-        ubarr2[ub2] = string[mubyte2]
-        ubarr2[ub2] = ubarr1[2]
-        ubarr2[ub2] = ubarr1[X]
-        ubarr2[ub2] = ubarr1[b]
-        ubarr2[ub2] = ubarr1[ub]
-        ubarr2[ub2] = ubarr1[mbyte2]
-        ubarr2[ub2] = ubarr1[mubyte2]
-        string[ub2] = 42
-        string[ub2] = 'B'
-        string[ub2] = X
-        string[ub2] = ub2
-        string[ub2] = mubyte2
-        string[ub2] = ubarr1[2]
-        string[ub2] = ubarr1[Y]
-        string[ub2] = ubarr1[ub2]
-        string[ub2] = ubarr1[mubyte2]
-        string[ub2] = string[Y]
-        string[ub2] = string[ub2]
-        string[ub2] = string[mbyte2]
-        string[ub2] = string[mubyte2]
-
-
-        ubarr2[b2] = 42
-        ubarr2[b2] = X
-        ubarr2[b2] = ub2
-        ubarr2[b2] = mubyte2
-        ubarr2[b2] = string[4]
-        ubarr2[b2] = string[X]
-        ubarr2[b2] = string[b]
-        ubarr2[b2] = string[ub]
-        ubarr2[b2] = string[mbyte2]
-        ubarr2[b2] = string[mubyte2]
-        ubarr2[b2] = ubarr1[2]
-        ubarr2[b2] = ubarr1[X]
-        ubarr2[b2] = ubarr1[b]
-        ubarr2[b2] = ubarr1[ub]
-        ubarr2[b2] = ubarr1[mbyte2]
-        ubarr2[b2] = ubarr1[mubyte2]
-        string[b2] = 42
-        string[b2] = 'B'
-        string[b2] = X
-        string[b2] = ub2
-        string[b2] = mubyte2
-        string[b2] = ubarr1[2]
-        string[b2] = ubarr1[Y]
-        string[b2] = ubarr1[ub2]
-        string[b2] = ubarr1[mubyte2]
-        string[b2] = string[Y]
-        string[b2] = string[ub2]
-        string[b2] = string[mbyte2]
-        string[b2] = string[mubyte2]
-
-    ubarr2[mubyte2] = 42
-    ubarr2[mubyte2] = X
-    ubarr2[mubyte2] = ub2
-    ubarr2[mubyte2] = mubyte2
-    ubarr2[mubyte2] = string[4]
-    ubarr2[mubyte2] = ubarr1[2]
-    string[mubyte2] = 42
-    string[mubyte2] = 'B'
-    string[mubyte2] = X
-    string[mubyte2] = ub2
-    string[mubyte2] = mubyte2
-    string[mubyte2] = ubarr1[2]
-
-    ubarr2[mubyte2] = string[Y]             ; via evaluation
-    ubarr2[mubyte2] = string[b]             ; via evaluation
-    ubarr2[mubyte2] = string[ub]            ; via evaluation
-    ubarr2[mubyte2] = string[mbyte2]        ; via evaluation
-    ubarr2[mubyte2] = string[mubyte2]       ; via evaluation
-    ubarr2[mubyte2] = ubarr1[Y]             ; via evaluation
-    ubarr2[mubyte2] = ubarr1[b]             ; via evaluation
-    ubarr2[mubyte2] = ubarr1[ub]            ; via evaluation
-    ubarr2[mubyte2] = ubarr1[mbyte2]        ; via evaluation
-    ubarr2[mubyte2] = ubarr1[mubyte2]       ; via evaluation
-    string[mubyte2] = ubarr1[Y]             ; via evaluation
-    string[mubyte2] = ubarr1[b]             ; via evaluation
-    string[mubyte2] = ubarr1[ub2]           ; via evaluation
-    string[mubyte2] = ubarr1[mbyte2]        ; via evaluation
-    string[mubyte2] = ubarr1[mubyte2]       ; via evaluation
-    string[mubyte2] = string[mubyte2]       ; via evaluation
-    ubarr1[ubarr2[A]] = ubarr2[ubarr1[Y]]   ; via evaluation
-
-
-
-byte_assignment_to_bytearray:
-
-    barr2[3] = 42
-    barr2[3] = b2
-    barr2[3] = mbyte2
-    barr2[3] = barr1[2]
-    barr2[3] = barr1[X]
-    barr2[3] = barr1[b]
-    barr2[3] = barr1[ub]
-    barr2[3] = barr1[mbyte2]
-    barr2[3] = barr1[mubyte2]
-
-    barr2[Y] = 42
-    barr2[Y] = b2
-    barr2[Y] = mbyte2
-    barr2[Y] = barr1[2]
-    barr2[Y] = barr1[X]
-    barr2[Y] = barr1[b]
-    barr2[Y] = barr1[ub]
-    barr2[Y] = barr1[mbyte2]
-    barr2[Y] = barr1[mubyte2]
-
-        barr2[b2] = 42
-        barr2[b2] = b2
-        barr2[b2] = mbyte2
-        barr2[b2] = barr1[2]
-        barr2[b2] = barr1[X]
-        barr2[b2] = barr1[b]
-        barr2[b2] = barr1[ub]
-        barr2[b2] = barr1[mbyte2]
-        barr2[b2] = barr1[mubyte2]
-
-        barr2[ub2] = 42
-        barr2[ub2] = b2
-        barr2[ub2] = mbyte2
-        barr2[ub2] = barr1[2]
-        barr2[ub2] = barr1[X]
-        barr2[ub2] = barr1[b]
-        barr2[ub2] = barr1[ub]
-        barr2[ub2] = barr1[mbyte2]
-        barr2[ub2] = barr1[mubyte2]
-
-    barr2[mubyte2] = 42
-    barr2[mubyte2] = b2
-    barr2[mubyte2] = mbyte2
-    barr2[mubyte2] = barr1[2]
-    barr2[mubyte2] = barr1[Y]         ; via evaluation
-    barr2[mubyte2] = barr1[b]         ; via evaluation
-    barr2[mubyte2] = barr1[ub]        ; via evaluation
-    barr2[mubyte2] = barr1[mbyte2]    ; via evaluation
-    barr2[mubyte2] = barr1[mubyte2]   ; via evaluation
-    barr1[ubarr2[A]] = barr2[ubarr1[Y]]   ; via evaluation
-
-
-byte_assignment_to_membytearray:
-
-    mbarr1[3] = 42
-    mbarr1[3] = b2
-    mbarr1[3] = mbyte2
-    mbarr1[3] = barr1[2]
-    mbarr1[3] = barr1[X]
-    mbarr1[3] = barr1[b]
-    mbarr1[3] = barr1[ub]
-    mbarr1[3] = barr1[mbyte2]
-    mbarr1[3] = barr1[mubyte2]
-
-    mbarr1[Y] = 42
-    mbarr1[Y] = b2
-    mbarr1[Y] = mbyte2
-    mbarr1[Y] = barr1[2]
-    mbarr1[Y] = barr1[X]
-    mbarr1[Y] = barr1[b]
-    mbarr1[Y] = barr1[ub]
-    mbarr1[Y] = barr1[mbyte2]
-    mbarr1[Y] = barr1[mubyte2]
-
-        mbarr1[b2] = 42
-        mbarr1[b2] = b2
-        mbarr1[b2] = mbyte2
-        mbarr1[b2] = barr1[2]
-        mbarr1[b2] = barr1[X]
-        mbarr1[b2] = barr1[b]
-        mbarr1[b2] = barr1[ub]
-        mbarr1[b2] = barr1[mbyte2]
-        mbarr1[b2] = barr1[mubyte2]
-
-        mbarr1[ub2] = 42
-        mbarr1[ub2] = b2
-        mbarr1[ub2] = mbyte2
-        mbarr1[ub2] = barr1[2]
-        mbarr1[ub2] = barr1[X]
-        mbarr1[ub2] = barr1[b]
-        mbarr1[ub2] = barr1[ub]
-        mbarr1[ub2] = barr1[mbyte2]
-        mbarr1[ub2] = barr1[mubyte2]
-
-    mbarr1[mubyte2] = 42
-    mbarr1[mubyte2] = b2
-    mbarr1[mubyte2] = mbyte2
-    mbarr1[mubyte2] = barr1[2]
-    mbarr1[mubyte2] = barr1[Y]         ; via evaluation
-    mbarr1[mubyte2] = barr1[b]         ; via evaluation
-    mbarr1[mubyte2] = barr1[ub]        ; via evaluation
-    mbarr1[mubyte2] = barr1[mbyte2]    ; via evaluation
-    mbarr1[mubyte2] = barr1[mubyte2]   ; via evaluation
-    mbarr1[ubarr2[A]] = barr2[ubarr1[Y]]   ; via evaluation
-
-
-
-; all possible assignments to a UWORD VARIABLE (not array)
-
-
-uword_assignment_to_uwordvar:
-    uw = 42
-    uw = 42.w
-    uw = 42555
-    uw = X
-    uw = ub2
-    uw = uw2
-    uw = mubyte2
-    uw = muword2
-    uw = string[4]
-    uw = ubarr1[2]
-    uw = uwarr1[2]
-    uw = string[X]
-    uw = string[b]
-    uw = string[ub]
-    uw = string[mbyte2]
-    uw = string[mubyte2]
-    uw = ubarr1[X]
-    uw = ubarr1[b]
-    uw = ubarr1[ub]
-    uw = ubarr1[mbyte2]
-    uw = ubarr1[mubyte2]
-    uw = uwarr1[X]
-    uw = uwarr1[b]
-    uw = uwarr1[ub]
-    uw = uwarr1[mbyte2]
-    uw = uwarr1[mubyte2]
-
-
-uword_assignment_to_uwordmem:
-    muword = 42
-    muword = 42.w
-    muword = 42555
-    muword = X
-    muword = ub2
-    muword = uw2
-    muword = mubyte2
-    muword = muword2
-    muword = string[4]
-    muword = ubarr1[2]
-    muword = uwarr1[2]
-    muword = string[X]
-    muword = string[b]
-    muword = string[ub]
-    muword = string[mbyte2]
-    muword = string[mubyte2]
-    muword = ubarr1[X]
-    muword = ubarr1[b]
-    muword = ubarr1[ub]
-    muword = ubarr1[mbyte2]
-    muword = ubarr1[mubyte2]
-    muword = uwarr1[X]
-    muword = uwarr1[b]
-    muword = uwarr1[ub]
-    muword = uwarr1[mbyte2]
-    muword = uwarr1[mubyte2]
-
-
-uword_assignment_to_uwordarray:
-    uwarr1[2] = 42
-    uwarr1[2] = 42.w
-    uwarr1[2] = 42555
-    uwarr1[2] = X
-    uwarr1[2] = ub2
-    uwarr1[2] = uw2
-    uwarr1[2] = mubyte2
-    uwarr1[2] = muword2
-    uwarr1[2] = string[4]
-    uwarr1[2] = ubarr1[2]
-    uwarr1[2] = uwarr1[2]
-
-        uwarr1[Y] = 42
-        uwarr1[Y] = 42.w
-        uwarr1[Y] = 42555
-        uwarr1[Y] = X
-        uwarr1[Y] = ub2
-        uwarr1[Y] = uw2
-        uwarr1[Y] = mubyte2
-        uwarr1[Y] = muword2
-        uwarr1[Y] = string[4]
-        uwarr1[Y] = ubarr1[2]
-        uwarr1[Y] = uwarr1[2]
-
-    uwarr1[b] = 42
-    uwarr1[b] = 42.w
-    uwarr1[b] = 42555
-    uwarr1[b] = X
-    uwarr1[b] = ub2
-    uwarr1[b] = uw2
-    uwarr1[b] = mubyte2
-    uwarr1[b] = muword2
-    uwarr1[b] = string[4]
-    uwarr1[b] = ubarr1[2]
-    uwarr1[b] = uwarr1[2]
-
-    uwarr1[ub] = 42
-    uwarr1[ub] = 42.w
-    uwarr1[ub] = 42555
-    uwarr1[ub] = X
-    uwarr1[ub] = ub2
-    uwarr1[ub] = uw2
-    uwarr1[ub] = mubyte2
-    uwarr1[ub] = muword2
-    uwarr1[ub] = string[4]
-    uwarr1[ub] = ubarr1[2]
-    uwarr1[ub] = uwarr1[2]
-
-        uwarr1[mbyte2] = 42
-        uwarr1[mbyte2] = 42.w
-        uwarr1[mbyte2] = 42555
-        uwarr1[mbyte2] = X
-        uwarr1[mbyte2] = ub2
-        uwarr1[mbyte2] = uw2
-        uwarr1[mbyte2] = mubyte2
-        uwarr1[mbyte2] = muword2
-        uwarr1[mbyte2] = string[4]
-        uwarr1[mbyte2] = ubarr1[2]
-        uwarr1[mbyte2] = uwarr1[2]
-
-        uwarr1[mubyte2] = 42
-        uwarr1[mubyte2] = 42.w
-        uwarr1[mubyte2] = 42555
-        uwarr1[mubyte2] = X
-        uwarr1[mubyte2] = ub2
-        uwarr1[mubyte2] = uw2
-        uwarr1[mubyte2] = mubyte2
-        uwarr1[mubyte2] = muword2
-        uwarr1[mubyte2] = string[4]
-        uwarr1[mubyte2] = ubarr1[2]
-        uwarr1[mubyte2] = uwarr1[2]
-
-
-   uwarr1[2] = string[Y]         ; via evaluation
-   uwarr1[2] = string[b]         ; via evaluation
-   uwarr1[2] = string[ub]        ; via evaluation
-   uwarr1[2] = string[mbyte2]    ; via evaluation
-   uwarr1[2] = string[mubyte2]   ; via evaluation
-   uwarr1[2] = ubarr1[Y]         ; via evaluation
-   uwarr1[2] = ubarr1[b]         ; via evaluation
-   uwarr1[2] = ubarr1[ub]        ; via evaluation
-   uwarr1[2] = ubarr1[mbyte2]    ; via evaluation
-   uwarr1[2] = ubarr1[mubyte2]   ; via evaluation
-   uwarr1[2] = uwarr1[Y]         ; via evaluation
-   uwarr1[2] = uwarr1[b]         ; via evaluation
-   uwarr1[2] = uwarr1[ub]        ; via evaluation
-   uwarr1[2] = uwarr1[mbyte2]    ; via evaluation
-   uwarr1[2] = uwarr1[mubyte2]   ; via evaluation
-
-
-word_assignment_to_wordvar:
-    w = -42
-    w = -42.w
-    w = 12555
-    w = X
-    w = ub2
-    w = b2
-    w = w2
-    w = mubyte2
-    w = mbyte2
-    w = mword2
-    w = string[4]
-    w = ubarr1[2]
-    w = barr1[2]
-    w = warr1[2]
-
-    w = string[X]
-    w = string[b]
-    w = string[ub]
-    w = string[mbyte2]
-    w = string[mubyte2]
-
-
-    w = barr1[X]
-    w = ubarr1[X]
-    w = barr1[b]
-    w = ubarr1[b]
-    w = barr1[ub]
-    w = ubarr1[ub]
-    w = barr1[mbyte2]
-    w = ubarr1[mbyte2]
-    w = barr1[mubyte2]
-    w = ubarr1[mubyte2]
-    w = warr1[X]
-    w = warr1[b]
-    w = warr1[ub]
-    w = warr1[mbyte2]
-    w = warr1[mubyte2]
-
-
-word_assignment_to_wordmem:
-    mword = -42
-    mword = -42.w
-    mword = 12555
-    mword = X
-    mword = ub2
-    mword = b2
-    mword = w2
-    mword = mubyte2
-    mword = mbyte2
-    mword = mword2
-    mword = string[4]
-    mword = ubarr1[2]
-    mword = barr1[2]
-    mword = warr1[2]
-
-
-    mword = string[X]
-    mword = string[b]
-    mword = string[ub]
-    mword = string[mbyte2]
-    mword = string[mubyte2]
-    mword = barr1[X]
-    mword = ubarr1[X]
-    mword = barr1[b]
-    mword = ubarr1[b]
-    mword = barr1[ub]
-    mword = ubarr1[ub]
-    mword = barr1[mbyte2]
-    mword = ubarr1[mbyte2]
-    mword = barr1[mubyte2]
-    mword = ubarr1[mubyte2]
-    mword = warr1[X]
-    mword = warr1[b]
-    mword = warr1[ub]
-    mword = warr1[mbyte2]
-    mword = warr1[mubyte2]
-
-
-word_assignment_to_wordarray:
-    warr2[2] = -42
-    warr2[2] = -42.w
-    warr2[2] = 12555
-    warr2[2] = X
-    warr2[2] = ub2
-    warr2[2] = b2
-    warr2[2] = w2
-    warr2[2] = mubyte2
-    warr2[2] = mbyte2
-    warr2[2] = mword2
-    warr2[2] = string[4]
-    warr2[2] = ubarr1[2]
-    warr2[2] = barr1[2]
-    warr2[2] = warr1[2]
-
-    warr2[Y] = -42
-    warr2[Y] = -42.w
-    warr2[Y] = 12555
-    warr2[Y] = X
-    warr2[Y] = ub2
-    warr2[Y] = b2
-    warr2[Y] = w2
-    warr2[Y] = mubyte2
-    warr2[Y] = mbyte2
-    warr2[Y] = mword2
-    warr2[Y] = string[4]
-    warr2[Y] = ubarr1[2]
-    warr2[Y] = barr1[2]
-    warr2[Y] = warr1[2]
-
-    warr2[b] = -42
-    warr2[b] = -42.w
-    warr2[b] = 12555
-    warr2[b] = X
-    warr2[b] = ub2
-    warr2[b] = b2
-    warr2[b] = w2
-    warr2[b] = mubyte2
-    warr2[b] = mbyte2
-    warr2[b] = mword2
-    warr2[b] = string[4]
-    warr2[b] = ubarr1[2]
-    warr2[b] = barr1[2]
-    warr2[b] = warr1[2]
-
-    warr2[ub] = -42
-    warr2[ub] = -42.w
-    warr2[ub] = 14255
-    warr2[ub] = X
-    warr2[ub] = ub2
-    warr2[ub] = b2
-    warr2[ub] = w2
-    warr2[ub] = mubyte2
-    warr2[ub] = mbyte2
-    warr2[ub] = mword2
-    warr2[ub] = string[4]
-    warr2[ub] = ubarr1[2]
-    warr2[ub] = barr1[2]
-    warr2[ub] = warr1[2]
-
-    warr2[mbyte2] = -42
-    warr2[mbyte2] = -42.w
-    warr2[mbyte2] = 12555
-    warr2[mbyte2] = X
-    warr2[mbyte2] = ub2
-    warr2[mbyte2] = b2
-    warr2[mbyte2] = w2
-    warr2[mbyte2] = mubyte2
-    warr2[mbyte2] = mbyte2
-    warr2[mbyte2] = mword2
-    warr2[mbyte2] = string[4]
-    warr2[mbyte2] = ubarr1[2]
-    warr2[mbyte2] = barr1[2]
-    warr2[mbyte2] = warr1[2]
-
-    warr2[mubyte2] = -42
-    warr2[mubyte2] = -42.w
-    warr2[mubyte2] = 12555
-    warr2[mubyte2] = X
-    warr2[mubyte2] = ub2
-    warr2[mubyte2] = b2
-    warr2[mubyte2] = w2
-    warr2[mubyte2] = mubyte2
-    warr2[mubyte2] = mbyte2
-    warr2[mubyte2] = mword2
-    warr2[mubyte2] = string[4]
-    warr2[mubyte2] = ubarr1[2]
-    warr2[mubyte2] = barr1[2]
-    warr2[mubyte2] = warr1[2]
-
-
-   warr1[2] = string[Y]          ; via evaluation
-   warr1[2] = string[b]          ; via evaluation
-   warr1[2] = string[ub]         ; via evaluation
-   warr1[2] = string[mbyte2]     ; via evaluation
-   warr1[2] = string[mubyte2]    ; via evaluation
-   warr1[2] = barr1[Y]           ; via evaluation
-   warr1[2] = barr1[b]           ; via evaluation
-   warr1[2] = barr1[ub]          ; via evaluation
-   warr1[2] = barr1[mbyte2]      ; via evaluation
-   warr1[2] = barr1[mubyte2]     ; via evaluation
-   warr1[2] = warr1[Y]           ; via evaluation
-   warr1[2] = warr1[b]           ; via evaluation
-   warr1[2] = warr1[ub]          ; via evaluation
-   warr1[2] = warr1[mbyte2]      ; via evaluation
-   warr1[2] = warr1[mubyte2]     ; via evaluation
-
-
-;; all possible assignments to a FLOAT VARIABLE
-float_assignment_to_floatvar:
-    fl1 = 34
-    fl1 = 34555.w
-    fl1 = 3.33e22
-    fl1 = X
-    fl1 = b2
-    fl1 = ub2
-    fl1 = w2
-    fl1 = uw2
-    fl1 = mbyte
-    fl1 = mubyte
-    fl1 = mword
-    fl1 = muword
-    fl1 = fl2
-    fl1 = mfloat2
-    fl1 = barr1[2]
-    fl1 = ubarr1[2]
-    fl1 = warr1[2]
-    fl1 = uwarr1[2]
-    fl1 = string[4]
-    fl1 = farr1[4]
-
-    fl1 = string[Y]            ; via evaluation
-    fl1 = string[b]            ; via evaluation
-    fl1 = string[ub]           ; via evaluation
-    fl1 = string[mbyte2]       ; via evaluation
-    fl1 = string[mubyte2]      ; via evaluation
-    fl1 = barr1[Y]             ; via evaluation
-    fl1 = ubarr1[Y]            ; via evaluation
-    fl1 = barr1[b]             ; via evaluation
-    fl1 = ubarr1[b]            ; via evaluation
-    fl1 = barr1[ub]            ; via evaluation
-    fl1 = ubarr1[ub]           ; via evaluation
-    fl1 = barr1[mbyte2]        ; via evaluation
-    fl1 = ubarr1[mbyte2]       ; via evaluation
-    fl1 = barr1[mubyte2]       ; via evaluation
-    fl1 = ubarr1[mubyte2]      ; via evaluation
-    fl1 = warr1[Y]             ; via evaluation
-    fl1 = warr1[b]             ; via evaluation
-    fl1 = warr1[ub]            ; via evaluation
-    fl1 = warr1[mbyte2]        ; via evaluation
-    fl1 = warr1[mubyte2]       ; via evaluation
-
-
-float_assignment_to_floatmem:
-    mfloat = 34
-    mfloat = 34555.w
-    mfloat = 3.33e22
-    mfloat = X
-    mfloat = b2
-    mfloat = ub2
-    mfloat = w2
-    mfloat = uw2
-    mfloat = mbyte
-    mfloat = mubyte
-    mfloat = mword
-    mfloat = muword
-    mfloat = fl2
-    mfloat = mfloat2
-    mfloat = barr1[2]
-    mfloat = ubarr1[2]
-    mfloat = warr1[2]
-    mfloat = uwarr1[2]
-    mfloat = string[4]
-    mfloat = farr1[4]
-
-    mfloat = string[Y]            ; via evaluation
-    mfloat = string[b]            ; via evaluation
-    mfloat = string[ub]           ; via evaluation
-    mfloat = string[mbyte2]       ; via evaluation
-    mfloat = string[mubyte2]      ; via evaluation
-    mfloat = barr1[Y]             ; via evaluation
-    mfloat = ubarr1[Y]            ; via evaluation
-    mfloat = barr1[b]             ; via evaluation
-    mfloat = ubarr1[b]            ; via evaluation
-    mfloat = barr1[ub]            ; via evaluation
-    mfloat = ubarr1[ub]           ; via evaluation
-    mfloat = barr1[mbyte2]        ; via evaluation
-    mfloat = ubarr1[mbyte2]       ; via evaluation
-    mfloat = barr1[mubyte2]       ; via evaluation
-    mfloat = ubarr1[mubyte2]      ; via evaluation
-    mfloat = warr1[Y]             ; via evaluation
-    mfloat = warr1[b]             ; via evaluation
-    mfloat = warr1[ub]            ; via evaluation
-    mfloat = warr1[mbyte2]        ; via evaluation
-    mfloat = warr1[mubyte2]       ; via evaluation
-
-
-
-    return
-}
-
-}
diff --git a/examples/compiled/cube3d-float.prg b/examples/compiled/cube3d-float.prg
new file mode 100644
index 0000000000000000000000000000000000000000..4c6cd9b07733a2d2473ccbfce028acb0a029a21a
GIT binary patch
literal 2531
zcmc&$Urbw77(eZ8Z!g5{-WyG9j1Pw=s!?Ff2$>Jta4;ZUfXUzSa*e}*#^8gJX(B?_
z%K&o&+lw?2t&I>4rer3Xv7y;wd?-kuS*Gz#;*8l|YUA8yC|mu$bK2fs{=Avk&~v`?
z`+nc=e82C~f=hW?x#jzmR#sG1(?b)q`DD}aYFg7p8;&&+Lg)!Kn(+sJErOVk!QkrZ
z>W6`Q-%ku3UwGpE5Ab-7Lc*-a1)~r~|KIE2G5T^_O>GGc)CHT4wmw4%ZEUEkYp8vt
zyzb=D6SZV`2%6izV86rLmLbIWVkh>*IK?LK5+UQid~LTd1me44tTdvS>ChJIjwtkR
z4L5%Lh97BnF{AV&mA<-<69zQ)93%!b+M;t{L5mPm8n2&`qQp;A8B^+=pOM%akmgm9
zn2FLQ2sysNaYoE&Fj-_Uyacp<*4ZV97PK7jqt3o81lR#V?AMVyyGIJDK6j*EEUfxu
zj}%mWEK=A57(@+ds$XXp1&*yaa7*A>KDHzHqXNe=;G?R*vjW%w2dJU5a}I7k#eEkR
z<DdrxH!EY`_nyG9ox&16OaSttsPT@2n@{Dq`DU@Ve!<NSVo+yq2teFiV64Z1+oFcR
ziPfqw9Lj(eYgMMn+6wy<PSbq2H~<@eGEyY)oL@V2xFD62IRn@&jo|=nqOFZ)ZQP-a
z-t5$F+7m(>J=;WE8$H{&LmO?|sok_MbM0iS0!EgVloUMtn8AqEro`IBe2_4$v8$j2
z9|zpvLB7N{dQrdq9a&3A!K(ea%n^}+=UXeH8l7E(XhF*f;-o+jLHON+bYrfBzNVp`
z)sep(ojbTq+qvyZtV6NJ)mXb?jj6268db9wJ#wwV4;MVI(o!wSJ#mk(?*ogSO03gi
z@dw@}!_Brhmb3Vjn#=5FahccV1hW<q+{5Cj{N-7THg|``E+uw~TkPT%ThOBDe1}Eu
ziCb*gZ}@xCW_r^7$CiOZFx|z){vNks9H>0_LjHT*IQt7LHwh~>T{M)T;~6@fVX{RN
z%x8_bVM-;5`8oe$rx7WS9;%MtIejU;(pOxO?khJ?BSON&6LxvR#2a>b!$c0d<nV1d
zd`FJQ6Tcg#J0wNOSMHQdZ)D<$`v!eit-oH8P&VM*8@!R30(>0a7>A_dxhwZo>#lm`
zp6c(BtiRMrDS20&aa);;K|BFZv*)ZQ;)#1w9>4d9x7R!AUG#2v6}dw0l!xRwIU)Ze
zQ(wLBZQqpdx-T}S3c(hw@21tEq3T=Xs@1Gn?b@WAY|)Y(T5MDW_1Jk_xg&H1|3v(x
zjcn2fmuEMp$@&z2PZ;<&2)v}>5XW_Wg>TM-pwUW|2Gp7K7hAyrjn{eb30z2z!nO|E
z&V#`M5gk8Zumz(_SX7|0pqURtkMQ;j58>7wi@~1HSEC4=Ktx!<HHzXlmr#6m6MCYL
z>m!@|Ms+DzsoTdhi;iQn^BA~_Sw5PtuVMI^zMM%_CCV^xrOK8`>e)oewqEe+=n{e>
b67BwWR)Vh=K2YXLJP=}U{+8E0jiK=`E(ld%

literal 0
HcmV?d00001

diff --git a/examples/compiled/cube3d-sprites.prg b/examples/compiled/cube3d-sprites.prg
new file mode 100644
index 0000000000000000000000000000000000000000..9943967b718944f585d9520082f75c4b6b6f621d
GIT binary patch
literal 7071
zcmeHMdrTBZ7~j1!@PVeF(d5!L&2ZNU;)7EZ@lh-y=;?_FQl+T98tS7OqSpFGv9Q?U
zUM03o#fl*(r>=GzTQsc=7mZ-Fm-O~h6I&Bat4$k}N-#0C;W)0}%-&&dy^yrf{?i+F
zhi_+ozi+<z&Fo|5cz7Oujy*;unWtuw=?6(c;i9>jWOfO$%$d(|97#7h0tV}KK>Hu1
z^f@G_cy?|QNhvBQv@FRj8bdfT-;$SS$t_CDE6iS)OE{j7O&B&bF77C%GE6jQXW3Eq
z_jenX0`^f}DXEdOPX#d(Bu;S1lfXU(<jG)90XYNg$v~RpNd9nnA~bLwtZm>FxAX{Y
ziKiwxN!neUr-f7O6G5B=ayr9JW;la%vx4_D@E(b);FShm2|?3AoDA|52F(aU+k#L&
z96ANW3~1y8eeFD_-oY72S3uCOJ?+#>uQdYMWKt`f4)P9~to$ujZoLaOc?@mAP0koy
zyeDq2StoIS38DnVS0My>Jt-1oDTvEJPU+7}F^I49K_Yu80&xk*$^Cg*3}Rs)B(j%9
zAQpgJLcPeZVy?L5B6hKaU62;y;+6P4yt0S)48#hJ(LxaOL0-z5SoR;Zw*W+|rhmn(
z@mKzx{#ihr5As6RM84X;MeL#=)LwY!7qiO3P$f?MfvEh18`66&i1Re@XqpU<M-wbL
zG|2Jff|#cn|9^EnazLB|@&cx^m8mRix)?tBHR23<|Fc1yt%*m|WOzK9U<ZAE%mVRc
z2*2ek`<}foftUsIU&lu)-jfM85GyoUXMi|U)1F40fwc038)|PFh|}@?WKRXz!e+>P
zb%vzU3wI0exo`mRJ=6D$$ETq@mjUN#fgfmrICJD&hRxGrKZ%4*h4@o6uKMHP;*|O(
zkaHM&j+Xs&NZAZHTMLXB(kzC3S&QvIq-GY<Ignps>?|$&>5yhH;7lzrVo1{%cDfeZ
ze@Lw?q&Dcpu}g(-pi6JvpJ0<>>|^PGjt6->_3D<#vVSByiE4|W%_D*}y}XAO*~f*T
z_@<6Ob)l7x&4o716?q)vK2=T@GG|`Bbq#eEFX#{%FX(H!PrHsoOA`pb>Yfui)jpwb
zI1Yy!n&5=a=|j`mL+x%YuNhj-g?P+HUNiE}sk~;&L;ERSE3~wQc+5s#EArY@UMuCH
z-QCF)!Tv8B?imYay|rjK%4CKboot5q(=L^(v#$VgCCDpi$K{onEAA(E&EQxDX<UW+
z^``kGD+O^mU^H~tRLzgGv1nprQOZJE&O#!0h(X#L^b-6Altwb1&SSvx_J-i#riD9f
zW)9Cqc37rym=ek11d!8MBokO9R6O;r<-GK+<-K9r;fEo9(I!wC$+PMV94hVm)C~21
z#9D`plqyv-j59bY55$W!MALKnAgrR&siV`vu{)<e+1qKR`m&pE?+Dx9T_;5GQ3aw3
zL=}iC5LF<mKvaRK0#OD2mkP|}xB$odEBQdBK5$7r(8dGHIjrq3Wg)qe??swTANVOY
z(A9U~B_4d>5&}4cMNF9z=MQeC``Ko?t=-__JnC8qmoyc@!b}(M@pE+79hVk<j&8f#
z==xdkAxP-K+7@1^=_comxJYd`B2K=Cxngtaloh-J$V$``y0sKEkbzvDa@j^d`Hhke
zH}FbIqTX6bkm$LMt?3j$uN3GkmFD=w1hvc?EAj0Jwn<#qW3{O3(b<l=F7$a@#{$%;
zl<yO7(Z$R9B#P$rF>%8ZMvO8%_d?Q($*JSb=^4{zWM${%Sr+6M6c#TnDP3t>RknJ~
zy7e2%H*VUz<?XH8w(r=vYuE0Iiaj*#WqC!#?p?cf?%2L<>)Ts4Z`xSCVg0%_tIJl|
zR+g45EiNp`Utr10$<CTFEhF7LJ~jEpq!*quj2e+JEG|aR`MV!Kdf3^~{>$ATZ{56c
z-TSTk>XpkEU0;8B{)@AposmvD9gWA19;yHMqYn?&9eiIrQ2XAy`)dTDx~l3On)b20
zs;XKLYWBbTUhM(#{eyLfKK$t8`Xfh=H9DLpr8A$M{o?$WU%M_|zH-(5t@rwko40<v
z`%8OA=fg*jyZr<0KUMM!Q&R9(_u}@!eWSg@=t#`#S?#NPM!s(}yy3?(xx@HI@0(at
ze&1Mr&sg4WbbD{v=;X5-O`^$E(~Z9f`GsCbVvKKe&uIVXUZ+3vfzfoz+55m`s*4eN
ztNp+F+}=A*UsKPCZe-dfPD-Cl9k68E{)3bza8k0slj;De4Ul~S-1i|~Db`+tzs1;-
zyr)kYzFKB$Omj@nymqhbtk1nJ-t1eKW}|#TSFLa4KG$`{knaN5yuaH>scGINvlo8C
QbFKBez+o(}#gp290{<w+rvLx|

literal 0
HcmV?d00001

diff --git a/examples/compiled/cube3d.prg b/examples/compiled/cube3d.prg
new file mode 100644
index 0000000000000000000000000000000000000000..7675f0736ee9729d22f679de6de3c5c030b55724
GIT binary patch
literal 4255
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
TwSOqIHwpL>PrT!Av|juRWcS7G

literal 0
HcmV?d00001

diff --git a/examples/compiled/hello.prg b/examples/compiled/hello.prg
new file mode 100644
index 0000000000000000000000000000000000000000..cc15225de2a60aab55e4973523e579cf0d9d7524
GIT binary patch
literal 233
zcmZSNkl}dDK2O2Oz}!N?s$U@>$lu*U!6{O~)5VK{fk9z4$D;odK3*I^_6h%R1;-#)
zg-HKU`(B3Q{{Ajbk*<op3@2QDeEfm*O4eS53o99V6)&u0>}_LOD{+C7saN8{N~Z-J
z3fDP+66zdl)H!x)arA0%C|vsgPMu?|I>$-g3$K7unjC91Id)or#WgwBYI2<9y6`q3
z!O+Oq1ZXn^Bvjm3so%=5QoWT?q2<3q*MEh^|0~%*cCrJl16#amg~X1C1d#GprWWP}
Q3>%p~umP<)ap7A60Cjv%`Tzg`

literal 0
HcmV?d00001

diff --git a/examples/compiled/mandelbrot.prg b/examples/compiled/mandelbrot.prg
new file mode 100644
index 0000000000000000000000000000000000000000..271aad69c3b47484e98cff2c2a3df36eaea42d6c
GIT binary patch
literal 1328
zcma)5O=uHQ5Pr#SHru`xD=6e(%j>BkQfn10ieTE*CUs3qTcJN5)`MCRp&o?RAN<P(
ze^^X!UX<-ZN}m!`yi{YwV_VV~q*xCv3L@ww<RDdA>pHU=W2+YfnR(y5neUs-ym;iz
z@<;!DR$sTLf$hD++B@1>8dzfwi-cMUA&gPW4ye!N7yxn=O{@aUH6@eDAR^b$Tt{;g
z%`lqy0NVfhGzHbBBWkcK5^Z6JgV9j4+St+7#SV4^o4SH(ZEdYV4o0Gp&Tw;xMWT$b
z&gQ1JXsEN=ApEi^GnI0poBD`u89j2UN4`h0)9ef7HE_2`nW^w??&+n%kHM)@;l${Z
zQ+=h(9i`0OrOfkg<~~!_mt#NpIe;AsA8_4i*PU=3F?wZnvW#PNk#dZJ?u^0@luoD%
zu}6w?3mqUI<RTx$p)=HTGmr){ifpb!HY|a-OTS75IVzQWubk?2ei5&5Ch)cVFA)%L
zc17lu32%14C;Ryxd?!e@AgC>6#d&ZMtKmLy=}&@jh!zL?)2%RCDL0J>b+wAZP}H!p
zswhlZisqe3PgQ}&qMUaYG_?^xMowDAO(jQ)2j1%TH>1F$lIHJd+o~w<a)GI^4eR((
z0F{bKbm3MwDOj5VtYGUx|AVB!Ex3Z00U6Hz-kTKm$12zHN2aW*6nb6oWE16&*Sn{j
zpL=i|8YhKs+K&32yGn0Y8+^yN>x9?n9u~9NEt_4nxn!^$_Zx99yrt^ggR#JPw}utE
zHzt_miMJrJH}+(1QHu%XW6v&9V~9SxKm*4GV~{3<{18og4cpd;xJ7Ii2Srny6boX&
zcfi;0OZdipAAGV@Cv{6#q%kQceV3R&>>u#o^}q6`TB%DoM^DWf3l8g<L)3Unjd_}o
z@^du5KvNM4?5QwXr!8!a5ZrZqX^dG<)r5j$flilU%9ChcPdjccnAV&$5i5t6Z-9FZ
z?q8tsIBW!7Cpgtg>npLJ$UVFQoc|b&-!3I%4Irp-TSRLi*K8WOMwe9hQ=C=eOOC+$
zG&KGPo*Z8T+t<P^&++z?GG!OG=BoeFL<uX6!MMQsUW^K`c$mbr#yz=jEChlq^8)HM
SP{y}orP;y+t9m%Pr2PUKXaOq#

literal 0
HcmV?d00001

diff --git a/examples/compiled/numbergame.prg b/examples/compiled/numbergame.prg
new file mode 100644
index 0000000000000000000000000000000000000000..c25548acb3b86ee239978bac09a54506e1541a2b
GIT binary patch
literal 1106
zcma)5O=#3W6rLouO%tm<?!n4i53a4c-TH%N4@zpYKbqZ?O}5%o18t!_dJqIp!lp`L
zuzC<L%2HGuaiQK6tO%m)7L7p!^`HnUR`d|CR&>R6X5wnSIWU>`zW4Ke??D84gZ!rL
zBJ4=)>4)TL7%G_Qei#^m?BD@}5R}xpM#MPVPHnXBKhLT}<QuwX>5$Fa1#_^tUxyL1
zSg>>>l>~%wRW}TC8=yFTsM|3Mh74^4G{_fo19}0{McuNp`81@poF2zD&~jjBviXAy
zGgE&PQw1{zePEl=mq<ikn8lc3Kt>zZ8N|Cl){bI?X(+@|2qQ4`lpV*<GMWupi;IK2
ze%KDf`vB<{mHG5{*fvc-hIxp#%4E|S`p`)Jpam(jz_n9hd>UHAs5rGgNXfTBHaApY
z;|%Le$Wz*BKpTw0qmkychct`sB#semSIO7~<SoLA@>B4Z7LbQyawX!oi#Xzw(XtF3
zYh7t3b6Fx=sgtD6<TdIX=Mj!|tR-&fDY#oEpH|gWx@FkdEcwa<6k>ct;H*)VQ3eXp
z;Yov7?DKO~J+Z0thm$#XRJ?^ZsKodK>%tBy5pa)eTvv>93fWX{r?M;mCa!5x_3<dn
z+rurdTc)CFD3FY|?F5BwoJx;OWetb9uM~2WTj44w_usMNOf+Vny*#D4lMpwaG?s27
zZ$a>2w|YVFoCVQ)DR{HW{QA)H+la8l0t5wLLnv6D|2P{!L1im)N|Gy1e<x^8ZWVj(
zOS9rTX|uTKFJBU`e0M5iYS5wtEwfT?T*YImlkDo+x;-~KHZgVNBqsMBzyIR&?bx}C
z{Zjlm$DWg37m=7NK&b&U4LH#ttr&dLhNne3ebm2pHFEQ?Q|_Hh_E$fQ&({~Hltg{1
z*KzBmAMi~j=v1fR+^F||NHD{dxT(0JqC_Ud$b{5Huiko~QrAJ_)iSzKuO$*~wPdGM
z^*=jIiYt~Rii<%j-CfmRap1a|xts9i*Yr-(y`87{486=|++_rh8?}z0<xIWmFB5d8
G?)(DjbBH$p

literal 0
HcmV?d00001

diff --git a/examples/compiled/rasterbars.prg b/examples/compiled/rasterbars.prg
new file mode 100644
index 0000000000000000000000000000000000000000..03cd0d26a1032e339162ebc1fbe7e8c25a2fbe38
GIT binary patch
literal 708
zcmZSNkl}dDK2O2Oz}!N?s$U@>$lu*U!6{O~)5VK{fk9y&=c4}-KI$B61utm6?-jhT
zQey#w0uPsu8Arm4y$t7K8PCmSJeRPC@!U>-4iKxMxvjIOf6~+$v*#^Zx_s5z4V$;^
z+_UfCkz*%MpSy7R>h)W9?mc+)<k^c?uiw7=@bUAPuit+B{PpYipTB?q{rmSH0)VW)
zfB*dc_3P)4Z(qNB{`leD+t;sNJbUu!!M!`Tu3x=;;oRwy$BrD_w`b?J%^TLPTE2AA
zyxB9RPU`RJY-?_)sVpll$jwSmNsNt(2o3W0@pN-`w6nG}GcnZH(b7;=R+N{OmJ}Bi
z5fbF*<KgDwWM^Y#WnpGwVq|0ldKd(NEG8yq7FJd^c1|vC9zK3SArVn=NoiSmMP*eD
zEggMB6EjO|J4a_XPaprF(1@tm#FX@`+=Ak=%9?r#{hwfHWNZR)29QjsxUo{dm0_iN
zE2Bcoe}%693XT6)vh^xlSjpbo#<Y^5SMkEC6%sol5-JoPa<07AE5f{zvsaWkB0<4{
zYvuo5$qPP)uRK=P_wwH9<-MybcmWuJYkBXi<-MEHD|F!i!v|2bayEdXm9baq0>l&<
zkSScKrZm0+I);sjg_WP3k(Zf=gPRj*w+2_QI#<G4p$om5TtKi^gKI9sxl=27L8O8e
z2Pk=b&|9OywNr}==;F1S5NQ^W^j@ZO619xyUI0@JNEy&E?=-l44spFx2O*%@K=tZi
T^$M;Wag66yYGBs|c0~dJ3&cc;

literal 0
HcmV?d00001

diff --git a/examples/compiled/readme.txt b/examples/compiled/readme.txt
new file mode 100644
index 000000000..ff6b3c995
--- /dev/null
+++ b/examples/compiled/readme.txt
@@ -0,0 +1,6 @@
+These .prg files are the compiled versions of most of the examples.
+They can be loaded and ran on a C64 or in an emulator, for example in Vice:
+
+x64  hello.prg
+
+will load and run the hello example.
diff --git a/examples/compiled/sprites.prg b/examples/compiled/sprites.prg
new file mode 100644
index 0000000000000000000000000000000000000000..3d72d24fe127e1df9dce11ed5e578d5aae18bba2
GIT binary patch
literal 924
zcmeHFL2DC16n>LMcbp|?#6py|Ou?9dG}=_K<WQSpZ6e#Iq%BquT#!P%>8%$@g+^gv
zFqbL?D?t&Q)s>#agMoq<>tUUvhol60uqcE*DC(u_Oj0Wz{09!-4DWsKV}>{HL%17n
z>5pjY^w}YrzDK7D`SBq-dYR_VUjzX9iaZXY<}8NMjA`cclXQBjkeeBs?qiTlCNGWA
zOhInbq!-M5W+pc|E?EX;&CWj6c%q7F@AI-&bX1n!%VYv9j(Orm9IyP)-8fza?>)Ui
zcuEDekQcp$yzN!w?Us6F_6EG|8h9%pXp#Kkcm681;#ih8uz11))+P9070gW{8~MNf
z^#dh9!MYYSwXLRJ_w|M^PZ=vFXoi9+DvhAw5qP+$kOPI`-{=N8s|NBaWbI%l5;{j}
za25yudx!GBu6?Qabcv|hS~cVmLdqJ6&TDGQO6x8Yf1gA}o48NdGO^M<JtzAou3nqJ
ze)BHlZ$EtcW(}kU&+N5eEqvss%E04gM3(|;2lRHp_cJQE&hCVyx%!0jEc$xRTA)7(
zZ?Pj9C#*}Gv*-y!8sn%i2R>(ciG}Md+~|)877=c^?uHvhc37-~kKKqkuqauM*fC)N
zc=BpsF~f}+staX0J1gDjY=S5{(vZrU?0CD#-zf>b(&l`_ei<`%KscstxVwTxTX3!;
Wz)B#maau7$LcXwZNIYm!Vf_O7W&sHR

literal 0
HcmV?d00001

diff --git a/examples/compiled/swirl-float.prg b/examples/compiled/swirl-float.prg
new file mode 100644
index 0000000000000000000000000000000000000000..e8d7ced1acecef0091bf1b5e9f13b8a00860196e
GIT binary patch
literal 673
zcmZSNkl}dDK2O2Oz}!N?s$U@>$lu*U!6{O~)5VK{fk8o(bJ2eZpKy*w!RT<iR>6{3
z@m2+(c#G-9lGqjxAgfmSI+rbwMguE77H}v$;8f`3S{Vdnv2#HMR;ok9tGE=VaIN%(
zNP$#5;9RK#lUivAVP$hEoaKD6m*HHmI|o=TP>~s2ku|y^H;%RL9K8;lYuz|{?KxKl
z_S$i-b>--_<y4r+3A5e-rU@*-&h^ff1L(Vi1VbZZ6Sx-=DsHUQZ)I4i-pZ)Z@?W9r
zze3~xm2ABV7gn<OwlS?_=vBP1YK6p(hy;+17G|y$I}<p2V>x%mb4sK#_r`EeV15_N
zxs<8*|NjIA77dmFmI{^yEGJk#ut=~vux7AMVBNv`fR%&IfGvWpfo%ob1-2h-3hW;2
z1?)4}53sMb=Y$xzn=|uD??JGsxelDYyEuCfa86)*x100bLC&>yoIump+JZ>1D?ly*
zMwcE}+b@Oh+n4>C%W!_iT!wR}5?X(^{8_-T@i&lj0z{ra1*T9rP-QHju%7t414x|*
zQka~Cm4OSmK#>Wgd=~9q83yNp1c5xDAjBmgauG=JmE9o4%YOL)6N3%Vbzl?Hclbne
UA-Ed5KwPlfvme2kDIjJ70KIzessI20

literal 0
HcmV?d00001

diff --git a/examples/compiled/swirl.prg b/examples/compiled/swirl.prg
new file mode 100644
index 0000000000000000000000000000000000000000..4a9b8d80a596754464d38df5e21f03c5d790f152
GIT binary patch
literal 876
zcmZSNkl}dDK2O2Oz}!N?s$U@>$lu*U!6{O~)5VK{fk9y}*P{OtK6)HLHVCZM=9tTH
z?v%n~j+G2^8P6+}aP4J0KbP^`i@glzdNn!L>O!P-xggT!$kG}dYc)A~UvRC};OKqM
zwKA~x8P{5Mj^3wS3YOe!wLludrk_70u~MOy@f^_9mCUsu)6auU-@|aeSBs-Zn`5mG
zSSiRRkkZZAmFjTx=yJSM=KwlAVGrZEoo_jS<|Q;Vw{`aPPntSo_Pj+)m#<p8Ve__~
zd-feXa_r>ka~CdOy?*P?y$6q;JbUr#_1kwJK7Ri4_1ll1zkdDx^Y`z+fB*hN0Fd?f
z@1Nhle*OIM?dzA%A3wZ%`})<3XHOnIxOeB)^{baJoI8E;*pY+#_UzoYdBfUO%a<;i
zH+#m^N&P*YZOsiem1V^RxmoEciLp@;p+WvWo^H;LcGi|=CWiVtS{ka#it@73lH#Hw
zLW2B!JltHI>};&8EX+(yjEszs7+?Uhn3$MZSXtTFIk~ub`1l2dL`20UrDf$6l~pyg
zbo32P%q*?#9G%@fef)z$BcfsxQ_{0?3yRAsYw9WVKPV)1IYA-0m+@TdZ(!WF{$cyA
z2FDUW;nd$id7w<{A7IRZBrybWXkH4^xD=)fyUqkdBV!Y2Krk>QRNPpp-^#F3y_Hd+
z<-bDLe}%^XE7^J#F05qlZDU%=(5rZ1)e4Cn5eXn2EzDdic5-m{vU2Za=axui?q%Vg
z!2FJtdnr@z|NjXLEE+5UEEOyZSWd8fV3A;TV9j8iz`BF=0V@Za0b2xH1KSF=3v55w
z6xco33)p9{A7EemoC{)LGI!>c-b}Emxi7eSlel{`xF@i^OXhx;$-VX&7tr*zPeEh?
E0BPHhy8r+H

literal 0
HcmV?d00001

diff --git a/examples/compiled/wizzine.prg b/examples/compiled/wizzine.prg
new file mode 100644
index 0000000000000000000000000000000000000000..b8234586d19a5b44f911e3b83a2a58f909216d80
GIT binary patch
literal 1307
zcmeH`TSyy06ozLK<F3hii73XZ$pn#zSTt6wR!FrL+mwJs5K_SsL9hsdAc%sJ6swTp
zB3J~)Dk6xEbc-NJg+vrYu)=0QtVN;(6%oY{@q)Lw-Br`qKJ=;3;V_&%vwZ)VfA>H-
znck*`P)_#aeDtIny)G|%k&m9eLFVVL008K#YDCaj(rJJJYoKxZ7X#gYPWcTqXP}p8
z;>Q9TPq23wSbnI)_y4bd&H+1s!kk?2$+vx!H$ZI!#9hp#ir|w8!_Zy?O-10dLkcsH
z!W4>R;DY>&Svd%Ko1?wc+11_C+cz*YGCDTFO-@bExMt@U7MGTJva-6i?%nil?d<OD
z9~}AvN5?0pXXh7}msi)p;LXjAaJR%P7`(o^yu3I+J3To*3iuBX_V;#owtSo3^|jR%
z!Y?l^F3iumW~QemxrwpSk)eUU-k$C*XJ@;kwWX=Cp}wxRrn;)qT2WqRF_)GUn+gl^
za*bJ;8R==MdR<CVVnTdetU5Z1Q7I#+aD^gFE|WnB@4uRu$z<{{g(94aP^y@yXmxB{
zd_rPUicX)JmY$KBWz5YhC^Qw9l$tGN<rUV-s_L5By84F3rj}OwU*2DG(s}Eo8}dp`
z8{{QdZN{8OxxfD@Tk}tx)d8@f1ELQC`Y53H0uE;p!4%sm6Gv1}CdM`2thQ!!q{6#w
zoE)pzc)8Vv^o%&EiNs>ue~ImEq?e7{c&H|<nsAX`E^^}?8%yRufacUB!XZ{MWFHXQ
ztuBv<KbaBPF_Maw;gXp_z<<|5p3{ah@!>AqGCn^D`8~09^i+w#AoOT(&fQ%wXoDWH
zu;&K63wT%^(}hAb^hxyxnp5=_^0-uz7DXg`BoT?lrZAlDwi7Oe5&0rWIW8Ua1L6jr
men_HX2#1(}+#f^yi11n_TW&Ej93m18Q}@hJ<F`yiY`*}rA&yo6

literal 0
HcmV?d00001

diff --git a/examples/numbergame-lowlevel.p8 b/examples/numbergame-lowlevel.p8
deleted file mode 100644
index 5275ad462..000000000
--- a/examples/numbergame-lowlevel.p8
+++ /dev/null
@@ -1,78 +0,0 @@
-%import c64utils
-%import c64flt
-
-
-; The classic number guessing game.
-; This version uses more low-level subroutines (calls directly into the C64's ROM routines)
-; and instead of a loop (with the added behind the scenes processing), uses absolute jumps.
-; It's less readable I think, but produces a smaller program.
-
-
-~ main {
-    sub start()  {
-        str   name    = "????????????????????????????????????????"
-        str   input   = "??????????"
-        ubyte  guess
-        ubyte  secretnumber = 0
-        ubyte  attempts_left = 10
-        memory uword freadstr_arg = $22		; argument for FREADSTR ($22/$23)
-
-        ; greeting
-        c64.VMCSB |= 2  ; switch lowercase chars
-        c64.STROUT("Please introduce yourself: ")
-        c64scr.input_chars(name)
-        c64.CHROUT('\n')
-        c64.CHROUT('\n')
-        c64.STROUT("Hello, ")
-        c64.STROUT(name)
-        c64.STROUT(".\nLet's play a number guessing game.\nI am thinking of a number from 1 to 100!You'll have to guess it!\n")
-
-        ; create a secret random number from 1-100
-        c64flt.RND()               ; fac = random number between 0 and 1
-        c64flt.MUL10()             ; fac *= 10
-        c64flt.MUL10()             ; .. and now *100
-        c64flt.FADDH()             ; add 0.5..
-        c64flt.FADDH()             ;   and again, so +1 total
-        A, Y = c64flt.GETADRAY()
-        secretnumber = A           ; secret number = rnd()*100+1
-
-ask_guess:
-
-        c64.STROUT("\nYou have ")
-        c64scr.print_ub(attempts_left)
-        c64.STROUT(" guess")
-        if(attempts_left>1)
-            c64.STROUT("es")
-
-        c64.STROUT(" left.\nWhat is your next guess? ")
-        Y=c64scr.input_chars(input)
-        c64.CHROUT('\n')
-        freadstr_arg = input
-        c64flt.FREADSTR(Y)
-        A, Y = c64flt.GETADRAY()
-        guess=A
-        if(guess==secretnumber) {
-            c64.STROUT("\nThat's my number, impressive!\n")
-            goto goodbye
-        }
-        c64.STROUT("\nThat is too ")
-        if(guess < secretnumber)
-            c64.STROUT("low!\n")
-        else
-            c64.STROUT("high!\n")
-
-        attempts_left--
-        if_nz goto ask_guess
-
-        ; game over.
-        c64.STROUT("\nToo bad! It was: ")
-        c64scr.print_ub(secretnumber)
-        c64.CHROUT('\n')
-
-goodbye:
-        c64.STROUT("\nThanks for playing, ")
-        c64.STROUT(name)
-        c64.STROUT(".\n")
-        return
-    }
-}
diff --git a/examples/test.p8 b/examples/test.p8
index 252d2e6ed..9780ff953 100644
--- a/examples/test.p8
+++ b/examples/test.p8
@@ -13,10 +13,19 @@
         word w1
         word w2
 
-        ubyte[3] uba
-        byte[3] ba
-        uword[3] uwa
-        word[3] wa
+        memory ubyte mub1 = $c000
+        memory ubyte mub2 = $c001
+        memory uword muw1 = $c100
+        memory uword muw2 = $c102
+
+        ubyte[3] uba1
+        byte[3] ba1
+        uword[3] uwa1
+        word[3] wa1
+        ubyte[3] uba2
+        byte[3] ba2
+        uword[3] uwa2
+        word[3] wa2
 
 ;        ub1 = ub2 & 44
 ;        b1 = b2 & 44
@@ -48,24 +57,28 @@
         swap(b1, b2)
         swap(uw1, uw2)
         swap(w1, w2)
+        swap(@($d020), @($d021))
+        swap(mub1, mub2)
+        swap(muw1, muw2)
+        swap(mub1, ub2)
+        swap(muw1, uw2)
 
-        swap(uba[0], uba[1])
-        swap(ba[0], ba[1])
-        swap(uwa[0], uwa[1])
-        swap(wa[0], wa[1])
+        swap(uba1[1], uba2[2])
+        swap(ba1[1], ba2[2])
+        swap(uwa1[1], uwa2[2])
+        swap(wa1[1], wa2[2])
 
-        ; this goes without xor trick:
         ubyte i1
         ubyte i2
-        swap(uba[i1], uba[i2])
-        swap(ba[i1], ba[i2])
-        swap(uwa[i1], uwa[i2])
-        swap(wa[i1], wa[i2])
+        swap(uba1[i1], uba2[i2])
+        swap(ba1[i1], ba2[i2])
+        swap(uwa1[i1], uwa2[i2])
+        swap(wa1[i1], wa2[i2])
 
-        swap(uba[1], ub1)
-        swap(uba[i1], ub1)
-        swap(uwa[1], uw1)
-        swap(uwa[i1], uw1)
+        swap(uba1[1], ub1)
+        swap(uba1[i1], ub1)
+        swap(uwa1[1], uw1)
+        swap(uwa1[i1], uw1)
     }