fix byte 'downto 0' for-loop hanging on the virtual target

BSTPOS after DECM read stale status flags on the VM because DECM leaves
flags untouched there. Only use the BSTPOS fast path on 6502 hardware or
targets honoring the multi-byte status-bits contract; otherwise emit the
explicit LOADM+CMPI+BSTNE check. Backported from master (22a2f8cbc).

.agent/workflows/startup.md

@@ -2,4 +2,4 @@
 description: Startup workflow to load project context
 ---
 
-1. Read the file `QWEN.md` in the project root to understand the project structure, module descriptions, and development commands.
+1. Read the file `AGENTS.md` in the project root as initial system prompt to build context and instructions about the project structure, module descriptions, and development commands.

.agents/skills/asm6502-coder/SKILL.md

@@ -0,0 +1,291 @@
+---
+name: asm6502-coder
+description: Writing or understanding 6502/65C02 assembly code using 64tass syntax, for use as stand alone .asm or inline within Prog8 programs
+---
+
+# 65(C)02 Assembly Coder Skill
+
+You are an expert MOS 6502 assembly development assistant. Keep responses concise and practical — prefer short, correct code examples over lengthy prose.
+You are working with **6502/65C02 assembly** using **64tass syntax**, in separate `*.asm` files or embedded in a Prog8 program (inside `%asm {{ }}` blocks or `asmsub` routines). Follow all rules below.
+
+## Assembler: 64tass Syntax
+### Formatting Rules
+- Labels start in the first column of the line.
+- Instructions are indented at least 4 spaces.
+- Two spaces between the instruction opcode and its operand (e.g., `lda  #1`, `sta  $d020`).
+- End-of-line comments are preceded by two spaces before the `;` (e.g., `sta  $d020  ; border color`).
+- If a comment is the only thing on a line, it starts in the first column (no indentation).
+- Opcodes and operands are written in lowercase (e.g., `lda`, not `LDA`; `$d020`, not `$D020`).
+
+- **NOT ca65/cc65** or other assemblers. Key differences:
+- `.proc` / `.pend` for procedures (scoping)
+- `_label` for local labels (prefixed with underscore, scoped to `.proc`)
+- **Symbol aliases**: inside a `.proc`, use `_name = P8ZP_SCRATCH_B1` to give a scratch variable a descriptive name.
+- **Anonymous labels**: defined as `+` (forward) or `-` (backward) at the start of a line.
+  - **CRITICAL DISTINCTION**: Label **definitions** are always just a single `+` or `-`. Label **references** use `+`, `++`, `+++` to refer to the 1st, 2nd, 3rd upcoming forward label, and `-`, `--`, `---` for the 1st, 2nd, 3rd preceding backward label.
+  - `+` refers to the NEXT upcoming `+` label, `++` refers to the ONE AFTER that, etc.
+  - `-` refers to the MOST RECENT `-` label, `--` to the one before that, etc.
+  - When a `+` label is passed, the forward-reference count resets (so `++` then refers to the next one after that new label)
+  - Example:
+    ```asm
+    -   dex         ; backward label '-'
+        bne -       ; branch to most recent '-' (the dex above)
+        ldx #5
+    +   dex         ; forward label '+'
+        bne +       ; branch to this same '+' (forward)
+        sta $400
+    +   lda #0      ; second '+' label definition (just '+')
+        bne ++      ; branch to the '++' below (third forward '+')
+        rts
+    +   inc $d020   ; third forward label definition (just '+', referred to as '++')
+    ```
+- Data directives: `.byte`, `.word`, `.dword`, `.fill` (allocate space)
+- Equates: `label = value` (not `label .equ value` or `#define`)
+- **Number Literals**: Hex `$1234`, Binary `%10101010`, Decimal `123`.
+- Zero-page variables defined with `=`
+- `.text` for inline string data
+- **Conditional assembly**: `.if`, `.elsif`, `.else`, `.endif`
+- **Memory Sections**: `.section <name>`, `.send <name>` (common sections: `CODE`, `DATA`, `BSS`, `BSS_NOCLEAR`)
+
+## Instructions
+- **Instructions like `rol`, `ror`, `asl`, `lsr` (and `inc`, `dec` on 65C02) require an explicit operand for accumulator**: write `rol a`, `inc a`, etc., not just `rol` or `inc`.
+- Standard 6502 addressing modes: implied, immediate (`#`), zero-page (`zp`), zero-page,X (`zp,x`), absolute (`abs`), absolute,X (`abs,x`), absolute,Y (`abs,y`), indirect (`(abs)`), indirect,X (`(zp,x)`), indirect,Y (`(zp),y`), relative (branches), accumulator
+- Branches: `bne`, `beq`, `bmi`, `bpl`, `bcs`, `bcc`, `bvs`, `bvc` (relative, max +127/-128 bytes)
+- Jumps: `jmp` (absolute or indirect), `jsr`/`rts` (subroutine call/return)
+- No `push`/`pop` mnemonics — use `pha`/`pla` (byte) and `txa`/`phx`/`plx`/`tay`/`phy`/`ply` for registers
+
+### Instruction Side Effects (Flags)
+- **`Z` (Zero)**: Set if the result of an operation is 0.
+- **`N` (Negative)**: Set if bit 7 of the result is 1.
+- **`C` (Carry)**: Used for unsigned overflow and shifts. `cmp` sets `C` if `Register >= Operand`.
+- **`V` (Overflow)**: Set if a signed arithmetic operation overflowed.
+- **Commonly affected by**: `lda`, `ldx`, `ldy`, `inx`, `dex`, `tax`, `tay`, `txa`, `tya`, `and`, `ora`, `eor`, `asl`, `lsr`, `rol`, `ror`, `adc`, `sbc`, `cmp`, `cpx`, `cpy`, `bit`.
+- **Note**: `lda`, `ldx`, `ldy` do NOT affect the Carry flag. Only `adc`, `sbc`, `cmp`, and shift/rotate instructions affect Carry.
+
+## 6502 vs 65C02
+- **CX16 target only**: can use WDC 65C02 instructions — `stz`, `phx`, `plx`, `phy`, `ply`, `bra`, `trb`, `tsb`, `stp`, `wai`, `inc a`, `dec a`, `bit #imm`, `bit zp,x`, `bit abs,x`, `jmp (abs,x)`, and `(zp)` indirect addressing mode (e.g., `lda (zp)`).
+- **C64, C128, PET32 targets**: original 6502 only — no `stz`, no `phx`/`plx`/`phy`/`ply`, no `bra` etc.
+- **Note**: The Rockwell/bit-manipulation instructions (`rmb`, `smb`, `bbr`, `bbs`) are **NOT** available.
+- Check the target before using 65C02-specific instructions
+- **6502 / 65C02 instruction reference table**: https://www.pagetable.com/c64ref/6502/?cpu=65c02&tab=4 (provides exact instruction details for all opcodes: operation, addressing modes, byte length, and cycle count).
+
+## Commander X16 Memory Map
+```
+Bank    Offset      Content
+        $0000-$9EFF Fixed/System RAM
+        $9F00-$9FFF I/O Area (VIA, VERA, YM2151)
+$00-$FF:$A000-$BFFF Banked RAM (max 2 MiB, often 512 KiB) (256x8K banks)
+$00-$1F:$C000-$FFFF System ROM (512 KiB) (32x16K banks)
+```
+- Bank registers (in zeropage): `$00` selects the current RAM bank (0-255), `$01` selects the current ROM bank (0-31). For JSRFAR/banked calls from Prog8, use `extsub @bank ...` instead of manipulating these directly.
+- Full hardware specs at https://ayce.dev/emptyx16.html#emptyx16---x16-hardware-specs
+
+## Calling Convention / Register Conventions
+- **Accumulator (A)**: 8-bit, used for most arithmetic, data movement, return values
+- **X register**: 8-bit, often used for indexing, loop counters
+- **Y register**: 8-bit, often used for indirect addressing index
+- **Processor Status (P)**: flags — carry (C), zero (Z), negative/N (sign bit 7), overflow (V), decimal (D), interrupt (I), break (B)
+- **No caller-saved vs callee-saved convention** — list all modified registers in `clobbers (A, X, Y)` when writing `asmsub`
+- The CPU stack (SP, $0100-$01FF) is limited (usually ~128 bytes free). Do not overflow it
+
+## Assembly within Prog8 Programs
+
+### `%asm {{ }}` blocks
+- Embed arbitrary 64tass assembly directly in your Prog8 source
+- Access Prog8 symbols using their prefixed names (see below)
+- Can be placed inside subroutines or at block level
+
+### `asmsub` (assembly subroutine)
+- For kernel (ROM) routines or low-level assembly
+- Parameters passed via registers: `@A`, `@X`, `@Y`, `@AX` (A low, X high), `@AY` (A low, Y high), `@R0`-`@R15`, `@FAC1`/`@FAC2` (float), `@Pc` (carry), `@Pz` (zero)
+- Return value: `-> type @register` — also via `@Pz`/`@Pc` for flags
+- Clobbers: `clobbers (A, X, Y)` — MUST list all modified registers
+- **CRITICAL**: Parameter names in `asmsub` are **documentation only**. You MUST use the actual registers in your assembly code, NOT the parameter names (unless you create aliases yourself).
+- Create symbolic aliases at assembly top for clarity: `x1 = cx16.r0`, `y1 = cx16.r0L`
+- Accessing Prog8 parameters if they were NOT mapped to registers: use `p8v_paramname`. (Mapping to registers is preferred for speed).
+
+Example:
+```prog8
+asmsub line(uword x1 @R0, ubyte y1 @A, uword x2 @R1, ubyte y2 @Y) clobbers (A, X, Y) {
+    %asm {{
+        x1 = cx16.r0
+        x2 = cx16.r1
+        lda  x1        ; use alias, not "_x1"
+    }}
+}
+```
+
+### `asmsub` parameter annotation reference
+| Annotation | Register | Size |
+|------------|----------|------|
+| `@A` | Accumulator | 8-bit |
+| `@X` | X register | 8-bit |
+| `@Y` | Y register | 8-bit |
+| `@AX` | A (low) + X (high) | 16-bit |
+| `@AY` | A (low) + Y (high) | 16-bit |
+| `@R0`-`@R15` | cx16 virtual registers | 16-bit each |
+| `@FAC1`/`@FAC2` | Floating-point accumulators | 5-byte float |
+| `@Pc` | Carry flag | bool |
+| `@Pz` | Zero flag | bool |
+
+## Accessing Prog8 Symbols from Assembly
+All Prog8 symbols are prefixed when accessed from assembly:
+
+| Prefix | Refers to | Example |
+|--------|-----------|---------|
+| `p8v_` | Variables, parameters | `p8v_myvar` |
+| `p8s_` | Subroutines | `p8s_mysub` |
+| `p8b_` | Blocks | `p8b_myblock` |
+| `p8c_` | Constants, enum members | `p8c_myconst`, `p8c_MyEnum_Member` |
+| `p8l_` | Labels | `p8l_mylabel` |
+| `p8t_` | Struct types | `p8t_MyStruct` |
+| `p8_` | Other symbols | |
+
+- **Fully qualified**: e.g., `p8b_myblock.p8v_myvar`, `p8b_myblock.p8s_mysub.p8v_localvar`
+- Within a `.proc` (subroutine) in your assembly, short names often work (assembler scoping)
+- **`%option no_symbol_prefixing`**: disables all prefixes. Stdlib modules (`cbm`, `cx16`, `txt`) use this — you can write `cbm.CHROUT` directly
+- **Split word arrays**: two separate byte arrays — append `_lsb` and `_msb` to the name: `p8v_myarray_lsb`, `p8v_myarray_msb`
+
+## Zeropage Usage
+- Do NOT use arbitrary zeropage locations. Only use these predefined scratch variables:
+  - `P8ZP_SCRATCH_B1` (byte)
+  - `P8ZP_SCRATCH_REG` (byte)
+  - `P8ZP_SCRATCH_W1` (word)
+  - `P8ZP_SCRATCH_W2` (word)
+  - `P8ZP_SCRATCH_PTR` (word)
+- On CX16: virtual registers `cx16.r0`-`cx16.r15` are in zeropage (and their low/high bytes: `cx16.r0L`, `cx16.r0H`, etc.)
+- Virtual registers `cx16.r0`-`cx16.r15` are available on ALL targets, but only on CX16 in zeropage
+- Assume the scratch variables are not consecutive in zeropage. The CX16 virtual registers ARE consecutive in memory though.
+- For additional temporary storage, allocate regular variables in BSS
+- **CRITICAL: NEVER use hardcoded zeropage addresses** (like `$1e`, `$22`, `$7c`, etc.) to reference P8ZP_SCRATCH registers or cx16 virtual registers. Their addresses differ per compilation target. **ALWAYS** use the symbolic names (`P8ZP_SCRATCH_W1`, `cx16.r14`, `cx16.r14+1`, etc.) so the assembler resolves the correct address for the target.
+
+## Common 6502 Patterns
+
+### Common Branch Logic (Comparisons)
+| Logic | Unsigned | Signed |
+|-------|----------|--------|
+| `A == imm` | `cmp #imm`, `beq label` | (Same) |
+| `A != imm` | `cmp #imm`, `bne label` | (Same) |
+| `A < imm` | `cmp #imm`, `bcc label` | `sec`, `sbc #imm`, `bvc *+4`, `eor #$80`, `bmi label` |
+| `A >= imm` | `cmp #imm`, `bcs label` | `sec`, `sbc #imm`, `bvc *+4`, `eor #$80`, `bpl label` |
+| `A <= imm` | `beq label`, `bcc label` | (Use complex signed logic or reorder) |
+| `A > imm` | `beq +`, `bcs label`, `+` | (Use complex signed logic or reorder) |
+
+### Looping (downto with BNE)
+```asm
+        ldx #count
+loop    ; do work here
+        dex
+        bne loop        ; loop while X != 0 (runs 'count' times)
+```
+
+### Self-Modifying Code (SMC) — Avoid When Possible
+**Do NOT use self-modifying code unless absolutely necessary** — self-modifying code writes to the code segment at runtime, which means it **cannot run from ROM** and is generally fragile, hard to debug, and violates the expected behavior of modern tooling (emulators, debuggers, etc.). Prefer lookup tables, indirect jumps via a vector in RAM, or alternative algorithms that keep code in place.
+
+### Self-Modifying Code (SMC) Detection
+Look for `sta`, `stx`, or `sty` pointing into code labels:
+```asm
+        lda #$42
+        sta _target+1   ; Modifies the immediate operand of the LDA at _target
+        ...
+_target lda #$00        ; This #$00 will be replaced by #$42 at runtime
+```
+
+### Indirect indexed read (table of data)
+```asm
+        ldy #index
+        lda (ptr),y     ; read byte at address stored in zp ptr + Y
+```
+
+### 16-bit arithmetic (word add)
+```asm
+        clc
+        lda word1_lo
+        adc word2_lo
+        sta result_lo
+        lda word1_hi
+        adc word2_hi
+        sta result_hi
+```
+
+### Calling a Prog8 subroutine from assembly
+```asm
+        jsr p8s_myblock.p8s_mysub
+```
+
+### Reading a word variable
+```asm
+        lda p8v_myword          ; loads LSB
+        ldy p8v_myword+1        ; loads MSB (word variables are stored LSB-first)
+```
+
+## CPU Quirks and Pitfalls
+
+### JMP ($xxFF) Page Wrap Bug (NMOS 6502)
+- **Problem**: On original 6502 CPUs, `jmp ($caff)` will fetch the LSB from `$caff` but the MSB from `$ca00` (instead of `$cb00`).
+- **Target**: Affects C64, C128, PET32.
+- **Solution**: Avoid placing indirect jump vectors on a page boundary, or use the CX16 (65C02) which fixed this bug.
+
+### BRK Instruction and the "Signature Byte"
+- **Behavior**: After a `BRK` instruction, the return address on the stack is incremented by **2**. This means the CPU skips the byte immediately following the `BRK` opcode.
+- **Usage**: This skipped byte is often used as a "signature" or parameter byte for the BRK handler.
+
+### BIT Instruction Flags
+- **Absolute/Zero-page**: `bit $1234` copies bit 7 of the memory value to the **N** flag and bit 6 to the **V** flag. The **Z** flag is set based on `A AND memory`.
+- **Immediate (65C02 only)**: `bit #$01` only affects the **Z** flag; it does **NOT** modify N or V.
+- **NMOS 6502**: Does **not** support `bit #imm`.
+
+### The "B" (Break) Flag
+- **Quirk**: The B flag (bit 4 of the status register) doesn't actually exist in the hardware status register. It only exists on the stack after a `PHP` or `BRK` instruction (set to 1) or a hardware IRQ/NMI (set to 0).
+- **Detection**: To tell if an interrupt was caused by `BRK` or a hardware IRQ, your handler must `pla`, `and #$10`, and check the result.
+
+### Decimal Mode Flag (D) Persistence
+- **Pitfall**: On NMOS 6502, the `D` flag is **not** cleared on interrupt. Always use `cld` in IRQ handlers. On 65C02, it is cleared automatically, but `cld` is still good practice.
+- **ADC/SBC**: Be extremely careful with arithmetic if you haven't explicitly set or cleared the `D` flag, as its state might be unknown.
+
+## Optimization Tips
+- **`stz` (65C02 only)**: Saves cycles and bytes compared to `lda #0`, `sta ...`.
+- **`bra` (65C02 only)**: Shorter and usually faster than `jmp`.
+- **Avoid `clc` before `bcc`**: `cmp` already sets the carry flag correctly for `bcc`/`bcs`.
+- **`inx` / `dex` vs `clc`+`adc #1`**: Incrementing/decrementing is faster and doesn't affect the carry flag.
+- **Zero-page usage**: Accessing variables in zeropage is 1 cycle faster and 1 byte shorter than absolute addressing.
+- **Cycle Counting**: Most instructions take 2-4 cycles. `jsr` takes 6, `rts` takes 6. Branches take 2 (no branch), 3 (branch taken), or 4 (branch taken across page boundary).
+
+## 64tass Macros
+Define macros for common tasks:
+```asm
+pushax  .macro
+        pha
+        txa
+        pha
+        .endm
+
+popax   .macro
+        pla
+        tax
+        pla
+        .endm
+```
+Call them with `#pushax` and `#popax`.
+
+## IRQ Handler Best Practices
+- **Clear the Decimal Flag (`cld`)**: On the original 6502, the decimal flag (`D`) is **not** automatically cleared when an interrupt occurs. If the interrupted code was in decimal mode, your handler will also run in decimal mode, causing arithmetic errors. Always call `cld` at the beginning of your handler. The 65C02 clears it automatically, but `cld` is still recommended for portability.
+
+## Invoking the Assembler (64tass)
+If you need to manually invoke `64tass` to assemble a generated `.asm` file, you should be aware of the default arguments that `prog8c` supplies to ensure compatibility with the generated code:
+
+- `--ascii`: **CRITICAL.** Prog8 generates character and string data in ASCII. Without this flag, `64tass` defaults to PETSCII, which will garble your strings.
+- `--case-sensitive`: Prog8 is case-sensitive and expects the assembler to be as well.
+- `--long-branch`: Enables automatic conversion of relative branches (`beq`, `bne`, etc.) to absolute jumps if the target is out of range. Prog8 relies on this.
+- `-Wno-implied-reg`: Suppresses warnings when the accumulator `a` is omitted from instructions like `rol`, `lsr`, etc. (though the skill recommends always using `rol a` for clarity).
+- `-Wall`: Enables all warnings.
+- `--cbm-prg` (or `--atari-xex` / `--nostart`): Sets the output format and adds the appropriate load address header.
+
+### Optional but Recommended for Debugging:
+- `--vice-labels --labels=labels.txt`: Generates a label file that can be loaded into the VICE monitor (`load_labels "labels.txt"`) to see your Prog8 symbol names while debugging.
+- `--list=listing.txt`: Generates a full assembly listing file with addresses and opcodes.
+
+### Example manual invocation:
+```bash
+64tass --ascii --case-sensitive --long-branch -Wall --cbm-prg -o myprogram.prg myprogram.asm
+```

.agents/skills/prog8-coder/SKILL.md

@@ -0,0 +1,248 @@
+---
+name: prog8-coder
+description: Writing or understanding Prog8 programs
+---
+
+# Prog8 Coder Skill
+
+You are an expert retro system development assistant, versed in the Prog8 programming language. Keep responses concise and practical — prefer short, correct code examples over lengthy prose.
+You are working with **Prog8** source code (`.p8` files) or its Intermediate Representation (`.p8ir` files). Prog8 targets 8-bit systems (C64, CX16, C128, PET32) with the 6502 CPU, plus a `virtual` target for testing.
+Follow ALL the rules below carefully.
+
+## General & Setup
+- A program = a `main` block containing a `start` subroutine entry point, plus optional other subroutines/blocks
+- Add `%zeropage basicsafe` at the top of your program to allow clean return on exit (instead of resetting the machine/emulator)
+- Module imports: `%import modulename` — no `as` aliasing. Use the module's defined prefix (e.g., `%import textio` → `txt.xxx`)
+- `.p8ir` files are the **Intermediate Representation** — target-independent, executable via `prog8c -vm file.p8ir`
+- **Library search**: `prog8c -libsearch <regex>` to find routines in the embedded stdlib (e.g., `prog8c -libsearch "txt\."`)
+- **Library dump**: `prog8c -libdump <dir>` to extract all embedded library source files
+- **`sys` module**: always available, no import needed
+- **CX16 programs**: add `%encoding iso`, call `txt.iso()` in `start()`, end with `sys.poweroff_system()`
+
+## Datatypes & Variables
+- Primitives: `bool`, `byte`, `ubyte`, `word`, `uword`, `long`, `float`, `str`
+- `ubyte`/`uword` = unsigned; `long` = signed 4-byte; `float` = 5-byte MS format; `str` = 0-terminated ubytes (max 255 chars)
+- **float requires `%import floats`** at top of file, else compiler errors
+- Arrays: max 256 bytes (512 for split word arrays). For larger data, use `memory()` + pointers
+- `memory(name, size)` returns a `uword` address to a statically reserved block of memory
+- To point a typed pointer at a `memory()` block, assign the uword directly: `^^MyStruct ptr = memory("name", size)`. The `^^Type:expression` syntax (below) only works with array literals, not general uword expressions.
+- Struct initialization: `^^StructType ptr = ^^StructType:[val1,val2,...]` (the `^^StructType:` can be omitted if inferable). This `^^Type:[...]` syntax does NOT work with variables or `memory()` — only literal arrays.
+- Struct definitions must be inside a block, not at file level.
+- Struct fields: simple types, `str`, and fixed-size arrays. Array fields: `ubyte[108] name`. `str` in struct = `^^ubyte`
+- Word/pointer arrays split into LSB/MSB by default. Override with `@nosplit`
+- **No call stack**: all variables statically allocated. No recursion without manual stack management
+- Variables zero-initialized (globals at start, locals on subroutine entry)
+- `@shared`, `@zp`, `@requirezp`, `@dirty`, `@nosplit` are **tags** that go on variable declarations. **Place them after the datatype (and array specifiers), before the variable name(s):**
+  ```
+  private ubyte[8] @shared vera_storage     ; single var with tag
+  ubyte @zp @shared varname                 ; multiple tags allowed
+  ubyte @requirezp var1                     ; require zeropage
+  ubyte[] @shared names                     ; array with tag
+  ```
+  The grammar is: `[private] datatype [arraydims] [tags...] identifierlist`
+- `@shared` marks variables as "used by external code" (assembly), prevents the optimizer from removing them
+- `@zp`/`@requirezp`: use sparingly — only for pointers (limited zeropage space)
+- Pointer-like typed pointers (`^^type`) support C-style scaled arithmetic; `uword` pointers always treat element as 1 byte
+- `&` = untyped address (uword); `&&` = typed pointer
+- Available zeropage scratch: `P8ZP_SCRATCH_B1`, `P8ZP_SCRATCH_REG`, `P8ZP_SCRATCH_W1`, `P8ZP_SCRATCH_W2`, `P8ZP_SCRATCH_PTR` — and cx16 virtual registers R0-R15 on all targets
+- Virtual registers (`cx16.r0`–`cx16.r15`): global 16-bit, NOT preserved across calls.
+- **WARNING: Virtual registers in ISR/IRQ handlers**: The virtual registers R0-R15 are *not preserved* across the IRQ handler call. If your handler uses them, it will corrupt the interrupted program's state. Either avoid using them in the handler, or save/restore with `cx16.save_virtual_registers()` / `cx16.restore_virtual_registers()`. This applies to all targets, not just CX16.
+- **WARNING: Long operations clobber R12-R15**: Some operations on `long` values use R12-R15 as temporary storage and will silently overwrite them. Do not rely on R12-R15 values when working with longs, and avoid using R12-R15 explicitly if your code uses long arithmetic.
+- **WARNING: VERA registers in ISR handlers (CX16)**: If your IRQ handler reads or writes VERA control registers (e.g., `cx16.VERA_DATA0`, `cx16.VERA_ADDR_L`, etc.), you must save and restore the VERA context around the handler's work using `cx16.save_vera_context()` / `cx16.restore_vera_context()`. Without this, the handler will corrupt any VERA operations (tilemap updates, sprite positioning, etc.) happening in the interrupted main program.
+- **IRQ handler best practices**: Keep handlers extremely short and fast — they run with interrupts disabled and steal cycles from the main program. Do NOT do lengthy processing, I/O, or complex subroutine calls inside the handler. Instead, set a boolean flag or semaphore that the main loop checks periodically, and do the actual work there.
+- Math performance: integer trig (`math.sin8`, `math.cos8`) uses fast LUTs; float trig (`floats.sin`/`cos`) is much slower
+
+## Recursion & Stack Management
+No call stack for variable storage — recursion overwrites locals. To handle it:
+1. **CPU hardware stack**: `push()`/`pushw()`/`pushl()`/`pushf()` and `pop()`/`popw()`/`popl()`/`popf()`. Save/restore locals around recursive calls
+2. **Software stacks**: `buffers.stack` (uword) / `buffers.smallstack` (ubyte). Both provide `push_b()`/`push_w()` and `pop_b()`/`pop_w()`
+3. **Iterative rewrite (preferred)**: Many recursive algorithms work as `repeat` loops with explicit bounds — avoids all stack overhead
+
+## Strings, Arrays & Pointers
+- `str` / array: max 256 bytes. `long[]` limited to 64 entries (64x4=256). `str[]` for string arrays: `str[5] names = ["a","b","c","d","e"]`
+- 2D arrays: `type[rows][cols] name`, access `name[r][c]`. Flat init list only (no nested `[[...]]`). Total size still ≤ 256 bytes
+- str/array passed as pointer to subroutine (receiving subroutine gets `^^ubyte` or `^^element`)
+- **No const pointers** or pointer-to-pointer currently supported
+- **Parsing limitation**: `pointer[index].field` as assignment target needs `^^`: `pointer[index]^^.field = value`
+- **Pre-allocate buffers**: `str buffer = "." * 50` (empty `""` allocates nothing — `strings.append()` will fail)
+- **No reassignment**: can't `buffer = "new text"` after declaration. Use `strings.copy()`/`strings.ncopy()`
+- String concat is expensive on 6502. Prefer separate prints over concatenation
+- **Efficient buffer iteration**: prefer `ptr++` + `@(ptr)` over `@(buffer + offset)`. Exception: if offset is a `ubyte` (≤ 255), `buffer[offset]` works fine
+- `@(ptr)` = peek/poke byte. For words: `peekw`/`pokew`, longs: `peekl`/`pokel`, floats: `peekf`/`pokef`, bools: `peekbool`/`pokebool`
+- Assigning a uword address to a `str` field of a struct is done by direct assignment. Compute the address in a uword variable first, then assign: `cx16.r0 = &namebufs + offset; entry.name = cx16.r0`. The `^^ubyte:(expr)` cast syntax does not parse — use a temp uword instead.
+- Use `len(array)` instead of hardcoded sizes
+- Array indexing is 0-based: `arr[0]` is first element
+- Static memory only — real dynamic allocation impossible, but can emulate with a simple arena allocator over a `memory()` slab
+
+## Logic & Control Flow
+- Logical operators (short-circuit, bool only): `and`, `or`, `xor`, `not`
+  - In `a and b`: if `a` is false, `b` is NOT evaluated
+  - In `a or b`: if `a` is true, `b` is NOT evaluated
+  - Important when `b` has side effects
+- Bitwise operators: `&`, `|`, `^`, `~`, `<<`, `>>`
+- Bit rotation: `rol()`/`ror()` (through carry), `rol2()`/`ror2()` (no carry)
+- CPU status flag branches: `if_cs`, `if_cc`, `if_z`, `if_nz` (compile to single 6502 branch instructions)
+- If-expressions for simple value assignments based on a choice
+- **Optional braces in if/else**: when the `if` or `else` body is a single statement, the `{ }` can be omitted. Place the statement on the next line, indented. Example:
+  ```
+  if x < 5
+      txt.print("small")
+  ```
+- `defer` defers statement execution until scope exit. Multiple defers fire in **reverse registration order** (LIFO / stack order — last deferred runs first). A defer is only registered if execution reaches that statement — conditional paths that skip the `defer` line will not register it.
+- `goto`, labels, jump lists allowed
+- **Common mistake**: `and`/`or` for bitmasking — use `&`/`|` instead!
+
+### The when Statement
+The `when` statement is a control flow construct that enables you to execute a specific action based on the value of an expression. It is generally more readable and often more efficient than a sequence of `if-else if` statements, as the compiler can optimize it into more efficient branching structures, such as a jump table.
+- **Expression**: Evaluates an expression and compares it against case values.
+- **Cases**: Defined by a value followed by the `->` operator.
+- **Blocks**: Use `{ }` to enclose multiple statements for a case.
+- **Else Clause**: Serves as a default handler; mandatory unless the expression type is fully covered.
+- **Efficiency**: Recommended for handling sets of fixed choices as it typically results in better assembly code.
+
+## Loop Constructs
+Prog8 supports these loop types. All support `break` and `continue` (except `unroll`).
+
+### `for` loop — iterate over a range or array
+- Loop variable **must be declared separately** before the `for` statement
+- Works with `ubyte`, `byte`, `uword`, `word`, `long`, pointer types (NOT `float`)
+- Iterates over ranges (`start to end`), descending ranges (`start downto end`), or arrays/strings
+- Optional `step <constant>` for non-unit step sizes
+- Loop variable value **after the loop is undefined** — don't rely on it
+- Descending loops with `downto` usually produce more efficient 6502 code
+```
+ubyte i
+for i in 20 to 155 {
+    ; body
+    break       ; exit loop
+    continue    ; next iteration
+}
+
+; descending
+for i in 155 downto 20 {}
+for i in 155 to 20 step -1 {}
+
+; iterate over array elements
+uword[] fib = [0, 1, 1, 2, 3, 5, 8, 13]
+uword num
+for num in fib {
+    ...
+}
+```
+
+### `while` loop — repeat while condition is true
+```
+while condition {
+    ; body
+    break
+    continue
+}
+```
+
+### `do`-`until` loop — always executes body at least once
+```
+do {
+    ; body
+    break
+    continue
+} until condition
+```
+
+### `repeat` loop — repeat a fixed number of times (most efficient)
+- Most efficient code generation — prefer over `for` when loop variable not needed
+- Omit count for infinite loop (still supports `break`)
+```
+repeat 15 {
+    ; body
+    break
+    continue
+}
+
+; infinite:
+repeat {
+    ; body
+    break if x==5
+}
+```
+
+### `unroll` loop — compile-time code duplication
+- Not a real loop — duplicates body N times at compile time
+- No `break`/`continue` allowed
+- Only simple statements (assignments, calls) in body
+- Constant iteration count required
+```
+unroll 80 {
+    cx16.VERA_DATA0 = 255
+}
+```
+
+## Subroutines & Return Values
+- **Don't use `private` on subroutines and variables** (including nested ones) unless the user asks for it. Everything is public by default in Prog8 — follow that convention.
+- `inline` keyword for subroutines to suggest inlining
+- No **function overloading** (except builtins) and no **polymorphism** in general. This means you must call specific routines for different types (e.g., `txt.print_ub(val)` vs `txt.print_w(val)` instead of a generic `print(val)`). Cannot use builtin names (msw, lsw, msb, lsb, mkword, mklong, peek, peekw, peekl, etc.) as variable/sub names
+- Can return 0, 1, or multiple values: `a, b, c = routine()`. Use `void` to skip: `void routine()`, `a, void, c = routine()`
+- Nested subroutines access parent scope variables directly
+
+## Assembly Subroutines (asmsub)
+For low-level assembly that gets arguments via registers and returns values in registers.
+- **Syntax**: `[private] [inline] asmsub subname(params) [clobbers(regs)] [-> returns] { %asm {{ ... }} }`
+- **Body Restriction**: The body of an `asmsub` **must only contain** a single `%asm {{ ... }}` node. Regular Prog8 statements or nested blocks are NOT allowed.
+- **Parameters**: `type name @register` (e.g., `ubyte val @A`, `uword addr @AX`, `float f @FAC1`).
+- **Return Values**: `-> type @register` (e.g., `-> ubyte @A`, `-> bool @Pz` for immediate branch use).
+- **Registers**:
+    - **8-bit**: `@A`, `@X`, `@Y`
+    - **16-bit**: `@AX`, `@AY`, `@XY` (register pairs)
+    - **Float**: `@FAC1`, `@FAC2` (Floating Point Accumulators)
+    - **Virtual**: `@R0`–`@R15` (16-bit), `@R0R1`–`@R14R15` (32-bit combined)
+    - **Status Flags (for returns)**: `@Pc` (Carry), `@Pz` (Zero), `@Pv` (Overflow), `@Pn` (Negative)
+- **Clobbers**: `clobbers (A, X, Y)` — list all hardware registers modified by the routine.
+- **Parameter names** are for documentation and type checking only. Use the registers in your assembly code.
+- **Inlining**: `inline asmsub` will paste the assembly code directly at the call site, avoiding `jsr`/`rts` overhead.
+
+## External Subroutines (extsub)
+Used to call routines at fixed memory addresses (like ROM KERNAL routines or third-party drivers).
+- **Syntax**: `[private] extsub [@bank <value>] address = subname(params) [clobbers(regs)] [-> returns]`
+- **Address**: Can be a hex literal (`$C000`) or a constant expression.
+- **Bank (optional)**: `@bank <integer>` (constant bank) or `@bank <identifier>` (variable bank).
+- **No Body**: Unlike `asmsub`, `extsub` has no `{ }` body; it just maps a signature to an address.
+- **Example**:
+  ```prog8
+  ; CX16 KERNAL CHROUT
+  extsub $FFD2 = chrout(ubyte char @A) clobbers(A, X, Y)
+
+  ; Routine in a specific RAM bank
+  extsub @bank 10 $C09F = audio_init() clobbers(A, X, Y) -> bool @Pc
+  ```
+
+## Inline Assembly
+When writing inline assembly (`%asm {{ }}` blocks or `asmsub` routines), load the **asm6502-coder** skill for formatting rules, symbol references, anonymous labels, and 64tass syntax details.
+
+
+
+## Standard Library
+- Find routines, functions, variables, modules and signatures in the symbol dump file for the given compilation target. 
+  - Online location: https://prog8.readthedocs.io/en/latest/libraries.html#low-fi-variable-and-subroutine-definitions-in-all-available-library-modules  they are linked there 1 for each compilation target
+  - Structure: builtin functions, then module sections with variables/constants (`type name`) and subroutines (`name (params) -> returntype`)
+- Text output: `textio` module (`txt.print`, `txt.chrout`, `txt.print_b`/`_ub`/`_w`/`_uw`/`_l`/`_bool`, `txt.print_f` for floats, `txt.spc()`, `txt.nl()`). **Note: Prog8 has no function overloading**, so you cannot use `txt.print(number)` — you must call the specific routine for the type (e.g., `txt.print_ub(val)` for an unsigned byte).
+- Math: `math` module — integer trig (`sin8`, `cos8`) via fast LUTs; `math.rnd()` for random numbers
+- String conversion: `conv` module (`str_uword`, `str2word`, etc.) — for printing numbers use txt routines instead
+- Char operations: `strings` module (`isdigit`, `isxdigit`, `isupper`, `islower`, `isletter`, `isspace`, `isprint`) — use these instead of manual ASCII/PETSCII arithmetic
+- String functions return useful lengths — capture them: `len = strings.copy(dest, src)`, `len = strings.append(buf, text)`, `len = strings.upper(mystr)`
+
+## Syntax & Formatting
+- Hex: `$FF` (not `0xFF`); Binary: `%1010` (not `0b1010`). Underscores for readability: `25_000_000`
+- 4-digit hex `$0000` = uword. No type suffixes (no `0L`). Cast: `expr as type`
+- Augmented assignment: `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `<<=`, `>>=`
+- **`;` starts a comment to end of line** — NOT a statement separator. One statement per line
+- **No `elif`**: use nested `else { if ... }`
+- Type casting: `expression as type` (e.g., `bytevar as word`). `as` has very low precedence (lower than arithmetic)
+- **No automatic type widening**: `byte*byte=byte` (overflow possible!). Cast explicitly
+- **No bare `{ }` blocks** like C/Java
+- Indentation: 4 spaces for .p8 and .asm files (no tabs)
+- Character encoding: 6502 targets use PETSCII by default (call `txt.lowercase()` at start for lowercase). Virtual target uses ISO (`%encoding iso` + `txt.iso()`)
+- **Test programs for CBM targets must only use lowercase text in string literals** (the C64/C128/PET32/CX16 targets all use PETSCII). In PETSCII, uppercase letters A-Z are the *graphics* symbols, so any uppercase text you put in a string literal is rendered as unpredictable graphics characters instead of readable letters. Use only lowercase (a-z) for any printed test output, labels, or expected-match strings on these targets; reserve uppercase for intentional PETSCII graphics. The `virtual` target (ISO) is unaffected and may use either case.
+- Array size inferred from initializer: `str[] types = ["a", "b", "c"]`
+- Enums: `Enum::Value` syntax (double colon), declared inside a block. They are syntactic sugar for a list of `const` declarations, not a type. Use enums for related values, `const` for standalone
+- Avoid `globals.XXXX` — move constants closer to where they're used
+- Member access through pointers: use `.` for both direct and pointer access. The compiler infers the type. For complex assignment targets, `^^` may be needed: `ptr^^.field = value`
+- Qualified names: must use full path from top level (e.g., `cx16.r0`, not relative)

.aiignore

@@ -13,5 +13,7 @@ dist/
 build/
 out/
 output/
+gradle/
 .gradle/
 .kotlin/
+.git/

.editorconfig

@@ -0,0 +1,45 @@
+# EditorConfig for Prog8 projects
+# Ensures consistent formatting across editors and team members
+# See https://editorconfig.org
+
+root = true
+
+# All files
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+# Prog8 source files (.p8)
+[*.p8]
+indent_style = space
+indent_size = 4
+
+# Assembly files (.asm) - 64tass syntax
+[*.asm]
+indent_style = space
+indent_size = 4
+
+# Kotlin compiler source files
+[*.kt]
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = false
+
+# Documentation files
+[*.md]
+trim_trailing_whitespace = false
+
+[*.rst]
+trim_trailing_whitespace = false
+
+# Gradle build files
+[*.gradle.kts]
+indent_style = space
+indent_size = 4
+
+# Git ignore files
+[.gitignore]
+indent_style = space
+indent_size = 2

.github/workflows/all-ci.yml

@@ -10,32 +10,46 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
-      - name: build and install recent 64tass
+      - name: install 64tass
         run: |
-          sudo apt-get install -y make build-essential
-          git clone --depth=1 https://github.com/irmen/64tass
-          cd 64tass
-          make -j4
-          sudo make install          
+          sudo apt update
+          sudo apt install 64tass
+          64tass --version
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           java-version: 17
           distribution: temurin
 
-      - name: Build and test with Gradle
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v6
+
+      - name: Compile
+        run: ./gradlew compileKotlin compileTestKotlin --console=plain
+
+      - name: Test
+        run: ./gradlew test --continue --console=plain
+
+      - name: Package
         run: |
-          ./gradlew build shadowJar --no-daemon
+          ./gradlew shadowJar --console=plain
           sha256sum -b compiler/build/libs/*-all.jar > compiler/build/libs/hash.txt
-        
+
       - name: Create compiler shadowJar artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
         with:
           name: prog8-compiler-jar-zipped
           path: |
             compiler/build/libs/*-all.jar
             compiler/build/libs/hash.txt
 
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v6
+        with:
+          name: test-results
+          path: compiler/build/test-results/test/
+

.gitignore

@@ -3,6 +3,9 @@
 .idea/developer-tools.xml
 .idea/usage.statistics.xml
 .idea/shelf/
+.junie/
+.junie/memory/
+.serena
 build/
 dist/
 output/
@@ -14,6 +17,7 @@ out-old/
 *.prg
 *.bin
 *.p8ir
+*.bankedcalls
 *.labels.txt
 *.vm.txt
 *.vice-mon-list
@@ -22,6 +26,7 @@ parser/**/*.interp
 parser/**/*.tokens
 parser/**/*.java
 compiler/src/prog8/buildversion/*
+languageServer/src/prog8/buildversion/*
 *.py[cod]
 *.egg
 *.egg-info
@@ -35,7 +40,6 @@ parsetab.py
 .pytest_cache/
 .attach_pid*
 compiler/lib/
-
 .gradle
 sd*.img
 *.d64

.idea/JunieProjectTechnologies.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JunieProjectTechnologies">
+    <option name="explicitlyEnabledTechs">
+      <set>
+        <option value="junie.python" />
+      </set>
+    </option>
+  </component>
+</project>

.idea/compiler.xml

@@ -2,6 +2,16 @@
 <project version="4">
   <component name="CompilerConfiguration">
     <option name="BUILD_PROCESS_HEAP_SIZE" value="3000" />
-    <bytecodeTargetLevel target="11" />
+    <bytecodeTargetLevel target="11">
+      <module name="prog8.codeGenExperimental" target="17" />
+      <module name="prog8.codeGenExperimental.main" target="17" />
+      <module name="prog8.codeGenExperimental.test" target="17" />
+      <module name="prog8.codeGenM68k" target="17" />
+      <module name="prog8.codeGenM68k.main" target="17" />
+      <module name="prog8.codeGenM68k.test" target="17" />
+      <module name="prog8.codeGenNew6502" target="17" />
+      <module name="prog8.codeGenNew6502.main" target="17" />
+      <module name="prog8.codeGenNew6502.test" target="17" />
+    </bytecodeTargetLevel>
   </component>
 </project>

.idea/gradle.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <option name="distributionType" value="LOCAL" />
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="modules">
+          <set>
+            <option value="$PROJECT_DIR$" />
+            <option value="$PROJECT_DIR$/codeCore" />
+            <option value="$PROJECT_DIR$/codeGenCpu6502" />
+            <option value="$PROJECT_DIR$/codeGenIntermediate" />
+            <option value="$PROJECT_DIR$/codeOptimizers" />
+            <option value="$PROJECT_DIR$/compiler" />
+            <option value="$PROJECT_DIR$/compilerAst" />
+            <option value="$PROJECT_DIR$/intermediate" />
+            <option value="$PROJECT_DIR$/languageServer" />
+            <option value="$PROJECT_DIR$/parser" />
+            <option value="$PROJECT_DIR$/simpleAst" />
+            <option value="$PROJECT_DIR$/virtualmachine" />
+          </set>
+        </option>
+        <option name="myGradleHome" value="/usr/share/java/gradle" />
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>

.idea/jarRepositories.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RemoteRepositoriesConfiguration">
+    <remote-repository>
+      <option name="id" value="central" />
+      <option name="name" value="Maven Central repository" />
+      <option name="url" value="https://repo1.maven.org/maven2" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="80ae155e-b222-4ca0-92cf-6041a298e78a" />
+      <option name="name" value="80ae155e-b222-4ca0-92cf-6041a298e78a" />
+      <option name="url" value="https://jitpack.io" />
+    </remote-repository>
+  </component>
+</project>

.idea/kotlinc.xml

@@ -7,13 +7,14 @@
     <option name="jvmTarget" value="11" />
   </component>
   <component name="KotlinCommonCompilerArguments">
-    <option name="apiVersion" value="2.2" />
-    <option name="languageVersion" value="2.2" />
+    <option name="apiVersion" value="2.4" />
+    <option name="languageVersion" value="2.4" />
   </component>
   <component name="KotlinCompilerSettings">
-    <option name="additionalArguments" value="-Xwhen-guards -jvm-default=no-compatibility" />
+    <option name="additionalArguments" value="-jvm-default=no-compatibility" />
   </component>
   <component name="KotlinJpsPluginSettings">
-    <option name="version" value="2.2.0" />
+    <option name="externalSystemId" value="Gradle" />
+    <option name="version" value="2.4.10" />
   </component>
 </project>

.idea/libraries/KotlinJavaRuntime.xml

@@ -1,23 +0,0 @@
-<component name="libraryTable">
-  <library name="KotlinJavaRuntime" type="repository">
-    <properties maven-id="org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.3.0" />
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.3.0/kotlin-stdlib-jdk8-2.3.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.3.0/kotlin-stdlib-2.3.0.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.3.0/kotlin-stdlib-jdk7-2.3.0.jar!/" />
-    </CLASSES>
-    <JAVADOC>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.3.0/kotlin-stdlib-jdk8-2.3.0-javadoc.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.3.0/kotlin-stdlib-2.3.0-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.3.0/kotlin-stdlib-jdk7-2.3.0-javadoc.jar!/" />
-    </JAVADOC>
-    <SOURCES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.3.0/kotlin-stdlib-jdk8-2.3.0-sources.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.3.0/kotlin-stdlib-2.3.0-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.3.0/kotlin-stdlib-jdk7-2.3.0-sources.jar!/" />
-    </SOURCES>
-  </library>
-</component>

.idea/libraries/antlr_antlr4.xml

@@ -1,18 +0,0 @@
-<component name="libraryTable">
-  <library name="antlr.antlr4" type="repository">
-    <properties maven-id="org.antlr:antlr4:4.13.2">
-      <exclude>
-        <dependency maven-id="com.ibm.icu:icu4j" />
-      </exclude>
-    </properties>
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.13.2/antlr4-4.13.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.13.2/antlr4-runtime-4.13.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr-runtime/3.5.3/antlr-runtime-3.5.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/ST4/4.3.4/ST4-4.3.4.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/abego/treelayout/org.abego.treelayout.core/1.0.3/org.abego.treelayout.core-1.0.3.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/eclipse_lsp4j.xml

@@ -1,13 +0,0 @@
-<component name="libraryTable">
-  <library name="eclipse.lsp4j" type="repository">
-    <properties maven-id="org.eclipse.lsp4j:org.eclipse.lsp4j:0.24.0" />
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/eclipse/lsp4j/org.eclipse.lsp4j/0.24.0/org.eclipse.lsp4j-0.24.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/eclipse/lsp4j/org.eclipse.lsp4j.jsonrpc/0.24.0/org.eclipse.lsp4j.jsonrpc-0.24.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/google/code/gson/gson/2.13.1/gson-2.13.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/google/errorprone/error_prone_annotations/2.38.0/error_prone_annotations-2.38.0.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/io_kotest_framework_datatest.xml

@@ -1,23 +0,0 @@
-<component name="libraryTable">
-  <library name="io.kotest.framework.datatest" type="repository">
-    <properties maven-id="io.kotest:kotest-framework-datatest:5.9.1" />
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-datatest/5.9.1/kotest-framework-datatest-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-datatest-jvm/5.9.1/kotest-framework-datatest-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.23/kotlin-stdlib-1.9.23.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.8.0/kotlinx-coroutines-core-jvm-1.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.9.1/kotest-common-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.9.23/kotlin-reflect-1.9.23.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.9.1/kotest-framework-api-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.9.1/kotest-assertions-shared-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.9.1/kotest-assertions-api-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.8.0/kotlinx-coroutines-jdk8-1.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.12/java-diff-utils-4.12.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.8.0/kotlinx-coroutines-test-jvm-1.8.0.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/io_kotest_runner_junit5_jvm.xml

@@ -1,41 +0,0 @@
-<component name="libraryTable">
-  <library name="io.kotest.runner.junit5.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.9.1" />
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.9.1/kotest-runner-junit5-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.9.1/kotest-framework-api-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.9.1/kotest-assertions-shared-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.12/java-diff-utils-4.12.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.8.0/kotlinx-coroutines-test-jvm-1.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.9.1/kotest-common-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.9.1/kotest-framework-engine-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.172/classgraph-4.8.172.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/ajalt/mordant/1.2.1/mordant-1.2.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/ajalt/colormath/1.2.0/colormath-1.2.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-debug/1.8.0/kotlinx-coroutines-debug-1.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/net/java/dev/jna/jna/5.9.0/jna-5.9.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/net/java/dev/jna/jna-platform/5.9.0/jna-platform-5.9.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy/1.10.9/byte-buddy-1.10.9.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy-agent/1.10.9/byte-buddy-agent-1.10.9.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-discovery-jvm/5.9.1/kotest-framework-discovery-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.9.1/kotest-assertions-core-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.8.0/kotlinx-coroutines-jdk8-1.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.9.1/kotest-assertions-api-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.9.1/kotest-extensions-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.9.1/kotest-framework-concurrency-jvm-5.9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.8.0/kotlinx-coroutines-core-jvm-1.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/23.0.0/annotations-23.0.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.8.2/junit-platform-engine-1.8.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.8.2/junit-platform-commons-1.8.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.2/apiguardian-api-1.1.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-suite-api/1.8.2/junit-platform-suite-api-1.8.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-launcher/1.8.2/junit-platform-launcher-1.8.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.8.2/junit-jupiter-api-5.8.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.23/kotlin-stdlib-1.9.23.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.9.23/kotlin-reflect-1.9.23.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/jetbrains_kotlinx_cli_jvm.xml

@@ -1,10 +0,0 @@
-<component name="libraryTable">
-  <library name="jetbrains.kotlinx.cli.jvm" type="repository">
-    <properties include-transitive-deps="false" maven-id="org.jetbrains.kotlinx:kotlinx-cli-jvm:0.3.6" />
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-cli-jvm/0.3.6/kotlinx-cli-jvm-0.3.6.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/michael_bull_kotlin_result_jvm.xml

@@ -1,20 +0,0 @@
-<component name="libraryTable">
-  <library name="michael.bull.kotlin.result.jvm" type="repository">
-    <properties maven-id="com.michael-bull.kotlin-result:kotlin-result-jvm:2.1.0" />
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/com/michael-bull/kotlin-result/kotlin-result-jvm/2.1.0/kotlin-result-jvm-2.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.0/kotlin-stdlib-2.2.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-    </CLASSES>
-    <JAVADOC>
-      <root url="jar://$MAVEN_REPOSITORY$/com/michael-bull/kotlin-result/kotlin-result-jvm/2.1.0/kotlin-result-jvm-2.1.0-javadoc.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.0/kotlin-stdlib-2.2.0-javadoc.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0-javadoc.jar!/" />
-    </JAVADOC>
-    <SOURCES>
-      <root url="jar://$MAVEN_REPOSITORY$/com/michael-bull/kotlin-result/kotlin-result-jvm/2.1.0/kotlin-result-jvm-2.1.0-sources.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.0/kotlin-stdlib-2.2.0-sources.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0-sources.jar!/" />
-    </SOURCES>
-  </library>
-</component>

.idea/misc.xml

@@ -20,6 +20,7 @@
   <component name="Black">
     <option name="sdkName" value="Python 3.11" />
   </component>
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="FrameworkDetectionExcludesConfiguration">
     <type id="Python" />
   </component>

.idea/modules.xml

@@ -2,24 +2,9 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/beanshell/beanshell.iml" filepath="$PROJECT_DIR$/beanshell/beanshell.iml" />
       <module fileurl="file://$PROJECT_DIR$/benchmark-program/benchmark-program.iml" filepath="$PROJECT_DIR$/benchmark-program/benchmark-program.iml" />
-      <module fileurl="file://$PROJECT_DIR$/codeCore/codeCore.iml" filepath="$PROJECT_DIR$/codeCore/codeCore.iml" />
-      <module fileurl="file://$PROJECT_DIR$/codeGenCpu6502/codeGenCpu6502.iml" filepath="$PROJECT_DIR$/codeGenCpu6502/codeGenCpu6502.iml" />
-      <module fileurl="file://$PROJECT_DIR$/codeGenExperimental/codeGenExperimental.iml" filepath="$PROJECT_DIR$/codeGenExperimental/codeGenExperimental.iml" />
-      <module fileurl="file://$PROJECT_DIR$/codeGenIntermediate/codeGenIntermediate.iml" filepath="$PROJECT_DIR$/codeGenIntermediate/codeGenIntermediate.iml" />
       <module fileurl="file://$PROJECT_DIR$/codeGenVirtual/codeGenVirtual.iml" filepath="$PROJECT_DIR$/codeGenVirtual/codeGenVirtual.iml" />
-      <module fileurl="file://$PROJECT_DIR$/codeOptimizers/codeOptimizers.iml" filepath="$PROJECT_DIR$/codeOptimizers/codeOptimizers.iml" />
-      <module fileurl="file://$PROJECT_DIR$/compiler/compiler.iml" filepath="$PROJECT_DIR$/compiler/compiler.iml" />
-      <module fileurl="file://$PROJECT_DIR$/compilerAst/compilerAst.iml" filepath="$PROJECT_DIR$/compilerAst/compilerAst.iml" />
-      <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" />
-      <module fileurl="file://$PROJECT_DIR$/virtualmachine/virtualmachine.iml" filepath="$PROJECT_DIR$/virtualmachine/virtualmachine.iml" />
     </modules>
   </component>
 </project>

.idea/vcs.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="" vcs="Git" />
   </component>
 </project>

.junie/AGENTS.md

@@ -0,0 +1,5 @@
+---
+description: Startup workflow to load project context
+---
+
+1. Read the file `AGENTS.md` in the project root as initial system prompt to build context and instructions about the project structure, module descriptions, and development commands.

.junie/instructions

@@ -0,0 +1,5 @@
+# Agent Instructions
+
+- The file `AGENTS.md` MUST be loaded as the very first step of every session, if it isn't already loaded by the system.
+- Follow all project-specific guidelines and information provided in `AGENTS.md`.
+- Ensure all automated tasks and code generations adhere to the language rules and architectural decisions described in `AGENTS.md`.

.qwen/settings.json

@@ -0,0 +1,31 @@
+{
+  "context": {
+    "fileName": "AGENTS.md"
+  },
+  "$version": 3,
+  "permissions": {
+    "allow": [
+      "Bash(prog8c *)",
+      "Bash(gradle *)",
+      "Bash(mkdir *)",
+      "Bash(ls *)",
+      "Bash(cat *)",
+      "Bash(find *)",
+      "Bash(sed *)",
+      "Bash(grep *)",
+      "Bash(xargs *)",
+      "Bash(wc *)",
+      "Bash(diff *)",
+      "Bash(paste *)",
+      "Bash(echo *)",
+      "Bash(cp *)",
+      "Bash(time)",
+      "Bash(kotlinc *)",
+      "Bash(python3 *)",
+      "Bash(jar *)",
+      "Bash(od *)",
+      "Bash(xxd *)",
+      "Bash(gcc *)"
+    ]
+  }
+}

AGENTS.md

@@ -1,32 +1,355 @@
-# Agent Instructions for Prog8 Project
+# CRITICAL RULES - MUST FOLLOW
 
-## Required Startup Actions
+## RESPONSES
 
-When starting a new session with this project, you **MUST** perform these actions before proceeding with any user requests:
+- Keep responses concise and to the point - unless the user asks otherwise
 
-1. **Read QWEN.md** - Execute: `read /home/irmen/Projects/prog8/QWEN.md`
-   - This file contains critical project context including:
-     - Project overview (Prog8 compiler for 8-bit retro systems)
-     - Module descriptions for all 20+ modules
-     - Gradle commands and build instructions
-     - Prog8 compiler usage examples
-     - Development shortcuts
+## PLANNING MODE
 
-2. **Check startup workflow** - Execute: `read /home/irmen/Projects/prog8/.agent/workflows/startup.md`
-   - This file may contain additional startup instructions
+- Always ask clarifying questions
+- Never assume design, tech stack or features
+- Use deep-dive sub-agents to assist with research
+- Use deep-dive sub-agents to review the different aspects of your plan before presenting to the user
 
-## Why This Matters
+## CHANGE / EDIT MODE
 
-The prog8 project is a complex compiler with:
-- Multiple code generation backends (6502, IR, Virtual Machine)
-- 20+ interconnected modules
-- Specific build and development workflows
-- Proprietary language syntax and conventions
+- Never implement features yourself when possible - use sub-agents!
+- Identify changes from the plan that can be implemented in parallel, and use sub-agents to implement the features efficiently
+- When using sub-agents to implement features, act as a coordinator only
+- Use the best model for the task - premium models for complex tasks (like coding) and mid-tier models for simpler tasks, like documentation
+- After completing features (large or small), always run commands like lint, type check and next build to check code quality
 
-Without reading QWEN.md first, you will lack essential context needed to:
-- Understand module relationships
-- Use correct gradle commands
-- Reference the right files
-- Follow project conventions
+## Project Overview
+- This project is a compiler for the Prog8 programming language.
+- Prog8 is a programming language primarily targeting 8-bit retro systems with the 6502 CPU, such as the Commodore 64, Commodore 128, and Commander X16.
+- The compiler has a 6502 code generator backend, and an IR code generator.
+- The IR code is meant to be used in a new machine specific code generator backend (primarily 6502 but maybe 68000 as well later)
+- The compiler includes a simple 'virtual machine' that can execute the IR code directly via interpretation.
+- Prog8 source files have .p8 extension – these are *not* LUA or PICO-8 source files in this case!
+- Prog8 source files are a "module" that can contain one or more "blocks". They can also import other modules, from internal library files or from source files on the filesystem.
+- The prog8 compiler is written mostly in Kotlin, those files have the .kt extension.
+- The standard library is mostly written in Prog8 and assembly code, and can be found in the "compiler" module, in the 'res/prog8lib' directory.
+- **Library Reference**: For a quick overview of all available modules, routines, and their signatures, **consult the skeleton files (symboldumps)** in `docs/source/_static/symboldumps/`. They are named `skeletons-<target>.txt`.
+- Kotlin version 2.4 is used for the compiler implementation.
+- Java 17 is used as Java runtime version.
+- ANTLR4 version 4.13 is used for the parser implementation.
+- Dependent library versions can be found in 'build.gradle.kts' and in the IntelliJ IDEA configuration files in .idea/libraries
+- The compiler main entrypoint is in the "compiler" module, in src/prog8/CompilerMain.kt
 
-**DO NOT PROCEED** with any user requests until you've read QWEN.md!
+## Compilation Flow (High-Level)
+```
+Source → parseMainModule() → processAst() → optimizeAst() → postprocessAst()
+       → Simple AST → Code Generator → Assembly → .prg
+```
+
+**Key phases in `compiler/src/prog8/compiler/Compiler.kt`:**
+- `parseMainModule()` - Import modules, parse to Compiler AST
+- `processAst()` - Semantic analysis, constant folding, type casting, validation
+- `optimizeAst()` - Dead code elimination, inlining, statement optimization
+- `postprocessAst()` - Memory layout, final transformations
+- Code generation – Simple AST → IR or 6502 assembly
+
+**Understanding this order is important:** For example, `ConstantIdentifierReplacer` runs during `processAst()`, so by the time `AstChecker` runs at the end of that phase, identifier references have already been replaced with their actual values.
+
+### Target Differences
+- **CPU instruction set differences**: Only the CommanderX16 target (cx16) can use 65C02 instructions such as STZ. The other targets (C64, C128, PET32) can only use original 6502 instructions.
+- When writing or understanding assembly code, load the `asm6502-coder` skill for 64tass syntax and conventions.
+
+
+## DEBUGGING TIP: Use `-noopt` to isolate problems
+When investigating a possible code generation problem (both IR and 6502), **FIRST try compiling the program with the `-noopt` switch** to disable most of the compiler optimizations.
+- **Problem gone with `-noopt`**: Issue is in **optimization phases** (`optimizeAst()`, `UnusedCodeRemover`, `Inliner`, etc.)
+- **Problem persists with `-noopt`**: Issue is in **parsing, semantic analysis, symboltable, or the regular code generation path**.
+
+This way you can determine if the problem is caused by a faulty optimization step, or just occurs in the regular code generation path.
+
+## DEBUGGING TIP: Use `-compareir` to see what changed
+When investigating optimization-related issues or tracking regressions:
+```bash
+# Compile without optimizations (baseline)
+prog8c -target virtual -noopt -out dir program.p8
+
+# Compile with optimizations and compare
+prog8c -target virtual -compareir dir/program_noopt.p8ir program.p8
+```
+**Output shows:**
+- Instruction/chunk/register count changes with percentages
+- First 10 actual instruction differences
+- Helps identify which optimization transformed the code
+
+## DEBUGGING TIP: Use `-vmtrace` to trace execution
+When debugging VM execution or control flow issues:
+```bash
+prog8c -target virtual -vm program.p8ir -vmtrace
+prog8c -target virtual -emu -vmtrace program.p8
+```
+**Output format:** `[chunkName:instructionIndex] instruction`
+- Shows each executed IR instruction with location
+- Useful for understanding control flow and finding where execution diverges
+- **Only works on virtual target**
+
+## Typical debugging workflow:
+1. **Quick check:** `-check` for syntax errors
+2. **Isolate:** `-noopt` to determine if problem is optimizer-related
+3. **Compare:** `-compareir` to see what instructions changed
+4. **Trace:** `-vmtrace` to watch actual execution flow
+5. **Deep dive:** `-printast1` / `-printast2` for compiler internals
+
+## IMPORTANT: SymbolTable cachedFlat cache
+The `SymbolTable` class has a **cached `flat` property** for fast symbol lookups.
+
+**CRITICAL:** If you modify the AST **after** SymbolTable construction, you **MUST** call `symbolTable.resetCachedFlat()` or lookups will fail!
+
+## IMPORTANT: Virtual Target (IR Codegen) Issues
+For problems that **ONLY occur with the 'virtual' target**, **ONLY modify these modules**:
+- `codeGenIntermediate` - IR code generator
+- `intermediate` - IR representation and file I/O  
+- `virtualmachine` - VM that executes IR code
+
+**DO NOT modify** `compilerAst`, `simpleAst`, `codeGenCpu6502`, etc. The IR codegen has its own separate handling for symbol tables, AST transformations, and unused code removal.
+
+## IMPORTANT: Compiler Crashes Must Be Fixed in the Compiler
+A Kotlin/Java crash in the compiler itself (as opposed to a compilation error in the user's program) indicates a bug in the compiler code. **Such crashes should NEVER be worked around by modifying the Prog8 source file that triggered them.**
+
+Instead, always fix the bug in the compiler's Kotlin code. The user's program is correct - the compiler needs to handle it properly.
+
+Steps when encountering a compiler crash:
+1. Create a minimal reproduction case of the Prog8 source that triggers the crash
+2. Debug the compiler to find the root cause in the Kotlin code
+3. Fix the compiler bug, not the user program
+
+## CRITICAL: NO FORMATTING
+- DO NOT change indentation and formatting of lines that are not being modified. NEVER run formatters (black, ruff, prettier, etc.) after edits,
+- .editorconfig handles basic formatting (indentation, line endings, whitespace)
+- Make ONLY the requested changes, touch nothing else
+- **NO EMOJI in user documentation**. Do not use emoji or decorative unicode symbols in documentation files. Functional unicode symbols are acceptable when they serve a clear purpose (e.g., → for arrows, ± for plus-minus, × for multiplication, ° for degrees). Avoid decorative emoji like ❌ ✅ ⚠️ 🎉 etc.
+
+### Code Style Guidelines
+**Minimal comments when making changes**: When modifying existing code, add only essential comments that explain *why* a change was made or document non-obvious behavior. **Do not add verbose comments** that restate what the code does; let the code speak for itself. Existing extensive comments should be preserved, but new changes should have minimal commentary.
+
+**Kotlin string `$` handling**: The `$` character is special in Kotlin string literals (string interpolation). If you need a literal `$` character, use Kotlin's `$$"..."` interpolation prefix instead of backslash escaping (`\$`) or `${'$'}`. The `$$"..."` syntax is a fairly recent Kotlin feature that avoids nasty escaping. For example:
+```kotlin
+val bill = $$"The value is $3.99"
+```
+
+
+## Prog8 language information
+
+When the task involves writing or understanding `.p8` (Prog8 source) or `.p8ir` (Prog8 intermediate representation) files, **load the `prog8-coder` skill** — it contains the full language reference, syntax rules, and standard library guidance.
+
+## Project Module Descriptions
+- `compiler` - Main compiler entrypoint (src/prog8/CompilerMain.kt)
+- `compilerAst` - Complex AST where most optimizations run
+- `simpleAst` - Simplified AST used by code generator backends
+- `parser` - ANTLR4 parser implementation
+- `codeCore` - Core code generation utilities
+- `codeGenCpu6502` - 6502 assembly code generator backend
+- `codeGenIntermediate` - Intermediate representation (IR) code generator
+- `codeGenVirtual` - Virtual machine code generator backend
+- `codeOptimizers` - Optimization passes
+- `intermediate` - IR components
+- `virtualmachine` - VM that executes IR code
+- `languageServer` - Language Server Protocol implementation
+- `docs` - Documentation files
+- `examples` - Example Prog8 programs
+
+## Key Information
+- never read the files and directories that are ignored via the .aiignore and .gitignore files (EXCEPT when it is a folder for agent config such as .junie, .opencode, .qwen or .agent)
+- never perform any git source control write/update/add/commit/branch operations. Read and status operations are allowed.
+- **git log/history queries can be useful** for understanding when/why a feature was added or tracking down when a bug was introduced, but for locating code use grep_search or glob instead.
+- Architecture decisions: separation of frontend/parser, IR intermediate representation, multiple backends
+
+# Dev environment tips
+
+## Development Workflows
+
+**1. Testing your own Prog8 programs** (no compiler changes):
+- No rebuild needed - just run `prog8c` directly
+- Edit your `.p8` file → compile/run → check stdout output
+- Example: `prog8c -target virtual -emu myprogram.p8`
+
+**2. Testing compiler or standard library changes**:
+- Rebuild required after every change to `.kt`, `.p8`, or `.asm` files in the compiler project
+- Workflow: edit source → `gradle installdist installshadowdist` → test with `prog8c`
+- Example: fix bug in `CodeGen6502.kt` → rebuild → `prog8c -target cx16 test.p8`
+
+## Building and Installing the Compiler
+- use the system installed gradle command instead of the gradle wrapper.
+
+### Quick compile check (NO tests)
+- **After changing compiler Kotlin source (.kt files)**: Use `gradle :compiler:compileKotlin --console=plain` to quickly check for syntax/compile errors
+- This compiles the compiler but **skips running tests**, this is much faster than `gradle build`
+- **Note:** This does NOT install the compiler - use `gradle installdist installshadowdist --console=plain` after to actually use your changes
+
+### When you MUST rebuild AND reinstall the compiler
+
+**After ANY change to:**
+1. **Kotlin compiler source code** (`.kt` files in any module, or the `.g4` grammar file)
+2. **Standard library Prog8 files** (`compiler/res/prog8lib/**/*.p8`)
+3. **Standard library assembly files** (`compiler/res/prog8lib/**/*.asm`)
+
+**Run:** `gradle installdist installshadowdist --console=plain`
+
+**Why:** The standard library files (.p8 and .asm) are embedded into the compiler JAR during the build. Changes to these files are NOT picked up by simply running `prog8c` - you MUST rebuild and reinstall for your changes to take effect.
+
+**Without this step, your changes will NOT be reflected when running `prog8c`!**
+- This compiles AND installs, but still skips running tests (faster than `gradle build`)
+
+### When to run full build with tests
+- **Before final verification**: Always run `gradle build` to ensure all tests pass
+- **After major refactoring**: Run `gradle build` to catch regressions
+- **When debugging test failures**: Use `gradle test --tests "*TestName*"` for specific tests
+- **When working on a standalone codegen module** (one that reads `.p8ir` files): Run `gradle :<module>:test --console=plain` instead of full `gradle build`. Compiler unit tests are irrelevant for IR-level changes. Do run full `gradle build` before final verification.
+
+### Build command summary
+
+| Command | When to use | Time |
+|---------|-------------|------|
+| `gradle :compiler:compileKotlin --console=plain` | Quick syntax check (no tests) | ~10-20s |
+| `gradle installdist installshadowdist --console=plain` | After compiler changes (to use them) | ~10-20s |
+| `gradle build --console=plain` | Before commits, after major changes | ~45-60s |
+| `gradle test --tests "*Name*" --console=plain` | Run specific tests | ~5-30s |
+
+**Note:** Use system `gradle` command, not wrapper. Run `gradle clean` if you suspect stale artifacts.
+
+## Using the Compiler (prog8c)
+- the prog8c compiler executable can be found in the compiler/build/install/prog8c/bin folder (this is already added to the shell's path)
+- **the `-check` switch performs a quick syntax/semantic check only; it will NOT produce any output files (no .prg, .asm, etc.)**. Use it only for fast error checking during development.
+- **the `-noopt` switch DISABLES all optimizations** - useful for debugging to determine if a problem is caused by the optimizer. **Optimizations are ENABLED by default** (no flag needed).
+- **prog8c uses single-dash command line options** (e.g., `-target`, `-noopt`, `-check`), NOT double-dash (`--target` is invalid).
+- **the `-printast1` switch prints out the internal Compiler AST** after parsing and semantic analysis.
+- **the `-printast2` switch prints out the optimized Simple AST** just before it goes to the code generator. This is useful for debugging optimizer issues.
+- **the `-out outdir` switch sets an alternative output directory** for compiled files (.prg, .asm, .list, etc.). **By default, output files are written to the same directory as the source file**.
+- **Other useful flags**: `-quiet` (suppress messages), `-warnimplicitcasts` (warn on implicit type widening), `-daemon` (keep a background compiler process alive — must be passed on every invocation)
+
+### Compilation Output Files
+- `*.prg` - The final compiled program file for the target system (e.g., Commander X16)
+- `*.asm` - Generated assembly code from the Prog8 source
+- `*.list` - Generated full assembly listing file from the Prog8 source
+- `*.p8ir` - Intermediate representation file, can be executed in the Virtual Machine
+- `*.vice-mon-list` - Vice emulator monitor list file for debugging
+
+### Execution Examples
+- `prog8c -target targetname input.p8` - Compile a Prog8 source file "input.p8" for the given target (cx16, c64, pet32, c128, virtual)
+- `prog8c -target targetname -emu input.p8` - Compile and execute a prog8 file in the emulator for the given target (cx16, c64, pet32, c128, virtual)
+- `prog8c -vm input.p8ir` - Execute an existing prog8 program, compiled in IR form, in the Virtual Machine
+
+### Library Tools
+- **Library search**: `prog8c -libsearch <regex>` — search for a regex pattern in the embedded stdlib files. Extremely useful to quickly find library routines, variables, or signatures (e.g., `prog8c -libsearch "txt\."` lists all textio routines)
+- **Library dump**: `prog8c -libdump <dir>` — extract all embedded library source files into a directory for direct inspection
+
+## Testing and Verification
+
+- Never assume your changes simply work, always test!
+- If the project does not have any testing tools, scripts, MCP tools, skills, etc. available for testing, ask the user whether testing should be skipped.
+
+### Automated Tests (gradle)
+Always use the `--console=plain` flag with these commands to avoid messing up the agent's text interface.
+- `gradle build --console=plain` - Full build including all tests (about 50s)
+- `gradle :compiler:test --console=plain` - Run only compiler tests (faster)
+- `gradle :compiler:test --tests "prog8tests.compiler.TestOptimization" --console=plain` - Run specific test class
+
+Note: By default, Gradle only shows failed tests. Passed and skipped tests are silent.
+
+**⚠️ CRITICAL: Test Filtering Patterns - Read This First!**
+
+Gradle's `--tests` filter has **strict rules** that are easy to get wrong:
+
+| Pattern | Example | Works?        |
+|---------|---------|---------------|
+| **Full class name** | `--tests "prog8tests.compiler.TestOptimization"` | **USE THIS**  | 
+| Wildcard at END | `--tests "prog8tests.compiler.Test*"` | Yes           |
+| Wildcard on package | `--tests "prog8tests.compiler.*"` | Yes           |
+| **Wildcard at START** | `--tests "*TestOptimization"` | FAILS         |
+| Test description | `--tests "*Optimization*inline*"` | FAILS         |
+
+**Why the restrictions?** Gradle's `--tests` filter matches **fully qualified class names only**. Wildcards work as **suffixes** (e.g., `Test*`) but NOT as prefixes (e.g., `*Test`). KoTest test names like `"inline multi-value void"` are _descriptions_, not method names, so you cannot filter by them.
+
+**To find failing tests after a run:**
+```bash
+# Check XML results (reliable)
+grep "<failure" compiler/build/test-results/test/*.xml
+
+# Or check HTML report (most reliable)
+cat compiler/build/reports/tests/test/index.html
+
+# For test compilation errors
+gradle :compiler:compileTestKotlin --info 2>&1 | grep "^e:"
+```
+
+**Additional notes:**
+- Unit tests use KoTest (FunSpec style)
+- Tests are in the "compiler" module's `test` directory (and some other modules)
+- Test config is in root `build.gradle.kts`; tests run in parallel
+- **When writing test programs**, add at the top: `%zeropage basicsafe` and `%option no_sysinit`
+- When a test fails, the output shows "There were failing tests. See the report at:" - **read that HTML report**
+
+### Compiler Unit Test Snippets
+Prog8 code snippets embedded in the compiler's own Kotlin unit tests (e.g., in `TestAstChecks.kt`, `TestOptimization.kt`) follow different rules from standalone programs:
+- **Keep self-contained** — avoid `%import` directives (test setup may not have library search path configured)
+- **Use `cx16` target** (not `virtual`, unless specifically testing the VM)
+- **Set `writeAssembly=false`** if the test only checks generated AST (much faster)
+- **Set `optimize=false`** by default for these snippets
+- **Do NOT use** the `%encoding iso` / `txt.iso()` / `sys.poweroff_system()` pattern — that's only for real CX16 emulator runs
+
+### Testing Assembly Output
+When testing generated assembly in Kotlin tests:
+- **NEVER dump raw assembly in string assertions** (e.g., `asm shouldContain "jsr label"`). On failure, this dumps the ENTIRE assembly listing into test logs.
+- **Instead, parse into lines and check specific properties:**
+  ```kotlin
+  val lines = asm.lines().map { it.trim() }
+  lines.any { it == "lda #42" } shouldBe true
+  lines.count { it.startsWith("jsr") } shouldBe 0
+  ```
+- Prefer `lines.any { ... }` for existence checks and `lines.count { ... } shouldBe 0` for absence checks.
+
+### Manual Verification & Emulators
+
+**Testing tip**: When writing and testing Prog8 programs, **use the `virtual` target** (e.g., `prog8c -target virtual -emu input.p8` or `prog8c -vm input.p8ir`). This is the preferred way to test because the virtual target can easily write output to stdout, making it simple to verify program behavior and check results.
+
+**CX16 output verification**: Use `x16emu -echo iso -run -prg input.prg` to echo screen output to stdout **and auto-start the program**. The `-run` flag is **critical**: without it, the program loads but doesn't execute, so you'll see no output. Pipe through `strings` or `grep` to filter: `x16emu -echo iso -run -prg input.prg 2>&1 | grep -E "(PASS|FAIL)"`.
+**IMPORTANT**: Always add `%encoding iso` at the top of your source file and call `txt.iso()` in `start()`. This prevents PETSCII→ISO charset translation errors that garble uppercase/special characters and make output unreadable:
+```prog8
+%encoding iso
+%import textio
+main { sub start() { txt.iso(); txt.print("PASS\n") } }
+```
+**IMPORTANT: Always use `sys.poweroff_system()` to exit the CX16 emulator cleanly!** Add `sys.poweroff_system()` at the end of your main program block - this exits x16emu automatically in most cases.
+**Note:** The `sys` module is always available, there is no need to import it ever.
+
+**Commodore 64 (x64sc)**: `x64sc input.prg` - run an existing compiled program in the Commodore-64 emulator. Ignore any errors and warnings, because the emulator doesn't produce any output on STDOUT.
+
+### actual 6502 CPU simulation tests
+For high-fidelity functional verification of generated 6502 code without a full emulator, you can use the `ksim65` simulator in your unit tests. This allows executing the compiled machine code and asserting on memory or register states.
+- Use the `simulate()` extension function on a `CompilationResult`.
+- See `prog8tests.codegeneration.TestExecution6502` for examples.
+- Both 6502 and 65C02 CPUs can be simulated.
+- The simulator supports capturing serial output and handling hardware reset/poweroff signals.
+- There are various assertion helper methods to test on the state of CPU registers, memory contents, etc.
+- Using the simulator is much faster and way more controllable than using a full emulator to run the code.
+- The simulator DOES NOT represent an actual real world machine and has VERY LIMITED hardware devices so it can generally not be used to run full example prorams on.
+
+## Git Operations for File Moves/Deletes
+
+**When renaming or moving git-tracked files, ALWAYS use `git mv`:**
+```bash
+# CORRECT - preserves git history
+git mv old/path/File.kt new/path/File.kt
+
+# WRONG - git sees this as delete + add (loses history)
+mv old/path/File.kt new/path/File.kt
+```
+
+**When deleting git-tracked files, ALWAYS use `git rm`:**
+```bash
+# CORRECT - properly stages the deletion
+git rm path/to/File.kt
+
+# WRONG - git sees this as unstaged deletion
+rm path/to/File.kt
+```
+
+**Why this matters:** `git mv` and `git rm` properly stage the changes and preserve file history. Plain `mv`/`rm` requires git to detect renames heuristically, which may not always work correctly.
+
+## TODO Items
+The file `docs/source/todo.rst` contains a comprehensive list of things that still have to be fixed, implemented, or optimized. **Use this to understand what features are NOT yet available** in the compiler or Prog8 language: if a user asks for something that's on the TODO list, you'll know it's not implemented yet and can explain the limitation.

Makefile

@@ -1,12 +1,20 @@
-# super simple Makefile to lauch the main gradle targets to build and/or test the prog8 compiler
+# super simple Makefile to launch the main gradle targets to build and/or test the prog8 compiler
 
 .PHONY: all test
 
+# Use system gradle if available, otherwise fall back to gradlew wrapper
+# Windows uses 'where' and gradlew.bat, Unix uses 'command -v' and ./gradlew
+ifeq ($(OS),Windows_NT)
+    GRADLE = $(shell where gradle >nul 2>&1 && echo gradle || echo gradlew.bat)
+else
+    GRADLE = $(shell command -v gradle >/dev/null 2>&1 && echo gradle || echo ./gradlew)
+endif
+
 all:
-	gradle installdist installshadowdist
-	@echo "compiler launch script can be found here: compiler/build/install/compiler-shadow/bin/prog8c"
+	$(GRADLE) installdist installshadowdist
+	@echo "compiler launch script can be found here: compiler/build/install/prog8c-shadow/bin/prog8c"
 
 test:
-	gradle build
-	@echo "compiler launch script can be found here: compiler/build/install/compiler-shadow/bin/prog8c"
+	$(GRADLE) build
+	@echo "compiler launch script can be found here: compiler/build/install/prog8c-shadow/bin/prog8c"
 

QWEN.md

@@ -1,86 +0,0 @@
-# Qwen Assistant Memory for prog8 Project
-
-This file contains project-specific information that helps the Qwen assistant understand and work effectively with the prog8 codebase.
-
-## Project Overview
-- This project is a compiler for the Prog8 programming language.
-- Prog8 is a programming language primarily targeting 8-bit retro systems with the 6502 CPU, such as the Commodore 64, Commodore 128, and Commander X16.
-- The compiler has a 6502 code generator backend, and an IR code generator.
-- The IR code is meant to be used in a new machine specific code generator backend (primarily 6502 but maybe 68000 as well later)
-- The compiler includes a simple 'virtual machine' that can execute the IR code directly via interpretation.
-- Prog8 source files have .p8 extension
-- Prog8 source files are a "module" that can contain 1 ore more "blocks". They can also import other modules, from internal library files or from source files on the filesystem.
-- The prog8 compiler is written mostly in Kotlin, those files have the .kt extension.
-
-## Prog8 language feature hints
-- an overview of the language features can be found in the documentation file docs/source/introduction.rst
-- the syntax and grammar is specified in an ANTLR4 grammar file found in the parser directory
-- the syntax for boolean logical operators is 'and', 'or', 'xor', 'not'. Bitwise operators are '&', '|', '^', '~', and '<<','>>' for bit shifting left and right respectively. All operators are documents in docs/source/programming.rst
-- note that Prog8 does have a 4-byte signed long type and 5-byte "Microsoft" floating point support
-- module imports are done using "%import modulename"
-
-## Module Descriptions
-- `beanshell` - EXPERIMENTAL/UNFINISHED Contains BeanShell integration for scripting capabilities within the compiler
-- `benchmark-c` - C implementations for performance comparison and benchmarking
-- `benchmark-program` - Benchmark programs to test compiler output performance
-- `codeCore` - Core code generation utilities and shared components
-- `codeGenCpu6502` - 6502 CPU-specific code generator backend (generates assembly for 6502-based systems)
-- `codeGenExperimental` - Experimental code generators that are under development
-- `codeGenIntermediate` - Intermediate representation (IR) code generator
-- `codeGenVirtual` - Virtual machine code generator backend
-- `codeOptimizers` - Optimization passes for improving generated code efficiency
-- `compiler` - Main compiler executable and top-level compiler logic
-- `compilerAst` - complicated Abstract Syntax Tree (AST) where most optimizations also run on, is later transformed into the simpleAst
-- `docs` - Documentation files for the Prog8 language and compiler
-- `examples` - Example Prog8 programs demonstrating language features
-- `intermediate` - Components related to the intermediate representation (IR) of Prog8 programs
-- `languageServer` - Language Server Protocol implementation for IDE integration
-- `parser` - ANTLR4 Parser implementation for the Prog8 language syntax
-- `scripts` - Utility scripts for development, testing, and deployment
-- `simpleAst` - Simplified AST that is used to run the code generator backends from
-- `syntax-files` - Syntax definition files for editors and IDEs
-- `virtualmachine` - Virtual machine implementation that can execute IR code
-
-## Key Information
-- never read the files and directories that are ignored via the .aiignore and .gitignore files
-- Current development focus areas: compiler optimizations, new language features, backend improvements
-- Important project conventions: Kotlin for compiler implementation, modular architecture, IR-based compilation
-- Architecture decisions: separation of frontend/parser, IR intermediate representation, multiple backends
-
-### Gradle Commands
-- use the system installed gradle command instead of the gradle wrapper.
-- `gradle build` - Full build of the compiler including running the full test suite
-- `gradle clean` - Clean build artifacts
-- `gradle compileKotlin` - Compile only the Kotlin source code
-- `gradle installdist` - Create the compiler JARs and executable file
-- `gradle installshadowdist` - Create the single "fat" compiler JAR and executable file
-
-### Development Shortcuts
-- `gradle test --tests "*TestName*"` - Run specific test classes
-- `gradle build --refresh-dependencies` - Refresh dependencies during development
-
-### Prog8 Compiler Usage
-- the prog8c compiler executable can be found in the compiler/build/install/prog8c/bin folder (this is already added to the shell's path)
-- the `-emu` switch can be used to directly execute the resulting program in an emulator after successful compilation.
-- `prog8c -target cx16 input.p8` - Compile a Prog8 source file "input.p8" for the CommanderX16 target
-- `prog8c -target cx16 -check input.p8` - Quickly check a Prog8 source file "input.p8" for compiler errors, no output binary is produced
-- `prog8c -target cx16 -emu  input.p8` - Compile and execute a prog8 file in the CommanderX16 emulator
-- `prog8c -target c64 -emu input.p8` - Compile and execute a prog8 file in the Commodore-64 emulator
-- `prog8c -target virtual input.p8` - Compile a prog8 file for the IR/Virtual machine target
-- `prog8c -target virtual -emu input.p8` - Compile and directly execute a prog8 file in the Virtual Machine
-- `prog8c -vm input.p8ir` - Execute an existing prog8 program, compiled in IR form, in the Virtual Machine
-- `x16emu -scale 2 -prg input.prg` - Just load an existing compiled program in the CommanderX16 emulator
-- `x64sc input.prg` - run an existing compiled program in the Commodore-64 emulator (Note: You can safely ignore errors and warnings from this emulator)
-
-### Compilation Output Files
-- `*.prg` - The final compiled program file for the target system (e.g., Commander X16)
-- `*.asm` - Generated assembly code from the Prog8 source
-- `*.list` - Generated full assembly listing file from the Prog8 source
-- `*.p8ir` - Intermediate representation file, can be executed in the Virtual Machine
-- `*.vice-mon-list` - Vice emulator monitor list file for debugging
-
-## Working Notes
-[Any ongoing notes about the project that would be helpful for the assistant to remember]
-
-## TODO Items
-The file docs/source/todo.rst contains a comprehensive list of things that still have to be fixed, implemented, or optimized.

README.md

@@ -15,10 +15,12 @@ which aims to provide many conveniences over raw assembly code (even when using
 
 **Want to buy me a coffee or a pizza perhaps?**
 
-This project was created over the last couple of years by dedicating thousands of hours of my free time to it, to make it the best I possibly can.
+This project was created over the last couple of years by dedicating a huge amount of my free time to it, to make it the best I possibly can.
 If you like Prog8, and think it's worth a nice cup of hot coffee or a delicious pizza, 
 you can help me out a little bit over at [ko-fi.com/irmen](https://ko-fi.com/irmen) or [PayPal](https://paypal.me/irmendejong)
 
+[![JetBrains logo.](https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.svg)](https://jb.gg/OpenSource)
+ I am using JetBrains products to develop the Prog8 compiler.
 
 Documentation
 -------------
@@ -63,8 +65,10 @@ What does Prog8 provide?
 - programs run very fast because it's compiled to native machine code
 - 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.
+- Can make vars and routines private, as a simple way to restrict access and hide implementation details
 - various data types other than just bytes (16-bit words, long integers, floats, strings)
 - Structs and typed pointers
+- 2D arrays (`matrix[row][col]` syntax)
 - floating point math is supported on certain targets
 - access to most Kernal ROM routines as external subroutine definitions you can call normally
 - tight control over Zeropage usage
@@ -90,7 +94,7 @@ What does Prog8 provide?
 *Rapid edit-compile-run-debug cycle:*
 
 - use a modern PC to do the work on, use nice editors and enjoy quick compilation times
-- can automatically run the program in the Vice emulator after succesful compilation
+- can automatically run the program in the Vice emulator after successful compilation
 - breakpoints, that let the Vice emulator drop into the monitor if execution hits them
 - source code labels automatically loaded in Vice emulator so it can show them in disassembly
 
@@ -109,8 +113,8 @@ Additional required tools
 -------------------------
 
 [64tass](https://sourceforge.net/projects/tass64/) - cross assembler. Install this on your shell path.
-A recent .exe version of this tool for Windows can be obtained from my [clone](https://github.com/irmen/64tass/releases) of this project.
-For other platforms it is very easy to compile it yourself (make ; make install).
+If you're on Windows, download a recent .exe from the official repository's file section <https://sourceforge.net/projects/tass64/files/binaries/>.
+For other systems (Mac, Linux) it is very easy to get it via your package manager or to compile it yourself.
 
 A **Java runtime (jre or jdk), version 11 or newer**  is required to run a prepackaged version of the compiler.
 If you want to build it from source, you'll need a Java SDK + Kotlin 1.3.x SDK (or for instance,
@@ -205,3 +209,10 @@ Here is a performance comparison with various C compilers for the 6502/C64 so yo
 an idea of how Prog8 stacks up.
 
 [comparison](benchmark-c/benchmark.md)
+
+
+Agent context instructions
+--------------------------
+
+[Agent context instructions](AGENTS.md)
+

beanshell/beanshell.iml

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <excludeFolder url="file://$MODULE_DIR$/build" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="library" name="jetbrains.kotlinx.cli.jvm" level="project" />
-    <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/bsh-3.0.0-SNAPSHOT.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-  </component>
-</module>

beanshell/build.gradle.kts

@@ -1,65 +0,0 @@
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-
-plugins {
-    id("application")
-    kotlin("jvm")
-}
-
-val serverMainClassName = "prog8lsp.MainKt"
-val applicationName = "prog8-beanshell"
-
-application {
-    mainClass.set(serverMainClassName)
-    description = "Code completions, diagnostics and more for Prog8"
-    // applicationDefaultJvmArgs = listOf("-DkotlinLanguageServer.version=$version")
-    applicationDistribution.into("bin") {
-        filePermissions {
-            user {
-                read=true
-                execute=true
-                write=true
-            }
-            other.execute = true
-            group.execute = true
-        }
-    }
-}
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    implementation(files("lib/bsh-3.0.0-SNAPSHOT.jar"))
-}
-
-configurations.forEach { config ->
-    config.resolutionStrategy {
-        preferProjectModules()
-    }
-}
-
-sourceSets.main {
-    java.srcDir("src")
-    resources.srcDir("resources")
-}
-
-tasks.startScripts {
-    applicationName = "prog8-beanshell"
-}
-
-tasks.register<Exec>("fixFilePermissions") {
-    // When running on macOS or Linux the start script
-    // needs executable permissions to run.
-
-    onlyIf { !System.getProperty("os.name").lowercase().contains("windows") }
-    commandLine("chmod", "+x", "${tasks.installDist.get().destinationDir}/bin/prog8-beanshell")
-}
-
-tasks.installDist {
-    finalizedBy("fixFilePermissions")
-}
-
-tasks.build {
-    finalizedBy("installDist")
-}

beanshell/src/prog8beanshell/CommandLineReader.kt

@@ -1,48 +0,0 @@
-package prog8beanshell
-
-import java.io.FilterReader
-import java.io.Reader
-
-
-class CommandLineReader(val input: Reader): FilterReader(input)  {
-    private val normal = 0
-    private val lastCharNL = 1
-    private val sentSemi = 2
-    private var state = lastCharNL
-
-    override fun read(): Int {
-        if (state == sentSemi) {
-            this.state = lastCharNL
-            return 10
-        } else {
-            var b = input.read()
-            while(b==13) b = input.read()
-
-            if (b == 10) {
-                if (this.state == lastCharNL) {
-                    b = 59
-                    this.state = sentSemi
-                } else {
-                    this.state = lastCharNL
-                }
-            } else {
-                this.state = normal
-            }
-
-            return b
-        }
-
-    }
-
-    override fun read(buff: CharArray, off: Int, len: Int): Int {
-        val b = read()
-        if (b == -1) {
-            return -1
-        } else {
-            buff[off] = b.toChar()
-            return 1
-        }
-
-    }
-}
-

beanshell/src/prog8beanshell/Main.kt

@@ -1,23 +0,0 @@
-package prog8beanshell
-
-import bsh.FileReader
-import bsh.Interpreter
-
-
-class BeanshellInterpreter {
-
-    fun run(symbols: Map<String, Any>) {
-        val interpreter = Interpreter(CommandLineReader(FileReader(System.`in`)), System.out, System.err, true)
-        interpreter.setExitOnEOF(false)
-        symbols.forEach { (name, value) -> interpreter.set(name, value) }
-        interpreter.run()
-    }
-}
-
-fun main(args: Array<String>) {
-    val i = BeanshellInterpreter()
-    i.run(mapOf(
-        "env" to System.getenv(),
-        "args" to args
-    ))
-}

benchmark-program/b_btree.p8

@@ -113,14 +113,14 @@ btree {
         sub count_node(^^Node r) {
             count++
             if r.left!=0 {
-                sys.pushw(r)
+                pushw(r)
                 count_node(r.left)
-                r = sys.popw()
+                r = popw()
             }
             if r.right!=0 {
-                sys.pushw(r)
+                pushw(r)
                 count_node(r.right)
-                r = sys.popw()
+                r = popw()
             }
         }
     }
@@ -179,15 +179,15 @@ btree {
 
         sub process_tree(^^Node r) {
             if r.left!=0 {
-                sys.pushw(r)
+                pushw(r)
                 process_tree(r.left)
-                r = sys.popw()
+                r = popw()
             }
             cx16.r0 = r.value
             if r.right!=0 {
-                sys.pushw(r)
+                pushw(r)
                 process_tree(r.right)
-                r = sys.popw()
+                r = popw()
             }
         }
     }
@@ -200,18 +200,18 @@ btree {
         sub process_tree(^^Node r, ubyte depth) {
             cx16.r0 = r.value
             if r.left!=0 {
-                sys.pushw(r)
-                sys.push(depth)
+                pushw(r)
+                push(depth)
                 process_tree(r.left, depth+1)
-                depth = sys.pop()
-                r = sys.popw()
+                depth = pop()
+                r = popw()
             }
             if r.right!=0 {
-                sys.pushw(r)
-                sys.push(depth)
+                pushw(r)
+                push(depth)
                 process_tree(r.right, depth+1)
-                depth = sys.pop()
-                r = sys.popw()
+                depth = pop()
+                r = popw()
             }
         }
     }

benchmark-program/b_life.p8

@@ -61,8 +61,7 @@ life {
         math.rndseed(12345,9999)
         uword offset = STRIDE+1
         ubyte x
-        ubyte y
-        for y in 0 to HEIGHT-1 {
+        repeat HEIGHT {
             for x in 0 to WIDTH-1 {
                 active_world[offset+x] = math.rnd() & 1
             }

benchmark-program/b_queens.p8

@@ -35,12 +35,12 @@ queens {
             if could_place(row, col) {
                 board[row] = col
                 ; we need to save the local variables row and col.
-                sys.push(row)
-                sys.push(col)
+                push(row)
+                push(col)
                 continue_running = place_queen(row + 1)
                 ; restore the local variables after the recursive call.
-                col = sys.pop()
-                row = sys.pop()
+                col = pop()
+                row = pop()
                 board[row] = 0
 
                 if not continue_running

build.gradle.kts

@@ -1,11 +1,9 @@
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.dsl.JvmDefaultMode
-import org.jetbrains.kotlin.gradle.internal.config.LanguageFeature
-import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 
 plugins {
-    kotlin("jvm") version "2.3.0"
+    kotlin("jvm") version "2.4.10"
 }
 
 allprojects {
@@ -14,12 +12,13 @@ allprojects {
     repositories {
         mavenLocal()
         mavenCentral()
+        maven { url = uri("https://jitpack.io") }
     }
 
     kotlin {
         compilerOptions {
             freeCompilerArgs = listOf()
-            jvmTarget = JvmTarget.JVM_11
+            jvmTarget = JvmTarget.JVM_17
             jvmDefault = JvmDefaultMode.NO_COMPATIBILITY
             // languageVersion.set(KotlinVersion.KOTLIN_2_3)
         }
@@ -32,7 +31,75 @@ allprojects {
     }
 
     java {
-        targetCompatibility = JavaVersion.VERSION_11
-        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_17
+        sourceCompatibility = JavaVersion.VERSION_17
+    }
+}
+
+// ============================================================================
+// Common Configuration for All Subprojects
+// ============================================================================
+// This avoids duplication in each module's build.gradle.kts
+// ============================================================================
+
+subprojects {
+    // Common dependency exclusions for all subprojects
+    // Note: antlr4 exclusion is done per-module since parser module needs it
+    configurations.all {
+        exclude(group = "com.ibm.icu", module = "icu4j")
+    }
+
+    // Common test dependencies via Kotest BOM (Bill of Materials)
+    // This manages all Kotest module versions centrally
+    dependencies {
+        testImplementation(platform("io.kotest:kotest-bom:6.2.3"))
+        // implementation("com.github.irmen:ksim65:v2.1")
+    }
+
+    // Common sourceSets configuration
+    sourceSets {
+        main {
+            java.srcDir("${project.projectDir}/src")
+            resources.srcDir("${project.projectDir}/res")
+        }
+        test {
+            java.srcDir("${project.projectDir}/test")
+        }
+    }
+
+    // Common test configuration
+    tasks.withType<Test>().configureEach {
+        // Enable JUnit 5 (required for Kotest)
+        useJUnitPlatform()
+
+        // Enable concurrent test execution for Kotest
+        // Set parallelism to number of CPU cores
+        jvmArgs("-Dkotest.framework.parallelism=${Runtime.getRuntime().availableProcessors()}")
+
+        // Disable Kotest autoscan warning
+        jvmArgs("-Dkotest.framework.classpath.scanning.autoscan.disable=true")
+
+        // Enable Gradle's parallel test execution (runs multiple test classes concurrently)
+        // Use 50% of available processors to avoid over-subscription
+        maxParallelForks = (Runtime.getRuntime().availableProcessors() / 2).coerceAtLeast(1)
+
+        // Allow filtering tests via -PtestFilter="*TestName*" from command line
+        // Example: gradle test -PtestFilter="*TestLookup*"
+        val testFilter = project.findProperty("testFilter")?.toString()
+        if(testFilter != null) {
+            filter {
+                includeTestsMatching(testFilter)
+            }
+        }
+
+        // Show test results - only show failures to reduce noise
+        testLogging {
+            events("failed")
+            // Show full exception details for failures
+            exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
+            showExceptions = true
+            showCauses = true
+            showStackTraces = true
+        }
     }
 }

codeCore/build.gradle.kts

@@ -1,22 +1,11 @@
 plugins {
     kotlin("jvm")
+    `java-test-fixtures`
 }
 
 dependencies {
     // should have no dependencies to other modules
-    // implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
-    implementation("com.michael-bull.kotlin-result:kotlin-result-jvm:2.1.0")
-}
+    implementation("com.michael-bull.kotlin-result:kotlin-result-jvm:2.3.1")
 
-sourceSets {
-    main {
-        java {
-            srcDir("${project.projectDir}/src")
-        }
-        resources {
-            srcDir("${project.projectDir}/res")
-        }
-    }
+    testImplementation("io.kotest:kotest-runner-junit5")
 }
-
-// note: there are no unit tests in this module!

codeCore/codeCore.iml

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <excludeFolder url="file://$MODULE_DIR$/build" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
-  </component>
-</module>

codeCore/src/prog8/code/Globals.kt

@@ -29,4 +29,23 @@ fun Path.sanitize(): Path {
     } catch (iox: IOException) {
         throw FileSystemException(this.toFile()).also { it.initCause(iox) }
     }
-}
+}
+
+
+object SymbolNames {
+    /**
+     * Strips Prog8 symbol prefixes (p8b_, p8t_, p8s_, p8v_, p8l_, p8c_) from a scoped name.
+     * Example: "p8b_plane.p8t_Point" -> "plane.Point"
+     * Used to compare names across different contexts where prefixes may or may not be applied.
+     * See https://github.com/irmen/prog8/issues/198
+     */
+    fun stripPrefixes(scopedName: String): String {
+        return scopedName.split('.')
+            .map { part ->
+                if(part.length > 4 && part.startsWith("p8") && part[2].isLetter() && part[3] == '_')
+                    part.drop(4)
+                else part
+            }
+            .joinToString(".")
+    }
+}

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

@@ -30,40 +30,48 @@ private val NumericDatatypes = arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, Ba
 
 
 class FSignature(val pure: Boolean,      // does it have side effects?
-                 val returnType: BaseDataType?,
+                 val returnTypes: Array<BaseDataType>,
                  vararg val parameters: FParam) {
 
     fun callConvention(actualParamTypes: List<BaseDataType>): CallConvention {
-        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)
-            BaseDataType.FLOAT -> ReturnConvention(returnType, RegisterOrPair.FAC1)
-            in IterableDatatypes -> ReturnConvention(returnType!!, RegisterOrPair.AY)
-            null -> ReturnConvention(null, null)
-            else -> {
-                // return type depends on arg type
-                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)
-                    BaseDataType.FLOAT -> ReturnConvention(paramType, RegisterOrPair.FAC1)
-                    in IterableDatatypes -> ReturnConvention(paramType, RegisterOrPair.AY)
-                    else -> ReturnConvention(paramType, null)
+        val returns: ReturnConvention
+        if(returnTypes.isEmpty())
+            returns = ReturnConvention(null, null)
+        else if(returnTypes.size==1) {
+            val returnType = returnTypes[0]
+            returns = when (returnType) {
+                BaseDataType.UBYTE, BaseDataType.BYTE -> ReturnConvention(returnType, RegisterOrPair.A)
+                BaseDataType.UWORD, BaseDataType.WORD -> ReturnConvention(returnType, RegisterOrPair.AY)
+                BaseDataType.LONG -> ReturnConvention(returnType, RegisterOrPair.R14R15)
+                BaseDataType.FLOAT -> ReturnConvention(returnType, RegisterOrPair.FAC1)
+                in IterableDatatypes -> ReturnConvention(returnType, RegisterOrPair.AY)
+                else -> {
+                    // return type depends on arg type
+                    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)
+                        BaseDataType.FLOAT -> ReturnConvention(paramType, RegisterOrPair.FAC1)
+                        in IterableDatatypes -> ReturnConvention(paramType, RegisterOrPair.AY)
+                        else -> ReturnConvention(paramType, null)
+                    }
                 }
             }
+        } else {
+            // note: this path is currently never hit because the builtin functions with multiple return values have been handled in specialized optimized codegens already earlier.
+            TODO("multiple return types from builtin function")
         }
 
         return when {
             actualParamTypes.isEmpty() -> CallConvention(emptyList(), returns)
             actualParamTypes.size==1 -> {
-                // One parameter goes via register/registerpair.
+                // One parameter goes via register/registerpair (except longs)
                 // this avoids repeated code for every caller to store the value in the subroutine's argument variable.
                 // (that store is still done, but only coded once at the start at the subroutine itself rather than at every call site).
                 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, false)
+                    BaseDataType.LONG -> ParamConvention(paramType, null, true)
                     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)
@@ -89,96 +97,102 @@ 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, BaseDataType.LONG), FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
-    "setmsb"  to FSignature(false, null, FParam("variable", BaseDataType.WORD, BaseDataType.UWORD, BaseDataType.LONG), FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
-    "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)),
-    "prog8_lib_structalloc"       to FSignature(true, BaseDataType.UWORD),
-    "prog8_lib_copylong"          to FSignature(false, null, FParam("pointer1", BaseDataType.UWORD), FParam("pointer2", BaseDataType.UWORD)),
-    "prog8_lib_copyfloat"         to FSignature(false, null, FParam("pointer1", BaseDataType.UWORD), FParam("pointer2", BaseDataType.UWORD)),
-    "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())),
-    "offsetof"      to FSignature(true, BaseDataType.UBYTE, FParam("field", BaseDataType.UBYTE)),
-    "sgn"           to FSignature(true, BaseDataType.BYTE, FParam("value", *NumericDatatypes)),
-    "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)),
-    "swap"          to FSignature(false, null, FParam("var1", *NumericDatatypes + BaseDataType.BOOL), FParam("var2", *NumericDatatypes + BaseDataType.BOOL)),
-    "swap__byte"    to FSignature(false, null, FParam("var1", BaseDataType.BYTE, BaseDataType.UBYTE, BaseDataType.BOOL), FParam("var2",BaseDataType.BYTE, BaseDataType.UBYTE, BaseDataType.BOOL)),
-    "swap__word"    to FSignature(false, null, FParam("var1", BaseDataType.WORD, BaseDataType.UWORD), FParam("var2",BaseDataType.WORD, BaseDataType.UWORD)),
-    "swap__long"    to FSignature(false, null, FParam("var1", BaseDataType.LONG), FParam("var2",BaseDataType.LONG)),
-    "swap__float"   to FSignature(false, null, FParam("var1", BaseDataType.FLOAT), FParam("var2",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)),
-    "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, 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, 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)),
-    "rsave"         to FSignature(false, null),
-    "rrestore"      to FSignature(false, null),
-    "memory"        to FSignature(true, BaseDataType.UWORD, FParam("name", BaseDataType.STR), FParam("size", BaseDataType.UWORD), FParam("alignment", BaseDataType.UWORD)),
-    "callfar"       to FSignature(false, BaseDataType.UWORD, FParam("bank", BaseDataType.UBYTE), FParam("address", BaseDataType.UWORD), FParam("arg", BaseDataType.UWORD)),
-    "callfar2"      to FSignature(false, BaseDataType.UWORD, FParam("bank", BaseDataType.UBYTE), FParam("address", BaseDataType.UWORD), FParam("argA", BaseDataType.UBYTE), FParam("argX", BaseDataType.UBYTE), FParam("argY", BaseDataType.UBYTE), FParam("argC", BaseDataType.BOOL)),
-    "call"          to FSignature(false, BaseDataType.UWORD, FParam("address", BaseDataType.UWORD)),
+    "setlsb"  to FSignature(false, emptyArray(), FParam("variable", BaseDataType.WORD, BaseDataType.UWORD, BaseDataType.LONG), FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
+    "setmsb"  to FSignature(false, emptyArray(), FParam("variable", BaseDataType.WORD, BaseDataType.UWORD, BaseDataType.LONG), FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
+    "rol"     to FSignature(false, emptyArray(), FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD, BaseDataType.LONG)),
+    "ror"     to FSignature(false, emptyArray(), FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD, BaseDataType.LONG)),
+    "rol2"    to FSignature(false, emptyArray(), FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD, BaseDataType.LONG)),
+    "ror2"    to FSignature(false, emptyArray(), FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD, BaseDataType.LONG)),
+    "cmp"     to FSignature(false, emptyArray(), 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, arrayOf(BaseDataType.BYTE), FParam("str1", BaseDataType.STR), FParam("str2", BaseDataType.STR)),
+    "prog8_lib_square_byte"       to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
+    "prog8_lib_square_word"       to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("value", BaseDataType.WORD, BaseDataType.UWORD)),
+    "prog8_lib_square_long"       to FSignature(true, arrayOf(BaseDataType.LONG), FParam("value", BaseDataType.LONG)),
+    "prog8_lib_structalloc"       to FSignature(true, arrayOf(BaseDataType.UWORD)),
+    "prog8_lib_copylong"          to FSignature(false, emptyArray(), FParam("pointer1", BaseDataType.UWORD), FParam("pointer2", BaseDataType.UWORD)),
+    "prog8_lib_copyfloat"         to FSignature(false, emptyArray(), FParam("pointer1", BaseDataType.UWORD), FParam("pointer2", BaseDataType.UWORD)),
+    "abs"           to FSignature(true, arrayOf(BaseDataType.UNDEFINED), FParam("value", *NumericDatatypes)),
+    "abs__byte"     to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("value", BaseDataType.BYTE)),
+    "abs__word"     to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("value", BaseDataType.WORD)),
+    "abs__long"     to FSignature(true, arrayOf(BaseDataType.LONG), FParam("value", BaseDataType.LONG)),
+    "abs__float"    to FSignature(true, arrayOf(BaseDataType.FLOAT), FParam("value", BaseDataType.FLOAT)),
+    "len"           to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("values", *IterableDatatypes)),
+    "sizeof"        to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("object", *(BaseDataType.entries - BaseDataType.STRUCT_INSTANCE).toTypedArray())),
+    "offsetof"      to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("field", BaseDataType.UBYTE)),
+    "sgn"           to FSignature(true, arrayOf(BaseDataType.BYTE), FParam("value", *NumericDatatypes)),
+    "sqrt"          to FSignature(true, arrayOf(BaseDataType.UNDEFINED), FParam("value", *NumericDatatypes)),
+    "sqrt__ubyte"   to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("value", BaseDataType.UBYTE)),
+    "sqrt__uword"   to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("value", BaseDataType.UWORD)),
+    "sqrt__long"    to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("value", BaseDataType.LONG)),
+    "sqrt__float"   to FSignature(true, arrayOf(BaseDataType.FLOAT), FParam("value", BaseDataType.FLOAT)),
+    "divmod"        to FSignature(false, arrayOf(BaseDataType.UNDEFINED, BaseDataType.UNDEFINED), FParam("dividend", BaseDataType.UBYTE, BaseDataType.UWORD), FParam("divisor", BaseDataType.UBYTE, BaseDataType.UWORD)),
+    "divmod__ubyte" to FSignature(false, arrayOf(BaseDataType.UBYTE, BaseDataType.UBYTE), FParam("dividend", BaseDataType.UBYTE), FParam("divisor", BaseDataType.UBYTE)),
+    "divmod__uword" to FSignature(false, arrayOf(BaseDataType.UWORD, BaseDataType.UWORD), FParam("dividend", BaseDataType.UWORD), FParam("divisor", BaseDataType.UWORD)),
+    "divmod__byte"  to FSignature(false, arrayOf(BaseDataType.BYTE, BaseDataType.BYTE), FParam("dividend", BaseDataType.BYTE), FParam("divisor", BaseDataType.BYTE)),
+    "divmod__word"  to FSignature(false, arrayOf(BaseDataType.WORD, BaseDataType.WORD), FParam("dividend", BaseDataType.WORD), FParam("divisor", BaseDataType.WORD)),
+    "lmh"           to FSignature(true, arrayOf(BaseDataType.UBYTE, BaseDataType.UBYTE, BaseDataType.UBYTE), FParam("value", BaseDataType.LONG)),
+    "lsb"           to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
+    "lsb__long"     to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("value", BaseDataType.LONG)),
+    "msb"           to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
+    "msb__long"     to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("value", BaseDataType.LONG)),
+    "lsw"           to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
+    "msw"           to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
+    "mkword"        to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("msb", BaseDataType.UBYTE), FParam("lsb", BaseDataType.UBYTE)),
+    "mklong"        to FSignature(true, arrayOf(BaseDataType.LONG), FParam("msb", BaseDataType.UBYTE), FParam("b2", BaseDataType.UBYTE), FParam("b1", BaseDataType.UBYTE), FParam("lsb", BaseDataType.UBYTE)),
+    "mklong2"       to FSignature(true, arrayOf(BaseDataType.LONG), FParam("msw", BaseDataType.UWORD), FParam("lsw", BaseDataType.UWORD)),
+    "clamp"         to FSignature(true, arrayOf(BaseDataType.UNDEFINED), FParam("value", BaseDataType.BYTE), FParam("minimum", BaseDataType.BYTE), FParam("maximum", BaseDataType.BYTE)),
+    "clamp__byte"   to FSignature(true, arrayOf(BaseDataType.BYTE), FParam("value", BaseDataType.BYTE), FParam("minimum", BaseDataType.BYTE), FParam("maximum", BaseDataType.BYTE)),
+    "clamp__ubyte"  to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("value", BaseDataType.UBYTE), FParam("minimum", BaseDataType.UBYTE), FParam("maximum", BaseDataType.UBYTE)),
+    "clamp__word"   to FSignature(true, arrayOf(BaseDataType.WORD), FParam("value", BaseDataType.WORD), FParam("minimum", BaseDataType.WORD), FParam("maximum", BaseDataType.WORD)),
+    "clamp__uword"  to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("value", BaseDataType.UWORD), FParam("minimum", BaseDataType.UWORD), FParam("maximum", BaseDataType.UWORD)),
+    "clamp__long"   to FSignature(true, arrayOf(BaseDataType.LONG), FParam("value", BaseDataType.LONG), FParam("minimum", BaseDataType.LONG), FParam("maximum", BaseDataType.LONG)),
+    "min"           to FSignature(true, arrayOf(BaseDataType.UNDEFINED), FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
+    "min__byte"     to FSignature(true, arrayOf(BaseDataType.BYTE), FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
+    "min__ubyte"    to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("val1", BaseDataType.UBYTE), FParam("val2", BaseDataType.UBYTE)),
+    "min__word"     to FSignature(true, arrayOf(BaseDataType.WORD), FParam("val1", BaseDataType.WORD), FParam("val2", BaseDataType.WORD)),
+    "min__uword"    to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("val1", BaseDataType.UWORD), FParam("val2", BaseDataType.UWORD)),
+    "min__long"     to FSignature(true, arrayOf(BaseDataType.LONG), FParam("val1", BaseDataType.LONG), FParam("val2", BaseDataType.LONG)),
+    "max"           to FSignature(true, arrayOf(BaseDataType.UNDEFINED), FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
+    "max__byte"     to FSignature(true, arrayOf(BaseDataType.BYTE), FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
+    "max__ubyte"    to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("val1", BaseDataType.UBYTE), FParam("val2", BaseDataType.UBYTE)),
+    "max__word"     to FSignature(true, arrayOf(BaseDataType.WORD), FParam("val1", BaseDataType.WORD), FParam("val2", BaseDataType.WORD)),
+    "max__uword"    to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("val1", BaseDataType.UWORD), FParam("val2", BaseDataType.UWORD)),
+    "max__long"     to FSignature(true, arrayOf(BaseDataType.LONG), FParam("val1", BaseDataType.LONG), FParam("val2", BaseDataType.LONG)),
+    "peek"          to FSignature(true, arrayOf(BaseDataType.UBYTE), FParam("address", BaseDataType.UWORD)),
+    "peekbool"      to FSignature(true, arrayOf(BaseDataType.BOOL), FParam("address", BaseDataType.UWORD)),
+    "peekw"         to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("address", BaseDataType.UWORD)),
+    "peekl"         to FSignature(true, arrayOf(BaseDataType.LONG), FParam("address", BaseDataType.UWORD)),
+    "peekf"         to FSignature(true, arrayOf(BaseDataType.FLOAT), FParam("address", BaseDataType.UWORD)),
+    "poke"          to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.UBYTE, BaseDataType.BYTE)),
+    "pokebool"      to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.BOOL)),
+    "pokebowl"      to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.BOOL)),
+    "pokew"         to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.UWORD, BaseDataType.WORD)),
+    "pokel"         to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.LONG)),
+    "pokef"         to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.FLOAT)),
+    "pokemon"       to FSignature(false, arrayOf(BaseDataType.UBYTE), FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.UBYTE)),
+    "rsave"         to FSignature(false, emptyArray()),
+    "rrestore"      to FSignature(false, emptyArray()),
+    "memory"        to FSignature(true,  arrayOf(BaseDataType.UWORD), FParam("name", BaseDataType.STR), FParam("size", BaseDataType.UWORD), FParam("alignment", BaseDataType.UWORD)),
+    "memory__ref"   to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("name", BaseDataType.STR)),
+    "callfar"       to FSignature(false, arrayOf(BaseDataType.UWORD), FParam("bank", BaseDataType.UBYTE), FParam("address", BaseDataType.UWORD), FParam("arg", BaseDataType.UWORD)),
+    "callfar2"      to FSignature(false, arrayOf(BaseDataType.UWORD), FParam("bank", BaseDataType.UBYTE), FParam("address", BaseDataType.UWORD), FParam("argA", BaseDataType.UBYTE), FParam("argX", BaseDataType.UBYTE), FParam("argY", BaseDataType.UBYTE), FParam("argC", BaseDataType.BOOL)),
+    "call"          to FSignature(false, arrayOf(BaseDataType.UWORD), FParam("address", BaseDataType.UWORD)),
+    "push"          to FSignature(false, emptyArray(), FParam("value", BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.BOOL)),
+    "pushw"         to FSignature(false, emptyArray(), FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.POINTER)),
+    "pushl"         to FSignature(false, emptyArray(), FParam("value", BaseDataType.LONG)),
+    "pushf"         to FSignature(false, emptyArray(), FParam("value", BaseDataType.FLOAT)),
+    "pop"           to FSignature(false, arrayOf(BaseDataType.UBYTE)),
+    "popw"          to FSignature(false, arrayOf(BaseDataType.UWORD)),
+    "popl"          to FSignature(false, arrayOf(BaseDataType.LONG)),
+    "popf"          to FSignature(false, arrayOf(BaseDataType.FLOAT)),
 )
 
 val InplaceModifyingBuiltinFunctions = setOf(
     "setlsb", "setmsb",
-    "rol", "ror", "rol2", "ror2",
-    "divmod", "divmod__ubyte", "divmod__uword",
-    "swap", "swap__byte", "swap__word", "swap__long", "swap__float"
+    "rol", "ror", "rol2", "ror2"
 )
 
 val SimpleBuiltinFunctions = setOf(
     "msb", "lsb", "msw", "lsw",
     "mkword", "mklong", "mklong2",
-    "set_carry", "set_irqd", "clear_carry", "clear_irqd")
+    "set_carry", "set_irqd", "clear_carry", "clear_irqd")

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

@@ -25,7 +25,6 @@ class CompilationOptions(val output: OutputType,
                          var includeSourcelines: Boolean = false,
                          var dumpVariables: Boolean = false,
                          var dumpSymbols: Boolean = false,
-                         var experimentalCodegen: Boolean = false,
                          var varsHighBank: Int? = null,
                          var varsGolden: Boolean = false,
                          var slabsHighBank: Int? = null,
@@ -34,6 +33,7 @@ class CompilationOptions(val output: OutputType,
                          var ignoreFootguns: Boolean = false,
                          var outputDir: Path = Path(""),
                          var quiet: Boolean = false,
+                         var profilingInstrumentation: Boolean = false,
                          var symbolDefs: Map<String, String> = emptyMap()
 ) {
     init {
@@ -42,5 +42,79 @@ class CompilationOptions(val output: OutputType,
 
     companion object {
         val AllZeropageAllowed: List<UIntRange> = listOf(0u..255u)
+
+        fun builder(compTarget: ICompilationTarget) = Builder(compTarget)
+
+        class Builder(private val compTarget: ICompilationTarget) {
+            private var output: OutputType = compTarget.defaultOutputType
+            private var launcher: CbmPrgLauncherType = CbmPrgLauncherType.NONE
+            private var zeropage: ZeropageType = ZeropageType.DONTUSE
+            private var zpReserved: List<UIntRange> = emptyList()
+            private var zpAllowed: List<UIntRange> = AllZeropageAllowed
+            private var floats: Boolean = false
+            private var noSysInit: Boolean = false
+            private var romable: Boolean = false
+            private var compilerVersion: String = "unknown"
+            private var loadAddress: UInt = compTarget.PROGRAM_LOAD_ADDRESS
+            private var memtopAddress: UInt = compTarget.PROGRAM_MEMTOP_ADDRESS
+            private var warnSymbolShadowing: Boolean = false
+            private var warnImplicitTypeCast: Boolean = false
+            private var optimize: Boolean = false
+            private var asmQuiet: Boolean = false
+            private var asmListfile: Boolean = false
+            private var includeSourcelines: Boolean = false
+            private var dumpVariables: Boolean = false
+            private var dumpSymbols: Boolean = false
+            private var varsHighBank: Int? = null
+            private var varsGolden: Boolean = false
+            private var slabsHighBank: Int? = null
+            private var slabsGolden: Boolean = false
+            private var breakpointCpuInstruction: String? = null
+            private var ignoreFootguns: Boolean = false
+            private var outputDir: Path = Path("")
+            private var quiet: Boolean = false
+            private var profilingInstrumentation: Boolean = false
+            private var symbolDefs: Map<String, String> = emptyMap()
+
+            fun output(output: OutputType) = apply { this.output = output }
+            fun launcher(launcher: CbmPrgLauncherType) = apply { this.launcher = launcher }
+            fun zeropage(zeropage: ZeropageType) = apply { this.zeropage = zeropage }
+            fun zpReserved(zpReserved: List<UIntRange>) = apply { this.zpReserved = zpReserved }
+            fun zpAllowed(zpAllowed: List<UIntRange>) = apply { this.zpAllowed = zpAllowed }
+            fun floats(floats: Boolean) = apply { this.floats = floats }
+            fun noSysInit(noSysInit: Boolean) = apply { this.noSysInit = noSysInit }
+            fun romable(romable: Boolean) = apply { this.romable = romable }
+            fun compilerVersion(compilerVersion: String) = apply { this.compilerVersion = compilerVersion }
+            fun loadAddress(loadAddress: UInt) = apply { this.loadAddress = loadAddress }
+            fun memtopAddress(memtopAddress: UInt) = apply { this.memtopAddress = memtopAddress }
+            fun warnSymbolShadowing(warnSymbolShadowing: Boolean) = apply { this.warnSymbolShadowing = warnSymbolShadowing }
+            fun warnImplicitTypeCast(warnImplicitTypeCast: Boolean) = apply { this.warnImplicitTypeCast = warnImplicitTypeCast }
+            fun optimize(optimize: Boolean) = apply { this.optimize = optimize }
+            fun asmQuiet(asmQuiet: Boolean) = apply { this.asmQuiet = asmQuiet }
+            fun asmListfile(asmListfile: Boolean) = apply { this.asmListfile = asmListfile }
+            fun includeSourcelines(includeSourcelines: Boolean) = apply { this.includeSourcelines = includeSourcelines }
+            fun dumpVariables(dumpVariables: Boolean) = apply { this.dumpVariables = dumpVariables }
+            fun dumpSymbols(dumpSymbols: Boolean) = apply { this.dumpSymbols = dumpSymbols }
+            fun varsHighBank(varsHighBank: Int?) = apply { this.varsHighBank = varsHighBank }
+            fun varsGolden(varsGolden: Boolean) = apply { this.varsGolden = varsGolden }
+            fun slabsHighBank(slabsHighBank: Int?) = apply { this.slabsHighBank = slabsHighBank }
+            fun slabsGolden(slabsGolden: Boolean) = apply { this.slabsGolden = slabsGolden }
+            fun breakpointCpuInstruction(breakpointCpuInstruction: String?) = apply { this.breakpointCpuInstruction = breakpointCpuInstruction }
+            fun ignoreFootguns(ignoreFootguns: Boolean) = apply { this.ignoreFootguns = ignoreFootguns }
+            fun outputDir(outputDir: Path) = apply { this.outputDir = outputDir }
+            fun quiet(quiet: Boolean) = apply { this.quiet = quiet }
+            fun profilingInstrumentation(profilingInstrumentation: Boolean) = apply { this.profilingInstrumentation = profilingInstrumentation }
+            fun symbolDefs(symbolDefs: Map<String, String>) = apply { this.symbolDefs = symbolDefs }
+
+            fun build(): CompilationOptions {
+                return CompilationOptions(
+                    output, launcher, zeropage, zpReserved, zpAllowed, floats, noSysInit, romable, compTarget, compilerVersion,
+                    loadAddress, memtopAddress, warnSymbolShadowing, warnImplicitTypeCast, optimize, asmQuiet, asmListfile,
+                    includeSourcelines, dumpVariables, dumpSymbols, varsHighBank, varsGolden,
+                    slabsHighBank, slabsGolden, breakpointCpuInstruction, ignoreFootguns, outputDir, quiet,
+                    profilingInstrumentation, symbolDefs
+                )
+            }
+        }
     }
 }

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

@@ -98,3 +98,24 @@ fun String.unescape(): String {
     }
     return result.joinToString("")
 }
+
+// === Symbol name prefixing ===
+// These are used by code generators to add p8b_/p8s_/p8v_/etc. prefixes to symbol names.
+// The prefix character depends on the symbol type (block='b', sub='s', variable='v', etc.)
+// Scoped names (containing dots) have each part prefixed according to its role.
+
+fun prefixScopedName(name: String, type: Char): String {
+    val generatedPrefix = "p8_label_gen_"
+    if('.' !in name) {
+        if(name.startsWith(generatedPrefix))
+            return name
+        return "p8${type}_$name"
+    }
+    val parts = name.split('.')
+    val firstPrefixed = "p8b_${parts[0]}"
+    val lastPart = parts.last()
+    val lastPrefixed = if(lastPart.startsWith(generatedPrefix)) lastPart else "p8${type}_$lastPart"
+    val inbetweenPrefixed = parts.drop(1).dropLast(1).map{ "p8s_$it" }
+    val prefixed = listOf(firstPrefixed) + inbetweenPrefixed + listOf(lastPrefixed)
+    return prefixed.joinToString(".")
+}

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

@@ -0,0 +1,449 @@
+package prog8.code.core
+
+import java.util.*
+
+
+/**
+ * Base data types supported by the Prog8 compiler.
+ * These represent the fundamental types that can be used in Prog8 programs.
+ */
+enum class BaseDataType {
+    UBYTE,              // pass by value            8 bits unsigned
+    BYTE,               // pass by value            8 bits signed
+    UWORD,              // pass by value            16 bits unsigned
+    WORD,               // pass by value            16 bits signed
+    LONG,               // pass by value            32 bits signed
+    FLOAT,              // pass by value            machine dependent
+    BOOL,               // pass by value            bit 0 of an 8-bit byte
+    STR,                // pass by reference
+    ARRAY,              // pass by reference, subtype is the element type
+    ARRAY_SPLITW,       // pass by reference, split word layout, subtype is the element type (restricted to word types)
+    POINTER,            // typed pointer, subtype is whatever type is pointed to
+    STRUCT_INSTANCE,    // the actual instance of a struct (not directly supported in the language yet, but we need its type)
+    ARRAY_POINTER,      // array of pointers (uwords), subtype is whatever type each element points to
+    UNDEFINED;
+
+
+    fun largerSizeThan(other: BaseDataType) =
+        when {
+            this == other -> false
+            this.isByteOrBool -> false
+            this.isWord -> other.isByteOrBool
+            this == LONG -> other.isByteOrBool || other.isWord
+            this == STR && other == UWORD || this == UWORD && other == STR -> false
+            this.isArray && other.isArray -> false
+            this.isArray -> other.isByteOrBool
+            this == STR -> other.isByteOrBool
+            this.isPointer -> other.isByteOrBool
+            else -> true
+        }
+
+    fun equalsSize(other: BaseDataType) =
+        when {
+            this == other -> true
+            this.isArray && other.isArray -> true
+            this.isByteOrBool -> other.isByteOrBool
+            this.isWord -> other.isWord || other.isPointer
+            this.isPointer -> other.isWord
+            this == STR && other== UWORD || this== UWORD && other== STR -> true
+            this == STR && other.isArray -> true
+            this.isArray && other == STR -> true
+            else -> false
+        }
+}
+
+
+// ============================================================================
+// BaseDataType Extension Properties
+// ============================================================================
+
+val BaseDataType.isByte get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE)
+val BaseDataType.isUnsignedByte get() = this == BaseDataType.UBYTE
+val BaseDataType.isSignedByte get() = this == BaseDataType.BYTE
+val BaseDataType.isBool get() = this == BaseDataType.BOOL
+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.isUnsignedWord get() = this == BaseDataType.UWORD
+val BaseDataType.isSignedWord get() = this == BaseDataType.WORD
+val BaseDataType.isLong get() = this == BaseDataType.LONG
+val BaseDataType.isFloat get() = this == BaseDataType.FLOAT
+val BaseDataType.isInteger get() = this in setOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)
+val BaseDataType.isIntegerOrBool get() = this in setOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.BOOL)
+val BaseDataType.isWordOrByteOrBool get() = this in setOf(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 setOf(BaseDataType.BYTE, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
+val BaseDataType.isUnsigned get() = !this.isSigned
+val BaseDataType.isSignedInteger get() = this.isSigned && this.isInteger
+val BaseDataType.isUnsignedInteger get() = this.isUnsigned && this.isInteger
+val BaseDataType.isArray get() = this == BaseDataType.ARRAY || this == BaseDataType.ARRAY_SPLITW || this == BaseDataType.ARRAY_POINTER
+val BaseDataType.isPointer get() = this == BaseDataType.POINTER
+val BaseDataType.isStructInstance get() = this == BaseDataType.STRUCT_INSTANCE
+val BaseDataType.isPointerArray get() = this == BaseDataType.ARRAY_POINTER
+val BaseDataType.isSplitWordArray get() = this == BaseDataType.ARRAY_SPLITW || this == BaseDataType.ARRAY_POINTER       // pointer arrays are also always stored as split uwords
+val BaseDataType.isIterable get() =  this in setOf(BaseDataType.STR, BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW, BaseDataType.ARRAY_POINTER)
+val BaseDataType.isPassByRef get() = this.isIterable && !this.isPointer
+val BaseDataType.isPassByValue get() = !this.isIterable || this.isPointer
+
+
+/**
+ * Interface for types that can be used as subtypes in DataType.
+ * Primarily used for struct types.
+ */
+interface ISubType {
+    val scopedNameString: String
+    fun memsize(sizer: IMemSizer): Int
+    fun sameas(other: ISubType): Boolean
+    fun getFieldType(name: String): DataType?
+}
+
+
+/**
+ * Represents a complete data type in Prog8, including base type and optional subtype.
+ * 
+ * DataType is immutable after construction. Use the companion object factory methods
+ * to create instances.
+ * 
+ * @property base The base data type (e.g., UBYTE, WORD, ARRAY, POINTER)
+ * @property sub The subtype for arrays and strings (e.g., UBYTE for byte arrays)
+ * @property subType The structured subtype for pointers and struct instances
+ * @property subTypeFromAntlr Deferred subtype resolution from parser
+ */
+class DataType private constructor(
+    val base: BaseDataType,
+    val sub: BaseDataType?,
+    var subType: ISubType?,
+    var subTypeFromAntlr: List<String>? = null
+) {
+
+    init {
+        when {
+            base.isPointerArray -> {
+                require(sub!=null || subType!=null || subTypeFromAntlr!=null)
+            }
+            base.isArray -> {
+                require(sub != null && subType==null && subTypeFromAntlr==null)
+                if(base.isSplitWordArray)
+                    require(sub == BaseDataType.UWORD || sub == BaseDataType.WORD)
+            }
+            base==BaseDataType.STR -> require(sub==BaseDataType.UBYTE) { "string subtype should be ubyte" }
+            base!=BaseDataType.POINTER -> require(sub == null) { "only string, array and pointer base types can have a subtype"}
+            else -> {
+                require(sub == null || (subType == null && subTypeFromAntlr == null)) {
+                    "sub and subtype can't both be set"
+                }
+            }
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is DataType) return false
+        return base == other.base && sub == other.sub && (subType==other.subType || subType!!.sameas(other.subType!!))
+    }
+
+    override fun hashCode(): Int = Objects.hash(base, sub, subType)
+
+    fun setActualSubType(actualSubType: ISubType) {
+        subType = actualSubType
+        subTypeFromAntlr = null
+    }
+
+    // ============================================================================
+    // Companion Object - Factory Methods
+    // ============================================================================
+    
+    companion object {
+
+        val UBYTE = DataType(BaseDataType.UBYTE, null, null)
+        val BYTE = DataType(BaseDataType.BYTE, null, null)
+        val UWORD = DataType(BaseDataType.UWORD, null, null)
+        val WORD = DataType(BaseDataType.WORD, null, null)
+        val LONG = DataType(BaseDataType.LONG, null, null)
+        val FLOAT = DataType(BaseDataType.FLOAT, null, null)
+        val BOOL = DataType(BaseDataType.BOOL, null, null)
+        val STR = DataType(BaseDataType.STR, BaseDataType.UBYTE, null)
+        val UNDEFINED = DataType(BaseDataType.UNDEFINED, null, null)
+
+        private val simpletypes = mapOf(
+            BaseDataType.UBYTE to DataType(BaseDataType.UBYTE, null, null),
+            BaseDataType.BYTE to DataType(BaseDataType.BYTE, null, null),
+            BaseDataType.UWORD to DataType(BaseDataType.UWORD, null, null),
+            BaseDataType.WORD to DataType(BaseDataType.WORD, null, null),
+            BaseDataType.LONG to DataType(BaseDataType.LONG, null, null),
+            BaseDataType.FLOAT to DataType(BaseDataType.FLOAT, null, null),
+            BaseDataType.BOOL to DataType(BaseDataType.BOOL, null, null),
+            BaseDataType.STR to DataType(BaseDataType.STR, BaseDataType.UBYTE, null),
+            BaseDataType.UNDEFINED to DataType(BaseDataType.UNDEFINED, null, null)
+        )
+
+        fun forDt(dt: BaseDataType): DataType {
+            if(dt.isStructInstance)
+                TODO("cannot use struct instance as a data type (yet) - use a pointer instead")
+            return simpletypes.getValue(dt)
+        }
+
+        fun arrayFor(elementDt: BaseDataType, splitwordarray: Boolean=true): DataType {
+            require(!elementDt.isPointer) { "use other array constructor for arrays of pointers" }
+            val actualElementDt = if(elementDt==BaseDataType.STR) BaseDataType.UWORD else elementDt      // array of strings is actually just an array of UWORD pointers
+            return if(splitwordarray && actualElementDt.isWord)
+                DataType(BaseDataType.ARRAY_SPLITW, actualElementDt, null)
+            else {
+                if(actualElementDt.isNumericOrBool)
+                    DataType(BaseDataType.ARRAY, actualElementDt, null)
+                else
+                    throw NoSuchElementException("invalid basic element dt $elementDt")
+            }
+        }
+
+        fun arrayOfPointersTo(sub: BaseDataType): DataType = DataType(BaseDataType.ARRAY_POINTER, sub, null)
+        fun arrayOfPointersTo(structType: ISubType?): DataType = DataType(BaseDataType.ARRAY_POINTER, null, structType)
+        fun arrayOfPointersFromAntlrTo(sub: BaseDataType?, identifier: List<String>?): DataType =
+            DataType(BaseDataType.ARRAY_POINTER, sub, null, identifier)
+
+        fun pointer(base: BaseDataType): DataType = DataType(BaseDataType.POINTER, base, null)
+        fun pointer(dt: DataType): DataType = if(dt.isBasic)
+                DataType(BaseDataType.POINTER, dt.base, null)
+            else
+                DataType(BaseDataType.POINTER, null, dt.subType, dt.subTypeFromAntlr)
+        fun pointer(structType: ISubType): DataType = DataType(BaseDataType.POINTER, null, structType)
+        fun pointerFromAntlr(identifier: List<String>): DataType = DataType(BaseDataType.POINTER, null, null, identifier)
+        fun structInstance(type: ISubType?): DataType = DataType(BaseDataType.STRUCT_INSTANCE, sub=null, type)
+        fun structInstanceFromAntlr(struct: List<String>): DataType = DataType(BaseDataType.STRUCT_INSTANCE, null, null, subTypeFromAntlr = struct)
+    }
+
+
+    // ============================================================================
+    // DataType Methods
+    // ============================================================================
+
+    fun elementToArray(splitwords: Boolean = true): DataType {
+        return if (base == BaseDataType.UWORD || base == BaseDataType.WORD || base == BaseDataType.STR) arrayFor(base, splitwords)
+        else if(base.isPointer) {
+            if(subType!=null) arrayOfPointersTo(subType)
+            else if(subTypeFromAntlr!=null) arrayOfPointersFromAntlrTo(sub, subTypeFromAntlr)
+            else arrayOfPointersTo(sub!!)
+        }
+        else arrayFor(base, false)
+    }
+
+    fun elementType(): DataType =
+        when {
+            isPointerArray -> DataType(BaseDataType.POINTER, sub, subType)
+            base.isArray || base==BaseDataType.STR -> forDt(sub!!)
+            else -> throw IllegalArgumentException("not an array")
+        }
+
+    fun typeForAddressOf(msb: Boolean): DataType {
+        if (isUndefined)
+            return if(msb) pointer(BaseDataType.UBYTE) else UWORD
+        else {
+            if (isBasic)
+                return pointer(base)
+            if (isString)
+                return pointer(BaseDataType.UBYTE)
+            if (isPointer)
+                return UWORD
+            if (isArray) {
+                if (msb || isSplitWordArray)
+                    return pointer(BaseDataType.UBYTE)
+                val elementDt = elementType()
+                require(elementDt.isBasic)
+                return pointer(elementDt)
+            }
+            if (subType != null)
+                return pointer(this)
+            return UWORD
+        }
+    }
+
+    fun dereference(): DataType {
+        require(isPointer || isUnsignedWord) { "cannot dereference non-pointer type ${this}"}
+        return when {
+            isUnsignedWord -> forDt(BaseDataType.UBYTE)
+            sub!=null -> forDt(sub)
+            subType!=null -> DataType(BaseDataType.STRUCT_INSTANCE, null, subType)
+            subTypeFromAntlr!=null -> DataType(BaseDataType.STRUCT_INSTANCE, null, null, subTypeFromAntlr)
+            else -> throw IllegalArgumentException("cannot dereference this pointer type")
+        }
+    }
+
+    override fun toString(): String = when(base) {
+        BaseDataType.ARRAY -> {
+            when(sub) {
+                BaseDataType.BOOL -> "bool[]"
+                BaseDataType.FLOAT -> "float[]"
+                BaseDataType.BYTE -> "byte[]"
+                BaseDataType.WORD -> "word[]"
+                BaseDataType.UBYTE -> "ubyte[]"
+                BaseDataType.UWORD -> "uword[]"
+                BaseDataType.LONG -> "long[]"
+                else -> throw IllegalArgumentException("invalid sub type")
+            }
+        }
+        BaseDataType.ARRAY_SPLITW -> {
+            when(sub) {
+                BaseDataType.WORD -> "word[] (split)"
+                BaseDataType.UWORD -> "uword[] (split)"
+                else -> throw IllegalArgumentException("invalid sub type")
+            }
+        }
+        BaseDataType.POINTER -> {
+            if(sub!=null) "^^${sub.name.lowercase()}" else if(subType!=null) "^^${subType!!.scopedNameString}" else "^^${subTypeFromAntlr}"
+        }
+        BaseDataType.ARRAY_POINTER -> {
+            if(sub!=null) "^^${sub.name.lowercase()}[] (split)" else if (subType!=null) "^^${subType!!.scopedNameString}[] (split)" else "^^${subTypeFromAntlr}[] (split)"
+        }
+        BaseDataType.STRUCT_INSTANCE -> {
+            sub?.name?.lowercase() ?: if (subType!=null) subType!!.scopedNameString else "$subTypeFromAntlr"
+        }
+        else -> base.name.lowercase()
+    }
+
+    fun sourceString(): String = when (base) {
+        BaseDataType.BOOL -> "bool"
+        BaseDataType.UBYTE -> "ubyte"
+        BaseDataType.BYTE -> "byte"
+        BaseDataType.UWORD -> "uword"
+        BaseDataType.WORD -> "word"
+        BaseDataType.LONG -> "long"
+        BaseDataType.FLOAT -> "float"
+        BaseDataType.STR -> "str"
+        BaseDataType.POINTER -> {
+            when {
+                sub!=null -> "^^${sub.name.lowercase()}"
+                subType!=null -> "^^${subType!!.scopedNameString}"
+                subTypeFromAntlr!=null -> "^^${subTypeFromAntlr!!.joinToString(".")}"
+                else -> "?????"
+            }
+        }
+        BaseDataType.STRUCT_INSTANCE -> {
+            when {
+                sub!=null -> sub.name.lowercase()
+                subType!=null -> subType!!.scopedNameString
+                subTypeFromAntlr!=null -> subTypeFromAntlr!!.joinToString(".")
+                else -> "?????"
+            }
+        }
+        BaseDataType.ARRAY_POINTER -> {
+            when {
+                sub!=null -> "^^${sub.name.lowercase()}["
+                subType!=null -> "^^${subType!!.scopedNameString}["
+                subTypeFromAntlr!=null -> "^^${subTypeFromAntlr!!.joinToString(".")}["
+                else -> "????? ["
+            }
+        }
+        BaseDataType.ARRAY -> {
+            when(sub) {
+                BaseDataType.UBYTE -> "ubyte["
+                BaseDataType.UWORD -> "@nosplit uword["
+                BaseDataType.BOOL -> "bool["
+                BaseDataType.BYTE -> "byte["
+                BaseDataType.WORD -> "@nosplit word["
+                BaseDataType.LONG -> "long["
+                BaseDataType.FLOAT -> "float["
+                else -> throw IllegalArgumentException("invalid sub type")
+            }
+        }
+        BaseDataType.ARRAY_SPLITW -> {
+            when(sub) {
+                BaseDataType.UWORD -> "uword["
+                BaseDataType.WORD -> "word["
+                else -> throw IllegalArgumentException("invalid sub type")
+            }
+        }
+        BaseDataType.UNDEFINED -> throw IllegalArgumentException("wrong dt")
+    }
+
+    /**
+     * Check if this type is assignable to the given target type (perhaps via a typecast)
+     * without loss of precision.
+     */
+    infix fun isAssignableTo(targetType: DataType) =
+        when(base) {
+            BaseDataType.BOOL -> targetType.base == BaseDataType.BOOL
+            BaseDataType.UBYTE -> targetType.base in setOf(BaseDataType.UBYTE, BaseDataType.WORD, BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.FLOAT)
+            BaseDataType.BYTE -> targetType.base in setOf(BaseDataType.BYTE, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
+            BaseDataType.UWORD -> targetType.base in setOf(BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.FLOAT, BaseDataType.POINTER, BaseDataType.ARRAY_POINTER)
+            BaseDataType.WORD -> targetType.base in setOf(BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
+            BaseDataType.LONG -> targetType.base in setOf(BaseDataType.LONG, BaseDataType.FLOAT)
+            BaseDataType.FLOAT -> targetType.base in arrayOf(BaseDataType.FLOAT)
+            BaseDataType.STR -> targetType.base in setOf(BaseDataType.STR, BaseDataType.UWORD) || (targetType.isPointer && targetType.sub==BaseDataType.UBYTE)
+            BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW -> targetType.base in setOf(BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW) && targetType.sub == sub
+            BaseDataType.POINTER -> {
+                when {
+                    targetType.base == BaseDataType.UWORD || targetType.base == BaseDataType.LONG -> true
+                    targetType.isPointer -> this.isUnsignedWord || this == targetType
+                    else -> false
+                }
+            }
+            BaseDataType.STRUCT_INSTANCE -> false        // we cannot deal with actual struct instances yet in any shape or form (only getting fields from it)
+            BaseDataType.ARRAY_POINTER -> false
+            BaseDataType.UNDEFINED -> false
+        }
+
+    fun largerSizeThan(other: DataType): Boolean = base.largerSizeThan(other.base)
+    fun equalsSize(other: DataType): Boolean = base.equalsSize(other.base)
+
+    /**
+     * Returns the memory size in bytes.
+     * Note: for pointer types, size() doesn't return the size of the pointer itself
+     * but the size of the thing it points to.
+     */
+    fun size(memsizer: IMemSizer): Int = if(sub!=null) {
+            memsizer.memorySize(sub)
+        } else if(subType!=null) {
+            subType!!.memsize(memsizer)
+        } else {
+            memsizer.memorySize(base)
+        }
+
+    // ============================================================================
+    // DataType Properties
+    // ============================================================================
+
+    val isBasic = sub==null && subType==null && subTypeFromAntlr==null
+    val isUndefined = base == BaseDataType.UNDEFINED
+    val isByte = base.isByte
+    val isUnsignedByte = base == BaseDataType.UBYTE
+    val isSignedByte = base == BaseDataType.BYTE
+    val isByteOrBool = base.isByteOrBool
+    val isWord = base.isWord
+    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
+    val isSigned = base.isSigned
+    val isUnsigned = !base.isSigned
+    val isSignedInteger = isSigned && isInteger
+    val isUnsignedInteger = isUnsigned && isInteger
+    val isArray = base.isArray
+    val isPointer = base.isPointer
+    val isPointerToByte = base.isPointer && sub?.isByteOrBool==true
+    val isPointerToWord = base.isPointer && sub?.isWord==true
+    val isStructInstance = base.isStructInstance
+    val isPointerArray = base.isPointerArray
+    val isBoolArray = base.isArray && !base.isPointerArray && sub == BaseDataType.BOOL
+    val isByteArray = base.isArray && !base.isPointerArray && (sub == BaseDataType.UBYTE || sub == BaseDataType.BYTE)
+    val isUnsignedByteArray = base.isArray && !base.isPointerArray && sub == BaseDataType.UBYTE
+    val isSignedByteArray = base.isArray && !base.isPointerArray && sub == BaseDataType.BYTE
+    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
+    val isFloat = base == BaseDataType.FLOAT
+    val isLong = base == BaseDataType.LONG
+    val isStringly = base == BaseDataType.STR || base == BaseDataType.UWORD || (base == BaseDataType.ARRAY && (sub == BaseDataType.UBYTE || sub == BaseDataType.BYTE))
+    val isSplitWordArray = base.isSplitWordArray
+    val isSplitUnsignedWordArray = base.isSplitWordArray && !base.isPointerArray && sub == BaseDataType.UWORD
+    val isSplitSignedWordArray = base.isSplitWordArray && !base.isPointerArray && sub == BaseDataType.WORD
+    val isIterable =  base.isIterable
+    val isPassByRef = base.isPassByRef
+    val isPassByValue = base.isPassByValue
+}

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

@@ -1,388 +1,5 @@
 package prog8.code.core
 
-import java.util.*
-
-enum class BaseDataType {
-    UBYTE,              // pass by value            8 bits unsigned
-    BYTE,               // pass by value            8 bits signed
-    UWORD,              // pass by value            16 bits unsigned
-    WORD,               // pass by value            16 bits signed
-    LONG,               // pass by value            32 bits signed
-    FLOAT,              // pass by value            machine dependent
-    BOOL,               // pass by value            bit 0 of an 8-bit byte
-    STR,                // pass by reference
-    ARRAY,              // pass by reference, subtype is the element type
-    ARRAY_SPLITW,       // pass by reference, split word layout, subtype is the element type (restricted to word types)
-    POINTER,            // typed pointer, subtype is whatever type is pointed to
-    STRUCT_INSTANCE,    // the actual instance of a struct (not directly supported in the language yet, but we need its type)
-    ARRAY_POINTER,      // array of pointers (uwords), subtype is whatever type each element points to
-    UNDEFINED;
-
-
-    fun largerSizeThan(other: BaseDataType) =
-        when {
-            this == other -> false
-            this.isByteOrBool -> false
-            this.isWord -> other.isByteOrBool
-            this == LONG -> other.isByteOrBool || other.isWord
-            this == STR && other == UWORD || this == UWORD && other == STR -> false
-            this.isArray && other.isArray -> false
-            this.isArray -> other != FLOAT
-            this == STR -> other != FLOAT
-            this.isPointer -> other.isByteOrBool
-            else -> true
-        }
-
-    fun equalsSize(other: BaseDataType) =
-        when {
-            this == other -> true
-            this.isArray && other.isArray -> true
-            this.isByteOrBool -> other.isByteOrBool
-            this.isWord -> other.isWord || other.isPointer
-            this.isPointer -> other.isWord
-            this == STR && other== UWORD || this== UWORD && other== STR -> true
-            this == STR && other.isArray -> true
-            this.isArray && other == STR -> true
-            else -> false
-        }
-}
-
-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.isFloat get() = this == BaseDataType.FLOAT
-val BaseDataType.isInteger get() = this in setOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)
-val BaseDataType.isIntegerOrBool get() = this in setOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.BOOL)
-val BaseDataType.isWordOrByteOrBool get() = this in setOf(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 setOf(BaseDataType.BYTE, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
-val BaseDataType.isArray get() = this == BaseDataType.ARRAY || this == BaseDataType.ARRAY_SPLITW || this == BaseDataType.ARRAY_POINTER
-val BaseDataType.isPointer get() = this == BaseDataType.POINTER
-val BaseDataType.isStructInstance get() = this == BaseDataType.STRUCT_INSTANCE
-val BaseDataType.isPointerArray get() = this == BaseDataType.ARRAY_POINTER
-val BaseDataType.isSplitWordArray get() = this == BaseDataType.ARRAY_SPLITW || this == BaseDataType.ARRAY_POINTER       // pointer arrays are also always stored as split uwords
-val BaseDataType.isIterable get() =  this in setOf(BaseDataType.STR, BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW, BaseDataType.ARRAY_POINTER)
-val BaseDataType.isPassByRef get() = this.isIterable && !this.isPointer
-val BaseDataType.isPassByValue get() = !this.isIterable || this.isPointer
-
-
-interface ISubType {
-    val scopedNameString: String
-    fun memsize(sizer: IMemSizer): Int
-    fun sameas(other: ISubType): Boolean
-    fun getFieldType(name: String): DataType?
-}
-
-class DataType private constructor(val base: BaseDataType, val sub: BaseDataType?, var subType: ISubType?, var subTypeFromAntlr: List<String>?=null) {
-
-    init {
-        when {
-            base.isPointerArray -> {
-                require(sub!=null || subType!=null || subTypeFromAntlr!=null)
-            }
-            base.isArray -> {
-                require(sub != null && subType==null && subTypeFromAntlr==null)
-                if(base.isSplitWordArray)
-                    require(sub == BaseDataType.UWORD || sub == BaseDataType.WORD)
-            }
-            base==BaseDataType.STR -> require(sub==BaseDataType.UBYTE) { "string subtype should be ubyte" }
-            base!=BaseDataType.POINTER -> require(sub == null) { "only string, array and pointer base types can have a subtype"}
-            else -> {
-                require(sub == null || (subType == null && subTypeFromAntlr == null)) {
-                    "sub and subtype can't both be set"
-                }
-            }
-        }
-    }
-
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (other !is DataType) return false
-        return base == other.base && sub == other.sub && (subType==other.subType || subType!!.sameas(other.subType!!))
-    }
-
-    override fun hashCode(): Int = Objects.hash(base, sub, subType)
-
-    fun setActualSubType(actualSubType: ISubType) {
-        subType = actualSubType
-        subTypeFromAntlr = null
-    }
-
-    companion object {
-
-        val UBYTE = DataType(BaseDataType.UBYTE, null, null)
-        val BYTE = DataType(BaseDataType.BYTE, null, null)
-        val UWORD = DataType(BaseDataType.UWORD, null, null)
-        val WORD = DataType(BaseDataType.WORD, null, null)
-        val LONG = DataType(BaseDataType.LONG, null, null)
-        val FLOAT = DataType(BaseDataType.FLOAT, null, null)
-        val BOOL = DataType(BaseDataType.BOOL, null, null)
-        val STR = DataType(BaseDataType.STR, BaseDataType.UBYTE, null)
-        val UNDEFINED = DataType(BaseDataType.UNDEFINED, null, null)
-
-        private val simpletypes = mapOf(
-            BaseDataType.UBYTE to DataType(BaseDataType.UBYTE, null, null),
-            BaseDataType.BYTE to DataType(BaseDataType.BYTE, null, null),
-            BaseDataType.UWORD to DataType(BaseDataType.UWORD, null, null),
-            BaseDataType.WORD to DataType(BaseDataType.WORD, null, null),
-            BaseDataType.LONG to DataType(BaseDataType.LONG, null, null),
-            BaseDataType.FLOAT to DataType(BaseDataType.FLOAT, null, null),
-            BaseDataType.BOOL to DataType(BaseDataType.BOOL, null, null),
-            BaseDataType.STR to DataType(BaseDataType.STR, BaseDataType.UBYTE, null),
-            BaseDataType.UNDEFINED to DataType(BaseDataType.UNDEFINED, null, null)
-        )
-
-        fun forDt(dt: BaseDataType): DataType {
-            if(dt.isStructInstance)
-                TODO("cannot use struct instance as a data type (yet) - use a pointer instead")
-            return simpletypes.getValue(dt)
-        }
-
-        fun arrayFor(elementDt: BaseDataType, splitwordarray: Boolean=true): DataType {
-            require(!elementDt.isPointer) { "use other array constructor for arrays of pointers" }
-            val actualElementDt = if(elementDt==BaseDataType.STR) BaseDataType.UWORD else elementDt      // array of strings is actually just an array of UWORD pointers
-            return if(splitwordarray && actualElementDt.isWord)
-                DataType(BaseDataType.ARRAY_SPLITW, actualElementDt, null)
-            else {
-                if(actualElementDt.isNumericOrBool)
-                    DataType(BaseDataType.ARRAY, actualElementDt, null)
-                else
-                    throw NoSuchElementException("invalid basic element dt $elementDt")
-            }
-        }
-
-        fun arrayOfPointersTo(sub: BaseDataType): DataType = DataType(BaseDataType.ARRAY_POINTER, sub, null)
-        fun arrayOfPointersTo(structType: ISubType?): DataType = DataType(BaseDataType.ARRAY_POINTER, null, structType)
-        fun arrayOfPointersFromAntlrTo(sub: BaseDataType?, identifier: List<String>?): DataType =
-            DataType(BaseDataType.ARRAY_POINTER, sub, null, identifier)
-
-        fun pointer(base: BaseDataType): DataType = DataType(BaseDataType.POINTER, base, null)
-        fun pointer(dt: DataType): DataType = if(dt.isBasic)
-                DataType(BaseDataType.POINTER, dt.base, null)
-            else
-                DataType(BaseDataType.POINTER, null, dt.subType, dt.subTypeFromAntlr)
-        fun pointer(structType: ISubType): DataType = DataType(BaseDataType.POINTER, null, structType)
-        fun pointerFromAntlr(identifier: List<String>): DataType = DataType(BaseDataType.POINTER, null, null, identifier)
-        fun structInstance(type: ISubType?): DataType = DataType(BaseDataType.STRUCT_INSTANCE, sub=null, type)
-        fun structInstanceFromAntlr(struct: List<String>): DataType = DataType(BaseDataType.STRUCT_INSTANCE, null, null, subTypeFromAntlr = struct)
-    }
-
-
-    fun elementToArray(splitwords: Boolean = true): DataType {
-        return if (base == BaseDataType.UWORD || base == BaseDataType.WORD || base == BaseDataType.STR) arrayFor(base, splitwords)
-        else arrayFor(base, false)
-    }
-
-    fun elementType(): DataType =
-        when {
-            isPointerArray -> DataType(BaseDataType.POINTER, sub, subType)
-            base.isArray || base==BaseDataType.STR -> forDt(sub!!)
-            else -> throw IllegalArgumentException("not an array")
-        }
-
-    fun typeForAddressOf(msb: Boolean): DataType {
-        if (isUndefined)
-            return if(msb) pointer(BaseDataType.UBYTE) else UWORD
-        else {
-            if (isBasic)
-                return pointer(base)
-            if (isString)
-                return pointer(BaseDataType.UBYTE)
-            if (isPointer)
-                return UWORD
-            if (isArray) {
-                if (msb || isSplitWordArray)
-                    return pointer(BaseDataType.UBYTE)
-                val elementDt = elementType()
-                require(elementDt.isBasic)
-                return pointer(elementDt)
-            }
-            if (subType != null)
-                return pointer(this)
-            return UWORD
-        }
-    }
-
-    fun dereference(): DataType {
-        require(isPointer || isUnsignedWord)
-        return when {
-            isUnsignedWord -> forDt(BaseDataType.UBYTE)
-            sub!=null -> forDt(sub)
-            subType!=null -> DataType(BaseDataType.STRUCT_INSTANCE, null, subType)
-            subTypeFromAntlr!=null -> DataType(BaseDataType.STRUCT_INSTANCE, null, null, subTypeFromAntlr)
-            else -> throw IllegalArgumentException("cannot dereference this pointer type")
-        }
-    }
-
-    override fun toString(): String = when(base) {
-        BaseDataType.ARRAY -> {
-            when(sub) {
-                BaseDataType.BOOL -> "bool[]"
-                BaseDataType.FLOAT -> "float[]"
-                BaseDataType.BYTE -> "byte[]"
-                BaseDataType.WORD -> "word[]"
-                BaseDataType.UBYTE -> "ubyte[]"
-                BaseDataType.UWORD -> "uword[]"
-                BaseDataType.LONG -> "long[]"
-                else -> throw IllegalArgumentException("invalid sub type")
-            }
-        }
-        BaseDataType.ARRAY_SPLITW -> {
-            when(sub) {
-                BaseDataType.WORD -> "word[] (split)"
-                BaseDataType.UWORD -> "uword[] (split)"
-                else -> throw IllegalArgumentException("invalid sub type")
-            }
-        }
-        BaseDataType.POINTER -> {
-            if(sub!=null) "^^${sub.name.lowercase()}" else if(subType!=null) "^^${subType!!.scopedNameString}" else "^^${subTypeFromAntlr}"
-        }
-        BaseDataType.ARRAY_POINTER -> {
-            if(sub!=null) "^^${sub.name.lowercase()}[] (split)" else if (subType!=null) "^^${subType!!.scopedNameString}[] (split)" else "^^${subTypeFromAntlr}[] (split)"
-        }
-        BaseDataType.STRUCT_INSTANCE -> {
-            sub?.name?.lowercase() ?: if (subType!=null) subType!!.scopedNameString else "$subTypeFromAntlr"
-        }
-        else -> base.name.lowercase()
-    }
-
-    fun sourceString(): String = when (base) {
-        BaseDataType.BOOL -> "bool"
-        BaseDataType.UBYTE -> "ubyte"
-        BaseDataType.BYTE -> "byte"
-        BaseDataType.UWORD -> "uword"
-        BaseDataType.WORD -> "word"
-        BaseDataType.LONG -> "long"
-        BaseDataType.FLOAT -> "float"
-        BaseDataType.STR -> "str"
-        BaseDataType.POINTER -> {
-            when {
-                sub!=null -> "^^${sub.name.lowercase()}"
-                subType!=null -> "^^${subType!!.scopedNameString}"
-                subTypeFromAntlr!=null -> "^^${subTypeFromAntlr!!.joinToString(".")}"
-                else -> "?????"
-            }
-        }
-        BaseDataType.STRUCT_INSTANCE -> {
-            when {
-                sub!=null -> sub.name.lowercase()
-                subType!=null -> subType!!.scopedNameString
-                subTypeFromAntlr!=null -> subTypeFromAntlr!!.joinToString(".")
-                else -> "?????"
-            }
-        }
-        BaseDataType.ARRAY_POINTER -> {
-            when {
-                sub!=null -> "^^${sub.name.lowercase()}["
-                subType!=null -> "^^${subType!!.scopedNameString}["
-                subTypeFromAntlr!=null -> "^^${subTypeFromAntlr!!.joinToString(".")}["
-                else -> "????? ["
-            }
-        }
-        BaseDataType.ARRAY -> {
-            when(sub) {
-                BaseDataType.UBYTE -> "ubyte["
-                BaseDataType.UWORD -> "@nosplit uword["
-                BaseDataType.BOOL -> "bool["
-                BaseDataType.BYTE -> "byte["
-                BaseDataType.WORD -> "@nosplit word["
-                BaseDataType.LONG -> "long["
-                BaseDataType.FLOAT -> "float["
-                else -> throw IllegalArgumentException("invalid sub type")
-            }
-        }
-        BaseDataType.ARRAY_SPLITW -> {
-            when(sub) {
-                BaseDataType.UWORD -> "uword["
-                BaseDataType.WORD -> "word["
-                else -> throw IllegalArgumentException("invalid sub type")
-            }
-        }
-        BaseDataType.UNDEFINED -> throw IllegalArgumentException("wrong dt")
-    }
-
-    // is the type assignable to the given other type (perhaps via a typecast) without loss of precision?
-    infix fun isAssignableTo(targetType: DataType) =
-        when(base) {
-            BaseDataType.BOOL -> targetType.base == BaseDataType.BOOL
-            BaseDataType.UBYTE -> targetType.base in setOf(BaseDataType.UBYTE, BaseDataType.WORD, BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.FLOAT)
-            BaseDataType.BYTE -> targetType.base in setOf(BaseDataType.BYTE, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
-            BaseDataType.UWORD -> targetType.base in setOf(BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.FLOAT, BaseDataType.POINTER, BaseDataType.ARRAY_POINTER)
-            BaseDataType.WORD -> targetType.base in setOf(BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
-            BaseDataType.LONG -> targetType.base in setOf(BaseDataType.LONG, BaseDataType.FLOAT)
-            BaseDataType.FLOAT -> targetType.base in arrayOf(BaseDataType.FLOAT)
-            BaseDataType.STR -> targetType.base in setOf(BaseDataType.STR, BaseDataType.UWORD) || (targetType.isPointer && targetType.sub==BaseDataType.UBYTE)
-            BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW -> targetType.base in setOf(BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW) && targetType.sub == sub
-            BaseDataType.POINTER -> {
-                when {
-                    targetType.base == BaseDataType.UWORD || targetType.base == BaseDataType.LONG -> true
-                    targetType.isPointer -> this.isUnsignedWord || this == targetType
-                    else -> false
-                }
-            }
-            BaseDataType.STRUCT_INSTANCE -> false        // we cannot deal with actual struct instances yet in any shape or form (only getting fields from it)
-            BaseDataType.ARRAY_POINTER -> false
-            BaseDataType.UNDEFINED -> false
-        }
-
-    fun largerSizeThan(other: DataType): Boolean = base.largerSizeThan(other.base)
-    fun equalsSize(other: DataType): Boolean = base.equalsSize(other.base)
-
-    // note: for pointer types, size() doesn't return the size of the pointer itself but the size of the thing it points to
-    fun size(memsizer: IMemSizer): Int = if(sub!=null) {
-            memsizer.memorySize(sub)
-        } else if(subType!=null) {
-            subType!!.memsize(memsizer)
-        } else {
-            memsizer.memorySize(base)
-        }
-
-    val isBasic = sub==null && subType==null && subTypeFromAntlr==null
-    val isUndefined = base == BaseDataType.UNDEFINED
-    val isByte = base.isByte
-    val isUnsignedByte = base == BaseDataType.UBYTE
-    val isSignedByte = base == BaseDataType.BYTE
-    val isByteOrBool = base.isByteOrBool
-    val isWord = base.isWord
-    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
-    val isSigned = base.isSigned
-    val isUnsigned = !base.isSigned
-    val isArray = base.isArray
-    val isPointer = base.isPointer
-    val isPointerToByte = base.isPointer && sub?.isByteOrBool==true
-    val isPointerToWord = base.isPointer && sub?.isWord==true
-    val isStructInstance = base.isStructInstance
-    val isPointerArray = base.isPointerArray
-    val isBoolArray = base.isArray && !base.isPointerArray && sub == BaseDataType.BOOL
-    val isByteArray = base.isArray && !base.isPointerArray && (sub == BaseDataType.UBYTE || sub == BaseDataType.BYTE)
-    val isUnsignedByteArray = base.isArray && !base.isPointerArray && sub == BaseDataType.UBYTE
-    val isSignedByteArray = base.isArray && !base.isPointerArray && sub == BaseDataType.BYTE
-    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
-    val isFloat = base == BaseDataType.FLOAT
-    val isLong = base == BaseDataType.LONG
-    val isStringly = base == BaseDataType.STR || base == BaseDataType.UWORD || (base == BaseDataType.ARRAY && (sub == BaseDataType.UBYTE || sub == BaseDataType.BYTE))
-    val isSplitWordArray = base.isSplitWordArray
-    val isSplitUnsignedWordArray = base.isSplitWordArray && !base.isPointerArray && sub == BaseDataType.UWORD
-    val isSplitSignedWordArray = base.isSplitWordArray && !base.isPointerArray && sub == BaseDataType.WORD
-    val isIterable =  base.isIterable
-    val isPassByRef = base.isPassByRef
-    val isPassByValue = base.isPassByValue
-}
-
 
 enum class CpuRegister {
     A,
@@ -406,7 +23,7 @@ enum class RegisterOrPair {
     R0R1, R2R3, R4R5, R6R7, R8R9, R10R11, R12R13, R14R15;
 
     companion object {
-        val names by lazy { entries.map { it.toString()} }
+        val names: Set<String> = entries.map { it.toString() }.toSet()
         fun fromCpuRegister(cpu: CpuRegister): RegisterOrPair {
             return when(cpu) {
                 CpuRegister.A -> A
@@ -440,12 +57,13 @@ enum class RegisterOrPair {
     }
 
     fun asScopedNameVirtualReg(type: DataType?): List<String> {
-        require(this in Cx16VirtualRegisters)
+        require(this in Cx16VirtualRegisters || this in CombinedLongRegisters)
         val suffix = when(type?.base) {
             BaseDataType.UBYTE, BaseDataType.BOOL -> "L"
             BaseDataType.BYTE -> "sL"
             BaseDataType.WORD -> "s"
             BaseDataType.UWORD, BaseDataType.POINTER, null -> ""
+            BaseDataType.LONG -> "sl"
             else -> throw IllegalArgumentException("invalid register param type for cx16 virtual reg")
         }
         return listOf("cx16", name.lowercase()+suffix)
@@ -463,7 +81,7 @@ enum class Statusflag {
     Pn;     // don't use
 
     companion object {
-        val names by lazy { entries.map { it.toString()} }
+        val names: Set<String> = entries.map { it.toString() }.toSet()
     }
 }
 
@@ -482,14 +100,14 @@ enum class BranchCondition {
     VC
 }
 
-val Cx16VirtualRegisters = arrayOf(
+val Cx16VirtualRegisters = setOf(
     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
 )
 
-val CombinedLongRegisters = arrayOf(
+val CombinedLongRegisters = setOf(
     RegisterOrPair.R0R1,
     RegisterOrPair.R2R3,
     RegisterOrPair.R4R5,
@@ -500,7 +118,7 @@ val CombinedLongRegisters = arrayOf(
     RegisterOrPair.R14R15
 )
 
-val CpuRegisters = arrayOf(
+val CpuRegisters = setOf(
     RegisterOrPair.A, RegisterOrPair.X, RegisterOrPair.Y,
     RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY
 )
@@ -536,4 +154,4 @@ enum class ZeropageWish {
 enum class SplitWish {
     DONTCARE,
     NOSPLIT
-}
+}

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

@@ -2,10 +2,53 @@ package prog8.code.core
 
 import java.nio.file.Path
 
-enum class CpuType {
-    CPU6502,
-    CPU65C02,
-    VIRTUAL
+/**
+ * Identifies the target CPU type and its key characteristics that affect IR semantics.
+ *
+ * The most important property is [statusBitsOnMultiByteOps], which controls the IR
+ * status-bit contract (see IRInstructions.kt for the full spec):
+ *
+ * - When `true`, the IR generator is allowed to skip emitting explicit CMP/CMPI before
+ *   branches that depend on the result of a previous "status-setting" instruction
+ *   (LOAD, INC, DEC, AND, OR, XOR, etc.). The contract is: "this instruction sets
+ *   Z and N based on the full multi-byte value." Backends for these targets must
+ *   honor this contract (e.g., M68000's `move.w #imm,d0` naturally sets Z based on
+ *   the 16-bit value, so the IR can rely on it).
+ *
+ * - When `false`, multi-byte operations on this target do NOT set status bits
+ *   correctly for the full value (e.g., 6502's `dec lo` only sets Z based on the
+ *   low byte of a 16-bit decrement). The IR generator must therefore always emit
+ *   an explicit CMP/CMPI before any branch that depends on the result. Backends
+ *   for these targets should NOT add `ora` postambles to set Z; instead they
+ *   rely on the explicit CMP/CMPI emitted by the IR generator.
+ *
+ *   For 8-bit CPUs (6502, 65C02) the natural status flags from a multi-byte
+ *   cascade are misleading: Z is set based on the LAST byte operated on, not
+ *   the full value. So we treat the contract as "no instruction sets status
+ *   bits except CMP/CMPI/SEC/CLC/SGN/BITTST" and have the IR generator emit
+ *   explicit compares. This avoids the trap of "this works for BYTE but
+ *   silently breaks for WORD/LONG".
+ */
+enum class CpuType(val statusBitsOnMultiByteOps: Boolean) {
+    /** 8-bit NMOS 6502. Multi-byte ops don't set Z based on full value. */
+    CPU6502(false),
+
+    /** 8-bit CMOS 65C02. Same status-bit issue as plain 6502. */
+    CPU65C02(false),
+
+    /**
+     * Virtual machine target. We use `false` here so the IR generator always
+     * emits explicit CMP/CMPI; the VM's setResultReg then does NOT set Z/N
+     * flags (only CMP/CMPI/SEC/CLC/SGN/BITTST do). This matches the VM's
+     * existing documentation (VirtualMachine.kt top comment) and keeps the
+     * behavior consistent across all current targets.
+     */
+    VIRTUAL(false)
+    ;
+
+    /** True for the 6502-family targets (plain 6502 and 65C02). */
+    val is6502: Boolean
+        get() = this == CPU6502 || this == CPU65C02
 }
 
 interface ICompilationTarget: IStringEncoding, IMemSizer {
@@ -13,8 +56,7 @@ interface ICompilationTarget: IStringEncoding, IMemSizer {
 
     val FLOAT_MAX_NEGATIVE: Double
     val FLOAT_MAX_POSITIVE: Double
-    val FLOAT_MEM_SIZE: Int
-    val STARTUP_CODE_RESERVED_SIZE: UInt        // this is here, so that certain compiler targets are able to tune this
+    val FLOAT_MEM_SIZE: UInt
     val PROGRAM_LOAD_ADDRESS : UInt
     val PROGRAM_MEMTOP_ADDRESS: UInt
     val BSSHIGHRAM_START: UInt
@@ -24,11 +66,12 @@ interface ICompilationTarget: IStringEncoding, IMemSizer {
 
     val cpu: CpuType
     var zeropage: Zeropage
-    var golden: GoldenRam
     val libraryPath: Path?
     val customLauncher: List<String>
     val additionalAssemblerOptions: List<String>
     val defaultOutputType: OutputType
+    val defaultLauncherType: CbmPrgLauncherType
+    val supportsBankedCalls: Boolean
 
     fun initializeMemoryAreas(compilerOptions: CompilationOptions)
     fun getFloatAsmBytes(num: Number): String

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

@@ -28,26 +28,21 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
     abstract val SCRATCH_PTR : UInt     // temp storage for a pointer
 
 
-    // the variables allocated into Zeropage.
+    // Collections for zeropage allocation (single-threaded usage)
     // name (scoped) ==> pair of address to (Datatype + bytesize)
     val allocatedVariables = mutableMapOf<String, VarAllocation>()
-
-    val free = mutableListOf<UInt>()     // subclasses must set this to the appropriate free locations.
+    val free = mutableSetOf<UInt>()     // subclasses must set this to the appropriate free locations.
 
     fun removeReservedFromFreePool() {
-        synchronized(this) {
-            for (reserved in options.zpReserved)
-                reserve(reserved)
+        for (reserved in options.zpReserved)
+            reserve(reserved)
 
-            free.removeAll(setOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_W1, SCRATCH_W1 + 1u, SCRATCH_W2, SCRATCH_W2 + 1u, SCRATCH_PTR, SCRATCH_PTR+1u))
-        }
+        free.removeAll(setOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_W1, SCRATCH_W1 + 1u, SCRATCH_W2, SCRATCH_W2 + 1u, SCRATCH_PTR, SCRATCH_PTR+1u))
     }
 
     fun retainAllowed() {
-        synchronized(this) {
-            for(allowed in options.zpAllowed)
-                free.retainAll { it in allowed }
-        }
+        for(allowed in options.zpAllowed)
+            free.retainAll { it in allowed }
     }
 
     fun availableBytes() = if(options.zeropage== ZeropageType.DONTUSE) 0 else free.size
@@ -65,7 +60,7 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
                           position: Position?,
                           errors: IErrorReporter): Result<VarAllocation, MemAllocationError> {
 
-        require(name.isEmpty() || name !in allocatedVariables) {"name can't be allocated twice"}
+        require(name.isEmpty() || !allocatedVariables.containsKey(name)) {"name can't be allocated twice"}
 
         if(options.zeropage== ZeropageType.DONTUSE)
             return Err(MemAllocationError("zero page usage has been disabled"))
@@ -95,19 +90,17 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
                     else -> throw MemAllocationError("weird dt")
                 }
 
-        synchronized(this) {
-            if(free.isNotEmpty()) {
-                if(size==1) {
-                    for(candidate in free.minOrNull()!! .. free.maxOrNull()!!+1u) {
-                        if(oneSeparateByteFree(candidate))
-                            return Ok(VarAllocation(makeAllocation(candidate, 1, datatype, name), datatype,1))
-                    }
-                    return Ok(VarAllocation(makeAllocation(free[0], 1, datatype, name), datatype,1))
-                }
+        if(free.isNotEmpty()) {
+            if(size==1) {
                 for(candidate in free.minOrNull()!! .. free.maxOrNull()!!+1u) {
-                    if (sequentialFree(candidate, size))
-                        return Ok(VarAllocation(makeAllocation(candidate, size, datatype, name), datatype, size))
+                    if(oneSeparateByteFree(candidate))
+                        return Ok(VarAllocation(makeAllocation(candidate, 1, datatype, name), datatype,1))
                 }
+                return Ok(VarAllocation(makeAllocation(free.first(), 1, datatype, name), datatype,1))
+            }
+            for(candidate in free.minOrNull()!! .. free.maxOrNull()!!+1u) {
+                if (sequentialFree(candidate, size))
+                    return Ok(VarAllocation(makeAllocation(candidate, size, datatype, name), datatype, size))
             }
         }
 
@@ -131,43 +124,12 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
         return address
     }
 
-    private fun oneSeparateByteFree(address: UInt) = address in free && address-1u !in free && address+1u !in free
+    private fun oneSeparateByteFree(address: UInt) = 
+        address in free && 
+        (address == 0u || address-1u !in free) && 
+        address+1u !in free
     private fun sequentialFree(address: UInt, size: Int): Boolean {
         require(size>0)
         return free.containsAll((address until address+size.toUInt()).toList())
     }
 }
-
-
-// TODO: this class is not yet used
-class GoldenRam(options: CompilationOptions, val region: UIntRange): MemoryAllocator(options) {
-    private var nextLocation: UInt = region.first
-
-    override fun allocate(
-        name: String,
-        datatype: DataType,
-        numElements: Int?,
-        position: Position?,
-        errors: IErrorReporter): Result<VarAllocation, MemAllocationError> {
-
-        val size: Int =
-            when {
-                datatype.isIntegerOrBool -> options.compTarget.memorySize(datatype, null)
-                datatype.isString -> numElements!!
-                datatype.isArray -> options.compTarget.memorySize(datatype, numElements!!)
-                datatype.isFloat -> {
-                    if (options.floats) {
-                        options.compTarget.memorySize(DataType.FLOAT, null)
-                    } else return Err(MemAllocationError("floating point option not enabled"))
-                }
-                else -> throw MemAllocationError("weird dt")
-            }
-
-        return if(nextLocation<=region.last && (region.last + 1u - nextLocation) >= size.toUInt()) {
-            val result = Ok(VarAllocation(nextLocation, datatype, size))
-            nextLocation += size.toUInt()
-            result
-        } else
-            Err(MemAllocationError("no more free space in Golden RAM to allocate $size sequential bytes"))
-    }
-}

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

@@ -1,6 +1,6 @@
 package prog8.code.core
 
-val AssociativeOperators = setOf("+", "*", "&", "|", "^", "==", "!=", "xor")       // note: and,or are not associative because of Shortcircuit/McCarthy evaluation
+val CommutativeOperators = setOf("+", "*", "&", "|", "^", "==", "!=", "xor")       // note: and,or are not commutative because of Shortcircuit/McCarthy evaluation
 val ComparisonOperators = setOf("==", "!=", "<", ">", "<=", ">=")
 val LogicalOperators = setOf("and", "or", "xor", "not", "in")
 val BitwiseOperators = setOf("&", "|", "^", "~")

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

@@ -4,16 +4,18 @@ import prog8.code.sanitize
 import prog8.code.source.SourceCode
 import java.nio.file.InvalidPathException
 import kotlin.io.path.Path
-import kotlin.io.path.toPath
 
-data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) {
-    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"
-            }
+/**
+ * Source code position.
+ */
+data class Position(
+    val file: String,
+    val line: Int,           // line number (1-based)
+    val startCol: Int,       // start column (1-based, tab-expanded)
+    val endCol: Int          // end column (1-based, tab-expanded)
+) {
+    override fun toString(): String {
+        return "[$file: line $line col ${startCol}-${endCol}]"
     }
 
     fun toClickableStr(): String {
@@ -33,4 +35,4 @@ data class Position(val file: String, val line: Int, val startCol: Int, val endC
     companion object {
         val DUMMY = Position("~dummy~", 0, 0, 0)
     }
-}
+}

codeCore/src/prog8/code/source/ImportFileSystem.kt

@@ -3,23 +3,20 @@ package prog8.code.source
 import prog8.code.core.Position
 import prog8.code.sanitize
 import java.nio.file.Path
-import java.util.*
+import java.util.concurrent.ConcurrentHashMap
 import kotlin.io.path.Path
 
 
 // Resource caching "filesystem".
 // Note that it leaves the decision to load a resource or an actual disk file to the caller.
+// Thread-safe: uses ConcurrentHashMap for all caches.
 
 object ImportFileSystem {
 
-    fun clearCaches() {
-        cache.clear()
-        lineSpanCache.clear()
-    }
+    val userHome: Path get() = Path.of(System.getProperty("user.home"))
 
     fun expandTilde(path: String): String = if (path.startsWith("~")) {
-        val userHome = System.getProperty("user.home")
-        userHome + path.drop(1)
+        userHome.toString() + path.drop(1)
     } else {
         path
     }
@@ -28,45 +25,45 @@ object ImportFileSystem {
 
     fun getFile(path: Path, isLibrary: Boolean=false): SourceCode {
         val normalized = path.sanitize()
-        val cached = cache[normalized.toString()]
-        if (cached != null)
-            return cached
-        val file = SourceCode.File(normalized, isLibrary)
-        cache[normalized.toString()] = file
-        return file
+        return cache.computeIfAbsent(normalized.toString().lowercase()) {
+            SourceCode.File(normalized, isLibrary)
+        }
     }
 
     fun getResource(name: String): SourceCode {
-        val cached = cache[name]
-        if (cached != null) return cached
-        val resource = SourceCode.Resource(name)
-        cache[name] = resource
-        return resource
+        return cache.computeIfAbsent(name.lowercase()) {
+            SourceCode.Resource(name)
+        }
+    }
+
+    fun clearCaches() {
+        cache.clear()
+        lineSpanCache.clear()
     }
 
     fun retrieveSourceLine(position: Position): String {
         if(SourceCode.isLibraryResource(position.file)) {
-            val cached = cache[SourceCode.withoutPrefix(position.file)]
+            val key = SourceCode.withoutPrefix(position.file)
+            val cached = cache[key.lowercase()]
+                ?: runCatching { getResource(key) }.getOrNull()
             if(cached != null)
                 return getLine(cached, position.line)
         }
-        val cached = cache[position.file]
+        val cached = cache[position.file.lowercase()]
         if(cached != null)
             return getLine(cached, position.line)
         val path = Path(position.file).sanitize()
-        val cached2 = cache[path.toString()]
+        val cached2 = cache[path.toString().lowercase()]
         if(cached2 != null)
             return getLine(cached2, position.line)
         throw NoSuchElementException("cannot get source line $position, with path $path")
     }
 
     private fun getLine(code: SourceCode, lineIndex: Int): String {
-        var spans = lineSpanCache[code]
-        if(spans==null) {
+        val spans = lineSpanCache.computeIfAbsent(code) {
             val lineSpans = Regex("^", RegexOption.MULTILINE).findAll(code.text).map { it.range.first }
             val ends = lineSpans.drop(1) + code.text.length
-            spans = lineSpans.zip(ends).map { (start, end) -> LineSpan(start, end) }.toList().toTypedArray()
-            lineSpanCache[code] = spans
+            lineSpans.zip(ends).map { (start, end) -> LineSpan(start, end) }.toList().toTypedArray()
         }
         val span = spans[lineIndex - 1]
         return code.text.substring(span.start, span.end).trim()
@@ -74,6 +71,6 @@ object ImportFileSystem {
 
     private class LineSpan(val start: Int, val end: Int)
 
-    private val cache = TreeMap<String, SourceCode>(String.CASE_INSENSITIVE_ORDER)
-    private val lineSpanCache = mutableMapOf<SourceCode, Array<LineSpan>>()
-}
+    private val cache = ConcurrentHashMap<String, SourceCode>()
+    private val lineSpanCache = ConcurrentHashMap<SourceCode, Array<LineSpan>>()
+}

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

@@ -11,11 +11,13 @@ class C128Target: ICompilationTarget,
     IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE) {
 
     override val name = NAME
+    override val supportsBankedCalls = true
     override val defaultEncoding = Encoding.PETSCII
     override val libraryPath = null
     override val customLauncher = emptyList<String>()
     override val additionalAssemblerOptions = emptyList<String>()
     override val defaultOutputType = OutputType.PRG
+    override val defaultLauncherType = CbmPrgLauncherType.BASIC
 
     companion object {
         const val NAME = "c128"
@@ -26,18 +28,16 @@ class C128Target: ICompilationTarget,
 
     override val FLOAT_MAX_POSITIVE = Mflpt5.FLOAT_MAX_POSITIVE
     override val FLOAT_MAX_NEGATIVE = Mflpt5.FLOAT_MAX_NEGATIVE
-    override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
-    override val STARTUP_CODE_RESERVED_SIZE = 20u
+    override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE.toUInt()
     override val PROGRAM_LOAD_ADDRESS = 0x1c01u
     override val PROGRAM_MEMTOP_ADDRESS = 0xc000u
 
-    override val BSSHIGHRAM_START = 0u    // TODO address?
-    override val BSSHIGHRAM_END = 0u      // TODO address?
-    override val BSSGOLDENRAM_START = 0u  // TODO address?
-    override val BSSGOLDENRAM_END = 0u    // TODO address?
+    override val BSSHIGHRAM_START = 0u      // no high ram
+    override val BSSHIGHRAM_END = 0u        // no high ram
+    override val BSSGOLDENRAM_START = 0x1300u
+    override val BSSGOLDENRAM_END = 0x1bdfu     //  note: $1be0 - $1bff contains the 16 virtual registers
 
     override lateinit var zeropage: Zeropage
-    override lateinit var golden: GoldenRam
 
     override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
 
@@ -71,11 +71,10 @@ class C128Target: ICompilationTarget,
         process.waitFor()
     }
 
-    override fun isIOAddress(address: UInt): Boolean = address==0u || address==1u || address in 0xd000u..0xdfffu
+    override fun isIOAddress(address: UInt): Boolean = address==0u || address==1u || address in 0xd000u..0xdfffu || address in 0xff00u..0xff04u
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = C128Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)    // TODO does the c128 have some of this somewhere?
     }
 
 }

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

@@ -12,11 +12,13 @@ class C64Target: ICompilationTarget,
     IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE) {
 
     override val name = NAME
+    override val supportsBankedCalls = true
     override val defaultEncoding = Encoding.PETSCII
     override val libraryPath = null
     override val customLauncher = emptyList<String>()
     override val additionalAssemblerOptions = emptyList<String>()
     override val defaultOutputType = OutputType.PRG
+    override val defaultLauncherType = CbmPrgLauncherType.BASIC
 
     companion object {
         const val NAME = "c64"
@@ -29,8 +31,7 @@ class C64Target: ICompilationTarget,
 
     override val FLOAT_MAX_POSITIVE = Mflpt5.FLOAT_MAX_POSITIVE
     override val FLOAT_MAX_NEGATIVE = Mflpt5.FLOAT_MAX_NEGATIVE
-    override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
-    override val STARTUP_CODE_RESERVED_SIZE = 20u
+    override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE.toUInt()
     override val PROGRAM_LOAD_ADDRESS = 0x0801u
     override val PROGRAM_MEMTOP_ADDRESS = 0xcfe0u      // $a000  if floats are used
     // note that at $cfe0-$cfff are the 16 'virtual registers' R0-R15
@@ -41,7 +42,6 @@ class C64Target: ICompilationTarget,
     override val BSSGOLDENRAM_END = 0u
 
     override lateinit var zeropage: Zeropage
-    override lateinit var golden: GoldenRam
 
     override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
 
@@ -87,7 +87,6 @@ class C64Target: ICompilationTarget,
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = C64Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)
     }
 
 }

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

@@ -15,16 +15,17 @@ import kotlin.io.path.nameWithoutExtension
 
 class ConfigFileTarget(
     override val name: String,
+    override val supportsBankedCalls: Boolean,
     override val defaultEncoding: Encoding,
     override val cpu: CpuType,
     override val PROGRAM_LOAD_ADDRESS: UInt,
     override val PROGRAM_MEMTOP_ADDRESS: UInt,
-    override val STARTUP_CODE_RESERVED_SIZE: UInt,
     override val BSSHIGHRAM_START: UInt,
     override val BSSHIGHRAM_END: UInt,
     override val BSSGOLDENRAM_START: UInt,
     override val BSSGOLDENRAM_END: UInt,
     override val defaultOutputType: OutputType,
+    override val defaultLauncherType: CbmPrgLauncherType,
     override val libraryPath: Path,
     override val customLauncher: List<String>,
     override val additionalAssemblerOptions: List<String>,
@@ -112,19 +113,26 @@ class ConfigFileTarget(
             val assemblerOptionsStr = props.getProperty("assembler_options", "").trim()
             val outputTypeString = props.getProperty("output_type", "PRG")
             val defaultOutputType = OutputType.valueOf(outputTypeString.uppercase())
+            val launcherString = props.getProperty("launcher", "BASIC")
+            val defaultLauncherType = try {
+                CbmPrgLauncherType.valueOf(launcherString.uppercase())
+            } catch (_: IllegalArgumentException) {
+                CbmPrgLauncherType.BASIC
+            }
 
             return ConfigFileTarget(
                 configfile.nameWithoutExtension,
+                props.getProperty("supports_banked_calls", "false").toBoolean(),
                 Encoding.entries.first { it.prefix==props.getString("encoding") },
                 cpuType,
                 props.getInteger("load_address"),
                 props.getInteger("memtop"),
-                0u,         // used only in a very specific error condition check in a certain scenario...
                 props.getInteger("bss_highram_start"),
                 props.getInteger("bss_highram_end"),
                 props.getInteger("bss_goldenram_start"),
                 props.getInteger("bss_goldenram_end"),
                 defaultOutputType,
+                defaultLauncherType,
                 libraryPath,
                 customLauncher,
                 if(assemblerOptionsStr=="") emptyList() else assemblerOptionsStr.split(" "),
@@ -145,10 +153,9 @@ class ConfigFileTarget(
     // TODO floats are not yet supported here, just enter some values
     override val FLOAT_MAX_POSITIVE = 9.999999999e97
     override val FLOAT_MAX_NEGATIVE = -9.999999999e97
-    override val FLOAT_MEM_SIZE = 8
+    override val FLOAT_MEM_SIZE = 8u
 
     override lateinit var zeropage: Zeropage
-    override lateinit var golden: GoldenRam     // TODO this is not yet used
 
     override fun getFloatAsmBytes(num: Number) = TODO("floats")
     override fun convertFloatToBytes(num: Double): List<UByte> = TODO("floats")
@@ -168,6 +175,5 @@ class ConfigFileTarget(
             zpFullsafe,
             compilerOptions
         )
-        // note: there's no golden ram yet
     }
 }

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

@@ -11,11 +11,13 @@ class Cx16Target: ICompilationTarget,
     IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE) {
 
     override val name = NAME
+    override val supportsBankedCalls = true
     override val defaultEncoding = Encoding.PETSCII
     override val libraryPath = null
     override val customLauncher = emptyList<String>()
     override val additionalAssemblerOptions = emptyList<String>()
     override val defaultOutputType = OutputType.PRG
+    override val defaultLauncherType = CbmPrgLauncherType.BASIC
 
     companion object {
         const val NAME = "cx16"
@@ -26,8 +28,7 @@ class Cx16Target: ICompilationTarget,
 
     override val FLOAT_MAX_POSITIVE = Mflpt5.FLOAT_MAX_POSITIVE
     override val FLOAT_MAX_NEGATIVE = Mflpt5.FLOAT_MAX_NEGATIVE
-    override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
-    override val STARTUP_CODE_RESERVED_SIZE = 20u
+    override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE.toUInt()
     override val PROGRAM_LOAD_ADDRESS = 0x0801u
     override val PROGRAM_MEMTOP_ADDRESS = 0x9f00u
 
@@ -37,7 +38,6 @@ class Cx16Target: ICompilationTarget,
     override val BSSGOLDENRAM_END = 0x07ffu
 
     override lateinit var zeropage: Zeropage
-    override lateinit var golden: GoldenRam
 
     override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
 
@@ -87,7 +87,6 @@ class Cx16Target: ICompilationTarget,
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = CX16Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, BSSGOLDENRAM_START..BSSGOLDENRAM_END)
     }
 
 

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

@@ -30,10 +30,10 @@ internal class NormalMemSizer(val floatsize: Int): IMemSizer {
             dt.isFloat -> floatsize * (numElements ?: 1)
             dt.isLong -> 4 * (numElements ?: 1)
             dt.isPointer -> 2  // pointer is just a uword
-            dt.isStructInstance -> dt.subType!!.memsize(this)
+            dt.isStructInstance -> dt.subType?.memsize(this) ?: 0
             dt.isUndefined -> throw IllegalArgumentException("undefined has no memory size")
             else -> 2 * (numElements ?: 1)
         }
     }
 
-}
+}

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

@@ -11,11 +11,13 @@ class PETTarget: ICompilationTarget,
     IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE) {
 
     override val name = NAME
+    override val supportsBankedCalls = false
     override val defaultEncoding = Encoding.PETSCII
     override val libraryPath = null
     override val customLauncher = emptyList<String>()
     override val additionalAssemblerOptions = emptyList<String>()
     override val defaultOutputType = OutputType.PRG
+    override val defaultLauncherType = CbmPrgLauncherType.BASIC
 
     companion object {
         const val NAME = "pet32"
@@ -25,8 +27,7 @@ class PETTarget: ICompilationTarget,
 
     override val FLOAT_MAX_POSITIVE = Mflpt5.FLOAT_MAX_POSITIVE
     override val FLOAT_MAX_NEGATIVE = Mflpt5.FLOAT_MAX_NEGATIVE
-    override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
-    override val STARTUP_CODE_RESERVED_SIZE = 20u
+    override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE.toUInt()
     override val PROGRAM_LOAD_ADDRESS = 0x0401u
     override val PROGRAM_MEMTOP_ADDRESS = 0x8000u
 
@@ -36,7 +37,6 @@ class PETTarget: ICompilationTarget,
     override val BSSGOLDENRAM_END = 0u
 
     override lateinit var zeropage: Zeropage
-    override lateinit var golden: GoldenRam
 
     override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
 
@@ -74,7 +74,6 @@ class PETTarget: ICompilationTarget,
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = PETZeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)
     }
 
 }

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

@@ -13,11 +13,13 @@ class VMTarget: ICompilationTarget,
     IMemSizer by NormalMemSizer(FLOAT_MEM_SIZE) {
 
     override val name = NAME
+    override val supportsBankedCalls = false
     override val defaultEncoding = Encoding.ISO
     override val libraryPath = null
     override val customLauncher = emptyList<String>()
     override val additionalAssemblerOptions = emptyList<String>()
     override val defaultOutputType = OutputType.PRG
+    override val defaultLauncherType = CbmPrgLauncherType.BASIC
 
     companion object {
         const val NAME = "virtual"
@@ -28,8 +30,7 @@ class VMTarget: ICompilationTarget,
 
     override val FLOAT_MAX_POSITIVE = Double.MAX_VALUE
     override val FLOAT_MAX_NEGATIVE = -Double.MAX_VALUE
-    override val FLOAT_MEM_SIZE = VMTarget.FLOAT_MEM_SIZE
-    override val STARTUP_CODE_RESERVED_SIZE = 0u  // not actually used
+    override val FLOAT_MEM_SIZE = VMTarget.FLOAT_MEM_SIZE.toUInt()
     override val PROGRAM_LOAD_ADDRESS = 0u      // not actually used
     override val PROGRAM_MEMTOP_ADDRESS = 0xffffu  // not actually used
 
@@ -38,7 +39,6 @@ class VMTarget: ICompilationTarget,
     override val BSSGOLDENRAM_START = 0u        // not actually used
     override val BSSGOLDENRAM_END = 0u          // not actually used
     override lateinit var zeropage: Zeropage    // not actually used
-    override lateinit var golden: GoldenRam     // not actually used
 
     override fun getFloatAsmBytes(num: Number): String {
         // little endian binary representation
@@ -69,6 +69,10 @@ class VMTarget: ICompilationTarget,
     }
 
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+        launchEmulatorWithTrace(programNameWithPath, quiet, traceEnabled = false)
+    }
+
+    fun launchEmulatorWithTrace(programNameWithPath: Path, quiet: Boolean, traceEnabled: Boolean) {
         if(!quiet)
             println("\nStarting Virtual Machine...")
 
@@ -76,7 +80,7 @@ class VMTarget: ICompilationTarget,
         val vm = Class.forName("prog8.vm.VmRunner").getDeclaredConstructor().newInstance() as IVirtualMachineRunner
         val withExt = if(programNameWithPath.extension=="p8ir") programNameWithPath else programNameWithPath.resolveSibling("${programNameWithPath.name}.p8ir")
         if(withExt.isReadable())
-            vm.runProgram(withExt.readText(), quiet)
+            vm.runProgram(withExt.readText(), quiet, traceEnabled)
         else
             throw java.nio.file.NoSuchFileException(withExt.name, null, "not a .p8ir file")
     }
@@ -85,14 +89,13 @@ class VMTarget: ICompilationTarget,
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = VirtualZeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)
     }
 }
 
 
 
 interface IVirtualMachineRunner {
-    fun runProgram(irSource: String, quiet: Boolean)
+    fun runProgram(irSource: String, quiet: Boolean, traceEnabled: Boolean = false)
 }
 
 private class VirtualZeropage(options: CompilationOptions): Zeropage(options) {

codeCore/src/prog8/code/target/encodings/PetsciiEncoding.kt

@@ -8,7 +8,7 @@ import java.io.CharConversionException
 object PetsciiEncoding {
 
     // decoding:  from Petscii/Screencodes (0-255) to Unicode
-    // character tables used from https://github.com/irmen/cbmcodecs2
+    // character tables used from https://codeberg.org/irmen/cbmcodecs2.git
 
     private val decodingPetsciiLowercase = charArrayOf(
         '\u0000',    //       0x00 -> \u0000

codeCore/src/prog8/code/target/zp/C128Zeropage.kt

@@ -43,13 +43,13 @@ class C128Zeropage(options: CompilationOptions) : Zeropage(options) {
                     0xb0u, 0xb1u, 0xb4u, 0xb5u, 0xb6u
                 ))
 
-                // if(options.zeropage==ZeropageType.BASICSAFE) {
-                    // can also clobber the FP locations (unconditionally, because the C128 target doesn't support floating point calculations in prog8 at this time0
-                    free.addAll(arrayOf(0x14u, 0x28u, 0x29u, 0x2au, 0x2bu, 0x2cu,
-                        0x50u, 0x51u, 0x52u, 0x53u, 0x54u, 0x59u, 0x5au, 0x5bu, 0x5cu, 0x5du, 0x5eu, 0x5fu, 0x60u, 0x61u, 0x62u,
-                        0x63u, 0x64u, 0x65u, 0x66u, 0x67u, 0x68u,
-                        0x6au, 0x6bu, 0x6cu, 0x6du, 0x6eu, 0x6fu, 0x71u))
-                // }
+                // C128 doesn't support floating point calculations in Prog8, so we can use the FP zeropage locations
+                // for general variables in both BASICSAFE and FLOATSAFE modes.
+                // These addresses are normally used by the C128 BASIC floating point routines.
+                free.addAll(arrayOf(0x14u, 0x28u, 0x29u, 0x2au, 0x2bu, 0x2cu,
+                    0x50u, 0x51u, 0x52u, 0x53u, 0x54u, 0x59u, 0x5au, 0x5bu, 0x5cu, 0x5du, 0x5eu, 0x5fu, 0x60u, 0x61u, 0x62u,
+                    0x63u, 0x64u, 0x65u, 0x66u, 0x67u, 0x68u,
+                    0x6au, 0x6bu, 0x6cu, 0x6du, 0x6eu, 0x6fu, 0x71u))
             }
             ZeropageType.DONTUSE -> {
                 free.clear()  // don't use zeropage at all
@@ -63,7 +63,9 @@ class C128Zeropage(options: CompilationOptions) : Zeropage(options) {
         removeReservedFromFreePool()
 
         if(options.zeropage==ZeropageType.FULL || options.zeropage==ZeropageType.KERNALSAFE) {
-            // in these cases there is enough space on the zero page to stick the cx16 virtual registers in there as well.
+            // C128 DESIGN: Virtual registers are ONLY allocated when sufficient zeropage space exists.
+            // C128 has limited zeropage space in BASICSAFE/FLOATSAFE modes.
+            // Virtual registers are only allocated in FULL and KERNALSAFE modes where space permits.
             allocateCx16VirtualRegisters()
         }
         

codeCore/src/prog8/code/target/zp/C64Zeropage.kt

@@ -9,7 +9,7 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
     override val SCRATCH_REG = 0x03u     // temp storage for a register byte, must be B1+1
     override val SCRATCH_W1 = 0xfbu      // temp storage 1 for a word  $fb+$fc
     override val SCRATCH_W2 = 0xfdu      // temp storage 2 for a word  $fd+$fe
-    override val SCRATCH_PTR = 0x9bu     // temp storage for a pointer $9b+$9c
+    override val SCRATCH_PTR = 0x04u     // temp storage for a pointer $04+$05
 
 
     init {
@@ -57,7 +57,7 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
                 // add the free Zp addresses
                 // these are valid for the C-64 but allow BASIC to keep running fully *as long as you don't use tape I/O*
                 free.addAll(arrayOf(0x02, 0x03, 0x04, 0x05, 0x06, 0x0a, 0x0e,
-                        0x92, 0x96, 0x9b, 0x9c, 0x9e, 0x9f, 0xa6,
+                        0x92, 0x96, 0x9c, 0x9e, 0x9f, 0xa6,
                         0xb0, 0xb1, 0xbe, 0xbf, 0xf9).map{it.toUInt()})
             } else {
                 // don't use the zeropage at all
@@ -72,7 +72,10 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
         removeReservedFromFreePool()
 
         if(options.zeropage==ZeropageType.FULL || options.zeropage==ZeropageType.KERNALSAFE) {
-            // in these cases there is enough space on the zero page to stick the cx16 virtual registers in there as well.
+            // C64 DESIGN: Virtual registers are ONLY allocated when sufficient zeropage space exists.
+            // C64 has limited zeropage space compared to CX16. In BASICSAFE and FLOATSAFE modes,
+            // there isn't enough contiguous space for all 32 bytes of virtual register variants.
+            // Virtual registers are only allocated in FULL and KERNALSAFE modes where space permits.
             allocateCx16VirtualRegisters()
         }
 

codeCore/src/prog8/code/target/zp/CX16Zeropage.kt

@@ -22,41 +22,47 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
 
         // the addresses 0x02 to 0x21 (inclusive) are taken for sixteen virtual 16-bit api registers.
 
-        synchronized(this) {
-            when (options.zeropage) {
-                ZeropageType.FULL -> {
-                    free.addAll(0x22u..0xffu)
-                }
-                ZeropageType.KERNALSAFE -> {
-                    free.addAll(0x22u..0x7fu)
-                    free.addAll(0xa9u..0xffu)
-                }
-                ZeropageType.FLOATSAFE -> {
-                    free.addAll(0x22u..0x7fu)
-                    free.addAll(0xd4u..0xffu)
-                }
-                ZeropageType.BASICSAFE -> {
-                    free.addAll(0x22u..0x7fu)
-                }
-                ZeropageType.DONTUSE -> {
-                    free.clear() // don't use zeropage at all
-                }
+        // Initialize free list - no synchronization needed during construction
+        // (object reference doesn't escape until fully constructed)
+        when (options.zeropage) {
+            ZeropageType.FULL -> {
+                free.addAll(0x22u..0xffu)
+            }
+            ZeropageType.KERNALSAFE -> {
+                free.addAll(0x22u..0x7fu)
+                free.addAll(0xa9u..0xffu)
+            }
+            ZeropageType.FLOATSAFE -> {
+                free.addAll(0x22u..0x7fu)
+                free.addAll(0xd4u..0xffu)
+            }
+            ZeropageType.BASICSAFE -> {
+                free.addAll(0x22u..0x7fu)
+            }
+            ZeropageType.DONTUSE -> {
+                free.clear() // don't use zeropage at all
             }
-
-            val distinctFree = free.distinct()
-            free.clear()
-            free.addAll(distinctFree)
-
-            removeReservedFromFreePool()
-            allocateCx16VirtualRegisters()
-            retainAllowed()
         }
+
+        val distinctFree = free.distinct()
+        free.clear()
+        free.addAll(distinctFree)
+
+        removeReservedFromFreePool()
+        allocateCx16VirtualRegisters()
+        retainAllowed()
     }
 
     private fun allocateCx16VirtualRegisters() {
-        // Note: the 16 virtual registers R0-R15 are not regular allocated variables, they're *memory mapped* elsewhere to fixed addresses.
-        // However, to be able for the compiler to "see" them as zeropage variables, we have to register them here as well.
-        // This is important because the compiler sometimes treats ZP variables more efficiently (for example if it's a pointer)
+        // CX16 DESIGN: Virtual registers are ALWAYS allocated in zeropage for all ZeropageType modes.
+        // The Commander X16 has ample zeropage space (0x22-0x7F in BASICSAFE, up to 0x22-0xFF in FULL),
+        // so virtual registers can always fit. This ensures consistent behavior across all modes.
+        // Virtual registers occupy addresses 0x02-0x21 (32 bytes for r0-r15 variants).
+        //
+        // Note: the 16 virtual registers R0-R15 are not regular allocated variables, they're *memory mapped*
+        // elsewhere to fixed addresses. However, to be able for the compiler to "see" them as zeropage
+        // variables, we have to register them here as well. This is important because the compiler
+        // sometimes treats ZP variables more efficiently (for example if it's a pointer).
         for(reg in 0..15) {
             allocatedVariables["cx16.r${reg}"]   = VarAllocation((2+reg*2).toUInt(), DataType.UWORD, 2)       // cx16.r0 .. cx16.r15
             allocatedVariables["cx16.r${reg}s"]  = VarAllocation((2+reg*2).toUInt(), DataType.WORD, 2)        // cx16.r0s .. cx16.r15s

codeCore/src/prog8/code/target/zp/PETZeropage.kt

@@ -32,7 +32,10 @@ class PETZeropage(options: CompilationOptions) : Zeropage(options) {
             }
             ZeropageType.FLOATSAFE,
             ZeropageType.BASICSAFE -> {
-                free.addAll(0xb1u..0xbau)       // TODO more?
+                // Only scratch register area is safe for transient use.
+                // $b5 and $ba are clobbered by PET BASIC/Kernal calls like CHROUT ($ffd2).
+                // User variables requiring persistent storage must NOT be placed here.
+                free.addAll(listOf(0xb1u, 0xb2u, 0xb3u, 0xb4u, 0xb6u, 0xb7u, 0xb8u, 0xb9u, 0xfbu, 0xfcu, 0xfdu, 0xfeu))
             }
             ZeropageType.DONTUSE -> {
                 free.clear()  // don't use zeropage at all
@@ -46,7 +49,9 @@ class PETZeropage(options: CompilationOptions) : Zeropage(options) {
         removeReservedFromFreePool()
 
         if(options.zeropage==ZeropageType.FULL || options.zeropage==ZeropageType.KERNALSAFE) {
-            // in these cases there is enough space on the zero page to stick the cx16 virtual registers in there as well.
+            // PET DESIGN: Virtual registers are ONLY allocated when sufficient zeropage space exists.
+            // PET has very limited zeropage space in BASICSAFE/FLOATSAFE modes (only 0xB1-0xBA).
+            // Virtual registers are only allocated in FULL and KERNALSAFE modes where space permits.
             allocateCx16VirtualRegisters()
         }
 
@@ -81,4 +86,4 @@ class PETZeropage(options: CompilationOptions) : Zeropage(options) {
         allocatedVariables["cx16.r12r13sl"] = VarAllocation((base+6*4).toUInt(), DataType.LONG, 4)
         allocatedVariables["cx16.r14r15sl"] = VarAllocation((base+7*4).toUInt(), DataType.LONG, 4)
     }
-}
+}

codeCore/src/testFixtures/kotlin/prog8tests/helpers/Dummies.kt

@@ -0,0 +1,67 @@
+package prog8tests.helpers
+
+import prog8.code.core.*
+
+
+/**
+ * Dummy IMemSizer implementation for testing.
+ * Returns standard memory sizes for all data types.
+ */
+object DummyMemsizer : IMemSizer {
+    override fun memorySize(dt: DataType, numElements: Int?): Int {
+        if (dt.isPointerArray)
+            return 2 * numElements!!
+        else if (dt.isArray) {
+            require(numElements != null)
+            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)
+        }
+    }
+
+    override fun memorySize(dt: BaseDataType): Int {
+        return memorySize(DataType.forDt(dt), null)
+    }
+}
+
+
+/**
+ * Dummy IStringEncoding implementation for testing.
+ * Returns empty list/string for all operations.
+ */
+object DummyStringEncoder : IStringEncoding {
+    override val defaultEncoding: Encoding = Encoding.ISO
+
+    override fun encodeString(str: String, encoding: Encoding): List<UByte> {
+        return emptyList()
+    }
+
+    override fun decodeString(bytes: Iterable<UByte>, encoding: Encoding): String {
+        return ""
+    }
+}
+
+
+/**
+ * ASCII IStringEncoding implementation for testing.
+ * Encodes/decodes using simple ASCII mapping.
+ */
+object AsciiStringEncoder : IStringEncoding {
+    override val defaultEncoding: Encoding = Encoding.ISO
+
+    override fun encodeString(str: String, encoding: Encoding): List<UByte> =
+        str.map { it.code.toUByte() }
+
+    override fun decodeString(bytes: Iterable<UByte>, encoding: Encoding): String =
+        bytes.joinToString("") { it.toInt().toChar().toString() }
+}

codeCore/src/testFixtures/kotlin/prog8tests/helpers/ErrorReporterForTests.kt

@@ -3,27 +3,38 @@ package prog8tests.helpers
 import prog8.code.core.IErrorReporter
 import prog8.code.core.Position
 
-internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors: Boolean=true, private val keepMessagesAfterReporting: Boolean=false): IErrorReporter {
+
+/**
+ * Test implementation of IErrorReporter that collects errors/warnings/infos in memory.
+ * 
+ * @param throwExceptionAtReportIfErrors If true, report() will throw an exception when errors exist
+ * @param keepMessagesAfterReporting If false, clear() is called after report()
+ */
+class ErrorReporterForTests(
+    private val throwExceptionAtReportIfErrors: Boolean = true,
+    private val keepMessagesAfterReporting: Boolean = false
+) : IErrorReporter {
 
     val errors = mutableListOf<String>()
     val warnings = mutableListOf<String>()
     val infos = mutableListOf<String>()
+    val printedErrors = mutableListOf<String>()
 
     override fun err(msg: String, position: Position) {
         val text = "${position.toClickableStr()} $msg"
-        if(text !in errors)
+        if (text !in errors)
             errors.add(text)
     }
 
     override fun warn(msg: String, position: Position) {
         val text = "${position.toClickableStr()} $msg"
-        if(text !in warnings)
+        if (text !in warnings)
             warnings.add(text)
     }
 
     override fun info(msg: String, position: Position) {
         val text = "${position.toClickableStr()} $msg"
-        if(text !in infos)
+        if (text !in infos)
             infos.add(text)
     }
 
@@ -31,17 +42,22 @@ internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors:
         err("undefined symbol: ${symbol.joinToString(".")}", position)
     }
 
-    override fun noErrors(): Boolean  = errors.isEmpty()
-    override fun noErrorForLine(position: Position) = !errors.any { ":${position.line}:" in it }
-    override fun printSingleError(errormessage: String) { /* prints nothing in tests */ }
+    override fun noErrors(): Boolean = errors.isEmpty()
+    
+    override fun noErrorForLine(position: Position): Boolean =
+        !errors.any { ":${position.line}:" in it }
+    
+    override fun printSingleError(errormessage: String) {
+        printedErrors.add(errormessage)
+    }
 
     override fun report() {
         infos.forEach { println("UNITTEST COMPILATION REPORT: INFO: $it") }
         warnings.forEach { println("UNITTEST COMPILATION REPORT: WARNING: $it") }
         errors.forEach { println("UNITTEST COMPILATION REPORT: ERROR: $it") }
-        if(throwExceptionAtReportIfErrors)
+        if (throwExceptionAtReportIfErrors)
             finalizeNumErrors(errors.size, warnings.size, infos.size)
-        if(!keepMessagesAfterReporting) {
+        if (!keepMessagesAfterReporting) {
             clear()
         }
     }

codeCore/test/prog8tests/codecore/TestConversions.kt

@@ -0,0 +1,109 @@
+package prog8tests.codecore
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import prog8.code.core.escape
+import prog8.code.core.toHex
+import prog8.code.core.unescape
+
+/**
+ * Unit tests for conversion functions in codeCore.
+ * Focus on toHex boundaries and escape/unescape roundtrips.
+ */
+class TestConversions: FunSpec({
+
+    // ============================================================================
+    // toHex() Tests
+    // ============================================================================
+
+    test("toHex for 0-15 (decimal output)") {
+        0.toHex() shouldBe "0"
+        10.toHex() shouldBe "10"
+        15.toHex() shouldBe "15"
+    }
+
+    test("toHex for 16-255 (hex with $)") {
+        16.toHex() shouldBe "\$10"
+        255.toHex() shouldBe "\$ff"
+    }
+
+    test("toHex for 256-65535 (4 digit hex)") {
+        256.toHex() shouldBe "\$0100"
+        65535.toHex() shouldBe "\$ffff"
+    }
+
+    test("toHex for larger numbers (8 digit hex)") {
+        65536.toHex() shouldBe "\$00010000"
+        0x12345678.toHex() shouldBe "\$12345678"
+    }
+
+    test("toHex for negative numbers") {
+        (-1).toHex() shouldBe "-1"
+        (-255).toHex() shouldBe "-\$ff"
+        Int.MIN_VALUE.toHex() shouldBe "\$80000000"
+    }
+
+    test("UInt.toHex") {
+        0u.toHex() shouldBe "0"
+        15u.toHex() shouldBe "15"
+        255u.toHex() shouldBe "\$ff"
+        65535u.toHex() shouldBe "\$ffff"
+    }
+
+    // ============================================================================
+    // escape() Tests
+    // ============================================================================
+
+    test("escape for plain string") {
+        "hello".escape() shouldBe "hello"
+    }
+
+    test("escape for tab and newline") {
+        "hello\tworld".escape() shouldBe "hello\\tworld"
+        "hello\nworld".escape() shouldBe "hello\\nworld"
+    }
+
+    test("escape for double quote") {
+        "hello\"world".escape() shouldBe "hello\\\"world"
+    }
+
+    test("escape for unicode outside passthrough range") {
+        "€".escape() shouldBe "\\u20ac"
+    }
+
+    test("escape for passthrough characters (\\u8000-\\u80ff)") {
+        "\u8000".escape() shouldBe "\\x00"
+        "\u80ff".escape() shouldBe "\\xff"
+    }
+
+    // ============================================================================
+    // unescape() Tests
+    // ============================================================================
+
+    test("unescape for plain string") {
+        "hello".unescape() shouldBe "hello"
+    }
+
+    test("unescape for tab and newline") {
+        "hello\\tworld".unescape() shouldBe "hello\tworld"
+        "hello\\nworld".unescape() shouldBe "hello\nworld"
+    }
+
+    test("unescape for double quote") {
+        "hello\\\"world".unescape() shouldBe "hello\"world"
+    }
+
+    test("unescape for unicode") {
+        "\\u0041".unescape() shouldBe "A"
+        "\\u20ac".unescape() shouldBe "€"
+    }
+
+    // ============================================================================
+    // Roundtrip Tests
+    // ============================================================================
+
+    test("escape then unescape roundtrip") {
+        val original = "hello\t\nworld\"test"
+        original.escape().unescape() shouldBe original
+    }
+})

codeCore/test/prog8tests/codecore/TestDataType.kt

@@ -0,0 +1,311 @@
+package prog8tests.codecore
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.booleans.shouldBeFalse
+import io.kotest.matchers.booleans.shouldBeTrue
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import prog8.code.core.*
+
+/**
+ * Unit tests for DataType and BaseDataType classes in codeCore.
+ * Focus on type predicates, relationships, and key operations.
+ */
+class TestDataType: FunSpec({
+
+    val dummyMemSizer = object : IMemSizer {
+        override fun memorySize(dt: DataType, numElements: Int?): Int {
+            if (dt.isPointerArray) return 2 * numElements!!
+            if (dt.isArray || dt.isSplitWordArray) {
+                require(numElements != null)
+                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)
+            }
+        }
+
+        override fun memorySize(dt: BaseDataType): Int {
+            return memorySize(DataType.forDt(dt), null)
+        }
+    }
+
+    // ============================================================================
+    // BaseDataType Extension Property Tests
+    // ============================================================================
+
+    test("isByte extension") {
+        BaseDataType.UBYTE.isByte.shouldBeTrue()
+        BaseDataType.BYTE.isByte.shouldBeTrue()
+        BaseDataType.UWORD.isByte.shouldBeFalse()
+        BaseDataType.WORD.isByte.shouldBeFalse()
+    }
+
+    test("isByteOrBool extension") {
+        BaseDataType.UBYTE.isByteOrBool.shouldBeTrue()
+        BaseDataType.BYTE.isByteOrBool.shouldBeTrue()
+        BaseDataType.BOOL.isByteOrBool.shouldBeTrue()
+        BaseDataType.UWORD.isByteOrBool.shouldBeFalse()
+    }
+
+    test("isWord extension") {
+        BaseDataType.UWORD.isWord.shouldBeTrue()
+        BaseDataType.WORD.isWord.shouldBeTrue()
+        BaseDataType.UBYTE.isWord.shouldBeFalse()
+    }
+
+    test("isInteger extension") {
+        BaseDataType.UBYTE.isInteger.shouldBeTrue()
+        BaseDataType.WORD.isInteger.shouldBeTrue()
+        BaseDataType.LONG.isInteger.shouldBeTrue()
+        BaseDataType.FLOAT.isInteger.shouldBeFalse()
+    }
+
+    test("isNumeric extension") {
+        BaseDataType.UBYTE.isNumeric.shouldBeTrue()
+        BaseDataType.FLOAT.isNumeric.shouldBeTrue()
+        BaseDataType.BOOL.isNumeric.shouldBeFalse()
+    }
+
+    test("isSigned extension") {
+        BaseDataType.BYTE.isSigned.shouldBeTrue()
+        BaseDataType.WORD.isSigned.shouldBeTrue()
+        BaseDataType.LONG.isSigned.shouldBeTrue()
+        BaseDataType.UBYTE.isSigned.shouldBeFalse()
+    }
+
+    test("isArray extension") {
+        BaseDataType.ARRAY.isArray.shouldBeTrue()
+        BaseDataType.ARRAY_SPLITW.isArray.shouldBeTrue()
+        BaseDataType.ARRAY_POINTER.isArray.shouldBeTrue()
+        BaseDataType.UBYTE.isArray.shouldBeFalse()
+    }
+
+    test("isPointer extension") {
+        BaseDataType.POINTER.isPointer.shouldBeTrue()
+        BaseDataType.UBYTE.isPointer.shouldBeFalse()
+    }
+
+    test("isSplitWordArray extension") {
+        BaseDataType.ARRAY_SPLITW.isSplitWordArray.shouldBeTrue()
+        BaseDataType.ARRAY_POINTER.isSplitWordArray.shouldBeTrue()
+        BaseDataType.ARRAY.isSplitWordArray.shouldBeFalse()
+    }
+
+    // ============================================================================
+    // DataType Companion Object Tests
+    // ============================================================================
+
+    test("DataType.forDt creates simple types") {
+        DataType.forDt(BaseDataType.UBYTE) shouldBe DataType.UBYTE
+        DataType.forDt(BaseDataType.WORD) shouldBe DataType.WORD
+        DataType.forDt(BaseDataType.LONG) shouldBe DataType.LONG
+        DataType.forDt(BaseDataType.FLOAT) shouldBe DataType.FLOAT
+    }
+
+    test("DataType.forDt throws for struct instance") {
+        shouldThrow<NotImplementedError> {
+            DataType.forDt(BaseDataType.STRUCT_INSTANCE)
+        }
+    }
+
+    test("DataType.arrayFor creates array types") {
+        val ubyteArray = DataType.arrayFor(BaseDataType.UBYTE)
+        ubyteArray.base shouldBe BaseDataType.ARRAY
+        ubyteArray.sub shouldBe BaseDataType.UBYTE
+
+        val wordArraySplit = DataType.arrayFor(BaseDataType.WORD)
+        wordArraySplit.base shouldBe BaseDataType.ARRAY_SPLITW
+        wordArraySplit.sub shouldBe BaseDataType.WORD
+    }
+
+    test("DataType.pointer creates pointer types") {
+        val ptrByte = DataType.pointer(BaseDataType.UBYTE)
+        ptrByte.base shouldBe BaseDataType.POINTER
+        ptrByte.sub shouldBe BaseDataType.UBYTE
+    }
+
+    // ============================================================================
+    // DataType Property Tests
+    // ============================================================================
+
+    test("DataType.isBasic property") {
+        DataType.UBYTE.isBasic.shouldBeTrue()
+        DataType.WORD.isBasic.shouldBeTrue()
+        DataType.STR.isBasic.shouldBeFalse()
+        DataType.arrayFor(BaseDataType.UBYTE).isBasic.shouldBeFalse()
+    }
+
+    test("DataType.isByte property") {
+        DataType.UBYTE.isByte.shouldBeTrue()
+        DataType.BYTE.isByte.shouldBeTrue()
+        DataType.WORD.isByte.shouldBeFalse()
+    }
+
+    test("DataType.isNumeric property") {
+        DataType.UBYTE.isNumeric.shouldBeTrue()
+        DataType.FLOAT.isNumeric.shouldBeTrue()
+        DataType.BOOL.isNumeric.shouldBeFalse()
+        DataType.STR.isNumeric.shouldBeFalse()
+    }
+
+    test("DataType.isArray property") {
+        DataType.arrayFor(BaseDataType.UBYTE).isArray.shouldBeTrue()
+        DataType.UBYTE.isArray.shouldBeFalse()
+    }
+
+    test("DataType.isPointer property") {
+        DataType.pointer(BaseDataType.UBYTE).isPointer.shouldBeTrue()
+        DataType.UBYTE.isPointer.shouldBeFalse()
+    }
+
+    test("DataType.isString property") {
+        DataType.STR.isString.shouldBeTrue()
+        DataType.UBYTE.isString.shouldBeFalse()
+    }
+
+    test("DataType.isPassByRef property") {
+        DataType.STR.isPassByRef.shouldBeTrue()
+        DataType.arrayFor(BaseDataType.UBYTE).isPassByRef.shouldBeTrue()
+        DataType.UBYTE.isPassByRef.shouldBeFalse()
+        DataType.pointer(BaseDataType.UBYTE).isPassByRef.shouldBeFalse()
+    }
+
+    // ============================================================================
+    // DataType Method Tests
+    // ============================================================================
+
+    test("DataType.elementType returns element type for arrays") {
+        DataType.arrayFor(BaseDataType.UBYTE).elementType() shouldBe DataType.UBYTE
+        DataType.arrayFor(BaseDataType.WORD).elementType() shouldBe DataType.WORD
+        DataType.STR.elementType() shouldBe DataType.UBYTE
+    }
+
+    test("DataType.elementType throws for non-arrays") {
+        shouldThrow<IllegalArgumentException> {
+            DataType.UBYTE.elementType()
+        }
+    }
+
+    test("DataType.dereference for pointers") {
+        DataType.pointer(BaseDataType.UBYTE).dereference() shouldBe DataType.UBYTE
+        DataType.pointer(BaseDataType.WORD).dereference() shouldBe DataType.WORD
+        DataType.UWORD.dereference() shouldBe DataType.UBYTE
+    }
+
+    test("DataType.size with memsizer") {
+        DataType.UBYTE.size(dummyMemSizer) shouldBe 1
+        DataType.WORD.size(dummyMemSizer) shouldBe 2
+        DataType.LONG.size(dummyMemSizer) shouldBe 4
+        DataType.FLOAT.size(dummyMemSizer) shouldBe 5
+    }
+
+    // ============================================================================
+    // DataType Comparison Tests
+    // ============================================================================
+
+    test("DataType equals for same types") {
+        DataType.UBYTE shouldBe DataType.UBYTE
+        DataType.WORD shouldBe DataType.WORD
+        DataType.STR shouldBe DataType.STR
+    }
+
+    test("DataType equals for different types") {
+        DataType.UBYTE shouldNotBe DataType.BYTE
+        DataType.UBYTE shouldNotBe DataType.WORD
+    }
+
+    test("BaseDataType.largerSizeThan") {
+        BaseDataType.WORD.largerSizeThan(BaseDataType.UBYTE).shouldBeTrue()
+        BaseDataType.LONG.largerSizeThan(BaseDataType.WORD).shouldBeTrue()
+        BaseDataType.UBYTE.largerSizeThan(BaseDataType.WORD).shouldBeFalse()
+        BaseDataType.STR.largerSizeThan(BaseDataType.UBYTE).shouldBeTrue()
+        BaseDataType.STR.largerSizeThan(BaseDataType.BOOL).shouldBeTrue()
+        BaseDataType.STR.largerSizeThan(BaseDataType.UWORD).shouldBeFalse()
+        BaseDataType.STR.largerSizeThan(BaseDataType.WORD).shouldBeFalse()
+        BaseDataType.STR.largerSizeThan(BaseDataType.POINTER).shouldBeFalse()
+        BaseDataType.STR.largerSizeThan(BaseDataType.LONG).shouldBeFalse()
+        BaseDataType.POINTER.largerSizeThan(BaseDataType.UBYTE).shouldBeTrue()
+        BaseDataType.POINTER.largerSizeThan(BaseDataType.BOOL).shouldBeTrue()
+        BaseDataType.POINTER.largerSizeThan(BaseDataType.UWORD).shouldBeFalse()
+        BaseDataType.POINTER.largerSizeThan(BaseDataType.STR).shouldBeFalse()
+    }
+
+    test("BaseDataType.equalsSize") {
+        BaseDataType.UBYTE.equalsSize(BaseDataType.UBYTE).shouldBeTrue()
+        BaseDataType.UBYTE.equalsSize(BaseDataType.BYTE).shouldBeTrue()
+        BaseDataType.WORD.equalsSize(BaseDataType.UWORD).shouldBeTrue()
+        BaseDataType.UBYTE.equalsSize(BaseDataType.WORD).shouldBeFalse()
+        BaseDataType.STR.equalsSize(BaseDataType.STR).shouldBeTrue()
+        BaseDataType.STR.equalsSize(BaseDataType.UWORD).shouldBeTrue()
+        BaseDataType.STR.equalsSize(BaseDataType.BYTE).shouldBeFalse()
+        BaseDataType.POINTER.equalsSize(BaseDataType.UWORD).shouldBeTrue()
+        BaseDataType.POINTER.equalsSize(BaseDataType.STR).shouldBeFalse()
+    }
+
+    // ============================================================================
+    // DataType.isAssignableTo Tests
+    // ============================================================================
+
+    test("bool assignability") {
+        DataType.BOOL.isAssignableTo(DataType.BOOL).shouldBeTrue()
+        DataType.BOOL.isAssignableTo(DataType.UBYTE).shouldBeFalse()
+    }
+
+    test("ubyte assignability") {
+        DataType.UBYTE.isAssignableTo(DataType.UBYTE).shouldBeTrue()
+        DataType.UBYTE.isAssignableTo(DataType.UWORD).shouldBeTrue()
+        DataType.UBYTE.isAssignableTo(DataType.LONG).shouldBeTrue()
+        DataType.UBYTE.isAssignableTo(DataType.FLOAT).shouldBeTrue()
+    }
+
+    test("byte assignability") {
+        DataType.BYTE.isAssignableTo(DataType.BYTE).shouldBeTrue()
+        DataType.BYTE.isAssignableTo(DataType.WORD).shouldBeTrue()
+        DataType.BYTE.isAssignableTo(DataType.LONG).shouldBeTrue()
+    }
+
+    test("uword assignability") {
+        DataType.UWORD.isAssignableTo(DataType.UWORD).shouldBeTrue()
+        DataType.UWORD.isAssignableTo(DataType.LONG).shouldBeTrue()
+        DataType.UWORD.isAssignableTo(DataType.FLOAT).shouldBeTrue()
+    }
+
+    test("string assignability") {
+        DataType.STR.isAssignableTo(DataType.STR).shouldBeTrue()
+        DataType.STR.isAssignableTo(DataType.UWORD).shouldBeTrue()
+    }
+
+    test("pointer assignability") {
+        val ptr = DataType.pointer(BaseDataType.UBYTE)
+        ptr.isAssignableTo(DataType.UWORD).shouldBeTrue()
+        ptr.isAssignableTo(DataType.LONG).shouldBeTrue()
+        ptr.isAssignableTo(DataType.pointer(BaseDataType.UBYTE)).shouldBeTrue()
+    }
+
+    // ============================================================================
+    // DataType.toString Tests
+    // ============================================================================
+
+    test("DataType.toString for basic types") {
+        DataType.UBYTE.toString() shouldBe "ubyte"
+        DataType.WORD.toString() shouldBe "word"
+        DataType.LONG.toString() shouldBe "long"
+        DataType.FLOAT.toString() shouldBe "float"
+    }
+
+    test("DataType.toString for arrays") {
+        DataType.arrayFor(BaseDataType.UBYTE).toString() shouldBe "ubyte[]"
+        DataType.arrayFor(BaseDataType.WORD).toString() shouldBe "word[] (split)"
+    }
+})

codeCore/test/prog8tests/codecore/TestZeropageFreeList.kt

@@ -0,0 +1,729 @@
+package prog8tests.codecore
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.booleans.shouldBeTrue
+import io.kotest.matchers.collections.shouldBeEmpty
+import io.kotest.matchers.ints.shouldBeGreaterThan
+import io.kotest.matchers.maps.shouldContainKey
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import prog8.code.core.*
+import prog8.code.target.C128Target
+import prog8.code.target.C64Target
+import prog8.code.target.Cx16Target
+import prog8.code.target.PETTarget
+import prog8.code.target.zp.C128Zeropage
+import prog8.code.target.zp.C64Zeropage
+import prog8.code.target.zp.CX16Zeropage
+import prog8.code.target.zp.PETZeropage
+
+
+/**
+ * Comprehensive tests for Zeropage free list configurations across all targets.
+ * 
+ * Tests verify that for each target and ZeropageType combination:
+ * - The exact list of free locations is correct
+ * - Scratch locations are properly reserved
+ * - Virtual registers are allocated when appropriate
+ */
+class TestZeropageFreeList: FunSpec({
+
+    // ============================================================================
+    // Helper Functions
+    // ============================================================================
+
+    fun createOptions(target: ICompilationTarget, zpType: ZeropageType, floats: Boolean = false): CompilationOptions {
+        return CompilationOptions.builder(target)
+            .output(OutputType.RAW)
+            .zeropage(zpType)
+            .floats(floats)
+            .compilerVersion("test")
+            .build()
+    }
+
+    fun verifyScratchLocationsReserved(zp: Zeropage) {
+        // Verify scratch locations are not in free list
+        zp.free.contains(zp.SCRATCH_B1) shouldBe false
+        zp.free.contains(zp.SCRATCH_REG) shouldBe false
+        zp.free.contains(zp.SCRATCH_W1) shouldBe false
+        zp.free.contains(zp.SCRATCH_W1 + 1u) shouldBe false
+        zp.free.contains(zp.SCRATCH_W2) shouldBe false
+        zp.free.contains(zp.SCRATCH_W2 + 1u) shouldBe false
+        zp.free.contains(zp.SCRATCH_PTR) shouldBe false
+        zp.free.contains(zp.SCRATCH_PTR + 1u) shouldBe false
+    }
+
+    fun verifyVirtualRegistersAllocated(zp: Zeropage, expected: Boolean) {
+        if (expected) {
+            // Check that virtual registers are allocated
+            for (reg in 0..15) {
+                zp.allocatedVariables shouldContainKey "cx16.r${reg}"
+            }
+        }
+    }
+
+    // ============================================================================
+    // C64 Zeropage Tests
+    // ============================================================================
+
+    context("C64Zeropage") {
+        
+        test("DONTUSE should have no free locations") {
+            val options = createOptions(C64Target(), ZeropageType.DONTUSE)
+            val zp = C64Zeropage(options)
+            
+            zp.free.shouldBeEmpty()
+            zp.availableBytes() shouldBe 0
+        }
+
+        test("BASICSAFE should have specific free locations") {
+            val options = createOptions(C64Target(), ZeropageType.BASICSAFE)
+            val zp = C64Zeropage(options)
+            
+            // BASICSAFE includes specific BASIC-safe locations
+            zp.free.isNotEmpty().shouldBeTrue()
+            zp.free.size shouldBeGreaterThan 0
+            
+            // Verify scratch locations are reserved
+            verifyScratchLocationsReserved(zp)
+            
+            // Virtual registers should be allocated for BASICSAFE
+            verifyVirtualRegistersAllocated(zp, expected = false)  // C64 doesn't allocate virtual regs for BASICSAFE
+        }
+
+        test("KERNALSAFE should have larger free list than BASICSAFE") {
+            val options = createOptions(C64Target(), ZeropageType.KERNALSAFE)
+            val zp = C64Zeropage(options)
+            
+            zp.free.isNotEmpty().shouldBeTrue()
+            
+            // KERNALSAFE has more locations than BASICSAFE
+            val basicsafeOptions = createOptions(C64Target(), ZeropageType.BASICSAFE)
+            val basicsafeZp = C64Zeropage(basicsafeOptions)
+            
+            zp.free.size shouldBeGreaterThan basicsafeZp.free.size
+            
+            verifyScratchLocationsReserved(zp)
+            verifyVirtualRegistersAllocated(zp, expected = true)  // KERNALSAFE gets virtual registers
+        }
+
+        test("FLOATSAFE should exclude float-used locations") {
+            val options = createOptions(C64Target(), ZeropageType.FLOATSAFE, floats = true)
+            val zp = C64Zeropage(options)
+            
+            zp.free.isNotEmpty().shouldBeTrue()
+            
+            // FLOATSAFE should have fewer locations than KERNALSAFE due to float exclusions
+            val kernalsafeOptions = createOptions(C64Target(), ZeropageType.KERNALSAFE)
+            val kernalsafeZp = C64Zeropage(kernalsafeOptions)
+            
+            zp.free.size shouldBeLessThan kernalsafeZp.free.size
+            
+            // Some float-related locations should not be free (exact set depends on implementation)
+            // Just verify the size difference is significant
+            (kernalsafeZp.free.size - zp.free.size) shouldBeGreaterThan 10
+            
+            verifyScratchLocationsReserved(zp)
+        }
+
+        test("FULL should have maximum free locations minus IRQ") {
+            val options = createOptions(C64Target(), ZeropageType.FULL)
+            val zp = C64Zeropage(options)
+            
+            // FULL should have the most free locations
+            val kernalsafeOptions = createOptions(C64Target(), ZeropageType.KERNALSAFE)
+            val kernalsafeZp = C64Zeropage(kernalsafeOptions)
+            
+            zp.free.size shouldBeGreaterThan kernalsafeZp.free.size
+            
+            // IRQ locations should not be free
+            zp.free.contains(0xa0u) shouldBe false
+            zp.free.contains(0xa1u) shouldBe false
+            zp.free.contains(0xa2u) shouldBe false
+            zp.free.contains(0x91u) shouldBe false
+            zp.free.contains(0xc0u) shouldBe false
+            zp.free.contains(0xc5u) shouldBe false
+            zp.free.contains(0xcbu) shouldBe false
+            zp.free.contains(0xf5u) shouldBe false
+            zp.free.contains(0xf6u) shouldBe false
+            
+            verifyScratchLocationsReserved(zp)
+            verifyVirtualRegistersAllocated(zp, expected = true)
+        }
+    }
+
+    // ============================================================================
+    // CX16 Zeropage Tests
+    // ============================================================================
+
+    context("CX16Zeropage") {
+        
+        test("DONTUSE should have no free locations") {
+            val options = createOptions(Cx16Target(), ZeropageType.DONTUSE)
+            val zp = CX16Zeropage(options)
+            
+            zp.free.shouldBeEmpty()
+            zp.availableBytes() shouldBe 0
+        }
+
+        test("BASICSAFE should have 0x22-0x7F") {
+            val options = createOptions(Cx16Target(), ZeropageType.BASICSAFE)
+            val zp = CX16Zeropage(options)
+            
+            // Virtual registers 0x02-0x21 should be allocated, not free
+            for (addr in 0x02u..0x21u) {
+                zp.free shouldNotBe addr
+            }
+            
+            // Free should be 0x22-0x7F minus scratch locations
+            for (addr in 0x22u..0x7Fu) {
+                if (addr !in setOf(zp.SCRATCH_B1, zp.SCRATCH_REG, zp.SCRATCH_W1, zp.SCRATCH_W1 + 1u, 
+                        zp.SCRATCH_W2, zp.SCRATCH_W2 + 1u, zp.SCRATCH_PTR, zp.SCRATCH_PTR + 1u)) {
+                    zp.free.contains(addr) shouldBe true
+                }
+            }
+            
+            verifyScratchLocationsReserved(zp)
+        }
+
+        test("KERNALSAFE should have 0x22-0x7F and 0xA9-0xFF") {
+            val options = createOptions(Cx16Target(), ZeropageType.KERNALSAFE)
+            val zp = CX16Zeropage(options)
+            
+            val basicsafeOptions = createOptions(Cx16Target(), ZeropageType.BASICSAFE)
+            val basicsafeZp = CX16Zeropage(basicsafeOptions)
+            
+            zp.free.size shouldBeGreaterThan basicsafeZp.free.size
+            
+            // Should include high memory range
+            zp.free.contains(0xa9u) shouldBe true
+            zp.free.contains(0xffu) shouldBe true
+            
+            verifyScratchLocationsReserved(zp)
+        }
+
+        test("FLOATSAFE should have 0x22-0x7F and 0xD4-0xFF") {
+            val options = createOptions(Cx16Target(), ZeropageType.FLOATSAFE, floats = true)
+            val zp = CX16Zeropage(options)
+
+            // Should include 0xD4-0xFF range
+            zp.free.contains(0xd4u) shouldBe true
+            zp.free.contains(0xffu) shouldBe true
+
+            // FLOATSAFE has different high range than KERNALSAFE (0xD4-0xFF vs 0xA9-0xFF)
+            val kernalsafeOptions = createOptions(Cx16Target(), ZeropageType.KERNALSAFE)
+            val kernalsafeZp = CX16Zeropage(kernalsafeOptions)
+
+            // FLOATSAFE should have fewer locations than KERNALSAFE (smaller high range)
+            zp.free.size shouldBeLessThan kernalsafeZp.free.size
+
+            verifyScratchLocationsReserved(zp)
+        }
+
+        test("FULL should have 0x22-0xFF") {
+            val options = createOptions(Cx16Target(), ZeropageType.FULL)
+            val zp = CX16Zeropage(options)
+            
+            // FULL should have the most free locations
+            val kernalsafeOptions = createOptions(Cx16Target(), ZeropageType.KERNALSAFE)
+            val kernalsafeZp = CX16Zeropage(kernalsafeOptions)
+            
+            zp.free.size shouldBeGreaterThan kernalsafeZp.free.size
+            
+            // Should include all locations from 0x22 to 0xFF (minus scratch)
+            for (addr in 0x80u..0xA8u) {
+                if (addr !in setOf(zp.SCRATCH_B1, zp.SCRATCH_REG, zp.SCRATCH_W1, zp.SCRATCH_W1 + 1u,
+                        zp.SCRATCH_W2, zp.SCRATCH_W2 + 1u, zp.SCRATCH_PTR, zp.SCRATCH_PTR + 1u)) {
+                    zp.free.contains(addr) shouldBe true
+                }
+            }
+            
+            verifyScratchLocationsReserved(zp)
+        }
+    }
+
+    // ============================================================================
+    // PET Zeropage Tests
+    // ============================================================================
+
+    context("PETZeropage") {
+        
+        test("DONTUSE should have no free locations") {
+            val options = createOptions(PETTarget(), ZeropageType.DONTUSE)
+            val zp = PETZeropage(options)
+            
+            zp.free.shouldBeEmpty()
+            zp.availableBytes() shouldBe 0
+        }
+
+        test("BASICSAFE should have minimal free locations") {
+            val options = createOptions(PETTarget(), ZeropageType.BASICSAFE)
+            val zp = PETZeropage(options)
+            
+            // BASICSAFE includes scratch register addresses ($b1-$b4, $b6-$b9)
+            // and $fb-$fe. After scratch removal, $fb-$fe remain usable.
+            zp.free.size shouldBeLessThan 20
+            zp.free.contains(0xfbu) shouldBe true
+            zp.free.contains(0xfcu) shouldBe true
+            zp.free.contains(0xfdu) shouldBe true
+            zp.free.contains(0xfeu) shouldBe true
+            
+            verifyScratchLocationsReserved(zp)
+        }
+
+        test("FLOATSAFE should be same as BASICSAFE") {
+            val floatOptions = createOptions(PETTarget(), ZeropageType.FLOATSAFE, floats = true)
+            val floatZp = PETZeropage(floatOptions)
+            
+            val basicOptions = createOptions(PETTarget(), ZeropageType.BASICSAFE)
+            val basicZp = PETZeropage(basicOptions)
+            
+            // FLOATSAFE and BASICSAFE should have same free locations for PET
+            floatZp.free.size shouldBe basicZp.free.size
+            setOf(0xfbu, 0xfcu, 0xfdu, 0xfeu).forEach { addr ->
+                floatZp.free.contains(addr) shouldBe true
+            }
+        }
+
+        test("KERNALSAFE should exclude IRQ locations") {
+            val options = createOptions(PETTarget(), ZeropageType.KERNALSAFE)
+            val zp = PETZeropage(options)
+            
+            // IRQ locations should not be free
+            zp.free.contains(0x8du) shouldBe false
+            zp.free.contains(0x8eu) shouldBe false
+            zp.free.contains(0x8fu) shouldBe false
+            zp.free.contains(0x97u) shouldBe false
+            zp.free.contains(0x98u) shouldBe false
+            zp.free.contains(0x99u) shouldBe false
+            zp.free.contains(0x9au) shouldBe false
+            zp.free.contains(0x9bu) shouldBe false
+            zp.free.contains(0x9eu) shouldBe false
+            zp.free.contains(0xa7u) shouldBe false
+            zp.free.contains(0xa8u) shouldBe false
+            zp.free.contains(0xa9u) shouldBe false
+            zp.free.contains(0xaau) shouldBe false
+            zp.free.contains(0xaaau) shouldBe false
+            
+            verifyScratchLocationsReserved(zp)
+        }
+
+        test("FULL should have all locations minus IRQ") {
+            val options = createOptions(PETTarget(), ZeropageType.FULL)
+            val zp = PETZeropage(options)
+            
+            // FULL should have most locations
+            zp.free.size shouldBeGreaterThan 100
+            
+            // IRQ locations should not be free
+            zp.free.contains(0x8du) shouldBe false
+            zp.free.contains(0x97u) shouldBe false
+            zp.free.contains(0xa7u) shouldBe false
+            
+            verifyScratchLocationsReserved(zp)
+            verifyVirtualRegistersAllocated(zp, expected = true)
+        }
+    }
+
+    // ============================================================================
+    // C128 Zeropage Tests
+    // ============================================================================
+
+    context("C128Zeropage") {
+        
+        test("DONTUSE should have no free locations") {
+            val options = createOptions(C128Target(), ZeropageType.DONTUSE)
+            val zp = C128Zeropage(options)
+            
+            zp.free.shouldBeEmpty()
+            zp.availableBytes() shouldBe 0
+        }
+
+        test("BASICSAFE should have specific safe locations") {
+            val options = createOptions(C128Target(), ZeropageType.BASICSAFE)
+            val zp = C128Zeropage(options)
+            
+            zp.free.isNotEmpty().shouldBeTrue()
+            
+            // Should include some specific BASIC-safe locations (excluding scratch)
+            // 0x0b is SCRATCH_PTR, 0x74 is SCRATCH_B1 for C128, so they're not free
+            // Check for other locations that should be free
+            zp.free.contains(0x0du) shouldBe true
+            zp.free.contains(0x1bu) shouldBe true  // In BASICSAFE range
+            
+            verifyScratchLocationsReserved(zp)
+        }
+
+        test("FLOATSAFE should be same as BASICSAFE for C128") {
+            val floatOptions = createOptions(C128Target(), ZeropageType.FLOATSAFE, floats = true)
+            val floatZp = C128Zeropage(floatOptions)
+            
+            val basicOptions = createOptions(C128Target(), ZeropageType.BASICSAFE)
+            val basicZp = C128Zeropage(basicOptions)
+            
+            // FLOATSAFE and BASICSAFE should have same free locations for C128
+            floatZp.free.size shouldBe basicZp.free.size
+        }
+
+        test("KERNALSAFE should have BASIC variables area") {
+            val options = createOptions(C128Target(), ZeropageType.KERNALSAFE)
+            val zp = C128Zeropage(options)
+
+            // Should include 0x0A-0x8F (BASIC variables area) minus scratch/virtual reg locations
+            // 0x0a is where virtual registers start for C128, so not free
+            // 0x8fu should be free
+            zp.free.contains(0x8fu) shouldBe true
+
+            // Should include additional specific locations
+            zp.free.contains(0x92u) shouldBe true
+            // 0xb6u is SCRATCH_W1 for C128 - won't be free
+            zp.free.contains(0x96u) shouldBe true  // Alternative location
+            
+            verifyScratchLocationsReserved(zp)
+        }
+
+        test("FULL should have maximum locations minus IRQ") {
+            val options = createOptions(C128Target(), ZeropageType.FULL)
+            val zp = C128Zeropage(options)
+
+            // FULL should have many locations (0x0A-0xFF minus IRQ and scratch)
+            // 0x0a is where virtual registers start for C128, so not free
+            zp.free.size shouldBeGreaterThan 150
+
+            // IRQ locations should not be free
+            zp.free.contains(0x90u) shouldBe false
+            zp.free.contains(0x91u) shouldBe false
+            zp.free.contains(0xa0u) shouldBe false
+            zp.free.contains(0xa1u) shouldBe false
+            zp.free.contains(0xa2u) shouldBe false
+            zp.free.contains(0xc0u) shouldBe false
+            zp.free.contains(0xccu) shouldBe false
+            zp.free.contains(0xcdu) shouldBe false
+            zp.free.contains(0xd0u) shouldBe false
+            zp.free.contains(0xd1u) shouldBe false
+            zp.free.contains(0xd2u) shouldBe false
+            zp.free.contains(0xd3u) shouldBe false
+            zp.free.contains(0xd4u) shouldBe false
+            zp.free.contains(0xd5u) shouldBe false
+            zp.free.contains(0xf7u) shouldBe false
+            
+            verifyScratchLocationsReserved(zp)
+            verifyVirtualRegistersAllocated(zp, expected = true)
+        }
+    }
+
+    // ============================================================================
+    // Cross-Target Comparison Tests
+    // ============================================================================
+
+    context("Cross-Target Comparisons") {
+        
+        test("all targets should have empty free list for DONTUSE") {
+            // C64
+            val c64Options = createOptions(C64Target(), ZeropageType.DONTUSE)
+            C64Zeropage(c64Options).free.shouldBeEmpty()
+            
+            // CX16
+            val cx16Options = createOptions(Cx16Target(), ZeropageType.DONTUSE)
+            CX16Zeropage(cx16Options).free.shouldBeEmpty()
+            
+            // PET
+            val petOptions = createOptions(PETTarget(), ZeropageType.DONTUSE)
+            PETZeropage(petOptions).free.shouldBeEmpty()
+            
+            // C128
+            val c128Options = createOptions(C128Target(), ZeropageType.DONTUSE)
+            C128Zeropage(c128Options).free.shouldBeEmpty()
+        }
+
+        test("scratch locations differ between targets") {
+            val c64Options = createOptions(C64Target(), ZeropageType.BASICSAFE)
+            val c64Zp = C64Zeropage(c64Options)
+
+            val cx16Options = createOptions(Cx16Target(), ZeropageType.BASICSAFE)
+            val cx16Zp = CX16Zeropage(cx16Options)
+
+            val petOptions = createOptions(PETTarget(), ZeropageType.BASICSAFE)
+            val petZp = PETZeropage(petOptions)
+
+            val c128Options = createOptions(C128Target(), ZeropageType.BASICSAFE)
+            val c128Zp = C128Zeropage(c128Options)
+
+            // Each target has different scratch locations
+            c64Zp.SCRATCH_B1 shouldBe 0x02u
+            cx16Zp.SCRATCH_B1 shouldBe 0x7au
+            petZp.SCRATCH_B1 shouldBe 0xb3u
+            c128Zp.SCRATCH_B1 shouldBe 0x74u
+        }
+    }
+
+    // ============================================================================
+    // Exhaustive Zeropage Address Tests - All 256 locations
+    // ============================================================================
+
+    context("Exhaustive C64 Zeropage Tests") {
+
+        test("DONTUSE - no addresses should be free") {
+            val options = createOptions(C64Target(), ZeropageType.DONTUSE)
+            val zp = C64Zeropage(options)
+            
+            for (addr in 0x00u..0xFFu) {
+                zp.free.contains(addr) shouldBe false
+            }
+        }
+
+        test("BASICSAFE - exact free address set") {
+            val options = createOptions(C64Target(), ZeropageType.BASICSAFE)
+            val zp = C64Zeropage(options)
+            
+            // BASICSAFE: specific BASIC-safe locations plus virtual registers at 0x04-0x23
+            // Scratch locations are removed from free list
+            // Just verify key properties
+            zp.free.size shouldBeGreaterThan 10
+            
+            // Scratch locations should NOT be free
+            setOf(0x02u, 0x03u, 0x04u, 0x05u, 0xFBu, 0xFCu, 0xFDu, 0xFEu).forEach { addr ->
+                zp.free.contains(addr) shouldBe false
+            }
+            
+            // Some known free locations
+            zp.free.contains(0x06u) shouldBe true
+            zp.free.contains(0x92u) shouldBe true
+        }
+
+        test("KERNALSAFE - exact free address set") {
+            val options = createOptions(C64Target(), ZeropageType.KERNALSAFE)
+            val zp = C64Zeropage(options)
+            
+            // KERNALSAFE: larger set including more locations, plus virtual registers at 0x04-0x23
+            // Scratch locations (0x02,0x03,0x04,0x05,0xFB,0xFC,0xFD,0xFE) are removed
+            // Virtual registers 0x04-0x23 are allocated (not free)
+            
+            // Just verify key properties since exact set is complex
+            zp.free.size shouldBeGreaterThan 50
+            
+            // IRQ locations should NOT be free
+            setOf(0xA0u, 0xA1u, 0xA2u, 0x91u, 0xC0u, 0xC5u, 0xCBu, 0xF5u, 0xF6u).forEach { addr ->
+                zp.free.contains(addr) shouldBe false
+            }
+            
+            // Scratch locations should NOT be free
+            setOf(0x02u, 0x03u, 0x04u, 0x05u, 0xFBu, 0xFCu, 0xFDu, 0xFEu).forEach { addr ->
+                zp.free.contains(addr) shouldBe false
+            }
+        }
+
+        test("FLOATSAFE - excludes float-used locations") {
+            val options = createOptions(C64Target(), ZeropageType.FLOATSAFE, floats = true)
+            val zp = C64Zeropage(options)
+            
+            // FLOATSAFE is KERNALSAFE minus float-used locations
+            zp.free.size shouldBeGreaterThan 20
+            
+            // FLOATSAFE should have fewer locations than KERNALSAFE
+            val kernalsafeOptions = createOptions(C64Target(), ZeropageType.KERNALSAFE)
+            val kernalsafeZp = C64Zeropage(kernalsafeOptions)
+            
+            zp.free.size shouldBeLessThan kernalsafeZp.free.size
+        }
+
+        test("FULL - maximum free locations minus IRQ") {
+            val options = createOptions(C64Target(), ZeropageType.FULL)
+            val zp = C64Zeropage(options)
+            
+            // FULL should have the most locations
+            zp.free.size shouldBeGreaterThan 100
+            
+            // IRQ locations should NOT be free
+            setOf(0xA0u, 0xA1u, 0xA2u, 0x91u, 0xC0u, 0xC5u, 0xCBu, 0xF5u, 0xF6u).forEach { addr ->
+                zp.free.contains(addr) shouldBe false
+            }
+            
+            // Scratch locations should NOT be free
+            setOf(0x02u, 0x03u, 0x04u, 0x05u, 0xFBu, 0xFCu, 0xFDu, 0xFEu).forEach { addr ->
+                zp.free.contains(addr) shouldBe false
+            }
+        }
+    }
+
+    context("Exhaustive CX16 Zeropage Tests") {
+
+        test("DONTUSE - no addresses should be free") {
+            val options = createOptions(Cx16Target(), ZeropageType.DONTUSE)
+            val zp = CX16Zeropage(options)
+            
+            for (addr in 0x00u..0xFFu) {
+                zp.free.contains(addr) shouldBe false
+            }
+        }
+
+        test("BASICSAFE - 0x22-0x7F minus scratch and virtual registers") {
+            val options = createOptions(Cx16Target(), ZeropageType.BASICSAFE)
+            val zp = CX16Zeropage(options)
+            
+            // Virtual registers 0x02-0x21 are allocated (not free)
+            for (addr in 0x02u..0x21u) {
+                zp.free.contains(addr) shouldBe false
+            }
+            
+            // BASICSAFE: 0x22-0x7F minus scratch
+            for (addr in 0x22u..0x7Fu) {
+                val isScratch = addr in setOf(0x7Au, 0x7Bu, 0x7Cu, 0x7Du, 0x7Eu, 0x7Fu, 0x22u, 0x23u)
+                zp.free.contains(addr) shouldBe !isScratch
+            }
+            
+            // Above 0x7F should not be free for BASICSAFE
+            for (addr in 0x80u..0xFFu) {
+                zp.free.contains(addr) shouldBe false
+            }
+        }
+
+        test("KERNALSAFE - 0x22-0x7F and 0xA9-0xFF") {
+            val options = createOptions(Cx16Target(), ZeropageType.KERNALSAFE)
+            val zp = CX16Zeropage(options)
+            
+            // Virtual registers 0x02-0x21 are allocated (not free)
+            for (addr in 0x02u..0x21u) {
+                zp.free.contains(addr) shouldBe false
+            }
+            
+            // Should include 0xA9-0xFF range
+            zp.free.contains(0xA9u) shouldBe true
+            zp.free.contains(0xFFu) shouldBe true
+        }
+
+        test("FLOATSAFE - 0x22-0x7F and 0xD4-0xFF") {
+            val options = createOptions(Cx16Target(), ZeropageType.FLOATSAFE, floats = true)
+            val zp = CX16Zeropage(options)
+            
+            // Should include 0xD4-0xFF range
+            zp.free.contains(0xD4u) shouldBe true
+            zp.free.contains(0xFFu) shouldBe true
+            
+            // Should NOT include 0xA9-0xD3 range that KERNALSAFE has
+            val kernalsafeOptions = createOptions(Cx16Target(), ZeropageType.KERNALSAFE)
+            val kernalsafeZp = CX16Zeropage(kernalsafeOptions)
+            
+            zp.free.size shouldBeLessThan kernalsafeZp.free.size
+        }
+
+        test("FULL - 0x22-0xFF minus scratch") {
+            val options = createOptions(Cx16Target(), ZeropageType.FULL)
+            val zp = CX16Zeropage(options)
+            
+            // Virtual registers 0x02-0x21 are allocated (not free)
+            for (addr in 0x02u..0x21u) {
+                zp.free.contains(addr) shouldBe false
+            }
+            
+            // FULL should have most locations from 0x22-0xFF
+            zp.free.size shouldBeGreaterThan 150
+        }
+    }
+
+    context("Exhaustive PET Zeropage Tests") {
+
+        test("DONTUSE - no addresses should be free") {
+            val options = createOptions(PETTarget(), ZeropageType.DONTUSE)
+            val zp = PETZeropage(options)
+            
+            for (addr in 0x00u..0xFFu) {
+                zp.free.contains(addr) shouldBe false
+            }
+        }
+
+        test("BASICSAFE - extra fb-fe free after scratch removal") {
+            val options = createOptions(PETTarget(), ZeropageType.BASICSAFE)
+            val zp = PETZeropage(options)
+            
+            // BASICSAFE includes scratch register addresses ($b1-$b4, $b6-$b9)
+            // and $fb-$fe. After removing scratch registers from the pool,
+            // only $fb-$fe remain free.
+            zp.free.size shouldBeLessThan 15
+            setOf(0xfbu, 0xfcu, 0xfdu, 0xfeu).forEach { addr ->
+                zp.free.contains(addr) shouldBe true
+            }
+        }
+
+        test("KERNALSAFE - excludes IRQ locations") {
+            val options = createOptions(PETTarget(), ZeropageType.KERNALSAFE)
+            val zp = PETZeropage(options)
+            
+            // IRQ locations should NOT be free
+            setOf(0x8Du, 0x8Eu, 0x8Fu, 0x97u, 0x98u, 0x99u, 0x9Au, 0x9Bu, 0x9Eu,
+                  0xA7u, 0xA8u, 0xA9u, 0xAAu).forEach { addr ->
+                zp.free.contains(addr) shouldBe false
+            }
+        }
+
+        test("FULL - all minus IRQ locations") {
+            val options = createOptions(PETTarget(), ZeropageType.FULL)
+            val zp = PETZeropage(options)
+            
+            // FULL should have most locations
+            zp.free.size shouldBeGreaterThan 150
+            
+            // IRQ locations should NOT be free
+            setOf(0x8Du, 0x97u, 0xA7u).forEach { addr ->
+                zp.free.contains(addr) shouldBe false
+            }
+        }
+    }
+
+    context("Exhaustive C128 Zeropage Tests") {
+
+        test("DONTUSE - no addresses should be free") {
+            val options = createOptions(C128Target(), ZeropageType.DONTUSE)
+            val zp = C128Zeropage(options)
+            
+            for (addr in 0x00u..0xFFu) {
+                zp.free.contains(addr) shouldBe false
+            }
+        }
+
+        test("BASICSAFE - specific safe locations") {
+            val options = createOptions(C128Target(), ZeropageType.BASICSAFE)
+            val zp = C128Zeropage(options)
+            
+            // BASICSAFE has specific locations
+            zp.free.size shouldBeGreaterThan 50
+            
+            // Note: Virtual registers are NOT allocated for BASICSAFE on C128
+            // (only for FULL and KERNALSAFE modes)
+        }
+
+        test("KERNALSAFE - BASIC variables area 0x0A-0x8F") {
+            val options = createOptions(C128Target(), ZeropageType.KERNALSAFE)
+            val zp = C128Zeropage(options)
+            
+            // Virtual registers at 0x0A-0x29 are allocated (not free)
+            for (addr in 0x0Au..0x29u) {
+                zp.free.contains(addr) shouldBe false
+            }
+            
+            // Should include some locations in BASIC variables area
+            zp.free.contains(0x8Fu) shouldBe true
+        }
+
+        test("FULL - 0x0A-0xFF minus IRQ") {
+            val options = createOptions(C128Target(), ZeropageType.FULL)
+            val zp = C128Zeropage(options)
+            
+            // FULL should have many locations
+            zp.free.size shouldBeGreaterThan 150
+            
+            // IRQ locations should NOT be free
+            setOf(0x90u, 0x91u, 0xA0u, 0xA1u, 0xA2u, 0xC0u, 0xCCu, 0xCDu,
+                  0xD0u, 0xD1u, 0xD2u, 0xD3u, 0xD4u, 0xD5u, 0xF7u).forEach { addr ->
+                zp.free.contains(addr) shouldBe false
+            }
+        }
+    }
+})
+
+// Helper infix function for readability
+infix fun Int.shouldBeLessThan(value: Int) {
+    if (this >= value) {
+        throw AssertionError("Expected $this to be less than $value")
+    }
+}

codeGenCpu6502/build.gradle.kts

@@ -5,39 +5,8 @@ plugins {
 dependencies {
     implementation(project(":codeCore"))
     implementation(project(":simpleAst"))
-    // implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
-    // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation("com.michael-bull.kotlin-result:kotlin-result-jvm:2.1.0")
+    implementation("com.michael-bull.kotlin-result:kotlin-result-jvm:2.3.1")
 
-    testImplementation("io.kotest:kotest-runner-junit5-jvm:5.9.1")
-    testImplementation("io.kotest:kotest-framework-datatest:5.9.1")
-}
-
-sourceSets {
-    main {
-        java {
-            setSrcDirs(listOf("$projectDir/src"))
-        }
-        resources {
-            setSrcDirs(listOf("$projectDir/res"))
-        }
-    }
-    test {
-        java {
-            setSrcDirs(listOf("$projectDir/test"))
-        }
-    }
-}
-
-tasks.test {
-    // Enable JUnit 5 (Gradle 4.6+).
-    useJUnitPlatform()
-
-    // Always run tests, even when nothing changed.
-    dependsOn("cleanTest")
-
-    // Show test results.
-    testLogging {
-        events("skipped", "failed")
-    }
+    testImplementation(testFixtures(project(":codeCore")))
+    testImplementation("io.kotest:kotest-runner-junit5")
 }

codeGenCpu6502/codeGenCpu6502.iml

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
-      <excludeFolder url="file://$MODULE_DIR$/build" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="module" module-name="codeCore" />
-    <orderEntry type="module" module-name="simpleAst" />
-    <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
-    <orderEntry type="library" name="io.kotest.runner.junit5.jvm" level="project" />
-    <orderEntry type="library" name="io.kotest.framework.datatest" level="project" />
-  </component>
-</module>

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

@@ -1,12 +1,14 @@
 package prog8.codegen.cpu6502
 
 import prog8.code.ast.PtAsmSub
+import prog8.code.ast.PtSubroutineParameter
 import prog8.code.core.CombinedLongRegisters
 import prog8.code.core.Cx16VirtualRegisters
 import prog8.code.core.RegisterOrPair
+import prog8.code.core.RegisterOrStatusflag
 
 
-fun asmsub6502ArgsEvalOrder(sub: PtAsmSub): List<Int> {
+fun asmsub6502ArgsEvalOrder(sub: PtAsmSub, argComplexity: List<Boolean>): List<Int> {
     val order = mutableListOf<Int>()
     // order is:
     //  1) combined cx16 virtual registers (longs),
@@ -15,6 +17,8 @@ fun asmsub6502ArgsEvalOrder(sub: PtAsmSub): List<Int> {
     //  4) single CPU registers (order Y,X,A),
     //  5) floating point registers (FAC1, FAC2),
     //  6) CPU Carry status flag
+    // Within each group, complex expressions are evaluated first (they may clobber registers,
+    // so running them before simple expressions avoids needing to save/restore already-loaded values).
     val args = sub.parameters.withIndex()
     val (combinedLongRegs, args1) = args.partition { it.value.first.registerOrPair in CombinedLongRegisters }
     val (cx16regs, args2) = args1.partition { it.value.first.registerOrPair in Cx16VirtualRegisters }
@@ -23,12 +27,17 @@ fun asmsub6502ArgsEvalOrder(sub: PtAsmSub): List<Int> {
     val (singleRegsMixed, rest) = args3.partition { it.value.first.registerOrPair != null }
     val (singleCpuRegs, floatRegs) = singleRegsMixed.partition {it.value.first.registerOrPair != RegisterOrPair.FAC1 && it.value.first.registerOrPair != RegisterOrPair.FAC2  }
 
-    combinedLongRegs.forEach { order += it.index }
-    cx16regs.forEach { order += it.index }
-    pairedRegs.forEach { order += it.index }
-    singleCpuRegs.sortedBy { it.value.first.registerOrPair!!.asCpuRegister() }.asReversed().forEach { order += it.index }
+    combinedLongRegs.sortedByDescending { argComplexity[it.index] }.forEach { order += it.index }
+    cx16regs.sortedByDescending { argComplexity[it.index] }.forEach { order += it.index }
+    pairedRegs.sortedByDescending { argComplexity[it.index] }.forEach { order += it.index }
+    singleCpuRegs
+        .sortedWith(
+            compareByDescending<IndexedValue<Pair<RegisterOrStatusflag, PtSubroutineParameter>>> { argComplexity[it.index] }
+                .thenByDescending { it.value.first.registerOrPair!!.asCpuRegister() }
+        )
+        .forEach { order += it.index }
     require(rest.all { it.value.first.registerOrPair==null && it.value.first.statusflag!=null})
-    floatRegs.forEach { order += it.index }
+    floatRegs.sortedByDescending { argComplexity[it.index] }.forEach { order += it.index }
     rest.forEach { order += it.index }
     require(order.size==sub.parameters.size)
 

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

@@ -17,6 +17,10 @@ internal class AssemblyProgram(
         outputDir: Path,
         private val compTarget: ICompilationTarget) : IAssemblyProgram {
 
+    override val irInstructionCount: Int = 0
+    override val irChunkCount: Int = 0
+    override val irRegisterCount: Int = 0
+
     private val assemblyFile = outputDir.resolve("$name.asm")
     private val prgFile = outputDir.resolve("$name.prg")        // CBM prg executable program
     private val xexFile = outputDir.resolve("$name.xex")        // Atari xex executable program
@@ -132,9 +136,27 @@ internal class AssemblyProgram(
         }
 
         val proc = ProcessBuilder(assemblerCommand)
-        if(!options.quiet)
-            proc.inheritIO()
-        val process = proc.start()
+            .redirectErrorStream(true)
+
+        if (options.quiet) {
+            proc.redirectOutput(ProcessBuilder.Redirect.DISCARD)
+        }
+
+        val process = try {
+            proc.start()
+        } catch (e: Exception) {
+            System.err.println("daemon: assembler failed to start: ${e.message}")
+            return false
+        }
+
+        if (!options.quiet) {
+            process.inputStream.bufferedReader().use { reader ->
+                reader.forEachLine {
+                    println(it)
+                }
+            }
+        }
+
         val result = process.waitFor()
         if (result == 0) {
             removeGeneratedLabelsFromMonlist()

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

@@ -42,12 +42,129 @@ internal class ForLoopsAsmGen(
         when {
             iterableDt.isByteArray -> forOverNonconstByteRange(stmt, iterableDt, range)
             iterableDt.isWordArray && !iterableDt.isSplitWordArray -> forOverNonconstWordRange(stmt, iterableDt, range)
-            else -> throw AssemblyError("range expression can only be byte or word")
+            iterableDt.isLongArray -> forOverNonconstLongRange(stmt, iterableDt, range)
+            else -> throw AssemblyError("range expression can only be byte, word or long")
         }
 
         asmgen.loopEndLabels.removeLast()
     }
 
+    private fun forOverNonconstLongRange(stmt: PtForLoop, iterableDt: DataType, range: PtRange) {
+        val stepsize = range.step.asConstInteger()!!
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        asmgen.loopEndLabels.add(endLabel)
+        val varname = asmgen.asmVariableName(stmt.variable)
+        
+        asmgen.assignExpressionToVariable(range.from, varname, iterableDt.elementType())
+
+        if (stepsize == 1 || stepsize == -1)
+            forOverLongsRangeStepOne(range, varname, iterableDt, loopLabel, endLabel, stmt)
+        else
+            forOverLongsRangeStepGreaterOne(range, varname, iterableDt, loopLabel, endLabel, stmt)
+    }
+
+    private fun forOverLongsRangeStepOne(range: PtRange, varname: String, iterableDt: DataType, loopLabel: String, endLabel: String, forloop: PtForLoop) {
+        val stepsize = range.step.asConstInteger()!!
+        
+        // Use temporary variable to store the limit
+        val toValueVar = asmgen.createTempVarReused(iterableDt.elementType().base, false, range)
+        asmgen.assignExpressionToVariable(range.to, toValueVar, iterableDt.elementType())
+
+        if (stepsize == 1) {
+            // Increment toValueVar to make the loop inclusive (0 to N runs N+1 times)
+            asmgen.out("""
+                inc  $toValueVar
+                bne  +
+                inc  $toValueVar+1
+                bne  +
+                inc  $toValueVar+2
+                bne  +
+                inc  $toValueVar+3
+    +
+            """)
+        } else {
+            // Decrement toValueVar to make the loop inclusive (N downto 0 runs N+1 times)
+            val label1 = asmgen.makeLabel("dec_1")
+            val label2 = asmgen.makeLabel("dec_2")
+            val label3 = asmgen.makeLabel("dec_3")
+            asmgen.out("""
+                lda  $toValueVar
+                bne  $label1
+                lda  $toValueVar+1
+                bne  $label2
+                lda  $toValueVar+2
+                bne  $label3
+                dec  $toValueVar+3
+    $label3:    dec  $toValueVar+2
+    $label2:    dec  $toValueVar+1
+    $label1:    dec  $toValueVar
+            """)
+        }
+
+        asmgen.out(loopLabel)
+        asmgen.translate(forloop.statements)
+
+        if (stepsize == 1) {
+            asmgen.out("""
+                inc  $varname
+                bne  +
+                inc  $varname+1
+                bne  +
+                inc  $varname+2
+                bne  +
+                inc  $varname+3
++               lda  $varname
+                cmp  $toValueVar
+                bne  $loopLabel
+                lda  $varname+1
+                cmp  $toValueVar+1
+                bne  $loopLabel
+                lda  $varname+2
+                cmp  $toValueVar+2
+                bne  $loopLabel
+                lda  $varname+3
+                cmp  $toValueVar+3
+                bne  $loopLabel
+            """)
+        } else {
+            asmgen.out("""
+                lda  $varname
+                bne  +++
+                lda  $varname+1
+                bne  ++
+                lda  $varname+2
+                bne  +
+                dec  $varname+3
++               dec  $varname+2
++               dec  $varname+1
++               dec  $varname
+                lda  $varname
+                cmp  $toValueVar
+                bne  $loopLabel
+                lda  $varname+1
+                cmp  $toValueVar+1
+                bne  $loopLabel
+                lda  $varname+2
+                cmp  $toValueVar+2
+                bne  $loopLabel
+                lda  $varname+3
+                cmp  $toValueVar+3
+                bne  $loopLabel
+            """)
+        }
+        asmgen.out(endLabel)
+    }
+
+    private fun forOverLongsRangeStepGreaterOne(range: PtRange, varname: String, iterableDt: DataType, loopLabel: String, endLabel: String, forloop: PtForLoop) {
+        // TODO: implement 32-bit loop
+        asmgen.romableError("for loops over long ranges with step != 1 not yet fully implemented", forloop.position)
+        asmgen.out(loopLabel)
+        asmgen.translate(forloop.statements)
+        asmgen.jmp(loopLabel)
+        asmgen.out(endLabel)
+    }
+
     private fun forOverNonconstByteRange(stmt: PtForLoop, iterableDt: DataType, range: PtRange) {
         val stepsize = range.step.asConstInteger()!!
         val loopLabel = asmgen.makeLabel("for_loop")
@@ -737,18 +854,18 @@ $loopLabel          sty  $indexVar
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
         asmgen.loopEndLabels.add(endLabel)
+        val varname = asmgen.asmVariableName(stmt.variable)
         when {
             iterableDt.isByteArray -> {
                 // loop over byte range via loopvar, step >= 2 or <= -2
-                val varname = asmgen.asmVariableName(stmt.variable)
                 asmgen.out("""
                             lda  #${range.first}
                             sta  $varname
 $loopLabel""")
                 asmgen.translate(stmt.statements)
                 when (range.step) {
-                    0, 1, -1 -> {
-                        throw AssemblyError("step 0, 1 and -1 should have been handled specifically  $range ${stmt.position}")
+                    1, -1 -> {
+                        throw AssemblyError("step 1 and -1 should have been handled specifically  $range ${stmt.position}")
                     }
                     2 -> {
                         if(range.last==255 || range.last==254) {
@@ -805,10 +922,9 @@ $loopLabel""")
             }
             iterableDt.isWordArray && !iterableDt.isSplitWordArray -> {
                 // loop over word range via loopvar, step >= 2 or <= -2
-                val varname = asmgen.asmVariableName(stmt.variable)
                 when (range.step) {
-                    0, 1, -1 -> {
-                        throw AssemblyError("step 0, 1 and -1 should have been handled specifically  $stmt")
+                    1, -1 -> {
+                        throw AssemblyError("step 1 and -1 should have been handled specifically  $stmt")
                     }
                     else -> {
                         // word, step >= 2 or <= -2
@@ -826,7 +942,6 @@ $loopLabel""")
                             bne  +
                             lda  $varname+1
                             cmp  #>${range.last}
-                            bne  +
                             beq  $endLabel
 +                           lda  $varname
                             clc
@@ -843,11 +958,54 @@ $loopLabel""")
             iterableDt.isLongArray -> {
                 // loop over long range via loopvar, step >= 2 or <= -2
                 when(range.step) {
-                    0, 1, -1 -> {
-                        throw AssemblyError("step 0, 1 and -1 should have been handled specifically  $stmt")
+                    1, -1 -> {
+                        throw AssemblyError("step 1 and -1 should have been handled specifically  $stmt")
                     }
                     else -> {
-                        TODO("for long range. Report this error please, and use word loops in the meantime  ${stmt.position}")
+                        // long, step >= 2 or <= -2
+                        // note: range.last has already been adjusted by kotlin itself to actually be the last value of the sequence
+                        val from = range.first.toLongHex()
+                        val to = range.last.toLongHex()
+                        val step = range.step.toLongHex()
+                        asmgen.out("""
+                            lda  #$${from.substring(6, 8)}
+                            sta  $varname
+                            lda  #$${from.substring(4, 6)}
+                            sta  $varname+1
+                            lda  #$${from.substring(2, 4)}
+                            sta  $varname+2
+                            lda  #$${from.take(2)}
+                            sta  $varname+3
+$loopLabel""")
+                        asmgen.translate(stmt.statements)
+                        asmgen.out("""
+                            lda  $varname
+                            cmp  #$${to.substring(6, 8)}
+                            bne  +
+                            lda  $varname+1
+                            cmp  #$${to.substring(4, 6)}
+                            bne  +
+                            lda  $varname+2
+                            cmp  #$${to.substring(2, 4)}
+                            bne  +
+                            lda  $varname+3
+                            cmp  #$${to.take(2)}
+                            beq  $endLabel
++                           lda  $varname
+                            clc
+                            adc  #$${step.substring(6, 8)}
+                            sta  $varname
+                            lda  $varname+1
+                            adc  #$${step.substring(4, 6)}
+                            sta  $varname+1
+                            lda  $varname+2
+                            adc  #$${step.substring(2, 4)}
+                            sta  $varname+2
+                            lda  $varname+3
+                            adc  #$${step.take(2)}
+                            sta  $varname+3""")
+                        asmgen.jmp(loopLabel)
+                        asmgen.out(endLabel)
                     }
                 }
             }
@@ -987,12 +1145,106 @@ $loopLabel""")
 
     private fun translateForSimpleLongRangeAsc(stmt: PtForLoop, range: IntProgression) {
         require(range.step==1)
-        TODO("for long range step +1. Report this error please, and use nested word loops in the meantime  ${stmt.position}")
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        asmgen.loopEndLabels.add(endLabel)
+        val varname = asmgen.asmVariableName(stmt.variable)
+        val from = range.first.toLongHex()
+        val to = range.last.toLongHex()
+        asmgen.out("""
+            lda  #$${from.substring(6, 8)}
+            sta  $varname
+            lda  #$${from.substring(4, 6)}
+            sta  $varname+1
+            lda  #$${from.substring(2, 4)}
+            sta  $varname+2
+            lda  #$${from.take(2)}
+            sta  $varname+3
+$loopLabel""")
+        asmgen.translate(stmt.statements)
+        asmgen.out("""
+            lda  $varname
+            cmp  #$${to.substring(6, 8)}
+            bne  +
+            lda  $varname+1
+            cmp  #$${to.substring(4, 6)}
+            bne  +
+            lda  $varname+2
+            cmp  #$${to.substring(2, 4)}
+            bne  +
+            lda  $varname+3
+            cmp  #$${to.take(2)}
+            beq  $endLabel
++           inc  $varname
+            bne  $loopLabel
+            inc  $varname+1
+            bne  $loopLabel
+            inc  $varname+2
+            bne  $loopLabel
+            inc  $varname+3""")
+        asmgen.jmp(loopLabel)
+        asmgen.out(endLabel)
+        asmgen.loopEndLabels.removeLast()
     }
 
     private fun translateForSimpleLongRangeDesc(stmt: PtForLoop, range: IntProgression) {
         require(range.step==-1)
-        TODO("for long range step -1. Report this error please, and use nested word loops in the meantime  ${stmt.position}")
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        asmgen.loopEndLabels.add(endLabel)
+        val varname = asmgen.asmVariableName(stmt.variable)
+        val from = range.first.toLongHex()
+        val to = range.last.toLongHex()
+        asmgen.out("""
+            lda  #$${from.substring(6, 8)}
+            sta  $varname
+            lda  #$${from.substring(4, 6)}
+            sta  $varname+1
+            lda  #$${from.substring(2, 4)}
+            sta  $varname+2
+            lda  #$${from.take(2)}
+            sta  $varname+3
+$loopLabel""")
+        asmgen.translate(stmt.statements)
+        if(range.last==0) {
+            asmgen.out("""
+                lda  $varname
+                bne  ++++
+                lda  $varname+1
+                bne  +++
+                lda  $varname+2
+                bne  ++
+                lda  $varname+3
+                beq  $endLabel""")
+        } else {
+            asmgen.out("""
+                lda  $varname
+                cmp  #$${to.substring(6, 8)}
+                bne  +
+                lda  $varname+1
+                cmp  #$${to.substring(4, 6)}
+                bne  +
+                lda  $varname+2
+                cmp  #$${to.substring(2, 4)}
+                bne  +
+                lda  $varname+3
+                cmp  #$${to.take(2)}
+                beq  $endLabel""")
+        }
+        asmgen.out("""
++           lda  $varname
+            bne  +++
+            lda  $varname+1
+            bne  ++
+            lda  $varname+2
+            bne  +
+            dec  $varname+3
++           dec  $varname+2
++           dec  $varname+1
++           dec  $varname""")
+        asmgen.jmp(loopLabel)
+        asmgen.out(endLabel)
+        asmgen.loopEndLabels.removeLast()
     }
 
     private fun assignLoopvarWord(stmt: PtForLoop, range: PtRange) =

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

@@ -9,6 +9,16 @@ import prog8.codegen.cpu6502.assignment.AsmAssignment
 import prog8.codegen.cpu6502.assignment.TargetStorageKind
 
 
+/*
+ * CRITICAL: `inline asmsub` subroutines MUST be inlined at the call site.
+ * They are NOT called with jsr - their assembly body is copied directly into the caller.
+ * This means: no .proc/.pend, no rts, no jsr. The return value is left in the appropriate
+ * CPU register (A/X/Y) and the caller picks it up.
+ *
+ * This is handled at line 68: `if (sub.inline) { ... }`.
+ * Any new codegen backend MUST replicate this behavior.
+ */
+
 internal class FunctionCallAsmGen(private val program: PtProgram, private val asmgen: AsmGen6502Internal) {
 
     internal fun translateFunctionCallStatement(stmt: PtFunctionCall) {
@@ -33,7 +43,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         // NOTE: does NOT output code to save/restore the X register for this call! Every caller should deal with this in their own way!!
         //       (you can use subroutine.shouldSaveX() and saveX()/restoreX() routines as a help for this)
 
-        val symbol = asmgen.symbolTable.lookup(call.name)!!
+        val symbol = asmgen.symbolTable.lookup(call.name) ?: asmgen.symbolTable.lookupUnscoped(call.name) ?: throw IllegalStateException("Symbol not found: ${call.name}")
         if(symbol.type == StNodeType.LABEL) {
             require(call.void)
             asmgen.out("  jsr  ${asmgen.asmSymbolName(symbol.scopedNameString)}")
@@ -44,6 +54,26 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         val subAsmName = asmgen.asmSymbolName(call.name)
 
         if(sub is PtAsmSub) {
+            val varBank = sub.address?.varbank
+            var varbank: String? = null
+            var bankFixLabel: String? = null
+            if (varBank != null) {
+                // the bank variable can also be the name of a subroutine that should be called to return the bank byte dynamically
+                val bankSymbol = asmgen.symbolTable.lookup(varBank.name) ?: asmgen.symbolTable.lookupUnscoped(varBank.name)
+                if (bankSymbol?.type == StNodeType.SUBROUTINE || bankSymbol?.type == StNodeType.EXTSUB) {
+                    val extsubId = asmgen.extsubCallSiteIds[sub]
+                    if (extsubId != null) {
+                        asmgen.out("  lda  #${extsubId.toInt()}")
+                    }
+                    asmgen.out("  jsr  ${asmgen.asmSymbolName(varBank.name)}")
+                    // store bank byte directly into the JSRFAR instruction data (forward label reference)
+                    bankFixLabel = asmgen.makeLabel("bank")
+                    asmgen.out("  sta  $bankFixLabel")
+                } else {
+                    varbank = asmgen.asmVariableName(varBank)
+                }
+            }
+
             argumentsViaRegisters(sub, call)
             if (sub.inline) {
                 // inline the subroutine. (regardless of optimization settings!)
@@ -56,54 +86,57 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
             } else {
                 val bank = sub.address?.constbank?.toString()
                 if(bank==null) {
-                    val varbank = if(sub.address?.varbank==null) null else asmgen.asmVariableName(sub.address!!.varbank!!)
-                    if(varbank!=null) {
+                    if(varbank!=null || bankFixLabel!=null) {
                         if(asmgen.options.romable)
                             TODO("no codegen yet for non-const bank in subroutine call that's usable in ROM  ${call.position}")
 
+                        // variable bank case: save/restore registers around the self-modifying sta
+                        if(varbank!=null) {
+                            asmgen.out("""
+                                php
+                                pha
+                                lda  $varbank
+                                sta  +
+                                pla
+                                plp""")
+                        }
+                        val label = bankFixLabel ?: "+"
+
                         // self-modifying code: set jsrfar bank argument
                         when(asmgen.options.compTarget.name) {
                             "cx16" -> {
                                 // JSRFAR can jump to a banked RAM address as well!
                                 asmgen.out("""
-                                php
-                                pha
-                                lda  $varbank
-                                sta  +
-                                pla
-                                plp
                                 jsr  cx16.JSRFAR
                                 .word  $subAsmName    ; ${sub.address!!.address.toHex()}
-+                               .byte  0    ; modified"""
+$label .byte  0    ; modified"""
                                 )
                             }
                             "c64" -> {
                                 asmgen.out("""
-                                php
-                                pha
-                                lda  $varbank
-                                sta  +
-                                pla
-                                plp
                                 jsr  c64.x16jsrfar
                                 .word  $subAsmName    ; ${sub.address!!.address.toHex()}
-+                               .byte  0    ; modified"""
+$label .byte  0    ; modified"""
                                 )
                             }
                             "c128" -> {
                                 asmgen.out("""
-                                php
-                                pha
-                                lda  $varbank
-                                sta  +
-                                pla
-                                plp
                                 jsr  c128.x16jsrfar
                                 .word  $subAsmName    ; ${sub.address!!.address.toHex()}
-+                               .byte  0    ; modified"""
+$label .byte  0    ; modified"""
                                 )
                             }
-                            else -> throw AssemblyError("callfar is not supported on the selected compilation target")
+                            else -> {
+                                if(asmgen.options.compTarget.supportsBankedCalls) {
+                                    val targetName = asmgen.options.compTarget.name
+                                    asmgen.out("""
+                                        jsr  $targetName.x16jsrfar
+                                        .word  $subAsmName    ; ${sub.address!!.address.toHex()}
+$label .byte  0    ; modified"""
+                                    )
+                                } else
+                                    throw AssemblyError("callfar is not supported on the selected compilation target")
+                            }
                         }
                     } else {
                         asmgen.out("  jsr  $subAsmName")
@@ -133,7 +166,17 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                                 .byte  $bank"""
                             )
                         }
-                        else -> throw AssemblyError("callfar is not supported on the selected compilation target")
+                        else -> {
+                            if(asmgen.options.compTarget.supportsBankedCalls) {
+                                val targetName = asmgen.options.compTarget.name
+                                asmgen.out("""
+                                    jsr  $targetName.x16jsrfar
+                                    .word  $subAsmName    ; ${sub.address!!.address.toHex()}
+                                    .byte  $bank"""
+                                )                                
+                            } else
+                                throw AssemblyError("callfar is not supported on the selected compilation target")
+                        }
                     }
                 }
             }
@@ -203,7 +246,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
 
     private fun usesOtherRegistersWhileEvaluating(arg: PtExpression): Boolean {
         return when(arg) {
-            is PtBuiltinFunctionCall -> {
+            is PtFunctionCall if arg.builtin -> {
                 if (arg.name in setOf("lsb", "msb", "lsw", "msw"))
                     usesOtherRegistersWhileEvaluating(arg.args[0])
                 else if (arg.name == "mkword" || arg.name == "mklong2")
@@ -234,7 +277,8 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         if(sub.parameters.size==1) {
             argumentViaRegister(sub, IndexedValue(0, sub.parameters.single().second), call.args[0])
         } else {
-            val optimalEvalOrder = asmsub6502ArgsEvalOrder(sub)
+            val argComplexity = call.args.map { usesOtherRegistersWhileEvaluating(it) }
+            val optimalEvalOrder = asmsub6502ArgsEvalOrder(sub, argComplexity)
             optimalEvalOrder.forEach {
                 val param = sub.parameters[it]
                 val arg = call.args[it]
@@ -268,8 +312,8 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
 
         val reg = parameter.register
         if(reg!=null) {
-            require(reg in Cx16VirtualRegisters) { "can only use R0-R15 'registers' here" }
-            val varName = "cx16.${reg.name.lowercase()}"
+            require(reg in Cx16VirtualRegisters || reg in CombinedLongRegisters) { "can only use R0-R15 'registers' here" }
+            val varName = reg.asScopedNameVirtualReg(value.type).joinToString(".")
             asmgen.assignExpressionToVariable(value, varName, parameter.type)
         } else {
             val varName = asmgen.asmVariableName(sub.scopedName + "." + parameter.name)
@@ -333,7 +377,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                 // we need to sign extend the source, do this via temporary word variable
                 asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_W1", DataType.UBYTE)
                 asmgen.signExtendVariableLsb("P8ZP_SCRATCH_W1", value.type.base)
-                asmgen.assignVariableToRegister("P8ZP_SCRATCH_W1", register, null, Position.DUMMY)
+                asmgen.assignVariableToRegister("P8ZP_SCRATCH_W1", register, null, value.position)
             } else {
                 val scope = value.definingISub()
                 val target: AsmAssignTarget =
@@ -343,8 +387,8 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                         AsmAssignTarget.fromRegisters(register, parameter.value.type.isSigned, value.position, scope, asmgen)
                     }
                 val src = if(value.type.isPassByRef) {
-                    if(value is PtIdentifier) {
-                        val addr = PtAddressOf(value.type.typeForAddressOf(false), false, Position.DUMMY)
+                    if(value is PtIdentifier || value is PtPointerDeref) {
+                        val addr = PtAddressOf(value.type.typeForAddressOf(false), false, value.position)
                         addr.add(value)
                         addr.parent = scope as PtNode
                         AsmAssignSource.fromAstSource(addr, program, asmgen).adjustSignedUnsigned(target)
@@ -382,6 +426,9 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         if(argType.isUnsignedWord && paramType.isString)
             return true
 
+        if (argType.isArray && (paramType.isString || paramType.isPointerToByte))
+            return true
+
         return false
     }
 }

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

@@ -352,7 +352,7 @@ internal class ProgramAndVarsGen(
         val varsInBlock = getVars(scope)
 
         // Zeropage Variables
-        val varnames = varsInBlock.filter { it.value.type==StNodeType.STATICVAR }.map { it.value.scopedNameString }.toSet()
+        val varnames = varsInBlock.filter { it.value.type==StNodeType.STATICVAR }.mapTo(mutableSetOf()) { it.value.scopedNameString }
         zeropagevars2asm(varnames)
 
         // MemDefs and Consts
@@ -372,13 +372,14 @@ internal class ProgramAndVarsGen(
     }
 
     private fun asmTypeString(dt: DataType): String {
+        val effectiveDt = if(dt.isArray) dt.elementType() else dt
         return when {
-            dt.isBool || dt.isUnsignedByte -> ".byte"
-            dt.isSignedByte -> ".char"
-            dt.isUnsignedWord || dt.isPointer -> ".word"
-            dt.isSignedWord -> ".sint"
-            dt.isLong -> ".dint"
-            dt.isFloat -> ".byte"
+            effectiveDt.isBool || effectiveDt.isUnsignedByte -> ".byte"
+            effectiveDt.isSignedByte -> ".char"
+            effectiveDt.isUnsignedWord || effectiveDt.isPointer -> ".word"
+            effectiveDt.isSignedWord -> ".sint"
+            effectiveDt.isLong -> ".dint"
+            effectiveDt.isFloat -> ".byte"
             else -> {
                 throw AssemblyError("weird dt")
             }
@@ -387,39 +388,56 @@ internal class ProgramAndVarsGen(
 
     private fun structInstances2asm() {
 
-        fun initValues(instance: StStructInstance): List<String> {
-            val structtype: StStruct = symboltable.lookup(instance.structName) as StStruct
-            return structtype.fields.zip(instance.initialValues).map { (field, value) ->
-                if(field.first.isFloat) {
-                    "["+compTarget.getFloatAsmBytes(value.number!!)+"]"
-                } else {
-                    when {
-                        value.number!=null -> {
-                            if(field.first.isPointer)
-                                "$"+value.number!!.toInt().toString(16)
-                            else if(field.first.isInteger)
-                                value.number!!.toInt().toString()
-                            else
-                                value.number.toString()
-                        }
-                        value.addressOfSymbol!=null -> value.addressOfSymbol!!
-                        value.boolean!=null -> if(value.boolean==true) "1" else "0"
-                        else -> throw AssemblyError("weird struct initial value $value")
-                    }
+        fun formatValue(value: StArrayElement, dt: DataType): String {
+            if(dt.isFloat) {
+                val numValue = (value as? StArrayElement.Number)?.value
+                    ?: throw AssemblyError("expected number for float field")
+                return "["+compTarget.getFloatAsmBytes(numValue)+"]"
+            }
+            return when (value) {
+                is StArrayElement.Number -> {
+                    if(dt.isPointer)
+                        "$"+value.value.toInt().toString(16)
+                    else if(dt.isInteger)
+                        value.value.toInt().toString()
+                    else
+                        value.value.toString()
+                }
+                is StArrayElement.AddressOf -> value.symbol
+                is StArrayElement.MemorySlab -> "$StMemorySlabBlockName.${value.name}"
+                is StArrayElement.BoolValue -> if(value.value) "1" else "0"
+                is StArrayElement.StructInstance -> throw AssemblyError("struct instance in struct initializer")
+            }
+        }
+
+        fun flatInitValues(instance: StStructInstance, structtype: StStruct): List<String> {
+            var valueIndex = 0
+            return structtype.fields.flatMap { field ->
+                val arraySz = field.arraySize
+                val count = arraySz ?: 1
+                val elemDt = if(arraySz!=null) field.type.elementType() else field.type
+                (0 until count).map {
+                    val value = instance.initialValues[valueIndex++]
+                    formatValue(value, elemDt)
                 }
             }
         }
 
-
         asmgen.out("; struct types")
         symboltable.allStructTypes().distinctBy { it.name }.forEach { structtype ->
-            val structargs = structtype.fields.withIndex().joinToString(",") { field -> "f${field.index}" }
+            val paramFields = structtype.fields.filter { !it.isArray }
+            val structargs = paramFields.indices.joinToString(",") { "f$it" }
             asmgen.out("${structtype.scopedNameString}    .struct $structargs\n")
-            structtype.fields.withIndex().forEach { (index, field) ->
-                val dt = field.first
-                val varname = "f${index}"
-                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
+            var paramIdx = 0
+            for(field in structtype.fields) {
+                val type = asmTypeString(field.type)
+                if(field.isArray) {
+                    val anonymous = List(field.arraySize!!) { "?" }.joinToString(",")
+                    asmgen.out("p8v_${field.name}  $type  $anonymous")
+                } else {
+                    asmgen.out("p8v_${field.name}  $type  \\f$paramIdx")
+                    paramIdx++
+                }
             }
             asmgen.out("    .endstruct\n")
         }
@@ -430,14 +448,7 @@ internal class ProgramAndVarsGen(
         asmgen.out("${StStructInstanceBlockName}_bss  .block\n")
         instancesNoInit.forEach {
             val structtype: StStruct = symboltable.lookup(it.structName) as StStruct
-            val zerovalues = structtype.fields.map { field ->
-                if(field.first.isFloat) {
-                    val floatbytes = List(compTarget.memorySize(BaseDataType.FLOAT)) { "?" }
-                    "[${floatbytes.joinToString(",")}]"
-                }
-                else "?"
-            }
-            asmgen.out("${it.name}    .dstruct  ${it.structName}, ${zerovalues.joinToString(",")}\n")
+            asmgen.out("${it.name}    .fill  ${structtype.size}\n")
         }
         asmgen.out("    .endblock\n")
         asmgen.out("    .send BSS\n")
@@ -445,9 +456,28 @@ internal class ProgramAndVarsGen(
         asmgen.out("; struct instances with initialization values\n")
         asmgen.out("    .section STRUCTINSTANCES\n")
         asmgen.out("$StStructInstanceBlockName  .block\n")
-        instances.forEach {
-            val instancename = it.name.substringAfter('.')
-            asmgen.out("$instancename    .dstruct  ${it.structName}, ${initValues(it).joinToString(",")}\n")
+        instances.forEach { instance ->
+            val instancename = instance.name.substringAfter('.')
+            val structtype: StStruct = symboltable.lookup(instance.structName) as StStruct
+            val values = flatInitValues(instance, structtype)
+            val hasArrays = structtype.fields.any { fld -> fld.isArray }
+            if(hasArrays) {
+                asmgen.out(instancename)
+                var valueIndex = 0
+                for(field in structtype.fields) {
+                    val arraySz = field.arraySize
+                    val count = arraySz ?: 1
+                    val elemDt = if(arraySz!=null) field.type.elementType() else field.type
+                    val type = asmTypeString(elemDt)
+                    val fieldValues = (0 until count).joinToString(",") {
+                        formatValue(instance.initialValues[valueIndex++], elemDt)
+                    }
+                    asmgen.out("  $type  $fieldValues")
+                }
+                asmgen.out("\n")
+            } else {
+                asmgen.out("$instancename    .dstruct  ${instance.structName}, ${values.joinToString(",")}\n")
+            }
         }
         asmgen.out("    .endblock\n")
         asmgen.out("    .send STRUCTINSTANCES\n")
@@ -502,7 +532,7 @@ internal class ProgramAndVarsGen(
         val varsInSubroutine = getVars(scope)
 
         // Zeropage Variables
-        val varnames = varsInSubroutine.filter { it.value.type==StNodeType.STATICVAR }.map { it.value.scopedNameString }.toSet()
+        val varnames = varsInSubroutine.filter { it.value.type==StNodeType.STATICVAR }.mapTo(mutableSetOf()) { it.value.scopedNameString }
         zeropagevars2asm(varnames)
 
         // MemDefs and Consts
@@ -614,18 +644,26 @@ internal class ProgramAndVarsGen(
             arrayVarsWithInitInZp.forEach {
                 val size = it.alloc.size
                 val name = asmgen.asmVariableName(it.name)
-                asmgen.out("""
-                    lda  #<${name}_init_value
-                    ldy  #>${name}_init_value
-                    sta  cx16.r0
-                    sty  cx16.r0+1
-                    lda  #<${name}
-                    ldy  #>${name}
-                    sta  cx16.r1
-                    sty  cx16.r1+1
-                    lda  #<$size
-                    ldy  #>$size
-                    jsr  sys.memcopy""")
+                if(it.alloc.dt.isSplitWordArray) {
+                    val halfSize = size / 2
+                    if(halfSize>0) {
+                        asmgen.out("""
+                            ldx  #${halfSize-1}
+                    -       lda  ${name}_init_value_lsb,x
+                            sta  ${name}_lsb,x
+                            lda  ${name}_init_value_msb,x
+                            sta  ${name}_msb,x
+                            dex
+                            bpl  -""")
+                    }
+                } else {
+                    asmgen.out("""
+                        ldx  #${size-1}
+                -       lda  ${name}_init_value,x
+                        sta  ${name},x
+                        dex
+                        bpl  -""")
+                }
             }
             asmgen.out("  jmp  +")
         }
@@ -739,7 +777,7 @@ internal class ProgramAndVarsGen(
                     it.initializationStringValue!!.second,
                     it.initializationStringValue!!.first
                 )
-                asmgen.romableError("string (${it.dt} ${it.name}) can only be used as read-only in ROMable code", Position.DUMMY, false)     // TODO print warning with position of the var
+                asmgen.romableError("string (${it.dt} ${it.name}) can only be used as read-only in ROMable code", it.astNode?.position ?: Position.DUMMY, false)
             }
             alignedStrings.sortedBy { it.align }.forEach {
                 outputStringvar(
@@ -748,22 +786,22 @@ internal class ProgramAndVarsGen(
                     it.initializationStringValue!!.second,
                     it.initializationStringValue!!.first
                 )
-                asmgen.romableError("string (${it.dt} ${it.name}) can only be used as read-only in ROMable code", Position.DUMMY, false)     // TODO print warning with position of the var
+                asmgen.romableError("string (${it.dt} ${it.name}) can only be used as read-only in ROMable code", it.astNode?.position ?: Position.DUMMY, false)
             }
 
             notAlignedOther.sortedBy { it.type }.forEach {
                 staticVariable2asm(it)
                 if(it.dt.isArray)
-                    asmgen.romableError("array (${it.dt} ${it.name}) can only be used as read-only in ROMable code", Position.DUMMY, false)     // TODO print warning with position of the var
+                    asmgen.romableError("array (${it.dt} ${it.name}) can only be used as read-only in ROMable code", it.astNode?.position ?: Position.DUMMY, false)
                 else
-                    asmgen.romableError("inlined variable (${it.dt} ${it.name})", Position.DUMMY)       // TODO print warning with position of the var
+                    asmgen.romableError("inlined variable (${it.dt} ${it.name})", it.astNode?.position ?: Position.DUMMY)
             }
             alignedOther.sortedBy { it.align }.sortedBy { it.type }.forEach {
                 staticVariable2asm(it)
                 if(it.dt.isArray)
-                    asmgen.romableError("array (${it.dt} ${it.name}) can only be used as read-only in ROMable code", Position.DUMMY, false)     // TODO print warning with position of the var
+                    asmgen.romableError("array (${it.dt} ${it.name}) can only be used as read-only in ROMable code", it.astNode?.position ?: Position.DUMMY, false)
                 else
-                    asmgen.romableError("inlined variable (${it.dt} ${it.name})", Position.DUMMY)       // TODO print warning with position of the var
+                    asmgen.romableError("inlined variable (${it.dt} ${it.name})", it.astNode?.position ?: Position.DUMMY)
             }
         }
     }
@@ -871,14 +909,14 @@ internal class ProgramAndVarsGen(
             dt.isSplitWordArray -> {
                 if(dt.elementType().isUnsignedWord || dt.elementType().isPointer) {
                     val data = makeArrayFillDataUnsigned(dt, value, orNumberOfZeros)
-                    asmgen.out("_array_$varname := ${data.joinToString()}")
-                    asmgen.out("${varname}_lsb\t.byte <_array_$varname")
-                    asmgen.out("${varname}_msb\t.byte >_array_$varname")
+                    asmgen.out("${varname}_words := ${data.joinToString()}")
+                    asmgen.out("${varname}_lsb\t.byte <${varname}_words")
+                    asmgen.out("${varname}_msb\t.byte >${varname}_words")
                 } else {
                     val data = makeArrayFillDataSigned(dt, value, orNumberOfZeros)
-                    asmgen.out("_array_$varname := ${data.joinToString()}")
-                    asmgen.out("${varname}_lsb\t.byte <_array_$varname")
-                    asmgen.out("${varname}_msb\t.byte >_array_$varname")
+                    asmgen.out("${varname}_words := ${data.joinToString()}")
+                    asmgen.out("${varname}_lsb\t.byte <${varname}_words")
+                    asmgen.out("${varname}_msb\t.byte >${varname}_words")
                 }
             }
             dt.isUnsignedWordArray -> {
@@ -914,7 +952,9 @@ internal class ProgramAndVarsGen(
             dt.isFloatArray -> {
                 val array = value ?: zeroFilledArray(orNumberOfZeros!!)
                 val floatFills = array.map {
-                    compTarget.getFloatAsmBytes(it.number!!)
+                    val numValue = (it as? StArrayElement.Number)?.value 
+                        ?: throw AssemblyError("expected number for float array")
+                    compTarget.getFloatAsmBytes(numValue)
                 }
                 asmgen.out(varname)
                 for (f in array.zip(floatFills))
@@ -925,11 +965,7 @@ internal class ProgramAndVarsGen(
     }
 
     private fun zeroFilledArray(numElts: Int): StArray {
-        val values = mutableListOf<StArrayElement>()
-        repeat(numElts) {
-            values.add(StArrayElement(0.0, null, null,null,null))
-        }
-        return values
+        return List(numElts) { StArrayElement.Number(0.0) }
     }
 
     private fun memdefsAndConsts2asm(memvars: Collection<StMemVar>, consts: Collection<StConstant>) {
@@ -937,10 +973,17 @@ internal class ProgramAndVarsGen(
             asmgen.out("  ${it.name} = ${it.address.toHex()}")
         }
         consts.sortedBy { it.name }.forEach {
+            val nameWithoutColons = it.name.replace("::", "_")
             if(it.dt.isFloat)
-                asmgen.out("  ${it.name} = ${it.value}")
-            else
-                asmgen.out("  ${it.name} = ${it.value.toHex()}")
+                asmgen.out("  ${nameWithoutColons} = ${it.value}")
+            else {
+                if(it.value!=null)
+                    asmgen.out("  ${nameWithoutColons} = ${it.value!!.toHex()}")
+                else if(it.memorySlab!=null)
+                    asmgen.out("  ${nameWithoutColons} = ${StMemorySlabBlockName}.${it.memorySlab!!.name}")
+                else
+                    TODO("asm gen for ${nameWithoutColons} = memory alloc?")
+            }
         }
     }
 
@@ -970,41 +1013,35 @@ internal class ProgramAndVarsGen(
         val array = value ?: zeroFilledArray(orNumberOfZeros!!)
         return when {
             dt.isBoolArray ->
-                // byte array can never contain pointer-to types, so treat values as all integers
                 array.map {
-                    if(it.boolean!=null)
-                        if(it.boolean==true) "1" else "0"
-                    else {
-                        val number = it.number!!
-                        if(number==0.0) "0" else "1"
+                    when(it) {
+                        is StArrayElement.BoolValue -> if(it.value) "1" else "0"
+                        is StArrayElement.Number -> if(it.value==0.0) "0" else "1"
+                        else -> throw AssemblyError("unexpected array element type for bool array")
                     }
                 }
             dt.isUnsignedByteArray ->
-                // byte array can never contain pointer-to types, so treat values as all integers
                 array.map {
-                    val number = it.number!!.toInt()
-                    "$"+number.toString(16).padStart(2, '0')
+                    val numValue = (it as? StArrayElement.Number)?.value 
+                        ?: throw AssemblyError("expected number for ubyte array")
+                    "$"+numValue.toInt().toString(16).padStart(2, '0')
                 }
             dt.isArray && (dt.elementType().isUnsignedWord || dt.elementType().isPointer) -> array.map {
-                if(it.number!=null) {
-                    "$" + it.number!!.toInt().toString(16).padStart(4, '0')
-                }
-                else if(it.addressOfSymbol!=null) {
-                    val addrOfSymbol = it.addressOfSymbol!!
-                    val symbol = symboltable.lookup(addrOfSymbol)!!
-                    if(symbol is StStaticVariable && symbol.dt.isSplitWordArray)
-                        asmgen.asmSymbolName(addrOfSymbol+"_lsb")  // the _lsb split array comes first in memory
-                    else
-                        asmgen.asmSymbolName(addrOfSymbol)
-                }
-                else if(it.structInstance!=null) {
-                    asmgen.asmSymbolName("${StStructInstanceBlockName}.${it.structInstance!!}")
-                }
-                else if(it.structInstanceUninitialized!=null) {
-                    asmgen.asmSymbolName("${StStructInstanceBlockName}_bss.${it.structInstanceUninitialized!!}")
-                }
-                else {
-                    throw AssemblyError("weird array elt")
+                when(it) {
+                    is StArrayElement.Number -> "$" + it.value.toInt().toString(16).padStart(4, '0')
+                    is StArrayElement.AddressOf -> {
+                        val symbol = symboltable.lookup(it.symbol)!!
+                        if(symbol is StStaticVariable && symbol.dt.isSplitWordArray)
+                            asmgen.asmSymbolName(it.symbol+"_lsb")
+                        else
+                            asmgen.asmSymbolName(it.symbol)
+                    }
+                    is StArrayElement.MemorySlab -> asmgen.asmSymbolName("$StMemorySlabBlockName.${it.name}")
+                    is StArrayElement.StructInstance -> {
+                        val prefix = if(it.uninitialized) "${StStructInstanceBlockName}_bss" else StStructInstanceBlockName
+                        asmgen.asmSymbolName("$prefix.${it.name}")
+                    }
+                    is StArrayElement.BoolValue -> throw AssemblyError("bool in word array")
                 }
             }
             else -> throw AssemblyError("invalid dt")
@@ -1014,41 +1051,66 @@ internal class ProgramAndVarsGen(
     private fun makeArrayFillDataSigned(dt: DataType, value: StArray?, orNumberOfZeros: Int?): List<String> {
         val array = value ?: zeroFilledArray(orNumberOfZeros!!)
         return when {
-            // byte array can never contain pointer-to types, so treat values as all integers
             dt.isUnsignedByteArray ->
                 array.map {
-                    val number = it.number!!.toInt()
+                    val numValue = (it as? StArrayElement.Number)?.value 
+                        ?: throw AssemblyError("expected number for ubyte array")
+                    val number = numValue.toInt()
                     "$"+number.toString(16).padStart(2, '0')
                 }
             dt.isSignedByteArray ->
                 array.map {
-                    val number = it.number!!.toInt()
+                    val numValue = (it as? StArrayElement.Number)?.value 
+                        ?: throw AssemblyError("expected number for byte array")
+                    val number = numValue.toInt()
                     val hexnum = number.absoluteValue.toString(16).padStart(2, '0')
-                    if(number>=0)
-                        "$$hexnum"
-                    else
-                        "-$$hexnum"
+                    if(number>=0) "$$hexnum" else "-$$hexnum"
+                }
+            dt.isArray && (dt.elementType().isUnsignedWord || dt.elementType().isPointer) ->
+                array.map {
+                    when(it) {
+                        is StArrayElement.Number -> "$" + it.value.toInt().toString(16).padStart(4, '0')
+                        is StArrayElement.AddressOf -> {
+                            val symbol = symboltable.lookup(it.symbol)!!
+                            if(symbol is StStaticVariable && symbol.dt.isSplitWordArray)
+                                asmgen.asmSymbolName(it.symbol+"_lsb")
+                            else
+                                asmgen.asmSymbolName(it.symbol)
+                        }
+                        is StArrayElement.MemorySlab -> asmgen.asmSymbolName("$StMemorySlabBlockName.${it.name}")
+                        is StArrayElement.StructInstance -> {
+                            val prefix = if(it.uninitialized) "${StStructInstanceBlockName}_bss" else StStructInstanceBlockName
+                            asmgen.asmSymbolName("$prefix.${it.name}")
+                        }
+                        is StArrayElement.BoolValue -> throw AssemblyError("bool in word array")
+                    }
+                }
+            dt.isSignedWordArray ->
+                array.map {
+                    when(it) {
+                        is StArrayElement.Number -> {
+                            val number = it.value.toInt()
+                            val hexnum = number.absoluteValue.toString(16).padStart(4, '0')
+                            if (number >= 0) "$$hexnum" else "-$$hexnum"
+                        }
+                        is StArrayElement.AddressOf -> asmgen.asmSymbolName(it.symbol)
+                        is StArrayElement.MemorySlab -> asmgen.asmSymbolName("$StMemorySlabBlockName.${it.name}")
+                        else -> throw AssemblyError("unexpected array element type for signed word array")
+                    }
+                }
+            dt.isLongArray ->
+                array.map {
+                    when(it) {
+                        is StArrayElement.Number -> {
+                            val number = it.value.toInt()
+                            val hexnum = number.absoluteValue.toLongHex()
+                            if (number >= 0) "$$hexnum" else "-$$hexnum"
+                        }
+                        is StArrayElement.AddressOf -> asmgen.asmSymbolName(it.symbol)
+                        is StArrayElement.MemorySlab -> asmgen.asmSymbolName("$StMemorySlabBlockName.${it.name}")
+                        else -> throw AssemblyError("unexpected array element type for long array")
+                    }
                 }
-            dt.isArray && (dt.elementType().isUnsignedWord || dt.elementType().isPointer) -> array.map {
-                val number = it.number!!.toInt()
-                "$" + number.toString(16).padStart(4, '0')
-            }
-            dt.isSignedWordArray -> array.map {
-                val number = it.number!!.toInt()
-                val hexnum = number.absoluteValue.toString(16).padStart(4, '0')
-                if(number>=0)
-                    "$$hexnum"
-                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/VariableAllocator.kt

@@ -1,19 +1,23 @@
 package prog8.codegen.cpu6502
 
 import com.github.michaelbull.result.fold
-import com.github.michaelbull.result.onSuccess
+import com.github.michaelbull.result.onOk
 import prog8.code.*
+import prog8.code.ast.*
 import prog8.code.core.*
 
 
 internal class VariableAllocator(private val symboltable: SymbolTable,
                                  private val options: CompilationOptions,
-                                 private val errors: IErrorReporter
+                                 private val errors: IErrorReporter,
+                                 private val program: PtProgram
 ) {
 
     private val zeropage = options.compTarget.zeropage
     internal val globalFloatConsts = mutableMapOf<Double, String>()     // all float values in the entire program (value -> varname)
     internal val zeropageVars: Map<String, MemoryAllocator.VarAllocation>
+    private val allStaticVariables by lazy { collectAllVariables(symboltable) }
+    private val usageScores by lazy { computeUsageScores(allStaticVariables) }
 
     init {
         allocateZeropageVariables()
@@ -46,7 +50,7 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
         if(options.zeropage== ZeropageType.DONTUSE)
             return
 
-        val allVariables = collectAllVariables(symboltable)
+        val allVariables = allStaticVariables
 
         val numberOfAllocatableVariables = allVariables.size
         val varsRequiringZp = allVariables.filter { it.zpwish == ZeropageWish.REQUIRE_ZEROPAGE }
@@ -85,14 +89,14 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
                     variable.astNode?.position ?: Position.DUMMY,
                     errors
                 )
-                result.onSuccess { numVariablesAllocatedInZP++ }
+                result.onOk { numVariablesAllocatedInZP++ }
                 //  no need to check for allocation error, if there is one, just allocate in normal system ram.
             }
 
             // try to allocate the "don't care" interger variables into the zeropage until it is full.
-            // TODO some form of intelligent priorization? most often used variables first? loopcounter vars first? ...?
+            // Prioritize by usage frequency: sort by computed hotness score (access frequency × type weight × loop depth)
             if(errors.noErrors()) {
-                val sortedList = varsDontCareWithoutAlignment.sortedByDescending { it.scopedNameString }
+                val sortedList = varsDontCareWithoutAlignment.sortedByDescending { usageScores[it.scopedNameString] ?: 0 }
                 for (variable in sortedList) {
                     if(variable.dt.isIntegerOrBool || variable.dt.isPointer) {
                         if(zeropage.free.isEmpty()) {
@@ -105,7 +109,7 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
                                 variable.astNode?.position ?: Position.DUMMY,
                                 errors
                             )
-                            result.onSuccess { numVariablesAllocatedInZP++ }
+                            result.onOk { numVariablesAllocatedInZP++ }
                         }
                     } else
                         numberOfNonIntegerVariables++
@@ -129,4 +133,33 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
         collect(st)
         return vars.sortedBy { it.dt.base }
     }
+
+    private fun computeUsageScores(vars: Collection<StStaticVariable>): Map<String, Int> {
+        val scores = mutableMapOf<String, Int>()
+        val varInfo = vars.associateBy { it.scopedNameString }
+        var loopDepth = 0
+
+        fun walk(node: PtNode) {
+            val isLoopEnter = node is PtForLoop || node is PtRepeatLoop
+            if(isLoopEnter) loopDepth++
+
+            if(node is PtIdentifier) {
+                val v = varInfo[node.name]
+                if(v != null) {
+                    val weight = when {
+                        v.dt.isPointer || v.dt.isWord -> 2
+                        else -> 1
+                    }
+                    scores[node.name] = (scores[node.name] ?: 0) + weight * (loopDepth + 1)
+                }
+            }
+
+            node.children.forEach { walk(it) }
+
+            if(isLoopEnter) loopDepth--
+        }
+
+        walk(program)
+        return scores
+    }
 }

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

@@ -125,10 +125,13 @@ internal class AnyExprAsmGen(
     }
 
     private fun assignFloatBinExpr(expr: PtBinaryExpression, assign: AsmAssignment): Boolean {
+        // C64/PET32 ROM T-variant entries skip CONUPK and need arisgn+Z flag set up beforehand.
+        // CX16 ROM entries are already fixed and handle this internally.
+        val tSuffix = if(asmgen.options.compTarget.name in listOf(C64Target.NAME, PETTarget.NAME)) "_NZ" else ""
         when(expr.operator) {
             "+" -> {
                 assignFloatOperandsToFACandARG(expr.left, expr.right)
-                asmgen.out("  jsr  floats.FADDT")
+                asmgen.out("  jsr  floats.FADDT$tSuffix")
                 asmgen.assignRegister(RegisterOrPair.FAC1, assign.target)
                 return true
             }
@@ -140,13 +143,13 @@ internal class AnyExprAsmGen(
             }
             "*" -> {
                 assignFloatOperandsToFACandARG(expr.left, expr.right)
-                asmgen.out("  jsr  floats.FMULTT")
+                asmgen.out("  jsr  floats.FMULTT$tSuffix")
                 asmgen.assignRegister(RegisterOrPair.FAC1, assign.target)
                 return true
             }
             "/" -> {
                 assignFloatOperandsToFACandARG(expr.right, expr.left)
-                asmgen.out("  jsr  floats.FDIVT")
+                asmgen.out("  jsr  floats.FDIVT$tSuffix")
                 asmgen.assignRegister(RegisterOrPair.FAC1, assign.target)
                 return true
             }

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

@@ -1,7 +1,9 @@
 package prog8.codegen.cpu6502.assignment
 
+import prog8.code.StConstant
 import prog8.code.ast.*
 import prog8.code.core.*
+import prog8.code.core.BaseDataType
 import prog8.codegen.cpu6502.AsmGen6502Internal
 
 
@@ -49,8 +51,12 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
     }
 
     init {
-        if(register!=null && !datatype.isNumericOrBool)
-            throw AssemblyError("must be numeric type")
+        if(register!=null) {
+            if(datatype.isPointer)
+                throw AssemblyError("register target type must be uword, not pointer $datatype $position")
+            else if(!datatype.isNumericOrBool)
+                throw AssemblyError("target type must be numeric not $datatype $position")
+        }
         if(kind==TargetStorageKind.REGISTER)
             require(register!=null)
         else
@@ -192,6 +198,19 @@ internal class AsmAssignSource(val kind: SourceStorageKind,
                     val parameter = asmgen.findSubroutineParameter(value.name, asmgen)
                     if(parameter?.definingAsmSub() != null)
                         throw AssemblyError("can't assign from a asmsub register parameter $value ${value.position}")
+
+                    // Check if this identifier is a constant with a value - if so, use the value directly instead of reading from memory
+                    val symbol = asmgen.symbolTable.lookup(value.name)
+                    if(symbol is StConstant && symbol.value != null) {
+                        val constValue = symbol.value!!
+                        val baseType = when(symbol.dt.base) {
+                            BaseDataType.POINTER -> BaseDataType.UWORD
+                            else -> symbol.dt.base
+                        }
+                        return AsmAssignSource(SourceStorageKind.LITERALNUMBER, program, asmgen, symbol.dt,
+                            number = PtNumber(baseType, constValue, value.position))
+                    }
+
                     val varName=asmgen.asmVariableName(value)
                     // special case: "cx16.r[0-15]" are 16-bits virtual registers of the commander X16 system
                     if(value.type.isUnsignedWord && varName.lowercase().startsWith("cx16.r")) {
@@ -208,19 +227,20 @@ internal class AsmAssignSource(val kind: SourceStorageKind,
                 is PtArrayIndexer -> {
                     AsmAssignSource(SourceStorageKind.ARRAY, program, asmgen, value.type, array = value)
                 }
-                is PtBuiltinFunctionCall -> {
-                    AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, value.type, expression = value)
-                }
                 is PtFunctionCall -> {
-                    val symbol = asmgen.symbolTable.lookup(value.name) ?: throw AssemblyError("lookup error ${value.name}")
-                    val sub = symbol.astNode as IPtSubroutine
-                    val returnType =
-                        if(sub is PtSub && sub.signature.returns.size>1)
-                            DataType.UNDEFINED      // TODO list of types instead?
-                        else
-                            sub.returnsWhatWhere().firstOrNull { rr -> rr.first.registerOrPair != null || rr.first.statusflag!=null }?.second
-                            ?: throw AssemblyError("can't translate zero return values in assignment")
-                    AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, returnType, expression = value)
+                    if(value.builtin) {
+                        AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, value.type, expression = value)
+                    } else {
+                        val symbol = asmgen.symbolTable.lookup(value.name) ?: throw AssemblyError("lookup error ${value.name}  ${value.position}")
+                        val sub = symbol.astNode as IPtSubroutine
+                        val returnType =
+                            if(sub is PtSub && sub.signature.returns.size>1)
+                                DataType.UNDEFINED      // TODO list of types instead?
+                            else
+                                sub.returnsWhatWhere().firstOrNull { rr -> rr.first.registerOrPair != null || rr.first.statusflag!=null }?.second
+                                ?: throw AssemblyError("can't translate zero return values in assignment")
+                        AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, returnType, expression = value)
+                    }
                 }
                 else -> {
                     AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, value.type, expression = value)
@@ -262,7 +282,7 @@ internal sealed class AsmAssignmentBase(val source: AsmAssignSource,
     }
 
     val target: AsmAssignTarget
-        get() = targets.single()
+        get() = targets.singleOrNull() ?: throw AssemblyError("code assumes single target but assignment is multi-value $position")
 }
 
 internal class AsmAssignment(source: AsmAssignSource,

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

@@ -44,7 +44,14 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
             "^=", "xor=" -> inplaceModification(assign.target, "^", assign.source)
             "<<=" -> inplaceModification(assign.target, "<<", assign.source)
             ">>=" -> inplaceModification(assign.target, ">>", assign.source)
-            "%=" -> inplaceModification(assign.target, "%", assign.source)
+            "%=" -> {
+                if(assign.source.datatype.isSigned) {
+                    asmgen.errors.err("remainder can only be used on unsigned integer operands on 6502 target for now", assign.position)
+                    // TODO implement the signed remainder asm routine
+                }
+                else
+                    inplaceModification(assign.target, "%", assign.source)
+            }
             "==" -> inplaceModification(assign.target, "==", assign.source)
             "!=" -> inplaceModification(assign.target, "!=", assign.source)
             "<" -> inplaceModification(assign.target, "<", assign.source)
@@ -55,6 +62,63 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
         }
     }
 
+    private fun inplaceModificationIndexedPointerField(target: AsmAssignTarget, operator: String, value: AsmAssignSource) {
+        val array = target.array!!
+        val elementDt = target.datatype
+        if(!elementDt.isByteOrBool && !elementDt.isWord)
+            throw AssemblyError("inplace modification indexed pointer field for type $elementDt not supported")
+        val indexedTarget = IndexedPtrTarget(target)
+        val ptr = ptrgen.indexedEffectiveAddress(indexedTarget)
+
+        val elementTemp = asmgen.createTempVarReused(elementDt.base, false, array)
+        if(elementDt.isByteOrBool) {
+            asmgen.out("""
+                ldy  #0
+                lda  ($ptr),y
+                sta  $elementTemp""")
+        } else {
+            asmgen.out("""
+                ldy  #0
+                lda  ($ptr),y
+                sta  $elementTemp
+                iny
+                lda  ($ptr),y
+                sta  $elementTemp+1""")
+        }
+
+        // save the computed address on the hardware stack so later code can't clobber it
+        asmgen.out("""
+            lda  $ptr
+            pha
+            lda  $ptr+1
+            pha""")
+
+        // reuse the existing variable-target logic to modify the temp
+        val tempTarget = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, elementDt, null, target.position, variableAsmName = elementTemp)
+        inplaceModification(tempTarget, operator, value)
+
+        // restore the address and store the temp back
+        asmgen.out("""
+            pla
+            sta  $ptr+1
+            pla
+            sta  $ptr""")
+        if(elementDt.isByteOrBool) {
+            asmgen.out("""
+                ldy  #0
+                lda  $elementTemp
+                sta  ($ptr),y""")
+        } else {
+            asmgen.out("""
+                ldy  #0
+                lda  $elementTemp
+                sta  ($ptr),y
+                iny
+                lda  $elementTemp+1
+                sta  ($ptr),y""")
+        }
+    }
+
     private fun inplaceModification(target: AsmAssignTarget, operator: String, value: AsmAssignSource) {
 
         // the asm-gen code can deal with situations where you want to assign a byte into a word.
@@ -240,7 +304,7 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
             TargetStorageKind.ARRAY -> {
                 val deref = target.array!!.pointerderef
                 if(deref!=null) {
-                    TODO("inplace modification array indexed pointer deref ${target.position}")
+                    inplaceModificationIndexedPointerField(target, operator, value)
                     return
                 }
                 val targetArrayVar = target.array.variable!!
@@ -311,14 +375,13 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                                 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 -> {
+                                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}")
                                     }
-                                }
                             }
                         }
 
@@ -570,11 +633,12 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
     internal fun inplacemodificationLongWithVariable(targetVar: String, operator: String, sourceVar: String) {
         when(operator) {
             "+" -> {
+                // need to unroll to correctly keep Carry flag for multi-byte arithmetic
                 asmgen.out("""
                     clc
-                    lda  $targetVar
-                    adc  $sourceVar
-                    sta  $targetVar
+                    lda  $targetVar+0
+                    adc  $sourceVar+0
+                    sta  $targetVar+0
                     lda  $targetVar+1
                     adc  $sourceVar+1
                     sta  $targetVar+1
@@ -583,14 +647,16 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                     sta  $targetVar+2
                     lda  $targetVar+3
                     adc  $sourceVar+3
-                    sta  $targetVar+3""")
+                    sta  $targetVar+3
+                    """)
             }
             "-" -> {
+                // need to unroll to correctly keep Carry flag for multi-byte arithmetic
                 asmgen.out("""
                     sec
-                    lda  $targetVar
-                    sbc  $sourceVar
-                    sta  $targetVar
+                    lda  $targetVar+0
+                    sbc  $sourceVar+0
+                    sta  $targetVar+0
                     lda  $targetVar+1
                     sbc  $sourceVar+1
                     sta  $targetVar+1
@@ -599,7 +665,8 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                     sta  $targetVar+2
                     lda  $targetVar+3
                     sbc  $sourceVar+3
-                    sta  $targetVar+3""")
+                    sta  $targetVar+3
+                    """)
             }
             "<<" -> {
                 asmgen.out("""
@@ -625,51 +692,102 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
             }
             "|" -> {
                 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""")
+                    ldy  #3
+-                   lda  $targetVar,y
+                    ora  $sourceVar,y
+                    sta  $targetVar,y
+                    dey
+                    bpl  -""")
             }
             "&" -> {
                 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""")
+                    ldy  #3
+-                   lda  $targetVar,y
+                    and  $sourceVar,y
+                    sta  $targetVar,y
+                    dey
+                    bpl  -""")
             }
             "^" -> {
                 asmgen.out("""
-                    lda  $targetVar
-                    eor  $sourceVar
-                    sta  $targetVar  
-                    lda  $targetVar+1
-                    eor  $sourceVar+1
+                    ldy  #3
+-                   lda  $targetVar,y
+                    eor  $sourceVar,y
+                    sta  $targetVar,y
+                    dey
+                    bpl  -""")
+            }
+            "*" -> {
+                asmgen.out("""
+                    ; Copy target to R12R13 (multiplicand)
+                    ldy  #3
+-                   lda  $targetVar,y
+                    sta  cx16.r12,y
+                    dey
+                    bpl  -
+                    ; Copy source to R14R15 (multiplier)
+                    ldy  #3
+-                   lda  $sourceVar,y
+                    sta  cx16.r14,y
+                    dey
+                    bpl  -
+                    jsr  prog8_math.multiply_longs
+                    ; Copy result from R14R15 back to target
+                    ldy  #3
+-                   lda  cx16.r14,y
+                    sta  $targetVar,y
+                    dey
+                    bpl  -""")
+            }
+            "/" -> {
+                asmgen.out("""
+                    ; Copy target to R12R13 (dividend)
+                    ldy  #3
+-                   lda  $targetVar,y
+                    sta  cx16.r12,y
+                    dey
+                    bpl  -
+                    ; Copy source to R14R15 (divisor)
+                    ldy  #3
+-                   lda  $sourceVar,y
+                    sta  cx16.r14,y
+                    dey
+                    bpl  -
+                    jsr  prog8_math.div_longs
+                    ; Copy result from R14R15 back to target
+                    ldy  #3
+-                   lda  cx16.r14,y
+                    sta  $targetVar,y
+                    dey
+                    bpl  -""")
+            }
+            "%" -> {
+                asmgen.out("""
+                    ; Copy target to R12R13 (dividend)
+                    ldy  #3
+-                   lda  $targetVar,y
+                    sta  cx16.r12,y
+                    dey
+                    bpl  -
+                    ; Copy source to R14R15 (divisor)
+                    ldy  #3
+-                   lda  $sourceVar,y
+                    sta  cx16.r14,y
+                    dey
+                    bpl  -
+                    jsr  prog8_math.div_longs
+                    ; Copy remainder from P8ZP_SCRATCH_W1/W2 back to target
+                    lda  P8ZP_SCRATCH_W1
+                    sta  $targetVar
+                    lda  P8ZP_SCRATCH_W1+1
                     sta  $targetVar+1
-                    lda  $targetVar+2
-                    eor  $sourceVar+2
+                    lda  P8ZP_SCRATCH_W2
                     sta  $targetVar+2
-                    lda  $targetVar+3
-                    eor  $sourceVar+3
+                    lda  P8ZP_SCRATCH_W2+1
                     sta  $targetVar+3""")
             }
             else -> {
-                TODO("in-place modify LONG with variable")
+                TODO("in-place modify LONG with variable, operator=$operator")
             }
         }
     }
@@ -994,6 +1112,93 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                     }
                 }
             }
+            "*" -> {
+                // long *= constant - use multiplication routine with loop-based copies
+                val lo = value and 0xFFFF
+                val hi = (value ushr 16) and 0xFFFF
+                asmgen.out("""
+                    ; Copy variable to R12R13 (multiplicand)
+                    ldy  #3
+-                   lda  $variable,y
+                    sta  cx16.r12,y
+                    dey
+                    bpl  -
+                    ; Load constant into R14R15 (multiplier)
+                    lda  #<${lo}
+                    sta  cx16.r14
+                    lda  #>${lo}
+                    sta  cx16.r14+1
+                    lda  #<${hi}
+                    sta  cx16.r15
+                    lda  #>${hi}
+                    sta  cx16.r15+1
+                    jsr  prog8_math.multiply_longs
+                    ; Copy result from R14R15 back to variable
+                    ldy  #3
+-                   lda  cx16.r14,y
+                    sta  $variable,y
+                    dey
+                    bpl  -""")
+            }
+            "/" -> {
+                // long /= constant - use division routine
+                val lo = value and 0xFFFF
+                val hi = (value ushr 16) and 0xFFFF
+                asmgen.out("""
+                    ; Copy variable to R12R13 (dividend)
+                    ldy  #3
+-                   lda  $variable,y
+                    sta  cx16.r12,y
+                    dey
+                    bpl  -
+                    ; Load constant into R14R15 (divisor)
+                    lda  #<${lo}
+                    sta  cx16.r14
+                    lda  #>${lo}
+                    sta  cx16.r14+1
+                    lda  #<${hi}
+                    sta  cx16.r15
+                    lda  #>${hi}
+                    sta  cx16.r15+1
+                    jsr  prog8_math.div_longs
+                    ; Copy result from R14R15 back to variable
+                    ldy  #3
+-                   lda  cx16.r14,y
+                    sta  $variable,y
+                    dey
+                    bpl  -""")
+            }
+            "%" -> {
+                // long %= constant - use division routine, remainder is in P8ZP_SCRATCH_W1/W2
+                val lo = value and 0xFFFF
+                val hi = (value ushr 16) and 0xFFFF
+                asmgen.out("""
+                    ; Copy variable to R12R13 (dividend)
+                    ldy  #3
+-                   lda  $variable,y
+                    sta  cx16.r12,y
+                    dey
+                    bpl  -
+                    ; Load constant into R14R15 (divisor)
+                    lda  #<${lo}
+                    sta  cx16.r14
+                    lda  #>${lo}
+                    sta  cx16.r14+1
+                    lda  #<${hi}
+                    sta  cx16.r15
+                    lda  #>${hi}
+                    sta  cx16.r15+1
+                    jsr  prog8_math.div_longs
+                    ; Copy remainder from P8ZP_SCRATCH_W1/W2 back to variable
+                    lda  P8ZP_SCRATCH_W1
+                    sta  $variable
+                    lda  P8ZP_SCRATCH_W1+1
+                    sta  $variable+1
+                    lda  P8ZP_SCRATCH_W2
+                    sta  $variable+2
+                    lda  P8ZP_SCRATCH_W2+1
+                    sta  $variable+3""")
+            }
             "<<" -> if (value > 0) inplaceLongShiftLeft()
             ">>" -> if (value > 0) inplaceLongShiftRight()
             "|" -> {
@@ -1135,9 +1340,9 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
             val assignValue = AsmAssignment(value,
                 listOf(
                     AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, DataType.UBYTE,
-                    address.definingISub(), Position.DUMMY, register = RegisterOrPair.A)
+                    address.definingISub(), address.position, register = RegisterOrPair.A)
                 ),
-                program.memsizer, Position.DUMMY)
+                program.memsizer, address.position)
             assignmentAsmGen.translateNormalAssignment(assignValue, address.definingISub())   // calculate value into A
         }
 
@@ -1220,6 +1425,33 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                     sbc  cx16.r0H
                     sta  ${arrayVar}_msb+$index""")
             }
+            "|" -> {
+                asmgen.out("""
+                    lda  ${arrayVar}_lsb+$index
+                    ora  cx16.r0L
+                    sta  ${arrayVar}_lsb+$index
+                    lda  ${arrayVar}_msb+$index
+                    ora  cx16.r0H
+                    sta  ${arrayVar}_msb+$index""")
+            }
+            "&" -> {
+                asmgen.out("""
+                    lda  ${arrayVar}_lsb+$index
+                    and  cx16.r0L
+                    sta  ${arrayVar}_lsb+$index
+                    lda  ${arrayVar}_msb+$index
+                    and  cx16.r0H
+                    sta  ${arrayVar}_msb+$index""")
+            }
+            "^" -> {
+                asmgen.out("""
+                    lda  ${arrayVar}_lsb+$index
+                    eor  cx16.r0L
+                    sta  ${arrayVar}_lsb+$index
+                    lda  ${arrayVar}_msb+$index
+                    eor  cx16.r0H
+                    sta  ${arrayVar}_msb+$index""")
+            }
             else -> TODO("inplace split word array value $operator")
         }
     }
@@ -1710,8 +1942,8 @@ $shortcutLabel:""")
     private fun inplacemodificationRegisterAwithVariableWithSwappedOperands(operator: String, variable: String, signed: Boolean) {
         // A = variable <operator> A
 
-        if(operator in AssociativeOperators)
-            return inplacemodificationRegisterAwithVariable(operator, variable, signed)     // just reuse existing code for associative operators
+        if(operator in CommutativeOperators)
+            return inplacemodificationRegisterAwithVariable(operator, variable, signed)     // just reuse existing code for commutative operators
 
         // now implement the non-assiciative operators...
         when (operator) {
@@ -3095,6 +3327,7 @@ $shortcutLabel:""")
                 lda  $name+1
                 sta  P8ZP_SCRATCH_W1+1
                 txa
+oweroff
                 jsr  prog8_math.divmod_uw_asm
                 lda  P8ZP_SCRATCH_W2
                 ldy  P8ZP_SCRATCH_W2+1

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

@@ -113,34 +113,126 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
     }
 
     internal fun inplaceByteInvert(target: PtrTarget) {
-        TODO("inplace byte invert pointer deref ${target.position}")
+        val (zpPtrVar, offset) = deref(target.pointer)
+        val eorVal = if(target.dt.isBool) 1 else 255
+        if(offset==0.toUByte() && asmgen.isTargetCpu(CpuType.CPU65C02)) {
+            asmgen.out("  lda  ($zpPtrVar) |  eor  #$eorVal |  sta  ($zpPtrVar)")
+        } else {
+            asmgen.out("""
+                ldy  #$offset
+                lda  ($zpPtrVar),y
+                eor  #$eorVal
+                sta  ($zpPtrVar),y""")
+        }
     }
 
     internal fun inplaceWordInvert(target: PtrTarget) {
-        TODO("inplace word invert pointer deref ${target.position}")
+        val (zpPtrVar, offset) = deref(target.pointer)
+        asmgen.out("""
+                ldy  #$offset
+                lda  ($zpPtrVar),y
+                eor  #255
+                sta  ($zpPtrVar),y
+                iny
+                lda  ($zpPtrVar),y
+                eor  #255
+                sta  ($zpPtrVar),y""")
+    }
+
+    internal fun inplaceLongInvert(target: PtrTarget) {
+        val (zpPtrVar, offset) = deref(target.pointer)
+        asmgen.out("""
+                ldy  #$offset
+                lda  ($zpPtrVar),y
+                eor  #255
+                sta  ($zpPtrVar),y
+                iny
+                lda  ($zpPtrVar),y
+                eor  #255
+                sta  ($zpPtrVar),y
+                iny
+                lda  ($zpPtrVar),y
+                eor  #255
+                sta  ($zpPtrVar),y
+                iny
+                lda  ($zpPtrVar),y
+                eor  #255
+                sta  ($zpPtrVar),y""")
     }
 
     internal fun inplaceByteNegate(target: PtrTarget, scope: IPtSubroutine?) {
-        TODO("inplace byte negate to pointer deref ${target.position}")
+        val (zpPtrVar, offset) = deref(target.pointer)
+        if(asmgen.isTargetCpu(CpuType.CPU65C02)) {
+            asmgen.out("""
+                ldy  #$offset
+                lda  ($zpPtrVar),y
+                eor  #255
+                ina
+                sta  ($zpPtrVar),y""")
+        } else {
+            asmgen.out("""
+                ldy  #$offset
+                lda  ($zpPtrVar),y
+                eor  #255
+                clc
+                adc  #1
+                sta  ($zpPtrVar),y""")
+        }
     }
 
     internal fun inplaceWordNegate(target: PtrTarget, scope: IPtSubroutine?) {
-        TODO("inplace word negate pointer deref ${target.position}")
+        val (zpPtrVar, offset) = deref(target.pointer)
+        asmgen.out("""
+                ldy  #$offset
+                sec
+                lda  #0
+                sbc  ($zpPtrVar),y
+                sta  ($zpPtrVar),y
+                iny
+                lda  #0
+                sbc  ($zpPtrVar),y
+                sta  ($zpPtrVar),y""")
     }
 
     internal fun inplaceLongNegate(target: PtrTarget, scope: IPtSubroutine?) {
-        TODO("inplace long negate pointer deref ${target.position}")
+        val (zpPtrVar, offset) = deref(target.pointer)
+        asmgen.out("""
+                ldy  #$offset
+                sec
+                lda  #0
+                sbc  ($zpPtrVar),y
+                sta  ($zpPtrVar),y
+                iny
+                lda  #0
+                sbc  ($zpPtrVar),y
+                sta  ($zpPtrVar),y
+                iny
+                lda  #0
+                sbc  ($zpPtrVar),y
+                sta  ($zpPtrVar),y
+                iny
+                lda  #0
+                sbc  ($zpPtrVar),y
+                sta  ($zpPtrVar),y""")
     }
 
     internal fun inplaceFloatNegate(target: PtrTarget, scope: IPtSubroutine?) {
-        TODO("inplace float negate pointer deref ${target.position}")
+        val (zpPtrVar, offset) = deref(target.pointer)
+        // flip sign bit in second byte of 5-byte float
+        asmgen.out("""
+                ldy  #$offset
+                iny
+                lda  ($zpPtrVar),y
+                eor  #${'$'}80
+                sta  ($zpPtrVar),y""")
     }
 
 
-    internal fun deref(pointer: PtPointerDeref, addOffsetToPointer: Boolean=false): Pair<String, UByte> {
+    internal fun deref(pointer: PtPointerDeref, addOffsetToPointer: Boolean=false, loadPointerFieldValue: Boolean=false): Pair<String, UByte> {
         // walk the pointer deref chain and leaves the final pointer value in a ZP var
         // this will often be the temp var P8ZP_SCRATCH_PTR but can also be the original pointer variable if it is already in zeropage and there is nothing to add to it
         // returns the ZP var to use as a pointer, and a Y register offset (which can be zero)
+        // loadPointerFieldValue: for addOffsetToPointer=true, also load the value if the final field is a pointer-typed field (rather than returning its address).
 
         fun addFieldOffsetToScratchPointer(fieldoffset: UInt) {
             if(fieldoffset==0u)
@@ -185,7 +277,7 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
             if(addOffsetToPointer) {
                 asmgen.assignExpressionToVariable(pointer.startpointer, "P8ZP_SCRATCH_PTR", DataType.UWORD)
                 addFieldOffsetToScratchPointer(field.second.toUInt())
-                if(pointer.derefLast)
+                if(pointer.derefLast || (loadPointerFieldValue && field.first.isPointer))
                     updateScratchPointer()
                 return "P8ZP_SCRATCH_PTR" to 0u
             } else {
@@ -235,21 +327,80 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
         } else {
             if(addOffsetToPointer) {
                 addFieldOffsetToScratchPointer(fieldinfo.second.toUInt())
+                if(loadPointerFieldValue && fieldinfo.first.isPointer)
+                    updateScratchPointer()
                 return "P8ZP_SCRATCH_PTR" to 0u
             } else
                 return "P8ZP_SCRATCH_PTR" to fieldinfo.second
         }
     }
 
+    internal fun indexedEffectiveAddress(target: IndexedPtrTarget): String {
+        val eltSize = asmgen.program.memsizer.memorySize(target.elementDt, null)
+        // generic: evaluate index as word, scale by element size, add field-corrected base pointer
+        asmgen.assignExpressionToVariable(target.index, "P8ZP_SCRATCH_W1", DataType.UWORD)
+        when (eltSize) {
+            1 -> {}
+            2 -> asmgen.out("  asl  P8ZP_SCRATCH_W1 |  rol  P8ZP_SCRATCH_W1+1")
+            4 -> asmgen.out("  asl  P8ZP_SCRATCH_W1 |  rol  P8ZP_SCRATCH_W1+1 |  asl  P8ZP_SCRATCH_W1 |  rol  P8ZP_SCRATCH_W1+1")
+            8 -> asmgen.out("  asl  P8ZP_SCRATCH_W1 |  rol  P8ZP_SCRATCH_W1+1 |  asl  P8ZP_SCRATCH_W1 |  rol  P8ZP_SCRATCH_W1+1 |  asl  P8ZP_SCRATCH_W1 |  rol  P8ZP_SCRATCH_W1+1")
+            else -> {
+                // generic multiply by eltSize
+                asmgen.out("""
+                    lda  P8ZP_SCRATCH_W1
+                    ldy  P8ZP_SCRATCH_W1+1
+                    sta  prog8_math.multiply_words.multiplier
+                    sty  prog8_math.multiply_words.multiplier+1
+                    lda  #<$eltSize
+                    ldy  #>$eltSize
+                    jsr  prog8_math.multiply_words
+                    sta  P8ZP_SCRATCH_W1
+                    sty  P8ZP_SCRATCH_W1+1""")
+            }
+        }
+        // save scaled index to W2, compute base (field-corrected) into P8ZP_SCRATCH_PTR, then add
+        asmgen.out("  lda  P8ZP_SCRATCH_W1 |  sta  P8ZP_SCRATCH_W2 |  lda  P8ZP_SCRATCH_W1+1 |  sta  P8ZP_SCRATCH_W2+1")
+        val (basePtr, _) = deref(target.pointer, addOffsetToPointer = true, loadPointerFieldValue = true)
+        if(basePtr != "P8ZP_SCRATCH_PTR") {
+            // deref returned the original zp pointer variable; copy it so we don't mutate it
+            asmgen.out("""
+                lda  $basePtr
+                sta  P8ZP_SCRATCH_PTR
+                lda  $basePtr+1
+                sta  P8ZP_SCRATCH_PTR+1""")
+        }
+        asmgen.out("""
+            clc
+            lda  P8ZP_SCRATCH_PTR
+            adc  P8ZP_SCRATCH_W2
+            sta  P8ZP_SCRATCH_PTR
+            lda  P8ZP_SCRATCH_PTR+1
+            adc  P8ZP_SCRATCH_W2+1
+            sta  P8ZP_SCRATCH_PTR+1""")
+        return "P8ZP_SCRATCH_PTR"
+    }
+
     internal fun assignPointerDerefExpression(target: AsmAssignTarget, value: PtPointerDeref) {
-        val (zpPtrVar, offset) = deref(value)
+        val (zpPtrVar, offset1) = deref(value)
+        val offset: UByte
+        if(value.derefLast) {
+            asmgen.loadIndirectWordAY(zpPtrVar, offset1)
+            asmgen.out("  sta  $zpPtrVar |  sty  $zpPtrVar+1")
+            offset = 0.toUByte()
+        } else {
+            offset = offset1
+        }
         if(value.type.isByteOrBool) {
             asmgen.loadIndirectByte(zpPtrVar, offset)
             asmgen.assignRegister(RegisterOrPair.A, target)
         }
         else if(value.type.isWord || value.type.isPointer) {
-            asmgen.loadIndirectWord(zpPtrVar, offset)
-            asmgen.assignRegister(RegisterOrPair.AY, target)
+            if(target.register in arrayOf(RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY)) {
+                asmgen.loadIndirectWordIntoRegisters(zpPtrVar, offset, target.register!!)
+            } else {
+                asmgen.loadIndirectWordAY(zpPtrVar, offset)
+                asmgen.assignRegister(RegisterOrPair.AY, target)
+            }
         }
         else if(value.type.isFloat) {
             asmgen.loadIndirectFloat(zpPtrVar, offset)
@@ -270,15 +421,17 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
                         sta  ${target.asmVarname}+2
                         iny
                         lda  ($zpPtrVar),y
-                        sta  ${target.asmVarname}+3
-                    """)
+                        sta  ${target.asmVarname}+3""")
                 }
                 TargetStorageKind.REGISTER -> {
                     require(target.register!! in CombinedLongRegisters)
                     asmgen.loadIndirectLongIntoCombinedLongRegister(zpPtrVar, offset, target.register)
                 }
                 TargetStorageKind.POINTER -> {
-                    // TODO optimize this so it doesn't need a temporary long var all the time
+                    asmgen.loadIndirectLongIntoCombinedLongRegister(zpPtrVar, offset, RegisterOrPair.R14R15)
+                    asmgen.assignRegister(RegisterOrPair.R14R15, target)
+                }
+                TargetStorageKind.ARRAY -> {
                     asmgen.loadIndirectLongIntoCombinedLongRegister(zpPtrVar, offset, RegisterOrPair.R14R15)
                     asmgen.assignRegister(RegisterOrPair.R14R15, target)
                 }
@@ -295,24 +448,24 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
     internal fun inplaceModification(target: PtrTarget, operator: String, value: AsmAssignSource) {
         when (operator) {
             "+" -> {
-                if(target.dt.isByte && value.number?.number==1.0 || value.number?.number==2.0) {
+                if(target.dt.isByte && (value.number?.number==1.0 || value.number?.number==2.0)) {
                     val amount = value.number.number.toInt()
                     inplaceByteInc(target, amount)
                 } else {
                     if (target.dt.isByte) inplaceByteAdd(target, value)
-                    else if (target.dt.isWord) inplaceWordAdd(target, value)
+                    else if (target.dt.isWord || target.dt.isPointer) inplaceWordAdd(target, value)
                     else if (target.dt.isFloat) inplaceFloatAddOrMul(target, "FADD", value)
                     else if (target.dt.isLong) inplaceLongAdd(target, value)
                     else throw AssemblyError("weird dt ${target.dt} ${target.position}")
                 }
             }
             "-" -> {
-                if(target.dt.isByte && value.number?.number==1.0 || value.number?.number==2.0) {
+                if(target.dt.isByte && (value.number?.number==1.0 || value.number?.number==2.0)) {
                     val amount = value.number.number.toInt()
                     inplaceByteDec(target, amount)
                 } else {
                     if (target.dt.isByte) inplaceByteSub(target, value)
-                    else if (target.dt.isWord) inplaceWordSub(target, value)
+                    else if (target.dt.isWord || target.dt.isPointer) inplaceWordSub(target, value)
                     else if (target.dt.isFloat) inplaceFloatSubOrDiv(target, "FSUB", value)
                     else if (target.dt.isLong) inplaceLongSub(target, value)
                     else throw AssemblyError("weird dt ${target.position}")
@@ -395,132 +548,163 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
     }
 
     internal fun assignByte(target: IndexedPtrTarget, byte: Int) {
-        val eltSize = asmgen.program.memsizer.memorySize(target.elementDt, null)
-        val constIndex = target.index.asConstInteger()
-        if(constIndex!=null) {
-            val (zpPtrVar, offset2) = deref(target.pointer)
-            val offset = eltSize*constIndex + offset2.toInt()
-            if(offset>255) {
-                // need to add index to the pointer (but not clobber it) to allow index>255
-                if(zpPtrVar.startsWith("P8ZP_SCRATCH_")) {          // TODO not very robust....
-                    asmgen.out("""
-                        lda  $zpPtrVar+1
-                        clc
-                        adc  #>$offset
-                        sta  $zpPtrVar+1
-                        ldy  #<$offset
-                        lda  #$byte
-                        sta  ($zpPtrVar),y""")
-                } else {
-                    asmgen.out("""
-                        lda  $zpPtrVar
-                        sta  P8ZP_SCRATCH_PTR
-                        lda  $zpPtrVar+1
-                        clc
-                        adc  #>$offset
-                        sta  P8ZP_SCRATCH_PTR+1
-                        ldy  #<$offset
-                        lda  #$byte
-                        sta  (P8ZP_SCRATCH_PTR),y""")
-                }
-            } else {
-                asmgen.out("""
-                    ldy  #<$offset
-                    lda  #$byte
-                    sta  ($zpPtrVar),y""")
-            }
-        } else if(target.index is PtIdentifier) {
-            val (zpPtrVar, _) = deref(target.pointer, addOffsetToPointer=true)
-            val indexVarName = asmgen.asmVariableName(target.index)
-            if(eltSize!=1) {
-                TODO("multiply index by element size $eltSize ${target.position}")
-                // asmgen.loadScaledArrayIndexIntoRegister() ...
-            }
-            // element size is 1, can immediately add the index value
-            if(target.index.type.isWord) {
-                asmgen.out("""
-                    clc
-                    lda  $zpPtrVar+1
-                    adc  $indexVarName+1
-                    sta  $zpPtrVar+1""")
-            }
-            asmgen.out("""
-                ldy  $indexVarName
-                lda  #$byte
-                sta  ($zpPtrVar),y""")
-        } else {
-            if(eltSize!=1) {
-                TODO("multiply index by element size $eltSize ${target.position}")
-                // asmgen.loadScaledArrayIndexIntoRegister() ...
-            }
-            if(target.index.type.isByte) {
-                asmgen.pushCpuStack(BaseDataType.UBYTE, target.index)
-                val (zpPtrVar, offset) = deref(target.pointer, addOffsetToPointer = true)
-                require(offset==0.toUByte())
-                asmgen.restoreRegisterStack(CpuRegister.Y, false)
-                asmgen.out("  lda  #$byte |  sta  ($zpPtrVar),y")
-            }
-            else {
-                asmgen.pushCpuStack(BaseDataType.UWORD, target.index)
-                val (zpPtrVar, offset) = deref(target.pointer, addOffsetToPointer = true)
-                require(offset==0.toUByte())
-                asmgen.out("""
-                    pla
-                    clc
-                    adc  $zpPtrVar+1
-                    sta  $zpPtrVar+1""")
-                if(asmgen.isTargetCpu(CpuType.CPU65C02)) asmgen.out("  ply") else asmgen.out("  pla |  tay")
-                asmgen.out("  lda  #$byte |  sta  ($zpPtrVar),y")
-            }
-        }
+        val ptr = indexedEffectiveAddress(target)
+        asmgen.storeIndirectByte(byte, ptr, 0u)
     }
 
     internal fun assignWord(target: IndexedPtrTarget, word: Int) {
-        TODO("array ptr assign const word ${target.position}")
+        val ptr = indexedEffectiveAddress(target)
+        asmgen.storeIndirectWord(word, ptr, 0u)
     }
 
     internal fun assignLong(target: IndexedPtrTarget, long: Int) {
-        TODO("array ptr assign const long ${target.position}")
+        val ptr = indexedEffectiveAddress(target)
+        val hex = long.toLongHex()
+        asmgen.out("""
+            ldy  #0
+            lda  #$${hex.substring(6,8)}
+            sta  ($ptr),y
+            iny
+            lda  #$${hex.substring(4,6)}
+            sta  ($ptr),y
+            iny
+            lda  #$${hex.substring(2,4)}
+            sta  ($ptr),y
+            iny
+            lda  #$${hex.take(2)}
+            sta  ($ptr),y""")
     }
 
     internal fun assignFloat(target: IndexedPtrTarget, float: Double) {
-        TODO("array ptr assign const float ${target.position}")
+        val ptr = indexedEffectiveAddress(target)
+        asmgen.storeIndirectFloat(float, ptr, 0u)
     }
 
     internal fun assignFAC1(target: IndexedPtrTarget) {
-        TODO("array ptr assign FAC1 ${target.position}")
+        val ptr = indexedEffectiveAddress(target)
+        asmgen.storeIndirectFloatFP1(ptr, 0u)
     }
 
     internal fun assignFloatAY(target: IndexedPtrTarget) {
-        TODO("array ptr assign float AY ${target.position}")
+        // A/Y contains a pointer to the source float. Save it, compute destination address,
+        // restore source pointer into W1, load destination pointer into A/Y, and copy.
+        if(asmgen.isTargetCpu(CpuType.CPU65C02))
+            asmgen.out("  pha |  phy")
+        else
+            asmgen.out("  pha |  tya |  pha")
+        val ptr = indexedEffectiveAddress(target)
+        if(asmgen.isTargetCpu(CpuType.CPU65C02)) {
+            asmgen.out("""
+                ply
+                pla
+                sta  P8ZP_SCRATCH_W1
+                sty  P8ZP_SCRATCH_W1+1
+                lda  $ptr
+                ldy  $ptr+1
+                jsr  floats.copy_float""")
+        } else {
+            asmgen.out("""
+                pla
+                tay
+                pla
+                sta  P8ZP_SCRATCH_W1
+                sty  P8ZP_SCRATCH_W1+1
+                lda  $ptr
+                ldy  $ptr+1
+                jsr  floats.copy_float""")
+        }
     }
 
     internal fun assignFloatVar(target: IndexedPtrTarget, varName: String) {
-        TODO("array ptr assign float var ${target.position}")
+        val ptr = indexedEffectiveAddress(target)
+        asmgen.storeIndirectFloatVar(varName, ptr, 0u)
     }
 
     internal fun assignByteReg(target: IndexedPtrTarget, register: CpuRegister) {
+        // save register on the stack so indexedEffectiveAddress can freely use scratch regs
         asmgen.saveRegisterStack(register, false)
-        TODO("array ptr assign byte reg ${target.position}")
-        asmgen.saveRegisterStack(register, false)
+        val ptr = indexedEffectiveAddress(target)
+        asmgen.restoreRegisterStack(register, false)
+        asmgen.storeIndirectByteReg(register, ptr, 0u, false, false)
     }
 
     internal fun assignWordReg(target: IndexedPtrTarget, regs: RegisterOrPair) {
+        // save word reg on the stack so indexedEffectiveAddress can freely use scratch regs
         saveOnStack(regs)
-        TODO("array ptr assign word reg ${target.position}")
+        val ptr = indexedEffectiveAddress(target)
         restoreFromStack(regs)
+        asmgen.storeIndirectWordReg(regs, ptr, 0u)
     }
 
     internal fun assignByteVar(target: IndexedPtrTarget, varName: String, extendToWord: Boolean, signed: Boolean) {
-        TODO("array ptr assign byte var ${target.position}")
+        val ptr = indexedEffectiveAddress(target)
+        if(extendToWord) {
+            // need to store byte var extended to word
+            asmgen.out("  lda  $varName")
+            if(signed) asmgen.signExtendAXlsb(BaseDataType.BYTE) else asmgen.signExtendAXlsb(BaseDataType.UBYTE)
+            asmgen.storeIndirectWordReg(RegisterOrPair.AX, ptr, 0u)
+        } else {
+            asmgen.storeIndirectByteVar(varName, ptr, 0u)
+        }
     }
 
     internal fun assignWordVar(target: IndexedPtrTarget, varName: String) {
-        TODO("array ptr assign word var ${target.position}")
+        val ptr = indexedEffectiveAddress(target)
+        asmgen.storeIndirectWordVar(varName, DataType.UWORD, ptr, 0u)
     }
 
     internal fun assignLongVar(target: IndexedPtrTarget, varName: String) {
-        TODO("array ptr assign long var ${target.position}")
+        val ptr = indexedEffectiveAddress(target)
+        asmgen.out("""
+            ldy  #0
+            lda  $varName
+            sta  ($ptr),y
+            iny
+            lda  $varName+1
+            sta  ($ptr),y
+            iny
+            lda  $varName+2
+            sta  ($ptr),y
+            iny
+            lda  $varName+3
+            sta  ($ptr),y""")
+    }
+
+    internal fun assignLongReg(target: IndexedPtrTarget, regs: RegisterOrPair) {
+        // generic fallback for long array via pointer
+        val startreg = regs.startregname()
+        // save source long on the stack in case index expression evaluation uses the same registers
+        asmgen.out("""
+            lda  cx16.$startreg
+            pha
+            lda  cx16.$startreg+1
+            pha
+            lda  cx16.$startreg+2
+            pha
+            lda  cx16.$startreg+3
+            pha""")
+        val ptr = indexedEffectiveAddress(target)
+        asmgen.out("""
+            pla
+            sta  cx16.$startreg+3
+            pla
+            sta  cx16.$startreg+2
+            pla
+            sta  cx16.$startreg+1
+            pla
+            sta  cx16.$startreg
+            ldy  #0
+            lda  cx16.$startreg
+            sta  ($ptr),y
+            iny
+            lda  cx16.$startreg+1
+            sta  ($ptr),y
+            iny
+            lda  cx16.$startreg+2
+            sta  ($ptr),y
+            iny
+            lda  cx16.$startreg+3
+            sta  ($ptr),y""")
     }
 
     internal fun assignLongVar(pointer: PtPointerDeref, varName: String) {
@@ -1738,7 +1922,7 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
 
         fun multiply() {
             // on entry here: number placed in routine argument variable
-            asmgen.loadIndirectWord(zpPtrVar, 0u)
+            asmgen.loadIndirectWordAY(zpPtrVar, 0u)
             asmgen.out("""
                 jsr  prog8_math.multiply_words
                 tax
@@ -1807,7 +1991,7 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
                 val number = value.number!!.number.toInt()
                 if(number in powersOfTwoInt)
                     throw AssemblyError("divide by power of two should have been a shift $value.position")
-                asmgen.loadIndirectWord(zpPtrVar, 0u)
+                asmgen.loadIndirectWordAY(zpPtrVar, 0u)
                 asmgen.out("""
                     sta  P8ZP_SCRATCH_W1
                     sty  P8ZP_SCRATCH_W1+1
@@ -1818,7 +2002,7 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
             SourceStorageKind.VARIABLE -> {
                 require(value.datatype.isWord)
                 val varname = value.asmVarname
-                asmgen.loadIndirectWord(zpPtrVar, 0u)
+                asmgen.loadIndirectWordAY(zpPtrVar, 0u)
                 asmgen.out("""
                     sta  P8ZP_SCRATCH_W1
                     sty  P8ZP_SCRATCH_W1+1
@@ -1830,7 +2014,7 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
                 val register = value.register!!
                 require(register.isWord())
                 val regname = asmgen.asmSymbolName(register)
-                asmgen.loadIndirectWord(zpPtrVar, 0u)
+                asmgen.loadIndirectWordAY(zpPtrVar, 0u)
                 asmgen.out("""
                     sta  P8ZP_SCRATCH_W1
                     sty  P8ZP_SCRATCH_W1+1
@@ -1839,7 +2023,7 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
                 divide(target.dt.isSigned)
             }
             SourceStorageKind.EXPRESSION -> {
-                asmgen.loadIndirectWord(zpPtrVar, 0u)
+                asmgen.loadIndirectWordAY(zpPtrVar, 0u)
                 asmgen.out("  sta  P8ZP_SCRATCH_W1 |  sty  P8ZP_SCRATCH_W1+1")
                 asmgen.assignExpressionToRegister(value.expression!!, RegisterOrPair.AY)
                 divide(target.dt.isSigned)
@@ -1869,7 +2053,7 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
                 val number = value.number!!.number.toInt()
                 if(number in powersOfTwoInt)
                     throw AssemblyError("divide by power of two should have been a shift $value.position")
-                asmgen.loadIndirectWord(zpPtrVar, 0u)
+                asmgen.loadIndirectWordAY(zpPtrVar, 0u)
                 asmgen.out("""
                     sta  P8ZP_SCRATCH_W1
                     sty  P8ZP_SCRATCH_W1+1
@@ -1880,7 +2064,7 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
             SourceStorageKind.VARIABLE -> {
                 require(value.datatype.isWord)
                 val varname = value.asmVarname
-                asmgen.loadIndirectWord(zpPtrVar, 0u)
+                asmgen.loadIndirectWordAY(zpPtrVar, 0u)
                 asmgen.out("""
                     sta  P8ZP_SCRATCH_W1
                     sty  P8ZP_SCRATCH_W1+1
@@ -1892,7 +2076,7 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
                 val register = value.register!!
                 require(register.isWord())
                 val regname = asmgen.asmSymbolName(register)
-                asmgen.loadIndirectWord(zpPtrVar, 0u)
+                asmgen.loadIndirectWordAY(zpPtrVar, 0u)
                 asmgen.out("""
                     sta  P8ZP_SCRATCH_W1
                     sty  P8ZP_SCRATCH_W1+1
@@ -1901,7 +2085,7 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
                 modulus()
             }
             SourceStorageKind.EXPRESSION -> {
-                asmgen.loadIndirectWord(zpPtrVar, 0u)
+                asmgen.loadIndirectWordAY(zpPtrVar, 0u)
                 asmgen.out("  sta  P8ZP_SCRATCH_W1 |  sty  P8ZP_SCRATCH_W1+1")
                 asmgen.assignExpressionToRegister(value.expression!!, RegisterOrPair.AY)
                 modulus()
@@ -2546,46 +2730,42 @@ internal class PointerAssignmentsGen(private val asmgen: AsmGen6502Internal, pri
         }
     }
 
-    internal fun assignIndexedPointer(target: AsmAssignTarget, arrayVarName: String, index: PtExpression, arrayDt: DataType) {
-        TODO("assign indexed pointer from array $arrayVarName  at ${target.position}")
-//        val ptrZp = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UWORD, target.scope, target.position, variableAsmName="P8ZP_SCRATCH_PTR")
-//        assignAddressOfIndexedPointer(ptrZp, arrayVarName, arrayDt, index)
-//        when {
-//            target.datatype.isByteOrBool -> {
-//                asmgen.out("""
-//                    ldy  #0
-//                    lda  (P8ZP_SCRATCH_PTR),y""")
-//                asmgen.assignRegister(RegisterOrPair.A, target)
-//            }
-//            target.datatype.isWord || target.datatype.isPointer -> {
-//                if(asmgen.isTargetCpu(CpuType.CPU65C02))
-//                    asmgen.out("""
-//                        ldy  #1
-//                        lda  (P8ZP_SCRATCH_PTR),y
-//                        tax
-//                        lda  (P8ZP_SCRATCH_PTR)""")
-//                else
-//                    asmgen.out("""
-//                        ldy  #1
-//                        lda  (P8ZP_SCRATCH_PTR),y
-//                        tax
-//                        dey
-//                        lda  (P8ZP_SCRATCH_PTR),y""")
-//                asmgen.assignRegister(RegisterOrPair.AX, target)
-//            }
-//            target.datatype.isLong -> {
-//                TODO("assign long from pointer to $target ${target.position}")
-//            }
-//            target.datatype.isFloat -> {
-//                // TODO optimize the float copying to avoid having to go through FAC1
-//                asmgen.out("""
-//                    lda  P8ZP_SCRATCH_PTR
-//                    ldy  P8ZP_SCRATCH_PTR+1
-//                    jsr  floats.MOVFM""")
-//                asmgen.assignRegister(RegisterOrPair.FAC1, target)
-//            }
-//            else -> throw AssemblyError("weird dt ${target.datatype}")
-//        }
+    internal fun assignIndexedPointer(target: AsmAssignTarget, arrayVarName: String, arrayIndexer: PtArrayIndexer) {
+        // Load value from array[index] and store to pointer target
+        if(target.datatype.isLong) {
+            // Get address of array[index] into AY, then 4-byte copy loop to target pointer
+            val index = arrayIndexer.index
+            asmgen.assignExpressionToRegister(index, RegisterOrPair.AY, false)
+            asmgen.out("  sty  P8ZP_SCRATCH_REG")
+            asmgen.out("  asl  a |  rol  P8ZP_SCRATCH_REG")  // *2
+            asmgen.out("  asl  a |  rol  P8ZP_SCRATCH_REG")  // *4
+            asmgen.out("  ldy  P8ZP_SCRATCH_REG")
+            asmgen.out("""
+                clc
+                adc  $arrayVarName
+                pha
+                tya
+                adc  $arrayVarName+1
+                tay
+                pla""")
+            // Now AY = address of array[index], save to scratch pointer
+            asmgen.out("  sta  P8ZP_SCRATCH_W1 |  sty  P8ZP_SCRATCH_W1+1")
+            // Get target pointer address
+            target.pointer?.let { ptr ->
+                val (ptrVar, offset) = deref(ptr)
+                // 4-byte copy loop from (P8ZP_SCRATCH_W1) to (ptrVar)+offset
+                asmgen.out("""
+                    ldx  #4
+                    ldy  #$offset
+-                   lda  (P8ZP_SCRATCH_W1),y
+                    sta  ($ptrVar),y
+                    iny
+                    dex
+                    bne  -""")
+            } ?: throw AssemblyError("expected pointer target ${target.position}")
+        } else {
+            throw AssemblyError("unsupported type for indexed pointer assignment ${target.datatype} ${target.position}")
+        }
     }
 
     private fun saveOnStack(regs: RegisterOrPair) {

codeGenCpu6502/test/Dummies.kt

@@ -1,93 +0,0 @@
-package prog8tests.codegencpu6502
-
-import prog8.code.core.*
-
-
-internal object DummyMemsizer : IMemSizer {
-    override fun memorySize(dt: DataType, numElements: Int?): Int {
-        if(dt.isPointerArray)
-            return 2 * numElements!!
-        else if(dt.isArray) {
-            require(numElements != null)
-            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)
-        }
-    }
-
-    override fun memorySize(dt: BaseDataType): Int {
-        return memorySize(DataType.forDt(dt), null)
-    }
-}
-
-internal object DummyStringEncoder : IStringEncoding {
-    override val defaultEncoding: Encoding = Encoding.ISO
-
-    override fun encodeString(str: String, encoding: Encoding): List<UByte> {
-        return emptyList()
-    }
-
-    override fun decodeString(bytes: Iterable<UByte>, encoding: Encoding): String {
-        return ""
-    }
-}
-
-internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors: Boolean=true, private val keepMessagesAfterReporting: Boolean=false): IErrorReporter {
-
-    val errors = mutableListOf<String>()
-    val warnings = mutableListOf<String>()
-    val infos = mutableListOf<String>()
-
-    override fun err(msg: String, position: Position) {
-        val text = "${position.toClickableStr()} $msg"
-        if(text !in errors)
-            errors.add(text)
-    }
-
-    override fun warn(msg: String, position: Position) {
-        val text = "${position.toClickableStr()} $msg"
-        if(text !in warnings)
-            warnings.add(text)
-    }
-
-    override fun info(msg: String, position: Position) {
-        val text = "${position.toClickableStr()} $msg"
-        if(text !in infos)
-            infos.add(text)
-    }
-
-    override fun undefined(symbol: List<String>, suggestImport: Boolean, position: Position) {
-         err("undefined symbol: ${symbol.joinToString(".")}", position)
-    }
-
-    override fun noErrors(): Boolean  = errors.isEmpty()
-    override fun noErrorForLine(position: Position) = !errors.any { ":${position.line}:" in it }
-    override fun printSingleError(errormessage: String) { /* prints nothing in tests */ }
-
-    override fun report() {
-        infos.forEach { println("UNITTEST COMPILATION REPORT: INFO: $it") }
-        warnings.forEach { println("UNITTEST COMPILATION REPORT: WARNING: $it") }
-        errors.forEach { println("UNITTEST COMPILATION REPORT: ERROR: $it") }
-        if(throwExceptionAtReportIfErrors)
-            finalizeNumErrors(errors.size, warnings.size, infos.size)
-        if(!keepMessagesAfterReporting) {
-            clear()
-        }
-    }
-
-    fun clear() {
-        errors.clear()
-        warnings.clear()
-        infos.clear()
-    }
-}

codeGenCpu6502/test/TestAsmOptimizer.kt

@@ -0,0 +1,610 @@
+package prog8tests.codegencpu6502
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import prog8.code.StMemVar
+import prog8.code.SymbolTable
+import prog8.code.ast.PtProgram
+import prog8.code.core.DataType
+import prog8.code.target.C64Target
+import prog8.codegen.cpu6502.*
+import prog8tests.helpers.DummyMemsizer
+import prog8tests.helpers.DummyStringEncoder
+
+
+class TestAsmOptimizer: FunSpec({
+
+    val machine = C64Target()
+    val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+    val symbolTable = SymbolTable(program)
+
+    // Add test variables with known non-IO addresses so the optimizer can resolve them
+    // Non-IO addresses in typical C64 RAM range
+    symbolTable.add(StMemVar("myvar", DataType.UBYTE, 0x0300u, null, null))
+    symbolTable.add(StMemVar("var", DataType.UBYTE, 0x0301u, null, null))
+    symbolTable.add(StMemVar("var1", DataType.UWORD, 0x0302u, null, null))
+    symbolTable.add(StMemVar("var2", DataType.UWORD, 0x0304u, null, null))
+    symbolTable.add(StMemVar("ptr", DataType.UWORD, 0x0306u, null, null))
+    symbolTable.add(StMemVar("P8ZP_SCRATCH_PTR", DataType.UWORD, 0x02u, null, null))
+    symbolTable.add(StMemVar("P8ZP_SCRATCH_W1", DataType.UWORD, 0x04u, null, null))
+    symbolTable.add(StMemVar("A1", DataType.UWORD, 0x0310u, null, null))
+    symbolTable.add(StMemVar("A2", DataType.UWORD, 0x0312u, null, null))
+
+    fun optimize(lines: MutableList<String>) {
+        optimizeAssembly(lines, machine, symbolTable)
+    }
+
+    // --- optimizeIncDec ---
+
+    test("optimizeIncDec: removes iny+dey sequence") {
+        val lines = mutableListOf("  iny", "  dey", "  rts", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  rts", "  nop")
+    }
+
+    test("optimizeIncDec: removes iny+dey sequence with comments") {
+        val lines = mutableListOf("  iny  ; increment Y", "  dey  ; decrement Y", "  rts", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  rts", "  nop")
+    }
+
+    test("optimizeIncDec: removes inx+dex sequence") {
+        val lines = mutableListOf("  inx", "  dex", "  rts", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  rts", "  nop")
+    }
+
+    test("optimizeIncDec: removes dey+iny sequence") {
+        val lines = mutableListOf("  dey", "  iny", "  rts", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  rts", "  nop")
+    }
+
+    test("optimizeIncDec: removes dex+inx sequence") {
+        val lines = mutableListOf("  dex", "  inx", "  rts", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  rts", "  nop")
+    }
+
+    test("optimizeIncDec: preserves non-canceling sequences") {
+        val lines = mutableListOf("  iny", "  inx", "  rts", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  iny", "  inx", "  rts", "  nop")
+    }
+
+    // --- optimizeStoreLoadSame ---
+
+    test("optimizeStoreLoadSame: removes sta X + lda X") {
+        val lines = mutableListOf("  lda  #42", "  sta  myvar", "  lda  myvar", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  lda  #42", "  sta  myvar", "  rts")
+    }
+
+    test("optimizeStoreLoadSame: removes sta X + lda X with comments") {
+        val lines = mutableListOf("  nop", "  sta  myvar", "  lda  myvar", "  rts  ; return")
+        optimize(lines)
+        lines shouldBe listOf("  nop", "  sta  myvar", "  rts  ; return")
+    }
+
+    test("optimizeStoreLoadSame: removes pha + pla") {
+        val lines = mutableListOf("  nop", "  pha", "  pla", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  nop", "  rts")
+    }
+
+    test("optimizeStoreLoadSame: removes phx + plx") {
+        val lines = mutableListOf("  nop", "  phx", "  plx", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  nop", "  rts")
+    }
+
+    test("optimizeStoreLoadSame: removes phy + ply") {
+        val lines = mutableListOf("  nop", "  phy", "  ply", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  nop", "  rts")
+    }
+
+    test("optimizeStoreLoadSame: removes lda X + sta X") {
+        val lines = mutableListOf("  nop", "  lda  myvar", "  sta  myvar", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  nop", "  lda  myvar", "  rts")
+    }
+
+    // --- optimizeJsrRtsAndOtherCombinations ---
+
+    test("optimizeJsrRts: converts jsr+rts to jmp") {
+        val lines = mutableListOf("  jsr  mysub", "  rts", "  nop", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  jmp  mysub", "  nop", "  nop")
+    }
+
+    test("optimizeJsrRts: converts jsr+rts to jmp with comments") {
+        val lines = mutableListOf("  jsr  mysub  ; call subroutine", "  rts  ; return", "  nop", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  jmp  mysub  ; call subroutine", "  nop", "  nop")
+    }
+
+    test("optimizeJsrRts: removes rts+jmp") {
+        val lines = mutableListOf("  rts", "  jmp  somewhere", "  nop", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  rts", "  nop", "  nop")
+    }
+
+    test("optimizeJsrRts: removes rts+bra") {
+        val lines = mutableListOf("  rts", "  bra  somewhere", "  nop", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  rts", "  nop", "  nop")
+    }
+
+    test("optimizeJsrRts: removes lda+cmp #0") {
+        val lines = mutableListOf("  lda  myvar", "  cmp  #0", "  beq  skip", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  lda  myvar", "  beq  skip", "  nop")
+    }
+
+    test("optimizeJsrRts: removes lda+cmp #0 with comments") {
+        val lines = mutableListOf("  lda  myvar  ; load variable", "  cmp  #0  ; compare to zero", "  beq  skip  ; branch if equal", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  lda  myvar  ; load variable", "  beq  skip  ; branch if equal", "  nop")
+    }
+
+    test("optimizeJsrRts: removes bra+jmp") {
+        val lines = mutableListOf("  bra  somewhere", "  jmp  elsewhere", "  nop", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  bra  somewhere", "  nop", "  nop")
+    }
+
+    test("optimizeJsrRts: preserves jsr+rts for floats.pushFAC") {
+        val lines = mutableListOf("  jsr  floats.pushFAC", "  rts", "  nop", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  jsr  floats.pushFAC", "  rts", "  nop", "  nop")
+    }
+
+    test("optimizeJsrRts: three consecutive jsr only tail jsr+rts becomes jmp") {
+        val lines = mutableListOf("  jsr  \$4000", "  jsr  \$5000", "  jsr  \$6000", "  rts", "  nop", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  jsr  \$4000", "  jsr  \$5000", "  jmp  \$6000", "  nop", "  nop")
+    }
+
+    test("optimizeJsrRts: single line with embedded newlines only tail converted defensively") {
+        val lines = mutableListOf("  jsr  \$4000\n  jsr  \$5000\n  jsr  \$6000", "  rts", "  nop", "  nop")
+        optimize(lines)
+        // Before fix this became jmp/jmp/jmp via replace("jsr","jmp"); after fix only one jmp via replaceMnemonic
+        val jmpCount = lines.joinToString("\n").split("jmp").size - 1
+        jmpCount shouldBe 1
+    }
+
+    // --- optimizeUselessPushPopStack ---
+
+    test("optimizeUselessPushPop: removes phy+ldy+pla") {
+        val lines = mutableListOf("  phy", "  ldy  #5", "  pla", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  tya", "  ldy  #5", "  rts")
+    }
+
+    test("optimizeUselessPushPop: removes phx+ldx+pla") {
+        val lines = mutableListOf("  phx", "  ldx  #5", "  pla", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  txa", "  ldx  #5", "  rts")
+    }
+
+    test("optimizeUselessPushPop: removes pha+lda+pla") {
+        // Note: optimizer removes all three: pha, lda, and pla
+        val lines = mutableListOf("  pha", "  lda  #5", "  pla", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  rts")
+    }
+
+    test("optimizeUselessPushPop: removes pha+tya+tay+pla") {
+        val lines = mutableListOf("  pha", "  tya", "  tay", "  pla", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  rts")
+    }
+
+    // --- optimizeUnneededTempvarInAdd ---
+
+    test("optimizeUnneededTempvarInAdd: removes scratch variable in add") {
+        val lines = mutableListOf("  sta  P8ZP_SCRATCH_W1", "  lda  #5", "  clc", "  adc  P8ZP_SCRATCH_W1", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  clc", "  adc  #5", "  rts")
+    }
+
+    test("optimizeUnneededTempvarInAdd: removes scratch variable in add with comments") {
+        // Note: comments don't affect the optimization
+        val lines = mutableListOf("  sta  P8ZP_SCRATCH_W1", "  lda  #5", "  clc", "  adc  P8ZP_SCRATCH_W1", "  rts  ; return")
+        optimize(lines)
+        lines shouldBe listOf("  clc", "  adc  #5", "  rts  ; return")
+    }
+
+    // --- optimizeTSBtoRegularOr ---
+
+    test("optimizeTSBtoRegularOr: converts lda/tsb/lda to lda/ora/sta") {
+        val lines = mutableListOf("  lda  var2", "  tsb  var1", "  lda  var1", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  lda  var1", "  ora  var2", "  sta  var1", "  rts")
+    }
+
+    test("optimizeTSBtoRegularOr: converts lda/tsb/lda to lda/ora/sta with comments") {
+        // Note: comments don't affect the optimization
+        val lines = mutableListOf("  lda  var2", "  tsb  var1", "  lda  var1", "  rts  ; return")
+        optimize(lines)
+        lines shouldBe listOf("  lda  var1", "  ora  var2", "  sta  var1", "  rts  ; return")
+    }
+
+    // --- optimizeSameAssignments ---
+
+    test("optimizeSameAssignments: removes duplicate lda/ldy/sta/sty word init") {
+        val lines = mutableListOf(
+            "  lda  #1", "  ldy  #0", "  sta  var1", "  sty  var1+1",
+            "  lda  #1", "  ldy  #0", "  sta  var2", "  sty  var2+1",
+            "  rts", "  nop", "  nop", "  nop", "  nop", "  nop"
+        )
+        optimize(lines)
+        lines shouldBe listOf(
+            "  lda  #1", "  ldy  #0", "  sta  var1", "  sty  var1+1",
+            "  sta  var2", "  sty  var2+1",
+            "  rts", "  nop", "  nop", "  nop", "  nop", "  nop"
+        )
+    }
+
+    // --- optimizeSamePointerIndexingAndUselessBeq ---
+
+    test("optimizeSamePointerIndexing: removes redundant ldy in pointer indexing") {
+        val lines = mutableListOf(
+            "  ldy  #0", "  lda  (ptr),y", "  ora  #3", "  ldy  #0", "  sta  (ptr),y", "  rts",
+            "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop"
+        )
+        optimize(lines)
+        lines shouldBe listOf("  ldy  #0", "  lda  (ptr),y", "  ora  #3", "  sta  (ptr),y", "  rts",
+            "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop")
+    }
+
+    // --- optimizeAddWordToSameVariableOrExtraRegisterLoadInWordStore ---
+
+    test("optimizeAddWordToSameVariable: optimizes P8ZP_SCRATCH_PTR += AY") {
+        val lines = mutableListOf(
+            "  clc", "  adc  P8ZP_SCRATCH_PTR", "  pha", "  tya",
+            "  adc  P8ZP_SCRATCH_PTR+1", "  tay", "  pla",
+            "  sta  P8ZP_SCRATCH_PTR", "  sty  P8ZP_SCRATCH_PTR+1", "  rts",
+            "  nop", "  nop", "  nop", "  nop"
+        )
+        optimize(lines)
+        lines shouldBe listOf(
+            "  clc", "  adc  P8ZP_SCRATCH_PTR", "  sta  P8ZP_SCRATCH_PTR",
+            "  tya", "  adc  P8ZP_SCRATCH_PTR+1", "  sta  P8ZP_SCRATCH_PTR+1", "  rts",
+            "  nop", "  nop", "  nop", "  nop"
+        )
+    }
+
+    test("optimizeExtraRegisterLoadInWordStore: removes ldx+sta+txa+ldy+sta") {
+        val lines = mutableListOf("  ldx  #42", "  sta  myvar", "  txa", "  ldy  #1", "  sta  myvar+1", "  rts",
+            "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop")
+        optimize(lines)
+        lines shouldBe listOf("  sta  myvar", "  lda  #42", "  ldy  #1", "  sta  myvar+1", "  rts",
+            "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop")
+    }
+
+    // --- Edge cases ---
+
+    test("handles empty input") {
+        val lines = mutableListOf<String>()
+        optimize(lines)
+        lines shouldBe emptyList()
+    }
+
+    test("handles single line input") {
+        val lines = mutableListOf("  rts")
+        optimize(lines)
+        lines shouldBe listOf("  rts")
+    }
+
+    test("multiple optimizations in one pass") {
+        val lines = mutableListOf("  iny", "  dey", "  lda  #1", "  sta  var", "  lda  var", "  rts")
+        optimize(lines)
+        lines shouldBe listOf("  lda  #1", "  sta  var", "  rts")
+    }
+
+    // --- Helper function tests ---
+
+    // hasInstr tests
+    test("hasInstr: exact match") {
+        "iny".hasInstr("iny") shouldBe true
+        "pla".hasInstr("pla") shouldBe true
+        "rts".hasInstr("rts") shouldBe true
+    }
+
+    test("hasInstr: starts with mnemonic and space") {
+        "lda  #1".hasInstr("lda") shouldBe true
+        "sta  myvar".hasInstr("sta") shouldBe true
+        "ldy  #0".hasInstr("ldy") shouldBe true
+        "inc  a".hasInstr("inc") shouldBe true
+    }
+
+    test("hasInstr: contains mnemonic after label") {
+        "mylabel: lda  #1".hasInstr("lda") shouldBe true
+        "loop: iny".hasInstr("iny") shouldBe true
+        "skip: rts".hasInstr("rts") shouldBe true
+    }
+
+    test("hasInstr: does not match named labels without colon") {
+        // Named labels require a colon to distinguish from instructions
+        "mylabel lda  #1".hasInstr("lda") shouldBe false
+        "loop iny".hasInstr("iny") shouldBe false
+        "skip rts".hasInstr("rts") shouldBe false
+    }
+
+    test("hasInstr: handles 64tass anonymous labels with colon") {
+        "+: lda  #1".hasInstr("lda") shouldBe true
+        "++: lda  #1".hasInstr("lda") shouldBe true
+        "-: lda  #1".hasInstr("lda") shouldBe true
+        "--: lda  #1".hasInstr("lda") shouldBe true
+        "+: rts".hasInstr("rts") shouldBe true
+        "+++: iny".hasInstr("iny") shouldBe true
+    }
+
+    test("hasInstr: handles 64tass anonymous labels without colon") {
+        "+ lda  #1".hasInstr("lda") shouldBe true
+        "++ lda  #1".hasInstr("lda") shouldBe true
+        "- lda  #1".hasInstr("lda") shouldBe true
+        "-- lda  #1".hasInstr("lda") shouldBe true
+        "+ rts".hasInstr("rts") shouldBe true
+        "+++ iny".hasInstr("iny") shouldBe true
+    }
+
+    test("hasInstr: handles scoped labels with periods") {
+        "mysub.loop: lda  #1".hasInstr("lda") shouldBe true
+        "_private: rts".hasInstr("rts") shouldBe true
+        // Without colon, named labels are not recognized
+        "mysub.loop lda  #1".hasInstr("lda") shouldBe false
+        "_private rts".hasInstr("rts") shouldBe false
+    }
+
+    test("hasInstr: does not match numbers as labels") {
+        "1 lda  #1".hasInstr("lda") shouldBe false
+        "+1 lda  #1".hasInstr("lda") shouldBe false
+        "-1 lda  #1".hasInstr("lda") shouldBe false
+    }
+
+    test("hasInstr: does not match partial mnemonics") {
+        "lda  #1".hasInstr("ld") shouldBe false
+        "sta  var".hasInstr("st") shouldBe false
+        "iny".hasInstr("in") shouldBe false
+    }
+
+    test("hasInstr: does not match mnemonic in operand") {
+        // Note: hasInstr uses contains(" mnemonic") which can match operands
+        // This is a known limitation - the optimizer only calls hasInstr on
+        // trimmed lines where the instruction is at the start or after a label
+        "lda  #iny".hasInstr("iny") shouldBe false
+        // "sta  pla" would match due to contains(" pla") - this is expected behavior
+        // in the optimizer context where lines are properly formatted
+    }
+
+    test("hasInstr: handles inc a variants") {
+        "inc  a".hasInstr("inc  a") shouldBe true
+        "inc a".hasInstr("inc a") shouldBe true
+        "inc  var".hasInstr("inc  a") shouldBe false
+    }
+
+    test("hasInstr: handles lines with trailing comments") {
+        "iny  ; increment Y".hasInstr("iny") shouldBe true
+        "lda  #1  ; load immediate".hasInstr("lda") shouldBe true
+        "mylabel: rts  ; return".hasInstr("rts") shouldBe true
+        // Note: hasInstr expects trimmed lines, so leading whitespace must be removed first
+        "dey  ; decrement Y".hasInstr("dey") shouldBe true
+    }
+
+    test("hasInstr: handles dec a variants") {
+        "dec  a".hasInstr("dec  a") shouldBe true
+        "dec a".hasInstr("dec a") shouldBe true
+        "dec  var".hasInstr("dec  a") shouldBe false
+    }
+
+    // isBranch tests
+    test("isBranch: matches branch instructions") {
+        "beq  skip".isBranch() shouldBe true
+        "bne  loop".isBranch() shouldBe true
+        "bcc  target".isBranch() shouldBe true
+        "bcs  target".isBranch() shouldBe true
+        "bmi  neg".isBranch() shouldBe true
+        "bpl  pos".isBranch() shouldBe true
+        "bvc  noov".isBranch() shouldBe true
+        "bvs  ov".isBranch() shouldBe true
+        "bra  somewhere".isBranch() shouldBe true
+    }
+
+    test("isBranch: matches branch instructions with trailing comments") {
+        "beq  skip  ; branch if equal".isBranch() shouldBe true
+        "bne  loop  ; branch if not equal".isBranch() shouldBe true
+        "bra  target  ; always branch".isBranch() shouldBe true
+    }
+
+    test("isBranch: does not match non-branch instructions") {
+        "lda  #1".isBranch() shouldBe false
+        "sta  var".isBranch() shouldBe false
+        "rts".isBranch() shouldBe false
+        "nop".isBranch() shouldBe false
+    }
+
+    // isStoreReg tests
+    test("isStoreReg: matches store instructions") {
+        "sta  var".isStoreReg() shouldBe true
+        "sty  var".isStoreReg() shouldBe true
+        "stx  var".isStoreReg() shouldBe true
+    }
+
+    test("isStoreReg: matches store instructions with trailing comments") {
+        "sta  var  ; store accumulator".isStoreReg() shouldBe true
+        "sty  myvar  ; store Y".isStoreReg() shouldBe true
+        "stx  counter  ; store X".isStoreReg() shouldBe true
+    }
+
+    test("isStoreReg: does not match non-store instructions") {
+        "lda  var".isStoreReg() shouldBe false
+        "ldy  var".isStoreReg() shouldBe false
+        "ldx  var".isStoreReg() shouldBe false
+        "sta".isStoreReg() shouldBe false  // no space after
+    }
+
+    // isStoreRegOrZero tests
+    test("isStoreRegOrZero: matches store and stz") {
+        "sta  var".isStoreRegOrZero() shouldBe true
+        "sty  var".isStoreRegOrZero() shouldBe true
+        "stx  var".isStoreRegOrZero() shouldBe true
+        "stz  var".isStoreRegOrZero() shouldBe true
+    }
+
+    test("isStoreRegOrZero: does not match non-store") {
+        "lda  var".isStoreRegOrZero() shouldBe false
+        "stz".isStoreRegOrZero() shouldBe false  // no space after
+    }
+
+    // isLoadReg tests
+    test("isLoadReg: matches load instructions") {
+        "lda  var".isLoadReg() shouldBe true
+        "ldy  var".isLoadReg() shouldBe true
+        "ldx  var".isLoadReg() shouldBe true
+    }
+
+    test("isLoadReg: matches load instructions with trailing comments") {
+        "lda  var  ; load accumulator".isLoadReg() shouldBe true
+        "ldy  #5  ; load Y".isLoadReg() shouldBe true
+        "ldx  counter  ; load X".isLoadReg() shouldBe true
+    }
+
+    test("isLoadReg: does not match non-load instructions") {
+        "sta  var".isLoadReg() shouldBe false
+        "sty  var".isLoadReg() shouldBe false
+        "stx  var".isLoadReg() shouldBe false
+        "lda".isLoadReg() shouldBe false  // no space after
+    }
+
+    // haslabel tests
+    test("haslabel: detects labels") {
+        haslabel("mylabel:") shouldBe true
+        haslabel("loop:") shouldBe true
+        haslabel("mylabel: lda  #1") shouldBe true
+        haslabel("loop: iny") shouldBe true
+    }
+
+    test("haslabel: detects labels with trailing comments") {
+        haslabel("mylabel:  ; this is a label") shouldBe true
+        haslabel("loop: lda  #1  ; load immediate") shouldBe true
+        haslabel("skip:  ; skip ahead") shouldBe true
+    }
+
+    test("haslabel: does not detect non-labels") {
+        haslabel("  lda  #1") shouldBe false
+        haslabel("  iny") shouldBe false
+        haslabel("; comment") shouldBe false
+        haslabel("") shouldBe false
+    }
+
+    test("haslabel: handles labels with leading whitespace") {
+        haslabel(" label:") shouldBe true
+        haslabel("\tlabel:") shouldBe true
+    }
+
+    // keeplabel tests
+    test("keeplabel: extracts label from line") {
+        keeplabel("mylabel: lda  #1") shouldBe "mylabel:"
+        keeplabel("loop: iny") shouldBe "loop:"
+        keeplabel("mylabel:") shouldBe "mylabel:"
+    }
+
+    test("keeplabel: extracts label from line with trailing comment") {
+        keeplabel("mylabel: lda  #1  ; load immediate") shouldBe "mylabel:"
+        keeplabel("loop:  ; just a label") shouldBe "loop:"
+        keeplabel("skip: rts  ; return") shouldBe "skip:"
+    }
+
+    test("keeplabel: returns colon-only for non-label lines with leading whitespace") {
+        // keeplabel splits on first whitespace and returns first part + ":"
+        // For "  lda  #1", first part is empty string, so returns ":"
+        keeplabel("  lda  #1") shouldBe ":"
+        keeplabel("  iny") shouldBe ":"
+    }
+
+    test("keeplabel: handles tab-separated labels") {
+        keeplabel("mylabel\tlda  #1") shouldBe "mylabel:"
+    }
+
+    // ========================================================================
+    // KNOWN BUGS - These tests demonstrate current optimizer defects.
+    // See AsmOptimizer.kt header for the full list.
+    // ========================================================================
+
+    test("float copy init to different destinations should not be removed") {
+        val lines = mutableListOf(
+            // Lines 0-6: first float copy
+            "  lda  #1", "  ldy  #0", "  sta  floatA", "  sty  floatA+1",
+            "  lda  #1", "  ldy  #0", "  jsr  floats.copy_float",
+            // Lines 7-13: second float copy to DIFFERENT destination
+            "  lda  #1", "  ldy  #0", "  sta  floatB", "  sty  floatB+1",
+            "  lda  #1", "  ldy  #0", "  jsr  floats.copy_float"
+        )
+        val beforeOpt = lines.toList()
+        optimize(lines)
+        lines shouldBe beforeOpt
+    }
+
+    test("variable name containing 'y' should not trigger false positive") {
+        val lines = mutableListOf(
+            "  ldy  #0", "  lda  (ptr),y", "  ora  myvar",  // 'y' in "myvar" no longer triggers false positive
+            "  ldy  #0", "  sta  (ptr),y", "  rts",
+            "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop"
+        )
+        // The second ldy should be removed since "ora" doesn't modify Y
+        optimize(lines)
+        lines shouldBe listOf("  ldy  #0", "  lda  (ptr),y", "  ora  myvar", "  sta  (ptr),y", "  rts",
+            "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop")
+    }
+
+    test("actual Y-modifying instructions should still be detected") {
+        val lines = mutableListOf(
+            "  ldy  #0", "  lda  (ptr),y", "  tay",  // tay modifies Y, so ldy cannot be removed
+            "  ldy  #0", "  sta  (ptr),y", "  rts",
+            "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop"
+        )
+        // The second ldy should NOT be removed since "tay" modifies Y
+        optimize(lines)
+        lines shouldBe listOf(
+            "  ldy  #0", "  lda  (ptr),y", "  tay",
+            "  ldy  #0", "  sta  (ptr),y", "  rts",
+            "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop", "  nop")
+    }
+
+    test("modifiesYRegister: correctly identifies Y-modifying instructions") {
+        "  ldy  #0".modifiesYRegister() shouldBe true
+        "  tay".modifiesYRegister() shouldBe true
+        "  iny".modifiesYRegister() shouldBe true
+        "  dey".modifiesYRegister() shouldBe true
+        "  tya".modifiesYRegister() shouldBe true
+        "  phy".modifiesYRegister() shouldBe true
+        "  ply".modifiesYRegister() shouldBe true
+        "  sty  var".modifiesYRegister() shouldBe true
+        "  ora  myvar".modifiesYRegister() shouldBe false  // false positive fixed
+        "  lda  #0".modifiesYRegister() shouldBe false
+        "  cpy  #0".modifiesYRegister() shouldBe false  // compare doesn't modify
+        "  jsr  func".modifiesYRegister() shouldBe false
+    }
+
+    test("compiler-prefixed memory-mapped IO variable accesses are not optimized away") {
+        symbolTable.add(StMemVar("p8b_main.p8v_io_data", DataType.UBYTE, 0xd021u, null, null))
+        symbolTable.add(StMemVar("p8b_main.p8v_result", DataType.UBYTE, 0x0300u, null, null))
+        val lines = mutableListOf(
+            "  lda  p8b_main.p8v_io_data", "  sta  p8b_main.p8v_result",
+            "  lda  p8b_main.p8v_io_data", "  sta  p8b_main.p8v_result",
+            "  lda  p8b_main.p8v_io_data", "  sta  p8b_main.p8v_result",
+            "  rts", "  nop"
+        )
+        optimize(lines)
+        lines.size shouldBe 8  // all instructions preserved
+        lines shouldBe listOf(
+            "  lda  p8b_main.p8v_io_data", "  sta  p8b_main.p8v_result",
+            "  lda  p8b_main.p8v_io_data", "  sta  p8b_main.p8v_result",
+            "  lda  p8b_main.p8v_io_data", "  sta  p8b_main.p8v_result",
+            "  rts", "  nop"
+        )
+    }
+})

codeGenCpu6502/test/TestCodegen.kt

@@ -14,6 +14,9 @@ import prog8.code.source.SourceCode
 import prog8.code.target.C64Target
 import prog8.codegen.cpu6502.AsmGen6502
 import prog8.codegen.cpu6502.VariableAllocator
+import prog8tests.helpers.DummyMemsizer
+import prog8tests.helpers.DummyStringEncoder
+import prog8tests.helpers.ErrorReporterForTests
 import java.nio.file.Files
 import kotlin.io.path.Path
 
@@ -21,20 +24,13 @@ class TestCodegen: FunSpec({
 
     fun getTestOptions(): CompilationOptions {
         val target = C64Target()
-        return CompilationOptions(
-            OutputType.RAW,
-            CbmPrgLauncherType.NONE,
-            ZeropageType.DONTUSE,
-            zpReserved = emptyList(),
-            zpAllowed = CompilationOptions.AllZeropageAllowed,
-            floats = true,
-            noSysInit = false,
-            romable = false,
-            compTarget = target,
-            compilerVersion="99.99",
-            loadAddress = target.PROGRAM_LOAD_ADDRESS,
-            memtopAddress = 0xffffu
-        )
+        return CompilationOptions.builder(target)
+            .output(OutputType.RAW)
+            .zeropage(ZeropageType.DONTUSE)
+            .floats(true)
+            .compilerVersion("99.99")
+            .memtopAddress(0xffffu)
+            .build()
     }
 
     test("augmented assign on arrays") {
@@ -174,7 +170,7 @@ class TestCodegen: FunSpec({
         val st = SymbolTable(program)
         st.add(StMemVar("zpmemvar", DataType.WORD, 0x20u, null, null))
         st.add(StMemVar("normalmemvar", DataType.WORD, 0x9000u, null, null))
-        val allocator = VariableAllocator(st, getTestOptions(), ErrorReporterForTests())
+        val allocator = VariableAllocator(st, getTestOptions(), ErrorReporterForTests(), program)
         allocator.isZpVar("zpmemvar") shouldBe true
         allocator.isZpVar("normalmemvar") shouldBe false
     }

codeGenExperimental/build.gradle.kts

@@ -1,26 +0,0 @@
-plugins {
-    kotlin("jvm")
-}
-
-dependencies {
-    implementation(project(":codeCore"))
-    implementation(project(":simpleAst"))
-    implementation(project(":intermediate"))
-    implementation(project(":codeGenIntermediate"))
-    // implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
-    // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation("com.michael-bull.kotlin-result:kotlin-result-jvm:2.1.0")
-}
-
-sourceSets {
-    main {
-        java {
-            srcDir(file("${project.projectDir}/src"))
-        }
-        resources {
-            srcDir(file("${project.projectDir}/res"))
-        }
-    }
-}
-
-// note: there are no unit tests in this module!

codeGenExperimental/codeGenExperimental.iml

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <excludeFolder url="file://$MODULE_DIR$/build" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
-    <orderEntry type="module" module-name="codeGenIntermediate" />
-    <orderEntry type="module" module-name="intermediate" />
-    <orderEntry type="module" module-name="codeCore" />
-    <orderEntry type="module" module-name="simpleAst" />
-  </component>
-</module>

codeGenExperimental/src/prog8/codegen/experimental/ExperiCodeGen.kt

@@ -1,43 +0,0 @@
-package prog8.codegen.experimental
-
-import prog8.code.IAssemblyProgram
-import prog8.code.ICodeGeneratorBackend
-import prog8.code.SymbolTable
-import prog8.code.ast.PtProgram
-import prog8.code.core.CompilationOptions
-import prog8.code.core.IErrorReporter
-import prog8.codegen.intermediate.IRCodeGen
-import prog8.intermediate.IRFileWriter
-
-class ExperiCodeGen(val retainSSA: Boolean): ICodeGeneratorBackend {
-    override fun generate(
-        program: PtProgram,
-        symbolTable: SymbolTable,
-        options: CompilationOptions,
-        errors: IErrorReporter
-    ): IAssemblyProgram {
-
-        // you could write a code generator directly on the PtProgram AST,
-        // but you can also use the Intermediate Representation to build a codegen on:
-        val irCodeGen = IRCodeGen(program, symbolTable, options, errors, retainSSA)
-        val irProgram = irCodeGen.generate()
-        irProgram.verifyRegisterTypes(irCodeGen.registerTypes())
-
-        // this stub only writes the IR program to disk but doesn't generate anything else.
-        IRFileWriter(irProgram, null).write()
-
-        if(!options.quiet)
-            println("** experimental codegen stub: no assembly generated **")
-        return EmptyProgram
-    }
-}
-
-private object EmptyProgram : IAssemblyProgram {
-    override val name = "<Empty Program>"
-    override fun assemble(options: CompilationOptions, errors: IErrorReporter): Boolean {
-        if(!options.quiet)
-            println("** nothing assembled **")
-        return true
-    }
-
-}

codeGenIntermediate/build.gradle.kts

@@ -7,39 +7,8 @@ dependencies {
     implementation(project(":codeCore"))
     implementation(project(":simpleAst"))
     implementation(project(":intermediate"))
-    // implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
-    // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation("com.michael-bull.kotlin-result:kotlin-result-jvm:2.1.0")
+    implementation("com.michael-bull.kotlin-result:kotlin-result-jvm:2.3.1")
 
-    testImplementation("io.kotest:kotest-runner-junit5-jvm:5.9.1")
-    testImplementation("io.kotest:kotest-framework-datatest:5.9.1")
-}
-
-sourceSets {
-    main {
-        java {
-            srcDir("${project.projectDir}/src")
-        }
-        resources {
-            srcDir("${project.projectDir}/res")
-        }
-    }
-    test {
-        java {
-            srcDir("${project.projectDir}/test")
-        }
-    }
-}
-
-tasks.test {
-    // Enable JUnit 5 (Gradle 4.6+).
-    useJUnitPlatform()
-
-    // Always run tests, even when nothing changed.
-    dependsOn("cleanTest")
-
-    // Show test results.
-    testLogging {
-        events("skipped", "failed")
-    }
+    testImplementation(testFixtures(project(":codeCore")))
+    testImplementation("io.kotest:kotest-runner-junit5")
 }

codeGenIntermediate/codeGenIntermediate.iml

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
-      <excludeFolder url="file://$MODULE_DIR$/build" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="module" module-name="codeCore" />
-    <orderEntry type="module" module-name="simpleAst" />
-    <orderEntry type="module" module-name="intermediate" />
-    <orderEntry type="library" name="io.kotest.runner.junit5.jvm" level="project" />
-    <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
-    <orderEntry type="library" name="io.kotest.framework.datatest" level="project" />
-  </component>
-</module>

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

@@ -1,6 +1,5 @@
 package prog8.codegen.intermediate
 
-import prog8.code.StMemorySlabBlockName
 import prog8.code.StStructInstanceBlockName
 import prog8.code.SymbolTable
 import prog8.code.ast.*
@@ -12,14 +11,17 @@ import prog8.intermediate.*
 
 internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGen: ExpressionGen) {
 
-    fun translate(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    fun translate(call: PtFunctionCall): ExpressionCodeResult {
+        require(call.builtin)
         return when(call.name) {
             "abs__byte", "abs__word", "abs__long", "abs__float" -> funcAbs(call)
             "cmp" -> funcCmp(call)
             "sgn" -> funcSgn(call)
             "sqrt__ubyte", "sqrt__uword", "sqrt__long", "sqrt__float" -> funcSqrt(call)
-            "divmod__ubyte" -> funcDivmod(call, IRDataType.BYTE)
-            "divmod__uword" -> funcDivmod(call, IRDataType.WORD)
+            "divmod__ubyte" -> funcDivmod(call, IRDataType.BYTE, false)
+            "divmod__uword" -> funcDivmod(call, IRDataType.WORD, false)
+            "divmod__byte" -> funcDivmod(call, IRDataType.BYTE, true)
+            "divmod__word" -> funcDivmod(call, IRDataType.WORD, true)
             "rsave", "rrestore" -> ExpressionCodeResult.EMPTY  // vm doesn't have registers to save/restore
             "callfar" -> funcCallfar(call)
             "callfar2" -> funcCallfar2(call)
@@ -30,7 +32,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             "msb__long" -> funcMsb(call, true)
             "lsb" -> funcLsb(call, false)
             "lsb__long" -> funcLsb(call, true)
-            "memory" -> funcMemory(call)
+            "lmh" -> funcLmh(call)
             "peek" -> funcPeek(call, IRDataType.BYTE)
             "peekbool" -> funcPeek(call, IRDataType.BYTE)
             "peekw" -> funcPeek(call, IRDataType.WORD)
@@ -57,20 +59,85 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             "prog8_lib_stringcompare" -> funcStringCompare(call)
             "prog8_lib_square_byte" -> funcSquare(call, IRDataType.BYTE)
             "prog8_lib_square_word" -> funcSquare(call, IRDataType.WORD)
+            "prog8_lib_square_long" -> funcSquare(call, IRDataType.LONG)
             "prog8_lib_structalloc" -> funcStructAlloc(call)
             "prog8_lib_copylong" -> funcCopyFromPointer1ToPointer2(call, IRDataType.LONG)
             "prog8_lib_copyfloat" -> funcCopyFromPointer1ToPointer2(call, IRDataType.FLOAT)
-            "sizeof" -> throw AssemblyError("sizeof must have been replaced with a constant")
-            "offsetof" -> throw AssemblyError("offsetof must have been replaced with a constant")
-            "swap__byte" -> funcSwap(call)
-            "swap__word" -> funcSwap(call)
-            "swap__long" -> funcSwap(call)
-            "swap__float" -> funcSwap(call)
-            else -> throw AssemblyError("missing builtinfunc for ${call.name}")
+            "push" -> funcPush(call)
+            "pushw" -> funcPushW(call)
+            "pushl" -> funcPushL(call)
+            "pushf" -> funcPushF(call)
+            "pop" -> funcPop()
+            "popw" -> funcPopW()
+            "popl" -> funcPopL()
+            "popf" -> funcPopF()
+            "sizeof" -> throw AssemblyError("sizeof must have been replaced with a constant  ${call.position}")
+            "offsetof" -> throw AssemblyError("offsetof must have been replaced with a constant  ${call.position}")
+            else -> throw AssemblyError("missing builtinfunc for ${call.name}  ${call.position}")
         }
     }
 
-    private fun funcCopyFromPointer1ToPointer2(call: PtBuiltinFunctionCall, type: IRDataType): ExpressionCodeResult {
+    private fun funcPush(call: PtFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val tr = exprGen.translateExpression(call.args[0])
+        addToResult(result, tr, tr.resultReg, -1)
+        addInstr(result, IRInstruction(Opcode.PUSH, IRDataType.BYTE, reg1=tr.resultReg), null)
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
+    }
+
+    private fun funcPushW(call: PtFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val tr = exprGen.translateExpression(call.args[0])
+        addToResult(result, tr, tr.resultReg, -1)
+        addInstr(result, IRInstruction(Opcode.PUSH, IRDataType.WORD, reg1=tr.resultReg), null)
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
+    }
+
+    private fun funcPushL(call: PtFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val tr = exprGen.translateExpression(call.args[0])
+        addToResult(result, tr, tr.resultReg, -1)
+        addInstr(result, IRInstruction(Opcode.PUSH, IRDataType.LONG, reg1=tr.resultReg), null)
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
+    }
+
+    private fun funcPushF(call: PtFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val tr = exprGen.translateExpression(call.args[0])
+        addToResult(result, tr, -1, tr.resultFpReg)
+        addInstr(result, IRInstruction(Opcode.PUSH, IRDataType.FLOAT, fpReg1 = RegisterNum(tr.resultFpReg)), null)
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
+    }
+
+    private fun funcPop(): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val resultRegister = codeGen.registers.next(IRDataType.BYTE)
+        addInstr(result, IRInstruction(Opcode.POP, IRDataType.BYTE, reg1=resultRegister), null)
+        return ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
+    }
+
+    private fun funcPopW(): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val resultRegister = codeGen.registers.next(IRDataType.WORD)
+        addInstr(result, IRInstruction(Opcode.POP, IRDataType.WORD, reg1=resultRegister), null)
+        return ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
+    }
+
+    private fun funcPopL(): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val resultRegister = codeGen.registers.next(IRDataType.LONG)
+        addInstr(result, IRInstruction(Opcode.POP, IRDataType.LONG, reg1=resultRegister), null)
+        return ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
+    }
+
+    private fun funcPopF(): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val resultRegister = codeGen.registers.next(IRDataType.FLOAT)
+        addInstr(result, IRInstruction(Opcode.POP, IRDataType.FLOAT, fpReg1 = RegisterNum(resultRegister)), null)
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, resultRegister)
+    }
+
+    private fun funcCopyFromPointer1ToPointer2(call: PtFunctionCall, type: IRDataType): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val trSourceAddr = exprGen.translateExpression(call.args[0])
         val trTargetAddr = exprGen.translateExpression(call.args[1])
@@ -80,15 +147,15 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             IRDataType.LONG -> {
                 val intermediateReg = codeGen.registers.next(IRDataType.LONG)
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.LOADI, type, reg1=intermediateReg, reg2=trSourceAddr.resultReg)
-                    it += IRInstruction(Opcode.STOREI, type, reg1=intermediateReg, reg2=trTargetAddr.resultReg)
+                    it += IRInstruction(Opcode.LOADI, type, reg1=intermediateReg, reg2=trSourceAddr.resultReg, immediate = 0)
+                    it += IRInstruction(Opcode.STOREI, type, reg1=intermediateReg, reg2=trTargetAddr.resultReg, immediate = 0)
                 }
             }
             IRDataType.FLOAT -> {
                 val intermediateReg = codeGen.registers.next(IRDataType.FLOAT)
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.LOADI, type, fpReg1=intermediateReg, reg1=trSourceAddr.resultReg)
-                    it += IRInstruction(Opcode.STOREI, type, fpReg1=intermediateReg, reg1=trTargetAddr.resultReg)
+                    it += IRInstruction(Opcode.LOADI, type, fpReg1=RegisterNum(intermediateReg), reg1=trSourceAddr.resultReg, immediate = 0)
+                    it += IRInstruction(Opcode.STOREI, type, fpReg1=RegisterNum(intermediateReg), reg1=trTargetAddr.resultReg, immediate = 0)
                 }
             }
             else -> throw AssemblyError("invalid type $type")
@@ -96,13 +163,13 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
-    private fun funcSquare(call: PtBuiltinFunctionCall, resultType: IRDataType): ExpressionCodeResult {
+    private fun funcSquare(call: PtFunctionCall, resultType: IRDataType): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val valueTr = exprGen.translateExpression(call.args[0])
         addToResult(result, valueTr, valueTr.resultReg, valueTr.resultFpReg)
         return if(resultType==IRDataType.FLOAT) {
             val resultFpReg = codeGen.registers.next(IRDataType.FLOAT)
-            addInstr(result, IRInstruction(Opcode.SQUARE, resultType, fpReg1 = resultFpReg, fpReg2 = valueTr.resultFpReg), null)
+            addInstr(result, IRInstruction(Opcode.SQUARE, resultType, fpReg1 = RegisterNum(resultFpReg), fpReg2 = RegisterNum(valueTr.resultFpReg)), null)
             ExpressionCodeResult(result, resultType, -1, resultFpReg)
         }
         else {
@@ -112,7 +179,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         }
     }
 
-    private fun funcCall(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcCall(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val addressTr = exprGen.translateExpression(call.args[0])
         addToResult(result, addressTr, addressTr.resultReg, -1)
@@ -121,12 +188,12 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
         else {
             val resultvalueReg = codeGen.registers.next(IRDataType.WORD)
-            addInstr(result, IRInstruction(Opcode.LOADHAY, IRDataType.WORD, reg1=resultvalueReg), null)
+            addInstr(result, IRInstruction(Opcode.LOADHR, IRDataType.WORD, reg1=resultvalueReg, immediate=4), null)
             ExpressionCodeResult(result, IRDataType.WORD, resultvalueReg, -1)
         }
     }
 
-    private fun funcCallfar(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcCallfar(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val bankTr = exprGen.translateExpression(call.args[0])
         val addressTr = exprGen.translateExpression(call.args[1])
@@ -138,7 +205,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.WORD, argumentwordTr.resultReg, -1)
     }
 
-    private fun funcCallfar2(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcCallfar2(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val bankTr = exprGen.translateExpression(call.args[0])
         val addressTr = exprGen.translateExpression(call.args[1])
@@ -160,16 +227,18 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.WORD, addressTr.resultReg, -1)
     }
 
-    private fun funcDivmod(call: PtBuiltinFunctionCall, type: IRDataType): ExpressionCodeResult {
+    private fun funcDivmod(call: PtFunctionCall, type: IRDataType, signed: Boolean): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val number = call.args[0]
         val divident = call.args[1]
         val divisionReg: Int
         val remainderReg: Int
+        val divmodOpcode = if(signed) Opcode.SDIVMOD else Opcode.DIVMOD
+        val divmodrOpcode = if(signed) Opcode.SDIVMODR else Opcode.DIVMODR
         if(divident is PtNumber) {
             val tr = exprGen.translateExpression(number)
             addToResult(result, tr, tr.resultReg, -1)
-            addInstr(result, IRInstruction(Opcode.DIVMOD, type, reg1 = tr.resultReg, immediate = divident.number.toInt()), null)
+            addInstr(result, IRInstruction(divmodOpcode, type, reg1 = tr.resultReg, immediate = divident.number.toInt()), null)
             divisionReg = tr.resultReg
             remainderReg = codeGen.registers.next(type)
         } else {
@@ -177,19 +246,29 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             addToResult(result, numTr, numTr.resultReg, -1)
             val dividentTr = exprGen.translateExpression(divident)
             addToResult(result, dividentTr, dividentTr.resultReg, -1)
-            addInstr(result, IRInstruction(Opcode.DIVMODR, type, reg1 = numTr.resultReg, reg2=dividentTr.resultReg), null)
+            addInstr(result, IRInstruction(divmodrOpcode, type, reg1 = numTr.resultReg, reg2=dividentTr.resultReg), null)
             divisionReg = numTr.resultReg
             remainderReg = dividentTr.resultReg
         }
-        // DIVMOD result convention: on value stack, division and remainder on top.
+        // DIVMOD instruction result convention: on value stack, division and remainder on top.
         addInstr(result, IRInstruction(Opcode.POP, type, reg1=remainderReg), null)
         addInstr(result, IRInstruction(Opcode.POP, type, reg1=divisionReg), null)
-        result += assignRegisterTo(call.args[2], divisionReg)
-        result += assignRegisterTo(call.args[3], remainderReg)
+        // return the 2 result values: division and remainder  division in AY, remainder in R15
+        if(type==IRDataType.BYTE) {
+            result += IRCodeChunk(null, null).also {
+                it += IRInstruction(Opcode.STOREHR, IRDataType.BYTE, reg1=divisionReg, immediate=0)
+                it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1=remainderReg, labelSymbol = "cx16.r15")
+            }
+        } else if(type==IRDataType.WORD) {
+            result += IRCodeChunk(null, null).also {
+                it += IRInstruction(Opcode.STOREHR, IRDataType.WORD, reg1=divisionReg, immediate=4)
+                it += IRInstruction(Opcode.STOREM, IRDataType.WORD, reg1=remainderReg, labelSymbol = "cx16.r15")
+            }
+        } else throw AssemblyError("invalid type for DIVMOD")
         return ExpressionCodeResult(result, type, -1, -1)
     }
 
-    private fun funcStringCompare(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcStringCompare(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val left  = exprGen.translateExpression(call.args[0])
         val right = exprGen.translateExpression(call.args[1])
@@ -200,7 +279,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
     }
 
-    private fun funcCmp(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcCmp(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val leftTr = exprGen.translateExpression(call.args[0])
         addToResult(result, leftTr, leftTr.resultReg, -1)
@@ -213,7 +292,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, dt, leftTr.resultReg, -1)
     }
 
-    private fun funcAbs(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcAbs(call: PtFunctionCall): ExpressionCodeResult {
         val sourceDt = call.args.single().type
         val result = mutableListOf<IRCodeChunkBase>()
         if(sourceDt.isUnsignedWord)
@@ -221,12 +300,15 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
 
         val tr = exprGen.translateExpression(call.args[0])
         addToResult(result, tr, tr.resultReg, -1)
+        val needsExplicitCmpi = !codeGen.options.compTarget.cpu.statusBitsOnMultiByteOps
         when (sourceDt.base) {
             BaseDataType.BYTE -> {
                 val notNegativeLabel = codeGen.createLabelName()
                 val compareReg = codeGen.registers.next(IRDataType.BYTE)
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADR, IRDataType.BYTE, reg1=compareReg, reg2=tr.resultReg)
+                    if(needsExplicitCmpi)
+                        it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=compareReg, immediate = 0)
                     it += IRInstruction(Opcode.BSTPOS, labelSymbol = notNegativeLabel)
                     it += IRInstruction(Opcode.NEG, IRDataType.BYTE, reg1=tr.resultReg)
                 }
@@ -238,6 +320,8 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 val compareReg = codeGen.registers.next(IRDataType.WORD)
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADR, IRDataType.WORD, reg1=compareReg, reg2=tr.resultReg)
+                    if(needsExplicitCmpi)
+                        it += IRInstruction(Opcode.CMPI, IRDataType.WORD, reg1=compareReg, immediate = 0)
                     it += IRInstruction(Opcode.BSTPOS, labelSymbol = notNegativeLabel)
                     it += IRInstruction(Opcode.NEG, IRDataType.WORD, reg1=tr.resultReg)
                 }
@@ -249,6 +333,8 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 val compareReg = codeGen.registers.next(IRDataType.LONG)
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADR, IRDataType.LONG, reg1=compareReg, reg2=tr.resultReg)
+                    if(needsExplicitCmpi)
+                        it += IRInstruction(Opcode.CMPI, IRDataType.LONG, reg1=compareReg, immediate = 0)
                     it += IRInstruction(Opcode.BSTPOS, labelSymbol = notNegativeLabel)
                     it += IRInstruction(Opcode.NEG, IRDataType.LONG, reg1=tr.resultReg)
                 }
@@ -257,14 +343,14 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             }
             BaseDataType.FLOAT -> {
                 val resultFpReg = codeGen.registers.next(IRDataType.FLOAT)
-                addInstr(result, IRInstruction(Opcode.FABS, IRDataType.FLOAT, fpReg1 = resultFpReg, fpReg2 = tr.resultFpReg), null)
+                addInstr(result, IRInstruction(Opcode.FABS, IRDataType.FLOAT, fpReg1 = RegisterNum(resultFpReg), fpReg2 = RegisterNum(tr.resultFpReg)), null)
                 return ExpressionCodeResult(result, IRDataType.FLOAT, -1, resultFpReg)
             }
             else -> throw AssemblyError("weird dt")
         }
     }
 
-    private fun funcSgn(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcSgn(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val tr = exprGen.translateExpression(call.args.single())
         val resultReg = codeGen.registers.next(IRDataType.BYTE)
@@ -272,7 +358,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         if(tr.dt==IRDataType.FLOAT) {
             addToResult(result, tr, -1, tr.resultFpReg)
             result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.SGN, tr.dt, reg1 = resultReg, fpReg1 = tr.resultFpReg)
+                it += IRInstruction(Opcode.SGN, tr.dt, reg1 = resultReg, fpReg1 = RegisterNum(tr.resultFpReg))
             }
         } else {
             addToResult(result, tr, tr.resultReg, -1)
@@ -283,7 +369,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
     }
 
-    private fun funcSqrt(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcSqrt(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val tr = exprGen.translateExpression(call.args.single())
         val dt = call.args[0].type
@@ -316,7 +402,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 addToResult(result, tr, -1, tr.resultFpReg)
                 val resultFpReg = codeGen.registers.next(IRDataType.FLOAT)
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.SQRT, IRDataType.FLOAT, fpReg1 = resultFpReg, fpReg2 = tr.resultFpReg)
+                    it += IRInstruction(Opcode.SQRT, IRDataType.FLOAT, fpReg1 = RegisterNum(resultFpReg), fpReg2 = RegisterNum(tr.resultFpReg))
                 }
                 return ExpressionCodeResult(result, IRDataType.FLOAT, -1, resultFpReg)
             }
@@ -324,7 +410,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         }
     }
 
-    private fun funcMkword(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcMkword(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val resultReg = codeGen.registers.next(IRDataType.WORD)
         if((call.args[0] as? PtNumber)?.number == 0.0) {
@@ -342,7 +428,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
     }
 
-    private fun funcMklong(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcMklong(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val resultReg = codeGen.registers.next(IRDataType.LONG)
         if(call.args.size==2) {
@@ -388,44 +474,34 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.LONG, resultReg, -1)
     }
 
-    private fun funcClamp(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val result = mutableListOf<IRCodeChunkBase>()
+    private fun funcClamp(call: PtFunctionCall): ExpressionCodeResult {
         val type = irType(call.type)
+        require(type != IRDataType.FLOAT)
+        val result = mutableListOf<IRCodeChunkBase>()
         val valueTr = exprGen.translateExpression(call.args[0])
         val minimumTr = exprGen.translateExpression(call.args[1])
         val maximumTr = exprGen.translateExpression(call.args[2])
         result += valueTr.chunks
         result += minimumTr.chunks
         result += maximumTr.chunks
-        if(type==IRDataType.FLOAT) {
-            result += codeGen.makeSyscall(
-                IMSyscall.CLAMP_FLOAT, listOf(
-                    valueTr.dt to valueTr.resultFpReg,
-                    minimumTr.dt to minimumTr.resultFpReg,
-                    maximumTr.dt to maximumTr.resultFpReg,
-                ), type to valueTr.resultFpReg
-            )
-            return ExpressionCodeResult(result, type, -1, valueTr.resultFpReg)
-        } else {
-            val syscall = when(call.type.base) {
-                BaseDataType.UBYTE -> IMSyscall.CLAMP_UBYTE
-                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(
-                    valueTr.dt to valueTr.resultReg,
-                    minimumTr.dt to minimumTr.resultReg,
-                    maximumTr.dt to maximumTr.resultReg,
-                ), type to valueTr.resultReg
-            )
-            return ExpressionCodeResult(result, type, valueTr.resultReg, -1)
+        val syscall = when(call.type.base) {
+            BaseDataType.UBYTE -> IMSyscall.CLAMP_UBYTE
+            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(
+                valueTr.dt to valueTr.resultReg,
+                minimumTr.dt to minimumTr.resultReg,
+                maximumTr.dt to maximumTr.resultReg,
+            ), type to valueTr.resultReg
+        )
+        return ExpressionCodeResult(result, type, valueTr.resultReg, -1)
     }
 
-    private fun funcMin(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcMin(call: PtFunctionCall): ExpressionCodeResult {
         val type = irType(call.type)
         val result = mutableListOf<IRCodeChunkBase>()
         val leftTr = exprGen.translateExpression(call.args[0])
@@ -444,7 +520,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, type, leftTr.resultReg, -1)
     }
 
-    private fun funcMax(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcMax(call: PtFunctionCall): ExpressionCodeResult {
         val type = irType(call.type)
         val result = mutableListOf<IRCodeChunkBase>()
         val leftTr = exprGen.translateExpression(call.args[0])
@@ -463,74 +539,55 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, type, leftTr.resultReg, -1)
     }
 
-    private fun funcSwap(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        require(call.args[0].type == call.args[1].type)
-        val result = mutableListOf<IRCodeChunkBase>()
-
-        val dt = irType(call.args[0].type)
-        val t1 = exprGen.translateExpression(call.args[0])
-        val t2 = exprGen.translateExpression(call.args[1])
-        if(dt==IRDataType.FLOAT) {
-            addToResult(result, t1, -1, t1.resultFpReg)
-            addToResult(result, t2, -1, t2.resultFpReg)
-            addInstr(result, IRInstruction(Opcode.SWAP, dt, fpReg1=t1.resultFpReg, fpReg2=t2.resultFpReg), null)
-            result += assignFpRegisterTo(call.args[0], t1.resultFpReg)
-            result += assignFpRegisterTo( call.args[1], t2.resultFpReg)
-        } else {
-            addToResult(result, t1, t1.resultReg, -1)
-            addToResult(result, t2, t2.resultReg, -1)
-            addInstr(result, IRInstruction(Opcode.SWAP, dt, reg1=t1.resultReg, reg2=t2.resultReg), null)
-            result += assignRegisterTo(call.args[0], t1.resultReg)
-            result += assignRegisterTo( call.args[1], t2.resultReg)
-        }
-        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
-    }
-
-    private fun funcPoke(call: PtBuiltinFunctionCall, dt: IRDataType): ExpressionCodeResult {
+    private fun funcPoke(call: PtFunctionCall, dt: IRDataType): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         if(codeGen.isZero(call.args[1])) {
             if (call.args[0] is PtNumber) {
-                val address = (call.args[0] as PtNumber).number.toInt()
+                val address = (call.args[0] as PtNumber).number.toUInt()
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZM, dt, address = address)
+                    it += IRInstruction(Opcode.STOREZM, dt, address = address.toAddress())
                 }
             } else {
-                val tr = exprGen.translateExpression(call.args[0])
-                addToResult(result, tr, tr.resultReg, -1)
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZI, dt, reg1 = tr.resultReg)
+                val (address, offset) = exprGen.getAddressAndOffset(call.args[0])
+                if(address!=null) {
+                    val tr = exprGen.translateExpression(address)
+                    addToResult(result, tr, tr.resultReg, -1)
+                    addInstr(result, IRInstruction(Opcode.STOREZI, dt, reg1 = tr.resultReg, immediate = offset!!), null)
+                } else {
+                    val tr = exprGen.translateExpression(call.args[0])
+                    addToResult(result, tr, tr.resultReg, -1)
+                    addInstr(result, IRInstruction(Opcode.STOREZI, dt, reg1 = tr.resultReg, immediate = 0), null)
                 }
             }
         } else {
+            val valueTr = exprGen.translateExpression(call.args[1])
             if (call.args[0] is PtNumber) {
-                // TODO first evaluate the expression value to store, then the address (easier peephole optimization later)
-                val address = (call.args[0] as PtNumber).number.toInt()
-                val tr = exprGen.translateExpression(call.args[1])
+                val address = (call.args[0] as PtNumber).number.toUInt()
+                addToResult(result, valueTr, valueTr.resultReg, valueTr.resultFpReg)
                 if(dt==IRDataType.FLOAT) {
-                    addToResult(result, tr, -1, tr.resultFpReg)
-                    result += IRCodeChunk(null, null).also {
-                        it += IRInstruction(Opcode.STOREM, dt, fpReg1 = tr.resultFpReg, address = address)
-                    }
+                    addInstr(result, IRInstruction(Opcode.STOREM, dt, fpReg1 = RegisterNum(valueTr.resultFpReg), address = address.toAddress()), null)
                 } else {
-                    addToResult(result, tr, tr.resultReg, -1)
-                    result += IRCodeChunk(null, null).also {
-                        it += IRInstruction(Opcode.STOREM, dt, reg1 = tr.resultReg, address = address)
-                    }
+                    addInstr(result, IRInstruction(Opcode.STOREM, dt, reg1 = valueTr.resultReg, address = address.toAddress()), null)
                 }
             } else {
-                // TODO first evaluate the expression value to store, then the address (easier peephole optimization later)
-                val addressTr = exprGen.translateExpression(call.args[0])
-                addToResult(result, addressTr, addressTr.resultReg, -1)
-                val valueTr = exprGen.translateExpression(call.args[1])
-                if(dt==IRDataType.FLOAT) {
-                    addToResult(result, valueTr, -1, valueTr.resultFpReg)
-                    result += IRCodeChunk(null, null).also {
-                        it += IRInstruction(Opcode.STOREI, IRDataType.FLOAT, reg1 = addressTr.resultReg, fpReg1 = valueTr.resultFpReg)
+                val (address, offset) = exprGen.getAddressAndOffset(call.args[0])
+                if(address!=null) {
+                    val addressTr = exprGen.translateExpression(address)
+                    addToResult(result, valueTr, valueTr.resultReg, valueTr.resultFpReg)
+                    addToResult(result, addressTr, addressTr.resultReg, -1)
+                    if(dt==IRDataType.FLOAT) {
+                        addInstr(result, IRInstruction(Opcode.STOREI, IRDataType.FLOAT, reg1 = addressTr.resultReg, fpReg1 = RegisterNum(valueTr.resultFpReg), immediate = offset!!), null)
+                    } else {
+                        addInstr(result, IRInstruction(Opcode.STOREI, dt, reg1 = valueTr.resultReg, reg2 = addressTr.resultReg, immediate = offset!!), null)
                     }
                 } else {
-                    addToResult(result, valueTr, valueTr.resultReg, -1)
-                    result += IRCodeChunk(null, null).also {
-                        it += IRInstruction(Opcode.STOREI, dt, reg1 = valueTr.resultReg, reg2 = addressTr.resultReg)
+                    val addressTr = exprGen.translateExpression(call.args[0])
+                    addToResult(result, valueTr, valueTr.resultReg, valueTr.resultFpReg)
+                    addToResult(result, addressTr, addressTr.resultReg, -1)
+                    if(dt==IRDataType.FLOAT) {
+                        addInstr(result, IRInstruction(Opcode.STOREI, IRDataType.FLOAT, reg1 = addressTr.resultReg, fpReg1 = RegisterNum(valueTr.resultFpReg), immediate = 0), null)
+                    } else {
+                        addInstr(result, IRInstruction(Opcode.STOREI, dt, reg1 = valueTr.resultReg, reg2 = addressTr.resultReg, immediate = 0), null)
                     }
                 }
             }
@@ -538,109 +595,77 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
-    private fun funcPeek(call: PtBuiltinFunctionCall, dt: IRDataType): ExpressionCodeResult {
+    private fun funcPeek(call: PtFunctionCall, dt: IRDataType): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         return if(dt==IRDataType.FLOAT) {
             if(call.args[0] is PtNumber) {
                 val resultFpRegister = codeGen.registers.next(IRDataType.FLOAT)
-                val address = (call.args[0] as PtNumber).number.toInt()
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1 = resultFpRegister, address = address)
-                }
+                val address = (call.args[0] as PtNumber).number.toUInt()
+                addInstr(result, IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1 = RegisterNum(resultFpRegister), address = address.toAddress()), null)
                 ExpressionCodeResult(result, IRDataType.FLOAT, -1, resultFpRegister)
             } else {
                 val tr = exprGen.translateExpression(call.args.single())
                 addToResult(result, tr, tr.resultReg, -1)
                 val resultFpReg = codeGen.registers.next(IRDataType.FLOAT)
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.LOADI, IRDataType.FLOAT, reg1 = tr.resultReg, fpReg1 = resultFpReg)
-                }
+                addInstr(result, IRInstruction(Opcode.LOADI, IRDataType.FLOAT, reg1 = tr.resultReg, fpReg1 = RegisterNum(resultFpReg), immediate = 0), null)
                 ExpressionCodeResult(result, IRDataType.FLOAT, -1, resultFpReg)
             }
         } else {
             if (call.args[0] is PtNumber) {
                 val resultRegister = codeGen.registers.next(dt)
-                val address = (call.args[0] as PtNumber).number.toInt()
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.LOADM, dt, reg1 = resultRegister, address = address)
-                }
+                val address = (call.args[0] as PtNumber).number.toUInt()
+                addInstr(result, IRInstruction(Opcode.LOADM, dt, reg1 = resultRegister, address = address.toAddress()), null)
                 ExpressionCodeResult(result, dt, resultRegister, -1)
             } else {
                 val tr = exprGen.translateExpression(call.args.single())
                 addToResult(result, tr, tr.resultReg, -1)
                 val resultReg = codeGen.registers.next(dt)
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.LOADI, dt, reg1 = resultReg, reg2 = tr.resultReg)
-                }
+                addInstr(result, IRInstruction(Opcode.LOADI, dt, reg1 = resultReg, reg2 = tr.resultReg, immediate = 0), null)
                 ExpressionCodeResult(result, dt, resultReg, -1)
             }
         }
     }
 
-    private fun funcPokemon(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcPokemon(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val address = call.args[0]
+        val newValue = call.args[1]
 
-        fun pokeM(result: MutableList<IRCodeChunkBase>, address: Int, value: PtExpression) {
-            if(codeGen.isZero(value)) {
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZM, IRDataType.BYTE, address = address)
-                }
-            } else {
-                val tr = exprGen.translateExpression(value)
-                addToResult(result, tr, tr.resultReg, -1)
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = tr.resultReg, address = address)
-                }
-            }
-        }
+        val newValueTr = if (codeGen.isZero(newValue)) null else exprGen.translateExpression(newValue)
 
-        fun pokeI(result: MutableList<IRCodeChunkBase>, register: Int, value: PtExpression) {
-            if(codeGen.isZero(value)) {
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = register)
-                }
-            } else {
-                val valueTr = exprGen.translateExpression(value)
-                addToResult(result, valueTr, valueTr.resultReg, -1)
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = valueTr.resultReg, reg2 = register)
-                }
-            }
-        }
-
-        return if(address is PtNumber) {
+        return if (address is PtNumber) {
+            val addressNum = address.number.toUInt()
             val resultRegister = codeGen.registers.next(IRDataType.BYTE)
-            val addressNum = address.number.toInt()
-            result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1 = resultRegister, address = addressNum)
+            if (newValueTr != null) addToResult(result, newValueTr, newValueTr.resultReg, -1)
+            addInstr(result, IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1 = resultRegister, address = addressNum.toAddress()), null)
+            if (newValueTr == null) {
+                addInstr(result, IRInstruction(Opcode.STOREZM, IRDataType.BYTE, address = addressNum.toAddress()), null)
+            } else {
+                addInstr(result, IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = newValueTr.resultReg, address = addressNum.toAddress()), null)
             }
-            // TODO first evaluate the expression value to store, then the address (easier peephole optimization later)
-            pokeM(result, addressNum, call.args[1])
             ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
         } else {
-            val addressTr = exprGen.translateExpression(address)
-            addToResult(result, addressTr, addressTr.resultReg, -1)
             val resultReg = codeGen.registers.next(IRDataType.BYTE)
-            result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.LOADI, IRDataType.BYTE, reg1 = resultReg, reg2 = addressTr.resultReg)
+            val (baseaddress, offset) = exprGen.getAddressAndOffset(address)
+            val addrExpr = baseaddress ?: address
+            val finalOffset = if (baseaddress != null) offset!! else 0
+
+            val addressTr = exprGen.translateExpression(addrExpr)
+            if (newValueTr != null) addToResult(result, newValueTr, newValueTr.resultReg, -1)
+            addToResult(result, addressTr, addressTr.resultReg, -1)
+
+            addInstr(result, IRInstruction(Opcode.LOADI, IRDataType.BYTE, reg1 = resultReg, reg2 = addressTr.resultReg, immediate = finalOffset), null)
+            if (newValueTr == null) {
+                addInstr(result, IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = addressTr.resultReg, immediate = finalOffset), null)
+            } else {
+                addInstr(result, IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = newValueTr.resultReg, reg2 = addressTr.resultReg, immediate = finalOffset), null)
             }
-            // TODO first evaluate the expression value to store, then the address (easier peephole optimization later)
-            pokeI(result, addressTr.resultReg, call.args[1])
             ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
         }
     }
 
 
-    private fun funcMemory(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val name = (call.args[0] as PtString).value
-        val code = IRCodeChunk(null, null)
-        val resultReg = codeGen.registers.next(IRDataType.WORD)
-        code += IRInstruction(Opcode.LOAD, IRDataType.WORD, reg1=resultReg, labelSymbol = "$StMemorySlabBlockName.memory_$name")
-        return ExpressionCodeResult(code, IRDataType.WORD, resultReg, -1)
-    }
-
-    private fun funcStructAlloc(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcStructAlloc(call: PtFunctionCall): ExpressionCodeResult {
         val code = IRCodeChunk(null, null)
         val resultReg = codeGen.registers.next(IRDataType.WORD)
         val labelname = SymbolTable.labelnameForStructInstance(call)
@@ -648,7 +673,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(code, IRDataType.WORD, resultReg, -1)
     }
 
-    private fun funcLsb(call: PtBuiltinFunctionCall, fromLong: Boolean): ExpressionCodeResult {
+    private fun funcLsb(call: PtFunctionCall, fromLong: Boolean): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val tr = exprGen.translateExpression(call.args.single())
         addToResult(result, tr, tr.resultReg, -1)
@@ -661,7 +686,23 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
     }
 
-    private fun funcLsw(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcLmh(call: PtFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        // TODO this can be more optimal if the argument is a variable or memory address
+        val tr = exprGen.translateExpression(call.args.single())
+        addToResult(result, tr, tr.resultReg, -1)
+        // low byte returned in A, mid in R15, high (bank) in R14
+        val byteReg = codeGen.registers.next(IRDataType.BYTE)
+        addInstr(result, IRInstruction(Opcode.BSIGB, IRDataType.LONG, reg1 = byteReg, reg2 = tr.resultReg), null)
+        addInstr(result, IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = byteReg, labelSymbol = "cx16.r14"), null)
+        addInstr(result, IRInstruction(Opcode.MIDB, IRDataType.LONG, reg1 = byteReg, reg2 = tr.resultReg), null)
+        addInstr(result, IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = byteReg, labelSymbol = "cx16.r15"), null)
+        addInstr(result, IRInstruction(Opcode.LSIGB, IRDataType.LONG, reg1 = byteReg, reg2 = tr.resultReg), null)
+        addInstr(result, IRInstruction(Opcode.STOREHR, IRDataType.BYTE, reg1 = byteReg, immediate = 0), null)
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
+    }
+
+    private fun funcLsw(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val tr = exprGen.translateExpression(call.args.single())
         addToResult(result, tr, tr.resultReg, -1)
@@ -670,7 +711,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
     }
 
-    private fun funcMsb(call: PtBuiltinFunctionCall, fromLong: Boolean): ExpressionCodeResult {
+    private fun funcMsb(call: PtFunctionCall, fromLong: Boolean): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val tr = exprGen.translateExpression(call.args.single())
         addToResult(result, tr, tr.resultReg, -1)
@@ -683,7 +724,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
     }
 
-    private fun funcMsw(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcMsw(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val tr = exprGen.translateExpression(call.args.single())
         addToResult(result, tr, tr.resultReg, -1)
@@ -692,7 +733,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
     }
 
-    private fun funcRolRor(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcRolRor(call: PtFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val arg = call.args[0]
         val vmDt = irType(arg.type)
@@ -710,17 +751,15 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             return ExpressionCodeResult(result, vmDt, -1, -1)
         }
 
-        val memAddr  = (arg as? PtMemoryByte)?.address?.asConstInteger()
+        val memAddr: UInt? = (arg as? PtMemoryByte)?.address?.asConstInteger()?.toUInt()
         if(memAddr!=null) {
-            addInstr(result, IRInstruction(opcodeMemAndReg.first, vmDt, address = memAddr), null)
+            addInstr(result, IRInstruction(opcodeMemAndReg.first, vmDt, address = memAddr.toAddress()), null)
             return ExpressionCodeResult(result, vmDt, -1, -1)
         }
 
         val arr = (arg as? PtArrayIndexer)
         val index = arr?.index?.asConstInteger()
-        if(arr!=null && index!=null) {
-            if(arr.variable==null)
-                TODO("support for ptr indexing ${arr.position}")
+        if(arr!=null && index!=null && arr.variable!=null) {
             val variable = arr.variable!!.name
             if(arr.splitWords) {
                 result += IRCodeChunk(null, null).also {
@@ -754,29 +793,24 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         addInstr(result, IRInstruction(opcode, vmDt, reg1 = tr.resultReg), null)
         if(saveCarry)
             addInstr(result, IRInstruction(Opcode.PUSHST), null)    // save Carry
-        result += assignRegisterTo(arg, tr.resultReg)
+        result += codeGen.assignRegisterTo(arg, tr.resultReg)
         if(saveCarry)
             addInstr(result, IRInstruction(Opcode.POPST), null)
         return ExpressionCodeResult(result, vmDt, -1, -1)
     }
 
-    private fun funcSetLsbMsb(call: PtBuiltinFunctionCall, msb: Boolean): ExpressionCodeResult {
+    private fun funcSetLsbMsb(call: PtFunctionCall, msb: Boolean): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val target = call.args[0]
         val isConstZeroValue = call.args[1].asConstInteger()==0
         when(target) {
             is PtIdentifier -> {
+                val offset = if (msb) { if(target.type.isLong) 3 else 1 } else 0
                 if(isConstZeroValue) {
                     result += IRCodeChunk(null, null).also {
                         val pointerReg = codeGen.registers.next(IRDataType.WORD)
                         it += IRInstruction(Opcode.LOAD, IRDataType.WORD, reg1 = pointerReg, labelSymbol = target.name)
-                        if (msb) {
-                            it += if(target.type.isLong)
-                                IRInstruction(Opcode.ADD, IRDataType.WORD, reg1 = pointerReg, immediate = 3)
-                            else
-                                IRInstruction(Opcode.INC, IRDataType.WORD, reg1 = pointerReg)
-                        }
-                        it += IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = pointerReg)
+                        it += IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = pointerReg, immediate = offset)
                     }
                 } else {
                     val valueTr = exprGen.translateExpression(call.args[1])
@@ -784,22 +818,39 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                     result += IRCodeChunk(null, null).also {
                         val pointerReg = codeGen.registers.next(IRDataType.WORD)
                         it += IRInstruction(Opcode.LOAD, IRDataType.WORD, reg1 = pointerReg, labelSymbol = target.name)
-                        if (msb) {
-                            it += if(target.type.isLong)
-                                IRInstruction(Opcode.ADD, IRDataType.WORD, reg1 = pointerReg, immediate = 3)
-                            else
-                                IRInstruction(Opcode.INC, IRDataType.WORD, reg1 = pointerReg)
-                        }
-                        it += IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = valueTr.resultReg, reg2 = pointerReg)
+                        it += IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = valueTr.resultReg, reg2 = pointerReg, immediate = offset)
                     }
                 }
             }
             is PtArrayIndexer -> {
-                if(target.splitWords) {
+                if(target.variable==null) {
+                    // pointer-based array indexing: compute memory address and store byte
+                    val eltSize = codeGen.program.memsizer.memorySize(target.type, null)
+                    val pointerTr = exprGen.translateExpression(target.pointerderef!!)
+                    addToResult(result, pointerTr, pointerTr.resultReg, -1)
+                    val constIndex = target.index.asConstInteger()
+                    if(constIndex != null) {
+                        val offset = eltSize * constIndex + if(msb) eltSize - 1 else 0
+                        if(offset > 0)
+                            addInstr(result, IRInstruction(Opcode.ADD, IRDataType.WORD, reg1 = pointerTr.resultReg, immediate = offset), null)
+                    } else {
+                        val (code, indexWordReg) = codeGen.loadIndexReg(target.index, eltSize, true, false)
+                        result += code
+                        addInstr(result, IRInstruction(Opcode.ADDR, IRDataType.WORD, reg1 = pointerTr.resultReg, reg2 = indexWordReg), null)
+                        if(msb)
+                            addInstr(result, IRInstruction(Opcode.ADD, IRDataType.WORD, reg1 = pointerTr.resultReg, immediate = eltSize - 1), null)
+                    }
+                    if(isConstZeroValue) {
+                        addInstr(result, IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = pointerTr.resultReg, immediate = 0), null)
+                    } else {
+                        val valueTr = exprGen.translateExpression(call.args[1])
+                        addToResult(result, valueTr, valueTr.resultReg, -1)
+                        addInstr(result, IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = valueTr.resultReg, reg2 = pointerTr.resultReg, immediate = 0), null)
+                    }
+                }
+                else if(target.splitWords) {
                     // lsb/msb in split arrays, element index 'size' is always 1
                     val constIndex = target.index.asConstInteger()
-                    if(target.variable==null)
-                        TODO("support for ptr indexing ${target.position}")
                     val varName = target.variable!!.name + if(msb) "_msb" else "_lsb"
                     if(isConstZeroValue) {
                         if(constIndex!=null) {
@@ -893,28 +944,4 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         }
         return ExpressionCodeResult(result, IRDataType.WORD, -1, -1)
     }
-
-
-    private fun assignRegisterTo(target: PtExpression, register: Int): IRCodeChunks {
-        val assignment = PtAssignment(target.position)
-        val assignTarget = PtAssignTarget(false, target.position)
-        assignTarget.children.add(target)
-        assignment.children.add(assignTarget)
-        assignment.children.add(PtIrRegister(register, target.type, target.position))
-        val result = mutableListOf<IRCodeChunkBase>()
-        result += codeGen.translateNode(assignment)
-        return result
-    }
-
-    private fun assignFpRegisterTo(target: PtExpression, fpRegister: Int): IRCodeChunks {
-        require(target.type.isFloat)
-        val assignment = PtAssignment(target.position)
-        val assignTarget = PtAssignTarget(false, target.position)
-        assignTarget.children.add(target)
-        assignment.children.add(assignTarget)
-        assignment.children.add(PtIrRegister(fpRegister, DataType.FLOAT, target.position))
-        val result = mutableListOf<IRCodeChunkBase>()
-        result += codeGen.translateNode(assignment)
-        return result
-    }
 }

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

@@ -55,7 +55,11 @@ class IRPeepholeOptimizer(private val irprog: IRProgram, private val retainSSA:
                                 || cleanupPushPop(chunk1, indexedInstructions)
                                 || simplifyConstantReturns(chunk1, indexedInstructions)
                                 || removeNeedlessLoads(chunk1, indexedInstructions)
-                                || loadfieldsAndStorefields(chunk1, indexedInstructions)
+                                || removeDeadStores(chunk1, indexedInstructions)
+                                // || removeLoadrForwarding(chunk1, indexedInstructions)  // DISABLED - needs debugging
+                                || removeSelfIdentityOps(chunk1, indexedInstructions)
+                                || simplifyShiftByZero(chunk1, indexedInstructions)
+                                || cancelAdjacentOps(chunk1, indexedInstructions)
                                 || removeNops(chunk1, indexedInstructions)   // last time, in case one of the optimizers replaced something with a nop
                     } while (changed)
                 }
@@ -335,23 +339,28 @@ class IRPeepholeOptimizer(private val irprog: IRProgram, private val retainSSA:
     }
 
     private fun removeNeedlessCompares(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
-        // a CMPI with 0, after an instruction like LOAD that already sets the status bits, can be removed.
-        // but only if the instruction after it is not using the Carry bit because that won't be set by a LOAD instruction etc.
+        // A CMPI #0 after an instruction that already sets the status bits can be removed.
+        // The optimization is ONLY safe if the target CPU honors the "multi-byte ops set
+        // status bits based on the full value" contract (CpuType.statusBitsOnMultiByteOps).
+        // On 8-bit targets like 6502/65C02 a 16/32-bit DEC/INC/AND/OR/XOR/LOAD only sets
+        // Z from the last byte, so a following CMPI #0 is NOT redundant - it tests the
+        // full multi-byte value. In that case we keep the explicit CMPI.
+        // See CpuType.statusBitsOnMultiByteOps for the rationale.
+        val targetHonorsContract = irprog.options.compTarget.cpu.statusBitsOnMultiByteOps
+        if (!targetHonorsContract) return false
         var changed = false
         indexedInstructions.reversed().forEach { (idx, ins) ->
             if(idx>0 && idx<(indexedInstructions.size-1) && ins.opcode==Opcode.CMPI && ins.immediate==0) {
                 val previous = indexedInstructions[idx-1].value
                 if(previous.reg1==ins.reg1) {
-                    if (previous.opcode in OpcodesThatSetStatusbitsIncludingCarry) {
+                    if (previous.opcode in OpcodesThatSetStatusbits) {
                         chunk.instructions.removeAt(idx)
                         changed = true
-                    } else if (previous.opcode in OpcodesThatSetStatusbitsButNotCarry) {
-                        val next = indexedInstructions[idx + 1].value
-                        if (next.opcode !in OpcodesThatDependOnCarry) {
-                            chunk.instructions.removeAt(idx)
-                            changed = true
-                        }
                     }
+                    // Note: the OpcodesThatSetStatusbitsButNotCarry set is empty under
+                    // the strict contract (see IRInstructions.kt) so we don't need a
+                    // second branch here. Only CMP/CMPI/SGN/BITTST are recognized as
+                    // setting flags.
                 }
             }
         }
@@ -443,7 +452,7 @@ jump p8_label_gen_2
                     }
                 }
                 Opcode.AND -> {
-                    when (ins.immediate) {
+                    when (val imm = ins.immediate) {
                         0 -> {
                             chunk.instructions[idx] = IRInstruction(Opcode.LOAD, ins.type, reg1 = ins.reg1, immediate = 0)
                             changed = true
@@ -461,28 +470,59 @@ jump p8_label_gen_2
                             changed = true
                         }
                     }
+                    // convert AND with all-ones-except-one-bit into BITCLR
+                    if(!changed) {
+                        val imm = ins.immediate ?: return@forEach
+                        val clearedBits = when(ins.type) {
+                            IRDataType.BYTE -> imm xor 0xFF
+                            IRDataType.WORD -> imm xor 0xFFFF
+                            IRDataType.LONG -> imm xor -1
+                            else -> 0
+                        }
+                        if(clearedBits > 0 && clearedBits and (clearedBits - 1) == 0) {
+                            val bitPos = Integer.numberOfTrailingZeros(clearedBits)
+                            chunk.instructions[idx] = IRInstruction(Opcode.BITCLR, ins.type, reg1 = ins.reg1, immediate = bitPos)
+                            changed = true
+                        }
+                    }
                 }
                 Opcode.OR -> {
-                    if (ins.immediate == 0) {
+                    val imm = ins.immediate
+                    if (imm == null) return@forEach
+                    if (imm == 0) {
                         chunk.instructions.removeAt(idx)
                         changed = true
-                    } 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)
+                    } else if ((imm == 255 && ins.type == IRDataType.BYTE) ||
+                               (imm == 65535 && ins.type == IRDataType.WORD) ||
+                               (imm == -1 && ins.type == IRDataType.LONG)) {
+                        chunk.instructions[idx] = IRInstruction(Opcode.LOAD, ins.type, reg1 = ins.reg1, immediate = imm)
+                        changed = true
+                    }
+                    // convert OR with power-of-2 into BITSET
+                    if(!changed && imm > 0 && imm and (imm - 1) == 0) {
+                        val bitPos = Integer.numberOfTrailingZeros(imm)
+                        chunk.instructions[idx] = IRInstruction(Opcode.BITSET, ins.type, reg1 = ins.reg1, immediate = bitPos)
                         changed = true
                     }
                 }
                 Opcode.XOR -> {
-                    if (ins.immediate == 0) {
+                    val imm = ins.immediate
+                    if (imm == null) return@forEach
+                    if (imm == 0) {
                         chunk.instructions.removeAt(idx)
                         changed = true
                     }
+                    // convert XOR with power-of-2 into BITTOG
+                    if(!changed && imm > 0 && imm and (imm - 1) == 0) {
+                        val bitPos = Integer.numberOfTrailingZeros(imm)
+                        chunk.instructions[idx] = IRInstruction(Opcode.BITTOG, ins.type, reg1 = ins.reg1, immediate = bitPos)
+                        changed = true
+                    }
                 }
                 else -> {}
             }
 
-            fun optimizeImmediateLoadAssociative(replacementOpcode: Opcode) {
+            fun optimizeImmediateLoad(replacementOpcode: Opcode, isCommutative: Boolean) {
 
                 fun getImmediateLoad(reg: Int): Pair<Int, Int>? {
                     // look if the given register gets an immediate value 1 or 2 istructions back
@@ -501,32 +541,126 @@ jump p8_label_gen_2
                 }
 
                 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
+                    if (isCommutative) {
+                        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
+                            return
                         }
                     }
+                    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")
+                Opcode.ADDR -> optimizeImmediateLoad(Opcode.ADD, true)
+                Opcode.MULR -> optimizeImmediateLoad(Opcode.MUL, true)
+                Opcode.MULSR -> optimizeImmediateLoad(Opcode.MULS, true)
+                Opcode.SUBR -> optimizeImmediateLoad(Opcode.SUB, false)
+                Opcode.DIVR -> optimizeImmediateLoad(Opcode.DIV, false)
+                Opcode.DIVSR -> optimizeImmediateLoad(Opcode.DIVS, false)
+                Opcode.MODR -> optimizeImmediateLoad(Opcode.MOD, false)
+                // Opcode.DIVMODR - skipped, no immediate DIVMOD variant exists
+                else -> {}
+            }
+        }
+        return changed
+    }
+
+    private fun removeSelfIdentityOps(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            when(ins.opcode) {
+                Opcode.LOADR -> {
+                    if((ins.reg1 != null && ins.reg1 == ins.reg2) || (ins.fpReg1 != null && ins.fpReg1 == ins.fpReg2)) {
+                        chunk.instructions[idx] = IRInstruction(Opcode.NOP)
+                        changed = true
+                    }
+                }
+                Opcode.ANDR, Opcode.ORR -> {
+                    if(ins.reg1 == ins.reg2) {
+                        chunk.instructions[idx] = IRInstruction(Opcode.NOP)
+                        changed = true
+                    }
+                }
+                Opcode.XORR -> {
+                    if(ins.reg1 == ins.reg2) {
+                        chunk.instructions[idx] = IRInstruction(Opcode.LOAD, ins.type, reg1 = ins.reg1, immediate = 0)
+                        changed = true
+                    }
+                }
+                else -> {}
+            }
+        }
+        return changed
+    }
+
+    private fun simplifyShiftByZero(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            if(idx>0 && ins.opcode in setOf(Opcode.LSLN, Opcode.LSRN, Opcode.ASRN) && ins.reg2 != null) {
+                val prev = indexedInstructions[idx-1].value
+                if(prev.opcode == Opcode.LOAD && prev.reg1 == ins.reg2 && prev.immediate == 0) {
+                    chunk.instructions[idx] = IRInstruction(Opcode.NOP)
+                    chunk.instructions.removeAt(idx-1)
+                    changed = true
+                }
+            }
+        }
+        return changed
+    }
+
+    private fun cancelAdjacentOps(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            if(idx >= chunk.instructions.size - 1)
+                return@forEach
+            val insAfter = chunk.instructions[idx+1]
+
+            when(ins.opcode) {
+                Opcode.INV -> {
+                    if(insAfter.opcode == Opcode.INV && insAfter.reg1 == ins.reg1) {
+                        chunk.instructions[idx] = IRInstruction(Opcode.NOP)
+                        chunk.instructions[idx+1] = IRInstruction(Opcode.NOP)
+                        changed = true
+                    }
+                }
+                Opcode.NEG -> {
+                    val sameReg = (ins.reg1 != null && ins.reg1 == insAfter.reg1) || (ins.fpReg1 != null && ins.fpReg1 == insAfter.fpReg1)
+                    if(insAfter.opcode == Opcode.NEG && sameReg) {
+                        chunk.instructions[idx] = IRInstruction(Opcode.NOP)
+                        chunk.instructions[idx+1] = IRInstruction(Opcode.NOP)
+                        changed = true
+                    }
+                }
+                Opcode.EXT, Opcode.EXTS -> {
+                    if(insAfter.opcode == ins.opcode && insAfter.reg1 == ins.reg1 && insAfter.type == ins.type) {
+                        chunk.instructions[idx+1] = IRInstruction(Opcode.NOP)
+                        changed = true
+                    }
+                }
+                Opcode.INC -> {
+                    if(insAfter.opcode == Opcode.DEC && insAfter.reg1 == ins.reg1) {
+                        chunk.instructions[idx] = IRInstruction(Opcode.NOP)
+                        chunk.instructions[idx+1] = IRInstruction(Opcode.NOP)
+                        changed = true
+                    }
+                }
+                Opcode.DEC -> {
+                    if(insAfter.opcode == Opcode.INC && insAfter.reg1 == ins.reg1) {
+                        chunk.instructions[idx] = IRInstruction(Opcode.NOP)
+                        chunk.instructions[idx+1] = IRInstruction(Opcode.NOP)
+                        changed = true
+                    }
+                }
                 else -> {}
             }
         }
@@ -595,21 +729,96 @@ jump p8_label_gen_2
         return changed
     }
 
-    private fun loadfieldsAndStorefields(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
-        var changed = false
-        indexedInstructions.reversed().forEach { (idx, ins) ->
-            if (ins.opcode == Opcode.LOADFIELD && ins.immediate==0) {
-                val loadi = IRInstruction(Opcode.LOADI, ins.type, ins.reg1!!, ins.reg2!!)
-                chunk.instructions[idx] = loadi
-                changed = true
+    private fun removeDeadStores(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
+        // Detect and remove dead stores: when a register is written but never read before being overwritten.
+        // Example:
+        //   LOAD r1, #5      <- dead store (r1 overwritten before use)
+        //   LOAD r1, #10
+        //   USE r1
+        
+        // Track for each register: (index of last write, whether value was read since)
+        val pendingWrites = mutableMapOf<Int, Pair<Int, Boolean>>()  // reg -> (writeIdx, wasRead)
+        val deadStores = mutableSetOf<Int>()
+
+        indexedInstructions.forEach { (idx, ins) ->
+            if (ins.opcode in OpcodesWithSideEffects) {
+                // Instruction has side effects, must never be removed as dead store,
+                // AND it also counts as a "read" of all current pending registers to avoid them being removed
+                pendingWrites.clear()
+                return@forEach
             }
-            else if (ins.opcode == Opcode.STOREFIELD && ins.immediate==0) {
-                val loadi = IRInstruction(Opcode.STOREI, ins.type, ins.reg1!!, ins.reg2!!)
-                chunk.instructions[idx] = loadi
+            val formats = instructionFormats.getValue(ins.opcode)
+            val format = formats[ins.type] ?: formats[null]
+
+            // First, check if this instruction READS any registers
+            if(format?.reg1 == OperandDirection.READ || format?.reg1 == OperandDirection.READWRITE) {
+                val reg = ins.reg1 ?: ins.fpReg1?.value
+                if(reg != null) {
+                    val existing = pendingWrites[reg]
+                    if(existing != null) {
+                        pendingWrites[reg] = existing.first to true
+                    }
+                }
+            }
+            if(format?.reg2 == OperandDirection.READ || format?.reg2 == OperandDirection.READWRITE) {
+                val reg = ins.reg2 ?: ins.fpReg2?.value
+                if(reg != null) {
+                    val existing = pendingWrites[reg]
+                    if(existing != null) {
+                        pendingWrites[reg] = existing.first to true
+                    }
+                }
+            }
+            if(format?.reg3 == OperandDirection.READ || format?.reg3 == OperandDirection.READWRITE) {
+                val reg = ins.reg3
+                if(reg != null) {
+                    val existing = pendingWrites[reg]
+                    if(existing != null) {
+                        pendingWrites[reg] = existing.first to true
+                    }
+                }
+            }
+
+            // Then, check if this instruction WRITES to any registers
+            if(format?.reg1 == OperandDirection.WRITE || format?.reg1 == OperandDirection.READWRITE) {
+                val reg = ins.reg1 ?: ins.fpReg1?.value
+                if(reg != null) {
+                    // Check if previous write to this reg was dead (never read before this overwrite)
+                    val existing = pendingWrites[reg]
+                    if(existing != null && !existing.second) {
+                        deadStores.add(existing.first)
+                    }
+                    // Record this new write as pending (not yet read)
+                    pendingWrites[reg] = idx to false
+                }
+            }
+        }
+        
+        // Any remaining pending writes that were never read are also dead
+        // (unless they're the final value needed - but we can't know that here)
+        // Actually, we should NOT remove these because they might be the final value
+        
+        // Remove dead stores (in reverse order to preserve indices)
+        var changed = false
+        deadStores.sortedDescending().forEach { idx ->
+            if(idx < chunk.instructions.size) {
+                chunk.instructions.removeAt(idx)
                 changed = true
             }
         }
-
         return changed
     }
-}
+
+    //private fun removeLoadrForwarding(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
+        // Forward LOADR instructions to their original source.
+        // Example:
+        //   LOAD r1, #5
+        //   LOADR r2, r1     -> LOAD r2, #5
+        //   LOADR r3, r2     -> LOAD r3, #5
+        
+        // todo: This needs more careful implementation considering:
+        //     - Cross-chunk register usage
+        //     - Function call side effects
+        //     - Proper invalidation of register tracking
+    //}
+}