add compiler version in assembly file

Removes the header shorthand, extracts shared validation into
LinkedForLoopChecks.kt, fixes until-validation for pointer sentinels,
and updates docs/examples/tests.

.agent/workflows/startup.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.

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

@@ -0,0 +1,204 @@
+---
+name: asm6502-coder
+description: Writing or understanding 6502/65C02 assembly in 64tass syntax, standalone or embedded in Prog8
+---
+
+# 6502 Assembly Coder
+
+Use 64tass syntax, not ca65 or another assembler. Keep answers concise and
+practical. This applies to standalone `.asm` files and Prog8 `%asm {{ }}` or
+`asmsub` blocks.
+
+Reference documentation for the assembler is available locally in
+`~/Documents/prog8-dev-resources` (the 64tass manual, `64tass.md`). Search this
+folder first before looking online.
+
+## Syntax
+
+- Labels begin in column 1. Instructions are indented at least four spaces.
+- Use lowercase opcodes and operands, two spaces between opcode and operand,
+  and two spaces before end-of-line comments.
+- Hex is `$1234`, binary is `%1010`, decimal is `123`.
+- Use `.byte`, `.word`, `.dword`, `.fill`, `.text`, and equates such as
+  `name = value`.
+- Sections use `.section name` and `.send name`.
+- Procedures use `.proc` and `.pend`; labels beginning with `_` are local to a
+  procedure.
+- Conditional assembly uses `.if`, `.elsif`, `.else`, and `.endif`.
+
+## Anonymous Labels
+
+Anonymous label definitions are always a single `+` or `-` in column 1.
+References use repeated signs:
+
+- `+` is the next upcoming `+` definition, `++` the second, `+++` the third.
+- `-` is the most recent `-` definition, `--` the preceding one, and so on.
+- Passing a `+` definition resets the forward-reference count.
+
+```asm
+-   dex
+    bne -       ; most recent '-' above
+    ldx #5
++   dex         ; first upcoming '+'
+    bne +       ; this '+'
+    sta $400
++   lda #0      ; second '+' definition
+    bne ++      ; next '+' after this one
+    rts
++   inc $d020   ; third '+' definition
+```
+
+## CPU Differences
+
+- `cx16` is the only Prog8 target that supports 65C02 instructions such as
+  `stz`, `phx`, `plx`, `phy`, `ply`, `bra`, `trb`, `tsb`, `wai`, `stp`, and
+  `bit #imm`. C64, C128, and PET32 use the original 6502.
+- Rockwell instructions (`rmb`, `smb`, `bbr`, `bbs`) are not available.
+- Use an explicit `a` for accumulator forms such as `rol a`, `lsr a`, `inc a`,
+  and `dec a`.
+- Branches are relative. Prog8's assembler invocation enables `--long-branch`
+  for out-of-range branches.
+- `lda`, `ldx`, and `ldy` do not affect carry. `cmp` sets carry for
+  `register >= operand`.
+- On NMOS 6502, `jmp ($xxff)` wraps the high-byte fetch within the page.
+- `BRK` skips the byte after its opcode. The byte is commonly a handler
+  signature.
+- `bit` memory forms set N and V from the operand and Z from `A AND operand`.
+  65C02 `bit #imm` sets only Z.
+- Decimal mode can persist into NMOS IRQ handlers. Use `cld` at handler entry
+  and explicitly control D before `adc` or `sbc`.
+
+## Prog8 Integration
+
+`asmsub` parameter names are documentation only. Use the actual registers or
+define assembly aliases, and list every modified register in `clobbers`.
+
+```prog8
+asmsub increment(uword value @R0) clobbers (A, X) {
+    %asm {{
+        lda  cx16.r0L
+        clc
+        adc  #1
+        sta  cx16.r0L
+    }}
+}
+```
+
+Annotations include `@A`, `@X`, `@Y`, `@AX`, `@AY`, `@R0`-`@R15`, `@FAC1`,
+`@FAC2`, `@Pc` (carry), and `@Pz` (zero). Unmapped parameters are accessed as
+`p8v_name`.
+
+Prog8 symbols use these prefixes: `p8v_` variables and parameters, `p8s_`
+subroutines, `p8b_` blocks, `p8c_` constants, `p8l_` labels, and `p8t_` struct
+types. Fully qualified names may look like
+`p8b_main.p8s_helper.p8v_local`. `%option no_symbol_prefixing` disables the
+prefixes. Split word arrays use `_lsb` and `_msb` symbols.
+
+## Zeropage and Memory
+
+- Never hardcode zeropage addresses. Use `P8ZP_SCRATCH_B1`,
+  `P8ZP_SCRATCH_REG`, `P8ZP_SCRATCH_W1`, `P8ZP_SCRATCH_W2`, and
+  `P8ZP_SCRATCH_PTR`, or the appropriate `cx16.r0`-`cx16.r15` symbols.
+- Scratch variables are not necessarily consecutive. CX16 virtual registers
+  are consecutive and have `L` and `H` byte names.
+- Allocate additional temporary storage in BSS.
+- The hardware stack occupies `$0100-$01ff` and is limited. Do not overflow
+  it.
+- Prog8 words are little-endian: load the low byte first, then the high byte.
+
+```asm
+        clc
+        lda  word1
+        adc  word2
+        sta  result
+        lda  word1+1
+        adc  word2+1
+        sta  result+1
+```
+
+## Common Patterns
+
+```asm
+        ldy  #index
+        lda  (ptr),y
+
+        jsr  p8s_main.p8s_helper
+```
+
+Avoid self-modifying code unless it is explicitly required. It cannot run
+from ROM and complicates debugging and tooling. Prefer lookup tables, RAM
+vectors, or alternative algorithms.
+
+## Reference
+
+### Primary: 6502 Family CPU Reference
+
+<https://www.pagetable.com/c64ref/6502/?cpu=65c02&tab=2> is the reference to reach for.
+It covers the whole 6502 family and lets you **select the CPU variant**, which matters
+because the parts genuinely differ. The variants are `6502`, `6502rorbug`, `65dtv02`,
+`65c02`, `r65c02` (Rockwell), `65c02s`, `65ce02` and `65c816`. Change the `cpu=` query
+parameter to switch; for Prog8, use `cpu=65c02` when working on cx16 and `cpu=6502` for
+c64, c128 and pet32.
+
+Per instruction it gives the operation, the opcodes, the byte length, the cycle count
+and which status flags are affected, with tabs for opcodes, instructions, addressing
+modes and a full opcode table (switchable between 4-4 and 3-3-2 layout). It can also
+show the NMOS undocumented opcodes, and each part lists what it is based on, so a
+variant's inherited instructions are visible.
+
+Cycle counts use a compact notation worth knowing: a trailing `t` means +1 if a branch
+is taken, `p` means +1 if a page is crossed, and `d` means +1 when the D (decimal) flag
+is set. So `d0  2+t+p` for `bne` is 2 cycles, 3 if taken, 4 if taken across a page.
+
+Consult it whenever an exact figure is needed rather than recalled: the byte length or
+cycle cost of an instruction, which flags it clobbers, whether an addressing mode exists
+on the target CPU, or whether an instruction belongs to a different part at all. Typical
+reasons are costing a peephole or code-size tradeoff, checking a hand-written routine,
+and confirming a mnemonic is valid before using it.
+
+Do not assume a timing from memory or from another part. Cycle counts are exactly the
+kind of detail that is misremembered, and the difference matters when it is the basis of
+an optimization claim. Read the number off the reference for the specific CPU being
+targeted.
+
+### Secondary: WDC 65C02 reference
+
+<https://cx16.dk/65c02/reference.html> is a 65C02-only reference. It is worth having
+because it states each instruction's effect in a single formula (for example
+`ADC:  A,Z,C,N = A+M+C`), which makes the flag behaviour quick to check, and it lists
+every status bit per instruction including the ones not affected. Use it for flag
+semantics; use the primary reference for timings and for anything CPU-specific, since
+it covers the 65C02 only and will not answer a question about the NMOS 6502.
+
+### Neither reference covers the assembler
+
+Both document the CPU, not 64tass. For whether 64tass accepts a mnemonic or a given
+syntax, assemble it: an instruction outside the selected CPU set fails with
+`error: general syntax` rather than being silently ignored. Note also that 64tass has
+no `w65c02s`; its CPU selection is `--m65xx` (default), `--m65c02` and `--m65ce02`, and
+Prog8 emits `.cpu 'w65c02'`.
+
+## Tools
+
+Prog8 invokes 64tass with `--ascii --case-sensitive --long-branch -Wall` plus
+the target output option such as `--cbm-prg`. For manual assembly:
+
+```bash
+64tass --ascii --case-sensitive --long-branch -Wall --cbm-prg \
+    -o myprogram.prg myprogram.asm
+```
+
+For debugging, add `--vice-labels --labels=labels.txt` and/or
+`--list=listing.txt`.
+
+To check an instruction's encoding or size, assemble it in isolation and read the
+output bytes. The 2-byte load address comes first, so `stx $7b` / `ldy $7b` below
+shows as `86 7b a4 7b` - two instructions, four bytes:
+
+```bash
+printf '.cpu  %s\n* = $0801\nlbl\tstx\t$7b\n\tldy\t$7b\n' "'w65c02'" > sz.asm
+64tass --ascii --case-sensitive --cbm-prg -o sz.prg sz.asm && xxd sz.prg
+```
+
+Note that a 64tass label takes no trailing colon; `lbl:` is a syntax error reported as
+`error: label required`.

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

