cleanup, animals example removed because it's superseded by the pointers/animalgame example now

update gradle wrapper to 9.2.0

.github/workflows/all-ci.yml

@@ -20,10 +20,10 @@ jobs:
           make -j4
           sudo make install          
 
-      - name: Set up JDK 11
+      - name: Set up JDK 17
         uses: actions/setup-java@v4
         with:
-          java-version: 11
+          java-version: 17
           distribution: temurin
 
       - name: Build and test with Gradle

.idea/libraries/KotlinJavaRuntime.xml

@@ -1,23 +1,23 @@
 <component name="libraryTable">
   <library name="KotlinJavaRuntime" type="repository">
-    <properties maven-id="org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.2.20" />
+    <properties maven-id="org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.2.21" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.2.20/kotlin-stdlib-jdk8-2.2.20.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.20/kotlin-stdlib-2.2.20.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.2.21/kotlin-stdlib-jdk8-2.2.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.21/kotlin-stdlib-2.2.21.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.2.20/kotlin-stdlib-jdk7-2.2.20.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.2.21/kotlin-stdlib-jdk7-2.2.21.jar!/" />
     </CLASSES>
     <JAVADOC>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.2.20/kotlin-stdlib-jdk8-2.2.20-javadoc.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.20/kotlin-stdlib-2.2.20-javadoc.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.2.21/kotlin-stdlib-jdk8-2.2.21-javadoc.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.21/kotlin-stdlib-2.2.21-javadoc.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0-javadoc.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.2.20/kotlin-stdlib-jdk7-2.2.20-javadoc.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.2.21/kotlin-stdlib-jdk7-2.2.21-javadoc.jar!/" />
     </JAVADOC>
     <SOURCES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.2.20/kotlin-stdlib-jdk8-2.2.20-sources.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.20/kotlin-stdlib-2.2.20-sources.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.2.21/kotlin-stdlib-jdk8-2.2.21-sources.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.21/kotlin-stdlib-2.2.21-sources.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0-sources.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.2.20/kotlin-stdlib-jdk7-2.2.20-sources.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.2.21/kotlin-stdlib-jdk7-2.2.21-sources.jar!/" />
     </SOURCES>
   </library>
 </component>

.idea/modules.xml

@@ -15,6 +15,7 @@
       <module fileurl="file://$PROJECT_DIR$/docs/docs.iml" filepath="$PROJECT_DIR$/docs/docs.iml" />
       <module fileurl="file://$PROJECT_DIR$/examples/examples.iml" filepath="$PROJECT_DIR$/examples/examples.iml" />
       <module fileurl="file://$PROJECT_DIR$/intermediate/intermediate.iml" filepath="$PROJECT_DIR$/intermediate/intermediate.iml" />
+      <module fileurl="file://$PROJECT_DIR$/languageServer/languageServer.iml" filepath="$PROJECT_DIR$/languageServer/languageServer.iml" />
       <module fileurl="file://$PROJECT_DIR$/parser/parser.iml" filepath="$PROJECT_DIR$/parser/parser.iml" />
       <module fileurl="file://$PROJECT_DIR$/.idea/modules/prog8.iml" filepath="$PROJECT_DIR$/.idea/modules/prog8.iml" />
       <module fileurl="file://$PROJECT_DIR$/simpleAst/simpleAst.iml" filepath="$PROJECT_DIR$/simpleAst/simpleAst.iml" />

README.md

@@ -34,8 +34,11 @@ How to get it/build it
   - you can also compile it yourself from source. [Instructions here](https://prog8.readthedocs.io/en/latest/compiling.html).
     Note that if you are not using *gradle* to build it, you might have to perform some manual
     tasks once to make it compile fully. These are explained in the linked instructions. 
-- Alternatively, you can also install the compiler as a package on some linux distros:
+- Alternatively, you can also install the compiler as a package on some linux distros (which will take care of dependencies automatically):
   - Arch (via AUR): [`prog8`](https://aur.archlinux.org/packages/prog8)
+- Finally there's a Homebrew recipe for Mac OS (but also for Linux, and WSL2 on Windows, this also takes care of dependencies automatically):
+  ``brew install prog8``
+
 
 Community
 ---------
@@ -58,9 +61,9 @@ What does Prog8 provide?
 
 - all advantages of a higher level language over having to write assembly code manually
 - programs run very fast because it's compiled to native machine code
-- code often is smaller and faster than equivalent C code compiled with CC65 or even LLVM-MOS
+- compiled code is very small; much smaller than equivalent C code compiled with CC65, and usually runs faster as well
 - modularity, symbol scoping, subroutines. No need for forward declarations.
-- various data types other than just bytes (16-bit words, floats, strings)
+- various data types other than just bytes (16-bit words, long integers, floats, strings)
 - Structs and typed pointers
 - floating point math is supported on certain targets
 - access to most Kernal ROM routines as external subroutine definitions you can call normally
@@ -82,7 +85,7 @@ What does Prog8 provide?
 - supports the sixteen 'virtual' 16-bit registers R0 - R15 from the Commander X16 (also available on other targets)
 - encode strings and characters into petscii or screencodes or even other encodings
 - Automatic ROM/RAM bank switching on certain compiler targets when calling routines in other banks
-- 50 Kb of available program RAM size on the C64 by default; because Basic ROM is banked out altogether 
+- 50 Kb of available program RAM size on the C64 by default (41 Kb on the C128) because Basic ROM is banked out by default 
 
 *Rapid edit-compile-run-debug cycle:*
 
@@ -193,3 +196,12 @@ For instance here's a well known space ship animated in 3D with hidden line remo
 in the CommanderX16 emulator:
 
 ![cobra3d](docs/source/_static/cobra3d.png)
+
+
+Performance comparison with various C compilers
+-----------------------------------------------
+
+Here is a performance comparison with various C compilers for the 6502/C64 so you can get
+an idea of how Prog8 stacks up.
+
+[comparison](benchmark-c/benchmark.md)

benchmark-c/benchmark.md

@@ -0,0 +1,39 @@
+# C-Bench-64 comparison
+
+Several benchmarks of https://thred.github.io/c-bench-64/
+have been ported to equivalent Prog8 code and the benchmark results have been penciled in in the graphs below.
+Because they use the CIA timer for measuring the duration of the runs, the code only works on a C64.
+
+Maybe one day I'll try to integrate the prog8 data properly but their benchmark site is comparing C compilers, which Prog8 clearly is not.
+
+However conclusions so far (note: these are micro benchmarks so interpret the results as you will!)
+
+* Prog8 program size is consistently one of the smallest.
+* Prog8 execution speed places it more or less in the middle of the stack.
+
+Measured with Prog8 V12.0 .
+Benchmarks ran on a PAL C64 emulated through VICE.
+
+textual results:
+
+| benchmark | size | time     |
+|-----------|------|----------|
+| crc8      | 1568 | 2.0 sec  |
+| crc16     | 1608 | 2.5 sec  |
+| crc32     | 1812 | 4.2 sec  |
+| pow       | 2152 | 11.7 sec |
+| sieve     | 1772 | 22.1 sec |
+| sieve_bit | 1918 | 40.1 sec |
+
+
+![crc8](result-crc8.png)
+
+![crc16](result-crc16.png)
+
+![crc32](result-crc32.png)
+
+![pow](result-pow.png)
+
+![sieve](result-sieve.png)
+
+![sieve-bit](result-sieve-bit.png)

benchmark-c/ciatimer.p8

@@ -0,0 +1,98 @@
+%import textio
+
+cia {
+    ubyte freq
+    const ubyte CNT = 200
+
+    sub calibrate() {
+        txt.print("calibrating frequency: ")
+        tod_init(0)
+        txt.print_ub(tod_freq())
+        txt.print(" hz\n")
+        tod_reset()
+    }
+
+    sub print_time() {
+        uword t = tod_get10()
+        txt.print("(cia) time: ")
+        txt.print_uw(t / 10)
+        txt.chrout('.')
+        txt.print_uw(t % 10)
+        txt.print(" sec.\n")
+    }
+
+    sub tod_reset() {
+        ; set the tod to 0
+        c64.CIA2TODHR = 0
+        c64.CIA2TODMIN = 0
+        c64.CIA2TODSEC = 0
+        c64.CIA2TOD10 = 0
+    }
+
+    sub tod_get10() -> uword {
+        ubyte h, m, s, t
+        uword time
+        h = c64.CIA2TODHR
+        m = c64.CIA2TODMIN
+        s = c64.CIA2TODSEC
+        t = c64.CIA2TOD10
+        time = t
+        time += (s & $0f) * (10 as uword)
+        time += (s >> 4) * (100 as uword)
+        time += (m & $0f) * 600
+        time += (m >> 4) * 6000
+        return time
+    }
+
+    sub tod_init(ubyte f) {
+        if (f == 0)
+            freq = tod_detect_freq()
+        else
+            freq = f
+
+        if (freq == 50)
+            c64.CIA2CRA |= $80
+        else
+            c64.CIA2CRA &= $7f
+    }
+
+    sub tod_freq() -> ubyte {
+        return freq
+    }
+
+    sub tod_detect_freq() -> ubyte {
+        uword cbl
+
+        c64.CIA2CRB = $40  ; stop timer
+        c64.CIA2CRA = $80  ; stop timer
+
+        ; set ta to overflow every 10000 count (~= 10ms)
+        c64.CIA2TAL = $10
+        c64.CIA2TAH = $27
+        c64.CIA2TBL = CNT
+        c64.CIA2TBH = 0
+
+        tod_reset()
+
+        c64.CIA2CRB = $41  ; input from tim1 overflow, continuous, start timer
+        c64.CIA2CRA = $81  ; start timer, continuous tod 50HZ
+
+
+        while c64.CIA2TODSEC == 0 {
+            ; wait for tod to count 1s
+        }
+
+        ;  cal=CIA2.ta_lo;
+        ;  cah=CIA2.ta_hi;
+        cbl = c64.CIA2TBL
+        ;  cbh=CIA2.tb_hi;
+
+        ;  printf("count2 = %d %d %d %d\n",cah, cal, cbh, cbl);
+        ;  printf("elapsed ~= %d0ms\n",CNT-cbl);
+
+        if CNT - cbl > 90
+            return 50
+        else
+            return 60
+    }
+}

benchmark-c/crc16.p8

@@ -0,0 +1,71 @@
+%import textio
+%import ciatimer
+
+; note: Prog8 has a complete CRC16 routine in its library: math.crc16
+
+
+main {
+    sub start() {
+        txt.lowercase()
+        cia.calibrate()
+        test.benchmark_name()
+        test.benchmark()
+        void test.benchmark_check()
+        cia.print_time()
+        repeat {}
+    }    
+}
+
+test {
+
+    const uword EXPECTED = $ffd0
+    uword crc_result
+
+    sub benchmark_name()
+    {
+        txt.print("crc16.p8\n")
+        txt.print("Calculates the CRC16 of the C64 Kernal\n")
+    }
+
+    sub benchmark()
+    {
+        crc_result = CRC16($e000, $2000)
+    }
+    
+    sub benchmark_check() -> bool
+    {
+        txt.print("CRC=")
+        txt.print_uwhex(crc_result, true)
+
+        if crc_result == EXPECTED
+        {
+            txt.print(" [OK]\n")
+            return false
+        }
+
+        txt.print(" [FAIL] - expected ")
+        txt.print_uwhex(EXPECTED, true)
+        txt.nl()
+        return true
+    }
+    
+    sub CRC16(^^ubyte data, uword length) -> uword {
+        ; CRC-16/XMODEM
+        uword crc
+
+        repeat length
+        {
+            crc ^= mkword(@(data),0)     ; currently there's no easy way to affect only the MSB of the variable
+
+            repeat 8
+            {
+                crc <<=1
+                if_cs
+                    crc ^= $1021
+            }
+            data++
+        }
+        return crc
+    }
+
+}

benchmark-c/crc32.p8

@@ -0,0 +1,72 @@
+%import textio
+%import ciatimer
+
+; note: Prog8 has a complete CRC32 routine in its library: math.crc32
+
+
+main {
+    sub start() {
+        txt.lowercase()
+        cia.calibrate()
+        test.benchmark_name()
+        test.benchmark()
+        void test.benchmark_check()
+        cia.print_time()
+        repeat {}
+    }    
+}
+
+test {
+
+    const long EXPECTED = $e1fa84c6
+    long crc_result
+
+    sub benchmark_name()
+    {
+        txt.print("crc32.p8\n")
+        txt.print("Calculates the CRC32 of the C64 Kernal\n")
+    }
+
+    sub benchmark()
+    {
+        crc_result = CRC32($e000, $2000)
+    }
+    
+    sub benchmark_check() -> bool
+    {
+        txt.print("CRC=")
+        txt.print_ulhex(crc_result, true)
+
+        if crc_result == EXPECTED
+        {
+            txt.print(" [OK]\n")
+            return false
+        }
+
+        txt.print(" [FAIL] - expected ")
+        txt.print_ulhex(EXPECTED, true)
+        txt.nl()
+        return true
+    }
+    
+    sub CRC32(^^ubyte data, uword length) -> long {
+        ; CRC-32/CKSUM
+        long crc
+
+        repeat length
+        {
+            crc ^= (@(data) as long)<<24     ; currently there's no easy way to affect only the MSB of the variable
+
+            repeat 8
+            {
+                crc <<=1
+                if_cs
+                    crc ^= $04c11db7
+            }
+            data++
+        }
+        crc ^= $ffffffff
+        return crc
+    }
+
+}

benchmark-c/crc8.p8

@@ -0,0 +1,72 @@
+%import textio
+%import ciatimer
+
+
+main {
+    sub start() {
+        txt.lowercase()
+        cia.calibrate()
+        test.benchmark_name()
+        test.benchmark()
+        void test.benchmark_check()
+        cia.print_time()
+        repeat {}
+    }    
+}
+
+
+test {
+
+    sub benchmark_name()
+    {
+        txt.print("crc8.p8\n")
+        txt.print("Calculates the CRC8 of the C64 Kernal\n")
+    }
+
+    sub benchmark()
+    {
+        crc_result = CRC8($e000, $2000)
+    }
+    
+    sub benchmark_check() -> bool
+    {
+        txt.print("CRC=")
+        txt.print_ubhex(crc_result, true)
+
+        if crc_result == EXPECTED
+        {
+            txt.print(" [OK]\n")
+            return false
+        }
+
+        txt.print(" [FAIL] - expected ")
+        txt.print_ubhex(EXPECTED, true)
+        txt.nl()
+        return true
+    }
+    
+
+    const ubyte EXPECTED = $a2
+    ubyte crc_result
+
+    sub CRC8(^^ubyte data, uword length) -> ubyte
+    {
+        ; CRC-8/GSM-A
+        ubyte crc
+
+        repeat length
+        {
+            crc ^= @(data)
+
+            repeat 8
+            {
+                if (crc & $80) != 0
+                    crc = (crc << 1) ^ $1d
+                else
+                    crc <<= 1
+            }
+            data++
+        }
+        return crc
+    }
+}

benchmark-c/pow.p8

@@ -0,0 +1,93 @@
+%import textio
+%import floats
+%import ciatimer
+
+
+main {
+    sub start() {
+        txt.lowercase()
+        cia.calibrate()
+        test.benchmark_name()
+        test.benchmark()
+        void test.benchmark_check()
+        cia.print_time()
+        repeat {}
+    }    
+}
+
+test {
+
+    const ubyte N_ITER = 10
+    const ubyte SIZE = 32
+    float[SIZE] array
+
+    const float expected = 3614007361536.000000
+    const float epsilon = 10000000
+    float res
+
+    sub benchmark_name()
+    {
+        txt.print("pow.p8\n")
+        txt.print("Calculates floating point exponential (")
+        txt.print_uw(N_ITER)
+        txt.print(" iterations)\n")
+    }
+
+    sub benchmark()
+    {
+        ubyte i,j
+        res = 0
+        
+        for j in 0 to SIZE-1 {
+            array[j]=0
+        }
+
+        for i in 0 to N_ITER-1 {
+            for j in 0 to SIZE-1 {
+                array[j] += testpow(2.5 / ((i + 1) as float), j)
+            }
+        }
+        
+        for j in 0 to SIZE-1 {
+            res += array[j]
+        }
+    }
+
+    sub testpow(float x, ubyte y) -> float
+    {
+        float tmp = x
+    
+        if y == 0
+            return 1
+    
+        repeat y-1
+            tmp *= x
+    
+        return tmp
+    }
+
+
+    sub benchmark_check() -> bool
+    {
+        txt.print("res      = ")
+        txt.print_f(res)
+        float diff = expected - res;
+        txt.print("\nexpected = ")
+        txt.print_f(expected)
+        txt.print("\nepsilon  = ")
+        txt.print_f(epsilon)
+        txt.print("\ndiff     = ")
+        txt.print_f(diff)
+
+        if (diff < epsilon and diff > -epsilon)
+        {
+            txt.print(" [OK]\n")
+            return false
+        }
+
+        txt.print("[FAIL]\n")
+        return true
+    }
+    
+
+}

benchmark-c/sieve.p8

@@ -0,0 +1,85 @@
+%import textio
+%import ciatimer
+
+
+main {
+    sub start() {
+        txt.lowercase()
+        cia.calibrate()
+        test.benchmark_name()
+        test.benchmark()
+        void test.benchmark_check()
+        cia.print_time()
+        repeat {}
+    }    
+}
+
+
+test {
+    const ubyte N_ITER = 10
+    const uword SIZE = 8191
+    const uword EXPECTED = 1900
+    uword prime_count
+    ^^bool @zp flags = memory("flags", SIZE, 0)
+
+    sub benchmark_name()
+    {
+        txt.print("sieve.c\n")
+        txt.print("Calculates the primes from 1 to ")
+        txt.print_uw(SIZE * 2 + 2)
+        txt.print(" (")
+        txt.print_ub(N_ITER)
+        txt.print(" iterations)\n")
+    }
+
+    sub benchmark()
+    {
+        repeat N_ITER
+            prime_count = sieve(SIZE)
+    }
+    
+    sub benchmark_check() -> bool
+    {
+        txt.print("count=")
+        txt.print_uw(prime_count)
+
+        if prime_count == EXPECTED
+        {
+            txt.print(" [OK]\n")
+            return false
+        }
+
+        txt.print(" [FAIL] - expected ")
+        txt.print_uw(EXPECTED)
+        txt.nl()
+        return true
+    }
+
+    
+    sub sieve(uword size) -> uword 
+    {
+        uword i, prime, k
+        uword count = 1
+
+        for i in 0 to size-1
+            flags[i] = true
+
+        for i in 0 to size-1 
+        {
+            if flags[i]
+            {
+                prime = i + i + 3
+                k = i + prime
+                while k < size
+                {
+                    flags[k] = false
+                    k += prime
+                }
+                count++
+            }
+        }
+    
+        return count
+    }
+
+}

benchmark-c/sieve_bit.p8

@@ -0,0 +1,107 @@
+%import textio
+%import ciatimer
+
+
+main {
+    sub start() {
+        txt.lowercase()
+        cia.calibrate()
+        test.benchmark_name()
+        test.benchmark()
+        void test.benchmark_check()
+        cia.print_time()
+        repeat {}
+    }    
+}
+
+
+test {
+    const ubyte N_ITER = 4
+    const uword SIZE = 16000
+    const uword EXPECTED = 3432
+    uword prime_count
+    ^^ubyte @zp flags = memory("flags", SIZE/8+1, 0)
+
+    sub benchmark_name()
+    {
+        txt.print("sieve_bit.p8\n")
+        txt.print("Calculates the primes from 1 to ")
+        txt.print_uw(SIZE * 2 + 2)
+        txt.print(" (")
+        txt.print_ub(N_ITER)
+        txt.print(" iterations)\n")
+    }
+
+    sub benchmark()
+    {
+        repeat N_ITER
+            prime_count = sieve(SIZE)
+    }
+    
+    sub benchmark_check() -> bool
+    {
+        txt.print("count=")
+        txt.print_uw(prime_count)
+
+        if prime_count == EXPECTED
+        {
+            txt.print(" [OK]\n")
+            return false
+        }
+
+        txt.print(" [FAIL] - expected ")
+        txt.print_uw(EXPECTED)
+        txt.nl()
+        return true
+    }
+
+    ubyte[] bitv = [
+        $01,    
+        $02,
+        $04,
+        $08,
+        $10,
+        $20,
+        $40,
+        $80
+    ]
+
+    sub check_flag(uword idx) -> bool
+    {
+        return flags[idx / 8] & bitv[lsb(idx) & 7] != 0
+    }
+
+    sub clear_flag(uword idx)
+    {
+        flags[idx / 8] &= ~(bitv[lsb(idx) & 7])
+    }
+
+    
+    sub sieve(uword size) -> uword 
+    {
+        uword i, prime, k
+        uword count=1
+    
+        for i in 0 to (size / 8)
+            flags[i] = $ff
+
+        for i in 0 to size-1
+        {
+            if check_flag(i)
+            {
+                prime = i + i + 3
+                k = i + prime;
+                while k < size
+                {
+                    clear_flag(k)
+                    k += prime
+                }
+                count++
+            }
+        }
+
+   
+        return count
+    }
+
+}

benchmark-program/b_adpcm.p8

@@ -7,7 +7,7 @@ adpcm {
 
         while cbm.RDTIM16()<max_time {
             adpcm.init(0,0)
-            uword @requirezp nibbles_ptr = $a000 ; for benchmark purposes, the exact nibbles don't really matter, so we just take the basic ROM as input
+            uword @requirezp nibbles_ptr = $0800 ; for benchmark purposes, the exact nibbles don't really matter, so we just take this benchmark program itself as input
             repeat 252/2 {
                 unroll 2 {
                     ubyte @zp nibble = @(nibbles_ptr)

benchmark-program/b_textelite.p8

@@ -472,7 +472,7 @@ elite_galaxy {
             generate_next_planet()
             textelite.num_commands++
         }
-        elite_planet.name = make_current_planet_name()
+        void strings.copy(make_current_planet_name(), elite_planet.name)
         init_market_for_planet()
     }
 
@@ -494,7 +494,7 @@ elite_galaxy {
         ubyte pi
         for pi in 0 to 255 {
             generate_next_planet()
-            elite_planet.name = make_current_planet_name()
+            void strings.copy(make_current_planet_name(), elite_planet.name)
             if elite_util.prefix_matches(nameptr, elite_planet.name) {
                 ubyte distance = elite_planet.distance(x, y)
                 if distance < current_distance {
@@ -532,7 +532,7 @@ elite_galaxy {
 ;                else
 ;                    txt.chrout('-')
 ;                txt.spc()
-                elite_planet.name = make_current_planet_name()
+                void strings.copy(make_current_planet_name(), elite_planet.name)
                 elite_planet.display(true, distance)
             }
             pn++
@@ -548,7 +548,7 @@ elite_galaxy {
         str current_name = "        "       ; 8 max
         ubyte pn = 0
 
-        current_name = elite_planet.name
+        void strings.copy(elite_planet.name, current_name)
         init(number)
 ;        txt.clear_screen()
 ;        txt.print("Galaxy #")
@@ -569,7 +569,7 @@ elite_galaxy {
             generate_next_planet()
             ubyte distance = elite_planet.distance(px, py)
             if distance <= max_distance {
-                elite_planet.name = make_current_planet_name()
+                void strings.copy(make_current_planet_name(), elite_planet.name)
                 elite_planet.name[0] = strings.upperchar(elite_planet.name[0])
                 uword tx = elite_planet.x
                 uword ty = elite_planet.y

benchmark-program/benchmark.p8

@@ -35,7 +35,7 @@ main {
         txt.color2(1, 6)
         txt.clear_screen()
 
-        txt.print("\n\n\n  prog8 compiler benchmark tests.\n")
+        txt.print("\n\n\n  prog8 compiler benchmark tests.\n\n  benchmark version v12\n\n")
         sys.wait(60)
 
         benchmark_number = 0
@@ -65,7 +65,7 @@ main {
         benchmark_number++
 
         announce_benchmark("circles with gfx_lores")
-        benchmark_score[benchmark_number]  = circles.draw(false, 300)
+        benchmark_score[benchmark_number]  = circles.draw(false, 400)
         benchmark_number++
 
         announce_benchmark("text-elite")
@@ -88,7 +88,7 @@ main {
         txt.color2(1, 6)
         uword total_score
         benchmark_number = 0
-        txt.print("\nscore benchmark\n\n")
+        txt.print("\nscore benchmark (v12)\n\n")
         do {
             txt.spc()
             txt.print_uw(benchmark_score[benchmark_number])

build.gradle.kts

@@ -5,7 +5,7 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 
 
 plugins {
-    kotlin("jvm") version "2.2.20"
+    kotlin("jvm") version "2.2.21"
 }
 
 allprojects {

codeCore/src/prog8/code/core/BuiltinFunctions.kt

@@ -37,6 +37,7 @@ class FSignature(val pure: Boolean,      // does it have side effects?
         val returns: ReturnConvention = when (returnType) {
             BaseDataType.UBYTE, BaseDataType.BYTE -> ReturnConvention(returnType, RegisterOrPair.A)
             BaseDataType.UWORD, BaseDataType.WORD -> ReturnConvention(returnType, RegisterOrPair.AY)
+            BaseDataType.LONG -> ReturnConvention(returnType, RegisterOrPair.R14R15_32)
             BaseDataType.FLOAT -> ReturnConvention(returnType, RegisterOrPair.FAC1)
             in IterableDatatypes -> ReturnConvention(returnType!!, RegisterOrPair.AY)
             null -> ReturnConvention(null, null)
@@ -45,6 +46,7 @@ class FSignature(val pure: Boolean,      // does it have side effects?
                 when (val paramType = actualParamTypes.first()) {
                     BaseDataType.UBYTE, BaseDataType.BYTE -> ReturnConvention(paramType, RegisterOrPair.A)
                     BaseDataType.UWORD, BaseDataType.WORD -> ReturnConvention(paramType, RegisterOrPair.AY)
+                    BaseDataType.LONG -> ReturnConvention(returnType, RegisterOrPair.R14R15_32)
                     BaseDataType.FLOAT -> ReturnConvention(paramType, RegisterOrPair.FAC1)
                     in IterableDatatypes -> ReturnConvention(paramType, RegisterOrPair.AY)
                     else -> ReturnConvention(paramType, null)
@@ -61,6 +63,7 @@ class FSignature(val pure: Boolean,      // does it have side effects?
                 val paramConv = when(val paramType = actualParamTypes[0]) {
                     BaseDataType.UBYTE, BaseDataType.BYTE -> ParamConvention(paramType, RegisterOrPair.A, false)
                     BaseDataType.UWORD, BaseDataType.WORD -> ParamConvention(paramType, RegisterOrPair.AY, false)
+                    BaseDataType.LONG -> ParamConvention(paramType, RegisterOrPair.R14R15_32, false)
                     BaseDataType.FLOAT -> ParamConvention(paramType, RegisterOrPair.AY, false)      // NOTE: for builtin functions, floating point arguments are passed by reference (so you get a pointer in AY)
                     in IterableDatatypes -> ParamConvention(paramType, RegisterOrPair.AY, false)
                     else -> ParamConvention(paramType, null, false)
@@ -88,11 +91,11 @@ class FSignature(val pure: Boolean,      // does it have side effects?
 val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "setlsb"  to FSignature(false, null, FParam("variable", BaseDataType.WORD, BaseDataType.UWORD), FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
     "setmsb"  to FSignature(false, null, FParam("variable", BaseDataType.WORD, BaseDataType.UWORD), FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
-    "rol"     to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
-    "ror"     to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
-    "rol2"    to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
-    "ror2"    to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
-    "cmp"     to FSignature(false, null, FParam("value1", *IntegerDatatypes), FParam("value2", *NumericDatatypes)),  // cmp returns a status in the carry flag, but not a proper return value
+    "rol"     to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD, BaseDataType.LONG)),
+    "ror"     to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD, BaseDataType.LONG)),
+    "rol2"    to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD, BaseDataType.LONG)),
+    "ror2"    to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD, BaseDataType.LONG)),
+    "cmp"     to FSignature(false, null, FParam("value1", *IntegerDatatypes), FParam("value2", *NumericDatatypes)),  // cmp returns result in the cpu status flags, but not asa proper return value
     "prog8_lib_stringcompare"     to FSignature(true, BaseDataType.BYTE, FParam("str1", BaseDataType.STR), FParam("str2", BaseDataType.STR)),
     "prog8_lib_square_byte"       to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
     "prog8_lib_square_word"       to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.WORD, BaseDataType.UWORD)),
@@ -100,6 +103,7 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "abs"           to FSignature(true, null, FParam("value", *NumericDatatypes)),
     "abs__byte"     to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.BYTE)),
     "abs__word"     to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.WORD)),
+    "abs__long"     to FSignature(true, BaseDataType.LONG, FParam("value", BaseDataType.LONG)),
     "abs__float"    to FSignature(true, BaseDataType.FLOAT, FParam("value", BaseDataType.FLOAT)),
     "len"           to FSignature(true, BaseDataType.UWORD, FParam("values", *IterableDatatypes)),
     "sizeof"        to FSignature(true, BaseDataType.UBYTE, FParam("object", *(BaseDataType.entries - BaseDataType.STRUCT_INSTANCE).toTypedArray())),
@@ -108,39 +112,47 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "sqrt"          to FSignature(true, null, FParam("value", *NumericDatatypes)),
     "sqrt__ubyte"   to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.UBYTE)),
     "sqrt__uword"   to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.UWORD)),
+    "sqrt__long"    to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.LONG)),
     "sqrt__float"   to FSignature(true, BaseDataType.FLOAT, FParam("value", BaseDataType.FLOAT)),
     "divmod"        to FSignature(false, null, FParam("dividend", BaseDataType.UBYTE, BaseDataType.UWORD), FParam("divisor", BaseDataType.UBYTE, BaseDataType.UWORD), FParam("quotient", BaseDataType.UBYTE, BaseDataType.UWORD), FParam("remainder", BaseDataType.UBYTE, BaseDataType.UWORD)),
     "divmod__ubyte" to FSignature(false, null, FParam("dividend", BaseDataType.UBYTE), FParam("divisor", BaseDataType.UBYTE), FParam("quotient", BaseDataType.UBYTE), FParam("remainder", BaseDataType.UBYTE)),
     "divmod__uword" to FSignature(false, null, FParam("dividend", BaseDataType.UWORD), FParam("divisor", BaseDataType.UWORD), FParam("quotient", BaseDataType.UWORD), FParam("remainder", BaseDataType.UWORD)),
     "lsb"           to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
-    "lsw"           to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
+    "lsb__long"     to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.LONG)),
     "msb"           to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
+    "msb__long"     to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.LONG)),
+    "lsw"           to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
     "msw"           to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
     "mkword"        to FSignature(true, BaseDataType.UWORD, FParam("msb", BaseDataType.UBYTE), FParam("lsb", BaseDataType.UBYTE)),
+    "mklong"        to FSignature(true, BaseDataType.LONG, FParam("msb", BaseDataType.UBYTE), FParam("b2", BaseDataType.UBYTE), FParam("b1", BaseDataType.UBYTE), FParam("lsb", BaseDataType.UBYTE)),
+    "mklong2"       to FSignature(true, BaseDataType.LONG, FParam("msw", BaseDataType.UWORD), FParam("lsw", BaseDataType.UWORD)),
     "clamp"         to FSignature(true, null, FParam("value", BaseDataType.BYTE), FParam("minimum", BaseDataType.BYTE), FParam("maximum", BaseDataType.BYTE)),
     "clamp__byte"   to FSignature(true, BaseDataType.BYTE, FParam("value", BaseDataType.BYTE), FParam("minimum", BaseDataType.BYTE), FParam("maximum", BaseDataType.BYTE)),
     "clamp__ubyte"  to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.UBYTE), FParam("minimum", BaseDataType.UBYTE), FParam("maximum", BaseDataType.UBYTE)),
     "clamp__word"   to FSignature(true, BaseDataType.WORD, FParam("value", BaseDataType.WORD), FParam("minimum", BaseDataType.WORD), FParam("maximum", BaseDataType.WORD)),
     "clamp__uword"  to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.UWORD), FParam("minimum", BaseDataType.UWORD), FParam("maximum", BaseDataType.UWORD)),
+    "clamp__long"   to FSignature(true, BaseDataType.LONG, FParam("value", BaseDataType.LONG), FParam("minimum", BaseDataType.LONG), FParam("maximum", BaseDataType.LONG)),
     "min"           to FSignature(true, null, FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
     "min__byte"     to FSignature(true, BaseDataType.BYTE, FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
     "min__ubyte"    to FSignature(true, BaseDataType.UBYTE, FParam("val1", BaseDataType.UBYTE), FParam("val2", BaseDataType.UBYTE)),
     "min__word"     to FSignature(true, BaseDataType.WORD, FParam("val1", BaseDataType.WORD), FParam("val2", BaseDataType.WORD)),
     "min__uword"    to FSignature(true, BaseDataType.UWORD, FParam("val1", BaseDataType.UWORD), FParam("val2", BaseDataType.UWORD)),
+    "min__long"     to FSignature(true, BaseDataType.LONG, FParam("val1", BaseDataType.LONG), FParam("val2", BaseDataType.LONG)),
     "max"           to FSignature(true, null, FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
     "max__byte"     to FSignature(true, BaseDataType.BYTE, FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
     "max__ubyte"    to FSignature(true, BaseDataType.UBYTE, FParam("val1", BaseDataType.UBYTE), FParam("val2", BaseDataType.UBYTE)),
     "max__word"     to FSignature(true, BaseDataType.WORD, FParam("val1", BaseDataType.WORD), FParam("val2", BaseDataType.WORD)),
     "max__uword"    to FSignature(true, BaseDataType.UWORD, FParam("val1", BaseDataType.UWORD), FParam("val2", BaseDataType.UWORD)),
+    "max__long"     to FSignature(true, BaseDataType.LONG, FParam("val1", BaseDataType.LONG), FParam("val2", BaseDataType.LONG)),
     "peek"          to FSignature(true, BaseDataType.UBYTE, FParam("address", BaseDataType.UWORD)),
     "peekbool"      to FSignature(true, BaseDataType.BOOL, FParam("address", BaseDataType.UWORD)),
     "peekw"         to FSignature(true, BaseDataType.UWORD, FParam("address", BaseDataType.UWORD)),
     "peekl"         to FSignature(true, BaseDataType.LONG, FParam("address", BaseDataType.UWORD)),
     "peekf"         to FSignature(true, BaseDataType.FLOAT, FParam("address", BaseDataType.UWORD)),
-    "poke"          to FSignature(false, null, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.UBYTE)),
+    "poke"          to FSignature(false, null, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.UBYTE, BaseDataType.BYTE)),
     "pokebool"      to FSignature(false, null, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.BOOL)),
     "pokebowl"      to FSignature(false, null, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.BOOL)),
-    "pokew"         to FSignature(false, null, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.UWORD)),
+    "pokew"         to FSignature(false, null, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.UWORD, BaseDataType.WORD)),
     "pokel"         to FSignature(false, null, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.LONG)),
     "pokef"         to FSignature(false, null, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.FLOAT)),
     "pokemon"       to FSignature(false, BaseDataType.UBYTE, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.UBYTE)),

codeCore/src/prog8/code/core/CompilationOptions.kt

@@ -13,6 +13,7 @@ class CompilationOptions(val output: OutputType,
                          val noSysInit: Boolean,
                          val romable: Boolean,
                          val compTarget: ICompilationTarget,
+                         val compilerVersion: String,
                          // these are set later, based on command line arguments or options in the source code:
                          var loadAddress: UInt,
                          var memtopAddress: UInt,
@@ -28,7 +29,6 @@ class CompilationOptions(val output: OutputType,
                          var varsGolden: Boolean = false,
                          var slabsHighBank: Int? = null,
                          var slabsGolden: Boolean = false,
-                         var dontSplitWordArrays: Boolean = false,
                          var breakpointCpuInstruction: String? = null,
                          var ignoreFootguns: Boolean = false,
                          var outputDir: Path = Path(""),

codeCore/src/prog8/code/core/Conversions.kt

@@ -13,9 +13,12 @@ fun Number.toHex(): String {
     //  256..65536 -> "$0100".."$ffff"
     //  larger -> "$12345678"
     // negative values are prefixed with '-'.
-    val integer = this.toInt()
-    if(integer<0)
+    val integer = this.toLong()
+    if(integer<0) {
+        if(integer==-2147483648L)
+            return "$80000000"      // the exception to the rule, because -$80000000 is not a valid hex number
         return '-' + abs(integer).toHex()
+    }
     return when (integer) {
         in 0 until 16 -> integer.toString()
         in 0 until 0x100 -> "$"+integer.toString(16).padStart(2,'0')

codeCore/src/prog8/code/core/Enumerations.kt

@@ -50,8 +50,10 @@ enum class BaseDataType {
 val BaseDataType.isByte get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE)
 val BaseDataType.isByteOrBool get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.BOOL)
 val BaseDataType.isWord get() = this in arrayOf(BaseDataType.UWORD, BaseDataType.WORD)
+val BaseDataType.isLong get() = this == BaseDataType.LONG
 val BaseDataType.isInteger get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)
 val BaseDataType.isIntegerOrBool get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.BOOL)
+val BaseDataType.isWordOrByteOrBool get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.BOOL)
 val BaseDataType.isNumeric get() = this == BaseDataType.FLOAT || this.isInteger
 val BaseDataType.isNumericOrBool get() = this == BaseDataType.BOOL || this.isNumeric
 val BaseDataType.isSigned get() = this in arrayOf(BaseDataType.BYTE, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
@@ -143,7 +145,7 @@ class DataType private constructor(val base: BaseDataType, val sub: BaseDataType
             return if(splitwordarray && actualElementDt.isWord)
                 DataType(BaseDataType.ARRAY_SPLITW, actualElementDt, null)
             else {
-                if(actualElementDt.isNumericOrBool && actualElementDt != BaseDataType.LONG)
+                if(actualElementDt.isNumericOrBool)
                     DataType(BaseDataType.ARRAY, actualElementDt, null)
                 else
                     throw NoSuchElementException("invalid basic element dt $elementDt")
@@ -222,6 +224,7 @@ class DataType private constructor(val base: BaseDataType, val sub: BaseDataType
                 BaseDataType.WORD -> "word[]"
                 BaseDataType.UBYTE -> "ubyte[]"
                 BaseDataType.UWORD -> "uword[]"
+                BaseDataType.LONG -> "long[]"
                 else -> throw IllegalArgumentException("invalid sub type")
             }
         }
@@ -284,6 +287,7 @@ class DataType private constructor(val base: BaseDataType, val sub: BaseDataType
                 BaseDataType.BOOL -> "bool["
                 BaseDataType.BYTE -> "byte["
                 BaseDataType.WORD -> "@nosplit word["
+                BaseDataType.LONG -> "long["
                 BaseDataType.FLOAT -> "float["
                 else -> throw IllegalArgumentException("invalid sub type")
             }
@@ -344,6 +348,7 @@ class DataType private constructor(val base: BaseDataType, val sub: BaseDataType
     val isUnsignedWord =  base == BaseDataType.UWORD
     val isSignedWord =  base == BaseDataType.WORD
     val isInteger = base.isInteger
+    val isWordOrByteOrBool = base.isWordOrByteOrBool
     val isIntegerOrBool = base.isIntegerOrBool
     val isNumeric = base.isNumeric
     val isNumericOrBool = base.isNumericOrBool
@@ -362,6 +367,7 @@ class DataType private constructor(val base: BaseDataType, val sub: BaseDataType
     val isWordArray = base.isArray && !base.isPointerArray && (sub == BaseDataType.UWORD || sub == BaseDataType.WORD)
     val isUnsignedWordArray = base.isArray && !base.isPointerArray && sub == BaseDataType.UWORD
     val isSignedWordArray = base.isArray && !base.isPointerArray && sub == BaseDataType.WORD
+    val isLongArray = base.isArray && sub == BaseDataType.LONG
     val isFloatArray = base.isArray && !base.isPointerArray && sub == BaseDataType.FLOAT
     val isString = base == BaseDataType.STR
     val isBool = base == BaseDataType.BOOL
@@ -394,7 +400,9 @@ enum class RegisterOrPair {
     FAC2,
     // cx16 virtual registers:
     R0, R1, R2, R3, R4, R5, R6, R7,
-    R8, R9, R10, R11, R12, R13, R14, R15;
+    R8, R9, R10, R11, R12, R13, R14, R15,
+    // combined virtual registers to store 32 bits longs:
+    R0R1_32, R2R3_32, R4R5_32, R6R7_32, R8R9_32, R10R11_32, R12R13_32, R14R15_32;
 
     companion object {
         val names by lazy { entries.map { it.toString()} }
@@ -407,6 +415,18 @@ enum class RegisterOrPair {
         }
     }
 
+    fun startregname() = when(this) {
+        R0R1_32 -> "r0"
+        R2R3_32 -> "r2"
+        R4R5_32 -> "r4"
+        R6R7_32 -> "r6"
+        R8R9_32 -> "r8"
+        R10R11_32 -> "r10"
+        R12R13_32 -> "r12"
+        R14R15_32 -> "r14"
+        else -> throw IllegalArgumentException("must be a combined virtual register $this")
+    }
+
     fun asCpuRegister(): CpuRegister = when(this) {
         A -> CpuRegister.A
         X -> CpuRegister.X
@@ -420,13 +440,14 @@ enum class RegisterOrPair {
             BaseDataType.UBYTE, BaseDataType.BOOL -> "L"
             BaseDataType.BYTE -> "sL"
             BaseDataType.WORD -> "s"
-            BaseDataType.UWORD, null -> ""
-            else -> throw IllegalArgumentException("invalid register param type")
+            BaseDataType.UWORD, BaseDataType.POINTER, null -> ""
+            else -> throw IllegalArgumentException("invalid register param type for cx16 virtual reg")
         }
         return listOf("cx16", name.lowercase()+suffix)
     }
 
     fun isWord() = this==AX || this == AY || this==XY || this in Cx16VirtualRegisters
+    fun isLong() = this in combinedLongRegisters
 
 }       // only used in parameter and return value specs in asm subroutines
 
@@ -463,6 +484,17 @@ val Cx16VirtualRegisters = arrayOf(
     RegisterOrPair.R12, RegisterOrPair.R13, RegisterOrPair.R14, RegisterOrPair.R15
 )
 
+val combinedLongRegisters = arrayOf(
+    RegisterOrPair.R0R1_32,
+    RegisterOrPair.R2R3_32,
+    RegisterOrPair.R4R5_32,
+    RegisterOrPair.R6R7_32,
+    RegisterOrPair.R8R9_32,
+    RegisterOrPair.R10R11_32,
+    RegisterOrPair.R12R13_32,
+    RegisterOrPair.R14R15_32
+)
+
 val CpuRegisters = arrayOf(
     RegisterOrPair.A, RegisterOrPair.X, RegisterOrPair.Y,
     RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY
@@ -498,6 +530,5 @@ enum class ZeropageWish {
 
 enum class SplitWish {
     DONTCARE,
-    SPLIT,
     NOSPLIT
 }

codeCore/src/prog8/code/core/Position.kt

@@ -6,7 +6,15 @@ import java.nio.file.InvalidPathException
 import kotlin.io.path.Path
 
 data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) {
-    override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]"
+    override fun toString(): String = "[$file: line $line col ${startCol}-${endCol}]"
+
+    init {
+        if(!file.startsWith('~') ||!file.endsWith('~'))
+            require(line>0 && startCol>=0 && endCol>=startCol) {
+                "Invalid position: $this"
+            }
+    }
+
     fun toClickableStr(): String {
         if(this===DUMMY)
             return ""

codeCore/src/prog8/code/target/NormalMemSizer.kt

@@ -14,6 +14,7 @@ internal class NormalMemSizer(val floatsize: Int): IMemSizer {
             return when(dt.sub) {
                 BaseDataType.BOOL, BaseDataType.UBYTE, BaseDataType.BYTE -> numElements
                 BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.STR -> numElements * 2
+                BaseDataType.LONG -> numElements * 4
                 BaseDataType.FLOAT-> numElements * floatsize
                 BaseDataType.UNDEFINED -> throw IllegalArgumentException("undefined has no memory size")
                 else -> throw IllegalArgumentException("invalid sub type")

codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt

@@ -451,7 +451,7 @@ class AsmGen6502Internal (
             if(line.length>=4 && invalid.matchesAt(line, 0)) {
                 errors.err(
                     "invalid assembly instruction used (not compatible with the 65816 CPU): ${line.trim()}",
-                    Position("<output-assemblycode>", index, 1, 1)
+                    Position("~output-assemblycode~", index+1, 1, 1)
                 )
             }
         }
@@ -758,6 +758,15 @@ class AsmGen6502Internal (
                     CpuRegister.Y -> out(" tay")
                 }
             }
+            expr.type.isLong -> {
+                assignExpressionToRegister(expr.index, RegisterOrPair.A)
+                out("  asl  a |  asl  a")
+                when (register) {
+                    CpuRegister.A -> {}
+                    CpuRegister.X -> out(" tax")
+                    CpuRegister.Y -> out(" tay")
+                }
+            }
             expr.type.isFloat -> {
                 if(options.compTarget.FLOAT_MEM_SIZE != 5)
                     TODO("support float size other than 5 ${expr.position}")
@@ -806,6 +815,7 @@ class AsmGen6502Internal (
             RegisterOrPair.AY,
             RegisterOrPair.XY -> assignmentAsmGen.assignRegisterpairWord(target, reg)
             in Cx16VirtualRegisters -> assignmentAsmGen.assignVirtualRegister(target, reg)
+            in combinedLongRegisters -> assignmentAsmGen.assignVirtualRegister(target, reg)
             RegisterOrPair.FAC1 -> assignmentAsmGen.assignFAC1float(target)
             RegisterOrPair.FAC2 -> assignmentAsmGen.assignFAC2float(target)
             else -> throw AssemblyError("invalid register")
@@ -843,7 +853,7 @@ class AsmGen6502Internal (
                             return
                         }
                         TargetStorageKind.POINTER -> {
-                            TODO("assign to pointer ${target.position}")
+                            pointerGen.assignByte(PtrTarget(target), 0)
                             return
                         }
                         else -> { }
@@ -853,7 +863,10 @@ class AsmGen6502Internal (
                 assignExpressionToRegister(value, RegisterOrPair.A)
                 assignmentAsmGen.assignRegisterByte(target, CpuRegister.A, target.datatype.isSigned, false)
             }
-            target.datatype.isPointer -> TODO("assign expression to pointer ${target.position}")
+            target.datatype.isPointer -> {
+                assignExpressionToRegister(value, RegisterOrPair.AX)
+                pointerGen.assignWordReg(PtrTarget(target), RegisterOrPair.AX)
+            }
             target.datatype.isWord || target.datatype.isPassByRef -> {
                 assignExpressionToRegister(value, RegisterOrPair.AY)
                 translateNormalAssignment(
@@ -863,6 +876,102 @@ class AsmGen6502Internal (
                     ), value.definingISub()
                 )
             }
+            target.datatype.isLong -> {
+                if(value is PtNumber) {
+                    val hex = value.asConstInteger()!!.toLongHex()
+                    when(target.kind) {
+                        TargetStorageKind.VARIABLE -> {
+                            out("""
+                                lda  #$${hex.substring(6,8)}
+                                sta  ${target.asmVarname}
+                                lda  #$${hex.substring(4, 6)}
+                                sta  ${target.asmVarname}+1
+                                lda  #$${hex.substring(2, 4)}
+                                sta  ${target.asmVarname}+2
+                                lda  #$${hex.take(2)}
+                                sta  ${target.asmVarname}+3""")
+                        }
+                        TargetStorageKind.ARRAY -> TODO("assign long to array  ${target.position}")
+                        TargetStorageKind.MEMORY -> throw AssemblyError("memory is bytes not long ${target.position}")
+                        TargetStorageKind.REGISTER -> assignExpressionToRegister(value, target.register!!, true)
+                        TargetStorageKind.POINTER -> pointerGen.assignLong(target.pointer!!, value.number.toInt())
+                        TargetStorageKind.VOID -> { /* do nothing */ }
+                    }
+                } else if(value is PtIdentifier && value.type.isLong) {
+                    when (target.kind) {
+                        TargetStorageKind.VARIABLE -> {
+                            val valuesym = asmSymbolName(value)
+                            out(
+                                """
+                                lda  $valuesym
+                                sta  ${target.asmVarname}
+                                lda  $valuesym+1
+                                sta  ${target.asmVarname}+1
+                                lda  $valuesym+2
+                                sta  ${target.asmVarname}+2
+                                lda  $valuesym+3
+                                sta  ${target.asmVarname}+3"""
+                            )
+                        }
+
+                        TargetStorageKind.ARRAY -> TODO("assign long to array  ${target.position}")
+                        TargetStorageKind.MEMORY -> throw AssemblyError("memory is bytes not long ${target.position}")
+                        TargetStorageKind.REGISTER -> assignExpressionToRegister(value, target.register!!, true)
+                        TargetStorageKind.POINTER -> pointerGen.assignLongVar(target.pointer!!, asmSymbolName(value))
+                        TargetStorageKind.VOID -> { /* do nothing */ }
+                    }
+                } else if(value is PtTypeCast && value.type.isLong) {
+                    if(value.value is PtIdentifier) {
+                        val valuesym = asmSymbolName((value.value as PtIdentifier).name)
+                        if(value.value.type.isByte) {
+                            when (target.kind) {
+                                TargetStorageKind.VARIABLE -> {
+                                    out("  lda  $valuesym |  sta  ${target.asmVarname}")
+                                    signExtendLongVariable(target.asmVarname, value.value.type.base)
+                                }
+                                TargetStorageKind.ARRAY -> TODO("assign typecasted long to array  ${target.position}")
+                                TargetStorageKind.MEMORY -> throw AssemblyError("memory is bytes not long ${target.position}")
+                                TargetStorageKind.REGISTER -> assignExpressionToRegister(value, target.register!!, true)
+                                TargetStorageKind.POINTER -> TODO("assign typecasted long into pointer  ${target.position}")
+                                TargetStorageKind.VOID -> { /* do nothing */ }
+                            }
+                        } else if(value.value.type.isWord) {
+                            when (target.kind) {
+                                TargetStorageKind.VARIABLE -> {
+                                    out("""
+                                        lda  $valuesym
+                                        sta  ${target.asmVarname}
+                                        lda  $valuesym+1
+                                        sta  ${target.asmVarname}+1""")
+                                    signExtendLongVariable(target.asmVarname, value.value.type.base)
+                                }
+                                TargetStorageKind.ARRAY -> TODO("assign typecasted long to array  ${target.position}")
+                                TargetStorageKind.MEMORY -> throw AssemblyError("memory is bytes not long ${target.position}")
+                                TargetStorageKind.REGISTER -> {
+                                    require(target.register in combinedLongRegisters)
+                                    val startreg = target.register!!.startregname()
+                                    out("""
+                                        lda  $valuesym
+                                        sta  cx16.$startreg
+                                        lda  $valuesym+1
+                                        sta  cx16.$startreg+1""")
+                                    signExtendLongVariable("cx16.$startreg", value.value.type.base)
+                                }
+                                TargetStorageKind.POINTER -> TODO("assign typecasted long into pointer  ${target.position}")
+                                TargetStorageKind.VOID -> { /* do nothing */ }
+                            }
+                        } else throw AssemblyError("weird casted type")
+                    } else {
+                        TODO("assign typecasted expression $value to a long target ${target.kind} at  ${target.position}  - please report this issue. Use simple expressions and temporary variables for now")
+                    }
+                } else if(target.kind == TargetStorageKind.REGISTER) {
+                    assignExpressionToRegister(value, target.register!!, true)
+                } else if(target.kind == TargetStorageKind.VARIABLE) {
+                    assignExpressionToVariable(value, target.asmVarname, target.datatype)
+                } else {
+                    TODO("assign long expression $value to a target ${target.kind} at  ${target.position} - please report this issue. Use simple expressions and temporary variables for now")
+                }
+            }
             target.datatype.isFloat -> {
                 assignExpressionToRegister(value, RegisterOrPair.FAC1)
                 assignRegister(RegisterOrPair.FAC1, target)
@@ -1168,12 +1277,12 @@ $repeatLabel""")
                             // print a message when more optimal code is possible for 65C02 cpu
                             val variable = symbolTable.lookup(arrayVariable.name)!!
                             if(variable is StStaticVariable && variable.length!!<=128u)
-                                errors.info("the jump address array is @split, but @nosplit would create more efficient code here", jump.position)
+                                errors.info("the jump address array is split, but @nosplit would create more efficient code here", jump.position)
                         }
                     } else {
                         // print a message when more optimal code is possible for 6502 cpu
                         if(!arrayIdx.splitWords)
-                            errors.info("the jump address array is @nosplit, but @split would create more efficient code here", jump.position)
+                            errors.info("the jump address array is @nosplit, but split would create more efficient code here", jump.position)
                     }
                 }
                 // we can do the address evaluation right now and just use a temporary pointer variable
@@ -1193,7 +1302,7 @@ $repeatLabel""")
         if(returnvalue!=null) {
             val returnDt = sub.signature.returns.single()
             if (returnDt.isNumericOrBool || returnDt.isPointer) {
-                assignExpressionToRegister(returnvalue, returnRegs.single().first.registerOrPair!!)
+                assignExpressionToRegister(returnvalue, returnRegs.single().first.registerOrPair!!, returnDt.isSigned)
             }
             else {
                 // all else take its address and assign that also to AY register pair
@@ -1214,7 +1323,7 @@ $repeatLabel""")
                 assignExpressionTo(it.first as PtExpression, tgt)
             }
             assigns.first().also {
-                assignExpressionToRegister(it.first as PtExpression, it.second.first.registerOrPair!!)
+                assignExpressionToRegister(it.first as PtExpression, it.second.first.registerOrPair!!, (it.first as PtExpression).type.isSigned)
             }
         }
         out("  rts")
@@ -1300,6 +1409,53 @@ $repeatLabel""")
         }
     }
 
+    internal fun signExtendLongVariable(asmvar: String, valueDt: BaseDataType) {
+        // sign extend signed word in a var to a full long in that variable
+        when(valueDt) {
+            BaseDataType.UBYTE -> {
+                if(isTargetCpu(CpuType.CPU65C02)) {
+                    out("""
+                        stz  $asmvar+1
+                        stz  $asmvar+2
+                        stz  $asmvar+3""")
+                }
+                else {
+                    out("""
+                        lda  #0
+                        sta  $asmvar+1
+                        sta  $asmvar+2
+                        sta  $asmvar+3""")
+                }
+            }
+            BaseDataType.BYTE -> {
+                out("""
+                    lda  $asmvar
+                    ora  #$7f
+                    bmi  +
+                    lda  #0
++                   sta  $asmvar+1
+                    sta  $asmvar+2
+                    sta  $asmvar+3""")
+            }
+            BaseDataType.UWORD -> {
+                if(isTargetCpu(CpuType.CPU65C02))
+                    out("  stz  $asmvar+2 |  stz  $asmvar+3")
+                else
+                    out("  lda  #0 |  sta  $asmvar+2 |  sta  $asmvar+3")
+            }
+            BaseDataType.WORD -> {
+                out("""
+                    lda  $asmvar+1
+                    ora  #$7f
+                    bmi  +
+                    lda  #0
++                   sta  $asmvar+2
+                    sta  $asmvar+3""")
+            }
+            else -> throw AssemblyError("need byte or word type")
+        }
+    }
+
     internal fun isZpVar(variable: PtIdentifier): Boolean = allocator.isZpVar(variable.name)
 
     internal fun jmp(asmLabel: String, indirect: Boolean=false, indexedX: Boolean=false) {
@@ -1375,7 +1531,7 @@ $repeatLabel""")
                 val constOffset = (ptrAndIndex.second as? PtNumber)?.number?.toInt()
                 if(addrOf!=null && constOffset!=null) {
                     if(addrOf.isFromArrayElement) {
-                        TODO("address-of array element $addrOf")
+                        TODO("address-of array element ${addrOf.position}")
                     } else if(addrOf.dereference!=null) {
                         throw AssemblyError("write &dereference, makes no sense at ${addrOf.position}")
                     } else {
@@ -1417,9 +1573,9 @@ $repeatLabel""")
             val constOffset = (ptrAndIndex.second as? PtNumber)?.number?.toInt()
             if(addrOf!=null && constOffset!=null) {
                 if(addrOf.isFromArrayElement) {
-                    TODO("address-of array element $addrOf")
+                    TODO("address-of array element ${addrOf.position}")
                 } else if(addrOf.dereference!=null) {
-                    TODO("read &dereference")
+                    TODO("read &dereference ${addrOf.position}")
                 } else {
                     out("  lda  ${asmSymbolName(addrOf.identifier!!)}+${constOffset}")
                     return true
@@ -1467,7 +1623,7 @@ $repeatLabel""")
                 val constOffset = (ptrAndIndex.second as? PtNumber)?.number?.toInt()
                 if(addrOf!=null && constOffset!=null) {
                     if(addrOf.isFromArrayElement) {
-                        TODO("address-of array element $addrOf")
+                        TODO("address-of array element ${addrOf.position}")
                     } else if(addrOf.dereference!=null) {
                         throw AssemblyError("write &dereference, makes no sense at ${addrOf.position}")
                     } else {
@@ -1500,9 +1656,9 @@ $repeatLabel""")
                 val constOffset = (ptrAndIndex.second as? PtNumber)?.number?.toInt()
                 if(addrOf!=null && constOffset!=null) {
                     if(addrOf.isFromArrayElement) {
-                        TODO("address-of array element $addrOf")
+                        TODO("address-of array element ${addrOf.position}")
                     } else if(addrOf.dereference!=null) {
-                        TODO("read &dereference")
+                        TODO("read &dereference ${addrOf.position}")
                     } else {
                         out("  lda  ${asmSymbolName(addrOf.identifier!!)}-${constOffset}")
                         return true
@@ -1847,9 +2003,9 @@ $repeatLabel""")
                 lda  #<$leftName
                 ldy  #>$leftName""")
             if(lessOrEquals)
-                out("jsr  floats.vars_lesseq_f")
+                out("  jsr  floats.vars_lesseq_f")
             else
-                out("jsr  floats.vars_less_f")
+                out("  jsr  floats.vars_less_f")
         }
         fun lessf(expr: PtExpression, rightName: String) {
             assignExpressionToRegister(expr, RegisterOrPair.FAC1, true)
@@ -1968,6 +2124,22 @@ $repeatLabel""")
         }
     }
 
+    internal fun loadIndirectLongIntoR14R15(zpPtrVar: String, offset: UByte) {
+        out("""
+            ldy  #$offset
+            lda  ($zpPtrVar),y
+            sta  cx16.r14
+            iny
+            lda  ($zpPtrVar),y
+            sta  cx16.r14+1
+            iny
+            lda  ($zpPtrVar),y
+            sta  cx16.r14+2
+            iny
+            lda  ($zpPtrVar),y
+            sta  cx16.r14+3""")
+    }
+
     internal fun storeIndirectByte(byte: Int, zpPtrVar: String, offset: UByte) {
         if (offset > 0u) {
             out("  lda  #$byte |  ldy  #$offset |  sta  ($zpPtrVar),y")
@@ -2104,7 +2276,7 @@ $repeatLabel""")
                 }
 
                 in Cx16VirtualRegisters -> {
-                    val regname = regs.asScopedNameVirtualReg(DataType.UWORD)
+                    val regname = regs.asScopedNameVirtualReg(DataType.UWORD).joinToString(".")
                     out("""
                         lda  $regname
                         ldy  #$offset
@@ -2171,7 +2343,7 @@ $repeatLabel""")
                 }
 
                 in Cx16VirtualRegisters -> {
-                    val regname = regs.asScopedNameVirtualReg(DataType.UWORD)
+                    val regname = regs.asScopedNameVirtualReg(DataType.UWORD).joinToString(".")
                     out("""
                         lda  $regname
                         ldy  #0
@@ -2280,6 +2452,70 @@ $repeatLabel""")
             }
         }
     }
+
+    internal fun pushLongRegisters(startreg: RegisterOrPair, numberOfLongs: Int) {
+        // may clobber P8ZP_SCRATCH_B1, X, Y.
+        if(numberOfLongs==0) return
+
+        val startregName = startreg.startregname()
+        if(numberOfLongs==1) {
+            out("""
+                tax
+                lda  cx16.$startregName
+                pha
+                lda  cx16.$startregName+1
+                pha
+                lda  cx16.$startregName+2
+                pha
+                lda  cx16.$startregName+3
+                pha
+                txa""")
+            return
+        }
+        val numbytes = numberOfLongs * options.compTarget.memorySize(BaseDataType.LONG)
+        out("""
+            tax
+            sty  P8ZP_SCRATCH_B1
+            ldy  #0
+-           lda  cx16.$startregName,y
+            pha
+            iny
+            cpy  #$numbytes
+            bne  -
+            ldy  P8ZP_SCRATCH_B1
+            txa""")
+    }
+
+    internal fun popLongRegisters(startreg: RegisterOrPair, numberOfLongs: Int) {
+        if(numberOfLongs==0) return
+
+        val startregName = startreg.startregname()
+        if(numberOfLongs==1) {
+            out("""
+                tax
+                pla
+                sta  cx16.$startregName+3
+                pla
+                sta  cx16.$startregName+2
+                pla
+                sta  cx16.$startregName+1
+                pla
+                sta  cx16.$startregName
+                txa""")
+            return
+        }
+        val numbytes = numberOfLongs * options.compTarget.memorySize(BaseDataType.LONG)
+        out("""
+            tax
+            sty  P8ZP_SCRATCH_B1
+            ldy  #$numbytes-1
+-           pla
+            sta  cx16.$startregName,y
+            dey
+            bpl  -
+            ldy  P8ZP_SCRATCH_B1
+            txa""")
+    }
 }
 
 /**
@@ -2293,4 +2529,8 @@ internal class SubroutineExtraAsmInfo {
     var usedFloatEvalResultVar2 = false
 
     val extraVars = mutableListOf<Triple<BaseDataType, String, UInt?>>()
-}
+}
+
+
+internal fun Double.toLongHex(): String = this.toUInt().toString(16).padStart(8, '0')
+internal fun Int.toLongHex(): String = this.toUInt().toString(16).padStart(8, '0')

codeGenCpu6502/src/prog8/codegen/cpu6502/AsmOptimizer.kt

@@ -544,7 +544,7 @@ private fun optimizeJsrRtsAndOtherCombinations(linesByFour: Sequence<List<Indexe
         val third = lines[2].value
 
         if(!haslabel(second)) {
-            if ((" jmp" in first || "\tjmp" in first ) && (" rts" in second || "\trts" in second)) {
+            if ((" jmp" in first || "\tjmp" in first || " bra" in first || "\tbra" in first ) && (" rts" in second || "\trts" in second)) {
                 mods += Modification(lines[1].index, true, null)
             }
             else if ((" jsr" in first || "\tjsr" in first ) && (" rts" in second || "\trts" in second)) {

codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt

@@ -27,17 +27,20 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         val sscope = fcall.definingISub()
 
         when (fcall.name) {
-            "lsw" -> throw AssemblyError("lsw() should have been removed or replaced by a const value")
-            "msw" -> throw AssemblyError("msw() should have been removed or replaced by a const value")
+            "msw" -> funcMsw(fcall, resultRegister)
+            "lsw" -> funcLsw(fcall, resultRegister)
             "msb" -> funcMsb(fcall, resultRegister)
-            "lsb" -> funcLsb(fcall, resultRegister)
+            "msb__long" -> funcMsbLong(fcall, resultRegister)
+            "lsb" -> funcLsb(fcall, resultRegister, false)
+            "lsb__long" -> funcLsb(fcall, resultRegister, true)
             "mkword" -> funcMkword(fcall, resultRegister)
-            "clamp__byte", "clamp__ubyte", "clamp__word", "clamp__uword" -> funcClamp(fcall, resultRegister)
-            "min__byte", "min__ubyte", "min__word", "min__uword" -> funcMin(fcall, resultRegister)
-            "max__byte", "max__ubyte", "max__word", "max__uword" -> funcMax(fcall, resultRegister)
-            "abs__byte", "abs__word", "abs__float" -> funcAbs(fcall, resultRegister, sscope)
+            "mklong", "mklong2" -> funcMklong(fcall)  // result is in R14:R15
+            "clamp__byte", "clamp__ubyte", "clamp__word", "clamp__uword", "clamp__long" -> funcClamp(fcall, resultRegister)
+            "min__byte", "min__ubyte", "min__word", "min__uword", "min__long" -> funcMin(fcall, resultRegister)
+            "max__byte", "max__ubyte", "max__word", "max__uword", "max__long" -> funcMax(fcall, resultRegister)
+            "abs__byte", "abs__word", "abs__long", "abs__float" -> funcAbs(fcall, resultRegister, sscope)
             "sgn" -> funcSgn(fcall, resultRegister, sscope)
-            "sqrt__ubyte", "sqrt__uword", "sqrt__float" -> funcSqrt(fcall, resultRegister, sscope)
+            "sqrt__ubyte", "sqrt__uword", "sqrt__long", "sqrt__float" -> funcSqrt(fcall, resultRegister, sscope)
             "divmod__ubyte" -> funcDivmod(fcall)
             "divmod__uword" -> funcDivmodW(fcall)
             "rol" -> funcRol(fcall)
@@ -48,10 +51,12 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             "setmsb" -> funcSetLsbMsb(fcall, true)
             "memory" -> funcMemory(fcall, discardResult, resultRegister)
             "peekw" -> funcPeekW(fcall, resultRegister)
+            "peekl" -> funcPeekL(fcall, resultRegister)
             "peekf" -> funcPeekF(fcall, resultRegister)
             "peekbool" -> funcPeekBool(fcall, resultRegister)
             "peek" -> throw AssemblyError("peek() should have been replaced by @()")
             "pokew" -> funcPokeW(fcall)
+            "pokel" -> funcPokeL(fcall)
             "pokef" -> funcPokeF(fcall)
             "pokemon" -> {
                 val memread = PtMemoryByte(fcall.position)
@@ -346,38 +351,112 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 }
             } else
                 throw AssemblyError("args for cmp() should have same dt")
-        } else {
-            // arg1 is a word
+        } else if(arg1.type.isWord) {
             if(arg2.type.isWord) {
-                when (arg2) {
-                    is PtIdentifier -> {
-                        asmgen.assignExpressionToRegister(arg1, RegisterOrPair.AY)
-                        asmgen.out("""
-                            cpy  ${asmgen.asmVariableName(arg2)}+1
-                            bne  +
-                            cmp  ${asmgen.asmVariableName(arg2)}
-+""")
+                if(arg1.type.isSigned) {
+                    when (arg2) {
+                        is PtIdentifier -> {
+                            asmgen.assignExpressionToRegister(arg1, RegisterOrPair.AY)
+                            asmgen.out("""
+                                sec
+                                sbc  ${asmgen.asmVariableName(arg2)}
+                                tya
+                                sbc  ${asmgen.asmVariableName(arg2)}+1""")
+                        }
+                        is PtBool -> TODO("word compare against bool  ${arg2.position}")
+                        is PtNumber -> {
+                            asmgen.assignExpressionToRegister(arg1, RegisterOrPair.AY)
+                            asmgen.out("""
+                                sec
+                                sbc  #<${arg2.number.toInt()}
+                                tya
+                                sbc  #>${arg2.number.toInt()}""")
+                        }
+                        else -> {
+                            asmgen.assignWordOperandsToAYAndVar(arg1, arg2, "P8ZP_SCRATCH_W1")
+                            asmgen.out("""
+                                sec
+                                sbc  P8ZP_SCRATCH_W1
+                                tya
+                                sbc  P8ZP_SCRATCH_W1+1""")
+                        }
                     }
-                    is PtBool -> TODO("word compare against bool  ${arg2.position}")
-                    is PtNumber -> {
-                        asmgen.assignExpressionToRegister(arg1, RegisterOrPair.AY)
-                        asmgen.out("""
-                            cpy  #>${arg2.number.toInt()}
-                            bne  +
-                            cmp  #<${arg2.number.toInt()}
+                } else {
+                    when (arg2) {
+                        is PtIdentifier -> {
+                            asmgen.assignExpressionToRegister(arg1, RegisterOrPair.AY)
+                            asmgen.out("""
+                                cpy  ${asmgen.asmVariableName(arg2)}+1
+                                bne  +
+                                cmp  ${asmgen.asmVariableName(arg2)}
 +""")
-                    }
-                    else -> {
-                        asmgen.assignWordOperandsToAYAndVar(arg1, arg2, "P8ZP_SCRATCH_W1")
-                        asmgen.out("""
-                            cpy  P8ZP_SCRATCH_W1+1
-                            bne  +
-                            cmp  P8ZP_SCRATCH_W1
+                        }
+                        is PtBool -> TODO("word compare against bool  ${arg2.position}")
+                        is PtNumber -> {
+                            asmgen.assignExpressionToRegister(arg1, RegisterOrPair.AY)
+                            asmgen.out("""
+                                cpy  #>${arg2.number.toInt()}
+                                bne  +
+                                cmp  #<${arg2.number.toInt()}
 +""")
+                        }
+                        else -> {
+                            asmgen.assignWordOperandsToAYAndVar(arg1, arg2, "P8ZP_SCRATCH_W1")
+                            asmgen.out("""
+                                cpy  P8ZP_SCRATCH_W1+1
+                                bne  +
+                                cmp  P8ZP_SCRATCH_W1
++""")
+                        }
                     }
                 }
             } else
                 throw AssemblyError("args for cmp() should have same dt")
+        } else if(arg1.type.isLong) {
+            if(arg2.type.isLong) {
+                if(arg1 is PtIdentifier && arg2 is PtNumber) {
+                    val var1 = asmgen.asmVariableName(arg1)
+                    val hex = arg2.number.toLongHex()
+                    asmgen.out("""
+                        sec
+                        lda  $var1
+                        sbc  #$${hex.substring(6, 8)}
+                        lda  $var1+1
+                        sbc  #$${hex.substring(4, 6)}
+                        lda  $var1+2
+                        sbc  #$${hex.substring(2, 4)}
+                        lda  $var1+3
+                        sbc  #$${hex.take(2)}""")
+                } else if(arg1 is PtIdentifier && arg2 is PtIdentifier) {
+                    val var1 = asmgen.asmVariableName(arg1)
+                    val var2 = asmgen.asmVariableName(arg2)
+                    asmgen.out("""
+                        sec
+                        lda  $var1
+                        sbc  $var2
+                        lda  $var1+1
+                        sbc  $var2+1
+                        lda  $var1+2
+                        sbc  $var2+2
+                        lda  $var1+3
+                        sbc  $var2+3""")
+                } else {
+                    // cmp() doesn't return a value and as such can't be used in an expression, so no need to save the temp registers' original values
+                    assignAsmGen.assignExpressionToRegister(arg2, RegisterOrPair.R14R15_32, true)
+                    assignAsmGen.assignExpressionToRegister(arg1, RegisterOrPair.R12R13_32, true)
+                    asmgen.out("""
+                        sec
+                        lda  cx16.r12
+                        sbc  cx16.r14
+                        lda  cx16.r12+1
+                        sbc  cx16.r14+1
+                        lda  cx16.r12+2
+                        sbc  cx16.r14+2
+                        lda  cx16.r12+3
+                        sbc  cx16.r14+3""")
+                }
+            } else
+                throw AssemblyError("args for cmp() should have same dt")
         }
     }
 
@@ -424,6 +503,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 asmgen.out("  jsr  prog8_lib.func_sqrt16_into_A")
                 assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, false, false)
             }
+            BaseDataType.LONG -> TODO("sqrt LONG ${fcall.position}")
             BaseDataType.FLOAT -> {
                 asmgen.out("  jsr  floats.func_sqrt_into_FAC1")
                 assignAsmGen.assignFAC1float(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.FAC1, true, fcall.position, scope, asmgen))
@@ -458,7 +538,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  lda  $variable |  lsr  a |  bcc  + |  ora  #$80 |+  |  sta  $variable")
                     }
-                    else -> throw AssemblyError("weird type")
+                    else -> throw AssemblyError("weird node")
                 }
             }
             BaseDataType.UWORD -> {
@@ -477,7 +557,27 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  lsr  $variable+1 |  ror  $variable |  bcc  + |  lda  $variable+1 |  ora  #$80 |  sta  $variable+1 |+  ")
                     }
-                    else -> throw AssemblyError("weird type")
+                    else -> throw AssemblyError("weird node")
+                }
+            }
+            BaseDataType.LONG -> {
+                // a bit strange, rotating a signed type, but it has to do for now
+                when(what) {
+                    is PtArrayIndexer -> TODO("ror2 long array ${what.position}")
+                    is PtIdentifier -> {
+                        val variable = asmgen.asmVariableName(what)
+                        asmgen.out("""
+                            lsr  $variable+3
+                            ror  $variable+2
+                            ror  $variable+1
+                            ror  $variable
+                            bcc  +
+                            lda  $variable+3
+                            ora  #$80
+                            sta  $variable+3
++""")
+                    }
+                    else -> throw AssemblyError("weird node")
                 }
             }
             else -> throw AssemblyError("weird type")
@@ -520,7 +620,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  ror  $variable")
                     }
-                    else -> throw AssemblyError("weird type")
+                    else -> throw AssemblyError("weird node")
                 }
             }
             BaseDataType.UWORD -> {
@@ -541,7 +641,18 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  ror  $variable+1 |  ror  $variable")
                     }
-                    else -> throw AssemblyError("weird type")
+                    else -> throw AssemblyError("weird node")
+                }
+            }
+            BaseDataType.LONG -> {
+                // a bit strange, rotating a signed type, but it has to do for now
+                when(what) {
+                    is PtArrayIndexer -> TODO("ror long array ${what.position}")
+                    is PtIdentifier -> {
+                        val variable = asmgen.asmVariableName(what)
+                        asmgen.out("  ror  $variable+3 |  ror  $variable+2 |  ror  $variable+1 |  ror  $variable")
+                    }
+                    else -> throw AssemblyError("weird node")
                 }
             }
             else -> throw AssemblyError("weird type")
@@ -573,7 +684,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  lda  $variable |  cmp  #$80 |  rol  a |  sta  $variable")
                     }
-                    else -> throw AssemblyError("weird type")
+                    else -> throw AssemblyError("weird node")
                 }
             }
             BaseDataType.UWORD -> {
@@ -592,7 +703,25 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  asl  $variable |  rol  $variable+1 |  bcc  + |  inc  $variable |+  ")
                     }
-                    else -> throw AssemblyError("weird type")
+                    else -> throw AssemblyError("weird node")
+                }
+            }
+            BaseDataType.LONG -> {
+                // a bit strange, rotating a signed type, but it has to do for now
+                when(what) {
+                    is PtArrayIndexer -> TODO("rol2 long array ${what.position}")
+                    is PtIdentifier -> {
+                        val variable = asmgen.asmVariableName(what)
+                        asmgen.out("""
+                            asl  $variable
+                            rol  $variable+1
+                            rol  $variable+2
+                            rol  $variable+3
+                            bcc  +
+                            inc  $variable
++""")
+                    }
+                    else -> throw AssemblyError("weird node")
                 }
             }
             else -> throw AssemblyError("weird type")
@@ -634,7 +763,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  rol  $variable")
                     }
-                    else -> throw AssemblyError("weird type")
+                    else -> throw AssemblyError("weird node")
                 }
             }
             BaseDataType.UWORD -> {
@@ -655,7 +784,18 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  rol  $variable |  rol  $variable+1")
                     }
-                    else -> throw AssemblyError("weird type")
+                    else -> throw AssemblyError("weird node")
+                }
+            }
+            BaseDataType.LONG -> {
+                // a bit strange, rotating a signed type, but it has to do for now
+                when(what) {
+                    is PtArrayIndexer -> TODO("rol long array ${what.position}")
+                    is PtIdentifier -> {
+                        val variable = asmgen.asmVariableName(what)
+                        asmgen.out("  rol  $variable |  rol  $variable+1 |  rol  $variable+2 |  rol  $variable+3")
+                    }
+                    else -> throw AssemblyError("weird node")
                 }
             }
             else -> throw AssemblyError("weird type")
@@ -729,6 +869,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             BaseDataType.BYTE -> asmgen.out("  jsr  prog8_lib.func_sign_b_into_A")
             BaseDataType.UWORD -> asmgen.out("  jsr  prog8_lib.func_sign_uw_into_A")
             BaseDataType.WORD -> asmgen.out("  jsr  prog8_lib.func_sign_w_into_A")
+            BaseDataType.LONG -> asmgen.out("  jsr  prog8_lib.func_sign_l_r14r15_into_A")          // note: long arg is stored in R14:R15
             BaseDataType.FLOAT -> asmgen.out("  jsr  floats.func_sign_f_into_A")
             else -> throw AssemblyError("weird type $dt")
         }
@@ -747,6 +888,10 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 asmgen.out("  jsr  prog8_lib.abs_w_into_AY")
                 assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, fcall.position, scope, asmgen), RegisterOrPair.AY)
             }
+            BaseDataType.LONG -> {
+                asmgen.out("  jsr  prog8_lib.abs_l_into_R14R15")
+                assignAsmGen.assignRegisterLong(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.R14R15_32, true, fcall.position, scope, asmgen), RegisterOrPair.R14R15_32)
+            }
             BaseDataType.FLOAT -> {
                 asmgen.out("  jsr  floats.func_abs_f_into_FAC1")
                 assignAsmGen.assignFAC1float(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.FAC1, true, fcall.position, scope, asmgen))
@@ -824,6 +969,19 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                     asmgen.restoreRegisterStack(CpuRegister.Y, true)
                     asmgen.out("  sta  ($varname),y")
                     return
+                } else if(addrExpr.operator=="+" && addrExpr.left is PtIdentifier) {
+                    asmgen.assignExpressionToRegister(addrExpr.right, RegisterOrPair.AY, false)
+                    val ptrName = asmgen.asmVariableName(addrExpr.left as PtIdentifier)
+                    asmgen.out("""
+                        clc
+                        adc  $ptrName
+                        sta  P8ZP_SCRATCH_W2
+                        tya
+                        adc  $ptrName+1
+                        sta  P8ZP_SCRATCH_W2+1""")
+                    asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // TODO *could* overwerite SCRATCH_W2 if it's a compliated expression...
+                    asmgen.storeIndirectByteReg(CpuRegister.A, "P8ZP_SCRATCH_W2", 0u, false, false)
+                    return
                 }
             }
             else -> { /* fall through */ }
@@ -874,6 +1032,20 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                             iny
                             sta  ($varname),y""")
                     return
+                } else if(addrExpr.operator=="+" && addrExpr.left is PtIdentifier) {
+                    asmgen.assignExpressionToRegister(addrExpr.right, RegisterOrPair.AY, false)
+                    val ptrName = asmgen.asmVariableName(addrExpr.left as PtIdentifier)
+                    asmgen.out("""
+                        clc
+                        adc  $ptrName
+                        sta  P8ZP_SCRATCH_W2
+                        tya
+                        adc  $ptrName+1
+                        sta  P8ZP_SCRATCH_W2+1""")
+                    asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AY)      // TODO *could* overwerite SCRATCH_W2 if it's a compliated expression...
+                    asmgen.out("  jsr  prog8_lib.func_pokew_scratchW2")
+                    //asmgen.storeIndirectWordReg(RegisterOrPair.AY, "P8ZP_SCRATCH_W2", 0u)
+                    return
                 }
             }
             else -> { /* fall through */ }
@@ -884,6 +1056,18 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         asmgen.out("  jsr  prog8_lib.func_pokew")
     }
 
+    private fun funcPokeL(fcall: PtBuiltinFunctionCall) {
+        // TODO optimize for the simple cases
+        asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
+        asmgen.saveRegisterStack(CpuRegister.A, false)
+        asmgen.saveRegisterStack(CpuRegister.Y, false)
+        // it's a statement so no need to preserve R14:R15
+        asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.R14R15_32, true)
+        asmgen.restoreRegisterStack(CpuRegister.Y, false)
+        asmgen.restoreRegisterStack(CpuRegister.A, false)
+        asmgen.out("  jsr  prog8_lib.func_pokel")
+    }
+
     private fun funcPeekF(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
         asmgen.out("  jsr  floats.MOVFM")
@@ -918,6 +1102,8 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                     val varname = asmgen.asmVariableName(pointer)
                     asmgen.assignExpressionToRegister(result.second, RegisterOrPair.Y)
                     asmgen.out("  lda  ($varname),y")
+                } else if(addrExpr.operator=="+" && addrExpr.left is PtIdentifier) {
+                    readValueFromPointerPlusOffset(addrExpr.left as PtIdentifier, addrExpr.right, BaseDataType.BOOL)
                 } else fallback()
             }
             else -> fallback()
@@ -963,6 +1149,8 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         lda  ($varname),y
                         tay
                         txa""")
+                } else if(addrExpr.operator=="+" && addrExpr.left is PtIdentifier) {
+                    readValueFromPointerPlusOffset(addrExpr.left as PtIdentifier, addrExpr.right, BaseDataType.UWORD)
                 } else fallback()
             }
             else -> fallback()
@@ -980,6 +1168,36 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         }
     }
 
+    private fun readValueFromPointerPlusOffset(ptr: PtIdentifier, offset: PtExpression, dt: BaseDataType) {
+        val varname = asmgen.asmVariableName(ptr)
+        asmgen.assignExpressionToRegister(offset, RegisterOrPair.AY)
+        asmgen.out("""
+            clc
+            adc  $varname
+            sta  P8ZP_SCRATCH_W1
+            tya
+            adc  $varname+1
+            sta  P8ZP_SCRATCH_W1+1""")
+        if (dt.isByteOrBool) {
+            if(asmgen.isTargetCpu(CpuType.CPU65C02)) {
+                asmgen.out("  lda  (P8ZP_SCRATCH_W1)")
+            } else {
+                asmgen.out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W1),y")
+            }
+        } else if(dt.isWord) {
+            asmgen.out("  jsr  prog8_lib.func_peekw.from_scratchW1")
+        } else throw AssemblyError("unsupported type for peek $dt")
+    }
+
+    private fun funcPeekL(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
+        // TODO optimize for the simple cases
+        asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
+        asmgen.out("  jsr  prog8_lib.func_peekl")
+        val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.R14R15_32, true, fcall.position, fcall.definingISub(), asmgen)
+        assignAsmGen.assignRegisterLong(targetReg, RegisterOrPair.R14R15_32)
+    }
+
+
     private fun funcClamp(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         val signed = fcall.type.isSigned
         when {
@@ -999,6 +1217,9 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, signed, fcall.position, fcall.definingISub(), asmgen)
                 assignAsmGen.assignRegisterpairWord(targetReg, RegisterOrPair.AY)
             }
+            fcall.type.isLong -> {
+                TODO("clamp long  ${fcall.position}")
+            }
             else -> throw AssemblyError("invalid dt")
         }
     }
@@ -1055,6 +1276,9 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, signed, fcall.position, fcall.definingISub(), asmgen)
                 asmgen.assignRegister(RegisterOrPair.AY, targetReg)
             }
+            fcall.type.isLong -> {
+                TODO("min long  ${fcall.position}")
+            }
             else -> {
                 throw AssemblyError("min float not supported")
             }
@@ -1063,55 +1287,109 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
 
     private fun funcMax(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         val signed = fcall.type.isSigned
-        if(fcall.type.isByte) {
-            asmgen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_B1", fcall.type)     // left
-            asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)          // right
-            asmgen.out("  cmp  P8ZP_SCRATCH_B1")
-            if(signed) asmgen.out("  bpl  +") else asmgen.out("  bcs  +")
-            asmgen.out("""
-                lda  P8ZP_SCRATCH_B1
-+""")
-            val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, signed, fcall.position, fcall.definingISub(), asmgen)
-            asmgen.assignRegister(RegisterOrPair.A, targetReg)
-        } else if(fcall.type.isWord) {
-            asmgen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_W1", fcall.type)     // left
-            asmgen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_W2", fcall.type)     // right
-            if(signed) {
+        when {
+            fcall.type.isByte -> {
+                asmgen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_B1", fcall.type)     // left
+                asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)          // right
+                asmgen.out("  cmp  P8ZP_SCRATCH_B1")
+                if (signed) asmgen.out("  bpl  +") else asmgen.out("  bcs  +")
                 asmgen.out("""
-                    lda  P8ZP_SCRATCH_W1
-                    ldy  P8ZP_SCRATCH_W1+1
-                    cmp  P8ZP_SCRATCH_W2
-                    tya
-                    sbc  P8ZP_SCRATCH_W2+1
-                    bvc  +
-                    eor  #$80
-+                   bmi  +
-                    lda  P8ZP_SCRATCH_W1                   
-                    ldy  P8ZP_SCRATCH_W1+1
-                    jmp  ++
-+                   lda  P8ZP_SCRATCH_W2
-                    ldy  P8ZP_SCRATCH_W2+1
+                    lda  P8ZP_SCRATCH_B1
++"""
+                )
+                val targetReg = AsmAssignTarget.fromRegisters(
+                    resultRegister ?: RegisterOrPair.A,
+                    signed,
+                    fcall.position,
+                    fcall.definingISub(),
+                    asmgen
+                )
+                asmgen.assignRegister(RegisterOrPair.A, targetReg)
+            }
+            fcall.type.isWord -> {
+                asmgen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_W1", fcall.type)     // left
+                asmgen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_W2", fcall.type)     // right
+                if (signed) {
+                    asmgen.out("""
+                        lda  P8ZP_SCRATCH_W1
+                        ldy  P8ZP_SCRATCH_W1+1
+                        cmp  P8ZP_SCRATCH_W2
+                        tya
+                        sbc  P8ZP_SCRATCH_W2+1
+                        bvc  +
+                        eor  #$80
++                       bmi  +
+                        lda  P8ZP_SCRATCH_W1                   
+                        ldy  P8ZP_SCRATCH_W1+1
+                        jmp  ++
++                       lda  P8ZP_SCRATCH_W2
+                        ldy  P8ZP_SCRATCH_W2+1
 +""")
+                } else {
+                    asmgen.out("""
+                        lda  P8ZP_SCRATCH_W1+1
+                        cmp  P8ZP_SCRATCH_W2+1
+                        bcc  ++
+                        bne  +
+                        lda  P8ZP_SCRATCH_W1
+                        cmp  P8ZP_SCRATCH_W2
+                        bcc  ++
++                       lda  P8ZP_SCRATCH_W1
+                        ldy  P8ZP_SCRATCH_W1+1
+                        jmp  ++
++                       lda  P8ZP_SCRATCH_W2
+                        ldy  P8ZP_SCRATCH_W2+1
++""")
+                }
+                val targetReg = AsmAssignTarget.fromRegisters(
+                    resultRegister ?: RegisterOrPair.AY,
+                    signed,
+                    fcall.position,
+                    fcall.definingISub(),
+                    asmgen
+                )
+                asmgen.assignRegister(RegisterOrPair.AY, targetReg)
+            }
+            fcall.type.isLong -> {
+                TODO("max long  ${fcall.position}")
+            }
+            else -> {
+                throw AssemblyError("max float not supported")
+            }
+        }
+    }
+
+    private fun funcMklong(fcall: PtBuiltinFunctionCall) {
+        // result long in R14:R15   (r14=lsw, r15=msw)
+
+        fun isArgRegister(expression: PtExpression, reg: RegisterOrPair): Boolean {
+            if(expression !is PtIdentifier)
+                return false
+            return expression.name.startsWith("cx16.${reg.name.lowercase()}")
+        }
+
+        if(fcall.args.size==2) {
+            // mklong2(msw, lsw)
+            if(isArgRegister(fcall.args[0], RegisterOrPair.R14) || isArgRegister(fcall.args[0], RegisterOrPair.R15) ||
+                isArgRegister(fcall.args[1], RegisterOrPair.R14) || isArgRegister(fcall.args[1], RegisterOrPair.R15)) {
+                error("cannot use R14 and/or R15 as arguments for mklong2 because the result should go into R0:R1 ${fcall.position}")
             } else {
-                asmgen.out("""
-                    lda  P8ZP_SCRATCH_W1+1
-                    cmp  P8ZP_SCRATCH_W2+1
-                    bcc  ++
-                    bne  +
-                    lda  P8ZP_SCRATCH_W1
-                    cmp  P8ZP_SCRATCH_W2
-                    bcc  ++
-+                   lda  P8ZP_SCRATCH_W1
-                    ldy  P8ZP_SCRATCH_W1+1
-                    jmp  ++
-+                   lda  P8ZP_SCRATCH_W2
-                    ldy  P8ZP_SCRATCH_W2+1
-+""")
+                assignAsmGen.assignExpressionToVariable(fcall.args[0], "cx16.r15", DataType.UWORD)
+                assignAsmGen.assignExpressionToVariable(fcall.args[1], "cx16.r14", DataType.UWORD)
             }
-            val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, signed, fcall.position, fcall.definingISub(), asmgen)
-            asmgen.assignRegister(RegisterOrPair.AY, targetReg)
         } else {
-            throw AssemblyError("max float not supported")
+            // mklong(msb, b2, b1, lsb)
+            if(isArgRegister(fcall.args[0], RegisterOrPair.R14) || isArgRegister(fcall.args[0], RegisterOrPair.R15) ||
+                isArgRegister(fcall.args[1], RegisterOrPair.R14) || isArgRegister(fcall.args[1], RegisterOrPair.R15) ||
+                isArgRegister(fcall.args[2], RegisterOrPair.R14) || isArgRegister(fcall.args[2], RegisterOrPair.R15) ||
+                isArgRegister(fcall.args[3], RegisterOrPair.R14) || isArgRegister(fcall.args[3], RegisterOrPair.R15)) {
+                error("cannot use R14 and/or R15 as arguments for mklong because the result should go into R14:R15 ${fcall.position}")
+            } else {
+                assignAsmGen.assignExpressionToVariable(fcall.args[0], "cx16.r15H", DataType.UBYTE)
+                assignAsmGen.assignExpressionToVariable(fcall.args[1], "cx16.r15L", DataType.UBYTE)
+                assignAsmGen.assignExpressionToVariable(fcall.args[2], "cx16.r14H", DataType.UBYTE)
+                assignAsmGen.assignExpressionToVariable(fcall.args[3], "cx16.r14L", DataType.UBYTE)
+            }
         }
     }
 
@@ -1182,10 +1460,43 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         }
     }
 
+    private fun funcMsbLong(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
+        val arg = fcall.args.single()
+        if (!arg.type.isLong)
+            throw AssemblyError("msb__long requires long argument")
+        if (arg is PtNumber)
+            throw AssemblyError("msb(const) should have been const-folded away")
+
+        if (arg is PtIdentifier) {
+            val sourceName = asmgen.asmVariableName(arg)
+            when(resultRegister) {
+                null, RegisterOrPair.A -> asmgen.out("  lda  $sourceName+3")
+                RegisterOrPair.X -> asmgen.out("  ldx  $sourceName+3")
+                RegisterOrPair.Y -> asmgen.out("  ldy  $sourceName+3")
+                RegisterOrPair.AX -> asmgen.out("  lda  $sourceName+3 |  ldx  #0")
+                RegisterOrPair.AY -> asmgen.out("  lda  $sourceName+3 |  ldy  #0")
+                RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName+3 |  ldy  #0")
+                in Cx16VirtualRegisters -> {
+                    val regname = resultRegister.name.lowercase()
+                    if(asmgen.isTargetCpu(CpuType.CPU65C02))
+                        asmgen.out("  lda  $sourceName+3 |  sta  cx16.$regname |  stz  cx16.$regname+1")
+                    else
+                        asmgen.out("  lda  $sourceName+3 |  sta  cx16.$regname |  lda  #0 |  sta  cx16.$regname+1")
+                }
+                in combinedLongRegisters -> {
+                    TODO("msb__long into long register ${fcall.position}")
+                }
+                else -> throw AssemblyError("invalid reg")
+            }
+        } else {
+            TODO("msb__long from $arg  ${fcall.position}")
+        }
+    }
+
     private fun funcMsb(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         val arg = fcall.args.single()
         if (!arg.type.isWord)
-            throw AssemblyError("msb required word argument")
+            throw AssemblyError("msb requires word argument")
         if (arg is PtNumber)
             throw AssemblyError("msb(const) should have been const-folded away")
         if (arg is PtIdentifier) {
@@ -1204,6 +1515,9 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                     else
                         asmgen.out("  lda  $sourceName+1 |  sta  cx16.$regname |  lda  #0 |  sta  cx16.$regname+1")
                 }
+                in combinedLongRegisters -> {
+                    TODO("msb into long register ${fcall.position}")
+                }
                 else -> throw AssemblyError("invalid reg")
             }
         } else {
@@ -1280,15 +1594,21 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                     asmgen.assignExpressionToRegister(arg, RegisterOrPair.AY)
                     asmgen.out("  sty  ${reg}L |  lda  #0 |  sta  ${reg}H |  lda  ${reg}L")
                 }
+                in combinedLongRegisters -> {
+                    TODO("msb into long register ${fcall.position}")
+                }
                 else -> throw AssemblyError("invalid reg")
             }
         }
     }
 
-    private fun funcLsb(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
+    private fun funcLsb(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?, fromLong: Boolean) {
         val arg = fcall.args.single()
-        if (!arg.type.isWord)
-            throw AssemblyError("lsb required word argument")
+        if(fromLong) {
+            if (!arg.type.isLong) throw AssemblyError("lsb__long requires long")
+        } else {
+            if (!arg.type.isWord) throw AssemblyError("lsb requires word")
+        }
         if (arg is PtNumber)
             throw AssemblyError("lsb(const) should have been const-folded away")
 
@@ -1308,6 +1628,9 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                     else
                         asmgen.out("  lda  $sourceName |  sta  cx16.$regname |  lda  #0 |  sta  cx16.$regname+1")
                 }
+                in combinedLongRegisters -> {
+                    TODO("lsb into long register ${fcall.position}")
+                }
                 else -> throw AssemblyError("invalid reg")
             }
         } else {
@@ -1366,11 +1689,87 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                     asmgen.assignExpressionToRegister(arg, RegisterOrPair.AY)
                     asmgen.out("  sta  ${reg}L |  ldy  #0 |  sty  ${reg}H |  cmp  #0")
                 }
+                in combinedLongRegisters -> {
+                    TODO("lsb into long register ${fcall.position}")
+                }
                 else -> throw AssemblyError("invalid reg")
             }
         }
     }
 
+    private fun funcMsw(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
+        val arg = fcall.args.single()
+        if (!arg.type.isLong)
+            throw AssemblyError("msw requires long argument")
+        if (arg is PtNumber)
+            throw AssemblyError("msw(const) should have been const-folded away")
+        if (arg is PtIdentifier) {
+            val sourceName = asmgen.asmVariableName(arg)
+            when(resultRegister) {
+                RegisterOrPair.AX -> asmgen.out("  lda  $sourceName+2 |  ldx  $sourceName+3")
+                null, RegisterOrPair.AY -> asmgen.out("  lda  $sourceName+2 |  ldy  $sourceName+3")
+                RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName+2 |  ldy  $sourceName+3")
+                in Cx16VirtualRegisters -> {
+                    val regname = resultRegister.name.lowercase()
+                    asmgen.out("  lda  $sourceName+2 |  sta  cx16.$regname |  lda  $sourceName+3 |  sta  cx16.$regname+1")
+                }
+                else -> throw AssemblyError("invalid reg")
+            }
+        } else {
+            // TODO can't efficiently preserve R14:R15 on the stack because the result of the routine is likely to be in CPU registers,
+            //      which in turn would be clobbered by popping stuff from the stack...
+            asmgen.assignExpressionToRegister(arg, RegisterOrPair.R14R15_32, true)
+            when(resultRegister) {
+                RegisterOrPair.AX -> asmgen.out("  lda  cx16.r15 |  ldx  cx16.r15+1")
+                null, RegisterOrPair.AY -> asmgen.out("  lda  cx16.r15 |  ldy  cx16.r15+1")
+                RegisterOrPair.XY -> asmgen.out("  ldx  cx16.r15 |  ldy  cx16.r15+1")
+                in Cx16VirtualRegisters -> {
+                    val regname = resultRegister.name.lowercase()
+                    asmgen.out("  lda  cx16.r15 |  sta  cx16.$regname |  lda  cx16.r15+1 |  sta  cx16.$regname+1")
+                }
+                else -> throw AssemblyError("invalid reg")
+            }
+        }
+    }
+
+    private fun funcLsw(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
+        val arg = fcall.args.single()
+        if (!arg.type.isLong)
+            throw AssemblyError("lsw requires long argument")
+        if (arg is PtNumber)
+            throw AssemblyError("lsw(const) should have been const-folded away")
+        if (arg is PtIdentifier) {
+            val sourceName = asmgen.asmVariableName(arg)
+            when(resultRegister) {
+                RegisterOrPair.AX -> asmgen.out("  lda  $sourceName |  ldx  $sourceName+1")
+                null, RegisterOrPair.AY -> asmgen.out("  lda  $sourceName |  ldy  $sourceName+1")
+                RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName |  ldy  $sourceName+1")
+                in Cx16VirtualRegisters -> {
+                    val regname = resultRegister.name.lowercase()
+                    asmgen.out("  lda  $sourceName |  sta  cx16.$regname |  lda  $sourceName+1 |  sta  cx16.$regname+1")
+                }
+                else -> throw AssemblyError("invalid reg")
+            }
+        } else {
+            // TODO can't efficiently preserve R14:R15 on the stack because the result of the routine is likely to be in CPU registers,
+            //      which in turn would be clobbered by popping stuff from the stack...
+            asmgen.assignExpressionToRegister(arg, RegisterOrPair.R14R15_32, true)
+            when(resultRegister) {
+                RegisterOrPair.AX -> asmgen.out("  lda  cx16.r14 |  ldx  cx16.r14+1")
+                null, RegisterOrPair.AY -> asmgen.out("  lda  cx16.r14 |  ldy  cx16.r14+1")
+                RegisterOrPair.XY -> asmgen.out("  ldx  cx16.r14 |  ldy  cx16.r14+1")
+                in Cx16VirtualRegisters -> {
+                    if(resultRegister!=RegisterOrPair.R14) {
+                        val regname = resultRegister.name.lowercase()
+                        asmgen.out("  lda  cx16.r14 |  sta  cx16.$regname |  lda  cx16.r14+1 |  sta  cx16.$regname+1")
+                    }
+                }
+                else -> throw AssemblyError("invalid reg")
+            }
+        }
+
+    }
+
     private fun translateArguments(call: PtBuiltinFunctionCall, scope: IPtSubroutine?) {
         val signature = BuiltinFunctions.getValue(call.name)
         val callConv = signature.callConvention(call.args.map {
@@ -1413,6 +1812,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                     val varname = "prog8_lib.func_${call.name}._arg_${paramName}"
                     val src = when  {
                         conv.dt==BaseDataType.FLOAT -> getSourceForFloat(value)
+                        conv.dt==BaseDataType.LONG -> TODO("LONG argument for builtin func ${call.position}")
                         conv.dt.isPassByRef -> {
                             // put the address of the argument in AY
                             val addr = PtAddressOf(DataType.forDt(conv.dt).typeForAddressOf(false), false, value.position)
@@ -1431,6 +1831,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 conv.reg != null -> {
                     val src = when {
                         conv.dt==BaseDataType.FLOAT -> getSourceForFloat(value)
+                        conv.dt==BaseDataType.LONG -> AsmAssignSource.fromAstSource(value, program, asmgen)
                         conv.dt.isPassByRef -> {
                             // put the address of the argument in AY
                             val addr = PtAddressOf(DataType.forDt(conv.dt).typeForAddressOf(false), false,value.position)
@@ -1442,7 +1843,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                             AsmAssignSource.fromAstSource(value, program, asmgen)
                         }
                     }
-                    val tgt = AsmAssignTarget.fromRegisters(conv.reg!!, false, value.position, null, asmgen)
+                    val tgt = AsmAssignTarget.fromRegisters(conv.reg!!, conv.dt.isSigned, value.position, null, asmgen)
                     val assign = AsmAssignment(src, listOf(tgt), program.memsizer, value.position)
                     asmgen.translateNormalAssignment(assign, scope)
                 }

codeGenCpu6502/src/prog8/codegen/cpu6502/ForLoopsAsmGen.kt

@@ -505,137 +505,158 @@ $endLabel""")
             is StMemVar -> symbol.length!!
             else -> 0u
         }
-        when {
-            iterableDt.isString -> {
-                if(asmgen.options.romable) {
-                    val indexVar = asmgen.createTempVarReused(BaseDataType.UBYTE, false, stmt)
-                    asmgen.out("""
+
+        fun iterateStrings() {
+            if(asmgen.options.romable) {
+                val indexVar = asmgen.createTempVarReused(BaseDataType.UBYTE, false, stmt)
+                asmgen.out("""
                         ldy  #0
                         sty  $indexVar
 $loopLabel              lda  $iterableName,y
                         beq  $endLabel
                         sta  ${asmgen.asmVariableName(stmt.variable)}""")
-                    asmgen.translate(stmt.statements)
-                    asmgen.out("""
+                asmgen.translate(stmt.statements)
+                asmgen.out("""
                         inc  $indexVar
                         ldy  $indexVar
                         bne  $loopLabel
 $endLabel""")
-                } else {
-                    val indexVar = asmgen.makeLabel("for_index")
-                    asmgen.out("""
+            } else {
+                val indexVar = asmgen.makeLabel("for_index")
+                asmgen.out("""
                         ldy  #0
                         sty  $indexVar
 $loopLabel              lda  $iterableName,y
                         beq  $endLabel
                         sta  ${asmgen.asmVariableName(stmt.variable)}""")
-                    asmgen.translate(stmt.statements)
-                    asmgen.out("""
+                asmgen.translate(stmt.statements)
+                asmgen.out("""
                         inc  $indexVar
                         ldy  $indexVar
                         bne  $loopLabel
 $indexVar   .byte  0                        
 $endLabel""")
-                }
             }
-            iterableDt.isByteArray || iterableDt.isBoolArray -> {
-                val indexVar = if(asmgen.options.romable)
-                    asmgen.createTempVarReused(iterableDt.elementType().base, false, stmt)
-                else
-                    asmgen.makeLabel("for_index")
-                asmgen.out("""
+        }
+
+        fun iterateBytes() {
+            val indexVar = if(asmgen.options.romable)
+                asmgen.createTempVarReused(iterableDt.elementType().base, false, stmt)
+            else
+                asmgen.makeLabel("for_index")
+            asmgen.out("""
                     ldy  #0
 $loopLabel          sty  $indexVar
                     lda  $iterableName,y
                     sta  ${asmgen.asmVariableName(stmt.variable)}""")
-                asmgen.translate(stmt.statements)
-                if(numElements<=255u) {
-                    asmgen.out("""
+            asmgen.translate(stmt.statements)
+            if(numElements<=255u) {
+                asmgen.out("""
                         ldy  $indexVar
                         iny
                         cpy  #$numElements
                         beq  $endLabel
                         bne  $loopLabel""")
-                } else {
-                    // length is 256
-                    asmgen.out("""
+            } else {
+                // length is 256
+                asmgen.out("""
                         ldy  $indexVar
                         iny
                         bne  $loopLabel
                         beq  $endLabel""")
-                }
-                if(!asmgen.options.romable) {
-                    if(numElements>=16u) {
-                        // allocate index var on ZP if possible, otherwise inline
-                        val result = zeropage.allocate(indexVar, DataType.UBYTE, null, stmt.position, asmgen.errors)
-                        result.fold(
-                            success = { (address, _, _)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
-                            failure = { asmgen.out("$indexVar    .byte  0") }
-                        )
-                    } else {
-                        asmgen.out("$indexVar    .byte  0")
-                    }
-                }
-                asmgen.out(endLabel)
             }
-            iterableDt.isSplitWordArray -> {
-                val indexVar = if(asmgen.options.romable)
-                    asmgen.createTempVarReused(BaseDataType.UBYTE, false, stmt)
-                else
-                    asmgen.makeLabel("for_index")
-                val loopvarName = asmgen.asmVariableName(stmt.variable)
-                asmgen.out("""
+            if(!asmgen.options.romable) {
+                if(numElements>=16u) {
+                    // allocate index var on ZP if possible, otherwise inline
+                    val result = zeropage.allocate(indexVar, DataType.UBYTE, null, stmt.position, asmgen.errors)
+                    result.fold(
+                        success = { (address, _, _)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
+                        failure = { asmgen.out("$indexVar    .byte  0") }
+                    )
+                } else {
+                    asmgen.out("$indexVar    .byte  0")
+                }
+            }
+            asmgen.out(endLabel)
+        }
+
+        fun iterateSplitWords() {
+            val indexVar = if(asmgen.options.romable)
+                asmgen.createTempVarReused(BaseDataType.UBYTE, false, stmt)
+            else
+                asmgen.makeLabel("for_index")
+            val loopvarName = asmgen.asmVariableName(stmt.variable)
+            asmgen.out("""
                     ldy  #0
 $loopLabel          sty  $indexVar
                     lda  ${iterableName}_lsb,y
                     sta  $loopvarName
                     lda  ${iterableName}_msb,y
                     sta  $loopvarName+1""")
-                asmgen.translate(stmt.statements)
-                if(numElements<=255u) {
-                    asmgen.out("""
+            asmgen.translate(stmt.statements)
+            if(numElements<=255u) {
+                asmgen.out("""
                         ldy  $indexVar
                         iny
                         cpy  #$numElements
                         beq  $endLabel
                         bne  $loopLabel""")
-                } else {
-                    // length is 256
-                    asmgen.out("""
+            } else {
+                // length is 256
+                asmgen.out("""
                         ldy  $indexVar
                         iny
                         bne  $loopLabel
                         beq  $endLabel""")
-                }
-                if(!asmgen.options.romable) {
-                    if(numElements>=16u) {
-                        // allocate index var on ZP if possible, otherwise inline
-                        val result = zeropage.allocate(indexVar, DataType.UBYTE, null, stmt.position, asmgen.errors)
-                        result.fold(
-                            success = { (address, _, _)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
-                            failure = { asmgen.out("$indexVar    .byte  0") }
-                        )
-                    } else {
-                        asmgen.out("$indexVar    .byte  0")
-                    }
-                }
-                asmgen.out(endLabel)
             }
-            iterableDt.isWordArray -> {
-                val indexVar = if(asmgen.options.romable)
-                    asmgen.createTempVarReused(BaseDataType.UBYTE, false, stmt)
-                else
-                    asmgen.makeLabel("for_index")
-                val loopvarName = asmgen.asmVariableName(stmt.variable)
-                asmgen.out("""
+            if(!asmgen.options.romable) {
+                if(numElements>=16u) {
+                    // allocate index var on ZP if possible, otherwise inline
+                    val result = zeropage.allocate(indexVar, DataType.UBYTE, null, stmt.position, asmgen.errors)
+                    result.fold(
+                        success = { (address, _, _)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
+                        failure = { asmgen.out("$indexVar    .byte  0") }
+                    )
+                } else {
+                    asmgen.out("$indexVar    .byte  0")
+                }
+            }
+            asmgen.out(endLabel)
+        }
+
+        fun iterateWords(actuallyLongs: Boolean = false) {
+            val indexVar = if(asmgen.options.romable)
+                asmgen.createTempVarReused(BaseDataType.UBYTE, false, stmt)
+            else
+                asmgen.makeLabel("for_index")
+            val loopvarName = asmgen.asmVariableName(stmt.variable)
+            asmgen.out("""
                     ldy  #0
 $loopLabel          sty  $indexVar
                     lda  $iterableName,y
                     sta  $loopvarName
                     lda  $iterableName+1,y
                     sta  $loopvarName+1""")
-                asmgen.translate(stmt.statements)
-                if(numElements<=127u) {
+            if(actuallyLongs) {
+                asmgen.out("""
+                    lda  $iterableName+2,y
+                    sta  $loopvarName+2
+                    lda  $iterableName+3,y
+                    sta  $loopvarName+3""")
+            }
+            asmgen.translate(stmt.statements)
+            if(numElements<=127u) {
+                if(actuallyLongs) {
+                    asmgen.out("""
+                        ldy  $indexVar
+                        iny
+                        iny
+                        iny
+                        iny
+                        cpy  #${numElements*4u}
+                        beq  $endLabel
+                        bne  $loopLabel""")
+                } else {
                     asmgen.out("""
                         ldy  $indexVar
                         iny
@@ -643,6 +664,19 @@ $loopLabel          sty  $indexVar
                         cpy  #${numElements*2u}
                         beq  $endLabel
                         bne  $loopLabel""")
+                }
+            } else {
+                if(actuallyLongs) {
+                    // array size is 64 longs, 256 bytes
+                    asmgen.out("""
+                        ldy  $indexVar
+                        iny
+                        iny
+                        iny
+                        iny
+                        bne  $loopLabel
+                        beq  $endLabel""")
+
                 } else {
                     // array size is 128 words, 256 bytes
                     asmgen.out("""
@@ -652,23 +686,29 @@ $loopLabel          sty  $indexVar
                         bne  $loopLabel
                         beq  $endLabel""")
                 }
-                if(!asmgen.options.romable) {
-                    if(numElements>=16u) {
-                        // allocate index var on ZP if possible, otherwise inline
-                        val result = zeropage.allocate(indexVar, DataType.UBYTE, null, stmt.position, asmgen.errors)
-                        result.fold(
-                            success = { (address, _, _)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
-                            failure = { asmgen.out("$indexVar    .byte  0") }
-                        )
-                    } else {
-                        asmgen.out("$indexVar    .byte  0")
-                    }
+            }
+            if(!asmgen.options.romable) {
+                if(numElements>=16u) {
+                    // allocate index var on ZP if possible, otherwise inline
+                    val result = zeropage.allocate(indexVar, DataType.UBYTE, null, stmt.position, asmgen.errors)
+                    result.fold(
+                        success = { (address, _, _)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
+                        failure = { asmgen.out("$indexVar    .byte  0") }
+                    )
+                } else {
+                    asmgen.out("$indexVar    .byte  0")
                 }
-                asmgen.out(endLabel)
-            }
-            iterableDt.isFloatArray -> {
-                throw AssemblyError("for loop with floating point variables is not supported")
             }
+            asmgen.out(endLabel)
+        }
+
+        when {
+            iterableDt.isString -> iterateStrings()
+            iterableDt.isByteArray || iterableDt.isBoolArray -> iterateBytes()
+            iterableDt.isSplitWordArray -> iterateSplitWords()
+            iterableDt.isWordArray -> iterateWords()
+            iterableDt.isLongArray -> iterateWords(true)
+            iterableDt.isFloatArray -> throw AssemblyError("for loop with floating point variables is not supported")
             else -> throw AssemblyError("can't iterate over $iterableDt")
         }
         asmgen.loopEndLabels.removeLast()

codeGenCpu6502/src/prog8/codegen/cpu6502/FunctionCallAsmGen.kt

@@ -21,7 +21,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         // we consider them NOT to be optimized into (possibly different) CPU registers.
         // Just load them in whatever the register spec says.
         return when (params.size) {
-            1 -> params[0].register == null && (params[0].type.isIntegerOrBool || params[0].type.isPointer)
+            1 -> params[0].register == null && (params[0].type.isWordOrByteOrBool || params[0].type.isPointer)
             2 -> params[0].type.isByteOrBool && params[1].type.isByteOrBool && params[0].register == null && params[1].register == null
             else -> false
         }
@@ -206,8 +206,11 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
             is PtBuiltinFunctionCall -> {
                 if (arg.name in arrayOf("lsb", "msb", "lsw", "msw"))
                     return usesOtherRegistersWhileEvaluating(arg.args[0])
-                if (arg.name == "mkword")
+                if (arg.name == "mkword" || arg.name == "mklong2")
                     return usesOtherRegistersWhileEvaluating(arg.args[0]) || usesOtherRegistersWhileEvaluating(arg.args[1])
+                if (arg.name == "mklong")
+                    return usesOtherRegistersWhileEvaluating(arg.args[0]) || usesOtherRegistersWhileEvaluating(arg.args[1]) ||
+                           usesOtherRegistersWhileEvaluating(arg.args[2]) || usesOtherRegistersWhileEvaluating(arg.args[3])
                 return !arg.isSimple()
             }
             is PtAddressOf -> false
@@ -276,7 +279,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
     private fun argumentViaRegister(sub: IPtSubroutine, parameter: IndexedValue<PtSubroutineParameter>, value: PtExpression, registerOverride: RegisterOrPair? = null): RegisterOrStatusflag {
         // pass argument via a register parameter
         if(!isArgumentTypeCompatible(value.type, parameter.value.type))
-            throw AssemblyError("argument type incompatible")
+            throw AssemblyError("argument type incompatible ${value.type} vs param ${parameter.value.type} at ${parameter.value.position}")
 
         val paramRegister: RegisterOrStatusflag = when(sub) {
             is PtAsmSub -> if(registerOverride==null) sub.parameters[parameter.index].first else RegisterOrStatusflag(registerOverride, null)
@@ -359,12 +362,17 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
     private fun isArgumentTypeCompatible(argType: DataType, paramType: DataType): Boolean {
         if(argType isAssignableTo paramType)
             return true
-        if(argType.isBool && paramType.isBool)
-            return true
+
+        // signed/unsigned args vs parameters are considered compatible
         if(argType.isByte && paramType.isByte)
             return true
         if(argType.isWord && paramType.isWord)
             return true
+// only signed longs and floats are available so these were already covered
+//        if(argType.isLong && paramType.isLong)
+//            return true
+//        if(argType.isFloat && paramType.isFloat)
+//            return true
 
         // we have a special rule for some types.
         // strings are assignable to UWORD, for example, and vice versa

codeGenCpu6502/src/prog8/codegen/cpu6502/IfElseAsmGen.kt

@@ -46,6 +46,7 @@ internal class IfElseAsmGen(private val program: PtProgram,
             return when {
                 rightDt.isByteOrBool -> translateIfByte(stmt, jumpAfterIf)
                 rightDt.isWord || rightDt.isPointer -> translateIfWord(stmt, compareCond, jumpAfterIf)
+                rightDt.isLong -> translateIfLong(stmt, compareCond, jumpAfterIf)
                 rightDt.isFloat -> translateIfFloat(stmt, compareCond, jumpAfterIf)
                 else -> throw AssemblyError("weird dt")
             }
@@ -575,6 +576,29 @@ internal class IfElseAsmGen(private val program: PtProgram,
         }
     }
 
+    private fun translateIfLong(stmt: PtIfElse, condition: PtBinaryExpression, jumpAfterIf: PtJump?) {
+        val constValue = condition.right.asConstInteger()
+        if(constValue==0) {
+            // optimized comparisons with zero
+            return when (condition.operator) {
+                "==" -> longEqualsZero(condition.left, false, jumpAfterIf, stmt)
+                "!=" -> longEqualsZero(condition.left, true, jumpAfterIf, stmt)
+                "<" -> longLessZero(condition.left, false, jumpAfterIf, stmt)
+                "<=" -> longLessZero(condition.left, true, jumpAfterIf, stmt)
+                ">" -> longGreaterZero(condition.left, false, jumpAfterIf, stmt)
+                ">=" -> longGreaterZero(condition.left, true, jumpAfterIf, stmt)
+                else -> throw AssemblyError("expected comparison operator")
+            }
+        }
+
+        return when (condition.operator) {
+            "==" -> longEqualsValue(condition.left, condition.right, false, jumpAfterIf, stmt)
+            "!=" -> longEqualsValue(condition.left, condition.right, true, jumpAfterIf, stmt)
+            "<", "<=", ">", ">=" -> compareLongValues(condition.left, condition.operator, condition.right, jumpAfterIf, stmt)
+            else -> throw AssemblyError("expected comparison operator")
+        }
+    }
+
     private fun translateIfWord(stmt: PtIfElse, condition: PtBinaryExpression, jumpAfterIf: PtJump?) {
         val signed = condition.left.type.isSigned
         val constValue = condition.right.asConstInteger()
@@ -606,7 +630,7 @@ internal class IfElseAsmGen(private val program: PtProgram,
     private fun wordGreaterEqualsZero(value: PtExpression, signed: Boolean, jump: PtJump?, stmt: PtIfElse) {
         // special case for word>=0
         if(signed) {
-            loadAndCmp0MSB(value)
+            loadAndCmp0MSB(value, false)
             if (jump != null)
                 translateJumpElseBodies("bpl", "bmi", jump, stmt.elseScope)
             else
@@ -619,7 +643,7 @@ internal class IfElseAsmGen(private val program: PtProgram,
     private fun wordLessZero(value: PtExpression, signed: Boolean, jump: PtJump?, stmt: PtIfElse) {
         // special case for word<0
         if(signed) {
-            loadAndCmp0MSB(value)
+            loadAndCmp0MSB(value, false)
             if (jump != null)
                 translateJumpElseBodies("bmi", "bpl", jump, stmt.elseScope)
             else
@@ -894,23 +918,31 @@ _jump                       jmp  (${target.asmLabel})
     }
 
 
-    private fun loadAndCmp0MSB(value: PtExpression) {
+    private fun loadAndCmp0MSB(value: PtExpression, long: Boolean) {
         when(value) {
             is PtArrayIndexer -> {
                 if(value.variable==null)
                     TODO("support for ptr indexing ${value.position}")
                 val varname = asmgen.asmVariableName(value.variable!!)
                 asmgen.loadScaledArrayIndexIntoRegister(value, CpuRegister.Y)
-                if(value.splitWords)
+                if(value.splitWords) {
+                    require(!long)
                     asmgen.out("  lda  ${varname}_msb,y")
+                }
+                else if(long)
+                    asmgen.out("  lda  $varname+3,y")
                 else
                     asmgen.out("  lda  $varname+1,y")
             }
             is PtIdentifier -> {
                 val varname = asmgen.asmVariableName(value)
-                asmgen.out("  lda  $varname+1")
+                if(long)
+                    asmgen.out("  lda  $varname+3")
+                else
+                    asmgen.out("  lda  $varname+1")
             }
             is PtAddressOf -> {
+                require(!long) {"addresses must still be words not longs"}
                 if(value.isFromArrayElement) {
                     asmgen.assignExpressionToRegister(value, RegisterOrPair.AY, true)
                     asmgen.out("  cpy  #0")
@@ -923,8 +955,14 @@ _jump                       jmp  (${target.asmLabel})
                 }
             }
             else -> {
-                asmgen.assignExpressionToRegister(value, RegisterOrPair.AY, true)
-                asmgen.out("  cpy  #0")
+                if(long) {
+                    // note: clobbers R14+R15
+                    asmgen.assignExpressionToRegister(value, RegisterOrPair.R14R15_32, true)
+                    asmgen.out("  lda  cx16.r14+3")
+                } else {
+                    asmgen.assignExpressionToRegister(value, RegisterOrPair.AY, true)
+                    asmgen.out("  cpy  #0")
+                }
             }
         }
     }
@@ -1226,6 +1264,93 @@ _jump                       jmp  (${target.asmLabel})
         }
     }
 
+    private fun longEqualsZero(value: PtExpression, notEquals: Boolean, jump: PtJump?, stmt: PtIfElse) {
+        if(value is PtIdentifier) {
+            val varname = asmgen.asmVariableName(value)
+            asmgen.out("""
+                lda  $varname
+                ora  $varname+1
+                ora  $varname+2
+                ora  $varname+3""")
+        } else {
+            asmgen.pushLongRegisters(RegisterOrPair.R14R15_32, 1)
+            asmgen.assignExpressionToRegister(value, RegisterOrPair.R14R15_32, value.type.isSigned)
+            asmgen.out("""
+                lda  cx16.r14
+                ora  cx16.r14+1
+                ora  cx16.r14+2
+                ora  cx16.r14+3
+                sta  P8ZP_SCRATCH_REG""")
+            asmgen.popLongRegisters(RegisterOrPair.R14R15_32, 1)
+            asmgen.out("  lda  P8ZP_SCRATCH_REG  ; restore flags")
+        }
+        if(notEquals) {
+            if (jump != null)
+                translateJumpElseBodies("bne", "beq", jump, stmt.elseScope)
+            else
+                translateIfElseBodies("beq", stmt)
+        } else {
+            if (jump != null)
+                translateJumpElseBodies("beq", "bne", jump, stmt.elseScope)
+            else
+                translateIfElseBodies("bne", stmt)
+        }
+    }
+
+    private fun longLessZero(value: PtExpression, lessEquals: Boolean, jump: PtJump?, stmt: PtIfElse) {
+        if(lessEquals) {
+            loadAndCheck0OrSignIntoCarry(value, true)
+            if (jump != null)
+                translateJumpElseBodies("bcs", "bcc", jump, stmt.elseScope)
+            else
+                translateIfElseBodies("bcc", stmt)
+        } else {
+            loadAndCmp0MSB(value, true)
+            if (jump != null)
+                translateJumpElseBodies("bmi", "bpl", jump, stmt.elseScope)
+            else
+                translateIfElseBodies("bpl", stmt)
+        }
+    }
+
+    private fun longGreaterZero(value: PtExpression, lessEquals: Boolean, jump: PtJump?, stmt: PtIfElse) {
+        if(lessEquals) {
+            loadAndCheck0OrSignIntoCarry(value, false)
+            if (jump != null)
+                translateJumpElseBodies("bcs", "bcc", jump, stmt.elseScope)
+            else
+                translateIfElseBodies("bcc", stmt)
+        } else {
+            loadAndCmp0MSB(value, true)
+            if (jump != null)
+                translateJumpElseBodies("bpl", "bmi", jump, stmt.elseScope)
+            else
+                translateIfElseBodies("bmi", stmt)
+        }
+    }
+
+    private fun loadAndCheck0OrSignIntoCarry(value: PtExpression, negative: Boolean) {
+        if(value is PtIdentifier) {
+            val varname = asmgen.asmVariableName(value)
+            asmgen.out("""
+                lda  #<$varname
+                ldy  #>$varname
+                sta  P8ZP_SCRATCH_W1
+                sty  P8ZP_SCRATCH_W1+1""")
+            asmgen.out(if(negative) "  sec" else "  clc")
+            asmgen.out("  jsr  prog8_lib.compare_long_0_and_sign")
+        } else {
+            assignmentAsmGen.assignExpressionToRegister(value, RegisterOrPair.R14R15_32, value.type.isSigned)
+            asmgen.out("""
+                lda  #<cx16.r14
+                ldy  #>cx16.r14
+                sta  P8ZP_SCRATCH_W1
+                sty  P8ZP_SCRATCH_W1+1""")
+            asmgen.out(if(negative) "  sec" else "  clc")
+            asmgen.out("  jsr  prog8_lib.compare_long_0_and_sign")
+        }
+    }
+
     private fun wordEqualsZero(value: PtExpression, notEquals: Boolean, signed: Boolean, jump: PtJump?, stmt: PtIfElse) {
 
         // special case for (u)word == 0
@@ -1303,6 +1428,141 @@ _jump                       jmp  (${target.asmLabel})
         }
     }
 
+    private fun longEqualsValue(
+        left: PtExpression,
+        right: PtExpression,
+        notEquals: Boolean,
+        jump: PtJump?,
+        stmt: PtIfElse
+    ) {
+        val constRight = right.asConstInteger()
+        val variableRight = (right as? PtIdentifier)?.name
+
+        if(left is PtIdentifier) {
+            val leftvar = asmgen.asmVariableName(left)
+            if(constRight!=null) {
+                val hex = constRight.toLongHex()
+                asmgen.out("""
+                    lda  $leftvar
+                    cmp  #$${hex.substring(6,8)}
+                    bne  +
+                    lda  $leftvar+1
+                    cmp  #$${hex.substring(4, 6)}
+                    bne  +
+                    lda  $leftvar+2
+                    cmp  #$${hex.substring(2, 4)}
+                    bne  +
+                    lda  $leftvar+3
+                    cmp  #$${hex.take(2)}
++""")
+            } else if(variableRight!=null) {
+                require(right.type.isLong)
+                asmgen.out("""
+                    lda  #<$leftvar
+                    ldy  #>$leftvar
+                    sta  P8ZP_SCRATCH_W1
+                    sty  P8ZP_SCRATCH_W1+1
+                    lda  #<$variableRight
+                    ldy  #>$variableRight
+                    jsr  prog8_lib.long_not_equals""")
+            }
+        }
+        else
+        {
+            // TODO cannot easily preserve R14:R15 on stack because we need the status flags of the comparison in between...
+            asmgen.assignExpressionToRegister(left, RegisterOrPair.R14R15_32, left.type.isSigned)
+            if(constRight!=null) {
+                val hex = constRight.toLongHex()
+                asmgen.out("""
+                    lda  cx16.r14
+                    cmp  #$${hex.substring(6,8)}
+                    bne  +
+                    lda  cx16.r14+1
+                    cmp  #$${hex.substring(4, 6)}
+                    bne  +
+                    lda  cx16.r14+2
+                    cmp  #$${hex.substring(2, 4)}
+                    bne  +
+                    lda  cx16.r14+3
+                    cmp  #$${hex.take(2)}
++""")
+            } else if(variableRight!=null) {
+                require(right.type.isLong)
+                asmgen.out("""
+                    lda  cx16.r14
+                    cmp  $variableRight
+                    bne  +
+                    lda  cx16.r14+1
+                    cmp  $variableRight+1
+                    bne  +
+                    lda  cx16.r14+2
+                    cmp  $variableRight+2
+                    bne  +
+                    lda  cx16.r14+3
+                    cmp  $variableRight+3
++""")
+            } else {
+                TODO("long == value expression ${right.position}")
+            }
+        }
+
+        if(notEquals) {
+            if (jump != null)
+                translateJumpElseBodies("bne", "beq", jump, stmt.elseScope)
+            else
+                translateIfElseBodies("beq", stmt)
+        } else {
+            if (jump != null)
+                translateJumpElseBodies("beq", "bne", jump, stmt.elseScope)
+            else
+                translateIfElseBodies("bne", stmt)
+        }
+    }
+
+    private fun compareLongValues(
+        left: PtExpression,
+        operator: String,
+        right: PtExpression,
+        jump: PtJump?,
+        stmt: PtIfElse
+    ) {
+        // this comparison is not part of an expression but part of an if statement, there's no need to save the previous values of the temp registers
+
+        if(operator=="<" || operator ==">=") {
+            assignmentAsmGen.assignExpressionToRegister(right, RegisterOrPair.R14R15_32, left.type.isSigned)
+            assignmentAsmGen.assignExpressionToRegister(left, RegisterOrPair.R12R13_32, left.type.isSigned)
+        } else {
+            // flip operands
+            assignmentAsmGen.assignExpressionToRegister(left, RegisterOrPair.R14R15_32, left.type.isSigned)
+            assignmentAsmGen.assignExpressionToRegister(right, RegisterOrPair.R12R13_32, left.type.isSigned)
+        }
+        asmgen.out("""
+            sec
+            lda  cx16.r12
+            sbc  cx16.r14
+            lda  cx16.r12+1
+            sbc  cx16.r14+1
+            lda  cx16.r12+2
+            sbc  cx16.r14+2
+            lda  cx16.r12+3
+            sbc  cx16.r14+3""")
+        when(operator) {
+            "<", ">" -> {
+                if (jump != null)
+                    translateJumpElseBodies("bmi", "bpl", jump, stmt.elseScope)
+                else
+                    translateIfElseBodies("bpl", stmt)
+            }
+            ">=", "<=" -> {
+                if (jump != null)
+                    translateJumpElseBodies("bpl", "bmi", jump, stmt.elseScope)
+                else
+                    translateIfElseBodies("bmi", stmt)
+            }
+            else -> throw RuntimeException("invalid operator $operator")
+        }
+    }
+
     private fun wordEqualsValue(
         left: PtExpression,
         right: PtExpression,
@@ -1709,7 +1969,7 @@ _jump                       jmp  (${target.asmLabel})
                     if(notEquals)
                         translateAYNotEquals("P8ZP_SCRATCH_W1", "P8ZP_SCRATCH_W1+1")
                     else
-                        translateAYNotEquals("P8ZP_SCRATCH_W1", "P8ZP_SCRATCH_W1+1")
+                        translateAYEquals("P8ZP_SCRATCH_W1", "P8ZP_SCRATCH_W1+1")
                 }
             }
         }
@@ -1889,4 +2149,5 @@ _jump                       jmp  (${target.asmLabel})
             else -> throw AssemblyError("expected comparison operator")
         }
     }
-}
+}
+

codeGenCpu6502/src/prog8/codegen/cpu6502/IfExpressionAsmGen.kt

@@ -15,32 +15,27 @@ internal class IfExpressionAsmGen(private val asmgen: AsmGen6502Internal, privat
         val falseLabel = asmgen.makeLabel("ifexpr_false")
         val endLabel = asmgen.makeLabel("ifexpr_end")
         evalIfExpressionConditonAndBranchWhenFalse(expr.condition, falseLabel)
-        when {
-            expr.type.isByteOrBool -> {
-                asmgen.assignExpressionToRegister(expr.truevalue, RegisterOrPair.A)
-                asmgen.jmp(endLabel)
-                asmgen.out(falseLabel)
-                asmgen.assignExpressionToRegister(expr.falsevalue, RegisterOrPair.A)
-                asmgen.out(endLabel)
-                assignmentAsmGen.assignRegisterByte(target, CpuRegister.A, false, false)
-            }
-            expr.type.isWord || expr.type.isString -> {
-                asmgen.assignExpressionToRegister(expr.truevalue, RegisterOrPair.AY)
-                asmgen.jmp(endLabel)
-                asmgen.out(falseLabel)
-                asmgen.assignExpressionToRegister(expr.falsevalue, RegisterOrPair.AY)
-                asmgen.out(endLabel)
-                assignmentAsmGen.assignRegisterpairWord(target, RegisterOrPair.AY)
-            }
-            expr.type.isFloat -> {
-                asmgen.assignExpressionToRegister(expr.truevalue, RegisterOrPair.FAC1, true)
-                asmgen.jmp(endLabel)
-                asmgen.out(falseLabel)
-                asmgen.assignExpressionToRegister(expr.falsevalue, RegisterOrPair.FAC1, true)
-                asmgen.out(endLabel)
-                asmgen.assignRegister(RegisterOrPair.FAC1, target)
-            }
-            else -> throw AssemblyError("weird dt")
+
+        if(expr.type.isByteOrBool) {
+            asmgen.assignExpressionToRegister(expr.truevalue, RegisterOrPair.A)
+            asmgen.jmp(endLabel)
+            asmgen.out(falseLabel)
+            asmgen.assignExpressionToRegister(expr.falsevalue, RegisterOrPair.A)
+            asmgen.out(endLabel)
+            assignmentAsmGen.assignRegisterByte(target, CpuRegister.A, false, false)
+        } else if(expr.type.isFloat) {
+            asmgen.assignExpressionToRegister(expr.truevalue, RegisterOrPair.FAC1, true)
+            asmgen.jmp(endLabel)
+            asmgen.out(falseLabel)
+            asmgen.assignExpressionToRegister(expr.falsevalue, RegisterOrPair.FAC1, true)
+            asmgen.out(endLabel)
+            asmgen.assignRegister(RegisterOrPair.FAC1, target)
+        } else {
+            asmgen.assignExpressionTo(expr.truevalue, target)
+            asmgen.jmp(endLabel)
+            asmgen.out(falseLabel)
+            asmgen.assignExpressionTo(expr.falsevalue, target)
+            asmgen.out(endLabel)
         }
     }
 
@@ -114,6 +109,7 @@ internal class IfExpressionAsmGen(private val asmgen: AsmGen6502Internal, privat
                 return when {
                     rightDt.isByteOrBool -> translateIfExpressionByteConditionBranch(condition, falseLabel)
                     rightDt.isWord -> translateIfExpressionWordConditionBranch(condition, falseLabel)
+                    rightDt.isLong -> translateIfExpressionLongConditionBranch(condition, falseLabel)
                     rightDt.isFloat -> translateIfExpressionFloatConditionBranch(condition, falseLabel)
                     else -> throw AssemblyError("weird dt")
                 }
@@ -200,6 +196,36 @@ internal class IfExpressionAsmGen(private val asmgen: AsmGen6502Internal, privat
         asmgen.out("  beq  $falseLabel")
     }
 
+    private fun translateIfExpressionLongConditionBranch(condition: PtBinaryExpression, falseLabel: String) {
+        // TODO can we reuse this whole thing from IfElse ?
+        val constValue = condition.right.asConstInteger()
+        if(constValue!=null) {
+            if (constValue == 0) {
+                when (condition.operator) {
+                    "==" -> return translateLongExprIsZero(condition.left, falseLabel)
+                    "!=" -> return translateLongExprIsNotZero(condition.left, falseLabel)
+                }
+            }
+            if (constValue != 0) {
+                when (condition.operator) {
+                    "==" -> return translateLongExprEqualsNumber(condition.left, constValue, falseLabel)
+                    "!=" -> return translateLongExprNotEqualsNumber(condition.left, constValue, falseLabel)
+                }
+            }
+        }
+        val variable = condition.right as? PtIdentifier
+        if(variable!=null) {
+            when (condition.operator) {
+                "==" -> return translateLongExprEqualsVariable(condition.left, variable, falseLabel)
+                "!=" -> return translateLongExprNotEqualsVariable(condition.left, variable, falseLabel)
+            }
+        }
+
+        // TODO don't store condition as expression result but just use the flags, like a normal PtIfElse translation does
+        asmgen.assignConditionValueToRegisterAndTest(condition)
+        asmgen.out("  beq  $falseLabel")
+    }
+
     private fun translateIfExpressionFloatConditionBranch(condition: PtBinaryExpression, elseLabel: String) {
         val constValue = (condition.right as? PtNumber)?.number
         if(constValue==0.0) {
@@ -339,6 +365,91 @@ internal class IfExpressionAsmGen(private val asmgen: AsmGen6502Internal, privat
         }
     }
 
+    private fun translateLongExprEqualsNumber(expr: PtExpression, number: Int, falseLabel: String) {
+        // if L==number
+        // TODO reuse code from ifElse?
+        val hex = number.toLongHex()
+        if(expr is PtIdentifier) {
+            val varname = asmgen.asmVariableName(expr)
+            asmgen.out("""
+                lda  $varname
+                cmp  #$${hex.substring(6, 8)}
+                bne  $falseLabel
+                lda  $varname+1
+                cmp  #$${hex.substring(4, 6)}
+                bne  $falseLabel
+                lda  $varname+2
+                cmp  #$${hex.substring(2, 4)}
+                bne  $falseLabel
+                lda  $varname+3
+                cmp  #$${hex.take(2)}
+                bne  $falseLabel""")
+        } else {
+            // TODO cannot easily preserve R14:R15 on stack because we need the status flags of the comparison in between...
+            asmgen.assignExpressionToRegister(expr, RegisterOrPair.R14R15_32, expr.type.isSigned)
+            asmgen.out("""
+                lda  cx16.r14
+                cmp  #$${hex.substring(6, 8)}
+                bne  $falseLabel
+                lda  cx16.r14+1
+                cmp  #$${hex.substring(4, 6)}
+                bne  $falseLabel
+                lda  cx16.r14+2
+                cmp  #$${hex.substring(2, 4)}
+                bne  $falseLabel
+                lda  cx16.r14+3
+                cmp  #$${hex.take(2)}
+                bne  $falseLabel""")
+        }
+    }
+
+    private fun translateLongExprEqualsVariable(expr: PtExpression, variable: PtIdentifier, falseLabel: String) {
+        // if L==variable
+        // TODO reuse code from ifElse?
+        val varname2 = asmgen.asmVariableName(variable)
+        if(expr is PtIdentifier) {
+            val varname = asmgen.asmVariableName(expr)
+            asmgen.out("""
+                lda  $varname
+                cmp  $varname2
+                bne  $falseLabel
+                lda  $varname+1
+                cmp  $varname2+1
+                bne  $falseLabel
+                lda  $varname+2
+                cmp  $varname2+2
+                bne  $falseLabel
+                lda  $varname+3
+                cmp  $varname2+3
+                bne  $falseLabel""")
+        } else {
+            // TODO cannot easily preserve R14:R15 on stack because we need the status flags of the comparison in between...
+            asmgen.assignExpressionToRegister(expr, RegisterOrPair.R14R15_32, expr.type.isSigned)
+            asmgen.out("""
+                lda  cx16.r14
+                cmp  $varname2
+                bne  $falseLabel
+                lda  cx16.r14+1
+                cmp  $varname2+1
+                bne  $falseLabel
+                lda  cx16.r14+2
+                cmp  $varname2+2
+                bne  $falseLabel
+                lda  cx16.r14+3
+                cmp  $varname2+3
+                bne  $falseLabel""")
+        }
+    }
+
+    private fun translateLongExprNotEqualsNumber(expr: PtExpression, number: Int, falseLabel: String) {
+        TODO("if expression LONG != number ${expr.position}")
+    }
+
+    private fun translateLongExprNotEqualsVariable(expr: PtExpression, variable: PtIdentifier, falseLabel: String) {
+        // if L!=variable
+        TODO("if expression LONG != variable ${expr.position}")
+    }
+
     private fun translateWordExprIsNotZero(expr: PtExpression, falseLabel: String) {
         // if w!=0
         // TODO reuse code from ifElse?
@@ -369,6 +480,56 @@ internal class IfExpressionAsmGen(private val asmgen: AsmGen6502Internal, privat
         }
     }
 
+    private fun translateLongExprIsZero(expr: PtExpression, falseLabel: String) {
+        // if L==0
+        // TODO reuse code from ifElse?
+        if(expr is PtIdentifier) {
+            val varname = asmgen.asmVariableName(expr)
+            asmgen.out("""
+                lda  $varname
+                ora  $varname+1
+                ora  $varname+2
+                ora  $varname+3
+                bne  $falseLabel""")
+        } else {
+            asmgen.pushLongRegisters(RegisterOrPair.R14R15_32, 1)
+            asmgen.assignExpressionToRegister(expr, RegisterOrPair.R14R15_32, expr.type.isSigned)
+            asmgen.out("""
+                lda  cx16.r14
+                ora  cx16.r14+1
+                ora  cx16.r14+2
+                ora  cx16.r14+3
+                sta  P8ZP_SCRATCH_REG""")
+            asmgen.popLongRegisters(RegisterOrPair.R14R15_32, 1)
+            asmgen.out("  lda  P8ZP_SCRATCH_REG |  bne  $falseLabel")
+        }
+    }
+
+    private fun translateLongExprIsNotZero(expr: PtExpression, falseLabel: String) {
+        // if L!=0
+        // TODO reuse code from ifElse?
+        if(expr is PtIdentifier) {
+            val varname = asmgen.asmVariableName(expr)
+            asmgen.out("""
+                lda  $varname
+                ora  $varname+1
+                ora  $varname+2
+                ora  $varname+3
+                beq  $falseLabel""")
+        } else {
+            asmgen.pushLongRegisters(RegisterOrPair.R14R15_32, 1)
+            asmgen.assignExpressionToRegister(expr, RegisterOrPair.R14R15_32, expr.type.isSigned)
+            asmgen.out("""
+                lda  cx16.r14
+                ora  cx16.r14+1
+                ora  cx16.r14+2
+                ora  cx16.r14+3
+                sta  P8ZP_SCRATCH_REG""")
+            asmgen.popLongRegisters(RegisterOrPair.R14R15_32, 1)
+            asmgen.out("  lda  P8ZP_SCRATCH_REG |  beq  $falseLabel")
+        }
+    }
+
     private fun translateIfCompareWithZeroByteBranch(condition: PtBinaryExpression, signed: Boolean, falseLabel: String) {
         // optimized code for byte comparisons with 0
 

codeGenCpu6502/src/prog8/codegen/cpu6502/ProgramAndVarsGen.kt

@@ -377,6 +377,7 @@ internal class ProgramAndVarsGen(
             dt.isSignedByte -> ".char"
             dt.isUnsignedWord || dt.isPointer -> ".word"
             dt.isSignedWord -> ".sint"
+            dt.isLong -> ".dint"
             dt.isFloat -> ".byte"
             else -> {
                 throw AssemblyError("weird dt")
@@ -411,27 +412,19 @@ internal class ProgramAndVarsGen(
 
 
         asmgen.out("; struct types")
-        symboltable.allStructInstances.distinctBy { it.structName }.forEach {
-            val structtype: StStruct = symboltable.lookup(it.structName) as StStruct
+        symboltable.allStructTypes().distinctBy { it.name }.forEach { structtype ->
             val structargs = structtype.fields.withIndex().joinToString(",") { field -> "f${field.index}" }
-            asmgen.out("${it.structName}    .struct $structargs\n")
+            asmgen.out("${structtype.scopedNameString}    .struct $structargs\n")
             structtype.fields.withIndex().forEach { (index, field) ->
                 val dt = field.first
                 val varname = "f${index}"
-                val type = when {
-                    dt.isBool || dt.isUnsignedByte -> ".byte"
-                    dt.isSignedByte -> ".char"
-                    dt.isUnsignedWord || dt.isPointer -> ".word"
-                    dt.isSignedWord -> ".sint"
-                    dt.isFloat -> ".byte"   // TODO check that float bytes are passed as an array parameter
-                    else -> throw AssemblyError("weird dt")
-                }
+                val type = asmTypeString(dt)
                 asmgen.out("p8v_${field.second}  $type  \\$varname")        // note: struct field symbol prefixing done here because that is a lot simpler than fixing up all expressions in the AST
             }
             asmgen.out("    .endstruct\n")
         }
 
-        val (instancesNoInit, instances) = symboltable.allStructInstances.partition { it.initialValues.isEmpty() }
+        val (instancesNoInit, instances) = symboltable.allStructInstances().partition { it.initialValues.isEmpty() }
         asmgen.out("; struct instances without initialization values, as BSS zeroed at startup\n")
         asmgen.out("    .section BSS\n")
         asmgen.out("${StStructInstanceBlockName}_bss  .block\n")
@@ -571,6 +564,7 @@ internal class ProgramAndVarsGen(
             else when(dt) {
                 BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.BOOL -> asmgen.out("$name    .byte  ?")
                 BaseDataType.UWORD, BaseDataType.WORD -> asmgen.out("$name    .word  ?")
+                BaseDataType.LONG -> asmgen.out("$name    .sint  ?")
                 BaseDataType.FLOAT -> asmgen.out("$name    .fill  ${options.compTarget.FLOAT_MEM_SIZE}")
                 else -> throw AssemblyError("weird dt for extravar $dt")
             }
@@ -781,6 +775,7 @@ internal class ProgramAndVarsGen(
             dt.isSignedByte -> asmgen.out("${variable.name}\t.char  ?")
             dt.isUnsignedWord -> asmgen.out("${variable.name}\t.word  ?")
             dt.isSignedWord -> asmgen.out("${variable.name}\t.sint  ?")
+            dt.isLong -> asmgen.out("${variable.name}\t.dint  ?")
             dt.isFloat -> asmgen.out("${variable.name}\t.fill  ${compTarget.FLOAT_MEM_SIZE}")
             dt.isSplitWordArray -> {
                 alignVar(variable.align)
@@ -795,7 +790,7 @@ internal class ProgramAndVarsGen(
             }
             dt.isPointer -> asmgen.out("${variable.name}\t.word  ?")        // a pointer is just an uword address
             dt.isPointerArray -> {
-                TODO("pointers are not supported yet")
+                TODO("pointers are not supported yet for uninitialized array ${variable.astNode?.position}")
             }
             else -> {
                 throw AssemblyError("weird dt")
@@ -829,6 +824,7 @@ internal class ProgramAndVarsGen(
 //            dt.isSignedByte -> asmgen.out("${variable.name}\t.char  $initialValue")
 //            dt.isUnsignedWord -> asmgen.out("${variable.name}\t.word  ${initialValue.toHex()}")
 //            dt.isSignedWord -> asmgen.out("${variable.name}\t.sint  $initialValue")
+//            dt.isLong -> asmgen.out("${variable.name}\t.dint  $initialValue")
 //            dt.isFloat -> {
 //                if(initialValue==0) {
 //                    asmgen.out("${variable.name}\t.byte  0,0,0,0,0  ; float")
@@ -905,6 +901,16 @@ internal class ProgramAndVarsGen(
                         asmgen.out("  .sint  " + chunk.joinToString())
                 }
             }
+            dt.isLongArray -> {
+                val data = makeArrayFillDataSigned(dt, value, orNumberOfZeros)
+                if (data.size <= 16)
+                    asmgen.out("$varname\t.dint  ${data.joinToString()}")
+                else {
+                    asmgen.out(varname)
+                    for (chunk in data.chunked(16))
+                        asmgen.out("  .dint  " + chunk.joinToString())
+                }
+            }
             dt.isFloatArray -> {
                 val array = value ?: zeroFilledArray(orNumberOfZeros!!)
                 val floatFills = array.map {
@@ -931,7 +937,7 @@ internal class ProgramAndVarsGen(
             asmgen.out("  ${it.name} = ${it.address.toHex()}")
         }
         consts.sortedBy { it.name }.forEach {
-            if(it.dt==BaseDataType.FLOAT)
+            if(it.dt.isFloat)
                 asmgen.out("  ${it.name} = ${it.value}")
             else
                 asmgen.out("  ${it.name} = ${it.value.toHex()}")
@@ -1027,7 +1033,7 @@ internal class ProgramAndVarsGen(
                 val number = it.number!!.toInt()
                 "$" + number.toString(16).padStart(4, '0')
             }
-            dt.isArray && dt.elementType().isSignedWord -> array.map {
+            dt.isSignedWordArray -> array.map {
                 val number = it.number!!.toInt()
                 val hexnum = number.absoluteValue.toString(16).padStart(4, '0')
                 if(number>=0)
@@ -1035,6 +1041,14 @@ internal class ProgramAndVarsGen(
                 else
                     "-$$hexnum"
             }
+            dt.isLongArray -> array.map {
+                val number = it.number!!.toInt()
+                val hexnum = number.absoluteValue.toLongHex()
+                if(number>=0)
+                    "$$hexnum"
+                else
+                    "-$$hexnum"
+            }
             else -> throw AssemblyError("invalid dt")
         }
     }

codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AnyExprAsmGen.kt

@@ -42,6 +42,12 @@ internal class AnyExprAsmGen(
                 }
                 throw AssemblyError("expression should have been handled otherwise: word ${expr.operator} at ${expr.position}")
             }
+            expr.type.isLong -> {
+                require(expr.left.type.isLong && expr.right.type.isLong) {
+                    "both operands must be longs"
+                }
+                throw AssemblyError("expression should have been handled otherwise: long ${expr.operator} at ${expr.position}")
+            }
             expr.type.isFloat -> {
                 require(expr.left.type.isFloat && expr.right.type.isFloat) {
                     "both operands must be floats"
@@ -179,7 +185,7 @@ internal class AnyExprAsmGen(
                 asmgen.assignRegister(RegisterOrPair.A, assign.target)
                 return true
             }
-            else -> TODO("float expression operator ${expr.operator}")
+            else -> TODO("float expression operator ${expr.operator}  ${expr.position}")
         }
     }
 

codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt

@@ -43,7 +43,7 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
             variableAsmName!!
         else {
             if(array.variable==null)
-                TODO("asmVarname for array with pointer")
+                TODO("asmVarname for array with pointer $position")
             asmgen.asmVariableName(array.variable!!)
         }
     }
@@ -114,25 +114,17 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
                     RegisterOrPair.FAC2 -> {
                         AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, DataType.FLOAT, scope, pos, register = registers)
                     }
-                    RegisterOrPair.R0,
-                    RegisterOrPair.R1,
-                    RegisterOrPair.R2,
-                    RegisterOrPair.R3,
-                    RegisterOrPair.R4,
-                    RegisterOrPair.R5,
-                    RegisterOrPair.R6,
-                    RegisterOrPair.R7,
-                    RegisterOrPair.R8,
-                    RegisterOrPair.R9,
-                    RegisterOrPair.R10,
-                    RegisterOrPair.R11,
-                    RegisterOrPair.R12,
-                    RegisterOrPair.R13,
-                    RegisterOrPair.R14,
-                    RegisterOrPair.R15 -> {
+                    in Cx16VirtualRegisters -> {
                         val dt = if(signed) DataType.WORD else DataType.UWORD
                         AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, dt, scope, pos, register = registers)
                     }
+                    in combinedLongRegisters -> {
+                        val dt = if(signed) DataType.LONG
+                            else
+                                TODO("unsigned long $pos")
+                        AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, dt, scope, pos, register = registers)
+                    }
+                    else -> throw AssemblyError("weird register $registers")
                 }
     }
 

codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt

@@ -4,6 +4,7 @@ import prog8.code.ast.*
 import prog8.code.core.*
 import prog8.codegen.cpu6502.AsmGen6502Internal
 import prog8.codegen.cpu6502.VariableAllocator
+import prog8.codegen.cpu6502.toLongHex
 
 
 internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
@@ -106,13 +107,24 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                             }
                         }
                     }
+                    target.datatype.isLong -> {
+                        when(value.kind) {
+                            SourceStorageKind.LITERALBOOLEAN -> inplacemodificationLongWithLiteralval(target.asmVarname, operator, value.boolean!!.asInt())
+                            SourceStorageKind.LITERALNUMBER -> inplacemodificationLongWithLiteralval(target.asmVarname, operator, value.number!!.number.toInt())
+                            SourceStorageKind.VARIABLE -> inplacemodificationLongWithVariable(target.asmVarname, operator, value.asmVarname)
+                            SourceStorageKind.EXPRESSION -> inplacemodificationLongWithExpression(target.asmVarname, operator, value.expression!!)
+                            SourceStorageKind.REGISTER -> inplacemodificationLongWithVariable(target.asmVarname, operator, regName(value))
+                            SourceStorageKind.ARRAY -> TODO("inplace modify long with array value ${target.position}")
+                            SourceStorageKind.MEMORY -> TODO("inplace modify long with memread value ${target.position}")
+                        }
+                    }
                     target.datatype.isFloat -> {
                         when(value.kind) {
                             SourceStorageKind.LITERALBOOLEAN -> inplacemodificationFloatWithLiteralval(target.asmVarname, operator, value.boolean!!.asInt().toDouble())
                             SourceStorageKind.LITERALNUMBER -> inplacemodificationFloatWithLiteralval(target.asmVarname, operator, value.number!!.number)
                             SourceStorageKind.VARIABLE -> inplacemodificationFloatWithVariable(target.asmVarname, operator, value.asmVarname)
                             SourceStorageKind.REGISTER -> inplacemodificationFloatWithVariable(target.asmVarname, operator, regName(value))
-                            SourceStorageKind.MEMORY -> TODO("memread into float")
+                            SourceStorageKind.MEMORY -> inplacemodificationFloatWithValue(target.asmVarname, operator, value.memory!!)
                             SourceStorageKind.ARRAY -> inplacemodificationFloatWithValue(target.asmVarname, operator, value.array!!)
                             SourceStorageKind.EXPRESSION -> {
                                 if(value.expression is PtTypeCast) {
@@ -152,18 +164,18 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                     is PtIdentifier -> {
                         val pointer = memory.address as PtIdentifier
                         when(value.kind) {
-                            SourceStorageKind.LITERALBOOLEAN -> inplacemodificationBytePointerWithLiteralval(pointer, operator, value.boolean!!.asInt())
-                            SourceStorageKind.LITERALNUMBER -> inplacemodificationBytePointerWithLiteralval(pointer, operator, value.number!!.number.toInt())
-                            SourceStorageKind.VARIABLE -> inplacemodificationBytePointerWithVariable(pointer, operator, value.asmVarname)
-                            SourceStorageKind.REGISTER -> inplacemodificationBytePointerWithVariable(pointer, operator, regName(value))
-                            SourceStorageKind.MEMORY -> TODO("memread into pointer")
-                            SourceStorageKind.ARRAY -> inplacemodificationBytePointerWithValue(pointer, operator, value.array!!)
+                            SourceStorageKind.LITERALBOOLEAN -> ptrgen.inplacemodificationBytePointerWithLiteralval(pointer, operator, value.boolean!!.asInt())
+                            SourceStorageKind.LITERALNUMBER -> ptrgen.inplacemodificationBytePointerWithLiteralval(pointer, operator, value.number!!.number.toInt())
+                            SourceStorageKind.VARIABLE -> ptrgen.inplacemodificationBytePointerWithVariable(pointer, operator, value.asmVarname)
+                            SourceStorageKind.REGISTER -> ptrgen.inplacemodificationBytePointerWithVariable(pointer, operator, regName(value))
+                            SourceStorageKind.MEMORY -> ptrgen. inplacemodificationBytePointerWithValue(pointer, operator, value.memory!!)
+                            SourceStorageKind.ARRAY -> ptrgen.inplacemodificationBytePointerWithValue(pointer, operator, value.array!!)
                             SourceStorageKind.EXPRESSION -> {
                                 if(value.expression is PtTypeCast) {
                                     if (tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator)) return
-                                    inplacemodificationBytePointerWithValue(pointer, operator, value.expression)
+                                    ptrgen.inplacemodificationBytePointerWithValue(pointer, operator, value.expression)
                                 } else {
-                                    inplacemodificationBytePointerWithValue(pointer, operator, value.expression!!)
+                                    ptrgen.inplacemodificationBytePointerWithValue(pointer, operator, value.expression!!)
                                 }
                             }
                         }
@@ -291,13 +303,32 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                             }
                         }
 
+                        target.datatype.isLong -> {
+                            when(value.kind) {
+                                SourceStorageKind.LITERALBOOLEAN -> inplacemodificationLongWithLiteralval(targetVarName, operator, value.boolean!!.asInt())
+                                SourceStorageKind.LITERALNUMBER -> inplacemodificationLongWithLiteralval(targetVarName, operator, value.number!!.number.toInt())
+                                SourceStorageKind.VARIABLE -> inplacemodificationLongWithVariable(targetVarName, operator, value.asmVarname)
+                                SourceStorageKind.REGISTER -> inplacemodificationLongWithVariable(targetVarName, operator, regName(value))
+                                SourceStorageKind.MEMORY -> TODO("inplace long modification with memread value ${target.position}")
+                                SourceStorageKind.ARRAY -> TODO("inplace long modification with array value ${target.position}")
+                                SourceStorageKind.EXPRESSION -> {
+                                    if(value.expression is PtTypeCast) {
+                                        if (tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator)) return
+                                        TODO("inplace long modification ${target.position}")
+                                    } else {
+                                        TODO("inplace long modification ${target.position}")
+                                    }
+                                }
+                            }
+                        }
+
                         target.datatype.isFloat -> {
                             when(value.kind) {
                                 SourceStorageKind.LITERALBOOLEAN -> inplacemodificationFloatWithLiteralval(targetVarName, operator, value.boolean!!.asInt().toDouble())
                                 SourceStorageKind.LITERALNUMBER -> inplacemodificationFloatWithLiteralval(targetVarName, operator, value.number!!.number)
                                 SourceStorageKind.VARIABLE -> inplacemodificationFloatWithVariable(targetVarName, operator, value.asmVarname)
                                 SourceStorageKind.REGISTER -> inplacemodificationFloatWithVariable(targetVarName, operator, regName(value))
-                                SourceStorageKind.MEMORY -> TODO("memread into float array")
+                                SourceStorageKind.MEMORY -> inplacemodificationFloatWithValue(targetVarName, operator, value.memory!!)
                                 SourceStorageKind.ARRAY -> inplacemodificationFloatWithValue(targetVarName, operator, value.array!!)
                                 SourceStorageKind.EXPRESSION -> {
                                     if(value.expression is PtTypeCast) {
@@ -488,7 +519,7 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                                 SourceStorageKind.LITERALNUMBER -> inplacemodificationFloatWithLiteralval(tempvar, operator, value.number!!.number)
                                 SourceStorageKind.VARIABLE -> inplacemodificationFloatWithVariable(tempvar, operator, value.asmVarname)
                                 SourceStorageKind.REGISTER -> inplacemodificationFloatWithVariable(tempvar, operator, regName(value))
-                                SourceStorageKind.MEMORY -> TODO("memread into float")
+                                SourceStorageKind.MEMORY -> inplacemodificationFloatWithValue(tempvar, operator, value.memory!!)
                                 SourceStorageKind.ARRAY -> inplacemodificationFloatWithValue(tempvar, operator, value.array!!)
                                 SourceStorageKind.EXPRESSION -> {
                                     if(value.expression is PtTypeCast) {
@@ -523,6 +554,457 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
         }
     }
 
+    internal fun inplacemodificationLongWithExpression(targetVar: String, operator: String, value: PtExpression) {
+        // it's not an expression so no need to preserve R14-R15
+        assignmentAsmGen.assignExpressionToRegister(value, RegisterOrPair.R14R15_32, value.type.isSigned)
+        inplacemodificationLongWithVariable(targetVar, operator, "cx16.r14")
+    }
+
+    internal fun inplacemodificationLongWithVariable(targetVar: String, operator: String, sourceVar: String) {
+        when(operator) {
+            "+" -> {
+                asmgen.out("""
+                    clc
+                    lda  $targetVar
+                    adc  $sourceVar
+                    sta  $targetVar
+                    lda  $targetVar+1
+                    adc  $sourceVar+1
+                    sta  $targetVar+1
+                    lda  $targetVar+2
+                    adc  $sourceVar+2
+                    sta  $targetVar+2
+                    lda  $targetVar+3
+                    adc  $sourceVar+3
+                    sta  $targetVar+3""")
+            }
+            "-" -> {
+                asmgen.out("""
+                    sec
+                    lda  $targetVar
+                    sbc  $sourceVar
+                    sta  $targetVar
+                    lda  $targetVar+1
+                    sbc  $sourceVar+1
+                    sta  $targetVar+1
+                    lda  $targetVar+2
+                    sbc  $sourceVar+2
+                    sta  $targetVar+2
+                    lda  $targetVar+3
+                    sbc  $sourceVar+3
+                    sta  $targetVar+3""")
+            }
+            "<<" -> {
+                asmgen.out("""
+                    ldy  $sourceVar
+-                   asl  $targetVar
+                    rol  $targetVar+1
+                    rol  $targetVar+2
+                    rol  $targetVar+3
+                    dey
+                    bne  -""")
+            }
+            ">>" -> {
+                asmgen.out("""
+                    ldy  $sourceVar
+-                   lda  $targetVar+3
+                    asl  a    ; save sign bit
+                    ror  $targetVar+3
+                    ror  $targetVar+2
+                    ror  $targetVar+1
+                    ror  $targetVar
+                    dey
+                    bne  -""")
+            }
+            "|" -> {
+                asmgen.out("""
+                    lda  $targetVar
+                    ora  $sourceVar
+                    sta  $targetVar  
+                    lda  $targetVar+1
+                    ora  $sourceVar+1
+                    sta  $targetVar+1
+                    lda  $targetVar+2
+                    ora  $sourceVar+2
+                    sta  $targetVar+2
+                    lda  $targetVar+3
+                    ora  $sourceVar+3
+                    sta  $targetVar+3""")
+            }
+            "&" -> {
+                asmgen.out("""
+                    lda  $targetVar
+                    and  $sourceVar
+                    sta  $targetVar  
+                    lda  $targetVar+1
+                    and  $sourceVar+1
+                    sta  $targetVar+1
+                    lda  $targetVar+2
+                    and  $sourceVar+2
+                    sta  $targetVar+2
+                    lda  $targetVar+3
+                    and  $sourceVar+3
+                    sta  $targetVar+3""")
+            }
+            "^" -> {
+                asmgen.out("""
+                    lda  $targetVar
+                    eor  $sourceVar
+                    sta  $targetVar  
+                    lda  $targetVar+1
+                    eor  $sourceVar+1
+                    sta  $targetVar+1
+                    lda  $targetVar+2
+                    eor  $sourceVar+2
+                    sta  $targetVar+2
+                    lda  $targetVar+3
+                    eor  $sourceVar+3
+                    sta  $targetVar+3""")
+            }
+            else -> {
+                TODO("in-place modify LONG with variable")
+            }
+        }
+    }
+
+    internal fun inplacemodificationLongWithLiteralval(variable: String, operator: String, value: Int) {
+
+        fun inplaceLongShiftLeft() {
+            when {
+                value in 0..2 -> {
+                    repeat(value) {
+                        asmgen.out("""
+                            asl  $variable
+                            rol  $variable+1
+                            rol  $variable+2
+                            rol  $variable+3""")
+                    }
+                }
+                value in 3..7 -> {
+                    asmgen.out("""
+                        ldy  #$value
+-                       asl  $variable
+                        rol  $variable+1
+                        rol  $variable+2
+                        rol  $variable+3
+                        dey
+                        bne  -""")
+                }
+                value == 8 -> {
+                    asmgen.out("""
+                        lda  $variable+2
+                        sta  $variable+3
+                        lda  $variable+1
+                        sta  $variable+2
+                        lda  $variable
+                        sta  $variable+1
+                        lda  #0
+                        sta  $variable""")
+                }
+                value in 9..15 -> {
+                    val shift = value - 8
+                    asmgen.out("""
+                        lda  $variable+2
+                        sta  $variable+3
+                        lda  $variable+1
+                        sta  $variable+2
+                        lda  $variable
+                        sta  $variable+1
+                        lda  #0
+                        sta  $variable""")
+                    if(shift==1) {
+                        asmgen.out("""
+                        asl  $variable+1
+                        rol  $variable+2
+                        rol  $variable+3""")
+                    } else {
+                        asmgen.out("""
+                        ldy  #$shift
+-                       asl  $variable+1
+                        rol  $variable+2
+                        rol  $variable+3
+                        dey
+                        bne  -""")
+                    }
+                }
+                value == 16 -> {
+                    asmgen.out("""
+                        lda  $variable+1
+                        sta  $variable+3
+                        lda  $variable
+                        sta  $variable+2
+                        lda  #0
+                        sta  $variable
+                        sta  $variable+1""")
+                }
+                value in 17..23 -> {
+                    val shift = value-16
+                    asmgen.out("""
+                        lda  $variable+1
+                        sta  $variable+3
+                        lda  $variable
+                        sta  $variable+2
+                        lda  #0
+                        sta  $variable
+                        sta  $variable+1""")
+                    if(shift==1) {
+                        asmgen.out("  asl  $variable+2 |  rol  $variable+3")
+                    } else {
+                        asmgen.out("""
+                        ldy  #$shift
+-                       asl  $variable+2
+                        rol  $variable+3
+                        dey
+                        bne  -""")
+                    }
+                }
+                value == 24 -> {
+                    asmgen.out("""
+                        lda  $variable
+                        sta  $variable+3
+                        lda  #0
+                        sta  $variable
+                        sta  $variable+1
+                        sta  $variable+2""")
+                }
+                value <= 31 -> {
+                    val shift = value-24
+                    if(shift==1) {
+                        asmgen.out("  lda  $variable |  asl  a")
+                    } else {
+                        asmgen.out("""
+                        lda  $variable
+                        ldy  #$shift
+-                       asl  a
+                        dey
+                        bne  -""")
+                    }
+                    asmgen.out("""
+                        sta  $variable+3
+                        lda  #0
+                        sta  $variable
+                        sta  $variable+1
+                        sta  $variable+2""")
+                }
+                else -> {
+                    asmgen.out("""
+                        lda  #0
+                        sta  $variable
+                        sta  $variable+1
+                        sta  $variable+2
+                        sta  $variable+3""")
+                }
+            }
+        }
+
+        fun inplaceLongShiftRight() {
+            when {
+                value in 0..2 -> {
+                    repeat(value) {
+                        asmgen.out("""
+                            lda  $variable+3
+                            asl  a      ; save sign bit
+                            ror  $variable+3
+                            ror  $variable+2
+                            ror  $variable+1
+                            ror  $variable""")
+                    }
+                }
+                // TODO optimize for more cases 8, 16, 24 etc but don't forget to take the sign bit into account!
+                value <= 31 -> {
+                    asmgen.out("""
+                        ldy  #$value
+-                       lda  $variable+3
+                        asl  a      ; save sign bit
+                        ror  $variable+3
+                        ror  $variable+2
+                        ror  $variable+1
+                        ror  $variable
+                        dey
+                        bne  -""")
+                }
+                else -> {
+                    asmgen.out("""
+                        lda  #0
+                        sta  $variable
+                        sta  $variable+1
+                        sta  $variable+2
+                        sta  $variable+3""")
+                }
+            }
+        }
+
+        when(operator) {
+            "+" -> {
+                when(value) {
+                    0 -> {}
+                    1 -> {
+                        asmgen.out("""
+                            inc  $variable
+                            bne  +
+                            inc  $variable+1
+                            bne  +
+                            inc  $variable+2
+                            bne  +
+                            inc  $variable+3
++""")
+                    }
+                    else -> {
+                        if(value in 1..255) {
+                            asmgen.out("""
+                                clc
+                                lda  $variable
+                                adc  #$value
+                                sta  $variable
+                                bcc  +
+                                inc  $variable+1
+                                bne  +
+                                inc  $variable+2
+                                bne  +
+                                inc  $variable+3
++""")
+                        } else if(value in 1..65535) {
+                            asmgen.out("""
+                                clc
+                                lda  $variable
+                                adc  #<$value
+                                sta  $variable
+                                lda  $variable+1
+                                adc  #>$value
+                                sta  $variable+1
+                                bcc  +
+                                inc  $variable+2
+                                bne  +
+                                inc  $variable+3
++""")
+                        } else {
+                            val hex = value.toLongHex()
+                            asmgen.out("""
+                                clc
+                                lda  $variable
+                                adc  #$${hex.substring(6,8)}
+                                sta  $variable
+                                lda  $variable+1
+                                adc  #$${hex.substring(4, 6)}
+                                sta  $variable+1
+                                lda  $variable+2
+                                adc  #$${hex.substring(2, 4)}
+                                sta  $variable+2
+                                lda  $variable+3
+                                adc  #$${hex.take(2)}
+                                sta  $variable+3""")
+                        }
+                    }
+                }
+            }
+            "-" -> {
+                when(value) {
+                    0 -> {}
+                    1 -> {
+                        asmgen.out("""
+                            lda  $variable
+                            bne  +++
+                            lda  $variable+1
+                            bne  ++
+                            lda  $variable+2
+                            bne  +
+                            dec  $variable+3
++                           dec  $variable+2
++                           dec  $variable+1
++                           dec  $variable""")
+                    }
+                    else -> {
+                        if(value in 1..255) {
+                            asmgen.out("""
+                                sec
+                                lda  $variable
+                                sbc  #$value
+                                sta  $variable
+                                bcs  +++
+                                lda  $variable+1
+                                bne  ++
+                                lda  $variable+2
+                                bne  +
+                                dec  $variable+3
++                               dec  $variable+2
++                               dec  $variable+1
++""")
+                        } else {
+                            val hex = value.toLongHex()
+                            asmgen.out("""
+                                sec
+                                lda  $variable
+                                sbc  #$${hex.substring(6,8)}
+                                sta  $variable
+                                lda  $variable+1
+                                sbc  #$${hex.substring(4, 6)}
+                                sta  $variable+1
+                                lda  $variable+2
+                                sbc  #$${hex.substring(2, 4)}
+                                sta  $variable+2
+                                lda  $variable+3
+                                sbc  #$${hex.take(2)}
+                                sta  $variable+3""")
+                        }
+                    }
+                }
+            }
+            "<<" -> if (value > 0) inplaceLongShiftLeft()
+            ">>" -> if (value > 0) inplaceLongShiftRight()
+            "|" -> {
+                val hex = value.toLongHex()
+                asmgen.out("""
+                    lda  $variable
+                    ora  #$${hex.substring(6,8)}
+                    sta  $variable  
+                    lda  $variable+1
+                    ora  #$${hex.substring(4, 6)}
+                    sta  $variable+1
+                    lda  $variable+2
+                    ora  #$${hex.substring(2, 4)}
+                    sta  $variable+2
+                    lda  $variable+3
+                    ora  #$${hex.take(2)}
+                    sta  $variable+3""")
+            }
+            "&" -> {
+                val hex = value.toLongHex()
+                asmgen.out("""
+                    lda  $variable
+                    and  #$${hex.substring(6,8)}
+                    sta  $variable  
+                    lda  $variable+1
+                    and  #$${hex.substring(4, 6)}
+                    sta  $variable+1
+                    lda  $variable+2
+                    and  #$${hex.substring(2, 4)}
+                    sta  $variable+2
+                    lda  $variable+3
+                    and  #$${hex.take(2)}
+                    sta  $variable+3""")
+            }
+            "^" -> {
+                val hex = value.toLongHex()
+                asmgen.out("""
+                    lda  $variable
+                    eor  #$${hex.substring(6,8)}
+                    sta  $variable  
+                    lda  $variable+1
+                    eor  #$${hex.substring(4, 6)}
+                    sta  $variable+1
+                    lda  $variable+2
+                    eor  #$${hex.substring(2, 4)}
+                    sta  $variable+2
+                    lda  $variable+3
+                    eor  #$${hex.take(2)}
+                    sta  $variable+3""")
+            }
+            else -> {
+                TODO("inplace long $operator $value")
+            }
+        }
+    }
+
     private fun tryIndexedIncDec(array: PtArrayIndexer, operator: String): Boolean {
         val arrayVar = array.variable
         if(arrayVar==null) {
@@ -912,188 +1394,6 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
         return false
     }
 
-    private fun inplacemodificationBytePointerWithValue(pointervar: PtIdentifier, operator: String, value: PtExpression) {
-        asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_B1", DataType.UBYTE)
-        inplacemodificationBytePointerWithVariable(pointervar, operator, "P8ZP_SCRATCH_B1")
-    }
-
-    private fun inplacemodificationBytePointerWithVariable(pointervar: PtIdentifier, operator: String, otherName: String) {
-        val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-
-        when (operator) {
-            "+" -> asmgen.out("  clc |  adc  $otherName")
-            "-" -> asmgen.out("  sec |  sbc  $otherName")
-            "*" -> asmgen.out("  ldy  $otherName |  jsr  prog8_math.multiply_bytes")
-            "/" -> asmgen.out("  ldy  $otherName |  jsr  prog8_math.divmod_ub_asm |  tya")
-            "%" -> asmgen.out("  ldy  $otherName |  jsr  prog8_math.remainder_ub_asm")
-            "<<" -> {
-                asmgen.out("""
-                        ldy  $otherName
-                        beq  + 
--                       asl  a
-                        dey
-                        bne  -
-+""")
-            }
-            ">>" -> {
-                asmgen.out("""
-                        ldy  $otherName
-                        beq  + 
--                       lsr  a
-                        dey
-                        bne  -
-+""")
-            }
-            "&" -> asmgen.out(" and  $otherName")
-            "|" -> asmgen.out(" ora  $otherName")
-            "^" -> asmgen.out(" eor  $otherName")
-            "==" -> {
-                asmgen.out("""
-                    cmp  $otherName
-                    beq  +
-                    lda  #0
-                    beq  ++
-+                   lda  #1
-+""")
-            }
-            "!=" -> {
-                asmgen.out("""
-                    cmp  $otherName
-                    bne  +
-                    lda  #0
-                    beq  ++
-+                   lda  #1
-+""")
-            }
-            // pretty uncommon, who's going to assign a comparison boolean expression to a pointer?
-            "<", "<=", ">", ">=" -> TODO("byte-var-to-pointer comparisons")
-            else -> throw AssemblyError("invalid operator for in-place modification $operator")
-        }
-        asmgen.storeAIntoZpPointerVar(sourceName, false)
-    }
-
-    private fun inplacemodificationBytePointerWithLiteralval(pointervar: PtIdentifier, operator: String, value: Int) {
-        // note: this contains special optimized cases because we know the exact value. Don't replace this with another routine.
-        when (operator) {
-            "+" -> {
-                if(value==1) {
-                    if(asmgen.options.romable) {
-                        val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                        if(asmgen.isTargetCpu(CpuType.CPU65C02))
-                            asmgen.out("  inc  a")
-                        else
-                            asmgen.out("  clc |  adc  #1")
-                        asmgen.storeAIntoZpPointerVar(sourceName, false)
-                    } else {
-                        asmgen.assignExpressionToRegister(pointervar, RegisterOrPair.AY)
-                        asmgen.out("  sta  (+) + 1 |  sty  (+) + 2")
-                        asmgen.out($$"+\tinc  $ffff\t; modified")
-                    }
-                } else {
-                    val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                    asmgen.out("  clc |  adc  #$value")
-                    asmgen.storeAIntoZpPointerVar(sourceName, false)
-                }
-            }
-            "-" -> {
-                if(value==1) {
-                    if(asmgen.options.romable) {
-                        val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                        if(asmgen.isTargetCpu(CpuType.CPU65C02))
-                            asmgen.out("  dec  a")
-                        else
-                            asmgen.out("  sec |  sbc  #1")
-                        asmgen.storeAIntoZpPointerVar(sourceName, false)
-                    } else {
-                        asmgen.assignExpressionToRegister(pointervar, RegisterOrPair.AY)
-                        asmgen.out("  sta  (+) + 1 |  sty  (+) + 2")
-                        asmgen.out($$"+\tdec  $ffff\t; modified")
-                    }
-                } else {
-                    val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                    asmgen.out("  sec |  sbc  #$value")
-                    asmgen.storeAIntoZpPointerVar(sourceName, false)
-                }
-            }
-            "*" -> {
-                val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                if(value in asmgen.optimizedByteMultiplications)
-                    asmgen.out("  jsr  prog8_math.mul_byte_${value}")
-                else
-                    asmgen.out("  ldy  #$value |  jsr  prog8_math.multiply_bytes")
-                asmgen.storeAIntoZpPointerVar(sourceName, false)
-            }
-            "/" -> {
-                val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                if(value==0)
-                    throw AssemblyError("division by zero")
-                asmgen.out("  ldy  #$value |  jsr  prog8_math.divmod_ub_asm |  tya")
-                asmgen.storeAIntoZpPointerVar(sourceName, false)
-            }
-            "%" -> {
-                val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                if(value==0)
-                    throw AssemblyError("division by zero")
-                asmgen.out("  ldy  #$value |  jsr  prog8_math.remainder_ub_asm")
-                asmgen.storeAIntoZpPointerVar(sourceName, false)
-            }
-            "<<" -> {
-                if (value > 0) {
-                    val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                    repeat(value) { asmgen.out("  asl  a") }
-                    asmgen.storeAIntoZpPointerVar(sourceName, false)
-                }
-            }
-            ">>" -> {
-                if (value > 0) {
-                    val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                    repeat(value) { asmgen.out("  lsr  a") }
-                    asmgen.storeAIntoZpPointerVar(sourceName, false)
-                }
-            }
-            "&" -> {
-                val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                asmgen.out("  and  #$value")
-                asmgen.storeAIntoZpPointerVar(sourceName, false)
-            }
-            "|"-> {
-                val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                asmgen.out("  ora  #$value")
-                asmgen.storeAIntoZpPointerVar(sourceName, false)
-            }
-            "^" -> {
-                val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                asmgen.out("  eor  #$value")
-                asmgen.storeAIntoZpPointerVar(sourceName, false)
-            }
-            "==" -> {
-                val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                asmgen.out("""
-                    cmp  #$value
-                    beq  +
-                    lda  #0
-                    beq  ++
-+                   lda  #1
-+""")
-                asmgen.storeAIntoZpPointerVar(sourceName, false)
-            }
-            "!=" -> {
-                val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
-                asmgen.out("""
-                    cmp  #$value
-                    bne  +
-                    lda  #0
-                    beq  ++
-+                   lda  #1
-+""")
-                asmgen.storeAIntoZpPointerVar(sourceName, false)
-            }
-            // pretty uncommon, who's going to assign a comparison boolean expression to a pointer?:
-            "<", "<=", ">", ">=" -> TODO("byte-litval-to-pointer comparisons")
-            else -> throw AssemblyError("invalid operator for in-place modification $operator")
-        }
-    }
-
     private fun inplacemodificationByteWithValue(name: String, dt: DataType, operator: String, value: PtExpression) {
         require(dt.isByteOrBool)
         if(!value.isSimple()) {
@@ -1851,7 +2151,7 @@ $shortcutLabel:""")
                 if(value in asmgen.optimizedWordMultiplications) {
                     asmgen.out("  lda  $lsb |  ldy  $msb |  jsr  prog8_math.mul_word_$value |  sta  $lsb |  sty  $msb")
                 } else {
-                    if(block?.options?.veraFxMuls==true)
+                    if(block?.options?.veraFxMuls==true) {
                         // cx16 verafx hardware mul
                         asmgen.out("""
                             lda  $lsb
@@ -1862,9 +2162,10 @@ $shortcutLabel:""")
                             ldy  #>$value
                             sta  cx16.r1
                             sty  cx16.r1+1
-                            jsr  verafx.muls
+                            jsr  verafx.muls16
                             sta  $lsb
                             sty  $msb""")
+                    }
                     else
                         asmgen.out("""
                             lda  $lsb
@@ -2349,9 +2650,10 @@ $shortcutLabel:""")
                                 ldy  $name+1
                                 sta  cx16.r0
                                 sty  cx16.r0+1
-                                jsr  verafx.muls
+                                jsr  verafx.muls16
                                 sta  $name
                                 sty  $name+1""")
+
                         } else {
                             if(valueDt.isUnsignedByte) {
                                 asmgen.out("  lda  $otherName |  sta  prog8_math.multiply_words.multiplier")
@@ -2494,7 +2796,7 @@ $shortcutLabel:""")
                     "+" -> asmgen.out("  lda  $name |  clc |  adc  $otherName |  sta  $name |  lda  $name+1 |  adc  $otherName+1 |  sta  $name+1")
                     "-" -> asmgen.out("  lda  $name |  sec |  sbc  $otherName |  sta  $name |  lda  $name+1 |  sbc  $otherName+1 |  sta  $name+1")
                     "*" -> {
-                        if(block?.options?.veraFxMuls==true)
+                        if(block?.options?.veraFxMuls==true) {
                             // cx16 verafx hardware muls
                             asmgen.out("""
                                 lda  $name
@@ -2505,9 +2807,10 @@ $shortcutLabel:""")
                                 ldy  $otherName+1
                                 sta  cx16.r1
                                 sty  cx16.r1+1
-                                jsr  verafx.muls
+                                jsr  verafx.muls16
                                 sta  $name
                                 sty  $name+1""")
+                        }
                         else
                             asmgen.out("""
                                 lda  $otherName
@@ -2698,7 +3001,7 @@ $shortcutLabel:""")
     private fun inplacemodificationWordWithValue(name: String, dt: DataType, operator: String, value: PtExpression, block: PtBlock?) {
         require(dt.isWord)
         fun multiplyVarByWordInAX() {
-            if(block?.options?.veraFxMuls==true)
+            if(block?.options?.veraFxMuls==true) {
                 // cx16 verafx hardware muls
                 asmgen.out("""
                     sta  cx16.r1
@@ -2707,9 +3010,10 @@ $shortcutLabel:""")
                     ldx  $name+1
                     sta  cx16.r0
                     stx  cx16.r0+1
-                    jsr  verafx.muls
+                    jsr  verafx.muls16
                     sta  $name
                     sty  $name+1""")
+            }
             else
                 asmgen.out("""
                     sta  prog8_math.multiply_words.multiplier
@@ -3003,7 +3307,7 @@ $shortcutLabel:""")
                         if(value is PtNumber && value.number<=255) {
                             TODO("shift a word var by ${value.number}")
                         } else {
-                            throw AssemblyError("shift by a word value not supported, max is a byte")
+                            throw AssemblyError("bit shift value can not be larger than a byte")
                         }
                     }
                     "&" -> {

codeGenCpu6502/test/Dummies.kt

@@ -12,12 +12,14 @@ internal object DummyMemsizer : IMemSizer {
             return when(dt.sub) {
                 BaseDataType.BOOL, BaseDataType.BYTE, BaseDataType.UBYTE -> numElements
                 BaseDataType.UWORD, BaseDataType.WORD -> numElements*2
+                BaseDataType.LONG -> numElements*4
                 BaseDataType.FLOAT -> numElements*5
                 else -> throw IllegalArgumentException("invalid sub type")
             }
         }
         return when {
             dt.isByteOrBool -> 1 * (numElements ?: 1)
+            dt.isLong -> 4 * (numElements ?: 1)
             dt.isFloat -> 5 * (numElements ?: 1)
             else -> 2 * (numElements ?: 1)
         }

codeGenCpu6502/test/TestCodegen.kt

@@ -31,6 +31,7 @@ class TestCodegen: FunSpec({
             noSysInit = false,
             romable = false,
             compTarget = target,
+            compilerVersion="99.99",
             loadAddress = target.PROGRAM_LOAD_ADDRESS,
             memtopAddress = 0xffffu
         )

codeGenIntermediate/src/prog8/codegen/intermediate/AssignmentGen.kt

@@ -24,7 +24,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             if(extsub!=null) {
                 require(funcCall.multipleResultRegs.size + funcCall.multipleResultFpRegs.size >= 2)
                 if (funcCall.multipleResultFpRegs.isNotEmpty())
-                    TODO("deal with (multiple?) FP return registers")
+                    TODO("deal with (multiple?) FP return registers ${assignment.position}")
                 if (extsub.returns.size == assignmentTargets.size) {
                     // Targets and values match. Assign all the things. Skip 'void' targets.
                     extsub.returns.zip(assignmentTargets).zip(funcCall.multipleResultRegs).forEach {
@@ -76,6 +76,11 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             RegisterOrPair.AY -> addInstr(result, IRInstruction(Opcode.LOADHAY, IRDataType.WORD, reg1=regNum), null)
             RegisterOrPair.XY -> addInstr(result, IRInstruction(Opcode.LOADHXY, IRDataType.WORD, reg1=regNum), null)
             in Cx16VirtualRegisters -> addInstr(result, IRInstruction(Opcode.LOADM, irType(returns.type), reg1=regNum, labelSymbol = "cx16.${returns.register.registerOrPair.toString().lowercase()}"), null)
+            in combinedLongRegisters -> {
+                require(returns.type.isLong)
+                val startreg = returns.register.registerOrPair!!.startregname()
+                addInstr(result, IRInstruction(Opcode.LOADM, IRDataType.LONG, reg1=regNum, labelSymbol = "cx16.${startreg}"), null)
+            }
             RegisterOrPair.FAC1 -> addInstr(result, IRInstruction(Opcode.LOADHFACZERO, IRDataType.FLOAT, fpReg1 = regNum), null)
             RegisterOrPair.FAC2 -> addInstr(result, IRInstruction(Opcode.LOADHFACONE, IRDataType.FLOAT, fpReg1 = regNum), null)
             null -> if(returns.register.statusflag!=null)
@@ -118,6 +123,9 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
     }
 
     internal fun translate(augAssign: PtAugmentedAssign): IRCodeChunks {
+        if(augAssign.target.type.isString)
+            throw AssemblyError("cannot assign to str type ${augAssign.position}")
+
         // augmented assignment always has just a single target
         if (augAssign.target.children.single() is PtIrRegister)
             throw AssemblyError("assigning to a register should be done by just evaluating the expression into resultregister")
@@ -183,7 +191,10 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                         "&=" -> addInstr(inplaceInstrs, IRInstruction(Opcode.ANDR, targetDt, reg1 = oldvalueReg, reg2 = operandTr.resultReg), null)
                         "^=", "xor=" -> addInstr(inplaceInstrs, IRInstruction(Opcode.XORR, targetDt, reg1 = oldvalueReg, reg2 = operandTr.resultReg), null)
                         "<<=" -> addInstr(inplaceInstrs, IRInstruction(Opcode.LSLN, targetDt, reg1 = oldvalueReg, reg2 = operandTr.resultReg), null)
-                        ">>=" -> addInstr(inplaceInstrs, IRInstruction(Opcode.LSRN, targetDt, reg1 = oldvalueReg, reg2 = operandTr.resultReg), null)
+                        ">>=" -> {
+                            val opc = if (signed) Opcode.ASRN else Opcode.LSRN
+                            addInstr(inplaceInstrs, IRInstruction(opc, targetDt, reg1 = oldvalueReg, reg2 = operandTr.resultReg), null)
+                        }
                         "or=" -> {
                             val shortcutLabel = codeGen.createLabelName()
                             addInstr(inplaceInstrs, IRInstruction(Opcode.BSTNE, labelSymbol = shortcutLabel), null)
@@ -462,7 +473,11 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
     }
 
     private fun translateRegularAssign(assignment: PtAssignment): IRCodeChunks {
-        // note: assigning array and string values is done via an explicit memcopy/stringcopy function call.
+        if(assignment.target.type.isString) {
+            // assigning array and string values is done via an explicit memcopy/stringcopy function calls.
+            throw AssemblyError("cannot assign to str type ${assignment.position}")
+        }
+
         val valueDt = irType(assignment.value.type)
         val targetDt = irType(assignment.target.type)
         val result = mutableListOf<IRCodeChunkBase>()
@@ -545,7 +560,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                         if(ptrWithOffset!=null) {
                             if(ptrWithOffset.operator=="+" && ptrWithOffset.left is PtIdentifier) {
                                 val constOffset = (ptrWithOffset.right as? PtNumber)?.number?.toInt()
-                                if(constOffset in 0..255) {
+                                if(constOffset in 0..65535) {
                                     val ptrName = (ptrWithOffset.left as PtIdentifier).name
                                     val pointerReg = codeGen.registers.next(IRDataType.WORD)
                                     result += IRCodeChunk(null, null).also {
@@ -555,18 +570,6 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                                     return result
                                 }
                             }
-                            val offsetTypecast = ptrWithOffset.right as? PtTypeCast
-                            if(ptrWithOffset.operator=="+" && ptrWithOffset.left is PtIdentifier && (ptrWithOffset.right.type.isByte || offsetTypecast?.value?.type?.isByte==true)) {
-                                // STOREIX only works with byte index.
-                                val tr = if(offsetTypecast?.value?.type?.isByte==true)
-                                    expressionEval.translateExpression(offsetTypecast.value)
-                                else
-                                    expressionEval.translateExpression(ptrWithOffset.right)
-                                addToResult(result, tr, tr.resultReg, -1)
-                                val ptrName = (ptrWithOffset.left as PtIdentifier).name
-                                addInstr(result, IRInstruction(Opcode.STOREIX, IRDataType.BYTE, reg1=valueRegister, reg2=tr.resultReg, labelSymbol = ptrName), null)
-                                return result
-                            }
                         }
 
                         val tr = expressionEval.translateExpression(memory!!.address)
@@ -697,9 +700,9 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                     val chunk = IRCodeChunk(null, null).also {
                         if(targetArray.splitWords) {
                             val lsbmsbReg = codeGen.registers.next(IRDataType.BYTE)
-                            it += IRInstruction(Opcode.LSIG, IRDataType.BYTE, reg1 = lsbmsbReg, reg2 = valueRegister)
+                            it += IRInstruction(Opcode.LSIGB, IRDataType.WORD, reg1 = lsbmsbReg, reg2 = valueRegister)
                             it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = lsbmsbReg, immediate = arrayLength, labelSymbol = "${variable}_lsb", symbolOffset = fixedIndex)
-                            it += IRInstruction(Opcode.MSIG, IRDataType.BYTE, reg1 = lsbmsbReg, reg2 = valueRegister)
+                            it += IRInstruction(Opcode.MSIGB, IRDataType.WORD, reg1 = lsbmsbReg, reg2 = valueRegister)
                             it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = lsbmsbReg, immediate = arrayLength, labelSymbol = "${variable}_msb", symbolOffset = fixedIndex)
                         }
                         else
@@ -712,9 +715,9 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                     result += IRCodeChunk(null, null).also {
                         if(targetArray.splitWords) {
                             val lsbmsbReg = codeGen.registers.next(IRDataType.BYTE)
-                            it += IRInstruction(Opcode.LSIG, IRDataType.BYTE, reg1 = lsbmsbReg, reg2 = valueRegister)
+                            it += IRInstruction(Opcode.LSIGB, IRDataType.WORD, reg1 = lsbmsbReg, reg2 = valueRegister)
                             it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1 = lsbmsbReg, reg2=indexReg, immediate = arrayLength, labelSymbol = "${variable}_lsb")
-                            it += IRInstruction(Opcode.MSIG, IRDataType.BYTE, reg1 = lsbmsbReg, reg2 = valueRegister)
+                            it += IRInstruction(Opcode.MSIGB, IRDataType.WORD, reg1 = lsbmsbReg, reg2 = valueRegister)
                             it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1 = lsbmsbReg, reg2=indexReg, immediate = arrayLength, labelSymbol = "${variable}_msb")
                         }
                         else
@@ -964,7 +967,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
 
     private fun operatorDivideInplace(symbol: String?, array: PtArrayIndexer?, constAddress: Int?, memory: PtMemoryByte?, vmDt: IRDataType, operand: PtExpression, signed: Boolean): IRCodeChunks? {
         if(array!=null) {
-            TODO("/ in array")
+            TODO("/ in array ${array.position}")
         }
         if(constAddress==null && memory!=null)
             return null  // TODO("optimized memory in-place /"")
@@ -1104,14 +1107,14 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         if(constAddress==null && memory!=null)
             return null  // TODO("optimized memory in-place -"")
 
+        val constValue = (operand as? PtNumber)?.number
         val result = mutableListOf<IRCodeChunkBase>()
         if(vmDt==IRDataType.FLOAT) {
-            if((operand as? PtNumber)?.number==1.0) {
+            if(constValue==1.0) {
                 addInstr(result, if(constAddress!=null)
                     IRInstruction(Opcode.DECM, vmDt, address = constAddress)
                 else
-                    IRInstruction(Opcode.DECM, vmDt, labelSymbol = symbol)
-                    , null)
+                    IRInstruction(Opcode.DECM, vmDt, labelSymbol = symbol), null)
             }
             else {
                 val tr = expressionEval.translateExpression(operand)
@@ -1119,16 +1122,14 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                 addInstr(result, if(constAddress!=null)
                     IRInstruction(Opcode.SUBM, vmDt, fpReg1=tr.resultFpReg, address = constAddress)
                 else
-                    IRInstruction(Opcode.SUBM, vmDt, fpReg1=tr.resultFpReg, labelSymbol = symbol)
-                    , null)
+                    IRInstruction(Opcode.SUBM, vmDt, fpReg1=tr.resultFpReg, labelSymbol = symbol), null)
             }
         } else {
-            if((operand as? PtNumber)?.number==1.0) {
+            if(constValue==1.0) {
                 addInstr(result, if(constAddress!=null)
                     IRInstruction(Opcode.DECM, vmDt, address = constAddress)
                 else
-                    IRInstruction(Opcode.DECM, vmDt, labelSymbol = symbol)
-                    , null)
+                    IRInstruction(Opcode.DECM, vmDt, labelSymbol = symbol), null)
             }
             else {
                 val tr = expressionEval.translateExpression(operand)
@@ -1136,8 +1137,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                 addInstr(result, if(constAddress!=null)
                     IRInstruction(Opcode.SUBM, vmDt, reg1=tr.resultReg, address = constAddress)
                 else
-                    IRInstruction(Opcode.SUBM, vmDt, reg1=tr.resultReg, labelSymbol = symbol)
-                    , null)
+                    IRInstruction(Opcode.SUBM, vmDt, reg1=tr.resultReg, labelSymbol = symbol), null)
             }
         }
         return result
@@ -1203,9 +1203,10 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             return null  // TODO("optimized memory in-place +"")
 
         val result = mutableListOf<IRCodeChunkBase>()
+        val constValue = (operand as? PtNumber)?.number
 
         if(vmDt==IRDataType.FLOAT) {
-            if((operand as? PtNumber)?.number==1.0) {
+            if(constValue==1.0) {
                 addInstr(result, if (constAddress != null)
                     IRInstruction(Opcode.INCM, vmDt, address = constAddress)
                 else
@@ -1220,7 +1221,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                     IRInstruction(Opcode.ADDM, vmDt, fpReg1 = tr.resultFpReg, labelSymbol = symbol) , null)
             }
         } else {
-            if((operand as? PtNumber)?.number==1.0) {
+            if(constValue==1.0) {
                 addInstr(result, if (constAddress != null)
                     IRInstruction(Opcode.INCM, vmDt, address = constAddress)
                 else
@@ -1309,11 +1310,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         } else {
             val shiftTr = expressionEval.translateExpression(operand)
             addToResult(result, shiftTr, shiftTr.resultReg, -1)
-            var shiftReg = shiftTr.resultReg
-            if(vmDt==IRDataType.WORD && shiftTr.dt==IRDataType.BYTE) {
-                shiftReg = codeGen.registers.next(IRDataType.WORD)
-                addInstr(result, IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1=shiftReg, reg2=shiftTr.resultReg), null)
-            }
+            val shiftReg = shiftTr.resultReg
             val opc = if (signed) Opcode.ASRNM else Opcode.LSRNM
             val ins = if(constAddress!=null)
                 IRInstruction(opc, vmDt, reg1 = shiftReg, address = constAddress)
@@ -1371,11 +1368,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         } else {
             val shiftTr = expressionEval.translateExpression(operand)
             addToResult(result, shiftTr, shiftTr.resultReg, -1)
-            var shiftReg = shiftTr.resultReg
-            if(vmDt==IRDataType.WORD && shiftTr.dt==IRDataType.BYTE) {
-                shiftReg = codeGen.registers.next(IRDataType.WORD)
-                addInstr(result, IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1=shiftReg, reg2=shiftTr.resultReg), null)
-            }
+            val shiftReg = shiftTr.resultReg
             addInstr(result, if(constAddress!=null)
                 IRInstruction(Opcode.LSLNM, vmDt, reg1=shiftReg, address = constAddress)
             else
@@ -1430,7 +1423,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
 
     private fun operatorModuloInplace(symbol: String?, array: PtArrayIndexer?, constAddress: Int?, memory: PtMemoryByte?, vmDt: IRDataType, operand: PtExpression): IRCodeChunks? {
         if(array!=null) {
-            TODO("% in array")
+            TODO("% in array  ${array.position}")
         }
         if(constAddress==null && memory!=null)
             return null  // TODO("optimized memory in-place %"")

codeGenIntermediate/src/prog8/codegen/intermediate/BuiltinFuncGen.kt

@@ -14,35 +14,40 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
 
     fun translate(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         return when(call.name) {
-            "abs__byte", "abs__word", "abs__float" -> funcAbs(call)
+            "abs__byte", "abs__word", "abs__long", "abs__float" -> funcAbs(call)
             "cmp" -> funcCmp(call)
             "sgn" -> funcSgn(call)
-            "sqrt__ubyte", "sqrt__uword", "sqrt__float" -> funcSqrt(call)
+            "sqrt__ubyte", "sqrt__uword", "sqrt__long", "sqrt__float" -> funcSqrt(call)
             "divmod__ubyte" -> funcDivmod(call, IRDataType.BYTE)
             "divmod__uword" -> funcDivmod(call, IRDataType.WORD)
             "rsave", "rrestore" -> ExpressionCodeResult.EMPTY  // vm doesn't have registers to save/restore
             "callfar" -> funcCallfar(call)
             "callfar2" -> funcCallfar2(call)
             "call" -> funcCall(call)
-            "lsw" -> throw AssemblyError("lsw() should have been removed or replaced by a const value")
-            "msw" -> throw AssemblyError("msw() should have been removed or replaced by a const value")
-            "msb" -> funcMsb(call)
-            "lsb" -> funcLsb(call)
+            "msw" -> funcMsw(call)
+            "lsw" -> funcLsw(call)
+            "msb" -> funcMsb(call, false)
+            "msb__long" -> funcMsb(call, true)
+            "lsb" -> funcLsb(call, false)
+            "lsb__long" -> funcLsb(call, true)
             "memory" -> funcMemory(call)
             "peek" -> funcPeek(call, IRDataType.BYTE)
             "peekbool" -> funcPeek(call, IRDataType.BYTE)
             "peekw" -> funcPeek(call, IRDataType.WORD)
+            "peekl" -> funcPeek(call, IRDataType.LONG)
             "peekf" -> funcPeek(call, IRDataType.FLOAT)
             "poke" -> funcPoke(call, IRDataType.BYTE)
             "pokebool" -> funcPoke(call, IRDataType.BYTE)
             "pokebowl" -> funcPoke(call, IRDataType.BYTE)
             "pokew" -> funcPoke(call, IRDataType.WORD)
+            "pokel" -> funcPoke(call, IRDataType.LONG)
             "pokef" -> funcPoke(call, IRDataType.FLOAT)
             "pokemon" -> funcPokemon(call)
             "mkword" -> funcMkword(call)
-            "clamp__byte", "clamp__ubyte", "clamp__word", "clamp__uword" -> funcClamp(call)
-            "min__byte", "min__ubyte", "min__word", "min__uword" -> funcMin(call)
-            "max__byte", "max__ubyte", "max__word", "max__uword" -> funcMax(call)
+            "mklong", "mklong2" -> funcMklong(call)
+            "clamp__byte", "clamp__ubyte", "clamp__word", "clamp__uword", "clamp__long" -> funcClamp(call)
+            "min__byte", "min__ubyte", "min__word", "min__uword", "min__long" -> funcMin(call)
+            "max__byte", "max__ubyte", "max__word", "max__uword", "max__long" -> funcMax(call)
             "setlsb" -> funcSetLsbMsb(call, false)
             "setmsb" -> funcSetLsbMsb(call, true)
             "rol" -> funcRolRor(call)
@@ -204,6 +209,17 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 result += IRCodeChunk(notNegativeLabel, null)
                 return ExpressionCodeResult(result, IRDataType.WORD, tr.resultReg, -1)
             }
+            BaseDataType.LONG -> {
+                val notNegativeLabel = codeGen.createLabelName()
+                val compareReg = codeGen.registers.next(IRDataType.LONG)
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.LOADR, IRDataType.LONG, reg1=compareReg, reg2=tr.resultReg)
+                    it += IRInstruction(Opcode.BSTPOS, labelSymbol = notNegativeLabel)
+                    it += IRInstruction(Opcode.NEG, IRDataType.LONG, reg1=tr.resultReg)
+                }
+                result += IRCodeChunk(notNegativeLabel, null)
+                return ExpressionCodeResult(result, IRDataType.LONG, tr.resultReg, -1)
+            }
             BaseDataType.FLOAT -> {
                 val resultFpReg = codeGen.registers.next(IRDataType.FLOAT)
                 addInstr(result, IRInstruction(Opcode.FABS, IRDataType.FLOAT, fpReg1 = resultFpReg, fpReg2 = tr.resultFpReg), null)
@@ -216,7 +232,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
     private fun funcSgn(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val tr = exprGen.translateExpression(call.args.single())
-        val resultReg = codeGen.registers.next(tr.dt)
+        val resultReg = codeGen.registers.next(IRDataType.BYTE)
 
         if(tr.dt==IRDataType.FLOAT) {
             addToResult(result, tr, -1, tr.resultFpReg)
@@ -253,6 +269,14 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 }
                 return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
             }
+            BaseDataType.LONG -> {
+                addToResult(result, tr, tr.resultReg, -1)
+                val resultReg = codeGen.registers.next(IRDataType.WORD)     // sqrt of a long still produces just a word result
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.SQRT, IRDataType.LONG, reg1=resultReg, reg2=tr.resultReg)
+                }
+                return ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
+            }
             BaseDataType.FLOAT -> {
                 addToResult(result, tr, -1, tr.resultFpReg)
                 val resultFpReg = codeGen.registers.next(IRDataType.FLOAT)
@@ -283,6 +307,52 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
     }
 
+    private fun funcMklong(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val resultReg = codeGen.registers.next(IRDataType.LONG)
+        if(call.args.size==2) {
+            // mklong2(word, word)
+            if((call.args[0] as? PtNumber)?.number == 0.0) {
+                // msw is 0, use EXT
+                val lswTr = exprGen.translateExpression(call.args[1])
+                addToResult(result, lswTr, lswTr.resultReg, -1)
+                addInstr(result, IRInstruction(Opcode.EXT, IRDataType.WORD, reg1=resultReg, reg2 = lswTr.resultReg), null)
+            } else {
+                val mswTr = exprGen.translateExpression(call.args[0])
+                addToResult(result, mswTr, mswTr.resultReg, -1)
+                val lswTr = exprGen.translateExpression(call.args[1])
+                addToResult(result, lswTr, lswTr.resultReg, -1)
+                addInstr(result, IRInstruction(Opcode.CONCAT, IRDataType.WORD, reg1=resultReg, reg2 = mswTr.resultReg, reg3 = lswTr.resultReg), null)
+            }
+        } else {
+            // mklong(msb, b3, b2, lsb)
+            if((call.args[0] as? PtNumber)?.number == 0.0 && (call.args[1] as? PtNumber)?.number == 0.0 && (call.args[2] as? PtNumber)?.number == 0.0) {
+                // use EXT.b + EXT.w
+                val lsbTr = exprGen.translateExpression(call.args[3])
+                addToResult(result, lsbTr, lsbTr.resultReg, -1)
+                val wordReg = codeGen.registers.next(IRDataType.WORD)
+                addInstr(result, IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1=wordReg, reg2 = lsbTr.resultReg), null)
+                addInstr(result, IRInstruction(Opcode.EXT, IRDataType.WORD, reg1=resultReg, reg2 = wordReg), null)
+            } else {
+                val msbTr = exprGen.translateExpression(call.args[0])
+                val b2Tr = exprGen.translateExpression(call.args[1])
+                val b1Tr = exprGen.translateExpression(call.args[2])
+                val lsbTr = exprGen.translateExpression(call.args[3])
+                addToResult(result, msbTr, msbTr.resultReg, -1)
+                addToResult(result, b2Tr, b2Tr.resultReg, -1)
+                addToResult(result, b1Tr, b1Tr.resultReg, -1)
+                addToResult(result, lsbTr, lsbTr.resultReg, -1)
+                val lswReg = codeGen.registers.next(IRDataType.WORD)
+                val mswReg = codeGen.registers.next(IRDataType.WORD)
+                addInstr(result, IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=mswReg, reg2 = msbTr.resultReg, reg3 = b2Tr.resultReg), null)
+                addInstr(result, IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=lswReg, reg2 = b1Tr.resultReg, reg3 = lsbTr.resultReg), null)
+                addInstr(result, IRInstruction(Opcode.CONCAT, IRDataType.WORD, reg1=resultReg, reg2 = mswReg, reg3 = lswReg), null)
+            }
+
+        }
+        return ExpressionCodeResult(result, IRDataType.LONG, resultReg, -1)
+    }
+
     private fun funcClamp(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val type = irType(call.type)
@@ -307,6 +377,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 BaseDataType.BYTE -> IMSyscall.CLAMP_BYTE
                 BaseDataType.UWORD -> IMSyscall.CLAMP_UWORD
                 BaseDataType.WORD -> IMSyscall.CLAMP_WORD
+                BaseDataType.LONG -> IMSyscall.CLAMP_LONG
                 else -> throw AssemblyError("invalid dt")
             }
             result += codeGen.makeSyscall(syscall, listOf(
@@ -515,26 +586,50 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(code, IRDataType.WORD, resultReg, -1)
     }
 
-    private fun funcLsb(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcLsb(call: PtBuiltinFunctionCall, fromLong: Boolean): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val tr = exprGen.translateExpression(call.args.single())
         addToResult(result, tr, tr.resultReg, -1)
         val resultReg = codeGen.registers.next(IRDataType.BYTE)
-        addInstr(result, IRInstruction(Opcode.LSIG, IRDataType.BYTE, reg1 = resultReg, reg2 = tr.resultReg), null)
+        if(fromLong)
+            addInstr(result, IRInstruction(Opcode.LSIGB, IRDataType.LONG, reg1 = resultReg, reg2 = tr.resultReg), null)
+        else
+            addInstr(result, IRInstruction(Opcode.LSIGB, IRDataType.WORD, reg1 = resultReg, reg2 = tr.resultReg), null)
         // note: if a word result is needed, the upper byte is cleared by the typecast that follows. No need to do it here.
         return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
     }
 
-    private fun funcMsb(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcLsw(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val tr = exprGen.translateExpression(call.args.single())
+        addToResult(result, tr, tr.resultReg, -1)
+        val resultReg = codeGen.registers.next(IRDataType.WORD)
+        addInstr(result, IRInstruction(Opcode.LSIGW, IRDataType.LONG, reg1 = resultReg, reg2 = tr.resultReg), null)
+        return ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
+    }
+
+    private fun funcMsb(call: PtBuiltinFunctionCall, fromLong: Boolean): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val tr = exprGen.translateExpression(call.args.single())
         addToResult(result, tr, tr.resultReg, -1)
         val resultReg = codeGen.registers.next(IRDataType.BYTE)
-        addInstr(result, IRInstruction(Opcode.MSIG, IRDataType.BYTE, reg1 = resultReg, reg2 = tr.resultReg), null)
+        if(fromLong)
+            addInstr(result, IRInstruction(Opcode.MSIGB, IRDataType.LONG, reg1 = resultReg, reg2 = tr.resultReg), null)
+        else
+            addInstr(result, IRInstruction(Opcode.MSIGB, IRDataType.WORD, reg1 = resultReg, reg2 = tr.resultReg), null)
         // note: if a word result is needed, the upper byte is cleared by the typecast that follows. No need to do it here.
         return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
     }
 
+    private fun funcMsw(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val tr = exprGen.translateExpression(call.args.single())
+        addToResult(result, tr, tr.resultReg, -1)
+        val resultReg = codeGen.registers.next(IRDataType.WORD)
+        addInstr(result, IRInstruction(Opcode.MSIGW, IRDataType.LONG, reg1 = resultReg, reg2 = tr.resultReg), null)
+        return ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
+    }
+
     private fun funcRolRor(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val arg = call.args[0]

codeGenIntermediate/src/prog8/codegen/intermediate/ExpressionGen.kt

@@ -99,7 +99,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         var pointerReg: Int
 
         if(deref.startpointer.type.isStructInstance) {
-            TODO("translate structinstance deref???")
+            TODO("translate structinstance deref??? ${deref.position}")
 /*
             val arrayIndexer = deref.startpointer as? PtArrayIndexer
             if(arrayIndexer==null)
@@ -406,7 +406,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         if(ptrWithOffset!=null) {
             if(ptrWithOffset.operator=="+" && ptrWithOffset.left is PtIdentifier) {
                 val constOffset = (ptrWithOffset.right as? PtNumber)?.number?.toInt()
-                if(constOffset in 0..255) {
+                if(constOffset in 0..65535) {
                     val ptrName = (ptrWithOffset.left as PtIdentifier).name
                     val pointerReg = codeGen.registers.next(IRDataType.WORD)
                     result += IRCodeChunk(null, null).also {
@@ -416,18 +416,6 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     return ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
                 }
             }
-            val offsetTypecast = ptrWithOffset.right as? PtTypeCast
-            if(ptrWithOffset.operator=="+" && ptrWithOffset.left is PtIdentifier && (ptrWithOffset.right.type.isByte || offsetTypecast?.value?.type?.isByte==true)) {
-                // LOADIX only works with byte index.
-                val tr = if(offsetTypecast?.value?.type?.isByte==true)
-                    translateExpression(offsetTypecast.value)
-                else
-                    translateExpression(ptrWithOffset.right)
-                addToResult(result, tr, tr.resultReg, -1)
-                val ptrName = (ptrWithOffset.left as PtIdentifier).name
-                addInstr(result, IRInstruction(Opcode.LOADIX, IRDataType.BYTE, reg1=resultRegister, reg2=tr.resultReg, labelSymbol = ptrName), null)
-                return ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
-            }
         }
 
         val tr = translateExpression(mem.address)
@@ -446,7 +434,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 else (it as PtNumber).number.toInt()
             }
             when {
-                elementDt.isIntegerOrBool -> {
+                elementDt.isWordOrByteOrBool -> {
                     if (elementDt.isByteOrBool) require(haystack.size in 0..PtContainmentCheck.MAX_SIZE_FOR_INLINE_CHECKS_BYTE)
                     if (elementDt.isWord) require(haystack.size in 0..PtContainmentCheck.MAX_SIZE_FOR_INLINE_CHECKS_WORD)
                     val gottemLabel = codeGen.createLabelName()
@@ -686,6 +674,10 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                         addInstr(result, IRInstruction(Opcode.CMPI, IRDataType.WORD, reg1=tr.resultReg, immediate = 0), null)
                         actualResultReg2 = loadStatusAsBooleanResult(Opcode.BSTNE, result)
                     }
+                    valueDt.isLong -> {
+                        addInstr(result, IRInstruction(Opcode.CMPI, IRDataType.LONG, reg1=tr.resultReg, immediate = 0), null)
+                        actualResultReg2 = loadStatusAsBooleanResult(Opcode.BSTNE, result)
+                    }
                     valueDt.isFloat -> {
                         actualResultReg2 = codeGen.registers.next(IRDataType.BYTE)
                         result += IRCodeChunk(null, null).also {
@@ -703,7 +695,11 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     }
                     BaseDataType.UWORD, BaseDataType.WORD -> {
                         actualResultReg2 = codeGen.registers.next(IRDataType.BYTE)
-                        addInstr(result, IRInstruction(Opcode.LSIG, IRDataType.BYTE, reg1=actualResultReg2, reg2=tr.resultReg, immediate = 0), null)
+                        addInstr(result, IRInstruction(Opcode.LSIGB, IRDataType.WORD, reg1=actualResultReg2, reg2=tr.resultReg, immediate = 0), null)
+                    }
+                    BaseDataType.LONG -> {
+                        actualResultReg2 = codeGen.registers.next(IRDataType.BYTE)
+                        addInstr(result, IRInstruction(Opcode.LSIGB, IRDataType.LONG, reg1=actualResultReg2, reg2=tr.resultReg, immediate = 0), null)
                     }
                     BaseDataType.FLOAT -> {
                         actualResultReg2 = codeGen.registers.next(IRDataType.BYTE)
@@ -719,7 +715,11 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     }
                     BaseDataType.UWORD, BaseDataType.WORD -> {
                         actualResultReg2 = codeGen.registers.next(IRDataType.BYTE)
-                        addInstr(result, IRInstruction(Opcode.LSIG, IRDataType.BYTE, reg1=actualResultReg2, reg2=tr.resultReg, immediate = 0), null)
+                        addInstr(result, IRInstruction(Opcode.LSIGB, IRDataType.WORD, reg1=actualResultReg2, reg2=tr.resultReg, immediate = 0), null)
+                    }
+                    BaseDataType.LONG -> {
+                        actualResultReg2 = codeGen.registers.next(IRDataType.BYTE)
+                        addInstr(result, IRInstruction(Opcode.LSIGB, IRDataType.LONG, reg1=actualResultReg2, reg2=tr.resultReg, immediate = 0), null)
                     }
                     BaseDataType.FLOAT -> {
                         actualResultReg2 = codeGen.registers.next(IRDataType.BYTE)
@@ -743,6 +743,10 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     BaseDataType.WORD -> {
                         actualResultReg2 = tr.resultReg
                     }
+                    BaseDataType.LONG -> {
+                        actualResultReg2 = codeGen.registers.next(IRDataType.WORD)
+                        addInstr(result, IRInstruction(Opcode.LSIGW, IRDataType.LONG, reg1=actualResultReg2, reg2=tr.resultReg, immediate = 0), null)
+                    }
                     BaseDataType.FLOAT -> {
                         actualResultReg2 = codeGen.registers.next(IRDataType.WORD)
                         addInstr(result, IRInstruction(Opcode.FTOUW, IRDataType.FLOAT, reg1=actualResultReg2, fpReg1 = tr.resultFpReg), null)
@@ -768,6 +772,10 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     BaseDataType.UWORD -> {
                         actualResultReg2 = tr.resultReg
                     }
+                    BaseDataType.LONG -> {
+                        actualResultReg2 = codeGen.registers.next(IRDataType.WORD)
+                        addInstr(result, IRInstruction(Opcode.LSIGW, IRDataType.LONG, reg1=actualResultReg2, reg2=tr.resultReg, immediate = 0), null)
+                    }
                     BaseDataType.FLOAT -> {
                         actualResultReg2 = codeGen.registers.next(IRDataType.WORD)
                         addInstr(result, IRInstruction(Opcode.FTOSW, IRDataType.FLOAT, reg1=actualResultReg2, fpReg1 = tr.resultFpReg), null)
@@ -775,6 +783,37 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     else -> throw AssemblyError("weird cast value type ${cast.position}")
                 }
             }
+            BaseDataType.LONG -> {
+                when(valueDt.base) {
+                    BaseDataType.UBYTE, BaseDataType.BOOL -> {
+                        // ubyte to long: double sign extend
+                        val wordreg = codeGen.registers.next(IRDataType.WORD)
+                        actualResultReg2 = codeGen.registers.next(IRDataType.LONG)
+                        addInstr(result, IRInstruction(Opcode.EXT, type = IRDataType.BYTE, reg1 = wordreg, reg2=tr.resultReg), null)
+                        addInstr(result, IRInstruction(Opcode.EXT, type = IRDataType.WORD, reg1 = actualResultReg2, reg2=wordreg), null)
+                    }
+                    BaseDataType.BYTE -> {
+                        // byte to long: double sign extend
+                        val wordreg = codeGen.registers.next(IRDataType.WORD)
+                        actualResultReg2 = codeGen.registers.next(IRDataType.LONG)
+                        addInstr(result, IRInstruction(Opcode.EXTS, type = IRDataType.BYTE, reg1 = wordreg, reg2=tr.resultReg), null)
+                        addInstr(result, IRInstruction(Opcode.EXTS, type = IRDataType.WORD, reg1 = actualResultReg2, reg2=wordreg), null)
+                    }
+                    BaseDataType.UWORD, BaseDataType.POINTER -> {
+                        actualResultReg2 = codeGen.registers.next(IRDataType.LONG)
+                        addInstr(result, IRInstruction(Opcode.EXT, type = IRDataType.WORD, reg1 = actualResultReg2, reg2=tr.resultReg), null)
+                    }
+                    BaseDataType.WORD -> {
+                        actualResultReg2 = codeGen.registers.next(IRDataType.LONG)
+                        addInstr(result, IRInstruction(Opcode.EXTS, type = IRDataType.WORD, reg1 = actualResultReg2, reg2=tr.resultReg), null)
+                    }
+                    BaseDataType.FLOAT -> {
+                        actualResultReg2 = codeGen.registers.next(IRDataType.LONG)
+                        addInstr(result, IRInstruction(Opcode.FTOSL, IRDataType.FLOAT, reg1=actualResultReg2, fpReg1 = tr.resultFpReg), null)
+                    }
+                    else -> throw AssemblyError("weird cast $valueDt to long ${cast.position}")
+                }
+            }
             BaseDataType.FLOAT -> {
                 actualResultFpReg2 = codeGen.registers.next(IRDataType.FLOAT)
                 when(valueDt.base) {
@@ -790,6 +829,9 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     BaseDataType.WORD -> {
                         addInstr(result, IRInstruction(Opcode.FFROMSW, IRDataType.FLOAT, reg1=tr.resultReg, fpReg1 = actualResultFpReg2), null)
                     }
+                    BaseDataType.LONG ->  {
+                        addInstr(result, IRInstruction(Opcode.FFROMSL, IRDataType.FLOAT, reg1=tr.resultReg, fpReg1 = actualResultFpReg2), null)
+                    }
                     else -> throw AssemblyError("weird cast value type ${cast.position}")
                 }
             }
@@ -799,7 +841,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 // no further conversion required, pointers are all just uwords
             }
             BaseDataType.ARRAY_POINTER -> {
-                TODO("typecast to array of pointers $valueDt -> ${cast.type}")
+                TODO("typecast to array of pointers $valueDt -> ${cast.type}  ${cast.position}")
             }
             else -> throw AssemblyError("weird cast value type ${cast.position}")
         }
@@ -1137,7 +1179,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                         fcallArgs = FunctionCallArgs(argRegisters, returnRegisters)
                     )
                 }
-                else TODO("extsub with banked address got called ${callTarget.name}")
+                else TODO("extsub with banked address got called ${callTarget.name}  ${fcall.position}")
             }
         addInstr(result, call, null)
         val resultRegs = returnRegisters.filter{it.dt!=IRDataType.FLOAT}.map{it.registerNum}
@@ -1715,9 +1757,9 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 result += pointerTr.chunks
                 pointerReg = pointerTr.resultReg
             } else if(left.pointerderef!=null) {
-                TODO("get pointer from deref $left")
+                TODO("get pointer from deref $left  ${left.position}")
             } else {
-                throw AssemblyError("weird arrayindexer $left")
+                throw AssemblyError("weird arrayindexer $left  ${left.position}")
             }
             val struct = left.type.subType!! as StStruct
             val constindex = left.index as? PtNumber

codeGenIntermediate/src/prog8/codegen/intermediate/IRCodeGen.kt

@@ -47,6 +47,7 @@ class IRCodeGen(
         ensureFirstChunkLabels(irProg)
         irProg.linkChunks()
         irProg.convertAsmChunks()
+        irProg.splitSSAchunks()
 
         // the optimizer also does 1 essential step regardless of optimizations: joining adjacent chunks.
         val optimizer = IRPeepholeOptimizer(irProg)
@@ -156,6 +157,7 @@ class IRCodeGen(
                             is IRCodeChunk -> {
                                 val replacement = IRCodeChunk(sub.label, first.next)
                                 replacement.instructions += first.instructions
+                                replacement.appendSrcPositions(first.sourceLinesPositions)
                                 replacement
                             }
                             is IRInlineAsmChunk -> IRInlineAsmChunk(sub.label, first.assembly, first.isIR, first.next)
@@ -271,7 +273,7 @@ class IRCodeGen(
             is PtSub -> throw AssemblyError("nested subroutines should have been flattened $node")
             is PtStructDecl -> emptyList()
             is PtSubSignature -> emptyList()
-            else -> TODO("missing codegen for $node")
+            else -> TODO("missing codegen for $node  ${node.position}")
         }
 
         val nonEmptyChunks = chunks.filter { it.isNotEmpty() || it.label != null }
@@ -409,6 +411,7 @@ class IRCodeGen(
             is IRCodeChunk -> {
                 val newChunk = IRCodeChunk(label, first.next)
                 newChunk.instructions += first.instructions
+                newChunk.appendSrcPositions(first.sourceLinesPositions)
                 newChunk
             }
             is IRInlineAsmChunk -> {
@@ -1141,7 +1144,7 @@ class IRCodeGen(
             if(identifier!=null && !isIndirectJump(goto))
                 IRInstruction(branchOpcode, labelSymbol = identifier.name)
             else
-                TODO("JUMP to expression address ${goto.target}")
+                TODO("JUMP to expression address ${goto.target}  ${goto.position}")
         }
     }
 
@@ -1859,7 +1862,7 @@ class IRCodeGen(
                 is PtNop -> { /* nothing */ }
                 is PtAssignment, is PtAugmentedAssign -> { /* global variable initialization is done elsewhere */ }
                 is PtVariable, is PtConstant, is PtMemMapped -> { /* vars should be looked up via symbol table */ }
-                is PtAlign -> TODO("ir support for inline %align")
+                is PtAlign -> TODO("ir support for inline %align  ${child.position}")
                 is PtSub -> {
                     val sub = IRSubroutine(child.name, translateParameters(child.signature.children), child.signature.returns, child.position)
                     for (subchild in child.children) {
@@ -1911,7 +1914,7 @@ class IRCodeGen(
                     }
                 }
                 is PtStructDecl -> { /* do nothing, should be found in the symbol table */ }
-                else -> TODO("weird block child node $child")
+                else -> TODO("weird block child node $child  ${child.position}")
             }
         }
         return irBlock
@@ -1975,12 +1978,17 @@ class IRCodeGen(
             in Cx16VirtualRegisters -> {
                 chunk += IRInstruction(Opcode.STOREM, paramDt, reg1=resultReg, labelSymbol = "cx16.${registerOrFlag.registerOrPair.toString().lowercase()}")
             }
+            in combinedLongRegisters -> {
+                require(paramDt==IRDataType.LONG)
+                val startreg = registerOrFlag.registerOrPair!!.startregname()
+                chunk += IRInstruction(Opcode.STOREM, paramDt, reg1=resultReg, labelSymbol = "cx16.${startreg}")
+            }
             null -> when(registerOrFlag.statusflag) {
                 // TODO: do the statusflag argument as last
                 Statusflag.Pc -> chunk += IRInstruction(Opcode.LSR, paramDt, reg1=resultReg)
                 else -> throw AssemblyError("unsupported statusflag as param")
             }
-            else -> throw AssemblyError("unsupported register arg")
+            else -> throw AssemblyError("unsupported register arg $registerOrFlag")
         }
         return chunk
     }

codeGenIntermediate/src/prog8/codegen/intermediate/IRPeepholeOptimizer.kt

@@ -55,6 +55,8 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
                                 || cleanupPushPop(chunk1, indexedInstructions)
                                 || simplifyConstantReturns(chunk1, indexedInstructions)
                                 || removeNeedlessLoads(chunk1, indexedInstructions)
+                                || useArrayIndexingInsteadOfAdds(chunk1, indexedInstructions)
+                                || removeNops(chunk1, indexedInstructions)   // last time, in case one of the optimizers replaced something with a nop
                     } while (changed)
                 }
             }
@@ -161,10 +163,10 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
             if(chunk.label!=null)
                 return false
             if(previous is IRCodeChunk && chunk is IRCodeChunk) {
-                // if the previous chunk doesn't end in a jump or a return, flow continues into the next chunk
+                // if the previous chunk doesn't end in a SSA branching instruction, flow continues into the next chunk, so they may be joined
                 val lastInstruction = previous.instructions.lastOrNull()
                 if(lastInstruction!=null)
-                    return lastInstruction.opcode !in OpcodesThatJump
+                    return lastInstruction.opcode !in OpcodesThatEndSSAblock
                 return true
             }
             return false
@@ -300,16 +302,16 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
             // remove useless RETURN
             if(idx>0 && (ins.opcode == Opcode.RETURN || ins.opcode==Opcode.RETURNR || ins.opcode==Opcode.RETURNI)) {
                 val previous = chunk.instructions[idx-1]
-                if(previous.opcode in OpcodesThatJump) {
+                if(previous.opcode in OpcodesThatBranchUnconditionally) {
                     chunk.instructions.removeAt(idx)
                     changed = true
                 }
             }
 
             // replace subsequent opcodes that jump by just the first
-            if(idx>0 && (ins.opcode in OpcodesThatJump)) {
+            if(idx>0 && (ins.opcode in OpcodesThatBranchUnconditionally)) {
                 val previous = chunk.instructions[idx-1]
-                if(previous.opcode in OpcodesThatJump) {
+                if(previous.opcode in OpcodesThatBranchUnconditionally) {
                     chunk.instructions.removeAt(idx)
                     changed = true
                 }
@@ -362,7 +364,7 @@ jump p8_label_gen_2
          */
         var changed=false
         indexedInstructions.reversed().forEach { (idx, ins) ->
-            if(idx>=2 && ins.opcode in OpcodesThatJump) {
+            if(idx>=2 && ins.opcode in OpcodesThatBranchUnconditionally) {
                 val previous = indexedInstructions[idx-1].value
                 val previous2 = indexedInstructions[idx-2].value
                 if(previous.opcode==Opcode.LOADR && previous2.opcode in OpcodesThatLoad) {
@@ -415,13 +417,19 @@ jump p8_label_gen_2
                             chunk.instructions.removeAt(idx)
                             changed = true
                         }
+                        -1 if ins.type == IRDataType.LONG -> {
+                            chunk.instructions.removeAt(idx)
+                            changed = true
+                        }
                     }
                 }
                 Opcode.OR -> {
                     if (ins.immediate == 0) {
                         chunk.instructions.removeAt(idx)
                         changed = true
-                    } else if ((ins.immediate == 255 && ins.type == IRDataType.BYTE) || (ins.immediate == 65535 && ins.type == IRDataType.WORD)) {
+                    } else if ((ins.immediate == 255 && ins.type == IRDataType.BYTE) ||
+                               (ins.immediate == 65535 && ins.type == IRDataType.WORD) ||
+                               (ins.immediate == -1 && ins.type == IRDataType.LONG)) {
                         chunk.instructions[idx] = IRInstruction(Opcode.LOAD, ins.type, reg1 = ins.reg1, immediate = ins.immediate)
                         changed = true
                     }
@@ -434,6 +442,54 @@ jump p8_label_gen_2
                 }
                 else -> {}
             }
+
+            fun optimizeImmediateLoadAssociative(replacementOpcode: Opcode) {
+
+                fun getImmediateLoad(reg: Int): Pair<Int, Int>? {
+                    // look if the given register gets an immediate value 1 or 2 istructions back
+                    // returns (index of load instruction, immediate value) or null.
+                    if(idx>=1) {
+                        val previous = indexedInstructions[idx-1].value
+                        if(previous.opcode==Opcode.LOAD && previous.reg1==reg)
+                            return idx-1 to previous.immediate!!
+                    }
+                    if(idx>=2) {
+                        val previous = indexedInstructions[idx-2].value
+                        if(previous.opcode==Opcode.LOAD && previous.reg1==reg)
+                            return idx-2 to previous.immediate!!
+                    }
+                    return null
+                }
+
+                if(ins.reg1!=null) {
+                    val immediate1 = getImmediateLoad(ins.reg1!!)
+                    if(immediate1!=null) {
+                        chunk.instructions[idx] = IRInstruction(replacementOpcode, ins.type, reg1 = ins.reg2, immediate = immediate1.second)
+                        chunk.instructions.removeAt(immediate1.first)
+                        changed=true
+                    } else {
+                        val immediate2 = getImmediateLoad(ins.reg2!!)
+                        if (immediate2 != null) {
+                            chunk.instructions[idx] = IRInstruction(replacementOpcode, ins.type, reg1 = ins.reg1, immediate = immediate2.second)
+                            chunk.instructions.removeAt(immediate2.first)
+                            changed=true
+                        }
+                    }
+                }
+            }
+
+            // try to use immediate arithmetic instruction if possible
+            when(ins.opcode) {
+                Opcode.ADDR -> optimizeImmediateLoadAssociative(Opcode.ADD)
+                Opcode.MULR -> optimizeImmediateLoadAssociative(Opcode.MUL)
+                Opcode.MULSR -> optimizeImmediateLoadAssociative(Opcode.MULS)
+//                Opcode.SUBR -> TODO("ir peephole Subr")
+//                Opcode.DIVR -> TODO("ir peephole Divr")
+//                Opcode.DIVSR -> TODO("ir peephole Divsr")
+//                Opcode.MODR -> TODO("ir peephole Modr")
+//                Opcode.DIVMODR -> TODO("ir peephole DivModr")
+                else -> {}
+            }
         }
         return changed
     }
@@ -499,4 +555,40 @@ jump p8_label_gen_2
         }
         return changed
     }
+
+    private fun useArrayIndexingInsteadOfAdds(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            if (ins.opcode == Opcode.ADD && ins.immediate!=null && idx>0) {
+                val load = indexedInstructions[idx-1].value
+                if((load.opcode==Opcode.LOAD) && load.labelSymbol!=null) {
+                    val lastInstruction = indexedInstructions[idx+1].value
+                    if(lastInstruction.opcode==Opcode.LOADI) {
+                        val targetRegister = lastInstruction.reg1!!
+                        if(ins.reg1==lastInstruction.reg2!! && load.reg1==lastInstruction.reg2!!) {
+                            val loadm = IRInstruction(Opcode.LOADM, lastInstruction.type, reg1=targetRegister, labelSymbol = load.labelSymbol, symbolOffset = ins.immediate)
+                            chunk.instructions[idx-1] = loadm
+                            chunk.instructions.removeAt(idx+1)
+                            chunk.instructions.removeAt(idx)
+                            changed = true
+                        }
+                    } else if(lastInstruction.opcode==Opcode.STOREI) {
+                        val targetRegister = lastInstruction.reg1!!
+                        if(ins.reg1==lastInstruction.reg2!! && load.reg1==lastInstruction.reg2!!) {
+                            val valueLoad = indexedInstructions[idx-2].value
+                            if(valueLoad.opcode==Opcode.LOAD && valueLoad.reg1==targetRegister) {
+                                val storem = IRInstruction(Opcode.STOREM, lastInstruction.type, reg1=valueLoad.reg1, labelSymbol = load.labelSymbol, symbolOffset = ins.immediate)
+                                chunk.instructions[idx-1] = storem
+                                chunk.instructions.removeAt(idx+1)
+                                chunk.instructions.removeAt(idx)
+                                changed = true
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return changed
+    }
 }

codeGenIntermediate/src/prog8/codegen/intermediate/RegisterPool.kt

@@ -7,6 +7,7 @@ internal class RegisterPool {
     // everything from 99000 onwards is reserved for special purposes:
     // 99000 - 99099 : WORD registers for syscall arguments and response value(s)
     // 99100 - 99199 : BYTE registers for syscall arguments and response value(s)
+    // 99200 - 99299 : LONG registers for syscall arguments and response value(s)
 
     private var nextRegister: Int=1
     private val registerTypes: MutableMap<Int, IRDataType> = mutableMapOf()
@@ -18,6 +19,8 @@ internal class RegisterPool {
             registerTypes[i] = IRDataType.WORD
         for(i in 99100..99199)
             registerTypes[i] = IRDataType.BYTE
+        for(i in 99200..99299)
+            registerTypes[i] = IRDataType.LONG
     }
 
     fun next(type: IRDataType): Int {

codeGenIntermediate/src/prog8/codegen/intermediate/StConvert.kt

@@ -122,7 +122,6 @@ private fun convert(variable: StMemVar): IRStMemVar {
 
 
 private fun convert(constant: StConstant): IRStConstant {
-    val dt = DataType.forDt(constant.dt)
     val scopedName = if('.' in constant.name) {
         constant.name
     } else {
@@ -132,7 +131,7 @@ private fun convert(constant: StConstant): IRStConstant {
             constant.name
         }
     }
-    return IRStConstant(scopedName, dt, constant.value)
+    return IRStConstant(scopedName, constant.dt, constant.value)
 }
 
 

codeGenIntermediate/test/Dummies.kt

@@ -10,12 +10,14 @@ internal object DummyMemsizer : IMemSizer {
             return when(dt.sub) {
                 BaseDataType.BOOL, BaseDataType.BYTE, BaseDataType.UBYTE -> numElements
                 BaseDataType.UWORD, BaseDataType.WORD -> numElements*2
+                BaseDataType.LONG -> numElements*4
                 BaseDataType.FLOAT -> numElements*5
                 else -> throw IllegalArgumentException("invalid sub type")
             }
         }
         return when {
             dt.isByteOrBool -> 1 * (numElements ?: 1)
+            dt.isLong -> 4 * (numElements ?: 1)
             dt.isFloat -> 5 * (numElements ?: 1)
             else -> 2 * (numElements ?: 1)
         }

codeGenIntermediate/test/TestIRPeepholeOpt.kt

@@ -23,6 +23,7 @@ class TestIRPeepholeOpt: FunSpec({
             noSysInit = true,
             romable = false,
             compTarget = target,
+            compilerVersion="99.99",
             loadAddress = target.PROGRAM_LOAD_ADDRESS,
             memtopAddress = 0xffffu
         )
@@ -204,21 +205,27 @@ class TestIRPeepholeOpt: FunSpec({
         val irProg = makeIRProgram(listOf(
             IRInstruction(Opcode.AND, IRDataType.BYTE, reg1=42, immediate = 0),
             IRInstruction(Opcode.AND, IRDataType.WORD, reg1=42, immediate = 0),
+            IRInstruction(Opcode.AND, IRDataType.LONG, reg1=42, immediate = 0),
             IRInstruction(Opcode.OR, IRDataType.BYTE, reg1=42, immediate = 255),
-            IRInstruction(Opcode.OR, IRDataType.WORD, reg1=42, immediate = 65535)
+            IRInstruction(Opcode.OR, IRDataType.WORD, reg1=42, immediate = 65535),
+            IRInstruction(Opcode.OR, IRDataType.LONG, reg1=42, immediate = -1)
         ))
-        irProg.chunks().single().instructions.size shouldBe 4
+        irProg.chunks().single().instructions.size shouldBe 6
         val opt = IRPeepholeOptimizer(irProg)
         opt.optimize(true, ErrorReporterForTests())
         val instr = irProg.chunks().single().instructions
-        instr.size shouldBe 4
+        instr.size shouldBe 6
         instr[0].opcode shouldBe Opcode.LOAD
         instr[1].opcode shouldBe Opcode.LOAD
         instr[2].opcode shouldBe Opcode.LOAD
         instr[3].opcode shouldBe Opcode.LOAD
+        instr[4].opcode shouldBe Opcode.LOAD
+        instr[5].opcode shouldBe Opcode.LOAD
         instr[0].immediate shouldBe 0
         instr[1].immediate shouldBe 0
-        instr[2].immediate shouldBe 255
-        instr[3].immediate shouldBe 65535
+        instr[2].immediate shouldBe 0
+        instr[3].immediate shouldBe 255
+        instr[4].immediate shouldBe 65535
+        instr[5].immediate shouldBe -1
     }
 })

codeGenIntermediate/test/TestVmCodeGen.kt

@@ -25,6 +25,7 @@ class TestVmCodeGen: FunSpec({
             noSysInit = false,
             romable = false,
             compTarget = target,
+            compilerVersion="99.99",
             loadAddress = target.PROGRAM_LOAD_ADDRESS,
             memtopAddress = 0xffffu
         )
@@ -340,7 +341,7 @@ class TestVmCodeGen: FunSpec({
         val errors = ErrorReporterForTests()
         val result = codegen.generate(program, st, options, errors) as VmAssemblyProgram
         val irChunks = (result.irProgram.blocks.first().children.single() as IRSubroutine).chunks
-        irChunks.size shouldBe 1
+        irChunks.size shouldBe 2
     }
 
     test("integer comparison expressions against zero") {
@@ -536,7 +537,7 @@ class TestVmCodeGen: FunSpec({
         val errors = ErrorReporterForTests()
         val result = codegen.generate(program, st, options, errors) as VmAssemblyProgram
         val irChunks = (result.irProgram.blocks.first().children.single() as IRSubroutine).chunks
-        irChunks.size shouldBe 1
+        irChunks.size shouldBe 2
     }
 
     test("extsub allowed in ir-codegen") {

codeOptimizers/src/prog8/optimizer/ConstantFoldingOptimizer.kt

@@ -39,7 +39,10 @@ class ConstantFoldingOptimizer(private val program: Program, private val errors:
             // see if LONG values may be reduced to something smaller
             val smaller = NumericLiteral.optimalInteger(numLiteral.number.toInt(), numLiteral.position)
             if(smaller.type!=BaseDataType.LONG) {
-                return listOf(IAstModification.ReplaceNode(numLiteral, smaller, parent))
+                if(parent !is Assignment || !parent.target.inferType(program).isLong) {
+                    // do NOT reduce the type if the target of the assignment is a long
+                    return listOf(IAstModification.ReplaceNode(numLiteral, smaller, parent))
+                }
             }
         }
 
@@ -346,7 +349,7 @@ class ConstantFoldingOptimizer(private val program: Program, private val errors:
                         }
                     }
                 } else if(arrayIndexedExpression.pointerderef!=null) {
-                    TODO("constant fold pointer[i]")
+                    TODO("constant fold pointer[i]  ${arrayIndexedExpression.position}")
                 }
             }
         }
@@ -440,7 +443,7 @@ class ConstantFoldingOptimizer(private val program: Program, private val errors:
         val numval = decl.value as? NumericLiteral
         if(decl.type== VarDeclType.CONST && numval!=null) {
             val valueDt = numval.inferType(program)
-            if(valueDt issimpletype BaseDataType.LONG) {
+            if(valueDt issimpletype BaseDataType.LONG || decl.datatype.isLong) {
                 return noModifications  // this is handled in the numericalvalue case
             }
             if(!(valueDt istype decl.datatype)) {

codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -169,7 +169,12 @@ class VarConstantValueTypeAdjuster(
                 val replaceFunc = if(t1.isBytes) {
                     if(t1 issimpletype BaseDataType.BYTE) "clamp__byte" else "clamp__ubyte"
                 } else if(t1.isInteger) {
-                    if(t1 issimpletype BaseDataType.WORD) "clamp__word" else "clamp__uword"
+                    when {
+                        t1 issimpletype BaseDataType.WORD -> "clamp__word"
+                        t1 issimpletype BaseDataType.UWORD -> "clamp__uword"
+                        t1 issimpletype BaseDataType.LONG -> "clamp__long"
+                        else -> throw FatalAstException("clamp type")
+                    }
                 } else {
                     errors.err("clamp builtin not supported for floats, use floats.clamp", functionCallExpr.position)
                     return noModifications
@@ -191,10 +196,12 @@ class VarConstantValueTypeAdjuster(
                     else
                         "${funcName}__ubyte"
                 } else if(t1.isInteger && t2.isInteger) {
-                    replaceFunc = if(t1 issimpletype BaseDataType.WORD || t2 issimpletype BaseDataType.WORD)
-                        "${funcName}__word"
-                    else
-                        "${funcName}__uword"
+                    replaceFunc = when {
+                        t1 issimpletype BaseDataType.LONG || t2 issimpletype BaseDataType.LONG -> "${funcName}__long"
+                        t1 issimpletype BaseDataType.WORD || t2 issimpletype BaseDataType.WORD -> "${funcName}__word"
+                        t1 issimpletype BaseDataType.UWORD || t2 issimpletype BaseDataType.UWORD -> "${funcName}__uword"
+                        else -> throw FatalAstException("min/max type")
+                    }
                 } else if(t1.isNumeric && t2.isNumeric) {
                     errors.err("min/max not supported for floats", functionCallExpr.position)
                     return noModifications
@@ -214,6 +221,7 @@ class VarConstantValueTypeAdjuster(
                 val replaceFunc = when {
                     dt.isSignedByte -> "abs__byte"
                     dt.isSignedWord -> "abs__word"
+                    dt.isLong -> "abs__long"
                     dt.isFloat -> "abs__float"
                     dt.isUnsignedByte || dt.isUnsignedWord -> {
                         return listOf(IAstModification.ReplaceNode(functionCallExpr, functionCallExpr.args[0], parent))
@@ -236,8 +244,16 @@ class VarConstantValueTypeAdjuster(
                     dt.isUnsignedByte -> "sqrt__ubyte"
                     dt.isUnsignedWord -> "sqrt__uword"
                     dt.isFloat -> "sqrt__float"
+                    dt.isLong -> {
+                        val value = functionCallExpr.args[0].constValue(program)?.number
+                        if(value!=null && value<0) {
+                            errors.err("expected unsigned or float numeric argument", functionCallExpr.args[0].position)
+                            return noModifications
+                        }
+                        "sqrt__long"
+                    }
                     else -> {
-                        errors.err("expected unsigned or float numeric argument", functionCallExpr.args[0].position)
+                        errors.err("expected numeric argument", functionCallExpr.args[0].position)
                         return noModifications
                     }
                 }
@@ -246,6 +262,15 @@ class VarConstantValueTypeAdjuster(
                     functionCallExpr))
             }
         }
+        else if(func==listOf("lsb") || func==listOf("msb")) {
+            val t1 = functionCallExpr.args[0].inferType(program)
+            if(t1.isLong) {
+                val replaceFunc = func[0]+"__long"
+                return listOf(IAstModification.SetExpression({functionCallExpr.target = it as IdentifierReference},
+                    IdentifierReference(listOf(replaceFunc), functionCallExpr.target.position),
+                    functionCallExpr))
+            }
+        }
         return noModifications
     }
 

codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt

@@ -247,15 +247,19 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
             if (rightVal?.number == 1.0) {
                 if (rightDt != leftDt && !(leftDt.isPointer && rightDt.isUnsignedWord)) {
                     val dt = if(leftDt.isPointer) BaseDataType.UWORD else leftDt.base
-                    val right = NumericLiteral(dt, rightVal.number, rightVal.position)
-                    return listOf(IAstModification.ReplaceNode(expr.right, right, expr))
+                    if(!dt.isLong) {
+                        val right = NumericLiteral(dt, rightVal.number, rightVal.position)
+                        return listOf(IAstModification.ReplaceNode(expr.right, right, expr))
+                    }
                 }
             }
             else if (rightVal?.number == 0.0) {
                 if (rightDt != leftDt && !(leftDt.isPointer && rightDt.isUnsignedWord)) {
                     val dt = if(leftDt.isPointer) BaseDataType.UWORD else leftDt.base
-                    val right = NumericLiteral(dt, rightVal.number, rightVal.position)
-                    return listOf(IAstModification.ReplaceNode(expr.right, right, expr))
+                    if(!dt.isLong) {
+                        val right = NumericLiteral(dt, rightVal.number, rightVal.position)
+                        return listOf(IAstModification.ReplaceNode(expr.right, right, expr))
+                    }
                 }
             }
         }
@@ -269,15 +273,19 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
             if (rightVal?.number == 1.0) {
                 if(rightDt!=leftDt && !(leftDt.isPointer && rightDt.isUnsignedWord)) {
                     val dt = if(leftDt.isPointer) BaseDataType.UWORD else leftDt.base
-                    val right = NumericLiteral(dt, rightVal.number, rightVal.position)
-                    return listOf(IAstModification.ReplaceNode(expr.right, right, expr))
+                    if(!dt.isLong) {
+                        val right = NumericLiteral(dt, rightVal.number, rightVal.position)
+                        return listOf(IAstModification.ReplaceNode(expr.right, right, expr))
+                    }
                 }
             }
             else if (rightVal?.number == 0.0) {
                 if(rightDt!=leftDt && !(leftDt.isPointer && rightDt.isUnsignedWord)) {
                     val dt = if(leftDt.isPointer) BaseDataType.UWORD else leftDt.base
-                    val right = NumericLiteral(dt, rightVal.number, rightVal.position)
-                    return listOf(IAstModification.ReplaceNode(expr.right, right, expr))
+                    if(!dt.isLong) {
+                        val right = NumericLiteral(dt, rightVal.number, rightVal.position)
+                        return listOf(IAstModification.ReplaceNode(expr.right, right, expr))
+                    }
                 }
             }
         }

codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -81,7 +81,7 @@ class UnusedCodeRemover(private val program: Program,
 
     private fun reportUnreachable(stmt: Statement) {
         when(val next = stmt.nextSibling()) {
-            null, is Label, is Directive, is VarDecl, is InlineAssembly, is Subroutine -> {}
+            null, is Label, is Directive, is VarDecl, is InlineAssembly, is Subroutine, is Break, is Jump -> {}
             else -> errors.warn("unreachable code", next.position)
         }
     }

compiler/build.gradle.kts

@@ -2,7 +2,8 @@ plugins {
     id("application")
     kotlin("jvm")
     // id("com.github.johnrengelman.shadow") version "8.1.1"
-    id("io.github.goooler.shadow") version "8.1.8"
+    // id("io.github.goooler.shadow") version "8.1.8"
+    id("com.gradleup.shadow") version "9.2.2"
     id("com.peterabeles.gversion") version "1.10.3"
 }
 

compiler/res/prog8lib/bcd.p8

@@ -0,0 +1,144 @@
+bcd {
+    ; Decimal addition an subtraction routines.
+    ; For CPUs that support BCD mode (binary coded decimal) (not all 6502 variants support this mode...)
+    ; This is useful for example for counting decimal score in a game, to avoid costly conversion to a decimal display string. Just print the hex representation.
+
+    sub addb(byte a, byte b) -> byte {
+        setbcd()
+        a += b
+        clearbcd()
+        return a
+    }
+
+    sub addub(ubyte a, ubyte b) -> ubyte {
+        setbcd()
+        a += b
+        clearbcd()
+        return a
+    }
+
+    sub addw(word a, word b) -> word {
+        setbcd()
+        a += b
+        clearbcd()
+        return a
+    }
+
+    sub adduw(uword a, uword b) -> uword {
+        setbcd()
+        a += b
+        clearbcd()
+        return a
+    }
+
+    sub addl(long a, long b) -> long {
+        setbcd()
+        a += b
+        clearbcd()
+        return a
+    }
+
+    sub addtol(^^long a, long b) {
+        ; -- inplace long BCD addition (avoids copying long values by value)
+        setbcd()
+        ;; NOT YET IMPLEMENTED IN PROG8: a^^ += b, so inline asm
+        %asm {{
+            lda  p8v_a
+            ldy  p8v_a+1
+            sta  P8ZP_SCRATCH_W1
+            sty  P8ZP_SCRATCH_W1+1
+            ldy  #0
+            clc
+            lda  (P8ZP_SCRATCH_W1),y
+            adc  p8v_b
+            sta  (P8ZP_SCRATCH_W1),y
+            iny
+            lda  (P8ZP_SCRATCH_W1),y
+            adc  p8v_b+1
+            sta  (P8ZP_SCRATCH_W1),y
+            iny
+            lda  (P8ZP_SCRATCH_W1),y
+            adc  p8v_b+2
+            sta  (P8ZP_SCRATCH_W1),y
+            iny
+            lda  (P8ZP_SCRATCH_W1),y
+            adc  p8v_b+3
+            sta  (P8ZP_SCRATCH_W1),y
+        }}
+        clearbcd()
+    }
+
+    sub subb(byte a, byte b) -> byte {
+        setbcd()
+        a -= b
+        clearbcd()
+        return a
+    }
+
+    sub subub(ubyte a, ubyte b) -> ubyte {
+        setbcd()
+        a -= b
+        clearbcd()
+        return a
+    }
+
+    sub subuw(uword a, uword b) -> uword {
+        setbcd()
+        a -= b
+        clearbcd()
+        return a
+    }
+
+    sub subl(long a, long b) -> long {
+        setbcd()
+        a -= b
+        clearbcd()
+        return a
+    }
+
+    sub subfroml(^^long a, long b) {
+        ; -- inplace long BCD subtraction (avoids copying long values by value)
+        setbcd()
+        ;; NOT YET IMPLEMENTED IN PROG8: a^^ -= b, so inline asm
+        %asm {{
+            lda  p8v_a
+            ldy  p8v_a+1
+            sta  P8ZP_SCRATCH_W1
+            sty  P8ZP_SCRATCH_W1+1
+            ldy  #0
+            sec
+            lda  (P8ZP_SCRATCH_W1),y
+            sbc  p8v_b
+            sta  (P8ZP_SCRATCH_W1),y
+            iny
+            lda  (P8ZP_SCRATCH_W1),y
+            sbc  p8v_b+1
+            sta  (P8ZP_SCRATCH_W1),y
+            iny
+            lda  (P8ZP_SCRATCH_W1),y
+            sbc  p8v_b+2
+            sta  (P8ZP_SCRATCH_W1),y
+            iny
+            lda  (P8ZP_SCRATCH_W1),y
+            sbc  p8v_b+3
+            sta  (P8ZP_SCRATCH_W1),y
+        }}
+        clearbcd()
+    }
+
+
+    inline asmsub setbcd() {
+        ; be safe and 6502 compatible and prohibit interrupts during BCD mode
+        %asm {{
+            php
+            sei
+            sed
+        }}
+    }
+
+    inline asmsub clearbcd() {
+        %asm {{
+            plp
+        }}
+    }
+}

compiler/res/prog8lib/buffers.p8

@@ -70,7 +70,65 @@ smallringbuffer {
     }
 }
 
-; note: for a "small stack"  (256 bytes size) just use the CPU stack via sys.push[w] / sys.pop[w].
+
+smallstack {
+    ; -- A small stack (LIFO) that uses just 256 bytes and is independent of the CPU stack. Stack is growing downward from the top of the buffer.
+    ;    You can store and retrieve bytes and words. There are no guards against stack over/underflow.
+    ; note: for a "small stack"  (256 bytes size) you might also perhaps just use the CPU stack via sys.push[w] / sys.pop[w].
+
+    ubyte[256] buffer
+    ubyte sp = 255
+
+    sub init() {
+        sp = 255
+    }
+
+    sub size() -> ubyte {
+        return 255-sp
+    }
+
+    sub free() -> ubyte {
+        return sp
+    }
+
+    sub isfull() -> bool {
+        return sp==0
+    }
+
+    sub isempty() -> bool {
+        return sp==255
+    }
+
+    sub push(ubyte value) {
+        ; -- put a byte on the stack
+        buffer[sp] = value
+        sp--
+    }
+
+    sub pushw(uword value) {
+        ; -- put a word on the stack (lsb first then msb)
+        buffer[sp] = lsb(value)
+        sp--
+        buffer[sp] = msb(value)
+        sp--
+    }
+
+    sub pop() -> ubyte {
+        ; -- pops a byte off the stack
+        sp++
+        return buffer[sp]
+    }
+
+    sub popw() -> uword {
+        ; -- pops a word off the stack.
+        sp++
+        cx16.r0H = buffer[sp]
+        sp++
+        cx16.r0L = buffer[sp]
+        return cx16.r0
+    }
+}
+
 
 stack {
     ; -- A stack (LIFO) that uses a block of 8 KB of memory. Growing downward from the top of the buffer.

compiler/res/prog8lib/c128/syslib.p8

@@ -133,6 +133,29 @@ asmsub RDTIM16() clobbers(X) -> uword @AY {
     }}
 }
 
+asmsub SETTIML(long jiffies @R0R1_32) {
+    ; -- just like SETTIM, but with a single 32 bit (lower 24 bits used) argument.
+    %asm {{
+        lda  cx16.r0
+        ldx  cx16.r0+1
+        ldy  cx16.r0+2
+        jmp  SETTIM
+    }}
+}
+
+asmsub RDTIML() clobbers(X) -> long @R0R1_32 {
+    ; --  like RDTIM() and returning the timer value as a 32 bit (lower 24 bits used) value.
+    %asm {{
+        jsr  RDTIM
+        sta  cx16.r0
+        stx  cx16.r0+1
+        sty  cx16.r0+2
+        lda  #0
+        sta  cx16.r0+3
+        rts
+    }}
+}
+
 sub CLEARST() {
     ; -- Set the ST status variable back to 0. (there's no direct kernal call for this)
     ;    Note: a drive error state (blinking led) isn't cleared! You can use diskio.status() to clear that.
@@ -335,7 +358,7 @@ extsub $FF71 = JMPFAR() clobbers(A,X)                           ; jump without r
 extsub $FF74 = INDFET(ubyte zpaddr @A, ubyte bank @X, ubyte offset @Y) clobbers(X) -> ubyte @A ; fetch byte from another bank (address in zp, ptr in A)
 extsub $FF77 = INDSTA(ubyte value @A, ubyte bank @X, ubyte offset @Y) clobbers(X) ; store byte to another bank (address in zp, ptr in $02b9)
 extsub $FF7A = INDCMP(ubyte value @A, ubyte bank @X, ubyte offset @Y) clobbers(X) -> bool @Pz, bool @Pc, bool @Pv; compare byte in another bank (address in zp, ptr in $02c8)
-extsub $FF7D = PRIMM()                                          ; print immediate string
+extsub $FF7D = PRIMM()                                          ; print immediate string  (the 0-terminated string immediately following the JSR PRIMM instruction)
 
 
 ; ---- C128 specific system utility routines: ----
@@ -1033,6 +1056,48 @@ _no_msb_size
         }}
     }
 
+    inline asmsub pushl(long value @R0R1_32) {
+        %asm {{
+            lda  cx16.r0
+            pha
+            lda  cx16.r0+1
+            pha
+            lda  cx16.r0+2
+            pha
+            lda  cx16.r0+3
+            pha
+        }}
+    }
+
+    inline asmsub popl() -> long @R0R1_32 {
+        %asm {{
+            pla
+            sta  cx16.r0+3
+            pla
+            sta  cx16.r0+2
+            pla
+            sta  cx16.r0+1
+            pla
+            sta  cx16.r0
+        }}
+    }
+
+    sub cpu_is_65816() -> bool {
+        ; Returns true when you have a 65816 cpu, false when it's a 6502.
+        ; The SuperCPU expansion for the C64/C128 contains a 65816.
+        %asm {{
+			php
+			clv
+			.byte $e2, $ea  ; SEP #$ea, should be interpreted as 2 NOPs by 6502. 65c816 will set the Overflow flag.
+			bvc +
+			lda #1
+			plp
+			rts
++			lda #0
+			plp
+			rts
+        }}
+    }
 }
 
 cx16 {
@@ -1075,6 +1140,16 @@ cx16 {
     &word r14s = $1bfc
     &word r15s = $1bfe
 
+    ; signed long versions
+    &long r0r1sl  = $1be0
+    &long r2r3sl  = $1be4
+    &long r4r5sl  = $1be8
+    &long r6r7sl  = $1bec
+    &long r8r9sl  = $1bf0
+    &long r10r11sl = $1bf4
+    &long r12r13sl = $1bf8
+    &long r14r15sl = $1bfc
+
     ; ubyte versions (low and high bytes)
     &ubyte r0L  = $1be0
     &ubyte r1L  = $1be2
@@ -1209,12 +1284,6 @@ cx16 {
             rts
         }}
     }
-
-    sub cpu_is_65816() -> bool {
-        ; Returns true when you have a 65816 cpu, false when it's a 6502.
-        return false
-    }
-
 }
 
 p8_sys_startup {
@@ -1243,6 +1312,11 @@ asmsub  init_system()  {
         lda  #0
         sta  c64.BGCOL0
         jsr  disable_runstop_and_charsetswitch
+        ; basic is not banked in, adjust MEMTOP
+        ldx  #<$c000
+        ldy  #>$c000
+        clc
+        jsr  cbm.MEMTOP
         cli
         rts
     }}
@@ -1264,6 +1338,10 @@ asmsub  cleanup_at_exit() {
         sta  $ff00          ; default bank 15
         jsr  cbm.CLRCHN		; reset i/o channels
         jsr  enable_runstop_and_charsetswitch
+        ldx  #<$ff00
+        ldy  #>$ff00
+        clc
+        jsr  cbm.MEMTOP     ; adjust MEMTOP to original value again
         lda  _exitcarry
         lsr  a
         lda  _exitcode

compiler/res/prog8lib/c128/textio.p8

@@ -406,6 +406,7 @@ asmsub width() clobbers(X,Y) -> ubyte @A {
     ; -- returns the text screen width (number of columns)
     %asm {{
         jsr  cbm.SCREEN
+        inx
         txa
         rts
     }}
@@ -415,11 +416,22 @@ asmsub height() clobbers(X, Y) -> ubyte @A {
     ; -- returns the text screen height (number of rows)
     %asm {{
         jsr  cbm.SCREEN
+        iny
         tya
         rts
     }}
 }
 
+asmsub size() clobbers(A) -> ubyte @X, ubyte @Y {
+    ; -- returns the text screen width in X and height in Y (number of columns and rows)
+    %asm {{
+        jsr  cbm.SCREEN
+        inx
+        iny
+        rts
+    }}
+}
+
 asmsub waitkey() -> ubyte @A {
     %asm {{
 -       jsr cbm.GETIN

compiler/res/prog8lib/c64/floats.asm

@@ -2,7 +2,8 @@
 
 FL_ONE_const	.byte  129     			; 1.0
 FL_ZERO_const	.byte  0,0,0,0,0		; 0.0
-FL_LOG2_const	.byte  $80, $31, $72, $17, $f8	; log(2)
+; note: don't add too many constants here because they all end up in the resulting program
+
 
 		.section BSS
 floats_temp_var         .byte  ?,?,?,?,?        ; temporary storage for a float
@@ -126,6 +127,75 @@ cast_FAC1_as_w_into_ay	.proc               ; also used for float 2 b
 		.pend
 
 
+cast_from_long          .proc
+        ; convert long pointed to by AY into a float pointed to by R0
+        ; a bit slow algorithm implemented below:  (msw(l) as word) as float * 65536.0 + (lsw(l) as float)
+        sta  P8ZP_SCRATCH_W1
+        sty  P8ZP_SCRATCH_W1+1
+        ldy  #3
+        lda  (P8ZP_SCRATCH_W1),y
+        sta  P8ZP_SCRATCH_REG
+        dey
+        lda  (P8ZP_SCRATCH_W1),y
+        ldy  P8ZP_SCRATCH_REG
+        jsr  GIVAYFAY
+        lda  #<FL_65536_const
+        ldy  #>FL_65536_const
+        jsr  CONUPK
+        jsr  FMULTT
+        jsr  pushFAC1
+        ldy  #1
+        lda  (P8ZP_SCRATCH_W1),y
+        sta  P8ZP_SCRATCH_REG
+        dey
+        lda  (P8ZP_SCRATCH_W1),y
+        ldy  P8ZP_SCRATCH_REG
+        jsr  GIVUAYFAY
+        jsr  MOVEF
+        clc
+        jsr  popFAC
+        jsr  FADDT
+        ldx  cx16.r0L
+        ldy  cx16.r0H
+        jmp  MOVMF
+
+FL_65536_const  .byte  $91, $00, $00, $00, $00  ; 65536.0
+        ; !notreached!
+        .pend
+
+cast_as_long            .proc
+        ; convert float pointed to by R0 into a long pointed to by AY
+
+        FACHO = FAC_ADDR + 1
+
+        ; save the target variable pointer on the stack
+        pha
+        tya
+        pha
+
+        lda  cx16.r0L
+        ldy  cx16.r0H
+        jsr  MOVFM
+        jsr  QINT
+
+        ; restore the target variable pointer from the stack, and put the result in it
+        pla
+        sta  P8ZP_SCRATCH_PTR+1
+        pla
+        sta  P8ZP_SCRATCH_PTR
+
+        ldx  #3
+        ldy  #0
+-       lda  FACHO,x
+        sta  (P8ZP_SCRATCH_PTR),y
+        iny
+        dex
+        bpl -
+        rts
+        .pend
+
+
+
 copy_float	.proc
 		; -- copies the 5 bytes of the mflt value pointed to by P8ZP_SCRATCH_W1,
 		;    into the 5 bytes pointed to by A/Y.  Clobbers A,Y.

compiler/res/prog8lib/c64/floats.p8

@@ -11,6 +11,7 @@ floats {
 		; note: the fac1 and fac2 are working registers and take 6 bytes each,
 		; floats in memory  (and rom) are stored in 5-byte MFLPT packed format.
 
+const uword FAC_ADDR = $61
 
 ; note: fac1/2 might get clobbered even if not mentioned in the function's name.
 ; note: for subtraction and division, the left operand is in fac2, the right operand in fac1.

compiler/res/prog8lib/c64/floats_funcs.asm

@@ -2,8 +2,11 @@
 
 
 func_sign_f_into_A	.proc
+		; sign in A, also sets status flags
 		jsr  MOVFM
-		jmp  SIGN
+		jsr  SIGN
+		cmp  #0
+		rts
 		.pend
 
 

compiler/res/prog8lib/c64/graphics.p8

@@ -288,29 +288,16 @@ hline_filled_right   .byte  0, %10000000, %11000000, %11100000, %11110000, %1111
     sub disc(uword xcenter, ubyte ycenter, ubyte radius) {
         ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
         ; Midpoint algorithm, filled.
+        ; Overdraws horizontal lines unfortunately.
         if radius==0
             return
         ubyte @zp yy = 0
         word decisionOver2 = (1 as word)-radius
-        ubyte last_y3 = ycenter+radius
-        ubyte last_y4 = ycenter-radius
-        ubyte new_y3, new_y4
-
         while radius>=yy {
             horizontal_line(xcenter-radius, ycenter+yy, radius*2+1)
             horizontal_line(xcenter-radius, ycenter-yy, radius*2+1)
-
-            new_y3 = ycenter+radius
-            if new_y3 != last_y3 {
-                horizontal_line(xcenter-yy, last_y3, yy*2+1)
-                last_y3 = new_y3
-            }
-            new_y4 = ycenter-radius
-            if new_y4 != last_y4 {
-                horizontal_line(xcenter-yy, last_y4, yy*2+1)
-                last_y4 = new_y4
-            }
-
+            horizontal_line(xcenter-yy, ycenter+radius, yy*2+1)
+            horizontal_line(xcenter-yy, ycenter-radius, yy*2+1)
             yy++
             if decisionOver2>=0 {
                 radius--
@@ -319,10 +306,6 @@ hline_filled_right   .byte  0, %10000000, %11000000, %11100000, %11110000, %1111
             decisionOver2 += yy*$0002
             decisionOver2++
         }
-        ; draw the final two spans
-        yy--
-        horizontal_line(xcenter-yy, last_y3, yy*2+1)
-        horizontal_line(xcenter-yy, last_y4, yy*2+1)
     }
 
 

compiler/res/prog8lib/c64/syslib.p8

@@ -132,6 +132,29 @@ asmsub RDTIM16() clobbers(X) -> uword @AY {
     }}
 }
 
+asmsub SETTIML(long jiffies @R0R1_32) {
+    ; -- just like SETTIM, but with a single 32 bit (lower 24 bits used) argument.
+    %asm {{
+        lda  cx16.r0
+        ldx  cx16.r0+1
+        ldy  cx16.r0+2
+        jmp  SETTIM
+    }}
+}
+
+asmsub RDTIML() clobbers(X) -> long @R0R1_32 {
+    ; --  like RDTIM() and returning the timer value as a 32 bit (lower 24 bits used) value.
+    %asm {{
+        jsr  RDTIM
+        sta  cx16.r0
+        stx  cx16.r0+1
+        sty  cx16.r0+2
+        lda  #0
+        sta  cx16.r0+3
+        rts
+    }}
+}
+
 sub CLEARST() {
     ; -- Set the ST status variable back to 0. (there's no direct kernal call for this)
     ;    Note: a drive error state (blinking led) isn't cleared! You can use diskio.status() to clear that.
@@ -1041,6 +1064,49 @@ _no_msb_size
             pla
         }}
     }
+
+    inline asmsub pushl(long value @R0R1_32) {
+        %asm {{
+            lda  cx16.r0
+            pha
+            lda  cx16.r0+1
+            pha
+            lda  cx16.r0+2
+            pha
+            lda  cx16.r0+3
+            pha
+        }}
+    }
+
+    inline asmsub popl() -> long @R0R1_32 {
+        %asm {{
+            pla
+            sta  cx16.r0+3
+            pla
+            sta  cx16.r0+2
+            pla
+            sta  cx16.r0+1
+            pla
+            sta  cx16.r0
+        }}
+    }
+
+    sub cpu_is_65816() -> bool {
+        ; Returns true when you have a 65816 cpu, false when it's a 6502.
+        ; The SuperCPU expansion for the C64/C128 contains a 65816.
+        %asm {{
+			php
+			clv
+			.byte $e2, $ea  ; SEP #$ea, should be interpreted as 2 NOPs by 6502. 65c816 will set the Overflow flag.
+			bvc +
+			lda #1
+			plp
+			rts
++			lda #0
+			plp
+			rts
+        }}
+    }
 }
 
 cx16 {
@@ -1084,6 +1150,16 @@ cx16 {
     &word r14s = $cffc
     &word r15s = $cffe
 
+    ; signed long versions
+    &long r0r1sl  = $cfe0
+    &long r2r3sl  = $cfe4
+    &long r4r5sl  = $cfe8
+    &long r6r7sl  = $cfec
+    &long r8r9sl  = $cff0
+    &long r10r11sl = $cff4
+    &long r12r13sl = $cff8
+    &long r14r15sl = $cffc
+
     ; ubyte versions (low and high bytes)
     &ubyte r0L  = $cfe0
     &ubyte r1L  = $cfe2
@@ -1218,12 +1294,6 @@ cx16 {
             rts
         }}
     }
-
-    sub cpu_is_65816() -> bool {
-        ; Returns true when you have a 65816 cpu, false when it's a 6502.
-        return false
-    }
-
 }
 
 p8_sys_startup {
@@ -1253,6 +1323,8 @@ asmsub  init_system()  {
         lda  #0
         sta  c64.BGCOL0
         jsr  disable_runstop_and_charsetswitch
+        lda  #$80
+        sta  650    ; enable key repeat for normal keys too
         lda  #PROG8_C64_BANK_CONFIG     ; apply bank config
         sta  $01
         and  #1
@@ -1289,6 +1361,8 @@ asmsub  cleanup_at_exit() {
         jsr  cbm.MEMTOP     ; adjust MEMTOP down again
         jsr  cbm.CLRCHN		; reset i/o channels
         jsr  enable_runstop_and_charsetswitch
+        lda  #0
+        sta  650            ; disable keyrepeats
         lda  _exitcarry
         lsr  a
         lda  _exitcode

compiler/res/prog8lib/c64/textio.p8

@@ -424,6 +424,14 @@ asmsub height() clobbers(X, Y) -> ubyte @A {
     }}
 }
 
+asmsub size() clobbers(A) -> ubyte @X, ubyte @Y {
+    ; -- returns the text screen width in X and height in Y (number of columns and rows)
+    %asm {{
+        jmp  cbm.SCREEN
+    }}
+}
+
+
 asmsub waitkey() -> ubyte @A {
     %asm {{
 -       jsr cbm.GETIN

compiler/res/prog8lib/conv.p8

@@ -6,8 +6,6 @@ conv {
 
 ; ----- number conversions to decimal strings ----
 
-    ubyte[16]  @shared string_out       ; result buffer for the string conversion routines (note: uses uninitialized ARRAY instead of STR, to force it to be allocated in BSS area so it's ROM-compatible)
-
     asmsub str_ub0(ubyte value @A) clobbers(X) -> str @AY {
         ; ---- convert the ubyte in A in decimal string form, with left padding 0s (3 positions total)
         %asm {{
@@ -155,6 +153,30 @@ asmsub  str_uwhex  (uword value @ AY) -> str @AY  {
 	}}
 }
 
+sub str_ulhex(long value) -> str {
+    %asm {{
+        lda  value+3
+        jsr  internal_ubyte2hex
+        sta  string_out
+        sty  string_out+1
+        lda  value+2
+        jsr  internal_ubyte2hex
+        sta  string_out+2
+        sty  string_out+3
+        lda  value+1
+        jsr  internal_ubyte2hex
+        sta  string_out+4
+        sty  string_out+5
+        lda  value
+        jsr  internal_ubyte2hex
+        sta  string_out+6
+        sty  string_out+7
+        lda  #0
+        sta  string_out+8
+    }}
+    return &string_out
+}
+
 asmsub  str_uw0  (uword value @ AY) clobbers(X) -> str @AY  {
 	; ---- convert the uword in A/Y in decimal string form, with left padding 0s (5 positions total)
 	%asm {{
@@ -228,15 +250,91 @@ asmsub  str_w  (word value @ AY) clobbers(X) -> str @AY  {
 	}}
 }
 
+sub  str_l  (long value) -> str  {
+	; ---- convert the long value into decimal string form, without left padding 0s
+        ; source: https://codebase64.net/doku.php?id=base:32_bit_hexadecimal_to_decimal_conversion
+        ; NOTE: this is a pretty slow conversion, don't use for time critical displays!
+        bool negative
+        string_out[0] = '0'
+        if value<0 {
+            negative = true
+            value = -value
+        }
+
+        %asm {{
+            jsr  hex2dec
+            ldx  #0
+-           lda  string_out+1,x
+            cmp  #'0'
+            bne  +
+            inx
+            bne  -
++           cpx  #10   ; just all 0? keep one
+            bne  +
+            dex
+
++           ; x points at the rightmost leading 0
+            lda  negative
+            beq  +
+            lda  #'-'       ; sign in front
+            sta  string_out,x
+            dex
+            bmi  _done
++           ; x still points at rightmost leading 0
+            ; remove leading 0's (there is at least one if we're here)
+            ldy  #0
+-           lda  string_out+1,x
+            sta  string_out,y
+            iny
+            inx
+            cpx  #10
+            bne  -
+            lda  #0
+            sta  string_out,y
+_done
+
+            lda  #<string_out
+            ldy  #>string_out
+            rts
+
+hex2dec:
+        ; converts 10 digits (32 bit values have max. 10 decimal digits)
+        ldx  #9+1
+l3      jsr  div10
+        ora  #$30
+        sta  string_out,x
+        dex
+        bne  l3
+        rts
+
+        ; divides a 32 bit value by 10
+        ; remainder is returned in akku
+div10
+        ldy  #32         ; 32 bits
+        lda  #0
+        clc
+l4      rol
+        cmp  #10
+        bcc  skip
+        sbc  #10
+skip    rol  value
+        rol  value+1
+        rol  value+2
+        rol  value+3
+        dey
+        bpl  l4
+        rts
+        }}
+    }
 
 ; ---- string conversion to numbers -----
 
-asmsub  any2uword(str string @AY) clobbers(Y) -> ubyte @A {
+asmsub  any2uword(str string @AY) -> uword @AY, ubyte @X {
 	; -- parses a string into a 16 bit unsigned number. String may be in decimal, hex or binary format.
 	;    (the latter two require a $ or % prefix to be recognised)
 	;    (any non-digit character will terminate the number string that is parsed)
-	;    returns amount of processed characters in A, and the parsed number will be in cx16.r15.
-	;    if the string was invalid, 0 will be returned in A.
+	;    returns the parsed number word in AY, and the number of processed characters (including the prefix symbol) in X.
+	;    if the string was invalid, 0 will be returned as count in X (and the word value in AY will be undefined).
 	%asm {{
 	pha
 	sta  P8ZP_SCRATCH_W1
@@ -257,13 +355,7 @@ _hex	pla
 _bin	pla
 	jsr  bin2uword
 _result
-        pha
-        lda  cx16.r15
-        sta  P8ZP_SCRATCH_B1        ; result value
-        pla
-        sta  cx16.r15
-        sty  cx16.r15+1
-        lda  P8ZP_SCRATCH_B1
+        ldx  cx16.r15
         rts
 	}}
 }
@@ -480,6 +572,85 @@ _try_iso
 	}}
 }
 
+asmsub hex2long(str string @AY) -> long @R0R1_32 {
+	; -- hexadecimal string (with or without '$') to long.
+	;    string may be in petscii or c64-screencode encoding.
+	;    stops parsing at the first character that's not a hex digit (except leading $)
+	;    result in R0:R1,  number of characters processed also remains in cx16.r15L if you want to use it!! (0 = error)
+    %asm {{
+	sta  P8ZP_SCRATCH_W2
+	sty  P8ZP_SCRATCH_W2+1
+	ldy  #0
+	sty  cx16.r0
+	sty  cx16.r0+1
+	sty  cx16.r0+2
+	sty  cx16.r0+3
+	sty  cx16.r15H
+	lda  (P8ZP_SCRATCH_W2),y
+	beq  _stop
+	cmp  #'$'
+	bne  _loop
+	iny
+_loop
+	lda  #0
+	sta  P8ZP_SCRATCH_B1
+	lda  (P8ZP_SCRATCH_W2),y
+	beq  _stop
+	cmp  #7                 ; screencode letters A-F are 1-6
+	bcc  _add_letter
+	and  #127
+	cmp  #97
+	bcs  _try_iso            ; maybe letter is iso:'a'-iso:'f' (97-102)
+	cmp  #'g'
+	bcs  _stop
+	cmp  #'a'
+	bcs  _add_letter
+	cmp  #'0'
+	bcc  _stop
+	cmp  #'9'+1
+	bcs  _stop
+_calc
+	asl  cx16.r0
+	rol  cx16.r0+1
+	rol  cx16.r0+2
+	rol  cx16.r0+3
+	asl  cx16.r0
+	rol  cx16.r0+1
+	rol  cx16.r0+2
+	rol  cx16.r0+3
+	asl  cx16.r0
+	rol  cx16.r0+1
+	rol  cx16.r0+2
+	rol  cx16.r0+3
+	asl  cx16.r0
+	rol  cx16.r0+1
+	rol  cx16.r0+2
+	rol  cx16.r0+3
+	and  #$0f
+	clc
+	adc  P8ZP_SCRATCH_B1
+	ora  cx16.r0
+	sta  cx16.r0
+	iny
+	bne  _loop
+_stop
+	sty  cx16.r15L
+	rts
+_add_letter
+	pha
+	lda  #9
+	sta  P8ZP_SCRATCH_B1
+	pla
+	jmp  _calc
+_try_iso
+        cmp  #103
+        bcs  _stop
+        and  #63
+        bne  _add_letter
+		; !notreached!
+    }}
+}
+
 asmsub  bin2uword(str string @AY) -> uword @AY {
 	; -- binary string (with or without '%') to uword.
 	;    stops parsing at the first character that's not a 0 or 1. (except leading %)
@@ -767,4 +938,6 @@ output		.fill 5      ; 0-terminated output buffer (to make printing easier)
 	}}
 }
 
+    ubyte[16]  @shared string_out       ; internal result buffer for the string conversion routines (note: uses uninitialized ARRAY instead of STR, to force it to be allocated in BSS area so it's ROM-compatible)
+
 }

compiler/res/prog8lib/cx16/buffers.p8

@@ -68,7 +68,65 @@ smallringbuffer {
     }
 }
 
-; note: for a "small stack"  (256 bytes size) just use the CPU stack via sys.push[w] / sys.pop[w].
+
+smallstack {
+    ; -- A small stack (LIFO) that uses just 256 bytes and is independent of the CPU stack. Stack is growing downward from the top of the buffer.
+    ;    You can store and retrieve bytes and words. There are no guards against stack over/underflow.
+    ; note: for a "small stack"  (256 bytes size) you might also perhaps just use the CPU stack via sys.push[w] / sys.pop[w].
+
+    ubyte[256] buffer
+    ubyte sp = 255
+
+    sub init() {
+        sp = 255
+    }
+
+    sub size() -> ubyte {
+        return 255-sp
+    }
+
+    sub free() -> ubyte {
+        return sp
+    }
+
+    sub isfull() -> bool {
+        return sp==0
+    }
+
+    sub isempty() -> bool {
+        return sp==255
+    }
+
+    sub push(ubyte value) {
+        ; -- put a byte on the stack
+        buffer[sp] = value
+        sp--
+    }
+
+    sub pushw(uword value) {
+        ; -- put a word on the stack (lsb first then msb)
+        buffer[sp] = lsb(value)
+        sp--
+        buffer[sp] = msb(value)
+        sp--
+    }
+
+    sub pop() -> ubyte {
+        ; -- pops a byte off the stack
+        sp++
+        return buffer[sp]
+    }
+
+    sub popw() -> uword {
+        ; -- pops a word off the stack.
+        sp++
+        cx16.r0H = buffer[sp]
+        sp++
+        cx16.r0L = buffer[sp]
+        return cx16.r0
+    }
+}
+
 
 stack {
     ; -- A stack (LIFO) that uses a block of 8 KB of memory. Growing downward from the top of the buffer.
@@ -78,7 +136,7 @@ stack {
     ubyte bank
 
     sub init(ubyte rambank) {
-        ; -- initialize the stack, must be called before use. Supply the HiRAM bank to use as buffer space.
+        ; -- initialize the stack, must be called before use. Supply the HIRAM bank to use as buffer space.
         sp = $bfff
         bank = rambank
     }
@@ -157,7 +215,7 @@ ringbuffer {
     ubyte bank = 255        ; set via init()
 
     sub init(ubyte rambank) {
-        ; -- initialize the ringbuffer, must be called before use. Supply the HiRAM bank to use as buffer space.
+        ; -- initialize the ringbuffer, must be called before use. Supply the HIRAM bank to use as buffer space.
         head = $a000
         tail = $bfff
         fill = 0

compiler/res/prog8lib/cx16/compression.p8

@@ -1,4 +1,4 @@
-; **experimental** data compression/decompression routines, API subject to change!!
+; data compression/decompression routines
 
 %import shared_compression
 

compiler/res/prog8lib/cx16/diskio.p8

@@ -244,6 +244,7 @@ io_error:
         ;    this version it only returns directory entries!
         ;    note: only a single iteration loop can be active at a time!
         cbm.SETNAM(5, "$:*=d")
+        diskio.lf_start_list.pattern_ptr = pattern_ptr
         goto diskio.lf_start_list.start_list_internal
     }
 
@@ -252,6 +253,7 @@ io_error:
         ;    this version only returns actual file entries!
         ;    note: only a single iteration loop can be active at a time!
         cbm.SETNAM(5, "$:*=p")
+        diskio.lf_start_list.pattern_ptr = pattern_ptr
         goto diskio.lf_start_list.start_list_internal
     }
 
@@ -566,7 +568,7 @@ return_status:
 
     sub internal_f_open_w(str filename, bool open_for_seeks) -> bool {
         f_close_w()
-        list_filename = filename
+        void strings.copy(filename, list_filename)
         str modifier = ",s,?"
         modifier[3] = 'w'
         if open_for_seeks
@@ -624,7 +626,7 @@ done:
         return list_filename
 
 io_error:
-        list_filename = "io error"
+        void strings.copy("io error", list_filename)
         goto done
     }
 
@@ -818,8 +820,13 @@ io_error:
 
     ; For use directly after a load or load_raw call (don't mess with the ram bank yet):
     ; Calculates the number of bytes loaded (files > 64Kb are truncated to 16 bits)
-    sub load_size(ubyte startbank, uword startaddress, uword endaddress) -> uword {
-        return $2000 * (cx16.getrambank() - startbank) + endaddress - startaddress
+    sub load_size(ubyte startbank, uword startaddress, uword endaddress) -> long {
+        &long banksize = &cx16.r12
+        banksize = cx16.getrambank() - startbank
+        banksize <<= 13     ; * 8192
+        banksize += endaddress
+        banksize -= startaddress
+        return banksize
     }
 
     asmsub vload(str name @R0, ubyte bank @A, uword startaddress @R1) clobbers(X, Y) -> bool @A {
@@ -994,15 +1001,12 @@ io_error:
         return false
     }
 
-    sub f_seek(uword pos_hiword, uword pos_loword) {
+    sub f_seek(long position) {
         ; -- seek in the reading file opened with f_open, to the given 32-bits position
         ;    Note: this will not work if you have already read the last byte of the file! Then you must close and reopen the file first.
         ubyte[6] command = ['p',0,0,0,0,0]
         command[1] = READ_IO_CHANNEL       ; f_open uses this secondary address
-        command[2] = lsb(pos_loword)
-        command[3] = msb(pos_loword)
-        command[4] = lsb(pos_hiword)
-        command[5] = msb(pos_hiword)
+        pokel(&command+2, position)
         cbm.SETNAM(sizeof(command), &command)
         cbm.SETLFS(15, drivenumber, 15)
         void cbm.OPEN()
@@ -1011,13 +1015,10 @@ io_error:
     }
 
 
-    sub f_seek_w(uword pos_hiword, uword pos_loword) {
+    sub f_seek_w(long position) {
         ; -- seek in the output file opened with f_open_w_seek, to the given 32-bits position
         diskio.f_seek.command[1] = WRITE_IO_CHANNEL       ; f_open_w uses this secondary address
-        diskio.f_seek.command[2] = lsb(pos_loword)
-        diskio.f_seek.command[3] = msb(pos_loword)
-        diskio.f_seek.command[4] = lsb(pos_hiword)
-        diskio.f_seek.command[5] = msb(pos_hiword)
+        pokel(&diskio.f_seek.command+2, position)
         cbm.SETNAM(sizeof(diskio.f_seek.command), &diskio.f_seek.command)
         cbm.SETLFS(15, drivenumber, 15)
         void cbm.OPEN()
@@ -1025,54 +1026,63 @@ io_error:
         reset_write_channel()    ; back to the write io channel
     }
 
-    asmsub f_tell() -> uword @R0, uword @R1, uword @R2, uword @R3 {
-        ; -- Returns the current read position of the opened read file,
-        ;    in R0 and R1 (low + high words) and the file size in R2 and R3 (low + high words).
-        ;    Returns 0 as size if the command is not supported by the DOS implementation/version.
-        %asm {{
-            jmp  internal_f_tell
-        }}
-    }
-
-    sub internal_f_tell() {
-        ; gets the (32 bits) position + file size of the opened read file channel
-        ubyte[2] command = ['t',0]
-        command[1] = READ_IO_CHANNEL       ; f_open uses this secondary address
-        cbm.SETNAM(sizeof(command), &command)
-        cbm.SETLFS(15, drivenumber, 15)
-        void cbm.OPEN()
-        void cbm.CHKIN(15)        ; use #15 as input channel
+    sub f_tell() -> long, long {
+        ; -- Returns the current read position of the opened read file, and the file size.
+        ;    Returns 0,0 if the command is not supported by the DOS implementation/version.
+        ubyte[3] command = ['?','?',0]
         bool success=false
-        ; valid response starts with "07," followed by hex notations of the position and filesize
-        if cbm.CHRIN()=='0' and cbm.CHRIN()=='7' and cbm.CHRIN()==',' {
-            cx16.r1 = read4hex()
-            cx16.r0 = read4hex()        ; position in R1:R0
-            void cbm.CHRIN()            ; separator space
-            cx16.r3 = read4hex()
-            cx16.r2 = read4hex()        ; filesize in R3:R2
-            success = true
+        long filesize, filepos
+        ubyte commandoffset
+
+        command[1] = 't'
+        commandoffset = 1
+        f_tell_internal()
+        return filepos, filesize
+
+        sub f_tell_internal() {
+            ; this code is used for both the T (tell) and FL (fatlba) commands
+            command[2] = READ_IO_CHANNEL       ; f_open uses this secondary address
+            cbm.SETNAM(sizeof(command)-commandoffset, &command+commandoffset)
+            cbm.SETLFS(15, drivenumber, 15)
+            void cbm.OPEN()
+            void cbm.CHKIN(15)        ; use #15 as input channel
+
+            ; valid response starts with "07," followed by hex notations of the position and filesize
+            if cbm.CHRIN()=='0' and cbm.CHRIN()=='7' and cbm.CHRIN()==',' {
+                filepos = read8hex()
+                void cbm.CHRIN()            ; separator space
+                filesize = read8hex()
+                success = true
+            } else {
+                filesize = filepos = 0
+            }
+
+            while cbm.READST()==0 {
+                cx16.r5L = cbm.CHRIN()
+                if cx16.r5L=='\r' or cx16.r5L=='\n'
+                    break
+            }
+
+            cbm.CLOSE(15)
+            reset_read_channel()       ; back to the read io channel
         }
-
-        while cbm.READST()==0 {
-            cx16.r5L = cbm.CHRIN()
-            if cx16.r5L=='\r' or cx16.r5L=='\n'
-                break
-        }
-
-        cbm.CLOSE(15)
-        reset_read_channel()       ; back to the read io channel
-        if success
-            return
-
-        cx16.r0 = cx16.r1 = cx16.r2 = cx16.r3 = 0
     }
 
-    sub read4hex() -> uword {
-        str hex = "0000"
-        hex[0] = cbm.CHRIN()
-        hex[1] = cbm.CHRIN()
-        hex[2] = cbm.CHRIN()
-        hex[3] = cbm.CHRIN()
-        return conv.hex2uword(hex)
+    sub f_fatlba() -> long, long {
+        ; -- Return the current LBA, cluster number  (sector index and shift value are ignored for now)
+        diskio.f_tell.command[0] = 'f'
+        diskio.f_tell.command[1] = 'l'
+        diskio.f_tell.commandoffset = 0
+        diskio.f_tell.f_tell_internal()
+        return diskio.f_tell.filepos, diskio.f_tell.filesize
+    }
+
+
+    sub read8hex() -> long {
+        str hex = "00000000"
+        for cx16.r0L in 0 to 7 {
+            hex[cx16.r0L] = cbm.CHRIN()
+        }
+        return conv.hex2long(hex)
     }
 }

compiler/res/prog8lib/cx16/floats.p8

@@ -14,6 +14,8 @@ floats {
 ; note: fac1/2 might get clobbered even if not mentioned in the function's name.
 ; note: for subtraction and division, the left operand is in fac2, the right operand in fac1.
 
+const uword FAC_ADDR = $c3
+
 extsub $fe00 = AYINT() clobbers(A,X,Y)          ; fac1-> signed word in 'facmo' and 'faclo', MSB FIRST. DON'T USE THIS, USE WRAPPER 'AYINT2' INSTEAD.  (might throw ILLEGAL QUANTITY)
 
 ; GIVAYF: signed word in Y/A (note different lsb/msb order) -> float in fac1

compiler/res/prog8lib/cx16/gfx_hires.p8

@@ -433,25 +433,12 @@ gfx_hires {
             return
         ubyte @zp yy = 0
         word @zp decisionOver2 = (1 as word)-radius
-        uword last_y3 = ycenter+radius
-        uword last_y4 = ycenter-radius
-        uword new_y3, new_y4
 
         while radius>=yy {
             horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, color)
             horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, color)
-
-            new_y3 = ycenter+radius
-            if new_y3 != last_y3 {
-                horizontal_line(xcenter-yy, last_y3, yy*$0002+1, color)
-                last_y3 = new_y3
-            }
-            new_y4 = ycenter-radius
-            if new_y4 != last_y4 {
-                horizontal_line(xcenter-yy, last_y4, yy*$0002+1, color)
-                last_y4 = new_y4
-            }
-
+            horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, color)
+            horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, color)
             yy++
             if decisionOver2>=0 {
                 radius--
@@ -460,11 +447,6 @@ gfx_hires {
             decisionOver2 += yy*$0002
             decisionOver2++
         }
-
-        ; draw the final two spans
-        yy--
-        horizontal_line(xcenter-yy, last_y3, yy*$0002+1, color)
-        horizontal_line(xcenter-yy, last_y4, yy*$0002+1, color)
     }
 
     sub safe_disc(uword @zp xcenter, uword @zp ycenter, ubyte @zp radius, ubyte color) {
@@ -474,23 +456,12 @@ gfx_hires {
             return
         ubyte @zp yy = 0
         word @zp decisionOver2 = (1 as word)-radius
-        uword last_y3 = ycenter+radius
-        uword last_y4 = ycenter-radius
-        uword new_y3, new_y4
 
         while radius>=yy {
             safe_horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, color)
             safe_horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, color)
-            new_y3 = ycenter+radius
-            if new_y3 != last_y3 {
-                safe_horizontal_line(xcenter-yy, last_y3, yy*$0002+1, color)
-                last_y3 = new_y3
-            }
-            new_y4 = ycenter-radius
-            if new_y4 != last_y4 {
-                safe_horizontal_line(xcenter-yy, last_y4, yy*$0002+1, color)
-                last_y4 = new_y4
-            }
+            safe_horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, color)
+            safe_horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, color)
             yy++
             if decisionOver2>=0 {
                 radius--
@@ -499,10 +470,6 @@ gfx_hires {
             decisionOver2 += yy*$0002
             decisionOver2++
         }
-        ; draw the final two spans
-        yy--
-        safe_horizontal_line(xcenter-yy, last_y3, yy*$0002+1, color)
-        safe_horizontal_line(xcenter-yy, last_y4, yy*$0002+1, color)
     }
 
     sub plot(uword @zp xx, uword @zp yy, ubyte @zp color) {

compiler/res/prog8lib/cx16/gfx_lores.p8

@@ -505,25 +505,11 @@ gfx_lores {
             return
         ubyte @zp yy = 0
         word @zp decisionOver2 = (1 as word)-radius
-        ubyte last_y3 = ycenter+radius
-        ubyte last_y4 = ycenter-radius
-        ubyte new_y3, new_y4
-
         while radius>=yy {
             horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, color)
             horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, color)
-
-            new_y3 = ycenter+radius
-            if new_y3 != last_y3 {
-                horizontal_line(xcenter-yy, last_y3, yy*$0002+1, color)
-                last_y3 = new_y3
-            }
-            new_y4 = ycenter-radius
-            if new_y4 != last_y4 {
-                horizontal_line(xcenter-yy, last_y4, yy*$0002+1, color)
-                last_y4 = new_y4
-            }
-
+            horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, color)
+            horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, color)
             yy++
             if decisionOver2>=0 {
                 radius--
@@ -532,11 +518,6 @@ gfx_lores {
             decisionOver2 += yy*$0002
             decisionOver2++
         }
-
-        ; draw the final two spans
-        yy--
-        horizontal_line(xcenter-yy, last_y3, yy*$0002+1, color)
-        horizontal_line(xcenter-yy, last_y4, yy*$0002+1, color)
     }
 
     sub safe_disc(uword @zp xcenter, uword @zp ycenter, ubyte @zp radius, ubyte color) {
@@ -546,29 +527,22 @@ gfx_lores {
             return
         ubyte @zp yy = 0
         word @zp decisionOver2 = (1 as word)-radius
-        uword last_y3 = ycenter+radius
-        uword last_y4 = ycenter-radius
-        uword new_y3, new_y4
 
         while radius>=yy {
             uword liney = ycenter+yy
             if msb(liney)==0
-                safe_horizontal_line(xcenter-radius, lsb(ycenter+yy), radius*$0002+1, color)
+                safe_horizontal_line(xcenter-radius, lsb(liney), radius*$0002+1, color)
             liney = ycenter-yy
             if msb(liney)==0
-                safe_horizontal_line(xcenter-radius, lsb(ycenter-yy), radius*$0002+1, color)
-            new_y3 = ycenter+radius
-            if new_y3 != last_y3 {
-                if msb(last_y3)==0
-                    safe_horizontal_line(xcenter-yy, lsb(last_y3), yy*$0002+1, color)
-                last_y3 = new_y3
-            }
-            new_y4 = ycenter-radius
-            if new_y4 != last_y4 {
-                if msb(last_y4)==0
-                    safe_horizontal_line(xcenter-yy, lsb(last_y4), yy*$0002+1, color)
-                last_y4 = new_y4
-            }
+                safe_horizontal_line(xcenter-radius, lsb(liney), radius*$0002+1, color)
+
+            liney = ycenter+radius
+            if msb(liney)==0
+                safe_horizontal_line(xcenter-yy, lsb(liney), yy*$0002+1, color)
+            liney = ycenter-radius
+            if msb(liney)==0
+                safe_horizontal_line(xcenter-yy, lsb(liney), yy*$0002+1, color)
+
             yy++
             if decisionOver2>=0 {
                 radius--
@@ -577,12 +551,6 @@ gfx_lores {
             decisionOver2 += yy*$0002
             decisionOver2++
         }
-        ; draw the final two spans
-        yy--
-        if msb(last_y3)==0
-            safe_horizontal_line(xcenter-yy, lsb(last_y3), yy*$0002+1, color)
-        if msb(last_y4)==0
-            safe_horizontal_line(xcenter-yy, lsb(last_y4), yy*$0002+1, color)
     }
 
     asmsub plot(uword x @AX, ubyte y @Y, ubyte color @R0) {

compiler/res/prog8lib/cx16/monogfx.p8

@@ -595,23 +595,12 @@ drawmode:               ora  cx16.r15L
             return
         ubyte @zp yy = 0
         word @zp decisionOver2 = (1 as word)-radius
-        uword last_y3 = ycenter+radius
-        uword last_y4 = ycenter-radius
-        uword new_y3, new_y4
 
         while radius>=yy {
             horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, draw)
             horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, draw)
-            new_y3 = ycenter+radius
-            if new_y3 != last_y3 {
-                horizontal_line(xcenter-yy, last_y3, yy*$0002+1, draw)
-                last_y3 = new_y3
-            }
-            new_y4 = ycenter-radius
-            if new_y4 != last_y4 {
-                horizontal_line(xcenter-yy, last_y4, yy*$0002+1, draw)
-                last_y4 = new_y4
-            }
+            horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, draw)
+            horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, draw)
             yy++
             if decisionOver2>=0 {
                 radius--
@@ -620,10 +609,6 @@ drawmode:               ora  cx16.r15L
             decisionOver2 += yy*$0002
             decisionOver2++
         }
-        ; draw the final two spans
-        yy--
-        horizontal_line(xcenter-yy, last_y3, yy*$0002+1, draw)
-        horizontal_line(xcenter-yy, last_y4, yy*$0002+1, draw)
     }
 
     sub safe_disc(uword @zp xcenter, uword @zp ycenter, ubyte @zp radius, bool draw) {
@@ -634,23 +619,12 @@ drawmode:               ora  cx16.r15L
             return
         ubyte @zp yy = 0
         word @zp decisionOver2 = (1 as word)-radius
-        uword last_y3 = ycenter+radius
-        uword last_y4 = ycenter-radius
-        uword new_y3, new_y4
 
         while radius>=yy {
             safe_horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, draw)
             safe_horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, draw)
-            new_y3 = ycenter+radius
-            if new_y3 != last_y3 {
-                safe_horizontal_line(xcenter-yy, last_y3, yy*$0002+1, draw)
-                last_y3 = new_y3
-            }
-            new_y4 = ycenter-radius
-            if new_y4 != last_y4 {
-                safe_horizontal_line(xcenter-yy, last_y4, yy*$0002+1, draw)
-                last_y4 = new_y4
-            }
+            safe_horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, draw)
+            safe_horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, draw)
             yy++
             if decisionOver2>=0 {
                 radius--
@@ -659,10 +633,6 @@ drawmode:               ora  cx16.r15L
             decisionOver2 += yy*$0002
             decisionOver2++
         }
-        ; draw the final two spans
-        yy--
-        safe_horizontal_line(xcenter-yy, last_y3, yy*$0002+1, draw)
-        safe_horizontal_line(xcenter-yy, last_y4, yy*$0002+1, draw)
     }
 
     sub plot(uword @zp xx, uword @zp yy, bool @zp draw) {
@@ -1038,7 +1008,7 @@ _doplot         beq  +
 
     ; y*40 lookup table. Pretty compact because it all fits in a word and we only need 240 y positions.
     ; a y*80 lookup table would be very large (lo,mid,hi for 480 values...)
-    uword[240] @split @shared times40 = [
+    uword[240] @shared times40 = [
         0, 40, 80, 120, 160, 200, 240, 280, 320, 360, 400, 440, 480, 520, 560, 600,
         640, 680, 720, 760, 800, 840, 880, 920, 960, 1000, 1040, 1080, 1120, 1160,
         1200, 1240, 1280, 1320, 1360, 1400, 1440, 1480, 1520, 1560, 1600, 1640, 1680,

compiler/res/prog8lib/cx16/syslib.p8

@@ -127,6 +127,28 @@ asmsub RDTIM16() clobbers(X) -> uword @AY {
     }}
 }
 
+asmsub SETTIML(long jiffies @R0R1_32) {
+    ; -- just like SETTIM, but with a single 32 bit (lower 24 bits used) argument.
+    %asm {{
+        lda  cx16.r0
+        ldx  cx16.r0+1
+        ldy  cx16.r0+2
+        jmp  SETTIM
+    }}
+}
+
+asmsub RDTIML() clobbers(X) -> long @R0R1_32 {
+    ; --  like RDTIM_safe() and returning the timer value as a 32 bit (lower 24 bits used) value.
+    %asm {{
+        jsr  RDTIM_safe
+        sta  cx16.r0
+        stx  cx16.r0+1
+        sty  cx16.r0+2
+        stz  cx16.r0+3
+        rts
+    }}
+}
+
 sub CLEARST() {
     ; -- Set the ST status variable back to 0. (there's no direct kernal call for this)
     ;    Note: a drive error state (blinking led) isn't cleared! You can use diskio.status() to clear that.
@@ -195,6 +217,16 @@ cx16 {
     &word r14s = $001e
     &word r15s = $0020
 
+    ; signed long versions
+    &long r0r1sl  = $0002
+    &long r2r3sl  = $0006
+    &long r4r5sl  = $000a
+    &long r6r7sl  = $000e
+    &long r8r9sl  = $0012
+    &long r10r11sl = $0016
+    &long r12r13sl = $001a
+    &long r14r15sl = $001e
+
     ; ubyte versions (low and high bytes)
     &ubyte r0L  = $0002
     &ubyte r1L  = $0004
@@ -441,7 +473,7 @@ extsub $ff62 = screen_set_charset(ubyte charset @A, uword charsetptr @XY)  clobb
 extsub $ff6e = JSRFAR()  ; following word = address to call, byte after that=rom/ram bank it is in
 extsub $ff74 = fetch(ubyte zp_startaddr @A, ubyte bank @X, ubyte index @Y)  clobbers(X) -> ubyte @A
 extsub $ff77 = stash(ubyte data @A, ubyte bank @X, ubyte index @Y)  clobbers(X)     ;  note: The the zero page address containing the base address is passed in stavec ($03B2)
-extsub $ff7d = PRIMM()
+extsub $ff7d = PRIMM()  ; print immediate string  (the 0-terminated string immediately following the JSR PRIMM instruction)
 
 ; high level graphics & fonts
 extsub $ff20 = GRAPH_init(uword vectors @R0)  clobbers(A,X,Y)
@@ -598,6 +630,10 @@ const ubyte  EXTAPI_scnsiz = $0D
 const ubyte  EXTAPI_kbd_leds = $0E
 const ubyte  EXTAPI_memory_decompress_from_func = $0F
 const ubyte  EXTAPI_default_palette = $10
+const ubyte  EXTAPI_has_machine_property = $11
+const ubyte  EXTAPI_kbdbuf_get = $12
+const ubyte  EXTAPI_kbdbuf_clear = $13
+const ubyte  EXTAPI_blink_enable = $14
 
 ; extapi16 call numbers
 const ubyte  EXTAPI16_test = $00
@@ -654,6 +690,30 @@ sub mouse_present() -> bool {
     return cx16.r0L != $fc       ; $fc = BAT_FAIL
 }
 
+asmsub get_charset() -> ubyte @A {
+    ;Get charset mode.  result: 0=unknown, 1=ISO, 2=PETSCII upper case/gfx, 3=PETSCII lowercase.
+    %asm {{
+
+KERNAL_MODE = $0372         ; internal kernal variable, risky to read it, but it's ben stable for many releases.
+        lda  KERNAL_MODE
+        beq  _end
+
+        bit  #$40                ;ISO mode flag
+        beq  +                   ;usually KERNAL_MODE 1 or 6 (| $40)
+        lda  #1
+        bra  _end
+
++       bit  #1                  ;PETSCII upper case/graphics
+        bne  +                   ;usually KERNAL_MODE 2 or 4
+        lda  #2
+        bra  _end
+
++       lda  #3                   ;PETSCII upper/lower case
+_end:
+        rts
+    }}
+}
+
 ; shims for the kernal routines called via the extapi call:
 
 asmsub mouse_set_pos(uword xpos @R0, uword ypos @R1) clobbers(X) {
@@ -736,31 +796,42 @@ asmsub set_default_palette() {
     }}
 }
 
-asmsub get_charset() -> ubyte @A {
-    ;Get charset mode.  result: 0=unknown, 1=ISO, 2=PETSCII upper case/gfx, 3=PETSCII lowercase.
+asmsub has_machine_property(ubyte property @X) clobbers(A,X) -> bool @Pc {
+    ; requires rom v49+
     %asm {{
+        lda  #EXTAPI_has_machine_property
+        jmp  cx16.extapi
+    }}
+}
 
-KERNAL_MODE = $0372         ; internal kernal variable, risky to read it, but it's ben stable for many releases.
-        lda  KERNAL_MODE
-        beq  _end
+asmsub kbdbuf_get() clobbers(X,Y) -> ubyte @A {
+    ; requires rom v49+
+    %asm {{
+        lda  #EXTAPI_kbdbuf_get
+        jmp  cx16.extapi
+    }}
+}
 
-        bit  #$40                ;ISO mode flag
-        beq  +                   ;usually KERNAL_MODE 1 or 6 (| $40)
-        lda  #1
-        bra  _end
+asmsub kbdbuf_clear() clobbers(A) {
+    ; requires rom v49+
+    %asm {{
+        lda  #EXTAPI_kbdbuf_clear
+        jmp  cx16.extapi
+    }}
+}
 
-+       bit  #1                  ;PETSCII upper case/graphics
-        bne  +                   ;usually KERNAL_MODE 2 or 4
-        lda  #2
-        bra  _end
-
-+       lda  #3                   ;PETSCII upper/lower case
-_end:
-        rts
+asmsub blink_enable(bool enable @X) clobbers(A,X) {
+    ; requires rom v49+
+    %asm {{
+        txa
+        and  #1
+        eor  #1
+        tax
+        lda  #EXTAPI_blink_enable
+        jmp  cx16.extapi
     }}
 }
 
-; TODO : implement shims for the remaining extapi calls.
 
 
 ; ---- end of kernal routines ----
@@ -1454,22 +1525,6 @@ sub search_x16edit() -> ubyte {
     return 255
 }
 
-    asmsub cpu_is_65816() -> bool @A {
-        ; -- Returns true when you have a 65816 cpu, false when it's a 6502.
-        %asm {{
-			php
-			clv
-			.byte $e2, $ea  ; SEP #$ea, should be interpreted as 2 NOPs by 6502. 65c816 will set the Overflow flag.
-			bvc +
-			lda #1
-			plp
-			rts
-+			lda #0
-			plp
-			rts
-        }}
-    }
-
     sub set_program_args(str args_ptr, ubyte args_size) {
         ; -- Set the inter-program arguments.
         ; standardized way to pass arguments between programs is in ram bank 0, address $bf00-$bfff.
@@ -2135,6 +2190,47 @@ save_SCRATCH_ZPWORD2	.word  ?
         }}
     }
 
+    inline asmsub pushl(long value @R0R1_32) {
+        %asm {{
+            lda  cx16.r0
+            pha
+            lda  cx16.r0+1
+            pha
+            lda  cx16.r0+2
+            pha
+            lda  cx16.r0+3
+            pha
+        }}
+    }
+
+    inline asmsub popl() -> long @R0R1_32 {
+        %asm {{
+            pla
+            sta  cx16.r0+3
+            pla
+            sta  cx16.r0+2
+            pla
+            sta  cx16.r0+1
+            pla
+            sta  cx16.r0
+        }}
+    }
+
+    asmsub cpu_is_65816() -> bool @A {
+        ; -- Returns true when you have a 65816 cpu, false when it's a 6502.
+        %asm {{
+			php
+			clv
+			.byte $e2, $ea  ; SEP #$ea, should be interpreted as 2 NOPs by 6502. 65c816 will set the Overflow flag.
+			bvc +
+			lda #1
+			plp
+			rts
++			lda #0
+			plp
+			rts
+        }}
+    }
 }
 
 p8_sys_startup {

compiler/res/prog8lib/cx16/textio.p8

@@ -615,6 +615,13 @@ asmsub height() clobbers(X, Y) -> ubyte @A {
     }}
 }
 
+asmsub size() clobbers(A) -> ubyte @X, ubyte @Y {
+    ; -- returns the text screen width in X and height in Y (number of columns and rows)
+    %asm {{
+        jmp  cbm.SCREEN
+    }}
+}
+
 asmsub waitkey() -> ubyte @A {
     %asm {{
 -       jsr cbm.GETIN

compiler/res/prog8lib/cx16/verafx.p8

@@ -116,26 +116,29 @@ verafx {
 
 
     asmsub mult16(uword value1 @R0, uword value2 @R1) clobbers(X) -> uword @AY {
-        ; Returns the 16 bits unsigned result of R0*R1 in AY.
+        ; Returns the lower 16 bits unsigned result of R0*R1 in AY
         ; Note: only the lower 16 bits!   (the upper 16 bits are not valid for unsigned word multiplications, only for signed)
         ; Verafx doesn't support unsigned values like this for full 32 bit result.
         ; Note: clobbers VRAM $1f9bc - $1f9bf (inclusive)
         %asm {{
-            lda  cx16.r0
-            sta  P8ZP_SCRATCH_W1
-            lda  cx16.r0+1
-            sta  P8ZP_SCRATCH_W1+1
-            jsr  verafx.muls
-            ldx  P8ZP_SCRATCH_W1
-            stx  cx16.r0
-            ldx  P8ZP_SCRATCH_W1+1
-            stx  cx16.r0+1
+            jmp  muls16
+        }}
+    }
+
+    asmsub muls16(word value1 @R0, word value2 @R1) clobbers(X) -> word @AY {
+        ; Returns just the lower 16 bits signed result of the multiplication in cx16.AY.
+        ; Note: clobbers R0, R1, and VRAM $1f9bc - $1f9bf (inclusive)
+        %asm {{
+            jsr  muls
+            lda  cx16.r0L
+            ldy  cx16.r0H
             rts
         }}
     }
 
-    asmsub muls(word value1 @R0, word value2 @R1) clobbers(X) -> word @AY, word @R0 {
-        ; Returns the 32 bits signed result in AY and R0  (lower word, upper word).
+
+    asmsub muls(word value1 @R0, word value2 @R1) clobbers(X) -> long @R0R1_32 {
+        ; Returns the 32 bits signed result in R0:R1  (lower word, upper word).
         ; Vera Fx multiplication support only works on signed values!
         ; Note: clobbers VRAM $1f9bc - $1f9bf (inclusive)
         %asm {{
@@ -171,12 +174,14 @@ verafx {
             stz  cx16.VERA_DATA0      ; multiply and write out result
             lda  #%00010001           ; $01 with Increment 1
             sta  cx16.VERA_ADDR_H     ; so we can read out the result
-            lda  cx16.VERA_DATA0      ; store the lower 16 bits of the result in AY
+            lda  cx16.VERA_DATA0      ; store the lower 16 bits of the result in R0
             ldy  cx16.VERA_DATA0
-            ldx  cx16.VERA_DATA0      ; store the upper 16 bits of the result in R0
-            stx  cx16.r0s
-            ldx  cx16.VERA_DATA0
-            stx  cx16.r0s+1
+            sta  cx16.r0L
+            sty  cx16.r0H
+            lda  cx16.VERA_DATA0      ; store the upper 16 bits of the result in R1
+            ldy  cx16.VERA_DATA0      ; store the upper 16 bits of the result in R1
+            sta  cx16.r1L
+            sty  cx16.r1H
             stz  cx16.VERA_FX_CTRL    ; Cache write disable
             stz  cx16.VERA_FX_MULT    ; $9F2C  reset multiply bit
             stz  cx16.VERA_CTRL       ; reset DCSEL

compiler/res/prog8lib/math.p8

@@ -220,6 +220,12 @@ _sinecosR8	.char  trunc(127.0 * sin(range(180+45) * rad(360.0/180.0)))
         }}
     }
 
+    sub mul32(uword a, uword b) -> long {
+        ; return 32 bits result of a*b
+        cx16.r2 = a*b
+        return mklong2(mul16_last_upper(), cx16.r2)
+    }
+
 sub direction_sc(byte x1, byte y1, byte x2, byte y2) -> ubyte {
     ; From a pair of signed coordinates around the origin, calculate discrete direction between 0 and 23 into A.
     cx16.r0L = 3        ; quadrant
@@ -548,14 +554,13 @@ log2_tab
     }
 
     sub crc16(^^ubyte data, uword length) -> uword {
-        ; calculates the CRC16 (XMODEM) checksum of the buffer.
+        ; calculates the CRC16 (XMODEM) checksum of the buffer. Clobbers R14 and R15.
         ; There are also "streaming" crc16_start/update/end routines below, that allow you to calculate crc16 for data that doesn't fit in a single memory block.
+        cx16.r14 = data
         crc16_start()
-        cx16.r13 = data
-        cx16.r14 = data+length
-        while cx16.r13!=cx16.r14 {
-            crc16_update(@(cx16.r13))
-            cx16.r13++
+        repeat length {
+            crc16_update(@(cx16.r14))
+            cx16.r14++
         }
         return crc16_end()
     }
@@ -602,19 +607,17 @@ log2_tab
         return cx16.r15
     }
 
-    sub crc32(^^ubyte data, uword length) {
+    sub crc32(^^ubyte data, uword length) -> long {
         ; Calculates the CRC-32 (ISO-HDLC/PKZIP) checksum of the buffer.
-        ; because prog8 doesn't have 32 bits integers, we have to split up the calculation over 2 words.
-        ; result stored in cx16.r14 (low word) and cx16.r15 (high word)
+        ; Clobbers R13 through R15,  returns the 32 bits result as long
         ; There are also "streaming" crc32_start/update/end routines below, that allow you to calculate crc32 for data that doesn't fit in a single memory block.
+        cx16.r13 = data
         crc32_start()
-        cx16.r12 = data
-        cx16.r13 = data+length
-        while cx16.r12!=cx16.r13 {
-            crc32_update(@(cx16.r12))
-            cx16.r12++
+        repeat length {
+            crc32_update(@(cx16.r13))
+            cx16.r13++
         }
-        crc32_end()
+        return crc32_end()
     }
 
     sub crc32_start() {
@@ -666,13 +669,12 @@ log2_tab
 ;        }
     }
 
-    sub crc32_end() {
-        ; finalize the "streaming" crc32
-        ; result stored in cx16.r14 (low word) and cx16.r15 (high word)
-        void crc32_end_result()
+    sub crc32_end() -> long {
+        ; finalize the "streaming" crc32 and returns the result
+        return crc32_end_result()
     }
 
-    asmsub crc32_end_result() -> uword @R15, uword @R14 {
+    asmsub crc32_end_result() -> long @R14R15_32 {
         ; finalize the "streaming" crc32
         ; returns the result value in cx16.r15 (high word) and r14 (low word)
         %asm {{

compiler/res/prog8lib/pet32/syslib.p8

@@ -81,6 +81,29 @@ asmsub RDTIM16() clobbers(X) -> uword @AY {
     }}
 }
 
+asmsub SETTIML(long jiffies @R0R1_32) {
+    ; -- just like SETTIM, but with a single 32 bit (lower 24 bits used) argument.
+    %asm {{
+        lda  cx16.r0
+        ldx  cx16.r0+1
+        ldy  cx16.r0+2
+        jmp  SETTIM
+    }}
+}
+
+asmsub RDTIML() clobbers(X) -> long @R0R1_32 {
+    ; --  like RDTIM() and returning the timer value as a 32 bit (lower 24 bits used) value.
+    %asm {{
+        jsr  RDTIM
+        sta  cx16.r0
+        stx  cx16.r0+1
+        sty  cx16.r0+2
+        lda  #0
+        sta  cx16.r0+3
+        rts
+    }}
+}
+
 asmsub kbdbuf_clear() {
     ; -- convenience helper routine to clear the keyboard buffer
     %asm {{
@@ -509,6 +532,37 @@ save_SCRATCH_ZPWORD2	.word  ?
         }}
     }
 
+    inline asmsub pushl(long value @R0R1_32) {
+        %asm {{
+            lda  cx16.r0
+            pha
+            lda  cx16.r0+1
+            pha
+            lda  cx16.r0+2
+            pha
+            lda  cx16.r0+3
+            pha
+        }}
+    }
+
+    inline asmsub popl() -> long @R0R1_32 {
+        %asm {{
+            pla
+            sta  cx16.r0+3
+            pla
+            sta  cx16.r0+2
+            pla
+            sta  cx16.r0+1
+            pla
+            sta  cx16.r0
+        }}
+    }
+
+    sub cpu_is_65816() -> bool {
+        ; Returns true when you have a 65816 cpu, false when it's a 6502.
+        return false
+    }
+
 }
 
 cx16 {
@@ -551,6 +605,16 @@ cx16 {
     &word r14s = $7ffc
     &word r15s = $7ffe
 
+    ; signed long versions
+    &long r0r1sl  = $7fe0
+    &long r2r3sl  = $7fe4
+    &long r4r5sl  = $7fe8
+    &long r6r7sl  = $7fec
+    &long r8r9sl  = $7fe0
+    &long r10r11sl = $7fe4
+    &long r12r13sl = $7fe8
+    &long r14r15sl = $7fec
+
     ; ubyte versions (low and high bytes)
     &ubyte r0L  = $7fe0
     &ubyte r1L  = $7fe2
@@ -686,11 +750,6 @@ cx16 {
         }}
     }
 
-    sub cpu_is_65816() -> bool {
-        ; Returns true when you have a 65816 cpu, false when it's a 6502.
-        return false
-    }
-
 }
 
 p8_sys_startup {

compiler/res/prog8lib/pet32/textio.p8

@@ -182,8 +182,8 @@ sub  setclr  (ubyte col, ubyte row, ubyte color)  {
 }
 
 
-sub  setcc  (ubyte col, ubyte row, ubyte character, ubyte charcolor_ignored)  {
-	; ---- set char at the given position on the screen. charcolor is ignored on PET
+sub  setcc  (ubyte col, ubyte row, ubyte character, ubyte charcolor)  {
+	; ---- set char at the given position on the screen. NOTE: charcolor is ignored on PET
 	%asm {{
   		lda  row
 		asl  a
@@ -236,6 +236,17 @@ asmsub height() clobbers(X, Y) -> ubyte @A {
     }}
 }
 
+asmsub size() clobbers(A) -> ubyte @X, ubyte @Y {
+    ; -- returns the text screen width in X and height in Y (number of columns and rows)
+    %asm {{
+        jsr  width
+        tax
+        jsr  height
+        tay
+        rts
+    }}
+}
+
 asmsub waitkey() -> ubyte @A {
     %asm {{
 -       jsr cbm.GETIN

compiler/res/prog8lib/prog8_funcs.asm

@@ -29,6 +29,36 @@ abs_w_into_AY	.proc
 +		rts
 		.pend
 
+abs_l_into_R14R15	.proc
+	; -- R14:R15 = abs(R14:R15)
+    lda  cx16.r15H
+    bmi  +   ; Negative if high bit of highest byte is set
+    rts
++
+    ; Invert all four bytes
+    lda  cx16.r14L
+    eor  #$FF
+    sta  cx16.r14L
+    lda  cx16.r14H
+    eor  #$FF
+    sta  cx16.r14H
+    lda  cx16.r15L
+    eor  #$FF
+    sta  cx16.r15L
+    lda  cx16.r15H
+    eor  #$FF
+    sta  cx16.r15H
+    ; Add 1 to whole 32-bit value
+    inc  cx16.r14L
+    bne  +
+    inc  cx16.r14H
+    bne  +
+    inc  cx16.r15L
+    bne  +
+    inc  cx16.r15H
++   rts
+		.pend
+
 func_sign_b_into_A	.proc
 		cmp  #0
 		beq  _zero
@@ -59,17 +89,39 @@ _possibly_zero	cmp  #0
 
 func_sign_w_into_A	.proc
 		cpy  #0
-		beq  _possibly_zero
-		bmi  _neg
-_pos		lda  #1
-		rts
-_neg		lda  #-1
-		rts
-_possibly_zero	cmp  #0
-		bne  _pos
+		bmi  _negative
+		bne  _positive
+		cmp  #0
+		beq  _zero
+_positive	lda  #1
+_zero		rts
+_negative	lda  #-1
 		rts
 		.pend
 
+func_sign_l_r14r15_into_A      .proc
+    lda  cx16.r14+3              ; msb
+    bmi  _negative
+    bne  _positive
+    lda  cx16.r14+2
+    bne  _positive
+    lda  cx16.r14+1
+    bne  _positive
+    lda  cx16.r14
+    beq  _zero
+    lda  #1
+_zero
+    rts
+_negative
+    lda  #-1
+    rts
+_positive
+    lda  #1
+    rts
+
+.pend
+
+
 
 func_sqrt16_into_A	.proc
 		; integer square root
@@ -405,6 +457,7 @@ func_peek   .proc
 	; -- read the byte value on the address in AY, into A
 	sta  P8ZP_SCRATCH_W1
 	sty  P8ZP_SCRATCH_W1+1
+from_scratchW1
 	ldy  #0
 	lda  (P8ZP_SCRATCH_W1),y
 	rts
@@ -414,6 +467,7 @@ func_peekw   .proc
 	; -- read the word value on the address in AY, into AY
 	sta  P8ZP_SCRATCH_W1
 	sty  P8ZP_SCRATCH_W1+1
+from_scratchW1
 	ldy  #0
 	lda  (P8ZP_SCRATCH_W1),y
 	pha
@@ -424,6 +478,26 @@ func_peekw   .proc
 	rts
 	.pend
 
+func_peekl   .proc
+	; -- read the ;pmg value on the address in AY, into R14:R15
+	sta  P8ZP_SCRATCH_W1
+	sty  P8ZP_SCRATCH_W1+1
+from_scratchW1
+	ldy  #0
+	lda  (P8ZP_SCRATCH_W1),y
+	sta  cx16.r14
+	iny
+	lda  (P8ZP_SCRATCH_W1),y
+	sta  cx16.r14+1
+	iny
+	lda  (P8ZP_SCRATCH_W1),y
+	sta  cx16.r14+2
+	iny
+	lda  (P8ZP_SCRATCH_W1),y
+	sta  cx16.r14+3
+	rts
+	.pend
+
 
 func_pokew   .proc
 	; -- store the word value in AY in the address in P8ZP_SCRATCH_W1
@@ -436,6 +510,35 @@ func_pokew   .proc
 	rts
 	.pend
 
+func_pokew_scratchW2   .proc
+	; -- store the word value in AY in the address in P8ZP_SCRATCH_W2
+	sty  P8ZP_SCRATCH_REG
+	ldy  #0
+	sta  (P8ZP_SCRATCH_W2),y
+	iny
+	lda  P8ZP_SCRATCH_REG
+	sta  (P8ZP_SCRATCH_W2),y
+	rts
+	.pend
+
+func_pokel   .proc
+	; -- store the long value in R14:R15 in the address in AY
+	sta  P8ZP_SCRATCH_W1
+	sty  P8ZP_SCRATCH_W1+1
+	ldy  #0
+	lda  cx16.r14
+	sta  (P8ZP_SCRATCH_W1),y
+	iny
+	lda  cx16.r14+1
+	sta  (P8ZP_SCRATCH_W1),y
+	iny
+	lda  cx16.r14+2
+	sta  (P8ZP_SCRATCH_W1),y
+	iny
+	lda  cx16.r14+3
+	sta  (P8ZP_SCRATCH_W1),y
+	rts
+	.pend
 
 func_clamp_byte .proc
 	; signed value in A, result in A

compiler/res/prog8lib/prog8_lib.asm

@@ -266,6 +266,25 @@ strcpy		.proc
 		rts
 		.pend
 
+strncpy		.proc
+		; copy a string (must be 0-terminated) from A/Y to (P8ZP_SCRATCH_W1)
+		; with maximum length to copy in X.
+		; returns the length of the string that was copied in Y.
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		ldy  #$ff
+-		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		sta  (P8ZP_SCRATCH_W1),y
+		beq  +
+		dex
+		bne  -
+		iny
+		lda  #0
+		sta  (P8ZP_SCRATCH_W1),y
++		rts
+		.pend
+
 strcmp_expression	.proc
 		; -- compare strings, result in A
 		lda  _arg_s2
@@ -449,3 +468,223 @@ _fullpage       lda  (P8ZP_SCRATCH_W1),y
                 bne  _fullpage
                 rts
 		.pend
+
+
+long_not_equals     .proc
+		; checks if the 32 bits long value pointed to by AY is NOT equal to the one pointed to by P8ZP_SCRATCH_W1
+		; returns A=1 if NOT equals otherwise A=0
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		ldy  #3
+-		lda  (P8ZP_SCRATCH_W1),y
+		cmp  (P8ZP_SCRATCH_W2),y
+		bne  _notequal
+		dey
+		bpl  -
+		lda  #0
+		rts
+_notequal       lda  #1
+		rts
+		.pend
+
+
+long_add_inplace        .proc
+		; long pointed to by AY += long pointed to by P8ZP_SCRATCH_W1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		clc
+		ldy  #0
+		lda  (P8ZP_SCRATCH_W2),y
+		adc  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		adc  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		adc  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		adc  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		rts
+		.pend
+
+long_sub_inplace    .proc
+		; long pointed to by AY -= long pointed to by P8ZP_SCRATCH_W1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		ldy  #0
+		sec
+		lda  (P8ZP_SCRATCH_W2),y
+		sbc  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		sbc  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		sbc  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		sbc  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		rts
+		.pend
+
+long_or_inplace       .proc
+		; long pointed to by AY OR= long pointed to by P8ZP_SCRATCH_W1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		ldy  #0
+		lda  (P8ZP_SCRATCH_W2),y
+		ora  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		ora  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		ora  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		ora  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		rts
+		.pend
+
+long_and_inplace       .proc
+		; long pointed to by AY AND= long pointed to by P8ZP_SCRATCH_W1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		ldy  #0
+		lda  (P8ZP_SCRATCH_W2),y
+		and  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		and  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		and  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		and  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		rts
+		.pend
+
+long_xor_inplace       .proc
+		; long pointed to by AY XOR= long pointed to by P8ZP_SCRATCH_W1
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		ldy  #0
+		lda  (P8ZP_SCRATCH_W2),y
+		eor  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		eor  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		eor  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		iny
+		lda  (P8ZP_SCRATCH_W2),y
+		eor  (P8ZP_SCRATCH_W1),y
+		sta  (P8ZP_SCRATCH_W2),y
+		rts
+		.pend
+
+long_shiftleftX_inplace         .proc
+		; bit shift left X bits the long value pointed to by AY
+		cpx  #0
+		beq  _end
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+-		ldy  #0
+		lda  (P8ZP_SCRATCH_W1),y
+		asl  a
+		sta  (P8ZP_SCRATCH_W1),y
+		iny
+		lda  (P8ZP_SCRATCH_W1),y
+		rol  a
+		sta  (P8ZP_SCRATCH_W1),y
+		iny
+		lda  (P8ZP_SCRATCH_W1),y
+		rol  a
+		sta  (P8ZP_SCRATCH_W1),y
+		iny
+		lda  (P8ZP_SCRATCH_W1),y
+		rol  a
+		sta  (P8ZP_SCRATCH_W1),y
+		dex
+		bne  -
+_end		rts
+		.pend
+
+long_shiftrightX_inplace        .proc
+		; bit shift right X bits the long value pointed to by AY
+		cpx  #0
+		beq  _end
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+-		ldy  #3
+		lda  (P8ZP_SCRATCH_W1),y
+		asl  a  ; save sign bit
+		lda  (P8ZP_SCRATCH_W1),y
+		ror  a
+		sta  (P8ZP_SCRATCH_W1),y
+		dey
+		lda  (P8ZP_SCRATCH_W1),y
+		ror  a
+		sta  (P8ZP_SCRATCH_W1),y
+		dey
+		lda  (P8ZP_SCRATCH_W1),y
+		ror  a
+		sta  (P8ZP_SCRATCH_W1),y
+		dey
+		lda  (P8ZP_SCRATCH_W1),y
+		ror  a
+		sta  (P8ZP_SCRATCH_W1),y
+		dex
+		bne  -
+_end		rts
+		.pend
+
+
+compare_long_0_and_sign	        .proc
+		; pointer to 32 bits signed long in P8ZP_SCRATCH_W1, carry Set=check NEGATIVE (<=0), carry Clear=check POSITIVE (>=0)
+		; returns carry Set if comparison succeeded otherwise carry Clear
+		ldy  #0
+		lda  (P8ZP_SCRATCH_W1),y
+		iny
+		ora  (P8ZP_SCRATCH_W1),y
+		iny
+		ora  (P8ZP_SCRATCH_W1),y
+		iny
+		ora  (P8ZP_SCRATCH_W1),y
+		beq  _success
+
+		lda  (P8ZP_SCRATCH_W1),y
+		bcc  _checkpositive
+		bmi  _success
+		bpl  _fail
+
+_checkpositive	bpl  _success
+
+_fail		clc
+		rts
+
+_success	sec
+		rts
+		.pend

compiler/res/prog8lib/shared_cbm_diskio.p8

@@ -222,6 +222,7 @@ io_error:
         ;    this version it only returns directory entries!
         ;    note: only a single iteration loop can be active at a time!
         cbm.SETNAM(5, "$:*=c")  ; on C64 (1581 diskdrive) the type for directories is CBM
+        diskio.lf_start_list.pattern_ptr = pattern_ptr
         goto diskio.lf_start_list.start_list_internal
     }
 
@@ -230,6 +231,7 @@ io_error:
         ;    this version only returns actual file entries!
         ;    note: only a single iteration loop can be active at a time!
         cbm.SETNAM(5, "$:*=p")
+        diskio.lf_start_list.pattern_ptr = pattern_ptr
         goto diskio.lf_start_list.start_list_internal
     }
 
@@ -550,7 +552,7 @@ done:
         return list_filename
 
 io_error:
-        list_filename = "io error"
+        void strings.copy("io error", list_filename)
         goto done
     }
 

compiler/res/prog8lib/shared_cbm_textio_functions.p8

@@ -109,6 +109,12 @@ txt {
         }}
     }
 
+    sub print_ulhex(long value, bool prefix) {
+        if prefix
+            cbm.CHROUT('$')
+        print(conv.str_ulhex(value))
+    }
+
     asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
         ; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
         %asm {{
@@ -165,6 +171,11 @@ _allzero    lda  #'0'
         }}
     }
 
+    sub print_l(long value) {
+        ; prints a 32 bit value to the screen
+        print(conv.str_l(value))
+    }
+
     asmsub  input_chars  (^^ubyte buffer @ AY) clobbers(A) -> ubyte @ Y  {
         ; ---- Input a string (max. 80 chars) from the keyboard, in PETSCII encoding.
         ;      Returns length in Y. (string is terminated with a 0 byte as well)

compiler/res/prog8lib/shared_compression.p8

@@ -1,4 +1,4 @@
-; **experimental** data compression/decompression routines, API subject to change!!
+; data compression/decompression routines
 ; This file contains the shared routines that work on all targets.
 
 compression {

compiler/res/prog8lib/shared_floats_functions.p8

@@ -160,6 +160,9 @@ sub log2(float value) -> float {
         ldy  #>FL_LOG2_const
         jsr  MOVFM
         jmp  FDIVT
+
+FL_LOG2_const	.byte  $80, $31, $72, $17, $f8	; log(2)
+        ; !notreached!
     }}
 }
 

compiler/res/prog8lib/sorting.p8

@@ -138,31 +138,29 @@ _done
         }
     }
 
-    ; TODO convert to ^^uword once code size regression is fixed
-    sub shellsort_uw(uword @requirezp values, ubyte num_elements) {
+    sub shellsort_uw(^^uword @requirezp values, ubyte num_elements) {
         ; sorts the values array (no-split unsigned words).
         num_elements--
         ubyte gap
         for gap in [132, 57, 23, 10, 4, 1] {
             ubyte i
             for i in gap to num_elements {
-                uword @zp temp = peekw(values+i*$0002)
+                uword @zp temp = values[i]
                 ubyte @zp j = i
                 ubyte @zp k = j-gap
                 while j>=gap {
-                    uword @zp v = peekw(values+k*$0002)
+                    uword @zp v = values[k]
                     if v <= temp break
-                    pokew(values+j*$0002, v)
+                    values[j] = v
                     j = k
                     k -= gap
                 }
-                pokew(values+j*$0002, temp)
+                values[j] = temp
             }
         }
     }
 
-    ; TODO convert to ^^uword once code size regression is fixed
-    sub shellsort_by_ub(^^ubyte @requirezp ub_keys, uword @requirezp wordvalues, ubyte num_elements) {
+    sub shellsort_by_ub(^^ubyte @requirezp ub_keys, ^^uword @requirezp wordvalues, ubyte num_elements) {
         ; sorts the 'wordvalues' array (no-split array of words) according to the 'ub_keys' array (which also gets sorted ofcourse).
         num_elements--
         ubyte @zp gap
@@ -170,7 +168,7 @@ _done
             ubyte i
             for i in gap to num_elements {
                 ubyte @zp temp = ub_keys[i]
-                uword temp_wv = peekw(wordvalues + i*$0002)
+                uword temp_wv = wordvalues[i]
                 ubyte @zp j = i
                 ubyte @zp k = j-gap
                 repeat {
@@ -178,18 +176,17 @@ _done
                     if v <= temp break
                     if j < gap break
                     ub_keys[j] = v
-                    pokew(wordvalues + j*$0002, peekw(wordvalues + k*$0002))
+                    wordvalues[j] = wordvalues[k]
                     j = k
                     k -= gap
                 }
                 ub_keys[j] = temp
-                pokew(wordvalues + j*$0002, temp_wv)
+                wordvalues[j] = temp_wv
             }
         }
     }
 
-    ; TODO convert to ^^uword once code size regression is fixed
-    sub shellsort_by_uw(uword @requirezp uw_keys, uword @requirezp wordvalues, ubyte num_elements) {
+    sub shellsort_by_uw(^^uword @requirezp uw_keys, ^^uword @requirezp wordvalues, ubyte num_elements) {
         ; sorts the 'wordvalues' array according to the 'uw_keys' array (which also gets sorted ofcourse).
         ; both arrays should be no-split array of words. uw_keys are unsigned.
         num_elements--
@@ -197,20 +194,20 @@ _done
         for gap in [132, 57, 23, 10, 4, 1] {
             ubyte i
             for i in gap to num_elements {
-                uword @zp temp = peekw(uw_keys+i*$0002)
-                uword temp_wv = peekw(wordvalues + i*$0002)
+                uword @zp temp = uw_keys[i]
+                uword temp_wv = wordvalues[i]
                 ubyte @zp j = i
                 ubyte @zp k = j-gap
                 while j>=gap {
-                    uword @zp v = peekw(uw_keys+k*2)
+                    uword @zp v = uw_keys[k]
                     if v <= temp break
-                    pokew(uw_keys+j*2, v)
-                    pokew(wordvalues + j*$0002, peekw(wordvalues + k*$0002))
+                    uw_keys[j] = v
+                    wordvalues[j] = wordvalues[k]
                     j = k
                     k -= gap
                 }
-                pokew(uw_keys+j*2, temp)
-                pokew(wordvalues + j*$0002, temp_wv)
+                uw_keys[j] = temp
+                wordvalues[j] = temp_wv
             }
         }
     }

compiler/res/prog8lib/strings.p8

@@ -213,8 +213,6 @@ _found      tya
     asmsub copy(str source @R0, str target @AY) clobbers(A) -> ubyte @Y {
         ; Copy a string to another, overwriting that one.
         ; Returns the length of the string that was copied.
-        ; Often you don’t have to call this explicitly and can just write string1 = string2
-        ; but this function is useful if you’re dealing with addresses for instance.
         %asm {{
 		sta  P8ZP_SCRATCH_W1
 		sty  P8ZP_SCRATCH_W1+1
@@ -224,6 +222,18 @@ _found      tya
         }}
     }
 
+    asmsub ncopy(str source @R0, str target @AY, ubyte maxlength @X) clobbers(A, X) -> ubyte @Y {
+        ; Copy a string to another, overwriting that one.
+        ; Returns the length of the string that was copied.
+        %asm {{
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		lda  cx16.r0
+		ldy  cx16.r0+1
+		jmp  prog8_lib.strncpy
+        }}
+    }
+
     asmsub append(str target @R0, str suffix @R1) clobbers(Y) -> ubyte @A {
         ; Append the suffix string to the target. (make sure the buffer is large enough!)
         ; Returns the length of the resulting string.
@@ -249,6 +259,41 @@ _found      tya
         }}
     }
 
+    asmsub nappend(str target @R0, str suffix @R1, ubyte maxlength @X) clobbers(Y) -> ubyte @A {
+        ; Append the suffix string to the target. (make sure the buffer is large enough!)
+        ; Returns the length of the resulting string.
+        %asm {{
+            lda  cx16.r0
+            ldy  cx16.r0+1
+            jsr  length
+            sty  P8ZP_SCRATCH_B1
+            cpx  P8ZP_SCRATCH_B1
+            beq  _max_too_small
+            bmi  _max_too_small
+            txa
+            sec
+            sbc  P8ZP_SCRATCH_B1
+            sta  P8ZP_SCRATCH_B1
+            tya
+            clc
+            adc  cx16.r0
+            sta  P8ZP_SCRATCH_W1
+            lda  cx16.r0+1
+            adc  #0
+            sta  P8ZP_SCRATCH_W1+1
+            lda  cx16.r1
+            ldy  cx16.r1+1
+            ldx  P8ZP_SCRATCH_B1
+            jsr  prog8_lib.strncpy
+            tya
+            clc
+            adc  P8ZP_SCRATCH_B1
+            rts
+_max_too_small
+            rts
+        }}
+    }
+
     asmsub compare(str string1 @R0, str string2 @AY) clobbers(Y) -> byte @A {
         ; Compares two strings for sorting.
         ; Returns -1 (255), 0 or 1, meaning: string1 sorts before, equal or after string2.

compiler/res/prog8lib/virtual/bcd.p8

@@ -0,0 +1,3 @@
+bcd {
+    ; virtual machine does not support BCD
+}

compiler/res/prog8lib/virtual/conv.p8

@@ -102,7 +102,7 @@ sub  str_uwbin  (uword value) -> str {
 }
 
 sub  str_uwhex  (uword value) -> str {
-    ; ---- convert the uword in A/Y in hexadecimal string form (4 digits)
+    ; ---- convert the uword in hexadecimal string form (4 digits)
     ubyte bits = msb(value)
     string_out[0] = hex_digits[bits>>4]
     string_out[1] = hex_digits[bits&15]
@@ -113,6 +113,26 @@ sub  str_uwhex  (uword value) -> str {
     return string_out
 }
 
+sub  str_ulhex  (long value) -> str {
+    ; ---- convert the long in hexadecimal string form (8 digits)
+    uword upperw = msw(value)
+    uword lowerw = lsw(value)
+    ubyte bits = msb(upperw)
+    string_out[0] = hex_digits[bits>>4]
+    string_out[1] = hex_digits[bits&15]
+    bits = lsb(upperw)
+    string_out[2] = hex_digits[bits>>4]
+    string_out[3] = hex_digits[bits&15]
+    bits = msb(lowerw)
+    string_out[4] = hex_digits[bits>>4]
+    string_out[5] = hex_digits[bits&15]
+    bits = lsb(lowerw)
+    string_out[6] = hex_digits[bits>>4]
+    string_out[7] = hex_digits[bits&15]
+    string_out[8] = 0
+    return string_out
+}
+
 sub  str_uw0  (uword value) -> str {
     ; ---- convert the uword in A/Y in decimal string form, with left padding 0s (5 positions total)
     uword value2 = value/10
@@ -141,7 +161,7 @@ sub  str_uw  (uword value) -> str {
 }
 
 sub  str_w  (word value) -> str {
-    ; ---- convert the (signed) word in A/Y in decimal string form, without left padding 0's
+    ; ---- convert the (signed) word into decimal string form, without left padding 0's
     ^^ubyte out_ptr = &string_out
     if value<0 {
         @(out_ptr) = '-'
@@ -152,6 +172,16 @@ sub  str_w  (word value) -> str {
     return string_out
 }
 
+sub  str_l  (long value) -> str {
+    ; ---- convert the (signed) long into decimal string form, without left padding 0's
+    %ir {{
+        loadm.l r99200,conv.str_l.value
+        load.w r99000,conv.string_out
+        syscall 60 (r99200.l, r99000.w) : r99000.w
+        returnr.w r99000
+    }}
+}
+
 sub internal_str_uw(uword value, str out_ptr) {
     uword value2 = value/10
     ubyte digits = value-value2*10 as ubyte
@@ -249,6 +279,26 @@ sub  hex2uword(str string) -> uword {
     }
 }
 
+sub  hex2long(str string) -> long {
+    ; -- hexadecimal string (with or without '$') to long.
+    ;    stops parsing at the first character that's not a hex digit (except leading $)
+    long result
+    ubyte char
+    if @(string)=='$'
+        string++
+    repeat {
+        char = @(string)
+        if char==0
+            return result
+        result <<= 4
+        if char>='0' and char<='9'
+            result |= char-'0'
+        else
+            result |= char-'a'+10
+        string++
+    }
+}
+
 sub  bin2uword(str string) -> uword {
     ; -- binary string (with or without '%') to uword.
     ;    stops parsing at the first character that's not a 0 or 1. (except leading %)
@@ -267,12 +317,15 @@ sub  bin2uword(str string) -> uword {
     }
 }
 
-sub  any2uword(str string) -> uword {
+sub  any2uword(str string) -> uword, ubyte {
     ; -- convert any number string (any prefix allowed) to uword.
+    ;    returns the parsed word value, and the number of processed characters (including the prefix symbol)
+    ubyte length
+    while string[length]!=0 length++
     when string[0] {
-        '$' -> return hex2uword(string)
-        '%' -> return bin2uword(string)
-        else -> return str2uword(string)
+        '$' -> return hex2uword(string), length
+        '%' -> return bin2uword(string), length
+        else -> return str2uword(string), length
     }
 }
 

compiler/res/prog8lib/virtual/diskio.p8

@@ -206,7 +206,7 @@ diskio {
 
     sub save(str filenameptr, uword start_address, uword savesize) -> bool {
         %ir {{
-            load.b r99100,0
+            load.b r99100,#0
             loadm.w r99000,diskio.save.filenameptr
             loadm.w r99001,diskio.save.start_address
             loadm.w r99002,diskio.save.savesize
@@ -218,7 +218,7 @@ diskio {
     ; like save() but omits the 2 byte prg header.
     sub save_raw(str filenameptr, uword start_address, uword savesize) -> bool {
         %ir {{
-            load.b r99100,1
+            load.b r99100,#1
             loadm.w r99000,diskio.save_raw.filenameptr
             loadm.w r99001,diskio.save_raw.start_address
             loadm.w r99002,diskio.save_raw.savesize
@@ -284,7 +284,7 @@ diskio {
         ; get the load adress from a PRG file (usually $0801 but it can be different)
         if f_open(filename) {
             uword address
-            f_read(&address, 2)
+            void f_read(&address, 2)
             f_close()
             return address
         }

compiler/res/prog8lib/virtual/math.p8

@@ -304,6 +304,12 @@ math {
         }}
     }
 
+    sub mul32(uword a, uword b) -> long {
+        ; return 32 bits result of a*b
+        cx16.r2 = a*b
+        return mklong2(mul16_last_upper(), cx16.r2)
+    }
+
     sub diff(ubyte b1, ubyte b2) -> ubyte {
         if b1>b2
             return b1-b2
@@ -353,10 +359,9 @@ math {
         return cx16.r15
     }
 
-    sub crc32(^^ubyte data, uword length) {
+    sub crc32(^^ubyte data, uword length) -> long {
         ; Calculates the CRC-32 (ISO-HDLC/PKZIP) checksum of the buffer.
-        ; because prog8 doesn't have 32 bits integers, we have to split up the calculation over 2 words.
-        ; result stored in cx16.r14 (low word) and cx16.r15 (high word)
+        ; Clobbers R12 through R15, returns the result in R0:R1
         ; There are also "streaming" crc32_start/update/end routines below, that allow you to calculate crc32 for data that doesn't fit in a single memory block.
         crc32_start()
         cx16.r12 = data
@@ -365,7 +370,7 @@ math {
             crc32_update(@(cx16.r12))
             cx16.r12++
         }
-        crc32_end()
+        return crc32_end()
     }
 
     sub crc32_start() {
@@ -391,11 +396,11 @@ math {
         }
     }
 
-    sub crc32_end() {
-        ; finalize the "streaming" crc32
-        ; result stored in cx16.r14 (low word) and cx16.r15 (high word)
+    sub crc32_end() -> long {
+        ; finalize the "streaming" crc32 and return the result in R0:R1
         cx16.r15 ^= $ffff
         cx16.r14 ^= $ffff
+        return mklong2(cx16.r15, cx16.r14)
     }
 
     ; there's no crc32_end_result() here because IR cannot return multiple values yet

compiler/res/prog8lib/virtual/monogfx.p8

@@ -302,23 +302,11 @@ monogfx {
             return
         ubyte @zp yy = 0
         word @zp decisionOver2 = (1 as word)-radius
-        uword last_y3 = ycenter+radius
-        uword last_y4 = ycenter-radius
-        uword new_y3, new_y4
-
         while radius>=yy {
             horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, draw)
             horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, draw)
-            new_y3 = ycenter+radius
-            if new_y3 != last_y3 {
-                horizontal_line(xcenter-yy, last_y3, yy*$0002+1, draw)
-                last_y3 = new_y3
-            }
-            new_y4 = ycenter-radius
-            if new_y4 != last_y4 {
-                horizontal_line(xcenter-yy, last_y4, yy*$0002+1, draw)
-                last_y4 = new_y4
-            }
+            horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, draw)
+            horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, draw)
             yy++
             if decisionOver2>=0 {
                 radius--
@@ -327,10 +315,6 @@ monogfx {
             decisionOver2 += yy*$0002
             decisionOver2++
         }
-        ; draw the final two spans
-        yy--
-        horizontal_line(xcenter-yy, last_y3, yy*$0002+1, draw)
-        horizontal_line(xcenter-yy, last_y4, yy*$0002+1, draw)
     }
 
     sub safe_disc(uword @zp xcenter, uword @zp ycenter, ubyte @zp radius, bool draw) {
@@ -340,23 +324,11 @@ monogfx {
             return
         ubyte @zp yy = 0
         word @zp decisionOver2 = (1 as word)-radius
-        uword last_y3 = ycenter+radius
-        uword last_y4 = ycenter-radius
-        uword new_y3, new_y4
-
         while radius>=yy {
             safe_horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, draw)
             safe_horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, draw)
-            new_y3 = ycenter+radius
-            if new_y3 != last_y3 {
-                safe_horizontal_line(xcenter-yy, last_y3, yy*$0002+1, draw)
-                last_y3 = new_y3
-            }
-            new_y4 = ycenter-radius
-            if new_y4 != last_y4 {
-                safe_horizontal_line(xcenter-yy, last_y4, yy*$0002+1, draw)
-                last_y4 = new_y4
-            }
+            safe_horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, draw)
+            safe_horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, draw)
             yy++
             if decisionOver2>=0 {
                 radius--
@@ -365,10 +337,6 @@ monogfx {
             decisionOver2 += yy*$0002
             decisionOver2++
         }
-        ; draw the final two spans
-        yy--
-        safe_horizontal_line(xcenter-yy, last_y3, yy*$0002+1, draw)
-        safe_horizontal_line(xcenter-yy, last_y4, yy*$0002+1, draw)
     }
 
     sub plot(uword @zp xx, uword @zp yy, bool @zp draw) {

compiler/res/prog8lib/virtual/strings.p8

@@ -106,12 +106,23 @@ strings {
     sub copy(str source, str target) -> ubyte {
         ; Copy a string to another, overwriting that one.
         ; Returns the length of the string that was copied.
-        ; Often you don’t have to call this explicitly and can just write string1 = string2
-        ; but this function is useful if you’re dealing with addresses for instance.
         %ir {{
             loadm.w r99000,strings.copy.source
             loadm.w r99001,strings.copy.target
-            syscall 39 (r99000.w, r99001.w): r99100.b
+            load.b r99100,#255
+            syscall 39 (r99000.w, r99001.w, r99100.b): r99100.b
+            returnr.b r99100
+        }}
+    }
+
+    sub ncopy(str source, str target, ubyte maxlength) -> ubyte {
+        ; Copy a string to another, overwriting that one, but limited to the given length.
+        ; Returns the length of the string that was copied.
+        %ir {{
+            loadm.w r99000,strings.ncopy.source
+            loadm.w r99001,strings.ncopy.target
+            loadm.b r99100,strings.ncopy.maxlength
+            syscall 39 (r99000.w, r99001.w, r99100.b): r99100.b
             returnr.b r99100
         }}
     }
@@ -123,6 +134,16 @@ strings {
         return copy(suffix, target+cx16.r0L) + cx16.r0L
     }
 
+    sub nappend(str target, str suffix, ubyte maxlength) -> ubyte {
+        ; Append the suffix string to the target, up to the given maximum length of the combined string.
+        ; Returns the length of the resulting string.
+        cx16.r0L = length(target)
+        if maxlength<cx16.r0L
+            return cx16.r0L
+        maxlength -= cx16.r0L
+        return ncopy(suffix, target+cx16.r0L, maxlength) + cx16.r0L
+    }
+
     sub compare(str st1, str st2) -> byte {
         ; Compares two strings for sorting.
         ; Returns -1 (255), 0 or 1, meaning: string1 sorts before, equal or after string2.

compiler/res/prog8lib/virtual/syslib.p8

@@ -53,7 +53,8 @@ sys {
         %ir {{
             loadm.w r99000,sys.internal_stringcopy.source
             loadm.w r99001,sys.internal_stringcopy.tgt
-            syscall 39 (r99000.w, r99001.w): r99100.b
+            load.b r99100,#255
+            syscall 39 (r99000.w, r99001.w, r99100.b): r99100.b
         }}
     }
 
@@ -192,6 +193,14 @@ sys {
         }}
     }
 
+    sub pushl(long l) {
+        ; note: this *should* be inlined, however since the VM has separate program counter and value stacks, this also works
+        %ir {{
+            loadm.l r99200,sys.pushl.l
+            push.l r99200
+        }}
+    }
+
     sub push_returnaddress(uword w) {
         ; note: this actually doesn't do anything useful on the VM because the code execution doesn't use the simulated cpu stack
         %ir {{
@@ -222,6 +231,14 @@ sys {
         }}
     }
 
+    sub popl() -> long {
+        ; note: this *should* be inlined, however since the VM has separate program counter and value stacks, this also works
+        %ir {{
+            pop.l r99200
+            returnr.l r99200
+        }}
+    }
+
     sub read_flags() -> ubyte {
         ; "simulate" the 6502 status register a little bit
         if_neg {
@@ -244,6 +261,11 @@ sys {
 
         return cx16.r0L
     }
+
+    sub cpu_is_65816() -> bool {
+        ; Returns true when you have a 65816 cpu, false when it's a 6502.
+        return false
+    }
 }
 
 cx16 {
@@ -285,6 +307,16 @@ cx16 {
     &word r14s = $ff1e
     &word r15s = $ff20
 
+    ; signed long versions
+    &long r0r1sl  = $ff02
+    &long r2r3sl  = $ff06
+    &long r4r5sl  = $ff0a
+    &long r6r7sl  = $ff0e
+    &long r8r9sl  = $ff12
+    &long r10r11sl = $ff16
+    &long r12r13sl = $ff1a
+    &long r14r15sl = $ff1e
+
     ; ubyte versions (low and high bytes)
     &ubyte r0L  = $ff02
     &ubyte r1L  = $ff04

compiler/res/prog8lib/virtual/textio.p8

@@ -8,7 +8,7 @@ txt {
 sub width() -> ubyte {
     %ir {{
         syscall 46 (): r99000.w
-        lsig.b r99100,r99000
+        lsigb.w r99100,r99000
         returnr.b r99100
     }}
 }
@@ -16,11 +16,16 @@ sub width() -> ubyte {
 sub height() -> ubyte {
     %ir {{
         syscall 46 (): r99000.w
-        msig.b r99100,r99000
+        msigb.w r99100,r99000
         returnr.b r99100
     }}
 }
 
+sub size() -> ubyte, ubyte {
+    ; -- returns the text screen width and height (number of columns and rows)
+    return width(), height()
+}
+
 sub  clear_screen() {
     str @shared sequence = "\x1b[2J\x1B[H"
     %ir {{
@@ -136,6 +141,13 @@ sub  print_uwhex  (uword value, bool prefix) {
     print(conv.str_uwhex(value))
 }
 
+sub  print_ulhex  (long value, bool prefix) {
+    ; ---- print the ulong in hexadecimal form (4 digits)
+    if prefix
+        chrout('$')
+    print(conv.str_ulhex(value))
+}
+
 sub  print_uw0  (uword value)  {
     ; ---- print the uword value in decimal form, with left padding 0s (5 positions total)
     print(conv.str_uw0(value))
@@ -151,12 +163,20 @@ sub  print_w  (word value) {
     print(conv.str_w(value))
 }
 
+sub  print_l  (long value) {
+    ; ---- print the (signed) long in decimal form, without left padding 0's
+    %ir {{
+        loadm.l r99200,txt.print_l.value
+        syscall 59 (r99200.l)
+    }}
+}
+
 sub  input_chars  (str buffer) -> ubyte  {
     ; ---- Input a string (max. 80 chars) from the keyboard. Returns length of input. (string is terminated with a 0 byte as well)
     ;      It assumes the keyboard is selected as I/O channel!
     %ir {{
         loadm.w r99000,txt.input_chars.buffer
-        load.b r99100,80
+        load.b r99100,#80
         syscall 6 (r99000.w, r99100.b): r99100.b
         returnr.b r99100
     }}

compiler/src/prog8/CompilerMain.kt

@@ -2,6 +2,7 @@ package prog8
 
 import kotlinx.cli.*
 import prog8.ast.AstException
+import prog8.buildversion.VERSION
 import prog8.code.source.ImportFileSystem.expandTilde
 import prog8.code.target.CompilationTargets
 import prog8.code.target.Cx16Target
@@ -12,13 +13,10 @@ import prog8.compiler.CompilerArguments
 import prog8.compiler.ErrorReporter
 import prog8.compiler.compileProgram
 import java.io.File
-import java.nio.file.FileSystems
-import java.nio.file.Path
-import java.nio.file.StandardWatchEventKinds
-import java.nio.file.WatchKey
+import java.net.URI
+import java.nio.file.*
 import java.time.LocalDateTime
-import kotlin.io.path.Path
-import kotlin.io.path.isReadable
+import kotlin.io.path.*
 import kotlin.system.exitProcess
 
 
@@ -46,6 +44,8 @@ private fun compileMain(args: Array<String>): Boolean {
     val symbolDefs by cli.option(ArgType.String, fullName = "D", description = "define assembly symbol(s) with -D SYMBOL=VALUE").multiple()
     val dumpSymbols by cli.option(ArgType.Boolean, fullName = "dumpsymbols", description = "print a dump of the variable declarations and subroutine signatures")
     val dumpVariables by cli.option(ArgType.Boolean, fullName = "dumpvars", description = "print a dump of the variables in the program")
+    val libSearch by cli.option(ArgType.String, fullName = "libsearch", description = "search for a regex pattern in the embedded library files")
+    val libDump by cli.option(ArgType.String, fullName = "libdump", description = "dump all the embedded library files into the specified output directory")
     val startEmulator1 by cli.option(ArgType.Boolean, fullName = "emu", description = "auto-start emulator after successful compilation")
     val startEmulator2 by cli.option(ArgType.Boolean, fullName = "emu2", description = "auto-start alternative emulator after successful compilation")
     val experimentalCodegen by cli.option(ArgType.Boolean, fullName = "expericodegen", description = "use experimental/alternative codegen")
@@ -60,14 +60,13 @@ private fun compileMain(args: Array<String>): Boolean {
     val quietAll by cli.option(ArgType.Boolean, fullName = "quiet", description = "don't print compiler and assembler messages, except warnings and errors")
     val quietAssembler by cli.option(ArgType.Boolean, fullName = "quietasm", description = "don't print assembler messages")
     val slabsGolden by cli.option(ArgType.Boolean, fullName = "slabsgolden", description = "put memory() slabs in 'golden ram' memory area instead of at the end of the program. On the cx16 target this is $0400-07ff. This is unavailable on other systems.")
-    val slabsHighBank by cli.option(ArgType.Int, fullName = "slabshigh", description = "put memory() slabs in high memory area instead of at the end of the program. On the cx16 target the value specifies the HiRAM bank to use, on other systems this value is ignored.")
+    val slabsHighBank by cli.option(ArgType.Int, fullName = "slabshigh", description = "put memory() slabs in high memory area instead of at the end of the program. On the cx16 target the value specifies the HIRAM bank to use, on other systems this value is ignored.")
     val dontIncludeSourcelines by cli.option(ArgType.Boolean, fullName = "nosourcelines", description = "do not include original Prog8 source lines in generated asm code")
-    val dontSplitWordArrays by cli.option(ArgType.Boolean, fullName = "dontsplitarrays", description = "don't store any word array as split lsb/msb in memory, as if all of those have @nosplit")
     val sourceDirs by cli.option(ArgType.String, fullName="srcdirs", description = "list of extra paths, separated with ${File.pathSeparator}, to search in for imported modules").multiple().delimiter(File.pathSeparator)
     val compilationTarget by cli.option(ArgType.String, fullName = "target", description = "target output of the compiler (one of ${CompilationTargets.joinToString(",")} or a custom target properties file) (required)")
     val showTimings by cli.option(ArgType.Boolean, fullName = "timings", description = "show internal compiler timings (for performance analysis)")
     val varsGolden by cli.option(ArgType.Boolean, fullName = "varsgolden", description = "put uninitialized variables in 'golden ram' memory area instead of at the end of the program. On the cx16 target this is $0400-07ff. This is unavailable on other systems.")
-    val varsHighBank by cli.option(ArgType.Int, fullName = "varshigh", description = "put uninitialized variables in high memory area instead of at the end of the program. On the cx16 target the value specifies the HiRAM bank to use, on other systems this value is ignored.")
+    val varsHighBank by cli.option(ArgType.Int, fullName = "varshigh", description = "put uninitialized variables in high memory area instead of at the end of the program. On the cx16 target the value specifies the HIRAM bank to use, on other systems this value is ignored.")
     val startVm by cli.option(ArgType.Boolean, fullName = "vm", description = "run a .p8ir IR source file in the embedded VM")
     val warnSymbolShadowing by cli.option(ArgType.Boolean, fullName = "warnshadow", description="show assembler warnings about symbol shadowing")
     val watchMode by cli.option(ArgType.Boolean, fullName = "watch", description = "continuous compilation mode (watch for file changes)")
@@ -90,6 +89,16 @@ private fun compileMain(args: Array<String>): Boolean {
     if(quietAll!=true)
         banner()
 
+    if(libDump!=null) {
+        scanLibraryFiles(libDump, null)
+        return true
+    }
+
+    if(libSearch!=null) {
+        scanLibraryFiles(null, libSearch)
+        return true
+    }
+
     val outputPath = pathFrom(outputDir)
     if(!outputPath.toFile().isDirectory) {
         System.err.println("Output path doesn't exist")
@@ -136,7 +145,7 @@ private fun compileMain(args: Array<String>): Boolean {
     }
 
     if(varsHighBank==0 && compilationTarget==Cx16Target.NAME) {
-        System.err.println("On the Commander X16, HiRAM bank 0 is used by the kernal and can't be used.")
+        System.err.println("On the Commander X16, HIRAM bank 0 is used by the kernal and can't be used.")
         return false
     }
 
@@ -193,7 +202,6 @@ private fun compileMain(args: Array<String>): Boolean {
                     slabsHighBank,
                     slabsGolden == true,
                     compilationTarget!!,
-                    dontSplitWordArrays == true,
                     breakpointCpuInstruction,
                     printAst1 == true,
                     printAst2 == true,
@@ -278,7 +286,6 @@ private fun compileMain(args: Array<String>): Boolean {
                     slabsHighBank,
                     slabsGolden == true,
                     compilationTarget!!,
-                    dontSplitWordArrays == true,
                     breakpointCpuInstruction,
                     printAst1 == true,
                     printAst2 == true,
@@ -363,3 +370,62 @@ fun runVm(irFilename: String, quiet: Boolean) {
     val vmdef = VMTarget()
     vmdef.launchEmulator(0, irFile, quiet)
 }
+
+
+
+private fun scanLibraryFiles(dump: String?, searchPattern: String?) {
+    val library_prefix = "/prog8lib"
+
+    val dumpPath = if(dump!=null) pathFrom(dump) else null
+    val pattern = searchPattern?.toRegex(RegexOption.IGNORE_CASE)
+    if(pattern!=null) {
+        println("You can also have a look in the documentation for the libraries at https://prog8.readthedocs.io/en/latest/libraries.html")
+        println("The library source files are available in the Github repository at https://github.com/irmen/prog8/tree/master/compiler/res/prog8lib")
+        println("Searching for pattern '$pattern' in embedded library files.\n")
+    }
+    if(dumpPath!=null) {
+        println("Dumping embedded library files into $dumpPath\n")
+        dumpPath.createDirectories()
+        val license = dumpPath / "${library_prefix.drop(1)}-$VERSION/LICENSE.txt"
+        license.parent.createDirectories()
+        license.writeText("These library files belong to the Prog8 compiler project, see https://github.com/irmen/prog8/\n" +
+        "They are licensed under the GNU GPL 3.0 software license, see https://www.gnu.org/licenses/gpl.html\n")
+    }
+
+    fun search(path: Path) {
+        val hits = mutableListOf<String>()
+        path.useLines { lines ->
+            lines.forEachIndexed { index, line ->
+                if (pattern!!.containsMatchIn(line)) {
+                    hits.add("${(index + 1).toString().padStart(6)}:  ${line.trimStart()}")
+                }
+            }
+        }
+        if(hits.isNotEmpty()) {
+            println("Found in Library file '${path.absolutePathString().drop(library_prefix.length+1)}':")
+            hits.forEach(::println)
+            println()
+        }
+    }
+
+    fun dump(path: Path) {
+        val targetfolder = dumpPath!! / (path.first().pathString + "-$VERSION")
+        val target = targetfolder / path.pathString.drop(library_prefix.length+1)
+        target.parent.createDirectories()
+        target.writeBytes(path.readBytes())
+    }
+
+    // Get the location of the current JAR
+    val jarUrl = object {}.javaClass.protectionDomain.codeSource.location
+    FileSystems.newFileSystem(URI.create("jar:$jarUrl"), emptyMap<String, String>()).use { fs ->
+        val dir = fs.getPath(library_prefix)
+        Files.walk(dir).use { paths ->
+            paths.filter { Files.isRegularFile(it) }.forEach { path ->
+                if(pattern!=null)
+                    search(path)
+                else
+                    dump(path)
+            }
+        }
+    }
+}

compiler/src/prog8/compiler/BuiltinFunctions.kt

@@ -20,12 +20,28 @@ internal val constEvaluatorsForBuiltinFuncs: Map<String, ConstExpressionCaller>
     "sgn" to ::builtinSgn,
     "sqrt__ubyte" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, false) { sqrt(it.toDouble()) } },
     "sqrt__uword" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, false) { sqrt(it.toDouble()) } },
-    "sqrt__float" to { a, p, prg -> oneFloatArgOutputFloat(a, p, prg) { sqrt(it) } },
+    "sqrt__long" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, false) {
+        val value=it.toDouble()
+        if(value<0)
+            throw CannotEvaluateException("sqrt", "argument cannot be negative")
+        else
+            sqrt(value)
+    } },
+    "sqrt__float" to { a, p, prg -> oneFloatArgOutputFloat(a, p, prg) {
+        if(it<0)
+            throw CannotEvaluateException("sqrt", "argument cannot be negative")
+        else
+            sqrt(it)
+    } },
     "lsb" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, true) { x: Int -> (x and 255).toDouble() } },
+    "lsb__long" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, true) { x: Int -> (x and 255).toDouble() } },
     "lsw" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, true) { x: Int -> (x and 65535).toDouble() } },
     "msb" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, true) { x: Int -> (x ushr 8 and 255).toDouble()} },
+    "msb__long" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, true) { x: Int -> (x ushr 24 and 255).toDouble()} },
     "msw" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, true) { x: Int -> (x ushr 16 and 65535).toDouble()} },
     "mkword" to ::builtinMkword,
+    "mklong" to ::builtinMklong,
+    "mklong2" to ::builtinMklong,
     "clamp__ubyte" to ::builtinClampUByte,
     "clamp__byte" to ::builtinClampByte,
     "clamp__uword" to ::builtinClampUWord,
@@ -34,10 +50,12 @@ internal val constEvaluatorsForBuiltinFuncs: Map<String, ConstExpressionCaller>
     "min__byte" to ::builtinMinByte,
     "min__uword" to ::builtinMinUWord,
     "min__word" to ::builtinMinWord,
+    "min__long" to ::builtinMinLong,
     "max__ubyte" to ::builtinMaxUByte,
     "max__byte" to ::builtinMaxByte,
     "max__uword" to ::builtinMaxUWord,
-    "max__word" to ::builtinMaxWord
+    "max__word" to ::builtinMaxWord,
+    "max__long" to ::builtinMaxLong
 )
 
 internal fun builtinFunctionReturnType(function: String): InferredTypes.InferredType {
@@ -65,11 +83,14 @@ private fun oneIntArgOutputInt(args: List<Expression>, position: Position, progr
         if(!constval.type.isInteger)
             throw SyntaxError("built-in function requires one integer argument", position)
     } else {
-        if(constval.type!=BaseDataType.UBYTE && constval.type!=BaseDataType.UWORD)
+        if(!constval.type.isInteger)
             throw SyntaxError("built-in function requires one integer argument", position)
     }
     val integer = constval.number.toInt()
-    return NumericLiteral.optimalInteger(function(integer).toInt(), args[0].position)
+    val result = function(integer)
+    if(result.isNaN())
+        throw CannotEvaluateException("built-in function", "result is NaN $position")
+    return NumericLiteral.optimalInteger(result.toInt(), args[0].position)
 }
 
 private fun oneFloatArgOutputFloat(args: List<Expression>, position: Position, program: Program, function: (arg: Double)->Double): NumericLiteral {
@@ -78,8 +99,10 @@ private fun oneFloatArgOutputFloat(args: List<Expression>, position: Position, p
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     if(constval.type != BaseDataType.FLOAT)
         throw SyntaxError("built-in function requires one float argument", position)
-
-    return NumericLiteral(BaseDataType.FLOAT, function(constval.number), args[0].position)
+    val result = function(constval.number)
+    if(result.isNaN())
+        throw CannotEvaluateException("built-in function", "result is NaN $position")
+    return NumericLiteral(BaseDataType.FLOAT, result, args[0].position)
 }
 
 private fun builtinAbs(args: List<Expression>, position: Position, program: Program): NumericLiteral {
@@ -132,7 +155,14 @@ private fun builtinSizeof(args: List<Expression>, position: Position, program: P
                 val elementDt = dt.getOrUndef().elementType()
                 NumericLiteral.optimalInteger(program.memsizer.memorySize(elementDt, length), position)
             }
-            dt.isString -> throw SyntaxError("sizeof(str) is undefined, did you mean len, or perhaps strings.length?", position)
+            dt.isString -> {
+                if(target is VarDecl) {
+                    val length = (target.value as StringLiteral).value.length + 1       // add the closing 0-byte
+                    NumericLiteral(BaseDataType.UBYTE, length.toDouble(), position)
+                }
+                else
+                    throw SyntaxError("sizeof(str) is undefined here. Perhaps use len, or strings.length?", position)
+            }
             else -> NumericLiteral.optimalInteger( program.memsizer.memorySize(dt.getOrUndef(), null), position)
         }
     } else {
@@ -203,6 +233,29 @@ private fun builtinMkword(args: List<Expression>, position: Position, program: P
     return NumericLiteral(BaseDataType.UWORD, result.toDouble(), position)
 }
 
+private fun builtinMklong(args: List<Expression>, position: Position, program: Program): NumericLiteral {
+    when(args.size) {
+        2 -> {
+            val constMsw = args[0].constValue(program) ?: throw NotConstArgumentException()
+            val constLsw = args[1].constValue(program) ?: throw NotConstArgumentException()
+            val result = (constMsw.number.toInt() shl 16) or constLsw.number.toInt()
+            return NumericLiteral(BaseDataType.LONG, result.toDouble(), position)
+        }
+        4 -> {
+            val constMsb = args[0].constValue(program) ?: throw NotConstArgumentException()
+            val constB2 = args[1].constValue(program) ?: throw NotConstArgumentException()
+            val constB1 = args[2].constValue(program) ?: throw NotConstArgumentException()
+            val constLsb = args[3].constValue(program) ?: throw NotConstArgumentException()
+            val result = (constMsb.number.toInt() shl 24) or
+                    (constB2.number.toInt() shl 16) or
+                    (constB1.number.toInt() shl 8) or
+                    constLsb.number.toInt()
+            return NumericLiteral(BaseDataType.LONG, result.toDouble(), position)
+        }
+        else -> throw SyntaxError("mkword requires msw and lsw, or msb,b2,b1,lsb arguments", position)
+    }
+}
+
 private fun builtinSgn(args: List<Expression>, position: Position, program: Program): NumericLiteral {
     if (args.size != 1)
         throw SyntaxError("sgn requires one argument", position)
@@ -246,6 +299,15 @@ private fun builtinMinUWord(args: List<Expression>, position: Position, program:
     return NumericLiteral(BaseDataType.UWORD, result.toDouble(), position)
 }
 
+private fun builtinMinLong(args: List<Expression>, position: Position, program: Program): NumericLiteral {
+    if (args.size != 2)
+        throw SyntaxError("min requires 2 arguments", position)
+    val val1 = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val val2 = args[1].constValue(program) ?: throw NotConstArgumentException()
+    val result = min(val1.number.toInt(), val2.number.toInt())
+    return NumericLiteral(BaseDataType.LONG, result.toDouble(), position)
+}
+
 private fun builtinMaxByte(args: List<Expression>, position: Position, program: Program): NumericLiteral {
     if (args.size != 2)
         throw SyntaxError("max requires 2 arguments", position)
@@ -282,6 +344,15 @@ private fun builtinMaxUWord(args: List<Expression>, position: Position, program:
     return NumericLiteral(BaseDataType.UWORD, result.toDouble(), position)
 }
 
+private fun builtinMaxLong(args: List<Expression>, position: Position, program: Program): NumericLiteral {
+    if (args.size != 2)
+        throw SyntaxError("max requires 2 arguments", position)
+    val val1 = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val val2 = args[1].constValue(program) ?: throw NotConstArgumentException()
+    val result = max(val1.number.toInt(), val2.number.toInt())
+    return NumericLiteral(BaseDataType.LONG, result.toDouble(), position)
+}
+
 private fun builtinClampUByte(args: List<Expression>, position: Position, program: Program): NumericLiteral {
     if(args.size!=3)
         throw SyntaxError("clamp requires 3 arguments", position)