@@ -0,0 +1,197 @@
+---
+name: m68k-coder
+description: Writing or understanding Motorola 68000/68020 assembly in vasm mot syntax, standalone or embedded in Prog8
+---
+
+# M68K Assembly Coder
+
+Use Motorola syntax for `vasm`, not Devpac or other assemblers. Keep answers
+concise and practical.
+
+Reference documentation for the assembler and linker is available locally in
+`~/Documents/prog8-dev-resources` (the vasm and vlink manuals). Search this
+folder first before looking online.
+
+## Syntax
+
+- Labels begin in column 1. Instructions are indented at least four spaces.
+- Use lowercase opcodes and operands, two spaces between opcode and operand,
+  and two spaces before end-of-line comments.
+- Use `.b`, `.w`, and `.l` for byte, word, and long operations. Do not rely on
+  default sizes.
+- Hex is `$1234`, binary is `%1010`, decimal is `123`, and characters use
+  `#'A'`.
+- Local labels start with `.`. Equates use `name = value`.
+- Data directives are `dc.b`, `dc.w`, `dc.l`; allocation directives are
+  `ds.b`, `ds.w`, `ds.l`.
+- Sections use forms such as `SECTION .text,code` and `SECTION .bss,bss`.
+
+```asm
+        moveq   #0,d0
+        move.w  value,d0
+        add.l   d1,d0
+.loop
+        dbra    d0,.loop
+```
+
+## FPU Size Suffixes
+
+FPU instructions that access memory **must** include a size suffix: `.s`
+(single, 4 bytes), `.d` (double, 8 bytes), or `.x` (extended, 12 bytes).
+Without a suffix, vasm defaults to `.x`, reading 12 bytes and corrupting
+results when the operand is smaller.
+
+**Use `.s` with memory operands:**
+```asm
+        fmove.s  value(pc),fp0      ; load float from memory
+        fcmp.s   other(pc),fp0      ; compare float in memory
+        ftst.s   value(pc)          ; test float in memory
+```
+
+**Omit the suffix for register-to-register operations:**
+```asm
+        fadd     fp1,fp0            ; fp0 = fp0 + fp1
+        fcmp     fp1,fp0            ; compare fp0 vs fp1
+        ftst     fp0                ; test fp0
+        fintrz   fp0,fp0            ; truncate fp0
+```
+
+The FPU registers are always 80-bit internally, so no size suffix is needed
+when both operands are registers.
+
+## Architecture
+
+- Registers `D0-D7` and `A0-A7` are 32-bit; `A7` is the stack pointer.
+- Pointers are 32-bit and must normally be accessed with `.l`.
+- Memory is big-endian: `$1234` is stored as `$12,$34` and a long's low byte
+  is at offset `+3`.
+- Word and long accesses must be even-aligned on 68000. 68020 permits
+  misalignment but it is slower.
+- **Byte `A7` auto-update steps by 2, not 1.** If A7 (== SP, the stack pointer) is the address
+  register and the operand length for post-increment or post-decrement is one byte, A7 is
+  decremented/incremented by 2 instead of 1, to maintain a word-aligned stack. This is the
+  specified behaviour of all the 680x0, not a 68000 quirk, so it is identical everywhere and
+  safe to rely on. Word and long operands step by 2 and 4.
+  ```asm
+        move.b  d0,-(sp)          ; A7 steps by 2, so SP stays word-aligned
+        ...
+        addq.l  #2, sp            ; and the matching pop is #2, not #1
+  ```
+  Do not "fix" this to an explicit `subq.l #1,sp`: that leaves SP odd and cause crash.
+- The 68000 (`amiga500`) has only word multiply/divide and no scaled indexing,
+  bit-field, or 32-bit multiply/divide instructions. The 68020 (`qemu68k`)
+  adds those features and `extb.l`.
+- On 68000, sign-extend a byte with `ext.w` followed by `ext.l`.
+- `move.b` and `move.w` to a data register do not clear its upper bits. Like
+  `move.w` only writes the lower 16 bits, `move.b` only writes the lower 8 bits;
+  both leave all other bits of the register untouched. So zero-extending a byte
+  to long requires `moveq #0,d0` first, then `move.b src,d0`, then `move.l d0,dst`
+  (or mask with `and.l #$ff` / `and.l #$ffff`). Relying on `move.b` to clear the
+  upper bits is a common bug that corrupts values.
+- `movea` does not set condition codes; `move` does. Keep the stack word
+  aligned and push words or longs, never bytes.
+
+## Registers and Calls
+
+- Return values use `D0` (primary), `D1` and `D2` (additional), or `A0` for a
+  pointer.
+- `D0-D1` and `A0-A1` are scratch registers. Preserve registers required by
+  the surrounding calling convention, especially `D2-D7` and `A2-A6`.
+- Never clobber `A5`: on every M68K target it is the Prog8 stack frame pointer
+  (locals at negative offsets, parameters at positive offsets). Overwriting it
+  corrupts the frame of the running subroutine and breaks unwinding.
+- Never clobber `A6` on the Amiga targets (`amiga500`, `amiga1200`): it holds
+  the AmigaOS library base pointer that library calls depend on. Prog8 itself
+  leaves `A6` free for that reason.
+- `move.l d0,-(sp)` pushes and `move.l (sp)+,d0` pops.
+
+### Prog8 M68K stack ABI
+
+- Normal framed subroutines use `link a5,#-N` and `unlk a5`; locals are at
+  negative `A5` offsets and incoming parameters are at positive offsets.
+- Arguments use word-packed slots of natural width: byte, bool, word and uword
+  arguments take a 2-byte slot; long, pointer and float arguments take a 4-byte
+  slot. The caller pushes arguments left-to-right (a byte sits at the base byte
+  of its 2-byte slot, the second byte is garbage; word values fill their slot)
+  and removes the complete argument area after the call. The area
+  size is always even, so the stack stays word-aligned; slot bases accumulate from
+  the rightmost argument at `8(a5)` according to each argument's width.
+- A normal call preserves the caller's frame. A `goto` or conditional branch
+  leaving the current subroutine must execute `unlk a5` on the taken path before
+  transferring control.
+- The built-in Prog8 `call(address)` is a zero-argument indirect call. It does
+  not marshal stack arguments. `asmsub` and `extsub` keep their explicit
+  register-annotated ABI, separate from normal framed calls.
+- Push narrow arguments into their own 2-byte slots, each with one instruction: a
+  byte uses `move.b ..., -(sp)` (A7 byte predecrement steps by 2, reserving the
+  slot; the byte lands at the slot's base byte), a word uses a plain
+  `move.w ..., -(sp)`. Never push a narrow value where the callee expects a
+  wide (4-byte) argument: the slot sizes must line up exactly.
+  Wide arguments (`move.l ..., -(sp)` / `fmove.s fp0,-(sp)`) push in one step.
+  Use `lea N(sp),sp` for the cleanup when the call returns a status flag
+  (`addq` clobbers CCR).
+
+## Prog8 Integration
+
+Assembly can appear in `%asm {{ }}` blocks or `asmsub` routines. `asmsub`
+parameter names are documentation only: use the actual annotated registers.
+Declare every modified register in `clobbers`.
+
+```prog8
+asmsub add100(uword value @D0) -> uword @D0 clobbers (D0) {
+    %asm {{
+        add.w  #100,d0
+    }}
+}
+```
+
+Do not use `%option no_sysinit` on `amiga500` or `qemu68k` targets when the goal
+is to create normal runnable programs. It skips critical startup logic including
+library initialization and CLI argument handling, causing programs to crash on
+start.
+
+Supported annotations include `@D0`-`@D7`, `@A0`-`@A6`, virtual `@R0`-`@R15`,
+floating-point `@FP0`-`@FP7`, and flags `@Pc` and `@Pz`.
+
+Prog8 assembly symbols are prefixed:
+
+| Prefix | Symbol |
+| --- | --- |
+| `p8v_` | variable or parameter |
+| `p8s_` | subroutine |
+| `p8b_` | block |
+| `p8c_` | constant or enum member |
+| `p8l_` | label |
+| `p8t_` | struct type |
+
+Use fully qualified names when needed, such as
+`p8b_main.p8v_value`. `%option no_symbol_prefixing` disables prefixes.
+
+```asm
+        move.l  p8v_pointer,a0
+        move.w  p8v_word,d0
+        jsr     p8s_main.p8s_helper
+```
+
+## Useful Patterns
+
+```asm
+        lea     source,a0
+        lea     dest,a1
+.copy
+        move.b  (a0)+,(a1)+
+        bne.s   .copy
+```
+
+Use `moveq` for small constants, `addq`/`subq` for constants 1 through 8, and
+`lea` for address arithmetic. Check divisors for zero and division overflow.
+
+## Tools
+
+For QEMU 68k, Prog8 invokes `vasmm68k_mot` with `-m68020 -m68881 -Felf
+-opt-speed -warnunaligned -ldots -spaces`, then links with `vlink`. For raw
+binary output use `-Fbin` and `-join=0x<addr>`. Add `-L listing.txt` when a
+listing is needed.
+
+Prog8 runs `amiga500` programs with `vamos --cpu 68000` and `qemu68k` programs
+with `qemu-system-m68k -M virt -cpu m68020 -m 1M -kernel program.elf -nographic`.

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

@@ -0,0 +1,168 @@
+---
+name: prog8-coder
+description: Writing or understanding Prog8 programs and Prog8 IR
+---
+
+# Prog8 Coder
+
+You are an expert Prog8 assistant. Keep answers concise and practical. This
+skill covers `.p8` source and `.p8ir` intermediate representation for the
+6502, M68000, and virtual targets.
+
+Various reference documentation is available locally in
+`~/Documents/prog8-dev-resources`: 
+
+Prog8 reference documentation, emulator manuals such as VICE and the X16
+emulator, the 64tass/vasm/vlink assembler and linker docs, X16 hardware and register specs,
+the Amiga NDK (docs and includes), and other resources. 
+Search in this folder first before looking online!
+
+
+## Essentials
+
+- A program normally has a `main` block with a parameterless `start` entry
+  subroutine. Other blocks and subroutines may be added.
+- `%import modulename` imports a module without aliases. Use its defined prefix,
+  such as `%import textio` followed by `txt.print(...)`.
+- `sys` is always available and needs no import.
+- `.p8ir` is target-independent IR and can be run with
+  `prog8c -vm program.p8ir`.
+- Use `%zeropage basicsafe` in test programs when a clean return is needed.
+- Find library routines with `prog8c -libsearch <regex>` or extract them with
+  `prog8c -libdump <dir>`.
+- Options accept single-dash or double-dash (`-target` == `--target`). Use
+  `-out <dir>` to place output in a directory, or `-o <file>` to name the exact
+  final program artifact (all other output files then land beside it).
+
+For CX16 emulator programs, use `%encoding iso`, call `txt.iso()` in `start`,
+and finish with `sys.poweroff_system()`. CBM targets use PETSCII by default;
+avoid uppercase in test output unless intentional graphics. The virtual target
+uses ISO when configured with `%encoding iso` and `txt.iso()`.
+
+On any CBM machine with PETSCII (this includes the Commander X16), files
+on disk must only consist of 'safe' characters (`a-z`, `0-9`, `.-+!%`).
+Do NOT mix casing in filenames; in Prog8 source code, filenames should
+usually be written in *lowercase* letters. Other characters (such as
+`_` or uppercase mixed with lowercase) can make kernal file operations
+fail, depending on the drive/host layer.
+
+Do not use `%option no_sysinit` on `amiga500`, `amiga1200`, or `qemu68k` targets when the goal
+is to create normal runnable programs. It skips critical startup logic including
+library initialization (DOS, graphics, intuition, timer) and CLI argument
+handling, causing programs to crash on start. It is appropriate for library
+modules, IRQ handlers, boot stubs, or code that deliberately avoids those
+libraries.
+
+## Types and Memory
+
+- Primitive types include `bool`, `byte`, `ubyte`, `word`, `uword`, `long`,
+  `float`, `str`, and `pointer`.
+- `pointer` is target-sized: 16-bit on 6502 targets, 32-bit on `amiga500`,
+  `qemu68k`, and `virtual`. Use it for portable addresses, not `uword` or
+  `long` chosen by assumption.
+- M68000 targets are big-endian and use 32-bit pointers. Load the `m68k-coder`
+  skill for assembly details.
+- `float` requires `%import floats`.
+- On 6502 and virtual targets, variables are statically allocated and
+  zero-initialized. There is no normal call stack for locals, so recursion
+  overwrites locals unless an explicit hardware or software stack is used.
+  Iterative rewrites are preferred. Arrays are cleared once at startup here,
+  not on every subroutine entry.
+- On the M68000 targets (`amiga500`, `amiga1200`, `qemu68k`) ordinary subroutine
+  locals and parameters live in an activation record on the CPU stack, so true
+  recursion and re-entrancy work. `link a5,#-N` / `unlk a5`, frame pointer `A5`,
+  locals at negative offsets, parameters at positive offsets. Block-level
+  variables, globals, `@shared`, memory slabs, and objects needing a permanent
+  external address stay static. Clean locals are zeroed on every call
+  including arrays, so the compiler warns for framed arrays over 8 bytes; use
+  `@dirty` when you assign first, otherwise you read stack garbage.
+- Normal M68K calls use word-packed argument slots: byte/bool/word/uword arguments
+  take a 2-byte slot, long/pointer/float take 4 bytes. The caller pushes arguments
+  left-to-right and removes the complete argument area after the call. Slot bases
+  accumulate right-to-left starting at positive `A5` offset 8, so a parameter's
+  offset depends on the widths of the parameters to its right; locals use negative
+  offsets. See `docs/source/technical.rst` for the full convention and static
+  fallback rules.
+- `memory(name, size)` reserves static memory and returns a `pointer`.
+- `str` and arrays have compile-time byte budgets. On 6502 targets the usual
+  limit is 256 bytes; M68000 targets allow up to 32768 bytes. Use `memory()`
+  for larger data.
+- Word arrays are split into LSB/MSB arrays by default. Use `@nosplit` when
+  contiguous storage is required.
+- Variable tags follow the type and array dimensions, before the name:
+
+```prog8
+ubyte[8] @shared vera_storage
+uword @requirezp address
+```
+
+Use `@shared` for values accessed externally by assembly. Use `@zp` and
+`@requirezp` sparingly because zeropage is limited. Never assume virtual
+registers survive calls. Long operations may clobber `R12-R15`.
+
+## Syntax Pitfalls
+
+- Hex uses `$FF`, binary uses `%1010`, and casts use `expression as type`.
+- There is no automatic type widening in expression results: `byte * byte`
+  remains a byte. Cast explicitly when a wider result is needed. Assignments,
+  call arguments, and mixed-type expressions do widen implicitly
+  (`ubyte`/`byte` to `word`/`uword` to `long`); only same-width signedness
+  reinterpretation (`uword` to `word` and back) needs an explicit `as` cast.
+- `&` is an untyped address and `&&` is a typed pointer. Complex pointer field
+  assignments may require `ptr^^.field`.
+- `and`, `or`, `xor`, and `not` are logical operators. Use `&`, `|`, `^`, and
+  `~` for bitwise operations.
+- `and` and `or` short-circuit, so the right operand may not be evaluated.
+- There is no `elif`, bare block, or semicolon statement separator. Semicolon
+  starts a comment. Prefer one statement per line and four-space indentation.
+- `defer` executes registered statements in reverse registration order.
+- Array indexing starts at zero. Use `len(array)` rather than hardcoded sizes.
+- There is no function overloading. Call type-specific library routines such as
+  `txt.print_ub` or `txt.print_w`.
+
+## Control Flow
+
+Prog8 supports `if`/`else`, `when`, `for`, `while`, `do`/`until`, `repeat`,
+`unroll`, `break`, `continue`, `goto`, and labels. `unroll` duplicates a
+constant-count body at compile time and does not support `break` or `continue`.
+`repeat` is usually more efficient than `for` when no loop variable is needed.
+Replace a `for` loop with a `repeat` loop when the loop variable is not used in the loop body.
+Use `if_cs`, `if_cc`, `if_z`, and `if_nz` for direct CPU-flag branches.
+
+## Subroutines and Assembly
+
+- Subroutines can return zero, one, or multiple values:
+  `a, b = routine()` or `void routine()`.
+- On M68K, ordinary calls preserve the caller's active frame. A `goto` or branch
+  that leaves the current subroutine must tear that frame down before transferring
+  control. The built-in `call(address)` is a zero-argument indirect call; it does
+  not marshal stack arguments.
+- Avoid `private` unless requested. Prog8 symbols are public by default.
+- `asmsub` bodies contain only one `%asm {{ ... }}` node. Parameters are type
+  checked and documented, but assembly must use the mapped registers. Declare
+  every modified hardware register in `clobbers`.
+- On M68K targets never clobber `A5`, the stack frame pointer. On the Amiga
+  targets never clobber `A6` either, it holds the AmigaOS library base.
+- `extsub` maps a signature to a fixed external address and has no body. Use
+  it for ROM, kernel, drivers, or binary-library routines.
+- For inline assembly, load `asm6502-coder` for 64tass syntax, target-specific
+  instructions, zero-page rules, and symbol references. Load `m68k-coder` for
+  M68000 assembly.
+
+## Interrupts and Hardware
+
+- Keep IRQ handlers short. Set a flag and do substantial work in the main loop.
+- Virtual registers `R0-R15` are not preserved across IRQ handlers. Avoid them
+  or save and restore them with the library routines.
+- CX16 IRQ handlers that touch VERA registers must save and restore VERA
+  context.
+- Use only symbolic scratch names such as `P8ZP_SCRATCH_W1` and
+  `cx16.r0`; never hardcode zeropage addresses.
+
+## Verification
+
+- Use the `virtual` target for behavioral tests when possible:
+  `prog8c -target virtual -emu program.p8`.
+- Use `-check` for syntax and semantic checks without output generation.
+- Use `-noopt` to determine whether a failure is optimizer-related.
+- For IR execution, use `-vmtrace` when control flow needs inspection.

.aiignore

@@ -0,0 +1,20 @@
+# An .aiignore file follows the same syntax as a .gitignore file.
+# .gitignore documentation: https://git-scm.com/docs/gitignore
+
+# you can ignore files
+.DS_Store
+*.log
+*.tmp
+*.bin
+*.prg
+
+# or folders
+dist/
+build/
+out/
+output/
+gradle/
+Libs/
+.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,45 @@ 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 11
-        uses: actions/setup-java@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v5
         with:
-          java-version: 11
+          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 --max-workers=3 -PtestConcurrency=2 -PtestMaxHeap=8g --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/
@@ -12,8 +15,11 @@ out-old/
 .*cache/
 *.directory
 *.prg
+*.elf
+*.o
 *.bin
 *.p8ir
+*.bankedcalls
 *.labels.txt
 *.vm.txt
 *.vice-mon-list
@@ -22,6 +28,7 @@ parser/**/*.interp
 parser/**/*.tokens
 parser/**/*.java
 compiler/src/prog8/buildversion/*
+languageServer/src/prog8/buildversion/*
 *.py[cod]
 *.egg
 *.egg-info
@@ -35,8 +42,10 @@ parsetab.py
 .pytest_cache/
 .attach_pid*
 compiler/lib/
-
 .gradle
 sd*.img
 *.d64
-
+AsyncIO/
+AsyncIO.info
+m68k-amigaos-ahi/
+Libs/

.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>
+</project>

.idea/gradle.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <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$/codeGenM68k" />
+            <option value="$PROJECT_DIR$/codeGenNew6502" />
+            <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/inspectionProfiles/Project_Default.xml

@@ -534,7 +534,6 @@
     <inspection_tool class="GroovyUnusedDeclaration" enabled="false" level="WARNING" enabled_by_default="false" />
     <inspection_tool class="GroovyUnusedIncOrDec" enabled="false" level="WARNING" enabled_by_default="false" />
     <inspection_tool class="GroovyVariableNotAssigned" enabled="false" level="WARNING" enabled_by_default="false" />
-    <inspection_tool class="GrpcSchemes" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
     <inspection_tool class="Guava" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="HardcodedFileSeparators" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="m_recognizeExampleMediaType" value="false" />
@@ -585,20 +584,6 @@
     </inspection_tool>
     <inspection_tool class="HtmlUnknownTarget" enabled="false" level="WARNING" enabled_by_default="false" />
     <inspection_tool class="HtmlWrongAttributeValue" enabled="false" level="WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpClientDuplicateImportInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpClientInappropriateProtocolUsageInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpClientRunRequestNameInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpClientUnresolvedAuthId" enabled="false" level="ERROR" enabled_by_default="false" />
-    <inspection_tool class="HttpClientUnresolvedVariable" enabled="false" level="WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpRequestContentLengthIsIgnored" enabled="false" level="WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpRequestCustomHttpMethodInspection" enabled="false" level="WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpRequestEnvironmentAuthConfigurationValidationInspection" enabled="false" level="WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpRequestJsonBodyInspection" enabled="false" level="WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpRequestPlaceholder" enabled="false" level="WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpRequestRequestSeparatorJsonBodyInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpRequestRequestSeparatorXmlBodyInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpRequestRequestSeparatorYamlBodyInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
-    <inspection_tool class="HttpRequestWhitespaceInsideRequestTargetPath" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
     <inspection_tool class="IOResource" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="ignoredTypesString" value="java.io.ByteArrayOutputStream,java.io.ByteArrayInputStream,java.io.StringBufferInputStream,java.io.CharArrayWriter,java.io.CharArrayReader,java.io.StringWriter,java.io.StringReader" />
       <option name="insideTryAllowed" value="false" />
@@ -629,7 +614,6 @@
       <option name="reportPerFile" value="true" />
       <option name="kotlinOnly" value="true" />
     </inspection_tool>
-    <inspection_tool class="IncorrectHttpHeaderInspection" enabled="false" level="WARNING" enabled_by_default="false" />
     <inspection_tool class="IncrementDecrementUsedAsExpression" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="IndexZeroUsage" enabled="false" level="WARNING" enabled_by_default="false" />
     <inspection_tool class="InfiniteLoopJS" enabled="false" level="WARNING" enabled_by_default="false" />

.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.21" />
   </component>
-</project>
+</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.2.20" />
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.2.20/kotlin-stdlib-jdk8-2.2.20.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.20/kotlin-stdlib-2.2.20.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.2.20/kotlin-stdlib-jdk7-2.2.20.jar!/" />
-    </CLASSES>
-    <JAVADOC>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.2.20/kotlin-stdlib-jdk8-2.2.20-javadoc.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.20/kotlin-stdlib-2.2.20-javadoc.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0-javadoc.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.2.20/kotlin-stdlib-jdk7-2.2.20-javadoc.jar!/" />
-    </JAVADOC>
-    <SOURCES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.2.20/kotlin-stdlib-jdk8-2.2.20-sources.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.2.20/kotlin-stdlib-2.2.20-sources.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0-sources.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.2.20/kotlin-stdlib-jdk7-2.2.20-sources.jar!/" />
-    </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,23 +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$/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`.

AGENTS.md

@@ -0,0 +1,405 @@
+# CRITICAL RULES - MUST FOLLOW
+
+## RESPONSES
+
+- Keep responses concise and to the point - unless the user asks otherwise
+
+## PLANNING MODE
+
+- 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
+
+## CHANGE / EDIT MODE
+
+- Use a subagent for larger chunks of work
+- 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), run the relevant quality commands (lint, type check, build) to check code quality.
+  Only compiler/standard-library changes require a build: that means Kotlin sources (`.kt`), the grammar (`.g4`), or embedded
+  standard library files (`compiler/res/prog8lib/**/*.p8` and `**/*.asm`). For changes limited to `examples/**`, `docs/**`, or
+  other non-compiler files, verify with the target compiler directly instead (for example `prog8c -target <target> <file>`), and
+  skip the build entirely
+  (exception: if the change is only whitespace or code comments, a build or test run is not necessary)
+- `gradle build` already runs the full test suite; don't run a separate full `gradle test` before it, to avoid lengthy double test runs (targeted `--tests` filters to find failing tests are fine)
+
+## 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 used by machine-specific code generator backends, including 6502 and M68K.
+- 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
+- **Codebase knowledge graph**: For a structured overview of modules, their dependencies, key entities, the end-to-end compilation pipeline, the standard library layout, and the test structure, consult `docs/CODEBASE-KNOWLEDGE-GRAPH.md`. Read it when you need to understand how the compiler fits together before diving into specific files.
+
+## 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 6502/65C02 assembly code, load the `asm6502-coder` skill for 64tass syntax and conventions.
+- When writing or understanding M68K assembly code (amiga500, amiga1200, qemu68k targets), load the `m68k-coder` skill for vasm mot syntax and conventions.
+- M68K ordinary subroutine locals and parameters use `A5`-based stack frames. Normal calls pass word-packed argument slots on the stack (2-byte slots for byte/word args, 4-byte for wide args, byte values at the slot base), and the caller cleans up; see `docs/source/technical.rst` for the complete convention and frame eligibility rules.
+
+
+## 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
+**Code comments**: Comments are the exception, not the norm. A comment earns its place only by recording
+something the code itself cannot say: the reason for a non-obvious choice, or a constraint that
+a well-meaning future edit would otherwise violate.
+
+- Inline comment inside a function body: 1 line, never more.
+- KDoc on a declaration: 3 lines, unless a genuine non-obvious contract cannot be stated shorter.
+- Never restate the identifier, the type, or what the following line does.
+- Prefer a good name or a well-named function over a comment that explains it.
+
+Before keeping any comment, delete it mentally and ask what the reader loses. If nothing, it goes.
+
+Keep existing comments as they are; do not expand, reword, or reformat them while editing
+nearby lines - unless that would cause inconsistency. 
+
+**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**: Run `gradle build` to ensure all tests pass - but only if the change actually touched the
+  compiler or standard library (`.kt`, `.g4`, or `compiler/res/prog8lib/**`). For `examples/**` or `docs/**`-only changes,
+  verify with `prog8c` directly instead and skip the build
+- **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 code gen 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 if the change touched compiler sources.
+
+### 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 options accept single-dash or double-dash** (e.g., `-target` and `--target` are equivalent).
+- **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 current working directory**.
+- **the `-o <file>` switch names the exact final program artifact** (also spelled `--output`); all other output files go in the same directory with the same stem. Cannot be combined with `-out` or with multiple source files.
+- **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
+Names follow the source file name, or the stem of the `-o` file when that option is used.
+- `*.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.
+- in prog8 code being tested, use '@shared' variables to avoid const-folding
+
+### Automated Tests (gradle)
+Always use the `--console=plain` flag with these commands to avoid messing up the agent's text interface.
+- `ionice -c 3 nice gradle build --console=plain` - Full build including all tests (about 50s)
+- `ionice -c 3 nice gradle :compiler:test --console=plain` - Run only compiler tests (faster)
+- `ionice -c 3 nice 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.
+
+On Unix-like systems, prefix **every** gradle invocation with `nice` to lower its CPU priority,
+because gradle is CPU-heavy. This applies to all gradle commands (build, compile, test, install), not
+just `gradle build`. Use the same prefix for the quick compile checks and install commands in
+"Building and Installing the Compiler" above.
+
+On **Linux** additionally put `ionice -c 3` in front (idle-class I/O scheduling), so the build doesn't
+compete for disk with whatever else is running: `ionice -c 3 nice gradle ...`. `ionice` is
+Linux-only (util-linux); on macOS/BSD just use `nice`.
+
+**⚠️ 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` - the latter ONLY when NOT writing for the amiga500 or qemu68k targets
+- When a test fails, the output shows "There were failing tests. See the report at:" - **read that HTML report**
+
+### TestCompilerOnExamples expected sizes
+`TestCompilerOnExamples` asserts exact output sizes per example. A code-generator change shifts them,
+so expect a handful of `expected:<N> but was:<M>` failures with no stack trace pointing at the cause.
+Attribute each one before editing: rebuild with the change reverted and compare the two generated
+`.asm` files, so the size delta is demonstrably yours and not a side effect. Then update the expected
+size. A delta of a few bytes from removed `ldy`/`lda` instructions is normal; a large or erratic delta
+means something else changed and needs investigating.
+
+### 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
+- **Do NOT** write compiler tests that depend on the `vasm` assembler: it is not always installed
+  (CI only installs `64tass`). For m68k codegen tests (`amiga500`, `qemu68k` targets) pass
+  `writeAssembly = true, assemble = false` to the `compileText`/`compileFile` helpers. This still
+  generates the codegen AST to assert on but skips assembling, so no vasm is needed. If a test's
+  assertions cannot be made from the AST alone, drop the test.
+
+### 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.
+
+For the amiga targets, `-emu` launches FS-UAE (GUI) while `-emu2` launches Vamos (headless CLI). For automated/non-interactive testing, prefer `-emu2` (vamos) to avoid opening a GUI window.
+
+**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"
 

README.md

@@ -4,21 +4,24 @@ PayPal: [![PayPal](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)]
 
 [![Documentation](https://readthedocs.org/projects/prog8/badge/?version=latest)](https://prog8.readthedocs.io/)
 
-Prog8 - Structured Programming Language for 8-bit 6502/65c02 microprocessors
-============================================================================
+Prog8 - Structured Programming Language for 6502/65c02 (8-bit) and 68000 (32-bit) microprocessors
+=================================================================================================
 
 *Written by Irmen de Jong (irmen@razorvine.net)*
 
 This is a structured programming language for the 8-bit 6502/6510/65c02 microprocessor from the late 1970's and 1980's
-as used in many home computers from that era. It is a medium to low level programming language,
+as used in many home computers from that era. It also supports the 32-bit Motorola 68000 CPU, for which the
+Commodore Amiga is the intended machine. It is a medium to low level programming language,
 which aims to provide many conveniences over raw assembly code (even when using a macro assembler).
 
 **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
 -------------
@@ -34,8 +37,11 @@ How to get it/build it
   - you can also compile it yourself from source. [Instructions here](https://prog8.readthedocs.io/en/latest/compiling.html).
     Note that if you are not using *gradle* to build it, you might have to perform some manual
     tasks once to make it compile fully. These are explained in the linked instructions. 
-- Alternatively, you can also install the compiler as a package on some linux distros:
+- Alternatively, you can also install the compiler as a package on some linux distros (which will take care of dependencies automatically):
   - Arch (via AUR): [`prog8`](https://aur.archlinux.org/packages/prog8)
+- Finally there's a Homebrew recipe for Mac OS (but also for Linux, and WSL2 on Windows, this also takes care of dependencies automatically):
+  ``brew install prog8``
+
 
 Community
 ---------
@@ -58,10 +64,12 @@ What does Prog8 provide?
 
 - all advantages of a higher level language over having to write assembly code manually
 - programs run very fast because it's compiled to native machine code
-- code often is smaller and faster than equivalent C code compiled with CC65 or even LLVM-MOS
+- compiled code is very small; much smaller than equivalent C code compiled with CC65, and usually runs faster as well
 - modularity, symbol scoping, subroutines. No need for forward declarations.
-- various data types other than just bytes (16-bit words, floats, strings)
+- 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
@@ -82,12 +90,12 @@ What does Prog8 provide?
 - supports the sixteen 'virtual' 16-bit registers R0 - R15 from the Commander X16 (also available on other targets)
 - encode strings and characters into petscii or screencodes or even other encodings
 - Automatic ROM/RAM bank switching on certain compiler targets when calling routines in other banks
-- 50 Kb of available program RAM size on the C64 by default; because Basic ROM is banked out altogether 
+- 50 Kb of available program RAM size on the C64 by default (41 Kb on the C128) because Basic ROM is banked out by default 
 
 *Rapid edit-compile-run-debug cycle:*
 
 - 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
 
@@ -97,17 +105,22 @@ What does Prog8 provide?
 - "c64": Commodore-64  (6502 like CPU)
 - "c128": Commodore-128  (6502 like CPU - the Z80 cpu mode is not supported)
 - "pet32": Commodore PET (limited support)
+- "amiga500": Commodore Amiga 500  (16/32-bit 68000 CPU; experimental)
+- "amiga1200": Commodore Amiga 1200  (32-bit 68020 CPU with optional FPU; experimental)
+- "qemu68k": Qemu M68k simulator (experimental)
 - via external configurable targets: Atari 800 XL, Neo6502, NES, C64 OS, Foenix F256, ...
 - If you only use standard kernal and prog8 library routines, it is possible to compile the *exact same program* for different machines (just change the compiler target flag)
 
+The m68k targets (amiga500, amiga1200, qemu68k) and the optional `-newcodegen` 6502 code generator are experimental and not yet suitable for production code.
+
 
 
 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,
@@ -172,7 +185,7 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
         }
     }
 
-when compiled an ran on a C-64 you'll get:
+when compiled and ran on a C-64 you'll get:
 
 ![c64 screen](docs/source/_static/primes_example.png)
 
@@ -193,3 +206,19 @@ For instance here's a well known space ship animated in 3D with hidden line remo
 in the CommanderX16 emulator:
 
 ![cobra3d](docs/source/_static/cobra3d.png)
+
+
+Performance comparison with various C compilers
+-----------------------------------------------
+
+Here is a performance comparison with various C compilers for the 6502/C64 so you can get
+an idea of how Prog8 stacks up.
+
+[comparison](benchmark-c/benchmark.md)
+
+
+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-c/benchmark.md

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

benchmark-c/ciatimer.p8

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

benchmark-c/crc16.p8

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

benchmark-c/crc32.p8

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

benchmark-c/crc8.p8

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

benchmark-c/pow.p8

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

benchmark-c/sieve.p8

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

benchmark-c/sieve_bit.p8

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

benchmark-program/b_3d.p8

@@ -41,7 +41,7 @@ rotate3d {
         for i in 0 to len(matrix_math.xcoor)-1 {
             rz = matrix_math.rotatedz[i]
             if rz >= 10 {
-                persp = 600 + rz/64
+                persp = 600 + (rz>>5)
                 sx = matrix_math.rotatedx[i] / persp as byte + WIDTH/2
                 sy = matrix_math.rotatedy[i] / persp as byte + HEIGHT/2
                 ;; txt.setcc(sx as ubyte, sy as ubyte, 46, 7)
@@ -51,7 +51,7 @@ rotate3d {
         for i in 0 to len(matrix_math.xcoor)-1 {
             rz = matrix_math.rotatedz[i]
             if rz < 10 {
-                persp = 600 + rz/64
+                persp = 600 + (rz>>5)
                 sx = matrix_math.rotatedx[i] / persp as byte + WIDTH/2
                 sy = matrix_math.rotatedy[i] / persp as byte + HEIGHT/2
                 ;; txt.setcc(sx as ubyte, sy as ubyte, 81, 7)
@@ -84,18 +84,19 @@ matrix_math {
         word wcosc = math.cos8(az)
         word wsinc = math.sin8(az)
 
-        word wcosa_sinb = wcosa*wsinb / 128
-        word wsina_sinb = wsina*wsinb / 128
+        ; instead of (slow) /128, we simply shift 7 bits (and take the roundoff error)
+        word wcosa_sinb = wcosa*wsinb >> 7
+        word wsina_sinb = wsina*wsinb >> 7
 
-        word Axx = wcosa*wcosb / 128
-        word Axy = (wcosa_sinb*wsinc - wsina*wcosc) / 128
-        word Axz = (wcosa_sinb*wcosc + wsina*wsinc) / 128
-        word Ayx = wsina*wcosb / 128
-        word Ayy = (wsina_sinb*wsinc + wcosa*wcosc) / 128
-        word Ayz = (wsina_sinb*wcosc - wcosa*wsinc) / 128
+        word Axx = wcosa*wcosb >> 7
+        word Axy = (wcosa_sinb*wsinc - wsina*wcosc) >> 7
+        word Axz = (wcosa_sinb*wcosc + wsina*wsinc) >> 7
+        word Ayx = wsina*wcosb >> 7
+        word Ayy = (wsina_sinb*wsinc + wcosa*wcosc) >> 7
+        word Ayz = (wsina_sinb*wcosc - wcosa*wsinc) >> 7
         word Azx = -wsinb
-        word Azy = wcosb*wsinc / 128
-        word Azz = wcosb*wcosc / 128
+        word Azy = wcosb*wsinc >> 7
+        word Azz = wcosb*wcosc >> 7
 
         ubyte @zp i
         for i in 0 to len(xcoor)-1 {

benchmark-program/b_adpcm.p8

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

benchmark-program/b_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()
             }
         }
     }
@@ -220,10 +220,10 @@ btree {
 
 arena {
     ; extremely trivial arena allocator (that never frees)
-    uword buffer = memory("arena", 2000, 0)
-    uword next = buffer
+    pointer buffer = memory("arena", 2000, 0)
+    pointer next = buffer
 
-    sub alloc(ubyte size) -> uword {
+    sub alloc(ubyte size) -> pointer {
         defer next += size
         return next
     }

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

benchmark-program/b_textelite.p8

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

benchmark-program/benchmark.p8

@@ -4,6 +4,12 @@
 ;
 ;  As the X16 computer is a more or less fixed system, it's not very useful
 ;  to benchmark the computer itself with.
+;
+;  The individual scores are iteration counts, and they differ by more than an
+;  order of magnitude between benchmarks (maze does ~3000, game of life ~180).
+;  Summing the raw counts therefore let one or two benchmarks dominate the total
+;  and hide regressions in all the others, so the total is a weighted sum - see
+;  benchmark_weight below.
 
 
 %import textio
@@ -26,6 +32,15 @@ main {
 
     str[20] benchmark_names
     uword[20] benchmark_score
+    ;  Weight per benchmark, in the same order as the benchmarks are run below. The total is the
+    ;  weighted sum of the raw iteration counts.
+    ;  The raw counts differ by more than an order of magnitude (maze ~3064, game of life ~180), so
+    ;  in an unweighted sum the two heaviest - maze solver and text-elite - were 57% of the total
+    ;  while game of life was 2%. A regression in a small benchmark was therefore nearly invisible.
+    ;  Their weights are scaled down so that every benchmark contributes roughly comparably; the
+    ;  other eight are left at 256 (i.e. unweighted).
+    uword[10] benchmark_weight = [ 64, 256, 256, 256, 256, 256, 256, 64, 256, 256 ]
+    str version = "14.0"
 
 
     sub start() {
@@ -35,8 +50,10 @@ main {
         txt.color2(1, 6)
         txt.clear_screen()
 
-        txt.print("\n\n\n  prog8 compiler benchmark tests.\n")
-        sys.wait(60)
+        txt.print("\n\n\n  prog8 compiler benchmark tests.\n\n  benchmark version ")
+        txt.print(version)
+        txt.print("\n\n")
+        sys.wait(120)
 
         benchmark_number = 0
 
@@ -65,7 +82,7 @@ main {
         benchmark_number++
 
         announce_benchmark("circles with gfx_lores")
-        benchmark_score[benchmark_number]  = circles.draw(false, 300)
+        benchmark_score[benchmark_number]  = circles.draw(false, 400)
         benchmark_number++
 
         announce_benchmark("text-elite")
@@ -88,13 +105,19 @@ main {
         txt.color2(1, 6)
         uword total_score
         benchmark_number = 0
-        txt.print("\nscore benchmark\n\n")
+        txt.print("\nscore benchmark (")
+        txt.print(version)
+        txt.print(")\n\n")
+
         do {
+            ;  Weighted contribution. Done in long arithmetic on purpose: score*weight overflows a
+            ;  uword (3064*256 is 784384, which wraps to 63488 and would corrupt the total).
+            uword weighted = ((benchmark_score[benchmark_number] as long) * benchmark_weight[benchmark_number] / 256) as uword
             txt.spc()
-            txt.print_uw(benchmark_score[benchmark_number])
+            txt.print_uw(weighted)
             txt.column(6)
             txt.print(benchmark_names[benchmark_number])
-            total_score += benchmark_score[benchmark_number]
+            total_score += weighted
             txt.nl()
             benchmark_number++
         } until benchmark_names[benchmark_number]==0

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.2.20"
+    kotlin("jvm") version "2.4.21"
 }
 
 allprojects {
@@ -14,12 +12,13 @@ allprojects {
     repositories {
         mavenLocal()
         mavenCentral()
+        maven { url = uri("https://jitpack.io") }
     }
 
     kotlin {
         compilerOptions {
-            freeCompilerArgs = listOf("-Xwhen-guards")
-            jvmTarget = JvmTarget.JVM_11
+            freeCompilerArgs = listOf()
+            jvmTarget = JvmTarget.JVM_17
             jvmDefault = JvmDefaultMode.NO_COMPATIBILITY
             // languageVersion.set(KotlinVersion.KOTLIN_2_3)
         }
@@ -32,7 +31,81 @@ 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.4"))
+        // implementation("org.codeberg.irmen:ksim65:v2.2")
+    }
+
+    // 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()
+
+        // Forked test JVMs each reserve up to -PtestMaxHeap, so keep the fork count
+        // bounded even on many-core machines to avoid swapping during parallel builds.
+        val testConcurrency = (project.findProperty("testConcurrency")?.toString()?.toIntOrNull()
+            ?: (Runtime.getRuntime().availableProcessors() / 2)).coerceIn(1, 4)
+        project.findProperty("testMaxHeap")?.toString()?.let { maxHeapSize = it }
+
+        // Enable concurrent test execution for Kotest
+        // Allow CI to override parallelism for memory-constrained runners
+        jvmArgs("-Dkotest.framework.parallelism=$testConcurrency")
+
+        // 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 = testConcurrency
+
+        // 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,21 @@ 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('.').joinToString(".") { part ->
+            if (part.length > 4 && part.startsWith("p8") && part[2].isLetter() && part[3] == '_')
+                part.drop(4)
+            else part
+        }
+    }
+}

codeCore/src/prog8/code/assembly/AssemblyProgram6502.kt

@@ -1,34 +1,29 @@
-package prog8.codegen.cpu6502
+package prog8.code.assembly
 
 import prog8.code.GENERATED_LABEL_PREFIX
-import prog8.code.IAssemblyProgram
-import prog8.code.core.CompilationOptions
-import prog8.code.core.ICompilationTarget
-import prog8.code.core.IErrorReporter
-import prog8.code.core.OutputType
+import prog8.code.core.*
 import prog8.code.target.C128Target
 import prog8.code.target.C64Target
 import prog8.code.target.PETTarget
 import java.nio.file.Path
 
 
-internal class AssemblyProgram(
-        override val name: String,
-        outputDir: Path,
-        private val compTarget: ICompilationTarget) : IAssemblyProgram {
+class AssemblyProgram6502(
+    override val name: String,
+    private val options: CompilationOptions,
+    private val compTarget: ICompilationTarget) : IAssemblyProgram {
 
-    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
-    private val binFile = outputDir.resolve("$name.bin")
-    private val viceMonListFile = outputDir.resolve(C64Target.viceMonListName(name))
-    private val listFile = outputDir.resolve("$name.list")
+    override val irInstructionCount: Int = 0
+    override val irChunkCount: Int = 0
+    override val irRegisterCount: Int = 0
 
     override fun assemble(options: CompilationOptions, errors: IErrorReporter): Boolean {
 
         val assemblerCommand: List<String>
+        val outs = OutputFiles.of(options, name)
 
         fun addRemainingOptions(command: MutableList<String>, program: Path, assembly: Path): List<String> {
+            // keep additionalAssemblerOptions BEFORE --output: a target config may contain its own --output
             if(options.compTarget.additionalAssemblerOptions.isNotEmpty())
                 command.addAll(options.compTarget.additionalAssemblerOptions)
 
@@ -41,7 +36,7 @@ internal class AssemblyProgram(
                 // CBM machines .prg generation.
 
                 val command = mutableListOf("64tass", "--cbm-prg", "--ascii", "--case-sensitive", "--long-branch",
-                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=$viceMonListFile")
+                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=${outs.viceMonList()}")
 
                 if(options.warnSymbolShadowing)
                     command.add("-Wshadow")
@@ -52,10 +47,10 @@ internal class AssemblyProgram(
                     command.add("--quiet")
 
                 if(options.asmListfile) {
-                    command.add("--list=$listFile")
+                    command.add("--list=${outs.list()}")
                 }
 
-                assemblerCommand = addRemainingOptions(command, prgFile, assemblyFile)
+                assemblerCommand = addRemainingOptions(command, outs.programFile, outs.asm())
                 if(!options.quiet)
                     println("\nCreating prg for target ${compTarget.name}.")
             }
@@ -63,7 +58,7 @@ internal class AssemblyProgram(
                 // Atari800XL .xex generation.
 
                 val command = mutableListOf("64tass", "--atari-xex", "--case-sensitive", "--long-branch",
-                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=$viceMonListFile")
+                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=${outs.viceMonList()}")
 
                 if(options.warnSymbolShadowing)
                     command.add("-Wshadow")
@@ -74,16 +69,16 @@ internal class AssemblyProgram(
                     command.add("--quiet")
 
                 if(options.asmListfile)
-                    command.add("--list=$listFile")
+                    command.add("--list=${outs.list()}")
 
-                assemblerCommand = addRemainingOptions(command,xexFile, assemblyFile)
+                assemblerCommand = addRemainingOptions(command, outs.programFile, outs.asm())
                 if(!options.quiet)
                     println("\nCreating xex for target ${compTarget.name}.")
             }
             OutputType.RAW -> {
                 // Neo6502/headerless raw program generation.
                 val command = mutableListOf("64tass", "--nostart", "--case-sensitive", "--long-branch",
-                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=$viceMonListFile")
+                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=${outs.viceMonList()}")
 
                 if(options.warnSymbolShadowing)
                     command.add("-Wshadow")
@@ -94,9 +89,9 @@ internal class AssemblyProgram(
                     command.add("--quiet")
 
                 if(options.asmListfile)
-                    command.add("--list=$listFile")
+                    command.add("--list=${outs.list()}")
 
-                assemblerCommand = addRemainingOptions(command, binFile, assemblyFile)
+                assemblerCommand = addRemainingOptions(command, outs.programFile, outs.asm())
                 if(!options.quiet)
                     println("\nCreating raw binary for target ${compTarget.name}.")
             }
@@ -104,7 +99,7 @@ internal class AssemblyProgram(
                 // CBM machines library (.bin) generation (with or without 2 byte load address header depending on the compilation target machine)
 
                 val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
-                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=$viceMonListFile")
+                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=${outs.viceMonList()}")
 
                 if(options.warnSymbolShadowing)
                     command.add("-Wshadow")
@@ -115,7 +110,7 @@ internal class AssemblyProgram(
                     command.add("--quiet")
 
                 if(options.asmListfile)
-                    command.add("--list=$listFile")
+                    command.add("--list=${outs.list()}")
 
                 if(compTarget.name in listOf(C64Target.NAME, C128Target.NAME, PETTarget.NAME)) {
                     if(!options.quiet)
@@ -127,26 +122,45 @@ internal class AssemblyProgram(
                     command.add("--nostart")       // should be headerless bin, because basic has problems doing a normal LOAD"lib",8,1 - need to use BLOAD
                 }
 
-                assemblerCommand = addRemainingOptions(command, binFile, assemblyFile)
+                assemblerCommand = addRemainingOptions(command, outs.programFile, outs.asm())
             }
+            else -> error("Unsupported output type: ${compTarget.defaultOutputType}")
         }
 
         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()
-            generateBreakpointList()
+            removeGeneratedLabelsFromMonlist(outs)
+            generateBreakpointList(outs)
         }
         return result==0
     }
 
-    private fun removeGeneratedLabelsFromMonlist() {
+    private fun removeGeneratedLabelsFromMonlist(outs: OutputFiles) {
         val pattern = Regex("""al (\w+) \S+$GENERATED_LABEL_PREFIX.+?""")
-        val lines = viceMonListFile.toFile().readLines()
-        viceMonListFile.toFile().outputStream().bufferedWriter().use {
+        val lines = outs.viceMonList().toFile().readLines()
+        outs.viceMonList().toFile().outputStream().bufferedWriter().use {
             for (line in lines) {
                 if(pattern.matchEntire(line)==null)
                     it.write(line+"\n")
@@ -154,11 +168,11 @@ internal class AssemblyProgram(
         }
     }
 
-    private fun generateBreakpointList() {
+    private fun generateBreakpointList(outs: OutputFiles) {
         // builds list of breakpoints, appends to monitor list file
         val breakpoints = mutableListOf<String>()
         val pattern = Regex("""al (\w+) \S+_prog8_breakpoint_\d+.?""")      // gather breakpoints by the source label that's generated for them
-        for (line in viceMonListFile.toFile().readLines()) {
+        for (line in outs.viceMonList().toFile().readLines()) {
             val match = pattern.matchEntire(line)
             if (match != null)
                 breakpoints.add("break $" + match.groupValues[1])
@@ -167,6 +181,7 @@ internal class AssemblyProgram(
         breakpoints.add(0, "; breakpoint list now follows")
         breakpoints.add(1, "; $num breakpoints have been defined")
         breakpoints.add(2, "del")
-        viceMonListFile.toFile().appendText(breakpoints.joinToString("\n") + "\n")
+        outs.viceMonList().toFile().appendText(breakpoints.joinToString("\n") + "\n")
     }
 }
+

codeCore/src/prog8/code/assembly/IAssemblyProgram.kt

@@ -0,0 +1,12 @@
+package prog8.code.assembly
+
+import prog8.code.core.CompilationOptions
+import prog8.code.core.IErrorReporter
+
+interface IAssemblyProgram {
+    val name: String
+    val irInstructionCount: Int
+    val irChunkCount: Int
+    val irRegisterCount: Int
+    fun assemble(options: CompilationOptions, errors: IErrorReporter): Boolean
+}

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

@@ -30,37 +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.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.FLOAT -> ReturnConvention(paramType, RegisterOrPair.FAC1)
-                    in IterableDatatypes -> ReturnConvention(paramType, RegisterOrPair.AY)
-                    else -> ReturnConvention(paramType, null)
+    fun callConventionFor6502(actualParamTypes: List<BaseDataType>): CallConvention {
+        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, BaseDataType.POINTER -> 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, BaseDataType.POINTER -> 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, 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)
@@ -86,74 +97,106 @@ class FSignature(val pure: Boolean,      // does it have side effects?
 }
 
 val BuiltinFunctions: Map<String, FSignature> = mapOf(
-    "setlsb"  to FSignature(false, null, FParam("variable", BaseDataType.WORD, BaseDataType.UWORD), FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
-    "setmsb"  to FSignature(false, null, FParam("variable", BaseDataType.WORD, BaseDataType.UWORD), FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
-    "rol"     to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
-    "ror"     to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
-    "rol2"    to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
-    "ror2"    to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
-    "cmp"     to FSignature(false, null, FParam("value1", *IntegerDatatypes), FParam("value2", *NumericDatatypes)),  // cmp returns a status in the carry flag, but not a proper return value
-    "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),
-    "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__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__float"   to FSignature(true, BaseDataType.FLOAT, FParam("value", BaseDataType.FLOAT)),
-    "divmod"        to FSignature(false, null, FParam("dividend", BaseDataType.UBYTE, BaseDataType.UWORD), FParam("divisor", BaseDataType.UBYTE, BaseDataType.UWORD), FParam("quotient", BaseDataType.UBYTE, BaseDataType.UWORD), FParam("remainder", BaseDataType.UBYTE, BaseDataType.UWORD)),
-    "divmod__ubyte" to FSignature(false, null, FParam("dividend", BaseDataType.UBYTE), FParam("divisor", BaseDataType.UBYTE), FParam("quotient", BaseDataType.UBYTE), FParam("remainder", BaseDataType.UBYTE)),
-    "divmod__uword" to FSignature(false, null, FParam("dividend", BaseDataType.UWORD), FParam("divisor", BaseDataType.UWORD), FParam("quotient", BaseDataType.UWORD), FParam("remainder", BaseDataType.UWORD)),
-    "lsb"           to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
-    "lsw"           to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
-    "msb"           to FSignature(true, BaseDataType.UBYTE, 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)),
-    "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)),
-    "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)),
-    "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)),
-    "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)),
-    "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)),
-    "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.POINTER, BaseDataType.UWORD, BaseDataType.LONG), FParam("pointer2", BaseDataType.POINTER, BaseDataType.UWORD, BaseDataType.LONG)),
+    "prog8_lib_copyfloat"         to FSignature(false, emptyArray(), FParam("pointer1", BaseDataType.POINTER, BaseDataType.UWORD, BaseDataType.LONG), FParam("pointer2", BaseDataType.POINTER, BaseDataType.UWORD, BaseDataType.LONG)),
+    "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, BaseDataType.LONG, BaseDataType.POINTER)),
+    "peekbool"      to FSignature(true, arrayOf(BaseDataType.BOOL), FParam("address", BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.POINTER)),
+    "peekw"         to FSignature(true, arrayOf(BaseDataType.UWORD), FParam("address", BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.POINTER)),
+    "peekl"         to FSignature(true, arrayOf(BaseDataType.LONG), FParam("address", BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.POINTER)),
+    "peekf"         to FSignature(true, arrayOf(BaseDataType.FLOAT), FParam("address", BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.POINTER)),
+    "peekp"         to FSignature(true, arrayOf(BaseDataType.POINTER), FParam("address", BaseDataType.POINTER, BaseDataType.UWORD, BaseDataType.LONG)),
+    "poke"          to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.POINTER), FParam("value", BaseDataType.UBYTE, BaseDataType.BYTE)),
+    "pokebool"      to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.POINTER), FParam("value", BaseDataType.BOOL)),
+    "pokebowl"      to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.POINTER), FParam("value", BaseDataType.BOOL)),
+    "pokew"         to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.POINTER), FParam("value", BaseDataType.UWORD, BaseDataType.WORD)),
+    "pokel"         to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.POINTER), FParam("value", BaseDataType.LONG)),
+    "pokef"         to FSignature(false, emptyArray(), FParam("address", BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.POINTER), FParam("value", BaseDataType.FLOAT)),
+    "pokep"         to FSignature(false, emptyArray(), FParam("address", BaseDataType.POINTER, BaseDataType.UWORD, BaseDataType.LONG), FParam("value", BaseDataType.POINTER)),
+    "pokemon"       to FSignature(false, arrayOf(BaseDataType.UBYTE), FParam("address", BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.POINTER), FParam("value", BaseDataType.UBYTE)),
+    "rsave"         to FSignature(false, emptyArray()),
+    "rrestore"      to FSignature(false, emptyArray()),
+    "memory"        to FSignature(true,  arrayOf(BaseDataType.POINTER), FParam("name", BaseDataType.STR), FParam("size", BaseDataType.UWORD), FParam("alignment", BaseDataType.UWORD)),
+    "memory__ref"   to FSignature(true, arrayOf(BaseDataType.POINTER), FParam("name", BaseDataType.STR)),
+    "callfar"       to FSignature(false, arrayOf(BaseDataType.UWORD), FParam("bank", BaseDataType.UBYTE), FParam("address", BaseDataType.POINTER), FParam("arg", BaseDataType.UWORD)),
+    "callfar2"      to FSignature(false, arrayOf(BaseDataType.UWORD), FParam("bank", BaseDataType.UBYTE), FParam("address", BaseDataType.POINTER), 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.POINTER)),
+    "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)),
+    "pushp"         to FSignature(false, emptyArray(), FParam("value", BaseDataType.POINTER)),
+    "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)),
+    "popp"          to FSignature(false, arrayOf(BaseDataType.POINTER)),
 )
 
 val InplaceModifyingBuiltinFunctions = setOf(
     "setlsb", "setmsb",
-    "rol", "ror", "rol2", "ror2",
-    "divmod", "divmod__ubyte", "divmod__uword"
+    "rol", "ror", "rol2", "ror2"
 )
+
+val SimpleBuiltinFunctions = setOf(
+    "msb", "lsb", "msw", "lsw",
+    "mkword", "mklong", "mklong2",
+    "set_carry", "set_irqd", "clear_carry", "clear_irqd")

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

@@ -4,6 +4,7 @@ import java.nio.file.Path
 import kotlin.io.path.Path
 
 
+@Suppress("unused")
 class CompilationOptions(val output: OutputType,
                          val launcher: CbmPrgLauncherType,
                          val zeropage: ZeropageType,
@@ -13,27 +14,30 @@ class CompilationOptions(val output: OutputType,
                          val noSysInit: Boolean,
                          val romable: Boolean,
                          val compTarget: ICompilationTarget,
+                         val compilerVersion: String,
                          // these are set later, based on command line arguments or options in the source code:
                          var loadAddress: UInt,
                          var memtopAddress: UInt,
+                         var varsAddress: UInt? = null,
                          var warnSymbolShadowing: Boolean = false,
+                         var warnImplicitTypeCast: Boolean = false,
                          var optimize: Boolean = false,
                          var asmQuiet: Boolean = false,
                          var asmListfile: Boolean = false,
                          var includeSourcelines: Boolean = false,
                          var dumpVariables: Boolean = false,
                          var dumpSymbols: Boolean = false,
-                         var experimentalCodegen: Boolean = false,
+                         var newCodegen: Boolean = false,
                          var varsHighBank: Int? = null,
                          var varsGolden: Boolean = false,
-                         var slabsHighBank: Int? = null,
-                         var slabsGolden: Boolean = false,
-                         var dontSplitWordArrays: Boolean = false,
                          var breakpointCpuInstruction: String? = null,
                          var ignoreFootguns: Boolean = false,
                          var outputDir: Path = Path(""),
                          var quiet: Boolean = false,
-                         var symbolDefs: Map<String, String> = emptyMap()
+                         var profilingInstrumentation: Boolean = false,
+                         var symbolDefs: Map<String, String> = emptyMap(),
+                         var privateSymbols: Boolean = false,
+                         var outputFile: Path? = null
 ) {
     init {
         compTarget.initializeMemoryAreas(this)
@@ -41,5 +45,81 @@ 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 varsAddress: UInt? = null
+            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 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 newCodegen: Boolean = false
+            private var symbolDefs: Map<String, String> = emptyMap()
+            private var outputFile: Path? = null
+
+            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 varsAddress(varsAddress: UInt?) = apply { this.varsAddress = varsAddress }
+            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 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 newCodegen(newCodegen: Boolean) = apply { this.newCodegen = newCodegen }
+            fun outputFile(outputFile: Path?) = apply { this.outputFile = outputFile }
+
+            fun build(): CompilationOptions {
+                return CompilationOptions(
+                    output, launcher, zeropage, zpReserved, zpAllowed, floats, noSysInit, romable, compTarget, compilerVersion,
+                    loadAddress, memtopAddress, varsAddress, warnSymbolShadowing, warnImplicitTypeCast, optimize, asmQuiet, asmListfile,
+                    includeSourcelines, dumpVariables, dumpSymbols, newCodegen, varsHighBank, varsGolden,
+                    breakpointCpuInstruction, ignoreFootguns, outputDir, quiet,
+                    profilingInstrumentation, symbolDefs
+                ).apply { this.outputFile = this@Builder.outputFile }
+            }
+        }
     }
 }

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

@@ -13,9 +13,12 @@ fun Number.toHex(): String {
     //  256..65536 -> "$0100".."$ffff"
     //  larger -> "$12345678"
     // negative values are prefixed with '-'.
-    val integer = this.toInt()
-    if(integer<0)
+    val integer = this.toLong()
+    if(integer<0) {
+        if(integer==-2147483648L)
+            return "$80000000"      // the exception to the rule, because -$80000000 is not a valid hex number
         return '-' + abs(integer).toHex()
+    }
     return when (integer) {
         in 0 until 16 -> integer.toString()
         in 0 until 0x100 -> "$"+integer.toString(16).padStart(2,'0')
@@ -95,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,534 @@
+package prog8.code.core
+
+import java.util.Objects
+
+
+
+
+/**
+ * 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)
+    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 || other == LONG) || 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): Boolean = equalsSize(other, null)
+    fun equalsSize(other: BaseDataType, memsizer: IMemSizer?): Boolean =
+        when {
+            this == other -> true
+            this.isArray && other.isArray -> true
+            this.isByteOrBool -> other.isByteOrBool
+            this.isWord -> other.isWord || (other.isPointer && (memsizer == null || memsizer.POINTER_MEM_SIZE == 2u))
+            this.isLong -> other.isLong || (other.isPointer && memsizer?.POINTER_MEM_SIZE != null && memsizer.POINTER_MEM_SIZE != 2u)
+            this.isPointer -> when(memsizer?.POINTER_MEM_SIZE) {
+                null -> other.isWord || other.isPointer
+                2u -> other.isWord || other.isPointer
+                else -> other.isLong || other.isPointer
+            }
+            this == STR && (other == UWORD || other == LONG) || (this == UWORD || this == LONG) && 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.maxUnsignedValue: Double
+    get() = when (this) {
+        BaseDataType.UBYTE -> 255.0
+        BaseDataType.BYTE -> 127.0
+        BaseDataType.UWORD -> 65535.0
+        BaseDataType.WORD -> 32767.0
+        BaseDataType.LONG -> 2147483647.0
+        else -> Double.MAX_VALUE
+    }
+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
+val BaseDataType.isPointer get() = this == BaseDataType.POINTER
+val BaseDataType.isStructInstance get() = this == BaseDataType.STRUCT_INSTANCE
+val BaseDataType.isIterable get() =  this in setOf(BaseDataType.STR, BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW)
+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?,
+    val pointeeSub: BaseDataType?,
+    var subType: ISubType?,
+    var subTypeFromAntlr: List<String>? = null
+) {
+
+    init {
+        when {
+            base.isArray && sub == BaseDataType.POINTER -> {
+                require(pointeeSub != null || subType != null || subTypeFromAntlr != null)
+            }
+            base.isArray -> {
+                require(sub != null)
+                // subType and subTypeFromAntlr allowed for arrays with struct element types
+                // (from parser creating ARRAY(LONG) directly for 32-bit targets, or from VariousCleanups conversion)
+                if(base == BaseDataType.ARRAY_SPLITW)
+                    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
+        if (base != other.base || sub != other.sub || pointeeSub != other.pointeeSub) return false
+        val st1 = subType
+        val st2 = other.subType
+        if (st1 == st2) return true
+        if (st1 == null || st2 == null) return false
+        return st1.sameas(st2)
+    }
+
+    override fun hashCode(): Int = Objects.hash(base, sub, pointeeSub, subType)
+
+    fun setActualSubType(actualSubType: ISubType) {
+        subType = actualSubType
+        subTypeFromAntlr = null
+    }
+
+    // ============================================================================
+    // Companion Object - Factory Methods
+    // ============================================================================
+    
+    companion object {
+
+        val UBYTE = DataType(BaseDataType.UBYTE, null, null, null)
+        val BYTE = DataType(BaseDataType.BYTE, null, null, null)
+        val UWORD = DataType(BaseDataType.UWORD, null, null, null)
+        val WORD = DataType(BaseDataType.WORD, null, null, null)
+        val LONG = DataType(BaseDataType.LONG, null, null, null)
+        val FLOAT = DataType(BaseDataType.FLOAT, null, null, null)
+        val BOOL = DataType(BaseDataType.BOOL, null, null, null)
+        val STR = DataType(BaseDataType.STR, BaseDataType.UBYTE, null, null)
+        val UNDEFINED = DataType(BaseDataType.UNDEFINED, null, null, null)
+
+        private val simpletypes = mapOf(
+            BaseDataType.UBYTE to DataType(BaseDataType.UBYTE, null, null, null),
+            BaseDataType.BYTE to DataType(BaseDataType.BYTE, null, null, null),
+            BaseDataType.UWORD to DataType(BaseDataType.UWORD, null, null, null),
+            BaseDataType.WORD to DataType(BaseDataType.WORD, null, null, null),
+            BaseDataType.LONG to DataType(BaseDataType.LONG, null, null, null),
+            BaseDataType.FLOAT to DataType(BaseDataType.FLOAT, null, null, null),
+            BaseDataType.BOOL to DataType(BaseDataType.BOOL, null, null, null),
+            BaseDataType.STR to DataType(BaseDataType.STR, BaseDataType.UBYTE, null, null),
+            BaseDataType.POINTER to DataType(BaseDataType.POINTER, null, null, null),
+            BaseDataType.UNDEFINED to DataType(BaseDataType.UNDEFINED, null, null, null)
+        )
+
+        fun forDt(dt: BaseDataType): DataType {
+            if(dt.isStructInstance)
+                return DataType(BaseDataType.STRUCT_INSTANCE, null, null, null)
+            return simpletypes.getValue(dt)
+        }
+
+        fun arrayFor(elementDt: BaseDataType, memsizer: IMemSizer): DataType {
+            require(elementDt != BaseDataType.POINTER) { "use arrayOfPointersTo for arrays of pointers" }
+            val actualElementDt = if(elementDt==BaseDataType.STR) {
+                memsizer.pointerBaseType
+            } else elementDt
+            if(actualElementDt.isNumericOrBool)
+                return DataType(BaseDataType.ARRAY, actualElementDt, null, null)
+            else
+                throw NoSuchElementException("invalid basic element dt $elementDt")
+        }
+
+        fun splitWordArrayFor(elementDt: BaseDataType): DataType {
+            require(elementDt.isWord) { "split word array element type must be word" }
+            return DataType(BaseDataType.ARRAY_SPLITW, elementDt, null, null)
+        }
+
+        fun arrayOfPointersTo(sub: BaseDataType): DataType =
+            DataType(BaseDataType.ARRAY, BaseDataType.POINTER, sub, null)
+        fun arrayOfPointersTo(structType: ISubType?): DataType =
+            DataType(BaseDataType.ARRAY, BaseDataType.POINTER, BaseDataType.STRUCT_INSTANCE, structType)
+        fun arrayOfPointersFromAntlrTo(sub: BaseDataType?, identifier: List<String>?): DataType =
+            DataType(BaseDataType.ARRAY, BaseDataType.POINTER, sub ?: BaseDataType.STRUCT_INSTANCE, null, identifier)
+
+        // array of struct instances: sub is STRUCT_INSTANCE, subType carries the resolved struct
+        fun arrayOfStructs(structType: ISubType): DataType = DataType(BaseDataType.ARRAY, BaseDataType.STRUCT_INSTANCE, null, structType)
+        fun arrayOfStructsFromAntlr(struct: List<String>): DataType =
+            DataType(BaseDataType.ARRAY, BaseDataType.STRUCT_INSTANCE, null, null, subTypeFromAntlr = struct)
+
+        fun pointer(base: BaseDataType): DataType = DataType(BaseDataType.POINTER, base, null, null)
+        fun pointer(dt: DataType): DataType = if(dt.isBasic)
+                DataType(BaseDataType.POINTER, dt.base, null, null)
+            else
+                DataType(BaseDataType.POINTER, null, null, dt.subType, dt.subTypeFromAntlr)
+        fun pointer(structType: ISubType): DataType = DataType(BaseDataType.POINTER, null, null, structType)
+        fun pointerFromAntlr(identifier: List<String>): DataType = DataType(BaseDataType.POINTER, null, null, null, identifier)
+        fun structInstance(type: ISubType?): DataType = DataType(BaseDataType.STRUCT_INSTANCE, sub=null, pointeeSub=null, type)
+        fun structInstanceFromAntlr(struct: List<String>): DataType = DataType(BaseDataType.STRUCT_INSTANCE, null, null, null, subTypeFromAntlr = struct)
+    }
+
+
+    // ============================================================================
+    // DataType Methods
+    // ============================================================================
+
+    fun elementToArray(target: ICompilationTarget, splitwords: Boolean = true): DataType {
+        fun pointerArray(): DataType =
+            if (subType != null)
+                arrayOfPointersTo(subType)
+            else if (subTypeFromAntlr != null)
+                arrayOfPointersFromAntlrTo(sub, subTypeFromAntlr)
+            else
+                arrayOfPointersTo(sub!!)
+
+        if(base == BaseDataType.STRUCT_INSTANCE) {
+            val st = subType
+            return if(st != null)
+                arrayOfStructs(st)
+            else
+                arrayOfStructsFromAntlr(subTypeFromAntlr!!)
+        }
+
+        if(base.isPointer)
+            return pointerArray()
+
+        if(!target.cpu.is6502)
+            return arrayFor(base, target)
+
+        return if (splitwords && (base == BaseDataType.UWORD || base == BaseDataType.WORD || base == BaseDataType.STR))
+            splitWordArrayFor(base)
+        else
+            arrayFor(base, target)
+    }
+
+    fun elementType(): DataType =
+        when {
+            isPointerArray -> {
+                if (subType != null) DataType(BaseDataType.POINTER, null, null, subType)
+                else if (subTypeFromAntlr != null) DataType(BaseDataType.POINTER, null, null, null, subTypeFromAntlr)
+                else DataType(BaseDataType.POINTER, pointeeSub!!, null, null)
+            }
+            base.isArray || base==BaseDataType.STR -> {
+                if (sub == BaseDataType.STRUCT_INSTANCE && subType != null)
+                    return DataType(BaseDataType.STRUCT_INSTANCE, null, null, subType)
+                val dt = forDt(sub!!)
+                if (subType != null) DataType(BaseDataType.POINTER, null, null, subType) else dt
+            }
+            else -> throw IllegalArgumentException("not an array")
+        }
+
+    fun typeForUntypedAddressOf(msb: Boolean, mem: IMemSizer): DataType {
+        val untypedPointerType = if(mem.memorySize(BaseDataType.POINTER)>2) LONG else UWORD
+        if (isUndefined)
+            return if(msb) pointer(BaseDataType.UBYTE) else untypedPointerType
+        else {
+            if (isBasic)
+                return pointer(base)
+            if (isString)
+                return pointer(BaseDataType.UBYTE)
+            if (isPointer)
+                return untypedPointerType
+            if (isArray) {
+                val isSplit = base == BaseDataType.ARRAY_SPLITW ||
+                    (isPointerArray && mem.memorySize(BaseDataType.POINTER) <= 2)
+                if (msb || isSplit)
+                    return pointer(BaseDataType.UBYTE)
+                val elementDt = elementType()
+                if (elementDt.isBasic)
+                    return pointer(elementDt)
+                return untypedPointerType
+            }
+            if (subType != null)
+                return pointer(this)
+            return untypedPointerType
+        }
+    }
+
+    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, null, subType)
+            subTypeFromAntlr!=null -> DataType(BaseDataType.STRUCT_INSTANCE, null, 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[]"
+                BaseDataType.POINTER -> {
+                    val pointee = if (subType != null) subType!!.scopedNameString
+                        else if (subTypeFromAntlr != null) "$subTypeFromAntlr"
+                        else pointeeSub!!.name.lowercase()
+                    "^^$pointee[]"
+                }
+                BaseDataType.STRUCT_INSTANCE -> if (subType != null) "${subType!!.scopedNameString}[]" else "$subTypeFromAntlr[]"
+                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.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 -> {
+            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["
+                BaseDataType.POINTER -> {
+                    val pointee = if (subType != null) "^^${subType!!.scopedNameString}["
+                        else if (subTypeFromAntlr != null) "^^${subTypeFromAntlr!!.joinToString(".")}["
+                        else "^^${pointeeSub!!.name.lowercase()}["
+                    pointee
+                }
+                BaseDataType.STRUCT_INSTANCE -> if (subType != null) "${subType!!.scopedNameString}[" else "$subTypeFromAntlr["
+                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) || targetType.isPointerArray
+            BaseDataType.WORD -> targetType.base in setOf(BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
+            BaseDataType.LONG -> targetType.base in setOf(BaseDataType.LONG, BaseDataType.FLOAT, BaseDataType.POINTER) || targetType.isPointerArray
+            BaseDataType.FLOAT -> targetType.base in arrayOf(BaseDataType.FLOAT)
+            BaseDataType.STR -> targetType.base in setOf(BaseDataType.STR, BaseDataType.UWORD, BaseDataType.LONG) || (targetType.isPointer && targetType.sub==BaseDataType.UBYTE)
+            BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW -> {
+                if (isPointerArray) {
+                    targetType.isPointerArray && if (subType != null && targetType.subType != null) subType!!.sameas(targetType.subType!!)
+                    else if (subType == null && targetType.subType == null) pointeeSub == targetType.pointeeSub
+                    else false
+                } else {
+                    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.UNDEFINED -> false
+        }
+
+    fun largerSizeThan(other: DataType): Boolean = base.largerSizeThan(other.base)
+    fun equalsSize(other: DataType): Boolean = base.equalsSize(other.base)
+    fun equalsSize(other: DataType, memsizer: IMemSizer): Boolean = base.equalsSize(other.base, memsizer)
+
+    /**
+     * 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 = when {
+        base == BaseDataType.ARRAY && sub == BaseDataType.POINTER -> memsizer.memorySize(BaseDataType.POINTER)
+        sub!=null -> memsizer.memorySize(sub)
+        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 == BaseDataType.ARRAY && sub == BaseDataType.POINTER
+    val isBoolArray = base == BaseDataType.ARRAY && sub == BaseDataType.BOOL
+    val isByteArray = base == BaseDataType.ARRAY && (sub == BaseDataType.UBYTE || sub == BaseDataType.BYTE)
+    val isUnsignedByteArray = base == BaseDataType.ARRAY && sub == BaseDataType.UBYTE
+    val isSignedByteArray = base == BaseDataType.ARRAY && sub == BaseDataType.BYTE
+    val isWordArray = (base == BaseDataType.ARRAY || base == BaseDataType.ARRAY_SPLITW) && (sub == BaseDataType.UWORD || sub == BaseDataType.WORD)
+    val isUnsignedWordArray = (base == BaseDataType.ARRAY || base == BaseDataType.ARRAY_SPLITW) && sub == BaseDataType.UWORD
+    val isSignedWordArray = (base == BaseDataType.ARRAY || base == BaseDataType.ARRAY_SPLITW) && sub == BaseDataType.WORD
+    val isLongArray = base == BaseDataType.ARRAY && sub == BaseDataType.LONG
+    val isFloatArray = base == BaseDataType.ARRAY && sub == BaseDataType.FLOAT
+    val isString = base == BaseDataType.STR
+    val isBool = base == BaseDataType.BOOL
+    val isFloat = base == BaseDataType.FLOAT
+    val isLong = base == BaseDataType.LONG
+    fun isStringly(memsizer: IMemSizer): Boolean =
+        base == BaseDataType.STR ||
+        (memsizer.POINTER_MEM_SIZE == 2u && base == BaseDataType.UWORD) ||
+        (memsizer.POINTER_MEM_SIZE > 2u && base == BaseDataType.LONG) ||
+        (base == BaseDataType.ARRAY && (sub == BaseDataType.UBYTE || sub == BaseDataType.BYTE))
+    fun isSplitWordArray(memsizer: IMemSizer): Boolean  {
+        return when (base) {
+            BaseDataType.ARRAY_SPLITW -> true
+            BaseDataType.ARRAY if sub == BaseDataType.POINTER -> memsizer.POINTER_MEM_SIZE <= 2u
+            else -> false
+        }
+    }
+    val isSplitUnsignedWordArray = base == BaseDataType.ARRAY_SPLITW && sub == BaseDataType.UWORD
+    val isSplitSignedWordArray = base == BaseDataType.ARRAY_SPLITW && sub == BaseDataType.WORD
+    val isIterable =  base.isIterable
+    val isPassByRef = base.isPassByRef
+    val isPassByValue = base.isPassByValue
+}

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

@@ -1,386 +1,14 @@
 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.isInteger get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)
-val BaseDataType.isIntegerOrBool get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.BOOL)
-val BaseDataType.isNumeric get() = this == BaseDataType.FLOAT || this.isInteger
-val BaseDataType.isNumericOrBool get() = this == BaseDataType.BOOL || this.isNumeric
-val BaseDataType.isSigned get() = this in arrayOf(BaseDataType.BYTE, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
-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 arrayOf(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 && actualElementDt != BaseDataType.LONG)
-                    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[]"
-                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.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 arrayOf(BaseDataType.UBYTE, BaseDataType.WORD, BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.FLOAT)
-            BaseDataType.BYTE -> targetType.base in arrayOf(BaseDataType.BYTE, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
-            BaseDataType.UWORD -> targetType.base in arrayOf(BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.FLOAT, BaseDataType.POINTER, BaseDataType.ARRAY_POINTER)
-            BaseDataType.WORD -> targetType.base in arrayOf(BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
-            BaseDataType.LONG -> targetType.base in arrayOf(BaseDataType.LONG, BaseDataType.FLOAT)
-            BaseDataType.FLOAT -> targetType.base in arrayOf(BaseDataType.FLOAT)
-            BaseDataType.STR -> targetType.base in arrayOf(BaseDataType.STR, BaseDataType.UWORD) || (targetType.isPointer && targetType.sub==BaseDataType.UBYTE)
-            BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW -> targetType.base in arrayOf(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 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 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,
     X,
-    Y
+    Y,
+    // m68k:
+    D0, D1, D2, D3, D4, D5, D6, D7,
+    A0, A1, A2, A3, A4, A5, A6,
+    FP0, FP1, FP2, FP3, FP4, FP5, FP6, FP7
 }
 
 enum class RegisterOrPair {
@@ -394,19 +22,65 @@ enum class RegisterOrPair {
     FAC2,
     // cx16 virtual registers:
     R0, R1, R2, R3, R4, R5, R6, R7,
-    R8, R9, R10, R11, R12, R13, R14, R15;
+    R8, R9, R10, R11, R12, R13, R14, R15,
+    // combined virtual registers to store 32 bits longs:
+    R0R1, R2R3, R4R5, R6R7, R8R9, R10R11, R12R13, R14R15,
+    // m68k data & address registers:
+    D0, D1, D2, D3, D4, D5, D6, D7,
+    A0, A1, A2, A3, A4, A5, A6,
+    // m68k FPU registers:
+    FP0, FP1, FP2, FP3, FP4, FP5, FP6, FP7;
 
     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
                 CpuRegister.X -> X
                 CpuRegister.Y -> Y
+                CpuRegister.D0 -> D0
+                CpuRegister.D1 -> D1
+                CpuRegister.D2 -> D2
+                CpuRegister.D3 -> D3
+                CpuRegister.D4 -> D4
+                CpuRegister.D5 -> D5
+                CpuRegister.D6 -> D6
+                CpuRegister.D7 -> D7
+                CpuRegister.A0 -> A0
+                CpuRegister.A1 -> A1
+                CpuRegister.A2 -> A2
+                CpuRegister.A3 -> A3
+                CpuRegister.A4 -> A4
+                CpuRegister.A5 -> A5
+                CpuRegister.A6 -> A6
+                CpuRegister.FP0 -> FP0
+                CpuRegister.FP1 -> FP1
+                CpuRegister.FP2 -> FP2
+                CpuRegister.FP3 -> FP3
+                CpuRegister.FP4 -> FP4
+                CpuRegister.FP5 -> FP5
+                CpuRegister.FP6 -> FP6
+                CpuRegister.FP7 -> FP7
             }
         }
     }
 
+    /**
+     * Returns the starting virtual register name for the current 32-bit combined virtual register
+     * @return The starting register name as a string, WITHOUT THE cx16 block scope prefix!
+     */
+    fun startregname() = when(this) {
+        R0R1 -> "r0"
+        R2R3 -> "r2"
+        R4R5 -> "r4"
+        R6R7 -> "r6"
+        R8R9 -> "r8"
+        R10R11 -> "r10"
+        R12R13 -> "r12"
+        R14R15 -> "r14"
+        else -> throw IllegalArgumentException("must be a combined virtual register $this")
+    }
+
     fun asCpuRegister(): CpuRegister = when(this) {
         A -> CpuRegister.A
         X -> CpuRegister.X
@@ -415,18 +89,20 @@ 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, null -> ""
-            else -> throw IllegalArgumentException("invalid register param type")
+            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)
     }
 
     fun isWord() = this==AX || this == AY || this==XY || this in Cx16VirtualRegisters
+    fun isLong() = this in CombinedLongRegisters
 
 }       // only used in parameter and return value specs in asm subroutines
 
@@ -437,7 +113,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()
     }
 }
 
@@ -456,14 +132,34 @@ 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 CpuRegisters = arrayOf(
+val CombinedLongRegisters = setOf(
+    RegisterOrPair.R0R1,
+    RegisterOrPair.R2R3,
+    RegisterOrPair.R4R5,
+    RegisterOrPair.R6R7,
+    RegisterOrPair.R8R9,
+    RegisterOrPair.R10R11,
+    RegisterOrPair.R12R13,
+    RegisterOrPair.R14R15
+)
+
+val M68kRegisters = setOf(
+    RegisterOrPair.D0, RegisterOrPair.D1, RegisterOrPair.D2, RegisterOrPair.D3,
+    RegisterOrPair.D4, RegisterOrPair.D5, RegisterOrPair.D6, RegisterOrPair.D7,
+    RegisterOrPair.A0, RegisterOrPair.A1, RegisterOrPair.A2, RegisterOrPair.A3,
+    RegisterOrPair.A4, RegisterOrPair.A5, RegisterOrPair.A6,
+    RegisterOrPair.FP0, RegisterOrPair.FP1, RegisterOrPair.FP2, RegisterOrPair.FP3,
+    RegisterOrPair.FP4, RegisterOrPair.FP5, RegisterOrPair.FP6, RegisterOrPair.FP7
+)
+
+val CpuRegisters = setOf(
     RegisterOrPair.A, RegisterOrPair.X, RegisterOrPair.Y,
     RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY
 )
@@ -473,6 +169,8 @@ enum class OutputType {
     RAW,
     PRG,
     XEX,
+    ELF,
+    AMIGAHUNK,
     LIBRARY
 }
 
@@ -498,6 +196,5 @@ enum class ZeropageWish {
 
 enum class SplitWish {
     DONTCARE,
-    SPLIT,
     NOSPLIT
-}
+}

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

@@ -2,10 +2,67 @@ 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),
+    
+    /** 16/32 bit Motorola 68000. has single instructions that set status bits when dealing with multi byte operands */
+    M68000(true),
+
+    /** 32 bit Motorola 68020. has single instructions that set status bits when dealing with multi byte operands */
+    M68020(true),
+
+    /**
+     * 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
+    val is68k: Boolean
+        get() = this == M68000 || this == M68020
+    /** True for targets that use the m68k-style hardware-register calling convention (D0-D7, A0-A6, FP0-FP7). */
+    val usesM68kConvention: Boolean
+        get() = is68k || this == VIRTUAL
+    /** True for big-endian targets. The 6502 family and the VM are little-endian. */
+    val isBigEndian: Boolean
+        get() = this == M68000 || this == M68020
 }
 
 interface ICompilationTarget: IStringEncoding, IMemSizer {
@@ -13,8 +70,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 ARRAY_SIZE_LIMIT: UInt
     val PROGRAM_LOAD_ADDRESS : UInt
     val PROGRAM_MEMTOP_ADDRESS: UInt
     val BSSHIGHRAM_START: UInt
@@ -24,11 +80,19 @@ 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
+
+    /**
+     * True when the code generator allocates subroutine locals and per-activation intermediate values
+     * in a stack frame instead of static memory, so a subroutine on a call-graph cycle can have more
+     * than one live activation. False means two live activations would share the same storage.
+     */
+    val supportsStackFrames: Boolean
 
     fun initializeMemoryAreas(compilerOptions: CompilationOptions)
     fun getFloatAsmBytes(num: Number): String
@@ -36,7 +100,12 @@ interface ICompilationTarget: IStringEncoding, IMemSizer {
     fun convertFloatToBytes(num: Double): List<UByte>
     fun convertBytesToFloat(bytes: List<UByte>): Double
 
-    fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean)
+    /**
+     * Launches an emulator to run the compiled program artifact.
+     * [programFile] is the exact artifact path including its extension; launchers must use it
+     * verbatim, without stripping or appending one.
+     */
+    fun launchEmulator(selectedEmulator: Int, programFile: Path, quiet: Boolean)
     fun isIOAddress(address: UInt): Boolean
 
     override fun encodeString(str: String, encoding: Encoding): List<UByte>

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

@@ -4,7 +4,7 @@ interface IErrorReporter {
     fun err(msg: String, position: Position)
     fun warn(msg: String, position: Position)
     fun info(msg: String, position: Position)
-    fun undefined(symbol: List<String>, position: Position)
+    fun undefined(symbol: List<String>, suggestImport: Boolean=false, position: Position)
     fun noErrors(): Boolean
     fun report()
     fun finalizeNumErrors(numErrors: Int, numWarnings: Int, numInfos: Int) {

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

@@ -1,15 +1,28 @@
 package prog8.code.core
 
 interface IMemSizer {
+    val FLOAT_MEM_SIZE: UInt
+    val POINTER_MEM_SIZE: UInt
+
+    val pointerType: DataType
+        get() = if(POINTER_MEM_SIZE > 2u) DataType.LONG else DataType.UWORD
+
+    val pointerBaseType: BaseDataType
+        get() = if(POINTER_MEM_SIZE > 2u) BaseDataType.LONG else BaseDataType.UWORD
+
     fun memorySize(dt: DataType, numElements: Int?): Int
 
     fun memorySize(dt: BaseDataType): Int {
         if(dt.isPassByRef)
-            return memorySize(DataType.UWORD, null)      // a pointer size
+            return POINTER_MEM_SIZE.toInt() 
         try {
             return memorySize(DataType.forDt(dt), null)
         } catch (x: NoSuchElementException) {
             throw IllegalArgumentException(x.message)
         }
     }
+
+    fun isSplitWordArray(dt: DataType): Boolean {
+        return dt.isSplitWordArray(this)
+    }
 }

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

@@ -28,35 +28,47 @@ 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 = mutableSetOf<UInt>()     // subclasses must set this to the appropriate free locations.
 
-    val free = mutableListOf<UInt>()     // subclasses must set this to the appropriate free locations.
+
+    /**
+     * Report a warning for every scratch byte that is excluded from allocation by a %zpreserved
+     * or %zpallowed directive. The compiler's code generators always use these fixed scratch
+     * locations internally (P8ZP_SCRATCH_*), so a %zpreserved/%zpallowed range that excludes one
+     * of them would let the compiler overwrite memory the user explicitly wants to protect.
+     */
+    fun checkScratchConflicts(errors: IErrorReporter) {
+        if(options.zeropage== ZeropageType.DONTUSE)
+            return
+
+        val scratchBytes = listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_W1, SCRATCH_W1 + 1u, SCRATCH_W2, SCRATCH_W2 + 1u, SCRATCH_PTR, SCRATCH_PTR + 1u)
+        for(byte in scratchBytes) {
+            val preserved = options.zpReserved.any { byte in it }
+            val allowed = options.zpAllowed.any { byte in it }
+            if(preserved || !allowed)
+                errors.warn("zero-page address $${byte.toString(16)} is a fixed scratch location used by the compiler (P8ZP_SCRATCH_*), but it is excluded by a %zpreserved or %zpallowed directive", Position.DUMMY)
+        }
+    }
 
     fun removeReservedFromFreePool() {
-        synchronized(this) {
-            for (reserved in options.zpReserved)
-                reserve(reserved)
+        for (reserved in options.zpReserved)
+            reserve(reserved)
 
-            free.removeAll(arrayOf(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
-    fun hasByteAvailable() = if(options.zeropage== ZeropageType.DONTUSE) false else free.isNotEmpty()
+    fun hasByteAvailable() = options.zeropage != ZeropageType.DONTUSE && free.isNotEmpty()
     fun hasWordAvailable(): Boolean {
-        if(options.zeropage== ZeropageType.DONTUSE)
-            return false
-
-        return free.windowed(2).any { it[0] == it[1] - 1u }
+        return options.zeropage != ZeropageType.DONTUSE && free.windowed(2).any { it[0] == it[1] - 1u }
     }
 
     override fun allocate(name: String,
@@ -65,7 +77,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 +107,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 +141,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,10 +1,10 @@
 package prog8.code.core
 
-val AssociativeOperators = arrayOf("+", "*", "&", "|", "^", "==", "!=", "xor")       // note: and,or are not associative because of Shortcircuit/McCarthy evaluation
-val ComparisonOperators = arrayOf("==", "!=", "<", ">", "<=", ">=")
-val LogicalOperators = arrayOf("and", "or", "xor", "not", "in")
-val BitwiseOperators = arrayOf("&", "|", "^", "~")
-val PrefixOperators = arrayOf("+", "-", "~", "not")
+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("&", "|", "^", "~")
+val PrefixOperators = setOf("+", "-", "~", "not")
 
 fun invertedComparisonOperator(operator: String) =
     when (operator) {

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

@@ -0,0 +1,80 @@
+package prog8.code.core
+
+import prog8.code.target.VMTarget
+import java.nio.file.Path
+import kotlin.io.path.extension
+import kotlin.io.path.name
+
+
+/** VICE/box16 monitor (symbol) list file name for an artifact stem. */
+fun viceMonListName(stem: String) = "$stem.vice-mon-list"
+
+
+/**
+ * Artifact stem of a user-supplied `-o` output file name.
+ * A dot at index 0 is not an extension separator: ".pgz" keeps its whole name.
+ * Only applied to `-o`; the legacy program stem (source name without extension) is used verbatim.
+ */
+fun outputStemOf(name: Path): String {
+    val filename = name.name
+    val dotIndex = filename.lastIndexOf('.')
+    return if (dotIndex <= 0) filename else filename.substring(0, dotIndex)
+}
+
+/**
+ * The final program artifact path: [CompilationOptions.outputFile] verbatim when set,
+ * otherwise [defaultName] plus the extension for [CompilationOptions.output], in [CompilationOptions.outputDir].
+ * RAW and LIBRARY both use ".bin"; AMIGAHUNK has no extension.
+ * On the virtual target the artifact is the IR file, so ".p8ir" is always enforced on -o.
+ */
+fun CompilationOptions.programFile(defaultName: String): Path {
+    // VMTarget's defaultOutputType = PRG is misleading: its artifact is the .p8ir file, never PRG.
+    // The VM identifies the IR by its extension, so -o is not verbatim here: ".p8ir" is enforced.
+    // Only the exact lowercase extension is recognized (same rule as -vm in CompilerMain).
+    if(compTarget is VMTarget) {
+        val ir = outputFile ?: return outputDir.resolve("$defaultName.p8ir")
+        return if (ir.extension=="p8ir") ir else ir.resolveSibling("${ir.name}.p8ir")
+    }
+    outputFile?.let { return it }
+    val filename = when(output) {
+        OutputType.PRG -> "$defaultName.prg"
+        OutputType.XEX -> "$defaultName.xex"
+        OutputType.RAW -> "$defaultName.bin"
+        OutputType.LIBRARY -> "$defaultName.bin"
+        OutputType.ELF -> "$defaultName.elf"
+        OutputType.AMIGAHUNK -> defaultName
+    }
+    return outputDir.resolve(filename)
+}
+
+/**
+ * Output artifact naming.
+ * Invariant: [asm] must resolve into the same directory as `CompilationOptions.outputDir`,
+ * because 64tass resolves `.binary` includes relative to the generated `.asm`.
+ */
+class OutputFiles(val programFile: Path, val stem: String, val dir: Path) {
+    fun asm() = dir.resolve("$stem.asm")
+    fun list() = dir.resolve("$stem.list")
+    fun viceMonList() = dir.resolve(viceMonListName(stem))
+    fun binFile() = dir.resolve("$stem.bin")
+    fun ir() = dir.resolve("$stem.p8ir")
+    fun bankedCalls() = dir.resolve("$stem.bankedcalls")
+    fun obj() = dir.resolve("$stem.o")
+    fun linkScript() = dir.resolve("$stem.link.ld")
+
+    companion object {
+        /**
+         * Builds the output file set. Without `-o` the stem is [defaultName] verbatim
+         * (outputStemOf is only applied to the `-o` name). With `-o` the stem is derived
+         * from the resolved artifact name, so it also covers the virtual target appending
+         * ".p8ir". [dir] is the program file's parent, or [CompilationOptions.outputDir]
+         * for a bare -o filename.
+         */
+        fun of(options: CompilationOptions, defaultName: String): OutputFiles {
+            val programFile = options.programFile(defaultName)
+            val stem = options.outputFile?.let { outputStemOf(programFile) } ?: defaultName
+            val dir = programFile.parent ?: options.outputDir
+            return OutputFiles(programFile, stem, dir)
+        }
+    }
+}

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

@@ -5,16 +5,27 @@ import prog8.code.source.SourceCode
 import java.nio.file.InvalidPathException
 import kotlin.io.path.Path
 
-data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) {
-    override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]"
+/**
+ * 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 {
         if(this===DUMMY)
             return ""
         if(SourceCode.isLibraryResource(file))
             return "$file:$line:$startCol:"
         return try {
-            val path = Path(file).sanitize().toString()
-            "file://$path:$line:$startCol:"
+            val path = Path(file).sanitize().toUri().toString()
+            "$path:$line:$startCol:"
         } catch(_: InvalidPathException) {
             // this can occur on Windows when the source origin contains "invalid" characters such as ':'
             "file://$file:$line:$startCol:"
@@ -24,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/cpu6502/ConstMultiply.kt

@@ -0,0 +1,80 @@
+package prog8.code.cpu6502
+
+// Horner ("shift-add") expansion of a multiply by a small compile-time constant, for the 6502 and
+// 65C02 backends. The runtime routines prog8_math.multiply_words / multiply_bytes cost the same
+// whatever the constant is (~442 and ~130 cycles), while this expansion costs O(bit length), so
+// for a small constant inlining wins. It generalises the hand-written prog8_math.mul_word_N /
+// mul_byte_N routines, which are themselves unrolled Horner chains (mul_word_3 is "AY = AY*2 + AY",
+// one Horner step for 11).
+//
+// The sequences live here rather than in either backend because the register bookkeeping is easy to
+// get subtly wrong and the two backends must not drift apart.
+//
+// The gate is on generated size, not on the constant's magnitude: cycles alone would argue for
+// expanding nearly every multiply and bloating every program. Budgets are the max instruction count
+// the expansion may take; the call sequence each replaces is 6 instructions.
+
+private const val WORD_BUDGET = 32
+private const val BYTE_BUDGET = 24
+
+// --- byte ---
+// Contract: A holds the multiplicand. Result in A. Only A and one scratch byte are live, so there
+// is no second register to keep in sync (unlike the word case, where a bare doubling leaves the
+// high byte stale in Y).
+
+fun byteShiftAddExpansion(value: Int): List<String>? {
+    if (value !in 3..255)
+        return null
+    val bitlen = 31 - Integer.numberOfLeadingZeros(value)
+    val popcount = Integer.bitCount(value)
+    if (1 + (bitlen-1) + 2*(popcount-1) > BYTE_BUDGET)
+        return null
+    val result = ArrayList<String>(1 + 3*bitlen)
+    result.add("sta  P8ZP_SCRATCH_REG")                     // keep x for the conditional adds
+    for (bit in (bitlen-1) downTo 0) {
+        result.add("asl  a")                                // r = r*2
+        if (value and (1 shl bit) != 0) {                   // r += x
+            result.add("clc")
+            result.add("adc  P8ZP_SCRATCH_REG")
+        }
+    }
+    return result
+}
+
+// --- word ---
+// Contract on entry: A = r.lo, Y = r.hi, P8ZP_SCRATCH_W1 = r, P8ZP_SCRATCH_W2 = x (all 16-bit,
+// little-endian: byte 0 is the low byte). On exit: A = result.lo, Y = result.hi.
+//
+// Two things this sequence must get right, both learned the hard way:
+//  * the add step must store the new high byte back to W1+1 as well as to Y. Writing it only to Y
+//    leaves W1+1 stale, and the next step's 'rol P8ZP_SCRATCH_W1+1' would then double the wrong
+//    high byte.
+//  * a trailing bare doubling (any even constant) updates A and W1+1 but not Y, so Y needs an
+//    explicit reload at the end. It cannot be 'tay', because at that point A holds the low byte.
+
+fun wordShiftAddExpansion(value: Int): List<String>? {
+    if (value < 3)
+        return null
+    val bitlen = 31 - Integer.numberOfLeadingZeros(value)
+    val popcount = Integer.bitCount(value)
+    if (1 + 2*(bitlen-1) + 7*(popcount-1) > WORD_BUDGET)
+        return null
+    val result = ArrayList<String>(2 + 9*bitlen)
+    for (bit in (bitlen-1) downTo 0) {
+        result.add("asl  a")                                // r = r*2
+        result.add("rol  P8ZP_SCRATCH_W1+1")
+        if (value and (1 shl bit) != 0) {                   // r += x
+            result.add("clc")
+            result.add("adc  P8ZP_SCRATCH_W2")
+            result.add("sta  P8ZP_SCRATCH_W1")
+            result.add("lda  P8ZP_SCRATCH_W1+1")
+            result.add("adc  P8ZP_SCRATCH_W2+1")
+            result.add("sta  P8ZP_SCRATCH_W1+1")
+            result.add("tay")
+            result.add("lda  P8ZP_SCRATCH_W1")
+        }
+    }
+    if (value and 1 == 0)
+        result.add("ldy  P8ZP_SCRATCH_W1+1")
+    return result
+}

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

@@ -3,18 +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 {
 
+    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
     }
@@ -23,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()
@@ -69,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/Amiga1200Target.kt

@@ -0,0 +1,86 @@
+package prog8.code.target
+
+import prog8.code.core.*
+import prog8.code.target.encodings.Encoder
+import prog8.code.target.zp.M68kZeropage
+import java.nio.file.Path
+
+
+class Amiga1200Target: ICompilationTarget,
+    IStringEncoding by Encoder(false),
+    IMemSizer by NormalMemSizer(4u, 4u) {
+
+    override val name = NAME
+    override val supportsBankedCalls = true
+    override val supportsStackFrames = true
+    override val defaultEncoding = Encoding.ISO
+    override val libraryPath = null
+    override val customLauncher = emptyList<String>()
+    override val additionalAssemblerOptions = emptyList<String>()
+    override val defaultOutputType = OutputType.AMIGAHUNK
+    override val defaultLauncherType = CbmPrgLauncherType.NONE
+
+    companion object {
+        const val NAME = "amiga1200"
+
+        /** needed to map bank numbers to libraries in extsub/CALLFAR library calls */
+        val LibraryNumbers = Amiga500Target.LibraryNumbers
+    }
+
+    override val cpu = CpuType.M68020
+
+    override val FLOAT_MAX_POSITIVE = Float.MAX_VALUE.toDouble()
+    override val FLOAT_MAX_NEGATIVE = -Float.MAX_VALUE.toDouble()
+    override val FLOAT_MEM_SIZE = 4u
+    override val POINTER_MEM_SIZE = 4u
+    override val ARRAY_SIZE_LIMIT = 32768u
+    override val PROGRAM_LOAD_ADDRESS = 0u      // amiga executables are relocatable
+    override val PROGRAM_MEMTOP_ADDRESS = 0xfffffffeu       // not actually used
+
+    override val BSSHIGHRAM_START = 0u          // not used
+    override val BSSHIGHRAM_END = 0u            // not used
+    override val BSSGOLDENRAM_START = 0u        // not used
+    override val BSSGOLDENRAM_END = 0u          // not used
+    override lateinit var zeropage: Zeropage
+
+    override fun getFloatAsmBytes(num: Number): String {
+        TODO("float asm bytes")
+    }
+
+    override fun convertFloatToBytes(num: Double): List<UByte> {
+        TODO("convert float to bytes")
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==4) { "need 4 bytes" }
+        TODO("convert bytes to float")
+    }
+
+    override fun launchEmulator(selectedEmulator: Int, programFile: Path, quiet: Boolean) {
+        if (selectedEmulator == 1) {
+            CopperlineEmulator.launch(programFile, quiet, "A1200", "68020", listOf("--fast", "2M", "--fpu"))
+            return
+        }
+        if (selectedEmulator != 2) {
+            System.err.println("The amiga1200 target supports FS-UAE (-emu) and Amitools's vamos (-emu2).")
+            return
+        }
+        val cpuStr = when (this.cpu) {
+            CpuType.M68000 -> "68000"
+            CpuType.M68020 -> "68020"
+            else -> error("invalid cpu type")
+        }
+        VamosEmulator.launch(programFile, quiet, cpuStr)
+        return
+    }
+
+    override fun isIOAddress(address: UInt): Boolean =
+        address in 0xbfd000u..0xbfdfffu ||             // CIA-B
+        address in 0xbfe000u..0xbfefffu ||             // CIA-A
+        address in 0xdff000u..0xdff1ffu ||             // Custom chipset (Paula, Alice, Lisa, Denise)
+        address in 0xe80000u..0xefffffu                // Zorro II autoconfig space
+
+    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
+        zeropage = M68kZeropage(compilerOptions)
+    }
+}

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

@@ -0,0 +1,126 @@
+package prog8.code.target
+
+import prog8.code.core.*
+import prog8.code.target.encodings.Encoder
+import prog8.code.target.zp.M68kZeropage
+import java.nio.file.Path
+
+
+class Amiga500Target: ICompilationTarget,
+    IStringEncoding by Encoder(false),
+    IMemSizer by NormalMemSizer(4u, 4u) {
+
+    override val name = NAME
+    override val supportsBankedCalls = true
+    override val supportsStackFrames = true
+    override val defaultEncoding = Encoding.ISO
+    override val libraryPath = null
+    override val customLauncher = emptyList<String>()
+    override val additionalAssemblerOptions = emptyList<String>()
+    override val defaultOutputType = OutputType.AMIGAHUNK
+    override val defaultLauncherType = CbmPrgLauncherType.NONE
+
+    companion object {
+        const val NAME = "amiga500"
+        
+        /** needed to map bank numbers to libraries in extsub/CALLFAR library calls */
+        val LibraryNumbers = mapOf(
+             1 to "Sys",        // exec
+             2 to "DOS",
+             3 to "Gfx",
+             4 to "Intuition",
+             5 to "GadTools",
+             6 to "Layers",
+             7 to "Asl",
+             8 to "ConsoleDevice",
+             9 to "Utility",
+            10 to "Expansion",
+            11 to "Icon",
+            12 to "Workbench",
+            13 to "Diskfont",
+            14 to "IFFParse",
+            15 to "Input",
+            16 to "Keymap",
+            17 to "Locale",
+            18 to "Timer",
+            19 to "LowLevel",
+            20 to "Math",
+            21 to "MathIeeeSingBas",
+            22 to "MathIeeeSingTrans",
+            23 to "MathIeeeDoubBas",
+            24 to "MathIeeeDoubTrans",
+            25 to "MathTrans",
+            26 to "NV",
+            27 to "RealTime",
+            28 to "Translator",
+            29 to "RexxSys",
+            30 to "Cx",
+            31 to "DataTypes",
+            32 to "Disk",
+            33 to "AmigaGuide",
+            34 to "ARexx",
+            35 to "BattClock",
+            36 to "BattMem",
+            // from here, non-standard libraries are listed
+            100 to "AsyncIO",
+            101 to "AHI",        // ahi.device base (amiga1200 target only, 68020+, used by the low-level ahi.* LVOs)
+        )
+    }
+
+    override val cpu = CpuType.M68000
+
+    override val FLOAT_MAX_POSITIVE = Float.MAX_VALUE.toDouble()
+    override val FLOAT_MAX_NEGATIVE = -Float.MAX_VALUE.toDouble()
+    override val FLOAT_MEM_SIZE = 4u
+    override val POINTER_MEM_SIZE = 4u
+    override val ARRAY_SIZE_LIMIT = 32768u
+    override val PROGRAM_LOAD_ADDRESS = 0u      // amiga executables are relocatable
+    override val PROGRAM_MEMTOP_ADDRESS = 0xfffffffeu       // not actually used
+
+    override val BSSHIGHRAM_START = 0u          // not used
+    override val BSSHIGHRAM_END = 0u            // not used
+    override val BSSGOLDENRAM_START = 0u        // not used    
+    override val BSSGOLDENRAM_END = 0u          // not used
+    override lateinit var zeropage: Zeropage
+
+    override fun getFloatAsmBytes(num: Number): String {
+        TODO("float asm bytes")
+    }
+
+    override fun convertFloatToBytes(num: Double): List<UByte> {
+        TODO("convert float to bytes")
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==4) { "need 4 bytes" }
+        TODO("convert bytes to float")
+    }
+
+    override fun launchEmulator(selectedEmulator: Int, programFile: Path, quiet: Boolean) {
+        if (selectedEmulator == 1) {
+            CopperlineEmulator.launch(programFile, quiet, "A500", "68000", listOf("--slow", "512K"))
+            return
+        }
+        if (selectedEmulator != 2) {
+            System.err.println("The amiga500 target supports FS-UAE (-emu) and Amitools's vamos (-emu2).")
+            return
+        }
+        val cpuStr = when (this.cpu) {
+            CpuType.M68000 -> "68000"
+            CpuType.M68020 -> "68020"
+            else -> error("invalid cpu type")
+        }
+        VamosEmulator.launch(programFile, quiet, cpuStr)
+        return
+    }
+
+    override fun isIOAddress(address: UInt): Boolean =
+        address in 0xbfd000u..0xbfdfffu ||             // CIA-B
+        address in 0xbfe000u..0xbfefffu ||             // CIA-A
+        address in 0xdff000u..0xdff1ffu ||             // Custom chipset (Paula, Alice, Lisa, Denise)
+        address in 0xe80000u..0xefffffu                // Zorro II autoconfig space
+
+    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
+        zeropage = M68kZeropage(compilerOptions)
+    }
+}

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

@@ -8,14 +8,17 @@ import java.nio.file.Path
 
 class C128Target: ICompilationTarget,
     IStringEncoding by Encoder(true),
-    IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE) {
+    IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE, 2u) {
 
     override val name = NAME
+    override val supportsBankedCalls = true
+    override val supportsStackFrames = 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 = "c128"
@@ -27,17 +30,17 @@ 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 POINTER_MEM_SIZE = 2u
+    override val ARRAY_SIZE_LIMIT = 256u
     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()
 
@@ -52,7 +55,7 @@ class C128Target: ICompilationTarget,
         return m5.toDouble()
     }
 
-    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+    override fun launchEmulator(selectedEmulator: Int, programFile: Path, quiet: Boolean) {
         if(selectedEmulator!=1) {
             System.err.println("The c128 target only supports the main emulator (Vice).")
             return
@@ -61,9 +64,9 @@ class C128Target: ICompilationTarget,
         if(!quiet)
             println("\nStarting C-128 emulator x128...")
 
-        val viceMonlist = C64Target.viceMonListName(programNameWithPath.toString())
-        val cmdline = listOf("x128", "-silent", "-moncommands", viceMonlist,
-            "-autostartprgmode", "1", "-autostart-warp", "-autostart", "${programNameWithPath}.prg")
+        val viceMonlist = programFile.resolveSibling(viceMonListName(outputStemOf(programFile)))
+        val cmdline = listOf("x128", "-silent", "-moncommands", viceMonlist.toString(),
+            "-autostartprgmode", "1", "-autostart-warp", "-autostart", programFile.toString())
         val processb = ProcessBuilder(cmdline)
         if(!quiet)
             processb.inheritIO()
@@ -71,11 +74,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

@@ -9,19 +9,20 @@ import java.nio.file.Path
 
 class C64Target: ICompilationTarget,
     IStringEncoding by Encoder(true),
-    IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE) {
+    IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE, 2u) {
 
     override val name = NAME
+    override val supportsBankedCalls = true
+    override val supportsStackFrames = 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 = "c64"
-
-        fun viceMonListName(baseFilename: String) = "$baseFilename.vice-mon-list"
     }
 
 
@@ -30,7 +31,8 @@ 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 POINTER_MEM_SIZE = 2u
+    override val ARRAY_SIZE_LIMIT = 256u
     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 +43,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()
 
@@ -56,7 +57,7 @@ class C64Target: ICompilationTarget,
         return m5.toDouble()
     }
 
-    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+    override fun launchEmulator(selectedEmulator: Int, programFile: Path, quiet: Boolean) {
         if(selectedEmulator!=1) {
             System.err.println("The c64 target only supports the main emulator (Vice).")
             return
@@ -66,9 +67,9 @@ class C64Target: ICompilationTarget,
             if(!quiet)
                 println("\nStarting C-64 emulator $emulator...")
 
-            val viceMonlist = viceMonListName(programNameWithPath.toString())
-            val cmdline = listOf(emulator, "-silent", "-moncommands", viceMonlist,
-                "-autostartprgmode", "1", "-autostart-warp", "-autostart", "${programNameWithPath}.prg")
+            val viceMonlist = programFile.resolveSibling(viceMonListName(outputStemOf(programFile)))
+            val cmdline = listOf(emulator, "-silent", "-moncommands", viceMonlist.toString(),
+                "-autostartprgmode", "1", "-autostart-warp", "-autostart", programFile.toString())
             val processb = ProcessBuilder(cmdline)
             if(!quiet)
                 processb.inheritIO()
@@ -87,7 +88,6 @@ class C64Target: ICompilationTarget,
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = C64Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)
     }
 
 }
@@ -98,6 +98,9 @@ val CompilationTargets = listOf(
     C128Target.NAME,
     Cx16Target.NAME,
     PETTarget.NAME,
+    Qemu68kTarget.NAME,
+    Amiga500Target.NAME,
+    Amiga1200Target.NAME,
     VMTarget.NAME
 )
 
@@ -106,6 +109,9 @@ fun getCompilationTargetByName(name: String) = when(name.lowercase()) {
     C128Target.NAME -> C128Target()
     Cx16Target.NAME -> Cx16Target()
     PETTarget.NAME -> PETTarget()
+    Qemu68kTarget.NAME -> Qemu68kTarget()
+    Amiga500Target.NAME -> Amiga500Target()
+    Amiga1200Target.NAME -> Amiga1200Target()
     VMTarget.NAME -> VMTarget()
     else -> throw IllegalArgumentException("invalid compilation target")
 }

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

@@ -4,6 +4,7 @@ import prog8.code.core.*
 import prog8.code.source.ImportFileSystem.expandTilde
 import prog8.code.target.encodings.Encoder
 import prog8.code.target.zp.ConfigurableZeropage
+import prog8.code.target.zp.M68kZeropage
 import java.io.IOException
 import java.nio.file.Path
 import java.util.*
@@ -15,19 +16,22 @@ 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 supportsStackFrames: Boolean,
     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>,
+    val varsAddress: UInt? = null,
     val ioAddresses: List<UIntRange>,
     val zpScratchB1: UInt,
     val zpScratchReg: UInt,
@@ -37,8 +41,13 @@ class ConfigFileTarget(
     val virtualregistersStart: UInt,
     val zpFullsafe: List<UIntRange>,
     val zpKernalsafe: List<UIntRange>,
-    val zpBasicsafe: List<UIntRange>
-): ICompilationTarget, IStringEncoding by Encoder(true), IMemSizer by NormalMemSizer(8) {
+    val zpBasicsafe: List<UIntRange>,
+    val pointerSize: Int = 2
+): ICompilationTarget, IStringEncoding by Encoder(true), IMemSizer by NormalMemSizer(8u, pointerSize.toUInt()) {
+
+    init {
+        require(pointerSize == 2 || pointerSize == 4) { "unsupported pointer size: $pointerSize" }
+    }
 
     companion object {
 
@@ -65,6 +74,12 @@ class ConfigFileTarget(
             return value.toUInt()
         }
 
+        private fun parsePointerSize(props: Properties): Int {
+            val pointerSize = parseInt(props.getProperty("pointer_size", "2")).toInt()
+            require(pointerSize == 2 || pointerSize == 4) { "unsupported pointer size: $pointerSize" }
+            return pointerSize
+        }
+
         private fun parseAddressRanges(key: String, props: Properties): List<UIntRange> {
             val rangesStr = props.getString(key)
             if(rangesStr.isBlank())
@@ -96,9 +111,12 @@ class ConfigFileTarget(
                 CpuType.valueOf("CPU$cpuString")
             }
             val ioAddresses = parseAddressRanges("io_regions", props)
-            val zpFullsafe = parseAddressRanges("zp_fullsafe", props)
-            val zpKernalsafe = parseAddressRanges("zp_kernalsafe", props)
-            val zpBasicsafe = parseAddressRanges("zp_basicsafe", props)
+            // The m68k has no zero page, so the zeropage settings below don't apply to an m68k
+            // target and are not required in its config file.
+            fun zpSetting(name: String) = if(cpuType.is68k) 0u else props.getInteger(name)
+            val zpFullsafe = if(cpuType.is68k) emptyList() else parseAddressRanges("zp_fullsafe", props)
+            val zpKernalsafe = if(cpuType.is68k) emptyList() else parseAddressRanges("zp_kernalsafe", props)
+            val zpBasicsafe = if(cpuType.is68k) emptyList() else parseAddressRanges("zp_basicsafe", props)
 
             val libraryPath = expandTilde(Path(props.getString("library")))
             if(!libraryPath.isDirectory())
@@ -110,34 +128,47 @@ class ConfigFileTarget(
                     (customLauncherStr+"\n").lines().map { it.trimEnd() }
                 else emptyList()
             val assemblerOptionsStr = props.getProperty("assembler_options", "").trim()
+            val pointerSize = parsePointerSize(props)
             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
+            }
+
+            val varsAddress = props.getProperty("vars_address")?.let { parseInt(it) }
 
             return ConfigFileTarget(
                 configfile.nameWithoutExtension,
+                props.getProperty("supports_banked_calls", "false").toBoolean(),
                 Encoding.entries.first { it.prefix==props.getString("encoding") },
                 cpuType,
+                props.getProperty("supports_stack_frames", cpuType.is68k.toString()).toBoolean(),
                 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(" "),
+                varsAddress,
                 ioAddresses,
-                props.getInteger("zp_scratch_b1"),
-                props.getInteger("zp_scratch_reg"),
-                props.getInteger("zp_scratch_w1"),
-                props.getInteger("zp_scratch_w2"),
-                props.getInteger("zp_scratch_ptr"),
-                props.getInteger("virtual_registers"),
+                zpSetting("zp_scratch_b1"),
+                zpSetting("zp_scratch_reg"),
+                zpSetting("zp_scratch_w1"),
+                zpSetting("zp_scratch_w2"),
+                zpSetting("zp_scratch_ptr"),
+                zpSetting("virtual_registers"),
                 zpFullsafe,
                 zpKernalsafe,
                 zpBasicsafe,
+                pointerSize,
             )
         }
     }
@@ -145,22 +176,23 @@ 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 val POINTER_MEM_SIZE = pointerSize.toUInt()
+    override val ARRAY_SIZE_LIMIT = 256u
     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")
     override fun convertBytesToFloat(bytes: List<UByte>): Double = TODO("floats")
-    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+    override fun launchEmulator(selectedEmulator: Int, programFile: Path, quiet: Boolean) {
         throw IllegalArgumentException("Custom compiler target cannot automatically launch an emulator. Do this manually.")
     }
 
     override fun isIOAddress(address: UInt): Boolean = ioAddresses.any { address in it }
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
-        zeropage = ConfigurableZeropage(
+        // the m68k has no zero page, so the zp scratch addresses in the config file don't apply there
+        zeropage = if(cpu.is68k) M68kZeropage(compilerOptions) else ConfigurableZeropage(
             zpScratchB1, zpScratchReg, zpScratchW1, zpScratchW2, zpScratchPtr,
             virtualregistersStart,
             zpBasicsafe,
@@ -168,6 +200,5 @@ class ConfigFileTarget(
             zpFullsafe,
             compilerOptions
         )
-        // note: there's no golden ram yet
     }
 }

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

@@ -0,0 +1,71 @@
+package prog8.code.target
+
+import java.io.File
+import java.nio.file.Path
+import java.nio.file.Paths
+import kotlin.io.path.copyTo
+import kotlin.io.path.createDirectories
+
+object CopperlineEmulator {
+    fun launch(programFile: Path, quiet: Boolean, model: String, cpu: String, memoryArgs: List<String>) {
+        val home = System.getProperty("user.home")
+        val sourceHdName = if (model == "A500") "Harddisk500" else "Harddisk1200"
+        val cmdDir = if (model == "A500") "c" else "C"
+        val libsDir = if (model == "A500") "libs" else "Libs"
+        val libs = listOf("diskfont.library", "iffparse.library", "lowlevel.library", "rexxsyslib.library", "asyncio.library", "icon.library")
+
+        val tempDir = Paths.get(System.getProperty("java.io.tmpdir"), "prog8-copperline-$model")
+        tempDir.createDirectories()
+        val progName = programFile.fileName.toString()
+        val stagedProg = tempDir.resolve(progName)
+        programFile.copyTo(stagedProg, overwrite = true)
+
+        val srcHd = File("$home/Documents/FS-UAE/Hard Drives/$sourceHdName")
+        if (!srcHd.isDirectory) System.err.println("Warning: source hard disk folder not found: ${srcHd}; skipping file staging.")
+        for (lib in libs) {
+            val src = File(srcHd, "$libsDir/$lib")
+            if (src.exists()) src.toPath().copyTo(tempDir.resolve(lib), overwrite = true)
+        }
+        val commands = if (model == "A500") listOf("Dir","List","Makedir","Assign","SetPatch","Mount","CPU","Echo","Avail") else listOf("Dir","List","MakeDir","Assign","SetPatch","Mount","CPU","Echo","Avail")
+        for (cmd in commands) {
+            val src = File(srcHd, "$cmdDir/$cmd")
+            if (src.exists()) src.toPath().copyTo(tempDir.resolve(cmd), overwrite = true)
+        }
+        val ramHandlerSrc = File(srcHd, "l/Ram-Handler")
+        if (model == "A500" && ramHandlerSrc.exists()) ramHandlerSrc.toPath().copyTo(tempDir.resolve("Ram-Handler"), overwrite = true)
+        val sysCfgSrc = File(srcHd, "Devs/system-configuration")
+        if (sysCfgSrc.exists()) sysCfgSrc.toPath().copyTo(tempDir.resolve("system-configuration"), overwrite = true)
+
+        val ksDirs = listOf(
+            File("${System.getProperty("user.home")}/Documents/FS-UAE/Kickstarts"),
+            File("${System.getProperty("user.home")}/Documents/Kickstarts")
+        )
+        val ksDir = ksDirs.firstOrNull { it.isDirectory } ?: ksDirs.first()
+        val candidates = ksDirs.filter { it.isDirectory }.flatMap { d -> d.listFiles()?.filter { it.name.endsWith(".rom", ignoreCase = true) && it.name.contains(model, ignoreCase = true) } ?: emptyList() }
+        val preferredVersion = if (model == "A500") "v1.3" else "v3.1"
+        val rom = candidates.firstOrNull { it.name.contains(preferredVersion, ignoreCase = true) && it.name.contains("[!", ignoreCase = true) }
+            ?: candidates.firstOrNull { it.name.contains(preferredVersion, ignoreCase = true) && !it.name.contains("[b", ignoreCase = true) && !it.name.contains("[h", ignoreCase = true) }
+            ?: candidates.firstOrNull { it.name.contains(preferredVersion, ignoreCase = true) }
+        if (rom == null) {
+            System.err.println("Warning: no Kickstart ROM for $model found in ${ksDir}; using bundled AROS.")
+        }
+        val cmd = mutableListOf(
+            "copperline",
+            "--factory",
+            "--model", model,
+            "--cpu", cpu
+        )
+        cmd.addAll(memoryArgs)
+        if (rom != null) cmd.add(rom.absolutePath)
+        cmd.addAll(listOf(
+            "--run", stagedProg.toString()
+        ))
+        if (!quiet) println("Launching Copperline...")
+        val pb = ProcessBuilder(cmd).inheritIO()
+        try {
+            pb.start().waitFor()
+        } catch (_: Exception) {
+            System.err.println("Cannot find 'copperline'. Install it from https://copperline.dev/")
+        }
+    }
+}

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

@@ -8,14 +8,17 @@ import java.nio.file.Path
 
 class Cx16Target: ICompilationTarget,
     IStringEncoding by Encoder(true),
-    IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE) {
+    IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE, 2u) {
 
     override val name = NAME
+    override val supportsBankedCalls = true
+    override val supportsStackFrames = 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 = "cx16"
@@ -27,7 +30,8 @@ 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 POINTER_MEM_SIZE = 2u
+    override val ARRAY_SIZE_LIMIT = 256u
     override val PROGRAM_LOAD_ADDRESS = 0x0801u
     override val PROGRAM_MEMTOP_ADDRESS = 0x9f00u
 
@@ -37,7 +41,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()
 
@@ -52,7 +55,7 @@ class Cx16Target: ICompilationTarget,
         return m5.toDouble()
     }
 
-    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+    override fun launchEmulator(selectedEmulator: Int, programFile: Path, quiet: Boolean) {
         val emulator: String
         val extraArgs: List<String>
 
@@ -63,7 +66,7 @@ class Cx16Target: ICompilationTarget,
             }
             2 -> {
                 emulator = "box16"
-                extraArgs = listOf("-sym", C64Target.viceMonListName(programNameWithPath.toString()))
+                extraArgs = listOf("-sym", programFile.resolveSibling(viceMonListName(outputStemOf(programFile))).toString())
             }
             else -> {
                 System.err.println("Cx16 target only supports x16emu and box16 emulators.")
@@ -74,7 +77,7 @@ class Cx16Target: ICompilationTarget,
         if(!quiet)
             println("\nStarting Commander X16 emulator $emulator...")
 
-        val cmdline = listOf(emulator, "-scale", "2", "-rtc", "-run", "-prg", "${programNameWithPath}.prg") + extraArgs
+        val cmdline = listOf(emulator, "-scale", "2", "-rtc", "-run", "-prg", programFile.toString()) + extraArgs
         val processb = ProcessBuilder(cmdline)
         if(!quiet)
             processb.inheritIO()
@@ -87,7 +90,6 @@ class Cx16Target: ICompilationTarget,
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = CX16Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, BSSGOLDENRAM_START..BSSGOLDENRAM_END)
     }
 
 

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

@@ -0,0 +1,86 @@
+package prog8.code.target
+
+import java.io.File
+import java.nio.file.Path
+import java.nio.file.Paths
+import kotlin.io.path.copyTo
+import kotlin.io.path.createDirectories
+import kotlin.io.path.writeText
+
+object FsUaeEmulator {
+    fun launch(
+        programFile: Path,
+        quiet: Boolean,
+        model: String,
+        preferredVersion: String,
+        romHint: String,
+        sourceHdName: String,
+        cmdDir: String,
+        libsDir: String,
+        commands: List<String>,
+        libs: List<String>,
+        extraFiles: List<Pair<String, String>>,
+        startupSequence: String
+    ) {
+        val home = System.getProperty("user.home")
+        val ksDir = File("$home/Documents/FS-UAE/Kickstarts")
+        val candidates = ksDir.listFiles()?.filter { it.name.endsWith(".rom", ignoreCase = true) && it.name.contains(model, ignoreCase = true) } ?: emptyList()
+        val rom = candidates.firstOrNull { it.name.contains(preferredVersion, ignoreCase = true) && it.name.contains("[!", ignoreCase = true) }
+            ?: candidates.firstOrNull { it.name.contains(preferredVersion, ignoreCase = true) && !it.name.contains("[b", ignoreCase = true) && !it.name.contains("[h", ignoreCase = true) }
+            ?: candidates.firstOrNull { it.name.contains(preferredVersion, ignoreCase = true) }
+            ?: candidates.firstOrNull { !it.name.contains("[b", ignoreCase = true) && !it.name.contains("[h", ignoreCase = true) }
+            ?: candidates.firstOrNull()
+            ?: ksDir.listFiles()?.firstOrNull { it.name.contains(romHint, ignoreCase = true) && it.name.endsWith(".rom", ignoreCase = true) }
+        if (rom == null) {
+            System.err.println("Cannot find a Kickstart ROM for $model in ${ksDir}")
+            return
+        }
+        val tempDir = Paths.get(System.getProperty("java.io.tmpdir"), "prog8-fsuae-$model")
+        tempDir.createDirectories()
+        val hdDir = tempDir.resolve("hd")
+        hdDir.resolve("S").createDirectories()
+        hdDir.resolve("C").createDirectories()
+        hdDir.resolve("L").createDirectories()
+        hdDir.resolve("Libs").createDirectories()
+        hdDir.resolve("Devs").createDirectories()
+        val progName = programFile.fileName.toString()
+        programFile.copyTo(hdDir.resolve(progName), overwrite = true)
+        val srcHd = File("$home/Documents/FS-UAE/Hard Drives/$sourceHdName")
+        for (cmd in commands) {
+            val src = File(srcHd, "$cmdDir/$cmd")
+            if (src.exists()) src.toPath().copyTo(hdDir.resolve("C/$cmd"), overwrite = true)
+        }
+        for (lib in libs) {
+            val src = File(srcHd, "$libsDir/$lib")
+            if (src.exists()) src.toPath().copyTo(hdDir.resolve("Libs/$lib"), overwrite = true)
+        }
+        for ((srcRel, dstRel) in extraFiles) {
+            val src = File(srcHd, srcRel)
+            if (src.exists()) {
+                val dst = hdDir.resolve(dstRel)
+                dst.parent.createDirectories()
+                src.toPath().copyTo(dst, overwrite = true)
+            }
+        }
+        hdDir.resolve("S/Startup-Sequence").writeText(startupSequence.replace("\$progName", progName))
+        val memoryArgs = if (model == "A500") listOf("--slow_memory=512") else listOf("--fast_memory=2048")
+        val cmd = listOf(
+            "fs-uae",
+            "--amiga_model=$model",
+            "--kickstart_file=${rom.absolutePath}",
+            "--hard_drive_0=${hdDir}",
+            "--automatic_input_grab=0",
+            "--window_width=1280",
+            "--window_height=1024",
+            "--floppy_drive_volume=8",
+            "--floppy_drive_volume_empty=8"
+        ) + memoryArgs
+        if (!quiet) println("Launching FS-UAE...")
+        val pb = ProcessBuilder(cmd).inheritIO()
+        try {
+            pb.start().waitFor()
+        } catch (_: Exception) {
+            System.err.println("Cannot find 'fs-uae'. Install it from https://fs-uae.net/")
+        }
+    }
+}

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

@@ -9,7 +9,7 @@ data class Mflpt5(val b0: UByte, val b1: UByte, val b2: UByte, val b3: UByte, va
     companion object {
         const val FLOAT_MAX_POSITIVE = 1.7014118345e+38         // bytes: 255,127,255,255,255
         const val FLOAT_MAX_NEGATIVE = -1.7014118345e+38        // bytes: 255,255,255,255,255
-        const val FLOAT_MEM_SIZE = 5
+        const val FLOAT_MEM_SIZE = 5u
 
         val zero = Mflpt5(0u, 0u, 0u, 0u, 0u)
         fun fromNumber(num: Number): Mflpt5 {
@@ -19,7 +19,7 @@ data class Mflpt5(val b0: UByte, val b1: UByte, val b2: UByte, val b3: UByte, va
 
             val flt = num.toDouble()
             if (flt !in FLOAT_MAX_NEGATIVE..FLOAT_MAX_POSITIVE)
-                throw InternalCompilerException("floating point number out of 5-byte mflpt range: $this")
+                throw InternalCompilerException("floating point number out of 5-byte mflpt range: $flt")
             if (flt == 0.0)
                 return zero
 
@@ -40,7 +40,7 @@ data class Mflpt5(val b0: UByte, val b1: UByte, val b2: UByte, val b3: UByte, va
 
             return when {
                 exponent < 0 -> zero  // underflow, use zero instead
-                exponent > 255 -> throw InternalCompilerException("floating point overflow: $this")
+                exponent > 255 -> throw InternalCompilerException("floating point overflow: $flt")
                 exponent == 0 -> zero
                 else -> {
                     val mantLong = mantissa.toLong()
@@ -73,4 +73,4 @@ data class Mflpt5(val b0: UByte, val b1: UByte, val b2: UByte, val b3: UByte, va
         val b4 = "$" + b4.toString(16).padStart(2, '0')
         return "$b0, $b1, $b2, $b3, $b4"
     }
-}
+}

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

@@ -4,35 +4,42 @@ import prog8.code.core.BaseDataType
 import prog8.code.core.DataType
 import prog8.code.core.IMemSizer
 
-internal class NormalMemSizer(val floatsize: Int): IMemSizer {
+internal class NormalMemSizer(override val FLOAT_MEM_SIZE: UInt, override val POINTER_MEM_SIZE: UInt): IMemSizer {
 
+    private val pointerSize = POINTER_MEM_SIZE.toInt()
+    private val floatSize = FLOAT_MEM_SIZE.toInt()
+    
     override fun memorySize(dt: DataType, numElements: Int?): Int {
         if(dt.isPointerArray)
-            return 2 * numElements!!        // array of pointers is just array of uwords
+            return pointerSize * numElements!!        // array of pointers
         else if(dt.isArray) {
-            if(numElements==null) return 2      // treat it as a pointer size
+            if(numElements==null) return pointerSize      // treat it as a pointer size
             return when(dt.sub) {
                 BaseDataType.BOOL, BaseDataType.UBYTE, BaseDataType.BYTE -> numElements
-                BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.STR -> numElements * 2
-                BaseDataType.FLOAT-> numElements * floatsize
+                BaseDataType.UWORD, BaseDataType.WORD  -> numElements * 2
+                BaseDataType.STR, BaseDataType.POINTER -> numElements * pointerSize
+                BaseDataType.LONG -> numElements * 4
+                BaseDataType.FLOAT-> numElements * floatSize
+                BaseDataType.STRUCT_INSTANCE -> numElements * (dt.subType?.memsize(this) ?: throw IllegalArgumentException("struct instance array has unresolved subtype"))
                 BaseDataType.UNDEFINED -> throw IllegalArgumentException("undefined has no memory size")
                 else -> throw IllegalArgumentException("invalid sub type")
             }
         }
         else if (dt.isString) {
             return numElements        // treat it as the size of the given string with the length
-                ?: 2    // treat it as the size to store a string pointer
+                ?: pointerSize    // treat it as the size to store a string pointer
         }
 
         return when {
             dt.isByteOrBool -> 1 * (numElements ?: 1)
-            dt.isFloat -> floatsize * (numElements ?: 1)
+            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.isWord -> 2 * (numElements ?: 1)
+            dt.isPointer -> pointerSize * (numElements ?: 1)
+            dt.isStructInstance -> dt.subType?.memsize(this) ?: throw IllegalArgumentException("struct instance has unresolved subtype")
             dt.isUndefined -> throw IllegalArgumentException("undefined has no memory size")
-            else -> 2 * (numElements ?: 1)
+            else -> throw IllegalArgumentException("invalid dt $dt")
         }
     }
 
-}
+}

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

@@ -8,14 +8,17 @@ import java.nio.file.Path
 
 class PETTarget: ICompilationTarget,
     IStringEncoding by Encoder(true),
-    IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE) {
+    IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE, 2u) {
 
     override val name = NAME
+    override val supportsBankedCalls = false
+    override val supportsStackFrames = 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"
@@ -26,7 +29,8 @@ 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 POINTER_MEM_SIZE = 2u
+    override val ARRAY_SIZE_LIMIT = 256u
     override val PROGRAM_LOAD_ADDRESS = 0x0401u
     override val PROGRAM_MEMTOP_ADDRESS = 0x8000u
 
@@ -36,7 +40,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()
 
@@ -51,7 +54,7 @@ class PETTarget: ICompilationTarget,
         return m5.toDouble()
     }
 
-    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+    override fun launchEmulator(selectedEmulator: Int, programFile: Path, quiet: Boolean) {
         if(selectedEmulator!=1) {
             System.err.println("The pet target only supports the main emulator (Vice).")
             return
@@ -60,9 +63,9 @@ class PETTarget: ICompilationTarget,
         if(!quiet)
             println("\nStarting PET emulator...")
 
-        val viceMonlist = C64Target.viceMonListName(programNameWithPath.toString())
-        val cmdline = listOf("xpet", "-model", "4032", "-ramsize", "32", "-videosize", "40", "-silent", "-moncommands", viceMonlist,
-            "-autostartprgmode", "1", "-autostart-warp", "-autostart", "${programNameWithPath}.prg")
+        val viceMonlist = programFile.resolveSibling(viceMonListName(outputStemOf(programFile)))
+        val cmdline = listOf("xpet", "-model", "4032", "-ramsize", "32", "-videosize", "40", "-silent", "-moncommands", viceMonlist.toString(),
+            "-autostartprgmode", "1", "-autostart-warp", "-autostart", programFile.toString())
         val processb = ProcessBuilder(cmdline)
         if(!quiet)
             processb.inheritIO()
@@ -74,7 +77,6 @@ class PETTarget: ICompilationTarget,
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = PETZeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)
     }
 
 }

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

@@ -0,0 +1,99 @@
+package prog8.code.target
+
+import prog8.code.core.*
+import prog8.code.target.encodings.Encoder
+import prog8.code.target.zp.M68kZeropage
+import java.nio.file.Path
+
+/**
+ * For now target a m68020 cpu
+ * Eventually the goal is to be able to create programs for the Amiga A1200 (68020 cpu) or A500 (68000 cpu)
+ */
+
+class Qemu68kTarget: ICompilationTarget,
+    IStringEncoding by Encoder(false),
+    IMemSizer by NormalMemSizer(4u, 4u) {
+
+    override val name = NAME
+    override val supportsBankedCalls = false
+    override val supportsStackFrames = true
+    override val defaultEncoding = Encoding.ISO
+    override val libraryPath = null
+    override val customLauncher = emptyList<String>()
+    override val additionalAssemblerOptions = emptyList<String>()
+    override val defaultOutputType = OutputType.ELF
+    override val defaultLauncherType = CbmPrgLauncherType.NONE
+
+    companion object {
+        const val NAME = "qemu68k"
+    }
+
+    override val cpu = CpuType.M68020
+
+    override val FLOAT_MAX_POSITIVE = Float.MAX_VALUE.toDouble()
+    override val FLOAT_MAX_NEGATIVE = -Float.MAX_VALUE.toDouble()
+    override val FLOAT_MEM_SIZE = 4u
+    override val POINTER_MEM_SIZE = 4u
+    override val ARRAY_SIZE_LIMIT = 32768u
+    override val PROGRAM_LOAD_ADDRESS = 0x10000u      
+    override val PROGRAM_MEMTOP_ADDRESS = 0x00100000u       // TODO hardcoded at 1 Mb of RAM for now... it starts at $0
+
+    override val BSSHIGHRAM_START = 0u          // not actually used
+    override val BSSHIGHRAM_END = 0u            // not actually used
+    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 fun getFloatAsmBytes(num: Number): String {
+        TODO("float asm bytes")
+    }
+
+    override fun convertFloatToBytes(num: Double): List<UByte> {
+        TODO("convert float to bytes")
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==4) { "need 4 bytes" }
+        TODO("convert bytes to float")
+    }
+
+    override fun launchEmulator(selectedEmulator: Int, programFile: Path, quiet: Boolean) {
+        if(selectedEmulator!=1) {
+            System.err.println("The qemu68k target only supports the main emulator (Qemu).")
+            return
+        }
+        if(!programFile.toFile().exists()) {
+            System.err.println("No program file found: $programFile")
+            return
+        }
+        val cpuStr = this.cpu.toString().lowercase()
+
+        val cmd = listOf(
+            "qemu-system-m68k",
+            "-M", "virt",
+            "-cpu", cpuStr,
+            "-m", "1M",
+            "-kernel", programFile.toString(),
+            "-nographic"
+        )
+        if(!quiet) {
+            println("Launching QEMU (press Ctrl-A X to exit)...")
+        }
+        val pb = ProcessBuilder(cmd).inheritIO()
+        try {
+            pb.start().waitFor()
+        } catch (_: java.io.IOException) {
+            System.err.println("Cannot launch qemu-system-m68k. Install it via your package manager, e.g.:")
+            System.err.println("  sudo apt install qemu-system-m68k       # Debian/Ubuntu")
+            System.err.println("  sudo pacman -S qemu-system-m68k         # Arch Linux")
+            System.err.println("or build it from source: https://www.qemu.org/download/")
+        }
+    }
+
+    override fun isIOAddress(address: UInt): Boolean = address>=0xff000000u
+
+    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
+        zeropage = M68kZeropage(compilerOptions)
+    }
+}
+

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

@@ -3,42 +3,44 @@ package prog8.code.target
 import prog8.code.core.*
 import prog8.code.target.encodings.Encoder
 import java.nio.file.Path
-import kotlin.io.path.extension
 import kotlin.io.path.isReadable
-import kotlin.io.path.name
 import kotlin.io.path.readText
 
 class VMTarget: ICompilationTarget,
     IStringEncoding by Encoder(false),
-    IMemSizer by NormalMemSizer(FLOAT_MEM_SIZE) {
+    IMemSizer by NormalMemSizer(8u, 4u) {
 
     override val name = NAME
+    override val supportsBankedCalls = false
+    override val supportsStackFrames = 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"
-        const val FLOAT_MEM_SIZE = 8             // 64-bits double
+        const val RAM_SIZE = 16 * 1024 * 1024   // 16 MB
     }
 
     override val cpu = CpuType.VIRTUAL
 
     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 PROGRAM_LOAD_ADDRESS = 0u      // not actually used
-    override val PROGRAM_MEMTOP_ADDRESS = 0xffffu  // not actually used
+    override val FLOAT_MEM_SIZE = 8u
+    override val POINTER_MEM_SIZE = 4u
+    override val ARRAY_SIZE_LIMIT = 65535u
+
+    override val PROGRAM_LOAD_ADDRESS = 0u
+    override val PROGRAM_MEMTOP_ADDRESS = 0xffffffu
 
     override val BSSHIGHRAM_START = 0u          // not actually used
     override val BSSHIGHRAM_END = 0u            // not actually used
     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
@@ -68,31 +70,37 @@ class VMTarget: ICompilationTarget,
         return Double.fromBits(b0 or b1 or b2 or b3 or b4 or b5 or b6 or b7)
     }
 
-    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+    override fun launchEmulator(selectedEmulator: Int, programFile: Path, quiet: Boolean) {
+        launchEmulatorWithTrace(programFile, quiet, traceEnabled = false)
+    }
+
+    /**
+     * Runs the given .p8ir file in the embedded virtual machine.
+     * The caller must pass the exact path; no fallback probing happens here, the -vm CLI flow resolves a bare name itself.
+     */
+    fun launchEmulatorWithTrace(programFile: Path, quiet: Boolean, traceEnabled: Boolean) {
         if(!quiet)
             println("\nStarting Virtual Machine...")
 
         // to not have external module dependencies in our own module, we launch the virtual machine via reflection
         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)
+        if(programFile.isReadable())
+            vm.runProgram(programFile.readText(), quiet, traceEnabled)
         else
-            throw java.nio.file.NoSuchFileException(withExt.name, null, "not a .p8ir file")
+            throw java.nio.file.NoSuchFileException(programFile.toString(), null, "not a .p8ir file")
     }
 
     override fun isIOAddress(address: UInt): Boolean = false
 
     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/VamosEmulator.kt

@@ -0,0 +1,16 @@
+package prog8.code.target
+
+import java.nio.file.Path
+
+object VamosEmulator {
+    fun launch(programFile: Path, quiet: Boolean, cpu: String) {
+        val cmd = listOf("vamos", "--cpu", cpu, programFile.toString())
+        if (!quiet) println("Launching Amitools's Vamos...")
+        val pb = ProcessBuilder(cmd).inheritIO()
+        try {
+            pb.start().waitFor()
+        } catch (_: Exception) {
+            System.err.println("Cannot find 'vamos' (Amitools's Amiga emulator). Install it from: https://github.com/cnvogelg/amitools")
+        }
+    }
+}

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

@@ -1,9 +1,6 @@
 package prog8.code.target.zp
 
-import prog8.code.core.CompilationOptions
-import prog8.code.core.InternalCompilerException
-import prog8.code.core.Zeropage
-import prog8.code.core.ZeropageType
+import prog8.code.core.*
 
 
 // reference: "Mapping the C128" zeropage chapter.
@@ -46,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
@@ -64,6 +61,43 @@ class C128Zeropage(options: CompilationOptions) : Zeropage(options) {
         free.addAll(distinctFree)
 
         removeReservedFromFreePool()
+
+        if(options.zeropage==ZeropageType.FULL || options.zeropage==ZeropageType.KERNALSAFE) {
+            // 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()
+        }
+        
         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)
+        val base = 0x0a     // Unfortunately it cannot be the same as on the Commander X16 ($02).
+        for(reg in 0..15) {
+            allocatedVariables["cx16.r${reg}"]   = VarAllocation((base+reg*2).toUInt(), DataType.UWORD, 2)       // cx16.r0 .. cx16.r15
+            allocatedVariables["cx16.r${reg}s"]  = VarAllocation((base+reg*2).toUInt(), DataType.WORD, 2)        // cx16.r0s .. cx16.r15s
+            allocatedVariables["cx16.r${reg}L"]  = VarAllocation((base+reg*2).toUInt(), DataType.UBYTE, 1)       // cx16.r0L .. cx16.r15L
+            allocatedVariables["cx16.r${reg}H"]  = VarAllocation((base+1+reg*2).toUInt(), DataType.UBYTE, 1)     // cx16.r0H .. cx16.r15H
+            allocatedVariables["cx16.r${reg}sL"] = VarAllocation((base+reg*2).toUInt(), DataType.BYTE, 1)        // cx16.r0sL .. cx16.r15sL
+            allocatedVariables["cx16.r${reg}sH"] = VarAllocation((base+1+reg*2).toUInt(), DataType.BYTE, 1)      // cx16.r0sH .. cx16.r15sH
+            allocatedVariables["cx16.r${reg}bL"] = VarAllocation((base+reg*2).toUInt(), DataType.BOOL, 1)        // cx16.r0bL .. cx16.r15bL
+            allocatedVariables["cx16.r${reg}bH"] = VarAllocation((base+1+reg*2).toUInt(), DataType.BOOL, 1)      // cx16.r0bH .. cx16.r15bH
+            free.remove((base+reg*2).toUInt())
+            free.remove((base+1+reg*2).toUInt())
+        }
+
+        // 32 bits combined register pairs cx16.r0r1 .. cx16.r14r15
+        allocatedVariables["cx16.r0r1sl"]   = VarAllocation((base+0*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r2r3sl"]   = VarAllocation((base+1*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r4r5sl"]   = VarAllocation((base+2*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r6r7sl"]   = VarAllocation((base+3*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r8r9sl"]   = VarAllocation((base+4*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r10r11sl"] = VarAllocation((base+5*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r12r13sl"] = VarAllocation((base+6*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r14r15sl"] = VarAllocation((base+7*4).toUInt(), DataType.LONG, 4)
+    }
 }

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()
         }
 
@@ -83,16 +86,28 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
         // 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)
-        // The base addres is $04.  Unfortunately it cannot be the same as on the Commander X16 ($02).
+        val base = 0x04     // Unfortunately it cannot be the same as on the Commander X16 ($02).
         for(reg in 0..15) {
-            allocatedVariables["cx16.r${reg}"]   = VarAllocation((4+reg*2).toUInt(), DataType.UWORD, 2)       // cx16.r0 .. cx16.r15
-            allocatedVariables["cx16.r${reg}s"]  = VarAllocation((4+reg*2).toUInt(), DataType.WORD, 2)        // cx16.r0s .. cx16.r15s
-            allocatedVariables["cx16.r${reg}L"]  = VarAllocation((4+reg*2).toUInt(), DataType.UBYTE, 1)       // cx16.r0L .. cx16.r15L
-            allocatedVariables["cx16.r${reg}H"]  = VarAllocation((5+reg*2).toUInt(), DataType.UBYTE, 1)       // cx16.r0H .. cx16.r15H
-            allocatedVariables["cx16.r${reg}sL"] = VarAllocation((4+reg*2).toUInt(), DataType.BYTE, 1)        // cx16.r0sL .. cx16.r15sL
-            allocatedVariables["cx16.r${reg}sH"] = VarAllocation((5+reg*2).toUInt(), DataType.BYTE, 1)        // cx16.r0sH .. cx16.r15sH
-            free.remove((4+reg*2).toUInt())
-            free.remove((5+reg*2).toUInt())
+            allocatedVariables["cx16.r${reg}"]   = VarAllocation((base+reg*2).toUInt(), DataType.UWORD, 2)       // cx16.r0 .. cx16.r15
+            allocatedVariables["cx16.r${reg}s"]  = VarAllocation((base+reg*2).toUInt(), DataType.WORD, 2)        // cx16.r0s .. cx16.r15s
+            allocatedVariables["cx16.r${reg}L"]  = VarAllocation((base+reg*2).toUInt(), DataType.UBYTE, 1)       // cx16.r0L .. cx16.r15L
+            allocatedVariables["cx16.r${reg}H"]  = VarAllocation((base+1+reg*2).toUInt(), DataType.UBYTE, 1)     // cx16.r0H .. cx16.r15H
+            allocatedVariables["cx16.r${reg}sL"] = VarAllocation((base+reg*2).toUInt(), DataType.BYTE, 1)        // cx16.r0sL .. cx16.r15sL
+            allocatedVariables["cx16.r${reg}sH"] = VarAllocation((base+1+reg*2).toUInt(), DataType.BYTE, 1)      // cx16.r0sH .. cx16.r15sH
+            allocatedVariables["cx16.r${reg}bL"] = VarAllocation((base+reg*2).toUInt(), DataType.BOOL, 1)        // cx16.r0bL .. cx16.r15bL
+            allocatedVariables["cx16.r${reg}bH"] = VarAllocation((base+1+reg*2).toUInt(), DataType.BOOL, 1)      // cx16.r0bH .. cx16.r15bH
+            free.remove((base+reg*2).toUInt())
+            free.remove((base+1+reg*2).toUInt())
         }
+
+        // 32 bits combined register pairs cx16.r0r1 .. cx16.r14r15
+        allocatedVariables["cx16.r0r1sl"]   = VarAllocation((base+0*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r2r3sl"]   = VarAllocation((base+1*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r4r5sl"]   = VarAllocation((base+2*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r6r7sl"]   = VarAllocation((base+3*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r8r9sl"]   = VarAllocation((base+4*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r10r11sl"] = VarAllocation((base+5*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r12r13sl"] = VarAllocation((base+6*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r14r15sl"] = VarAllocation((base+7*4).toUInt(), DataType.LONG, 4)
     }
 }

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
@@ -64,6 +70,19 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
             allocatedVariables["cx16.r${reg}H"]  = VarAllocation((3+reg*2).toUInt(), DataType.UBYTE, 1)       // cx16.r0H .. cx16.r15H
             allocatedVariables["cx16.r${reg}sL"] = VarAllocation((2+reg*2).toUInt(), DataType.BYTE, 1)        // cx16.r0sL .. cx16.r15sL
             allocatedVariables["cx16.r${reg}sH"] = VarAllocation((3+reg*2).toUInt(), DataType.BYTE, 1)        // cx16.r0sH .. cx16.r15sH
+            allocatedVariables["cx16.r${reg}bL"] = VarAllocation((2+reg*2).toUInt(), DataType.BOOL, 1)       // cx16.r0bL .. cx16.r15bL
+            allocatedVariables["cx16.r${reg}bH"] = VarAllocation((3+reg*2).toUInt(), DataType.BOOL, 1)       // cx16.r0bH .. cx16.r15bH
         }
+
+        // 32 bits combined register pairs cx16.r0r1 .. cx16.r14r15
+        allocatedVariables["cx16.r0r1sl"]   = VarAllocation((2+0*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r2r3sl"]   = VarAllocation((2+1*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r4r5sl"]   = VarAllocation((2+2*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r6r7sl"]   = VarAllocation((2+3*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r8r9sl"]   = VarAllocation((2+4*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r10r11sl"] = VarAllocation((2+5*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r12r13sl"] = VarAllocation((2+6*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r14r15sl"] = VarAllocation((2+7*4).toUInt(), DataType.LONG, 4)
+
     }
 }

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

@@ -57,7 +57,24 @@ class ConfigurableZeropage(
                 allocatedVariables["cx16.r${reg}H"]  = VarAllocation(address+1u, DataType.UBYTE, 1)    // cx16.r0H .. cx16.r15H
                 allocatedVariables["cx16.r${reg}sL"] = VarAllocation(address, DataType.BYTE, 1)        // cx16.r0sL .. cx16.r15sL
                 allocatedVariables["cx16.r${reg}sH"] = VarAllocation(address+1u, DataType.BYTE, 1)     // cx16.r0sH .. cx16.r15sH
+                allocatedVariables["cx16.r${reg}bL"] = VarAllocation(address, DataType.BOOL, 1)        // cx16.r0bL .. cx16.r15bL
+                allocatedVariables["cx16.r${reg}bH"] = VarAllocation(address+1u, DataType.BOOL, 1)     // cx16.r0bH .. cx16.r15bH
+                free.remove(address)
+                free.remove(address+1u)
             }
         }
+
+        if(virtualRegistersStart<0xffu) {
+            // 32 bits combined register pairs cx16.r0r1 .. cx16.r14r15
+            val start = virtualRegistersStart.toInt()
+            allocatedVariables["cx16.r0r1sl"] = VarAllocation((start + 0 * 4).toUInt(), DataType.LONG, 4)
+            allocatedVariables["cx16.r2r3sl"] = VarAllocation((start + 1 * 4).toUInt(), DataType.LONG, 4)
+            allocatedVariables["cx16.r4r5sl"] = VarAllocation((start + 2 * 4).toUInt(), DataType.LONG, 4)
+            allocatedVariables["cx16.r6r7sl"] = VarAllocation((start + 3 * 4).toUInt(), DataType.LONG, 4)
+            allocatedVariables["cx16.r8r9sl"] = VarAllocation((start + 4 * 4).toUInt(), DataType.LONG, 4)
+            allocatedVariables["cx16.r10r11sl"] = VarAllocation((start + 5 * 4).toUInt(), DataType.LONG, 4)
+            allocatedVariables["cx16.r12r13sl"] = VarAllocation((start + 6 * 4).toUInt(), DataType.LONG, 4)
+            allocatedVariables["cx16.r14r15sl"] = VarAllocation((start + 7 * 4).toUInt(), DataType.LONG, 4)
+        }
     }
 }

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

@@ -0,0 +1,21 @@
+package prog8.code.target.zp
+
+import prog8.code.core.CompilationOptions
+import prog8.code.core.Zeropage
+
+/**
+ * The m68k has no zero page, so there are no scratch locations to hand out.
+ * Any attempt to use one is a bug in the code generator.
+ */
+class M68kZeropage(options: CompilationOptions): Zeropage(options) {
+    override val SCRATCH_B1: UInt
+        get() = throw IllegalStateException("m68k shouldn't use this zeropage variable")
+    override val SCRATCH_REG: UInt
+        get() = throw IllegalStateException("m68k shouldn't use this zeropage variable")
+    override val SCRATCH_W1: UInt
+        get() = throw IllegalStateException("m68k shouldn't use this zeropage variable")
+    override val SCRATCH_W2: UInt
+        get() = throw IllegalStateException("m68k shouldn't use this zeropage variable")
+    override val SCRATCH_PTR: UInt
+        get() = throw IllegalStateException("m68k shouldn't use this zeropage variable")
+}

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

@@ -1,9 +1,6 @@
 package prog8.code.target.zp
 
-import prog8.code.core.CompilationOptions
-import prog8.code.core.InternalCompilerException
-import prog8.code.core.Zeropage
-import prog8.code.core.ZeropageType
+import prog8.code.core.*
 
 
 // reference: http://www.zimmers.net/cbmpics/cbm/PETx/petmem.txt
@@ -35,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
@@ -47,6 +47,43 @@ class PETZeropage(options: CompilationOptions) : Zeropage(options) {
         free.addAll(distinctFree)
 
         removeReservedFromFreePool()
+
+        if(options.zeropage==ZeropageType.FULL || options.zeropage==ZeropageType.KERNALSAFE) {
+            // 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()
+        }
+
         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)
+        val base = 0x04     // Unfortunately it cannot be the same as on the Commander X16 ($02).  TODO: is this valid on PET?
+        for(reg in 0..15) {
+            allocatedVariables["cx16.r${reg}"]   = VarAllocation((base+reg*2).toUInt(), DataType.UWORD, 2)       // cx16.r0 .. cx16.r15
+            allocatedVariables["cx16.r${reg}s"]  = VarAllocation((base+reg*2).toUInt(), DataType.WORD, 2)        // cx16.r0s .. cx16.r15s
+            allocatedVariables["cx16.r${reg}L"]  = VarAllocation((base+reg*2).toUInt(), DataType.UBYTE, 1)       // cx16.r0L .. cx16.r15L
+            allocatedVariables["cx16.r${reg}H"]  = VarAllocation((base+1+reg*2).toUInt(), DataType.UBYTE, 1)     // cx16.r0H .. cx16.r15H
+            allocatedVariables["cx16.r${reg}sL"] = VarAllocation((base+reg*2).toUInt(), DataType.BYTE, 1)        // cx16.r0sL .. cx16.r15sL
+            allocatedVariables["cx16.r${reg}sH"] = VarAllocation((base+1+reg*2).toUInt(), DataType.BYTE, 1)      // cx16.r0sH .. cx16.r15sH
+            allocatedVariables["cx16.r${reg}bL"] = VarAllocation((base+reg*2).toUInt(), DataType.BOOL, 1)        // cx16.r0bL .. cx16.r15bL
+            allocatedVariables["cx16.r${reg}bH"] = VarAllocation((base+1+reg*2).toUInt(), DataType.BOOL, 1)      // cx16.r0bH .. cx16.r15bH
+            free.remove((base+reg*2).toUInt())
+            free.remove((base+1+reg*2).toUInt())
+        }
+
+        // 32 bits combined register pairs cx16.r0r1 .. cx16.r14r15
+        allocatedVariables["cx16.r0r1sl"]   = VarAllocation((base+0*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r2r3sl"]   = VarAllocation((base+1*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r4r5sl"]   = VarAllocation((base+2*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r6r7sl"]   = VarAllocation((base+3*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r8r9sl"]   = VarAllocation((base+4*4).toUInt(), DataType.LONG, 4)
+        allocatedVariables["cx16.r10r11sl"] = VarAllocation((base+5*4).toUInt(), DataType.LONG, 4)
+        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,72 @@
+package prog8tests.helpers
+
+import prog8.code.core.*
+
+
+/**
+ * Dummy IMemSizer implementation for testing.
+ * Returns standard memory sizes for all data types.
+ */
+object DummyMemsizer : IMemSizer {
+    override val FLOAT_MEM_SIZE: UInt = 4u
+    override val POINTER_MEM_SIZE: UInt = 2u
+
+    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
+                BaseDataType.POINTER -> numElements * 2
+                BaseDataType.STRUCT_INSTANCE -> numElements * (dt.subType?.memsize(this) ?: throw IllegalArgumentException("struct instance array has unresolved subtype"))
+                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,45 +3,61 @@ 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)
     }
 
-    override fun undefined(symbol: List<String>, position: Position) {
+    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 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/TestConfigFileTarget.kt

@@ -0,0 +1,66 @@
+package prog8tests.codecore
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import prog8.code.core.BaseDataType
+import prog8.code.target.ConfigFileTarget
+import java.nio.file.Files
+import kotlin.io.path.writeText
+
+class TestConfigFileTarget: FunSpec({
+    fun loadTarget(extraProperties: String = ""): ConfigFileTarget {
+        val directory = Files.createTempDirectory("prog8-config-target")
+        val library = Files.createDirectories(directory.resolve("library"))
+        val config = directory.resolve("target.properties")
+        config.writeText(
+            """
+            cpu = 65C02
+            encoding = iso
+            load_address = 2048
+            memtop = 65535
+            bss_highram_start = 0
+            bss_highram_end = 0
+            bss_goldenram_start = 0
+            bss_goldenram_end = 0
+            zp_scratch_b1 = 240
+            zp_scratch_reg = 241
+            zp_scratch_w1 = 242
+            zp_scratch_w2 = 244
+            zp_scratch_ptr = 246
+            virtual_registers = 2
+            zp_fullsafe = 34-239
+            zp_kernalsafe = 34-239
+            zp_basicsafe = 34-239
+            io_regions =
+            """.trimIndent() + "\nlibrary = $library\n$extraProperties"
+        )
+        return try {
+            ConfigFileTarget.fromConfigFile(config)
+        } finally {
+            directory.toFile().deleteRecursively()
+        }
+    }
+
+    test("legacy config defaults to 2-byte pointers and 256 element arrays") {
+        val target = loadTarget()
+
+        target.POINTER_MEM_SIZE shouldBe 2u
+        target.memorySize(BaseDataType.POINTER) shouldBe 2
+        target.ARRAY_SIZE_LIMIT shouldBe 256u
+    }
+
+    test("config supports 4-byte pointers") {
+        val target = loadTarget("pointer_size = 4")
+
+        target.POINTER_MEM_SIZE shouldBe 4u
+        target.memorySize(BaseDataType.POINTER) shouldBe 4
+        target.ARRAY_SIZE_LIMIT shouldBe 256u
+    }
+
+    test("config rejects unsupported pointer sizes") {
+        shouldThrow<IllegalArgumentException> {
+            loadTarget("pointer_size = 3")
+        }
+    }
+})