diff --git a/STATUS.md b/STATUS.md index 290d553..4acd433 100644 --- a/STATUS.md +++ b/STATUS.md @@ -14,9 +14,16 @@ which runs correctly under MAME (apple2gs). (signed and unsigned). Carry-chained multi-word ops via ADC/SBC pseudos + ASLA16 / shift libcalls. - Comparisons and signed/unsigned widening (sext, zext, trunc) for all - the above sizes. + the above sizes. Signed compare near INT_MIN handled via EOR-with- + sign-bit transform. - Pointer arithmetic, array indexing, struct field access, struct return-by-value (up to 8 bytes — Pair, Vec4, double). +- Pointer dereference (`*p`) lowers via `LDAptr / STAptr / STBptr` + to `[$E0],Y` indirect-LONG with the bank byte at `$E2` forced to 0 + — DBR-independent, so `pha;plb` bank-switched callers don't corrupt + data through callee local-pointer writes. Const-int pointers + (`*(volatile uint16 *)0x5000 = v` MMIO idiom) lower to `STAabs` + (DBR-relative) so bank-2 writes still work. - Bitfields, switch statements (verified up to ~12 cases + default), function pointers, function-pointer tables, indirect calls via `__jsl_indir` trampoline. @@ -25,14 +32,15 @@ which runs correctly under MAME (apple2gs). - Loops with goto / break / continue, nested loops, state machines. - `` varargs with int / long / unsigned long long mixed args. - Heap: `malloc` / `free` (libc.c first-fit allocator) — linked-list - reverse with `cons` works. + reverse with `cons` works; free-list coalesce verified. - Strings: hand-rolled `strlen`, `strcmp`, `strcpy`, `strchr`, atoi/itoa roundtrip. - Soft-float (single): all four ops + comparisons, MAME-verified. - Soft-double: add, sub, mul, div all return correct bit patterns bit-for-bit against gcc with round-to-nearest-even rounding; - 3-iter Newton sqrt converges. Long-running iterations may hit MAME's - 1-second sim-time budget (test config issue, not a compiler bug). + 3-iter Newton sqrt converges. Compiles at -O2 throughout. Long- + running iterations may hit MAME's 1-second sim-time budget (test + config issue, not a compiler bug). - Inline assembly with `"a"`, `"x"`, `"y"` register constraints and arbitrary opcode bytes (used for the `pha;plb` bank-switch idiom). - C++ minimal: clang++ compiles a class with virtual + non-trivial @@ -43,22 +51,41 @@ which runs correctly under MAME (apple2gs). C99 truncation semantics for snprintf. `%.Nf` produces the correct fractional digits with round-half-up. - qsort + bsearch over arbitrary element size with a user `cmp` - callback (insertion-sort variant — sidesteps the greedy regalloc - bug in the recursive iterative-qsort form). + callback. - Standard string/stdlib glue: strcat, strncat, strpbrk, strspn, strcspn, atol, llabs (kept in their own translation unit so vprintf's branch layout doesn't shift). - ``: fabs, floor, ceil, fmod, copysign, sqrt, pow, - sin, cos, exp, log, atan, atan2, asin, acos, sinh, cosh, tanh - (and float variants). Bit-twiddling for fabs/floor/ceil/copysign; - Newton iteration for sqrt; range-reduction + Taylor for sin/cos/ - exp/log/atan; identities for asin/acos/atan2/sinh/cosh/tanh. - Accuracy is in the ~1e-6 range — good enough for typical numeric - work, far short of glibc-quality. These are slow (each call is - dozens to hundreds of soft-double libcalls) — pre-compute or - cache when possible. + sin, cos, tan, exp, log, atan, atan2, asin, acos, sinh, cosh, + tanh (and float variants). Bit-twiddling for fabs/floor/ceil/ + copysign; Newton iteration for sqrt; range-reduction + Taylor + for sin/cos/exp/log/atan; identities for asin/acos/atan2/sinh/ + cosh/tanh. Accuracy is in the ~1e-6 range — good enough for + typical numeric work, far short of glibc-quality. These are + slow (each call is dozens to hundreds of soft-double libcalls) + — pre-compute or cache when possible. - `setjmp` / `longjmp` from libgcc.s. - Static constructors via crt0's init_array walk. +- `` file I/O against an in-memory FS: `mfsRegister + (path, buf, size, cap, writable)` stages a buffer as a named + file; `fopen`/`fread`/`fwrite`/`fseek`/`ftell`/`fclose`/`fgetc` + /`fgets`/`ungetc`/`fprintf` operate on it via a per-FILE + (kind, buf, size, cap, pos, eof, err, unget) record. stdin/ + stdout/stderr route through `putchar` as before. +- ``: wcslen / wcscmp / wcsncmp / wcscpy / wcsncpy / + wcscat / wcschr / wcsrchr; mbtowc / wctomb / mbstowcs / + wcstombs / mblen with the trivial 1:1 byte<->wide mapping + (Latin-1). wchar_t is 16-bit on this target. +- ``: in-process signal table. signal() registers a + handler; raise() invokes it. Default actions: SIGABRT calls + abort(), SIGINT/SIGTERM call exit(128+sig), others ignored. +- ``: setlocale always returns "C"; localeconv returns + a fixed C-locale lconv struct. +- C++ subset: classes, single inheritance, virtual functions, + polymorphism via base-class pointer arrays, virtual dtors. + Compile with `clang++ -fno-exceptions -fno-rtti`. Multiple + inheritance with virtual bases, full RTTI, exceptions are + out of scope. **Toolchain:** @@ -67,487 +94,148 @@ which runs correctly under MAME (apple2gs). text/rodata/bss, emits a flat binary the IIgs ROM can load. Auto-relocates bss above text+rodata when the default `--bss-base 0x2000` would overlap text, and skips past the - IIgs IO window ($C000-$CFFF) if needed. + IIgs IO window ($C000-$CFFF) if needed. `--gc-sections` + (default ON) drops unreachable functions: a minimal program + with full runtime linked shrinks from ~43KB to ~1.5KB. - `tools/omfEmit` produces OMF v2.1 single-segment files (the IIgs's native object format) for round-tripping with classic dev tools. +- `link816 --debug-out FILE` writes a DWARF sidecar with text/ + rodata/bss/init_array relocations applied to every `.debug_*` + section, so `.debug_addr` / `.debug_line` PC values are final- + image addresses. - `runtime/build.sh` builds crt0, libc, soft-float, soft-double, libgcc into linkable objects. -- `scripts/smokeTest.sh` runs 107 end-to-end checks (scalar ops, - control flow, calling conventions, MAME execution, regressions, - link816 bss-base safety + weak-symbol resolution + - heap_end-vs-heap_start sanity, iigs/toolbox.h compile + link - check (singles inlined, multi-arg wrappers in iigsToolbox.s), - standalone runtime headers, AsmPrinter peepholes for STZ / - PEA / PEI — single-STA, shared-LDA-multi-STA, and DPF0- - forwarding cases — malloc/free coalesce ordering, plus - real-world coverage tests: Conway's Game of Life blinker - (2D loop + neighbour bounds), binary search tree (recursive - struct + malloc), function-pointer dispatch table (indirect - JSL via `__jsl_indir`). Currently 100% pass at -O2 throughout. +- `scripts/smokeTest.sh` runs 113 end-to-end checks at -O2: + scalar ops, control flow, calling conventions, MAME execution + regressions, link816 bss-base safety + weak-symbol resolution + + heap_end-vs-heap_start sanity, iigs/toolbox.h compile + link, + standalone runtime headers, AsmPrinter peepholes (STZ / PEA / + PEI — single-STA, shared-LDA-multi-STA, DPF0-forwarding), + malloc/free coalesce ordering, plus real-world coverage: + Conway's Game of Life blinker (2D loop + neighbour bounds), + binary search tree (recursive struct + malloc), function-pointer + dispatch table (indirect JSL via `__jsl_indir`), memory-backed + file I/O (mfsRegister + fopen/fread/fwrite/fseek/fprintf), C++ + polymorphism (single inheritance + virtual functions), wchar / + signal core APIs, hex dumper writing through fprintf, JSON + tokenizer state machine, scripts/bench.sh size-vs-Calypsi + harness. 100% pass. + +- `scripts/bench.sh` compiles a microbenchmark suite with both + clang (this toolchain) and Calypsi cc65816, comparing emitted + text-section size. Current ratio: ~2.2x (clang generates more + bytes than Calypsi on average; sumOfSquares is the worst case + at 6.45x because of __mulsi3 dispatch). Eight benchmarks + shipped under `benchmarks/`. + +**Backend register allocation:** + +- Greedy regalloc as default at -O1+; fast at -O0/optnone. +- Pre-RA passes: `WidenAcc16` (Acc16→Wide16 promotion, lets + greedy spread i16 pressure across A and 16 IMG slots); + `TiedDefSpill` (handles tied-def-multi-use hazard); + `ABridgeViaX` (bridges via X/Y when free). +- Post-RA passes: `SpillToX` (STA/LDA pairs → TAX/TXA bridges + when X dead); `StackSlotCleanup` (deletes redundant adjacent + spills); `NegYIndY` (rewrites negative-Y indirect-Y stack-rel + ops to avoid the 24-bit-add bank-cross). +- Pre-emit: `BranchExpand` (long Bxx → INV_Bxx skip; BRA target); + `SepRepCleanup` (coalesces adjacent SEP/REP toggles, plus a + cross-mode-neutral coalesce that drops REP/SEP pairs sandwiching + X-flag-only ops, branches, transfers — saves 4B / 12cyc per + collapse). AsmPrinter LDAi8imm peephole walks past mode-neutral + MIs to fuse the closing REP into a following SEP. +- Imaginary registers IMG0..IMG15 backed by DP $C0..$CE + + $D0..$DE — gives greedy 17 effective i16 carriers (A + 16 IMG) + before stack spills kick in. **ABI:** - arg0 in A; arg1 in X for i32-first-arg signatures; rest pushed RTL - on the system stack with PHA. Caller deallocates via `tsc;clc;adc + on the system stack with PHA. Caller deallocates via `tsc;clc;adc #N;tcs` or `PLY*N/2`. - Return: i8/i16 in A; i32 in A:X; i64 in A:X:Y plus DP[$F0..$F1] for the highest 16 bits. - Frame is empty-descending (S points to next-free); offsets account for the +1 skew vs LLVM's full-descending model. +**IIgs toolbox:** + +- `iigs/toolbox.h` — autogenerated wrappers for all ~1300 IIgs + toolbox routines across 35 tool sets (Tool Locator, Memory + Manager, Misc Tools, QuickDraw II / Aux, Event Manager, + Sound Manager, Apple Desktop Bus, SANE, Integer Math, Text + Tools, Window Manager, Menu Manager, Control Manager, + LineEdit, Dialog Manager, Scrap Manager, Standard File, + Note Synth/Sequencer, Font Manager, List Manager, ACE, + Resource Manager, MIDI, Video Overlay, TextEdit, Media + Control, Print Manager, Scheduler, Desk Manager, …). Names + match Apple's IIgs Toolbox Reference exactly (TLStartUp, + MMStartUp, NewWindow, SysBeep, …). 417 simple wrappers + (zero/single-arg, i16-or-void return) inline in the header; + 890 multi-arg ones live in `runtime/src/iigsToolbox.s`. + Generated by `scripts/genToolbox.py` from ORCA-C's + `ORCACDefs/` (re-runnable when ORCA-C updates). + ## In flight -Two open bugs tracked: - -1. **#107 — strtok / qsort -O1+ miscompile — RESOLVED.** Three - independent issues across the backend, runtime, and linker; - all fixed. - - **Fix 1 (W65816StackSlotCleanup cross-MBB):** Pass -4 / - Pass -4c collapsed `LDA fs.X; STA stk.Y; ... LDA_indY stk.Y` - patterns with only an MBB-local safety check, missing cross-MBB - readers of stk.Y. Greedy regalloc had spilled an in-place INA - result back to stk.Y; eliminating the bb.3 init store left the - bb.10 reload reading garbage. Function-wide cross-MBB check - added. - - **Fix 2 (W65816SepRepCleanup LDAi8imm hoist):** Pre-pass that - relocates LDAi8imm BEFORE byte-store SEP/REP wraps. LDAi8imm - expands at AsmPrinter to its own SEP+LDA8+REP that toggles M; - the post-RA scheduler was moving it INSIDE an STBptr wrap, so - the LDAi8imm's REP fired BEFORE the byte STA. The STA then - ran in M=16, writing 2 bytes of zero and clobbering the next - byte. Hoist puts the toggle in the outer M=16 zone, leaving - the byte STA in M=8. - - **Fix 3 (link816 bss-base safety + strtok_r noinline):** With - the backend fixes, -O2 strtok grew large enough that the - strtok() wrapper inlining (~290 extra bytes) pushed the - binary's text+rodata past 0xC000 (IIgs IO window). Reads of - string literals or stdio handles in that range hit IO - registers and corrupted execution. Two complementary fixes: - `__attribute__((noinline))` on `strtok_r` so the wrapper - doesn't duplicate it (-O2 strtok.o now 1564B, was 2156B); - link816 auto-relocates bss above text+rodata when default - `--bss-base 0x2000` would overlap, and skips past the IO - window if needed. - - strtok.c now compiles at -O2 with everything else. Smoke - #84 (4-call strtok continuation) and #92 (recursive parser) - both pass. Workaround comments in build.sh / smokeTest.sh - removed. - - The `__attribute__((noinline,optnone))` defenses on iterative - qsort / RPN `runAll` / expression-parser `runAll` were - subsequently dropped; the smoke now compiles them at plain - `-O2` without escape hatches. - -The W65816 backend assembler now supports all common indirect -addressing modes (`(dp)`, `(dp),Y`, `(dp,X)`, `(d,s),Y`, -`[dp]`, `[dp],Y`, and `JMP (abs)`). All `.byte` opcode hacks in -the runtime have been removed in favour of the mnemonics. The -disassembler decodes them too. - -Runtime now exposes a ~complete C99 subset: sprintf/snprintf with correct %.Nf precision, qsort/bsearch, -the full string.h family (strcat/strncat/strpbrk/strspn/strcspn/ -strtok/strtok_r), math.h with the eleven common transcendentals -(sqrt/pow/sin/cos/exp/log/atan/atan2/asin/acos/sinh/cosh/tanh), -atol/llabs/atexit/exit/abort, and a smoke test that exercises -malloc + struct pointers + strcmp/strcpy via a working hash table -end-to-end in MAME. - -`strtok` / `strtok_r` live in their own TU at `-O2` (with -`__attribute__((noinline))` on `strtok_r` so the strtok() wrapper -doesn't duplicate it). Multi-call strtok over "a,b,,c" works -end-to-end in smoke. The layout-sensitive miscompile that -previously haunted strtok_r's inner CMP loop has been fixed by -modelling `Uses=[P]` on the conditional branches (the LICM/sink -interaction that elided "redundant" CMPs no longer fires); no -surgical workaround flags needed. - -A small **RPN calculator** test (smoke #87) chains strtok, atol, -push/pop over a static stack, snprintf "%ld", and strcmp to verify -the end-to-end composition under a realistic-ish workload — adds, -subs, muls, divs, and 3-deep operand stacks all work. - -**setjmp / longjmp** (smoke #88) now work end-to-end: setjmp saves -SP / 24-bit ret addr / DP, longjmp restores them and returns the -val argument as setjmp's "second return". Required two fixes: -(a) the W65816 assembler had no instruction definition for -`(dp)` / `(dp), y` / `(dp, x)` indirect addressing modes, so the -mnemonic forms silently fell through to absolute-,Y opcodes — -fixed in `src/llvm/lib/Target/W65816/W65816InstrFormats.td` + -`W65816InstrInfo.td` + `AsmParser/W65816AsmParser.cpp` (the runtime -.byte hacks have been replaced with mnemonics); (b) added -`__attribute__((returns_twice))` to the setjmp declaration so the -optimizer doesn't constant-fold post-setjmp env reads to 0. - -**CRC32** (smoke #89) verifies the standard "123456789" → 0xCBF43926 -end-to-end — exercises uint32_t shifts, XORs, char-by-char loops. - -**Brainfuck interpreter** (smoke #90) executes a small bf program -and verifies the output bytes — exercises loop bracket matching, -pointer math (data pointer), branching on cell value. - -**Recursive-descent expression parser** (smoke #92) evaluates -"3+4", "2*3+4", "2+3*4", "(3+4)*5", "100/4-5*2+1" with proper -operator precedence and parentheses — exercises mutual recursion, -char-by-char tokenization, and integer arithmetic in concert. - -The **DWARF sidecar** (`link816 --debug-out FILE`) now applies -text/rodata/bss/init_array relocations to every `.debug_*` section -before writing it. PC values in `.debug_addr` and `.debug_line` end -up as final-image addresses, so a consumer can map back to source -lines without re-running the linker. Intra-debug references (e.g. -`.debug_info` -> `.debug_str` offsets) are intentionally left -object-local — sections are concatenated, not recompacted, and each -slice carries an `; OBJ ... SEC ... SIZE ...` header so a multi-TU -consumer can scope intra-debug offsets per-slice. The smoke test -verifies the address of a known function appears in the patched -sidecar bytes. - -## Known issues / workarounds - -- **(d,s),y / (sr,s),y addressing wraps the bank** when Y is - negative as 16-bit unsigned. Worked around by `W65816NegYIndY` - rewriting the affected ops to `TAX ; LDA/STA $0000,X`. Stays - correct for negative offsets like `arr[i-1]`. - -- **Pointer-deref bank policy is now split-by-syntax** (FIXED): - `*p` (where `p` is a runtime pointer / local-or-arg vreg) lowers - via `LDAptr / STAptr / STBptr` to `[$E0],Y` indirect-LONG with - the bank byte at `$E2` forced to 0 — DBR-independent. The - `*(volatile uint16 *)0x5000 = v` MMIO idiom (const-int pointer) - is matched by a separate TableGen pattern that lowers straight - to `STAabs` (DBR-relative) so the smoke tests' bank-2 write - path still works. Two tracked issues this resolved: - (a) PHI-elim was eliding the inserter's `COPY $a = ptr_vreg` - when the loop body had multiple Acc16 PHIs competing for A — - the inserter now spills the pointer to a fresh stack slot and - reloads via LDAfi to keep RA honest; sumTable now correct. - (b) pointer staging through `[$E0]` is bank-0 only, so - switchToBank2 + helper-with-local-ptr no longer corrupts data - in the wrong bank. See `feedback_dbr_ptr_deref_spill.md`. - - **Greedy regalloc fails on long-arg call chains** — a function that strings ~7+ independent `helper(longArg1, longArg2)` calls - overflows greedy at -O1+ ("ran out of registers during register - allocation"). Same root issue as softDouble's old -O2 hold-out. - Threshold raised somewhat by expanding IMG slots from 8 to 16 - (now backed by DP $C0..$DE) — most "normal-looking" mixed-arity - workloads now compile, but pathological pressure (many i32+ args - + bitmask SETCC chain) still fails. Workarounds (in order of - preference): mark the heaviest helper `__attribute__((noinline))` - to reduce caller pressure; `-mllvm -regalloc=fast` for that TU; - or `__attribute__((optnone))` on the affected function. A proper - fix needs either a custom greedy→fast fallback in - `W65816TargetMachine::createTargetRegisterAllocator` or a smarter - spill-placement pre-RA pass. + overflows greedy at -O1+ with "ran out of registers during + register allocation". IMG slot expansion (8→16) raised the + threshold; most "normal-looking" mixed-arity workloads now + compile, but pathological pressure (many i32+ args + bitmask + SETCC chain in one function) still fails. Workarounds: mark + the heaviest helper `__attribute__((noinline))`; or + `-mllvm -regalloc=fast` for that TU; or `__attribute__((optnone))` + on the affected function. Proper fix needs either a custom + greedy→fast fallback in + `W65816TargetMachine::createTargetRegisterAllocator` or a + smarter spill-placement pre-RA pass. -- **Bank-0 size limit (~48KB)** — the runtime + program must fit in - $1000-$BFFF (text+rodata) plus $D000-$DFFF (LC1 for rodata-spill - and BSS). Past that, link816 hard-fails because text would - cross the IO window. In practice this is rarely hit now that - link816 has `--gc-sections` (default ON, see Recently Fixed) - which drops unreachable functions: a minimal program shrinks - from ~43KB (whole runtime) to ~1.5KB. Programs that genuinely - use most of the runtime can still hit the limit. - -## Recently fixed - -- **DBR pointer-deref RA elision (sumTable miscompile)** — - `LDAptr / STAptr / STBptr` inserter's first-thing - `COPY $a = ptr_vreg` was being elided by RA when the loop body - had multiple Acc16 PHIs competing for A. PHI-elim silently - dropped the COPY needed to refresh A with the pointer at the - top of each iteration; sumTable's inner loop did `STA $E0` - while A held the accumulator. Fix: spill the pointer to a - fresh stack slot via `STAfi` and reload via `LDAfi` — forces - RA to materialize the value through real machine ops. See - `feedback_dbr_ptr_deref_spill.md`. - -- **softDouble.c -O2 hold-out** — with the DBR fix in place, - `dclass` can be `noinline` (its pointer-arg writes go through - `STBptr / STAptr` which now use `[$E0],Y` indirect-long with - bank=0). Drops register pressure in `__muldf3 / __divdf3 / - __adddf3` enough that greedy regalloc no longer runs out. All - three smoke build sites moved from `-O1` to `-O2`. - -- **IMG slot count doubled (8 → 16)** — Img16 / Wide16 register - classes now hold IMG0..IMG15, backed by DP $C0..$CE + $D0..$DE. - Reduces greedy regalloc spills for moderately-busy functions. - Existing `IMG0..IMG7 → $D0..$DE` mapping unchanged so smoke - tests that assume specific DP carriers (e.g. DPF0 at $F0) still - work. User app DP is now $00..$BF (was $00..$CF). - -- **Real-world smoke coverage added** — Conway's Game of Life - blinker (2D arrays + neighbour bounds), binary search tree - (recursive struct + malloc), function-pointer dispatch table - (indirect-JSL via `__jsl_indir`). Total smoke tests at 107. - -- **iigs/toolbox.h expanded** — from 4 stubs to 18+ wrappers - across Tool Locator, Memory Manager, Misc Tools, QuickDraw II, - Event Manager, Window Manager, plus GS/OS Quit. Multi-arg - wrappers live in `runtime/src/iigsToolbox.s` (the backend's - inline-asm constraints can't take memory operands); single-arg - ones stay inline. - -- **#70 — iterative qsort -O2 miscompile** — `W65816StackSlotCleanup` - Pass -2 was deleting a store to a slot the loop body read. - Function-wide `slotHasOtherRefs` safety check added (Pass -1 and - Pass -2c hardened with the same pattern). Iterative qsort at - plain -O2 + greedy now compiles correctly; the `optnone` workaround - in smoke #70 was removed. - -- **strtok -O2 layout-sensitive miscompile** — modelling `Uses=[P]` - on the conditional branches (BEQ/BNE/BCS/BCC/BMI/BPL/BVS/BVC) made - MachineCSE / scheduler / LICM / sink see the CMP→Bxx flag - dependency. An entire class of layout-sensitive flag-corruption - bugs went away; verified by sweeping `--rodata-base` from text-end - to text-end+300 in 13 increments — every layout returns the correct - strtok result. As a follow-on, MachineCSE has been re-enabled - (was previously disabled in `W65816TargetMachine::addMachineSSAOpti­ - mization` as a workaround for the same root cause). - -- **link816 silently produced 4.3GB binaries** when `--rodata-base` - was set inside the text region. Now dies with a clear error: - `--rodata-base 0xX overlaps text 0xY+N (must start at or after 0xZ)`. - -- **link816 BSS-relocate landed in IIgs Language Card area** — - when text+rodata grew past $C000, link816 placed BSS at $D000 - (the LC1 area), where IIgs-by-default maps ROM (writes drop - silently, reads return ROM bytes). Globals never initialised; - caught by the expression-parser smoke (#92) when adding rand / - strnlen / etc. pushed the runtime past that threshold. Two-part - fix: crt0 now enables LC1 RAM via the standard `lda $C083` - read-twice trick at startup, and link816 hard-fails (rather - than silently corrupt) if BSS would exceed the LC1 ceiling - ($E000) — past that you'd need crt0 to also enable LC2 / shadow - RAM, which we haven't wired up. - -- **STZ peephole multi-STA latent miscompile** — AsmPrinter's - `LDA #0; STA $g` -> `STZ $g` peephole eliminated the LDA but - only consumed the FIRST `STA`. When SDAG-CSE shared one - `LDA #0` across multiple `STA`s (`g16=0; g32=0;` is one IR - shape), trailing `STA`s read whatever was in A on entry — - silently corrupting any global where A wasn't 0 at function - entry. Smoke happened to pass because A was 0 by luck in - every covered path. Fixed by gating the peephole on the - consuming `STA` killing A (regalloc only sets `killed` on the - last reader); smoke #98 added to lock the multi-STA case. - -- **PEI AsmPrinter peephole** — new: `LDA $dp; PHA` -> `PEI $dp` - saves 1 byte and avoids touching A. Fires on the - `copyPhysReg(A=DPF0); PUSH16` pattern (i64-libcall return-value - forwarding into the next call's stacked args), which appears - in every chained soft-double / soft-int64 expression. Saves - 68 bytes across the runtime (-64 in math.o alone). Same - next-instruction-modifies-A safety check as the PEA peephole. - Smoke #99 added. - -- **PEA peephole opcode-allowlist replaced with `modifiesRegister`** — - the next-after-PUSH16 check that gates the PEA peephole was a - hand-curated list of opcodes that obviously redefine A; switched - to `MachineInstr::modifiesRegister(A, TRI)` which also catches - implicit-defs (e.g. JSL clobbering A as part of the call ABI). - Saves a few bytes and is more robust. - -- **libgcc.s `lda #0; sta $XX` -> `stz $XX`** — 7 sites converted - in libgcc.s after STZ landed in the assembler. Saves 28 bytes; - also removes two PHA/PLA save-restore wraps around the LDA #0 - (STZ doesn't touch A, so the wraps are unnecessary). - -- **libgcc.s `lda dp; pha` -> `pei dp`** — 2 sites in __divhi3 / - __modhi3 where the loaded A is dead after the push. PEI - doesn't touch A, saves 1 byte each. - -- **W65816StackSlotCleanup Pass 1c skip-list extended** — added - STAabs / STA8abs / STAptr / STBptr / STAptrOff / STBptrOff and - ADJCALLSTACKDOWN to the A-transparent list. Lets the redundant- - CMP-after-A-modifier elimination see through more pseudo - stores and the call-stack-down pseudo. Saves 8 bytes in math.o. - (ADJCALLSTACKUP is NOT transparent — when PEI doesn't process - it, AsmPrinter emits a TSC/CLC/ADC/TCS that clobbers A.) - -- **crt0.s `lda #0; sta` -> `stz`** — IRQ-disable block and the - BSS-zero loop both used `.byte 0xa9, 0x00 ; sta` raw-byte - workarounds for `lda #0` (the assembler emits a 16-bit immediate - in M=8, mis-encoding it). `stz` works in M=8 (stores 1 byte) and - doesn't touch A — both `.byte` workarounds removed; saves 4 bytes - in crt0.o. - -- **Runtime correctness pass — five real bugs fixed:** - - `free()` coalesce: when a freed block was absorbed into a - lower-address neighbour (`bEnd == a` path), the absorbed entry - was left in the free list overlapping the extended one. A - follow-on malloc could hand out the same memory to two - callers. Fix: track outer-loop predecessor and excise the - absorbed entry. Smoke #100 added. - - `sqrt(-0.0)` returned NaN; should return -0.0 per IEEE-754. - The sign-bit check fired before the zero check. Fix: mask - sign bit when testing for zero. - - `log(0)` returned NaN; should return -Infinity (pole error). - Same sign-bit-vs-zero ordering issue; both ±0 now return - `-1.0/0.0`. - - `snprintf(buf, 0, ...)` wrote `'\0'` to `buf[-1]` (one byte - BEFORE the buffer). C99 says n=0 must not touch the buffer. - Fix: set `gEnd = NULL` for n=0 so neither the normal nor the - truncation NUL-write path fires. Smoke #76 extended. - - `malloc(>~32KB)` and `calloc(n, m)` had silent integer overflow - on size_t (16-bit), wrapping to small values and handing out - tiny allocations claiming huge sizes. Bumped malloc to bail - above 0x7FF0 (heap is at most ~32KB anyway) and made calloc - overflow-check before multiplying. - -- **Removed** dead `runtime/src/softDouble.s` (a stub from before - `softDouble.c` was implemented; the build script doesn't reference - it but it was confusing to leave around). - -- **inttypes.h PRId64 / PRIu64 / PRIx64** documented as - unsupported in the runtime's printf — the macros expand to - `"lld"`/`"llu"`/`"llx"` but the formatter only knows the `l` - length modifier, not `ll`, so the format prints literally and - the va_list misaligns. Use `PRId32` etc. for now. - -- **More runtime fixes (round 2):** - - `fputs(s, stream)` was forwarding to `puts(s)`, which appends a - newline. C says fputs MUST NOT add one. Direct char-by-char - write now. - - `exit(code)` never invoked the registered `atexit` handler. - C99 7.20.4.3 requires it. Now runs the single-slot handler - (with re-entry guard) before the BRK. - - `printf("%f", -0.0)` printed `0.000000` instead of `-0.000000` - because `if (v < 0)` (a `__ltdf2` call) returns false for - negative zero. Switched to the IEEE-754 sign-bit test that - snprintf already uses. - - `vfprintf` was missing entirely (declared neither in stdio.h - nor implemented). Added a thin wrapper around vprintf. - -- **link816 weak-symbol resolution:** the linker previously used - "last def wins" with no regard for STB_GLOBAL vs STB_WEAK. When - a user provided a strong override of a weak libc stub (e.g. - `putchar`), it worked only by link-order luck — reversing the - order let the weak stub silently overwrite the strong def. - Now properly: strong over weak (any order), strong + strong - errors out, weak + weak picks the first. Smoke #100 added. - -- **More runtime fixes (round 3):** - - `writeHex` / `emitHex` had a stack-overflow buffer overrun - (`char buf[5]` but `printf("%08x", ...)` would write 8 bytes). - On 16-bit `unsigned int`, max useful width is 4 — buf shrunk - to 4 and width is now capped. - - `writeDec` / `writeSignedLong` / `emitDec` / `emitSignedLong` - used `-n` on signed input, which overflows for INT_MIN / - LONG_MIN (UB). All four switched to unsigned-negation - (`0u - (unsigned)n`) for correctness and to keep an - optimizer-aware compiler from exploiting the UB. - - `atoi` / `atol` / `strtol` / `strtoul` likewise built the - parsed magnitude in a signed accumulator and negated at the - end — same UB on the boundary value. All switched to - unsigned magnitude + unsigned-negation cast. - - `link816 parseInt` / `omfEmit parseInt` silently truncated - addresses > 24 bits to `uint32_t` low bits — `--text-base - 0x100000000` would silently wrap to 0. Both now reject - out-of-range addresses with a clear error. - -- **More runtime fixes (round 4):** - - `pow(x, y)` computed `n = -n` for the integer-y branch when - yi was INT_MIN (-32768); same signed-overflow UB pattern as - the print functions. Switched to unsigned magnitude. - - Added `perror(prefix)` — was missing from the runtime; common - pattern in portable code that reports I/O failure via - `errno + strerror`. Declared in stdio.h, implemented as - char-by-char emit through putchar (no fprintf dependency). - -- **link816 `__heap_end` was hardcoded at $BF00**, ignoring where - `__heap_start` actually ended up. When BSS got auto-relocated - into LC1 ($D000+), heap_start ended up > heap_end and malloc - immediately returned NULL on every call — silently bricking any - program that allocated dynamic memory after the runtime grew - past the default-bss threshold. Heap_end now picks - $BF00 / $E000 based on where heap_start lands (and skips the IO - window if heap_start would have landed in $C000-$CFFF). - Smoke #102 added. - -- **link816 rodata auto-skips IIgs IO window** ($C000-$CFFF). When - text+rodata grew past 0xC000 the rodata bytes silently corrupted - at runtime — string literals in the IO range read back as - hardware register values, breaking strcmp / strstr / printf / etc. - Now: rodata that would land in or cross $C000-$CFFF auto-skips - to $D000. Init_array gets the same treatment. Text that would - cross IO is hard-rejected at link time (no auto-fix possible — - PC fetches in IO would read hardware registers). This was the - root cause of the "tan/tanf triggers layout-sensitive failure" - symptom listed in older STATUS notes. - -- **runInMame skips writes to IO window** during the binary load. - Without this, the zero-padding in the rodata-skip gap would - clobber soft switches (e.g. the LC1 RAM enable that crt0 sets - via $C083) when the loader naively wrote the entire image - byte-by-byte to memory. - -- **link816 `--gc-sections` (default ON)** — discards sections not - reachable from the entry point (`__start` / `_start` / `main` - for the canonical crt0 setup) plus all `.init_array` sections. - Built on `-ffunction-sections` so each function is in its own - section. A minimal program with full runtime linked shrinks - from ~43KB to ~1.5KB. Adding `tan/tanf` to math.c (which - caused the latent layout-sensitive failure described above) - no longer pushes any test past the bank-0 limit. Tests that - intentionally check unreachable symbols pass `--no-gc-sections` - to opt out. - -- **`fwrite(stdout, ...)` was a stub returning 0** even though - `stdout` has a working `putchar` route. Now actually writes - through `putchar` for stdout/stderr (only). Also gained the - same `size * nmemb` overflow guard as `calloc`. - -## What's still needed for a "ship-ready" toolchain - -- **softDouble.c -O2 — FIXED.** Marking `dclass` noinline (in - addition to `dpack`) drops register pressure in `__muldf3`/ - `__divdf3`/`__adddf3` enough that greedy regalloc no longer - runs out. The previous blocker was that noinline-dclass would - write through pointer args via the DBR-relative `(d,s),y` mode - and corrupt caller data after a bank switch — that path now - goes through `STAptr/STBptr` which use `[$E0],Y` indirect-long - with the bank byte forced to 0, so DBR is irrelevant. All - three smoke build sites moved to `-O2`. - - -- **More of the C standard library**: real `` file I/O - (`fopen`, `fread`, `fwrite`, `fseek` are currently stubs - returning success/zero) — would need a memory-backed FS or a - MAME hook. `` / `` / `` are stubbed - (compile and return safe defaults). `` mostly absent. - A `time()` impl wired to ReadTimeHex (Misc Tool $0D03) was - attempted but crashes MAME without the Tool Locator initialised - in crt0; `clock()` via VBL counter at $E1006B needs 24-bit +- **`time()` / `clock()` are stubs** returning 0. ReadTimeHex + (Misc Tool $0D03) needs the Tool Locator initialised in crt0 + to not crash MAME; the VBL counter at $E1006B needs 24-bit far-pointer support that the backend doesn't yet model. -- **C++ runtime support**: vtable layout for multiple inheritance, - RTTI, exceptions (or a documented `-fno-exceptions` requirement). +- **`(d,s),y / (sr,s),y` addressing wraps the bank** when Y is + negative as 16-bit unsigned. Worked around by `W65816NegYIndY` + rewriting the affected ops to `TAX ; LDA/STA $0000,X`. The + workaround stays correct for negative offsets like `arr[i-1]` + but the underlying issue is unfixed at the addressing-mode + level. -- **REP/SEP scheduling pass** (design doc §3.3): the current - prologue picks one M-mode for the whole function based on - whether any 8-bit accumulator value is used. A per-region - scheduler would reduce the SEP/REP wrap overhead on i8 stores. +- **Bank-0 size limit (~48KB)** — the runtime + program must fit + in $1000-$BFFF (text+rodata) plus $D000-$DFFF (LC1 for rodata- + spill and BSS). Past that, link816 hard-fails because text + would cross the IO window. In practice rarely hit thanks to + `--gc-sections`, but programs that genuinely use most of the + runtime can still trip it. Future work: enable LC2 / shadow + RAM via crt0 to add ~16KB more. -- **Toolbox / IIgs system call bindings**: `iigs/toolbox.h` covers - the common entry points across Tool Locator, Memory Manager, - Misc Tools, QuickDraw II, Event Manager, Window Manager, plus - GS/OS Quit. Multi-arg wrappers (NewHandle, QDStartUp, MoveTo, - EMStartUp, GetNextEvent, NewWindow, CloseWindow) live in - `runtime/src/iigsToolbox.s` because the backend's inline-asm - constraints can't take memory operands. Single-arg / no-arg - wrappers stay inline. More routines (Menu Manager, Dialog - Manager, Standard File, Sound) still TBD. +## Yet to come -- **Real-world program coverage**: the smoke tests are - microbenchmarks. A few known-good Apple IIgs C programs (e.g. - a textfile pager, a small game) compiled and run end-to-end - would catch issues no synthetic test currently exercises. +- **GS/OS-backed `` file I/O** — current FS is + memory-backed (programs `mfsRegister` buffers as files). A + GS/OS backend would let programs see the real ProDOS volume + during MAME execution, but needs Tool Locator init in crt0 + and a class-1 parm-block dispatch wrapper around $E100A8. -- **Cycle-time / size benchmarks vs Calypsi 5.16**: design doc §1 - says the goal is to "match or exceed" Calypsi. We have neither - baseline numbers nor a comparison harness yet. +- **C++ exceptions / RTTI / multiple inheritance with virtual + bases** — only the `-fno-exceptions -fno-rtti` subset is + supported. `__cxa_throw` etc. would need an unwind ABI on + this target plus a personality routine. + +- **Close the size gap to Calypsi** — `scripts/bench.sh` + shows clang at ~2.2x Calypsi text size on the included + microbenchmarks, with sumOfSquares as the worst case (6.45x) + due to __mulsi3 dispatch overhead. Targeted improvements: + inline 16x16->32 multiply for small operands; widen the + IMG slot heuristic so greedy uses them more aggressively; + cycle-time benchmark harness (separate from size). + +- **Larger/real-world end-to-end programs** — current real-world + smoke (Game of Life, BST, dispatch, hex dumper, JSON tokenizer) + exercises core idioms. A multi-thousand-line program (e.g. + a small interactive shell, a text editor command loop) would + catch issues no smaller test reaches. diff --git a/bench_simple.s b/bench_simple.s new file mode 100644 index 0000000..52a06b9 --- /dev/null +++ b/bench_simple.s @@ -0,0 +1,51 @@ +; Generated by Calypsi ISO C compiler for 65816 + + .rtmodel version,"1" + .rtmodel codeModel,"large" + .rtmodel dataModel,"small" + .rtmodel core,"65816" + .rtmodel huge,"0" + .rtmodel target,"none-specified" + .extern _Dp + .extern _Mul16 + .extern _Vfp +; unsigned long sumOfSquares(unsigned short n) { + .section farcode,text + .public sumOfSquares +sumOfSquares: + phy + phy + sta 1,s +; unsigned long total = 0; + stz dp:.tiny _Dp + stz dp:.tiny (_Dp+2) +; for (unsigned short i = 1; i <= n; i++) total += (unsigned long)i * i; + lda ##1 + sta 3,s +`?L5`: lda 1,s + cmp 3,s + bcs `?L4` +; return total; + ldx dp:.tiny (_Dp+2) + lda dp:.tiny _Dp +; } + ply + ply + rtl +`?L4`: lda 3,s + tax + jsl long:_Mul16 + clc + adc dp:.tiny _Dp + pha + txa + adc dp:.tiny (_Dp+2) + tax + pla + stx dp:.tiny (_Dp+2) + sta dp:.tiny _Dp + lda 3,s + inc a + sta 3,s + bra `?L5` + diff --git a/benchmarks/bsearch.c b/benchmarks/bsearch.c new file mode 100644 index 0000000..7f7bcda --- /dev/null +++ b/benchmarks/bsearch.c @@ -0,0 +1,10 @@ +int bsearch(const int *arr, int n, int key) { + int lo = 0, hi = n - 1; + while (lo <= hi) { + int mid = (lo + hi) / 2; + if (arr[mid] == key) return mid; + if (arr[mid] < key) lo = mid + 1; + else hi = mid - 1; + } + return -1; +} diff --git a/benchmarks/crc32.c b/benchmarks/crc32.c new file mode 100644 index 0000000..3c76cc0 --- /dev/null +++ b/benchmarks/crc32.c @@ -0,0 +1,10 @@ +unsigned long crc32(const unsigned char *p, unsigned int n) { + unsigned long crc = 0xFFFFFFFFUL; + while (n--) { + crc ^= *p++; + for (int k = 0; k < 8; k++) { + crc = (crc >> 1) ^ (0xEDB88320UL & -(long)(crc & 1)); + } + } + return crc ^ 0xFFFFFFFFUL; +} diff --git a/benchmarks/dotProduct.c b/benchmarks/dotProduct.c new file mode 100644 index 0000000..8a65dbb --- /dev/null +++ b/benchmarks/dotProduct.c @@ -0,0 +1,7 @@ +long dotProduct(const short *a, const short *b, unsigned int n) { + long sum = 0; + for (unsigned int i = 0; i < n; i++) { + sum += (long)a[i] * (long)b[i]; + } + return sum; +} diff --git a/benchmarks/fib.c b/benchmarks/fib.c new file mode 100644 index 0000000..d2896c0 --- /dev/null +++ b/benchmarks/fib.c @@ -0,0 +1,4 @@ +unsigned short fib(unsigned short n) { + if (n < 2) return n; + return fib(n - 1) + fib(n - 2); +} diff --git a/benchmarks/memcmp.c b/benchmarks/memcmp.c new file mode 100644 index 0000000..d59118b --- /dev/null +++ b/benchmarks/memcmp.c @@ -0,0 +1,10 @@ +typedef unsigned char u8; +int mymemcmp(const void *a, const void *b, unsigned int n) { + const u8 *p = (const u8 *)a; + const u8 *q = (const u8 *)b; + while (n--) { + if (*p != *q) return *p - *q; + p++; q++; + } + return 0; +} diff --git a/benchmarks/popcount.c b/benchmarks/popcount.c new file mode 100644 index 0000000..6f08a16 --- /dev/null +++ b/benchmarks/popcount.c @@ -0,0 +1,5 @@ +int popcount(unsigned long x) { + int n = 0; + while (x) { n += x & 1; x >>= 1; } + return n; +} diff --git a/benchmarks/strcpy.c b/benchmarks/strcpy.c new file mode 100644 index 0000000..7fb0a66 --- /dev/null +++ b/benchmarks/strcpy.c @@ -0,0 +1,5 @@ +char *mystrcpy(char *dst, const char *src) { + char *d = dst; + while ((*d++ = *src++)) {} + return dst; +} diff --git a/benchmarks/sumOfSquares.c b/benchmarks/sumOfSquares.c new file mode 100644 index 0000000..5b98ba3 --- /dev/null +++ b/benchmarks/sumOfSquares.c @@ -0,0 +1,5 @@ +unsigned long sumOfSquares(unsigned short n) { + unsigned long total = 0; + for (unsigned short i = 1; i <= n; i++) total += (unsigned long)i * i; + return total; +} diff --git a/runtime/include/iigs/toolbox.h b/runtime/include/iigs/toolbox.h index 66b6f62..57d7ddf 100644 --- a/runtime/include/iigs/toolbox.h +++ b/runtime/include/iigs/toolbox.h @@ -1,27 +1,12 @@ -// IIgs toolbox helpers — wrappers for commonly-used Apple IIgs system -// calls. +// AUTOGENERATED by scripts/genToolbox.py from ORCA-C ORCACDefs/. +// DO NOT EDIT by hand — regenerate to update. // -// Toolbox dispatch on the IIgs goes through the Tool Locator at -// $E10000. Each routine is identified by a 16-bit "tool number" -// (high byte = function within set, low byte = tool set), loaded -// into X, and called via JSL $E10000. -// -// GS/OS dispatch goes through $E100A8 with X holding the call -// number and a parameter-block pointer pushed on the stack. -// -// Calling convention: -// - Args go on the stack (push order: rightmost first), then the -// caller pushes a result-space slot (16 or 32 bits) BEFORE -// the args if the routine returns something non-void. -// - The result is read off the same stack slot AFTER JSL. -// - Tool number lives in X immediately before JSL. -// - Tools clobber A, X, Y, P; the runtime spills around the call. -// -// Single-arg / no-arg wrappers are `static inline`. Multi-arg -// wrappers are declared `extern` here and implemented in -// runtime/src/iigsToolbox.s — backend constraints don't allow -// memory-operand inline asm so the multi-arg pushes need real -// .s code. +// Complete IIgs toolbox: ~1300 routines across 35 tool sets. +// Names match Apple's IIgs Toolbox Reference (TLStartUp, +// MMStartUp, NewWindow, SysBeep, etc.). Multi-arg wrappers +// (those whose stub body uses memory operands) live in +// runtime/src/iigsToolbox.s; zero-arg / single-arg simple +// ones are inlined here. #ifndef IIGS_TOOLBOX_H #define IIGS_TOOLBOX_H @@ -30,16 +15,1674 @@ extern "C" { #endif -// ===== Tool numbers (high byte = function, low byte = tool set) ===== -// Tool sets: -// 01 = Tool Locator 02 = Memory Manager 03 = Misc Tools -// 04 = QuickDraw II 06 = Event Manager 0E = Window Manager -// 1B = Menu Manager 29 = Standard File +// tool 0x011D set 0x1D (ACETools) +static inline void ACEBootInit(void) { + __asm__ volatile ( + "ldx #0x011D\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} -// ===================================================================== -// Tool Locator (Set $01) -// ===================================================================== -static inline void TBoxTLStartUp(void) { +// tool 0x021D set 0x1D (ACETools) +static inline void ACEStartUp(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x021D\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x031D set 0x1D (ACETools) +static inline void ACEShutDown(void) { + __asm__ volatile ( + "ldx #0x031D\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x041D set 0x1D (ACETools) +static inline unsigned short ACEVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x041D\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x051D set 0x1D (ACETools) +static inline void ACEReset(void) { + __asm__ volatile ( + "ldx #0x051D\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x061D set 0x1D (ACETools) +static inline unsigned short ACEStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x061D\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned long ACEInfo(unsigned short a0); // 0x071D +// tool 0x0B1D set 0x1D (ACETools) +static inline void ACECompBegin(void) { + __asm__ volatile ( + "ldx #0x0B1D\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void ACECompress(void * a0, long a1, void * a2, long a3, unsigned short a4, unsigned short a5); // 0x091D +extern void ACEExpand(void * a0, long a1, void * a2, long a3, unsigned short a4, unsigned short a5); // 0x0A1D +// tool 0x0C1D set 0x1D (ACETools) +static inline void ACEExpBegin(void) { + __asm__ volatile ( + "ldx #0x0C1D\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void GetACEExpState(void * a0); // 0x0D1D +extern void SetACEExpState(void * a0); // 0x0E1D +// tool 0x0109 set 0x09 (AppleDeskBus) +static inline void ADBBootInit(void) { + __asm__ volatile ( + "ldx #0x0109\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0209 set 0x09 (AppleDeskBus) +static inline void ADBStartUp(void) { + __asm__ volatile ( + "ldx #0x0209\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0309 set 0x09 (AppleDeskBus) +static inline void ADBShutDown(void) { + __asm__ volatile ( + "ldx #0x0309\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0409 set 0x09 (AppleDeskBus) +static inline unsigned short ADBVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0409\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0509 set 0x09 (AppleDeskBus) +static inline void ADBReset(void) { + __asm__ volatile ( + "ldx #0x0509\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0609 set 0x09 (AppleDeskBus) +static inline unsigned short ADBStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0609\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0F09 set 0x09 (AppleDeskBus) +static inline void AbsOn(void) { + __asm__ volatile ( + "ldx #0x0F09\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x1009 set 0x09 (AppleDeskBus) +static inline void AbsOff(void) { + __asm__ volatile ( + "ldx #0x1009\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void AsyncADBReceive(void * a0, unsigned short a1); // 0x0D09 +// tool 0x1609 set 0x09 (AppleDeskBus) +static inline void ClearSRQTable(void) { + __asm__ volatile ( + "ldx #0x1609\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void GetAbsScale(void * a0); // 0x1309 +// tool 0x1109 set 0x09 (AppleDeskBus) +static inline unsigned short ReadAbs(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1109\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void ReadKeyMicroData(unsigned short a0, void * a1, unsigned short a2); // 0x0A09 +extern void ReadKeyMicroMemory(void * a0, void * a1, unsigned short a2); // 0x0B09 +extern void SendInfo(unsigned short a0, void * a1, unsigned short a2); // 0x0909 +extern void SetAbsScale(void * a0); // 0x1209 +extern void SRQPoll(void * a0, unsigned short a1); // 0x1409 +// tool 0x1509 set 0x09 (AppleDeskBus) +static inline void SRQRemove(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1509\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SyncADBReceive(unsigned short a0, void * a1, unsigned short a2); // 0x0E09 +// tool 0x0110 set 0x10 (ControlManager) +static inline void CtlBootInit(void) { + __asm__ volatile ( + "ldx #0x0110\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void CtlStartUp(unsigned short a0, unsigned short a1); // 0x0210 +// tool 0x0310 set 0x10 (ControlManager) +static inline void CtlShutDown(void) { + __asm__ volatile ( + "ldx #0x0310\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0410 set 0x10 (ControlManager) +static inline unsigned short CtlVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0410\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0510 set 0x10 (ControlManager) +static inline void CtlReset(void) { + __asm__ volatile ( + "ldx #0x0510\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0610 set 0x10 (ControlManager) +static inline unsigned short CtlStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0610\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1210 set 0x10 (ControlManager) +static inline void CtlNewRes(void) { + __asm__ volatile ( + "ldx #0x1210\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void DisposeControl(void * a0); // 0x0A10 +extern void DragControl(short a0, short a1, void * a2, void * a3, unsigned short a4, void * a5); // 0x1710 +extern void * DragRect(void * a0, void * a1, short a2, short a3, void * a4, void * a5, void * a6, unsigned short a7); // 0x1D10 +extern void DrawControls(void * a0); // 0x1010 +extern void DrawOneCtl(void * a0); // 0x2510 +extern void EraseControl(void * a0); // 0x2410 +extern unsigned short FindControl(void * a0, short a1, short a2, void * a3); // 0x1310 +extern void * GetCtlAction(void * a0); // 0x2110 +// tool 0x1F10 set 0x10 (ControlManager) +static inline unsigned short GetCtlDPage(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1F10\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned long GetCtlParams(void * a0); // 0x1C10 +extern unsigned long GetCtlRefCon(void * a0); // 0x2310 +extern void * GetCtlTitle(void * a0); // 0x0D10 +extern unsigned short GetCtlValue(void * a0); // 0x1A10 +extern unsigned long GrowSize(void); // 0x1E10 +extern void HideControl(void * a0); // 0x0E10 +extern void HiliteControl(unsigned short a0, void * a1); // 0x1110 +extern void KillControls(void * a0); // 0x0B10 +extern void MoveControl(short a0, short a1, void * a2); // 0x1610 +extern void * NewControl(void * a0, void * a1, void * a2, unsigned short a3, unsigned short a4, unsigned short a5, unsigned short a6, void * a7, void * a8, void * a9); // 0x0910 +extern void SetCtlAction(void * a0, void * a1); // 0x2010 +extern void * SetCtlIcons(void * a0); // 0x1810 +extern void SetCtlParams(unsigned short a0, unsigned short a1, void * a2); // 0x1B10 +extern void SetCtlRefCon(void * a0, void * a1); // 0x2210 +extern void SetCtlTitle(void * a0, void * a1); // 0x0C10 +extern void SetCtlValue(unsigned short a0, void * a1); // 0x1910 +extern void ShowControl(void * a0); // 0x0F10 +extern unsigned short TestControl(short a0, short a1, void * a2); // 0x1410 +extern unsigned short TrackControl(short a0, short a1, void * a2, void * a3); // 0x1510 +extern unsigned long CallCtlDefProc(void * a0, unsigned short a1, long a2); // 0x2C10 +extern void * CMLoadResource(unsigned short a0, long a1); // 0x3210 +extern void CMReleaseResource(unsigned short a0, long a1); // 0x3310 +extern void * FindTargetCtl(void); // 0x2610 +extern void * GetCtlHandleFromID(void * a0, long a1); // 0x3010 +extern unsigned long GetCtlID(void * a0); // 0x2A10 +extern unsigned short GetCtlMoreFlags(void * a0); // 0x2E10 +extern void * GetCtlParamPtr(void); // 0x3510 +extern void InvalCtls(void * a0); // 0x3710 +extern void * MakeNextCtlTarget(void); // 0x2710 +extern void MakeThisCtlTarget(void * a0); // 0x2810 +extern void * NewControl2(void * a0, unsigned short a1, void * a2); // 0x3110 +extern void NotifyControls(unsigned short a0, unsigned short a1, long a2, void * a3); // 0x2D10 +extern void NotifyCtls(unsigned short a0, unsigned short a1, long a2, void * a3); // 0x2D10 +extern unsigned short SendEventToCtl(unsigned short a0, void * a1, void * a2); // 0x2910 +extern void SetCtlID(long a0, void * a1); // 0x2B10 +extern void SetCtlMoreFlags(unsigned short a0, void * a1); // 0x2F10 +extern void SetCtlParamPtr(void * a0); // 0x3410 +extern unsigned short FindRadioButton(void * a0, unsigned short a1); // 0x3910 +extern void GetLETextByID(void * a0, long a1, void * a2); // 0x3B10 +extern void SetLETextByID(void * a0, long a1, void * a2); // 0x3A10 +extern void SetCtlValueByID(unsigned short a0, void * a1, long a2); // 0x3C10 +extern unsigned short GetCtlValueByID(void * a0, long a1); // 0x3D10 +extern void InvalOneCtlByID(void * a0, long a1); // 0x3E10 +extern void HiliteCtlByID(unsigned short a0, void * a1, long a2); // 0x3F10 +// tool 0x0105 set 0x05 (DeskManager) +static inline void DeskBootInit(void) { + __asm__ volatile ( + "ldx #0x0105\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0205 set 0x05 (DeskManager) +static inline void DeskStartUp(void) { + __asm__ volatile ( + "ldx #0x0205\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0305 set 0x05 (DeskManager) +static inline void DeskShutDown(void) { + __asm__ volatile ( + "ldx #0x0305\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0405 set 0x05 (DeskManager) +static inline unsigned short DeskVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0405\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0505 set 0x05 (DeskManager) +static inline void DeskReset(void) { + __asm__ volatile ( + "ldx #0x0505\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0605 set 0x05 (DeskManager) +static inline unsigned short DeskStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0605\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1105 set 0x05 (DeskManager) +static inline void ChooseCDA(void) { + __asm__ volatile ( + "ldx #0x1105\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x1D05 set 0x05 (DeskManager) +static inline void CloseAllNDAs(void) { + __asm__ volatile ( + "ldx #0x1D05\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x1605 set 0x05 (DeskManager) +static inline void CloseNDA(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1605\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void CloseNDAbyWinPtr(void * a0); // 0x1C05 +extern void CloseNDAByWinPtr(void * a0); // 0x1C05 +// tool 0x1E05 set 0x05 (DeskManager) +static inline void FixAppleMenu(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1E05\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void * GetDAStrPtr(void); // 0x1405 +// tool 0x1B05 set 0x05 (DeskManager) +static inline unsigned short GetNumNDAs(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1B05\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void InstallCDA(void * a0); // 0x0F05 +extern void InstallNDA(void * a0); // 0x0E05 +// tool 0x1505 set 0x05 (DeskManager) +static inline unsigned short OpenNDA(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1505\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0C05 set 0x05 (DeskManager) +static inline void RestAll(void) { + __asm__ volatile ( + "ldx #0x0C05\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0A05 set 0x05 (DeskManager) +static inline void RestScrn(void) { + __asm__ volatile ( + "ldx #0x0A05\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0B05 set 0x05 (DeskManager) +static inline void SaveAll(void) { + __asm__ volatile ( + "ldx #0x0B05\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0905 set 0x05 (DeskManager) +static inline void SaveScrn(void) { + __asm__ volatile ( + "ldx #0x0905\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void SetDAStrPtr(void * a0, void * a1); // 0x1305 +extern void SystemClick(void * a0, void * a1, unsigned short a2); // 0x1705 +// tool 0x1805 set 0x05 (DeskManager) +static inline unsigned short SystemEdit(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1805\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned short SystemEvent(unsigned short a0, long a1, long a2, void * a3, unsigned short a4); // 0x1A05 +// tool 0x1905 set 0x05 (DeskManager) +static inline void SystemTask(void) { + __asm__ volatile ( + "ldx #0x1905\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void AddToRunQ(void * a0); // 0x1F05 +extern void RemoveCDA(void * a0); // 0x2105 +extern void RemoveFromRunQ(void * a0); // 0x2005 +extern void RemoveNDA(void * a0); // 0x2205 +extern unsigned short CallDeskAcc(unsigned short a0, long a1, unsigned short a2, long a3); // 0x2405 +extern void GetDeskAccInfo(unsigned short a0, long a1, unsigned short a2, void * a3); // 0x2305 +extern unsigned long GetDeskGlobal(unsigned short a0); // 0x2505 +// tool 0x0115 set 0x15 (DialogManager) +static inline void DialogBootInit(void) { + __asm__ volatile ( + "ldx #0x0115\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0215 set 0x15 (DialogManager) +static inline void DialogStartUp(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0215\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x0315 set 0x15 (DialogManager) +static inline void DialogShutDown(void) { + __asm__ volatile ( + "ldx #0x0315\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0415 set 0x15 (DialogManager) +static inline unsigned short DialogVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0415\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0515 set 0x15 (DialogManager) +static inline void DialogReset(void) { + __asm__ volatile ( + "ldx #0x0515\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0615 set 0x15 (DialogManager) +static inline unsigned short DialogStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0615\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned short Alert(void * a0, void * a1); // 0x1715 +extern unsigned short CautionAlert(void * a0, void * a1); // 0x1A15 +extern void CloseDialog(void * a0); // 0x0C15 +extern unsigned short DefaultFilter(void * a0, void * a1, unsigned short a2); // 0x3615 +extern unsigned short DialogSelect(void * a0, void * a1, unsigned short a2); // 0x1115 +extern void DisableDItem(void * a0, unsigned short a1); // 0x3915 +extern void DlgCopy(void * a0); // 0x1315 +extern void DlgCut(void * a0); // 0x1215 +extern void DlgDelete(void * a0); // 0x1515 +extern void DlgPaste(void * a0); // 0x1415 +extern void DrawDialog(void * a0); // 0x1615 +extern void EnableDItem(void * a0, unsigned short a1); // 0x3A15 +extern void ErrorSound(void * a0); // 0x0915 +extern unsigned short FindDItem(void * a0, void * a1); // 0x2415 +// tool 0x3415 set 0x15 (DialogManager) +static inline unsigned short GetAlertStage(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x3415\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetControlDItem(void * a0, unsigned short a1); // 0x1E15 +extern unsigned short GetDefButton(void * a0); // 0x3715 +extern void GetDItemBox(void * a0, unsigned short a1, void * a2); // 0x2815 +extern unsigned short GetDItemType(void * a0, unsigned short a1); // 0x2615 +extern unsigned short GetDItemValue(void * a0, unsigned short a1); // 0x2E15 +extern unsigned short GetFirstDItem(void * a0); // 0x2A15 +extern void GetIText(void * a0, unsigned short a1, void * a2); // 0x1F15 +extern void GetNewDItem(void * a0, void * a1); // 0x3315 +extern void * GetNewModalDialog(void * a0); // 0x3215 +extern unsigned short GetNextDItem(void * a0, unsigned short a1); // 0x2B15 +extern void HideDItem(void * a0, unsigned short a1); // 0x2215 +extern unsigned short IsDialogEvent(void * a0); // 0x1015 +extern unsigned short ModalDialog(void * a0); // 0x0F15 +extern unsigned long ModalDialog2(void * a0); // 0x2C15 +extern void NewDItem(void * a0, unsigned short a1, void * a2, unsigned short a3, void * a4, unsigned short a5, unsigned short a6, void * a7); // 0x0D15 +extern void * NewModalDialog(void * a0, unsigned short a1, unsigned long a2); // 0x0A15 +extern void * NewModelessDialog(void * a0, void * a1, void * a2, unsigned short a3, unsigned long a4, void * a5); // 0x0B15 +extern unsigned short NoteAlert(void * a0, void * a1); // 0x1915 +extern void ParamText(void * a0, void * a1, void * a2, void * a3); // 0x1B15 +extern void RemoveDItem(void * a0, unsigned short a1); // 0x0E15 +// tool 0x3515 set 0x15 (DialogManager) +static inline void ResetAlertStage(void) { + __asm__ volatile ( + "ldx #0x3515\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void SelectIText(void * a0, unsigned short a1, unsigned short a2, unsigned short a3); // 0x2115 +extern void SelIText(void * a0, unsigned short a1, unsigned short a2, unsigned short a3); // 0x2115 +extern void SetDAFont(void * a0); // 0x1C15 +extern void SetDefButton(unsigned short a0, void * a1); // 0x3815 +extern void SetDItemBox(void * a0, unsigned short a1, void * a2); // 0x2915 +extern void SetDItemType(unsigned short a0, void * a1, unsigned short a2); // 0x2715 +extern void SetDItemValue(unsigned short a0, void * a1, unsigned short a2); // 0x2F15 +extern void SetIText(void * a0, unsigned short a1, void * a2); // 0x2015 +extern void ShowDItem(void * a0, unsigned short a1); // 0x2315 +extern unsigned short StopAlert(void * a0, void * a1); // 0x1815 +extern void UpdateDialog(void * a0, void * a1); // 0x2515 +// tool 0x0106 set 0x06 (EventManager) +static inline void EMBootInit(void) { + __asm__ volatile ( + "ldx #0x0106\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void EMStartUp(unsigned short a0, unsigned short a1, short a2, short a3, short a4, short a5, unsigned short a6); // 0x0206 +// tool 0x0306 set 0x06 (EventManager) +static inline void EMShutDown(void) { + __asm__ volatile ( + "ldx #0x0306\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0406 set 0x06 (EventManager) +static inline unsigned short EMVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0406\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0506 set 0x06 (EventManager) +static inline void EMReset(void) { + __asm__ volatile ( + "ldx #0x0506\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0606 set 0x06 (EventManager) +static inline unsigned short EMStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0606\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0D06 set 0x06 (EventManager) +static inline unsigned short Button(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x0D06\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0906 set 0x06 (EventManager) +static inline unsigned short DoWindows(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0906\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned short EventAvail(unsigned short a0, void * a1); // 0x0B06 +extern void FakeMouse(unsigned short a0, unsigned short a1, short a2, short a3, unsigned short a4); // 0x1906 +extern unsigned short FlushEvents(unsigned short a0, unsigned short a1); // 0x1506 +extern unsigned long GetCaretTime(void); // 0x1206 +extern unsigned long GetDblTime(void); // 0x1106 +extern void GetMouse(void * a0); // 0x0C06 +extern unsigned short GetNextEvent(unsigned short a0, void * a1); // 0x0A06 +extern unsigned short GetOSEvent(unsigned short a0, void * a1); // 0x1606 +extern unsigned short OSEventAvail(unsigned short a0, void * a1); // 0x1706 +extern unsigned short PostEvent(unsigned short a0, unsigned long a1); // 0x1406 +// tool 0x1806 set 0x06 (EventManager) +static inline void SetEventMask(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1806\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x1306 set 0x06 (EventManager) +static inline void SetSwitch(void) { + __asm__ volatile ( + "ldx #0x1306\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0E06 set 0x06 (EventManager) +static inline unsigned short StillDown(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x0E06\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned long TickCount(void); // 0x1006 +// tool 0x0F06 set 0x06 (EventManager) +static inline unsigned short WaitMouseUp(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x0F06\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1B06 set 0x06 (EventManager) +static inline unsigned short GetKeyTranslation(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1B06\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1A06 set 0x06 (EventManager) +static inline void SetAutoKeyLimit(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1A06\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x1C06 set 0x06 (EventManager) +static inline void SetKeyTranslation(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1C06\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x011B set 0x1B (FontManager) +static inline void FMBootInit(void) { + __asm__ volatile ( + "ldx #0x011B\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void FMStartUp(unsigned short a0, unsigned short a1); // 0x021B +// tool 0x031B set 0x1B (FontManager) +static inline void FMShutDown(void) { + __asm__ volatile ( + "ldx #0x031B\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x041B set 0x1B (FontManager) +static inline unsigned short FMVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x041B\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x051B set 0x1B (FontManager) +static inline void FMReset(void) { + __asm__ volatile ( + "ldx #0x051B\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x061B set 0x1B (FontManager) +static inline unsigned short FMStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x061B\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void AddFamily(unsigned short a0, void * a1); // 0x0D1B +extern void AddFontVar(void * a0, unsigned short a1); // 0x141B +extern unsigned long ChooseFont(void * a0, unsigned short a1); // 0x161B +// tool 0x091B set 0x1B (FontManager) +static inline unsigned short CountFamilies(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x091B\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned short CountFonts(void * a0, unsigned short a1); // 0x101B +// tool 0x1B1B set 0x1B (FontManager) +static inline unsigned short FamNum2ItemID(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1B1B\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned short FindFamily(unsigned short a0, unsigned short a1, void * a2); // 0x0A1B +extern void FindFontStats(void * a0, unsigned short a1, unsigned short a2, void * a3); // 0x111B +extern void FixFontMenu(unsigned short a0, unsigned short a1, unsigned short a2); // 0x151B +extern unsigned long FMGetCurFID(void); // 0x1A1B +extern unsigned long FMGetSysFID(void); // 0x191B +extern void FMSetSysFont(void * a0); // 0x181B +extern unsigned short GetFamInfo(unsigned short a0, void * a1); // 0x0B1B +extern unsigned short GetFamNum(void * a0); // 0x0C1B +extern void InstallFont(void * a0, unsigned short a1); // 0x0E1B +// tool 0x171B set 0x1B (FontManager) +static inline unsigned short ItemID2FamNum(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x171B\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void LoadFont(void * a0, unsigned short a1, unsigned short a2, void * a3); // 0x121B +// tool 0x131B set 0x1B (FontManager) +static inline void LoadSysFont(void) { + __asm__ volatile ( + "ldx #0x131B\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void SetPurgeStat(void * a0, unsigned short a1); // 0x0F1B +extern void InstallWithStats(void * a0, unsigned short a1, void * a2); // 0x1C1B +// tool 0x04FF set 0xFF (?) +static inline unsigned short DebugVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x04FF\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x06FF set 0xFF (?) +static inline unsigned short DebugStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x06FF\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void DebugStr(void * a0); // 0x09FF +extern void SetMileStone(void * a0); // 0x0AFF +extern void DebugSetHook(void * a0); // 0x0BFF +extern unsigned long DebugGetInfo(unsigned short a0); // 0x0CFF +extern void * EvalExpr(void * a0); // 0x0002 +extern void SendCardMessage(void * a0); // 0x0001 +extern void SendHCMessage(void * a0); // 0x0005 +extern void * GetGlobal(void * a0); // 0x0012 +extern void SetGlobal(void * a0, void * a1); // 0x0013 +extern void ZeroBytes(void * a0, void * a1); // 0x0006 +extern unsigned short GSStringEqual(void * a0, void * a1); // 0x0022 +extern void ScanToReturn(void * a0); // 0x001C +extern void ScanToZero(void * a0); // 0x001D +extern unsigned short StringEqual(void * a0, void * a1); // 0x001A +extern void * StringLength(void * a0); // 0x0003 +extern void * StringMatch(void * a0, void * a1); // 0x0004 +extern void * BoolToStr(unsigned short a0); // 0x0010 +extern void * CopyGSString(void * a0); // 0x0020 +extern void * ExtToStr(long double a0); // 0x0011 +extern void * GSConcat(void * a0, void * a1); // 0x0021 +extern void * GSToPString(void * a0); // 0x001E +extern void * GSToZero(void * a0); // 0x0023 +extern void * LongToStr(void * a0); // 0x000D +extern void * NumToHex(void * a0, void * a1); // 0x000F +extern void * NumToStr(void * a0); // 0x000E +extern void PointToStr(void * a0, void * a1); // 0x002D +extern void * PasToZero(void * a0); // 0x0007 +extern void * PToGSString(void * a0); // 0x001F +extern void RectToStr(void * a0, void * a1); // 0x002E +extern void ReturnToPas(void * a0, void * a1); // 0x001B +extern unsigned short StrToBool(void * a0); // 0x000B +extern void * StrToExt(void * a0); // 0x000C +extern void * StrToLong(void * a0); // 0x0009 +extern void * StrToNum(void * a0); // 0x000A +extern void StrToPoint(void * a0, void * a1); // 0x002F +extern void StrToRect(void * a0, void * a1); // 0x0030 +extern void * ZeroToGS(void * a0); // 0x0024 +extern void ZeroToPas(void * a0, void * a1); // 0x0008 +extern void * GetFieldByID(unsigned short a0, void * a1); // 0x0016 +extern void * GetFieldByName(unsigned short a0, void * a1); // 0x0014 +extern void * GetFieldByNum(unsigned short a0, void * a1); // 0x0015 +extern void SetFieldByID(unsigned short a0, void * a1, void * a2); // 0x0019 +extern void SetFieldByName(unsigned short a0, void * a1, void * a2); // 0x0017 +extern void SetFieldByNum(unsigned short a0, void * a1, void * a2); // 0x0018 +extern void ChangedMaskAndData(void * a0); // 0x002C +extern void GetMaskAndData(void * a0, void * a1); // 0x002B +// tool 0x0029 set 0x29 (?) +static inline void BeginXSound(void) { + __asm__ volatile ( + "ldx #0x0029\n" + "jsl 0xe100a8\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x002A set 0x2A (?) +static inline void EndXSound(void) { + __asm__ volatile ( + "ldx #0x002A\n" + "jsl 0xe100a8\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern unsigned short FindNamedResource(void * a0, void * a1, void * a2, void * a3); // 0x0026 +extern void * GetResourceName(void * a0, void * a1); // 0x0028 +extern void * LoadNamedResource(void * a0, void * a1); // 0x0025 +extern void SetResourceName(void * a0, void * a1, void * a2); // 0x0027 +extern void * NewXWindow(void * a0, void * a1, unsigned short a2, void * a3); // 0x0031 +extern void CloseXWindow(void * a0); // 0x0033 +extern void * GetXWindowValue(void * a0); // 0x0037 +// tool 0x0034 set 0x34 (?) +static inline void HideHCPalettes(void) { + __asm__ volatile ( + "ldx #0x0034\n" + "jsl 0xe100a8\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0035 set 0x35 (?) +static inline void ShowHCPalettes(void) { + __asm__ volatile ( + "ldx #0x0035\n" + "jsl 0xe100a8\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void SetXWIdleTime(void * a0, void * a1); // 0x0032 +extern void SetXWindowValue(void * a0, void * a1); // 0x0036 +extern void XWAllowReEntrancy(void * a0, unsigned short a1, unsigned short a2); // 0x0038 +// tool 0x010B set 0x0B (IntegerMath) +static inline void IMBootInit(void) { + __asm__ volatile ( + "ldx #0x010B\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x020B set 0x0B (IntegerMath) +static inline void IMStartUp(void) { + __asm__ volatile ( + "ldx #0x020B\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x030B set 0x0B (IntegerMath) +static inline void IMShutDown(void) { + __asm__ volatile ( + "ldx #0x030B\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x040B set 0x0B (IntegerMath) +static inline unsigned short IMVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x040B\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x050B set 0x0B (IntegerMath) +static inline void IMReset(void) { + __asm__ volatile ( + "ldx #0x050B\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x060B set 0x0B (IntegerMath) +static inline unsigned short IMStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x060B\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern short Dec2Int(void * a0, unsigned short a1, unsigned short a2); // 0x280B +extern void * Dec2Long(void * a0, unsigned short a1, unsigned short a2); // 0x290B +extern void * Fix2Frac(void * a0); // 0x1C0B +extern void * Fix2Long(void * a0); // 0x1B0B +extern void Fix2X(void * a0, void * a1); // 0x1E0B +extern void * FixATan2(void * a0, void * a1); // 0x170B +extern void * FixDiv(void * a0, void * a1); // 0x110B +extern void * FixMul(void * a0, void * a1); // 0x0F0B +extern void * FixRatio(short a0, short a1); // 0x0E0B +extern short FixRound(void * a0); // 0x130B +extern void * Frac2Fix(void * a0); // 0x1D0B +extern void Frac2X(void * a0, void * a1); // 0x1F0B +extern void * FracCos(void * a0); // 0x150B +extern void * FracDiv(void * a0, void * a1); // 0x120B +extern void * FracMul(void * a0, void * a1); // 0x100B +extern void * FracSin(void * a0); // 0x160B +extern void * FracSqrt(void * a0); // 0x140B +extern unsigned short Hex2Int(void * a0, unsigned short a1); // 0x240B +extern unsigned long Hex2Long(void * a0, unsigned short a1); // 0x250B +extern unsigned long HexIt(unsigned short a0); // 0x2A0B +extern unsigned short HiWord(unsigned long a0); // 0x180B +extern void Int2Dec(short a0, void * a1, unsigned short a2, unsigned short a3); // 0x260B +extern void Int2Hex(unsigned short a0, void * a1, unsigned short a2); // 0x220B +extern void Long2Dec(void * a0, void * a1, unsigned short a2, unsigned short a3); // 0x270B +extern void * Long2Fix(void * a0); // 0x1A0B +extern void Long2Hex(unsigned long a0, void * a1, unsigned short a2); // 0x230B +extern unsigned short LoWord(unsigned long a0); // 0x190B +extern void * Multiply(short a0, short a1); // 0x090B +extern void * X2Fix(void * a0); // 0x200B +extern void * X2Frac(void * a0); // 0x210B +// tool 0x0114 set 0x14 (LineEdit) +static inline void LEBootInit(void) { + __asm__ volatile ( + "ldx #0x0114\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void LEStartUp(unsigned short a0, unsigned short a1); // 0x0214 +// tool 0x0314 set 0x14 (LineEdit) +static inline void LEShutDown(void) { + __asm__ volatile ( + "ldx #0x0314\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0414 set 0x14 (LineEdit) +static inline unsigned short LEVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0414\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0514 set 0x14 (LineEdit) +static inline void LEReset(void) { + __asm__ volatile ( + "ldx #0x0514\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0614 set 0x14 (LineEdit) +static inline unsigned short LEStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0614\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void LEActivate(void * a0); // 0x0F14 +extern void LEClick(void * a0, void * a1); // 0x0D14 +extern void LECopy(void * a0); // 0x1314 +extern void LECut(void * a0); // 0x1214 +extern void LEDeactivate(void * a0); // 0x1014 +extern void LEDelete(void * a0); // 0x1514 +extern void LEDispose(void * a0); // 0x0A14 +// tool 0x1914 set 0x14 (LineEdit) +static inline void LEFromScrap(void) { + __asm__ volatile ( + "ldx #0x1914\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x1C14 set 0x14 (LineEdit) +static inline unsigned short LEGetScrapLen(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1C14\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * LEGetTextHand(void * a0); // 0x2214 +extern unsigned short LEGetTextLen(void * a0); // 0x2314 +extern void LEIdle(void * a0); // 0x0C14 +extern void LEInsert(void * a0, unsigned short a1, void * a2); // 0x1614 +extern void LEKey(unsigned short a0, unsigned short a1, void * a2); // 0x1114 +extern void * LENew(void * a0, void * a1, unsigned short a2); // 0x0914 +extern void LEPaste(void * a0); // 0x1414 +extern void * LEScrapHandle(void); // 0x1B14 +extern void LESetCaret(void * a0, void * a1); // 0x1F14 +extern void LESetHilite(void * a0, void * a1); // 0x1E14 +extern void LESetJust(unsigned short a0, void * a1); // 0x2114 +// tool 0x1D14 set 0x14 (LineEdit) +static inline void LESetScrapLen(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1D14\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void LESetSelect(unsigned short a0, unsigned short a1, void * a2); // 0x0E14 +extern void LESetText(void * a0, unsigned short a1, void * a2); // 0x0B14 +extern void LETextBox(void * a0, unsigned short a1, void * a2, unsigned short a3); // 0x1814 +extern void LETextBox2(void * a0, unsigned short a1, void * a2, unsigned short a3); // 0x2014 +// tool 0x1A14 set 0x14 (LineEdit) +static inline void LEToScrap(void) { + __asm__ volatile ( + "ldx #0x1A14\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void LEUpdate(void * a0); // 0x1714 +extern void * GetLEDefProc(void); // 0x2414 +extern unsigned short LEClassifyKey(void * a0); // 0x2514 +// tool 0x011C set 0x1C (ListManager) +static inline void ListBootInit(void) { + __asm__ volatile ( + "ldx #0x011C\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x021C set 0x1C (ListManager) +static inline void ListStartUp(void) { + __asm__ volatile ( + "ldx #0x021C\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x031C set 0x1C (ListManager) +static inline void ListShutDown(void) { + __asm__ volatile ( + "ldx #0x031C\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x041C set 0x1C (ListManager) +static inline unsigned short ListVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x041C\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x051C set 0x1C (ListManager) +static inline void ListReset(void) { + __asm__ volatile ( + "ldx #0x051C\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x061C set 0x1C (ListManager) +static inline unsigned short ListStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x061C\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * CreateList(void * a0, void * a1); // 0x091C +extern void DrawMember(void * a0, void * a1); // 0x0C1C +extern void * GetListDefProc(void); // 0x0E1C +extern void NewList(void * a0, void * a1); // 0x101C +extern void * NextMember(void * a0, void * a1); // 0x0B1C +extern void * ResetMember(void * a0); // 0x0F1C +extern void SelectMember(void * a0, void * a1); // 0x0D1C +extern void SortList(void * a0, void * a1); // 0x0A1C +extern void DrawMember2(unsigned short a0, void * a1); // 0x111C +extern void NewList2(void * a0, unsigned short a1, void * a2, unsigned short a3, unsigned short a4, void * a5); // 0x161C +extern unsigned short NextMember2(unsigned short a0, void * a1); // 0x121C +extern unsigned short ResetMember2(void * a0); // 0x131C +extern void SelectMember2(unsigned short a0, void * a1); // 0x141C +extern void SortList2(void * a0, void * a1); // 0x151C +extern unsigned short CompareStrings(unsigned short a0, void * a1, void * a2); // 0x181C +extern void ListKey(unsigned short a0, void * a1, void * a2); // 0x171C +extern void GetLoadSegInfo(unsigned short a0, unsigned short a1, unsigned short a2, void * a3); // 0x0F11 +extern unsigned short GetUserID(void * a0); // 0x1011 +extern unsigned short GetUserID2(void * a0); // 0x2111 +extern void * LGetPathname(unsigned short a0, unsigned short a1); // 0x1111 +extern void * LGetPathname2(unsigned short a0, unsigned short a1); // 0x2211 +// tool 0x0111 set 0x11 (Loader) +static inline void LoaderInitialization(void) { + __asm__ volatile ( + "ldx #0x0111\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0511 set 0x11 (Loader) +static inline void LoaderReset(void) { + __asm__ volatile ( + "ldx #0x0511\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0311 set 0x11 (Loader) +static inline void LoaderShutDown(void) { + __asm__ volatile ( + "ldx #0x0311\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0211 set 0x11 (Loader) +static inline void LoaderStartUp(void) { + __asm__ volatile ( + "ldx #0x0211\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0611 set 0x11 (Loader) +static inline unsigned short LoaderStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0611\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0411 set 0x11 (Loader) +static inline unsigned short LoaderVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0411\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * LoadSegNum(unsigned short a0, unsigned short a1, unsigned short a2); // 0x0B11 +extern void RenamePathname(void * a0, void * a1); // 0x1311 +extern void UnloadSegNum(unsigned short a0, unsigned short a1, unsigned short a2); // 0x0C11 +extern unsigned short UserShutDown(unsigned short a0, unsigned short a1); // 0x1211 +extern void * GetPathname(void); // 0x1111 +extern void * GetPathname2(void); // 0x2211 +// tool 0x0101 set 0x01 (ToolLocator) +static inline void TLBootInit(void) { + __asm__ volatile ( + "ldx #0x0101\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0201 set 0x01 (ToolLocator) +static inline void TLStartUp(void) { __asm__ volatile ( "ldx #0x0201\n" "jsl 0xe10000\n" @@ -49,7 +1692,8 @@ static inline void TBoxTLStartUp(void) { ); } -static inline void TBoxTLShutDown(void) { +// tool 0x0301 set 0x01 (ToolLocator) +static inline void TLShutDown(void) { __asm__ volatile ( "ldx #0x0301\n" "jsl 0xe10000\n" @@ -59,52 +1703,1186 @@ static inline void TBoxTLShutDown(void) { ); } -// ===================================================================== -// Memory Manager (Set $02) -// ===================================================================== - -// MMStartUp — call as the first MM routine. Returns the caller's -// 16-bit userId; save it for later DisposeAll calls. -static inline unsigned short TBoxMMStartUp(void) { - unsigned short id; +// tool 0x0401 set 0x01 (ToolLocator) +static inline unsigned short TLVersion(void) { + unsigned short _r; __asm__ volatile ( - "pha\n" // result space + "pha\n" // result space + "ldx #0x0401\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0501 set 0x01 (ToolLocator) +static inline void TLReset(void) { + __asm__ volatile ( + "ldx #0x0501\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0601 set 0x01 (ToolLocator) +static inline unsigned short TLStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0601\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetFuncPtr(unsigned short a0, unsigned short a1); // 0x0B01 +extern void * GetTSPtr(unsigned short a0, unsigned short a1); // 0x0901 +extern void * GetWAP(unsigned short a0, unsigned short a1); // 0x0C01 +extern void LoadOneTool(unsigned short a0, unsigned short a1); // 0x0F01 +extern void LoadTools(void * a0); // 0x0E01 +extern void MessageCenter(unsigned short a0, unsigned short a1, void * a2); // 0x1501 +extern void RestoreTextState(void * a0); // 0x1401 +extern void * SaveTextState(void); // 0x1301 +extern void SetTSPtr(unsigned short a0, unsigned short a1, void * a2); // 0x0A01 +extern void SetWAP(unsigned short a0, unsigned short a1, void * a2); // 0x0D01 +extern unsigned short TLMountVolume(short a0, short a1, void * a2, void * a3, void * a4, void * a5); // 0x1101 +extern unsigned short TLTextMountVolume(void * a0, void * a1, void * a2, void * a3); // 0x1201 +// tool 0x1001 set 0x01 (ToolLocator) +static inline void UnloadOneTool(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1001\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void * MessageByName(unsigned short a0, void * a1); // 0x1701 +// tool 0x1601 set 0x01 (ToolLocator) +static inline void SetDefaultTPT(void) { + __asm__ volatile ( + "ldx #0x1601\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void ShutDownTools(unsigned short a0, void * a1); // 0x1901 +extern void * StartUpTools(unsigned short a0, unsigned short a1, void * a2); // 0x1801 +extern void AcceptRequests(void * a0, unsigned short a1, void * a2); // 0x1B01 +extern void * GetMsgHandle(unsigned short a0, long a1); // 0x1A01 +extern void SendRequest(unsigned short a0, unsigned short a1, long a2, long a3, void * a4); // 0x1C01 +// tool 0x0126 set 0x26 (?) +static inline void MCBootInit(void) { + __asm__ volatile ( + "ldx #0x0126\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0226 set 0x26 (?) +static inline void MCStartUp(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0226\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x0326 set 0x26 (?) +static inline void MCShutDown(void) { + __asm__ volatile ( + "ldx #0x0326\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0426 set 0x26 (?) +static inline unsigned short MCVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0426\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0526 set 0x26 (?) +static inline void MCReset(void) { + __asm__ volatile ( + "ldx #0x0526\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0626 set 0x26 (?) +static inline unsigned short MCStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0626\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern long MCBinToTime(long a0); // 0x0D26 +extern void MCControl(unsigned short a0, unsigned short a1); // 0x1B26 +// tool 0x1526 set 0x26 (?) +static inline void MCDShutDown(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1526\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void MCDStartUp(unsigned short a0, void * a1, unsigned short a2); // 0x1426 +extern long MCGetDiscID(unsigned short a0); // 0x2826 +extern void MCGetDiscTitle(long a0, void * a1); // 0x1226 +extern long MCGetDiscTOC(unsigned short a0, unsigned short a1); // 0x2726 +extern void MCGetErrorMsg(unsigned short a0, void * a1); // 0x0926 +extern long MCGetFeatures(unsigned short a0, unsigned short a1); // 0x1626 +extern void MCGetName(unsigned short a0, void * a1); // 0x2D26 +// tool 0x2926 set 0x26 (?) +static inline unsigned short MCGetNoTracks(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x2926\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern long MCGetPosition(unsigned short a0, unsigned short a1); // 0x2426 +extern void MCGetProgram(long a0, void * a1); // 0x1026 +extern void MCGetSpeeds(unsigned short a0, void * a1); // 0x1D26 +extern unsigned short MCGetStatus(unsigned short a0, unsigned short a1); // 0x1A26 +extern long MCGetTimes(unsigned short a0, unsigned short a1); // 0x2626 +extern void MCGetTrackTitle(long a0, unsigned short a1, void * a2); // 0x0E26 +extern void MCJog(unsigned short a0, long a1, unsigned short a2); // 0x2026 +// tool 0x0A26 set 0x26 (?) +static inline void MCLoadDriver(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0A26\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x1826 set 0x26 (?) +static inline void MCPause(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1826\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x1726 set 0x26 (?) +static inline void MCPlay(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1726\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x2A26 set 0x26 (?) +static inline void MCRecord(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x2A26\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void MCScan(unsigned short a0, unsigned short a1); // 0x1C26 +// tool 0x2226 set 0x26 (?) +static inline unsigned short MCSearchDone(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x2226\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void MCSearchTo(unsigned short a0, unsigned short a1, long a2); // 0x2126 +// tool 0x2326 set 0x26 (?) +static inline void MCSearchWait(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x2326\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void MCSendRawData(unsigned short a0, long a1); // 0x1926 +extern void MCSetAudio(unsigned short a0, unsigned short a1); // 0x2526 +extern void MCSetDiscTitle(long a0, long a1); // 0x1326 +extern void MCSetProgram(long a0, long a1); // 0x1126 +extern void MCSetTrackTitle(long a0, unsigned short a1, void * a2); // 0x0F26 +extern void MCSetVolume(unsigned short a0, unsigned short a1, unsigned short a2); // 0x2E26 +extern void MCSpeed(unsigned short a0, unsigned short a1); // 0x1E26 +// tool 0x2B26 set 0x26 (?) +static inline void MCStop(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x2B26\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void MCStopAt(unsigned short a0, unsigned short a1, long a2); // 0x1F26 +extern long MCTimeToBin(long a0); // 0x0C26 +// tool 0x0B26 set 0x26 (?) +static inline void MCUnLoadDriver(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0B26\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void MCWaitRawData(unsigned short a0, void * a1, unsigned short a2, unsigned short a3); // 0x2C26 +// tool 0x0102 set 0x02 (MemoryManager) +static inline void MMBootInit(void) { + __asm__ volatile ( + "ldx #0x0102\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0202 set 0x02 (MemoryManager) +static inline unsigned short MMStartUp(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space "ldx #0x0202\n" "jsl 0xe10000\n" "pla\n" - : "=a"(id) + : "=a"(_r) : : "x", "y", "memory" ); - return id; + return _r; } -// MMShutDown — releases all MM resources owned by `userId`. -static inline void TBoxMMShutDown(unsigned short userId) { +// tool 0x0302 set 0x02 (MemoryManager) +static inline void MMShutDown(unsigned short a0) { __asm__ volatile ( - "pha\n" + "pha\n" // arg0 "ldx #0x0302\n" "jsl 0xe10000\n" : - : "a"(userId) + : "a"(a0) : "x", "y", "memory" ); } -// NewHandle / DisposeHandle live in iigsToolbox.s — the parameter -// blocks are 4-arg with mixed widths and need explicit asm. -extern unsigned long TBoxNewHandle(unsigned long size, - unsigned short userId, - unsigned short attr, - unsigned long addr); -extern void TBoxDisposeHandle(unsigned long handle); +// tool 0x0402 set 0x02 (MemoryManager) +static inline unsigned short MMVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0402\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} -// ===================================================================== -// Misc Tools (Set $03) -// ===================================================================== +// tool 0x0502 set 0x02 (MemoryManager) +static inline void MMReset(void) { + __asm__ volatile ( + "ldx #0x0502\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} -// SysBeep — short beep through the speaker. -static inline void TBoxBeep(void) { +// tool 0x0602 set 0x02 (MemoryManager) +static inline unsigned short MMStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0602\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void BlockMove(void * a0, void * a1, unsigned long a2); // 0x2B02 +extern void CheckHandle(void * a0); // 0x1E02 +// tool 0x1F02 set 0x02 (MemoryManager) +static inline void CompactMem(void) { + __asm__ volatile ( + "ldx #0x1F02\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x1102 set 0x02 (MemoryManager) +static inline void DisposeAll(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1102\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void DisposeHandle(void * a0); // 0x1002 +extern void * FindHandle(void * a0); // 0x1A02 +extern unsigned long FreeMem(void); // 0x1B02 +extern unsigned long GetHandleSize(void * a0); // 0x1802 +extern void HandToHand(void * a0, void * a1, unsigned long a2); // 0x2A02 +extern void HandToPtr(void * a0, void * a1, unsigned long a2); // 0x2902 +extern void HLock(void * a0); // 0x2002 +// tool 0x2102 set 0x02 (MemoryManager) +static inline void HLockAll(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x2102\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void HUnlock(void * a0); // 0x2202 +// tool 0x2302 set 0x02 (MemoryManager) +static inline void HUnlockAll(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x2302\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern unsigned long MaxBlock(void); // 0x1C02 +extern void * NewHandle(unsigned long a0, unsigned short a1, unsigned short a2, void * a3); // 0x0902 +extern void PtrToHand(void * a0, void * a1, unsigned long a2); // 0x2802 +// tool 0x1302 set 0x02 (MemoryManager) +static inline void PurgeAll(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1302\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void PurgeHandle(void * a0); // 0x1202 +extern void ReAllocHandle(unsigned long a0, unsigned short a1, unsigned short a2, void * a3, void * a4); // 0x0A02 +extern void RestoreHandle(void * a0); // 0x0B02 +extern void SetHandleSize(unsigned long a0, void * a1); // 0x1902 +extern void SetPurge(unsigned short a0, void * a1); // 0x2402 +extern void SetPurgeAll(unsigned short a0, unsigned short a1); // 0x2502 +extern unsigned long TotalMem(void); // 0x1D02 +extern void AddToOOMQueue(void * a0); // 0x0C02 +extern unsigned long RealFreeMem(void); // 0x2F02 +extern void RemoveFromOOMQueue(void * a0); // 0x0D02 +extern unsigned short SetHandleID(unsigned short a0, void * a1); // 0x3002 +// tool 0x010F set 0x0F (MenuManager) +static inline void MenuBootInit(void) { + __asm__ volatile ( + "ldx #0x010F\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void MenuStartUp(unsigned short a0, unsigned short a1); // 0x020F +// tool 0x030F set 0x0F (MenuManager) +static inline void MenuShutDown(void) { + __asm__ volatile ( + "ldx #0x030F\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x040F set 0x0F (MenuManager) +static inline unsigned short MenuVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x040F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x050F set 0x0F (MenuManager) +static inline void MenuReset(void) { + __asm__ volatile ( + "ldx #0x050F\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x060F set 0x0F (MenuManager) +static inline unsigned short MenuStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x060F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void CalcMenuSize(unsigned short a0, unsigned short a1, unsigned short a2); // 0x1C0F +extern void CheckMItem(unsigned short a0, unsigned short a1); // 0x320F +// tool 0x140F set 0x0F (MenuManager) +static inline unsigned short CountMItems(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x140F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0E0F set 0x0F (MenuManager) +static inline void DeleteMenu(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0E0F\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x100F set 0x0F (MenuManager) +static inline void DeleteMItem(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x100F\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x310F set 0x0F (MenuManager) +static inline void DisableMItem(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x310F\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void DisposeMenu(void * a0); // 0x2E0F +// tool 0x2A0F set 0x0F (MenuManager) +static inline void DrawMenuBar(void) { + __asm__ volatile ( + "ldx #0x2A0F\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x300F set 0x0F (MenuManager) +static inline void EnableMItem(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x300F\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x130F set 0x0F (MenuManager) +static inline unsigned short FixMenuBar(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x130F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0C0F set 0x0F (MenuManager) +static inline void FlashMenuBar(void) { + __asm__ volatile ( + "ldx #0x0C0F\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern unsigned long GetBarColors(void); // 0x180F +extern void * GetMenuBar(void); // 0x0A0F +// tool 0x200F set 0x0F (MenuManager) +static inline unsigned short GetMenuFlag(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x200F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetMenuMgrPort(void); // 0x1B0F +extern void * GetMenuTitle(unsigned short a0); // 0x220F +extern void * GetMHandle(unsigned short a0); // 0x160F +extern void * GetMItem(unsigned short a0); // 0x250F +// tool 0x270F set 0x0F (MenuManager) +static inline unsigned short GetMItemFlag(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x270F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x340F set 0x0F (MenuManager) +static inline unsigned short GetMItemMark(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x340F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetMItemStyle(unsigned short a0); // 0x360F +// tool 0x1A0F set 0x0F (MenuManager) +static inline unsigned short GetMTitleStart(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1A0F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1E0F set 0x0F (MenuManager) +static inline unsigned short GetMTitleWidth(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1E0F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetSysBar(void); // 0x110F +extern void HiliteMenu(unsigned short a0, unsigned short a1); // 0x2C0F +// tool 0x2F0F set 0x0F (MenuManager) +static inline void InitPalette(void) { + __asm__ volatile ( + "ldx #0x2F0F\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void InsertMenu(void * a0, unsigned short a1); // 0x0D0F +extern void InsertMItem(void * a0, unsigned short a1, unsigned short a2); // 0x0F0F +// tool 0x230F set 0x0F (MenuManager) +static inline unsigned short MenuGlobal(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x230F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void MenuKey(void * a0, void * a1); // 0x090F +// tool 0x290F set 0x0F (MenuManager) +static inline void MenuNewRes(void) { + __asm__ volatile ( + "ldx #0x290F\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void MenuRefresh(void * a0); // 0x0B0F +extern void MenuSelect(void * a0, void * a1); // 0x2B0F +extern void * NewMenu(void * a0); // 0x2D0F +extern void * NewMenuBar(void * a0); // 0x150F +extern void SetBarColors(unsigned short a0, unsigned short a1, unsigned short a2); // 0x170F +extern void SetMenuBar(void * a0); // 0x390F +extern void SetMenuFlag(unsigned short a0, unsigned short a1); // 0x1F0F +extern void SetMenuID(unsigned short a0, unsigned short a1); // 0x370F +extern void SetMenuTitle(void * a0, unsigned short a1); // 0x210F +extern void SetMItem(void * a0, unsigned short a1); // 0x240F +// tool 0x280F set 0x0F (MenuManager) +static inline void SetMItemBlink(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x280F\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetMItemFlag(unsigned short a0, unsigned short a1); // 0x260F +extern void SetMItemID(unsigned short a0, unsigned short a1); // 0x380F +extern void SetMItemMark(unsigned short a0, unsigned short a1); // 0x330F +extern void SetMItemName(void * a0, unsigned short a1); // 0x3A0F +extern void SetMItemStyle(void * a0, unsigned short a1); // 0x350F +// tool 0x190F set 0x0F (MenuManager) +static inline void SetMTitleStart(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x190F\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetMTitleWidth(unsigned short a0, unsigned short a1); // 0x1D0F +extern void SetSysBar(void * a0); // 0x120F +extern void * GetPopUpDefProc(void); // 0x3B0F +// tool 0x450F set 0x0F (MenuManager) +static inline void HideMenuBar(void) { + __asm__ volatile ( + "ldx #0x450F\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void InsertMItem2(unsigned short a0, void * a1, unsigned short a2, unsigned short a3); // 0x3F0F +extern void * NewMenu2(unsigned short a0, void * a1); // 0x3E0F +extern void * NewMenuBar2(unsigned short a0, void * a1, void * a2); // 0x430F +extern unsigned short PopUpMenuSelect(unsigned short a0, unsigned short a1, unsigned short a2, unsigned short a3, void * a4); // 0x3C0F +extern void SetMenuTitle2(unsigned short a0, void * a1, unsigned short a2); // 0x400F +extern void SetMItem2(unsigned short a0, void * a1, unsigned short a2); // 0x410F +extern void SetMItemName2(unsigned short a0, void * a1, unsigned short a2); // 0x420F +// tool 0x460F set 0x0F (MenuManager) +static inline void ShowMenuBar(void) { + __asm__ volatile ( + "ldx #0x460F\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x4F0F set 0x0F (MenuManager) +static inline unsigned short GetMItemBlink(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x4F0F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x4C0F set 0x0F (MenuManager) +static inline unsigned short GetMItemFlag2(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x4C0F\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetMItemIcon(unsigned short a0); // 0x480F +extern void * GetMItemStruct(unsigned short a0); // 0x4A0F +extern void InsertPathMItems(unsigned short a0, void * a1, unsigned short a2, unsigned short a3, unsigned short a4, unsigned short a5, void * a6); // 0x500F +// tool 0x4B0F set 0x0F (MenuManager) +static inline void RemoveMItemStruct(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x4B0F\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetMItemFlag2(unsigned short a0, unsigned short a1); // 0x4D0F +extern void SetMItemIcon(unsigned short a0, void * a1, unsigned short a2); // 0x470F +extern void SetMItemStruct(unsigned short a0, void * a1, unsigned short a2); // 0x490F +// tool 0x0120 set 0x20 (VideoOverlay) +static inline void MidiBootInit(void) { + __asm__ volatile ( + "ldx #0x0120\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void MidiStartUp(unsigned short a0, unsigned short a1); // 0x0220 +// tool 0x0320 set 0x20 (VideoOverlay) +static inline void MidiShutDown(void) { + __asm__ volatile ( + "ldx #0x0320\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0420 set 0x20 (VideoOverlay) +static inline unsigned short MidiVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0420\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0520 set 0x20 (VideoOverlay) +static inline void MidiReset(void) { + __asm__ volatile ( + "ldx #0x0520\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0620 set 0x20 (VideoOverlay) +static inline unsigned short MidiStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0620\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void MidiClock(unsigned short a0, long a1); // 0x0B20 +extern void MidiControl(unsigned short a0, long a1); // 0x0920 +extern void MidiDevice(unsigned short a0, void * a1); // 0x0A20 +extern unsigned long MidiInfo(unsigned short a0); // 0x0C20 +extern unsigned short MidiReadPacket(void * a0, unsigned short a1); // 0x0D20 +extern unsigned short MidiWritePacket(void * a0); // 0x0E20 +// tool 0x0123 set 0x23 (MediaControl) +static inline void MSBootInit(void) { + __asm__ volatile ( + "ldx #0x0123\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0223 set 0x23 (MediaControl) +static inline void MSStartUp(void) { + __asm__ volatile ( + "ldx #0x0223\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0323 set 0x23 (MediaControl) +static inline void MSShutDown(void) { + __asm__ volatile ( + "ldx #0x0323\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void * MSVersion(void); // 0x0423 +// tool 0x0523 set 0x23 (MediaControl) +static inline void MSReset(void) { + __asm__ volatile ( + "ldx #0x0523\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void * MSStatus(void); // 0x0623 +extern void * ConvertToTime(unsigned short a0, unsigned short a1, unsigned short a2, unsigned short a3); // 0x2023 +extern void DeleteTrack(unsigned short a0, void * a1); // 0x1D23 +extern void GetTuningTable(void * a0); // 0x2523 +extern void InitMIDIDriver(unsigned short a0, unsigned short a1, unsigned short a2, void * a3); // 0x2723 +// tool 0x0D23 set 0x23 (MediaControl) +static inline void KillAllNotes(void) { + __asm__ volatile ( + "ldx #0x0D23\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void * Locate(long a0, void * a1); // 0x1123 +extern void * LocateEnd(void * a0); // 0x1B23 +extern void Merge(void * a0, void * a1); // 0x1C23 +extern void MIDIMessage(unsigned short a0, unsigned short a1, unsigned short a2, unsigned short a3, unsigned short a4); // 0x1A23 +// tool 0x2323 set 0x23 (MediaControl) +static inline void MSResume(void) { + __asm__ volatile ( + "ldx #0x2323\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x2223 set 0x23 (MediaControl) +static inline void MSSuspend(void) { + __asm__ volatile ( + "ldx #0x2223\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void PlayNote(unsigned short a0, unsigned short a1, unsigned short a2); // 0x0B23 +// tool 0x2823 set 0x23 (MediaControl) +static inline void RemoveMIDIDriver(void) { + __asm__ volatile ( + "ldx #0x2823\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void SeqPlayer(void * a0); // 0x1523 +// tool 0x0923 set 0x23 (MediaControl) +static inline void SetBasicChan(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0923\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x0923 set 0x23 (MediaControl) +static inline void SetBasicChannel(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0923\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x1923 set 0x23 (MediaControl) +static inline void SetBeat(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1923\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetCallBack(void * a0); // 0x1723 +extern void SetInstrument(void * a0, unsigned short a1); // 0x1423 +extern void SetMetro(unsigned short a0, unsigned short a1, void * a2); // 0x1E23 +// tool 0x0A23 set 0x23 (MediaControl) +static inline void SetMIDIMode(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0A23\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetMIDIPort(unsigned short a0, unsigned short a1); // 0x1323 +extern void SetPlayTrack(unsigned short a0, unsigned short a1); // 0x0F23 +// tool 0x0E23 set 0x23 (MediaControl) +static inline void SetRecTrack(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0E23\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x1623 set 0x23 (MediaControl) +static inline void SetTempo(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1623\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetTrackOut(unsigned short a0, unsigned short a1); // 0x2623 +extern void SetTuningTable(void * a0); // 0x2423 +// tool 0x1223 set 0x23 (MediaControl) +static inline void SetVelComp(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1223\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void StopNote(unsigned short a0, unsigned short a1); // 0x0C23 +extern void SysExOut(void * a0, unsigned short a1, void * a2); // 0x1823 +extern void TrackToChannel(unsigned short a0, unsigned short a1); // 0x1023 +// tool 0x0103 set 0x03 (MiscTools) +static inline void MTBootInit(void) { + __asm__ volatile ( + "ldx #0x0103\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0203 set 0x03 (MiscTools) +static inline void MTStartUp(void) { + __asm__ volatile ( + "ldx #0x0203\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0303 set 0x03 (MiscTools) +static inline void MTShutDown(void) { __asm__ volatile ( "ldx #0x0303\n" "jsl 0xe10000\n" @@ -114,43 +2892,902 @@ static inline void TBoxBeep(void) { ); } -// WriteCString — Misc Tool $0B; writes a NUL-terminated string to -// the text screen. Note: actual GS uses Text Tools or stdio; -// this is the legacy entry point. -static inline void TBoxWriteCString(const char *s) { +// tool 0x0403 set 0x03 (MiscTools) +static inline unsigned short MTVersion(void) { + unsigned short _r; __asm__ volatile ( - "pha\n" - "ldx #0x290B\n" + "pha\n" // result space + "ldx #0x0403\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0503 set 0x03 (MiscTools) +static inline void MTReset(void) { + __asm__ volatile ( + "ldx #0x0503\n" "jsl 0xe10000\n" : - : "a"(s) + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0603 set 0x03 (MiscTools) +static inline unsigned short MTStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0603\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void WriteBRam(void * a0); // 0x0903 +extern void ReadBRam(void * a0); // 0x0A03 +extern void WriteBParam(unsigned short a0, unsigned short a1); // 0x0B03 +// tool 0x0C03 set 0x03 (MiscTools) +static inline unsigned short ReadBParam(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x0C03\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void WriteTimeHex(void * a0); // 0x0E03 +extern void ReadAsciiTime(void * a0); // 0x0F03 +extern void * GetAddr(unsigned short a0); // 0x1603 +extern unsigned long GetTick(void); // 0x2503 +// tool 0x2903 set 0x03 (MiscTools) +static inline unsigned short GetIRQEnable(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x2903\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x2303 set 0x03 (MiscTools) +static inline void IntSource(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x2303\n" + "jsl 0xe10000\n" + : + : "a"(a0) : "x", "y", "memory" ); } -// ReadAsciiTime — fills a 20-byte buffer with the current time -// formatted as "DDD MMM dd hh:mm:ss yyyy". -static inline void TBoxReadAsciiTime(char *buf20) { +extern void ClampMouse(unsigned short a0, unsigned short a1, unsigned short a2, unsigned short a3); // 0x1C03 +// tool 0x1B03 set 0x03 (MiscTools) +static inline void ClearMouse(void) { __asm__ volatile ( - "pha\n" - "ldx #0x0F03\n" + "ldx #0x1B03\n" "jsl 0xe10000\n" : - : "a"(buf20) + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x1A03 set 0x03 (MiscTools) +static inline void HomeMouse(void) { + __asm__ volatile ( + "ldx #0x1A03\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x1803 set 0x03 (MiscTools) +static inline void InitMouse(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1803\n" + "jsl 0xe10000\n" + : + : "a"(a0) : "x", "y", "memory" ); } -// ===================================================================== -// QuickDraw II (Set $04) -// ===================================================================== +extern void PosMouse(short a0, short a1); // 0x1E03 +// tool 0x1F03 set 0x03 (MiscTools) +static inline unsigned short ServeMouse(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1F03\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} -// QDStartUp / QDShutDown. Multi-arg startup lives in iigsToolbox.s. -extern void TBoxQDStartUp(unsigned short masterSCB, - unsigned short pageSize, - unsigned short userId); +// tool 0x1903 set 0x03 (MiscTools) +static inline void SetMouse(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1903\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} -static inline void TBoxQDShutDown(void) { +extern unsigned short PackBytes(void * a0, unsigned short a1, void * a2, unsigned short a3); // 0x2603 +extern unsigned short UnPackBytes(void * a0, unsigned short a1, void * a2, unsigned short a3); // 0x2703 +extern unsigned short Munger(void * a0, unsigned short a1, void * a2, unsigned short a3, void * a4, unsigned short a5, void * a6); // 0x2803 +extern void SetHeartBeat(void * a0); // 0x1203 +extern void DelHeartBeat(void * a0); // 0x1303 +// tool 0x1403 set 0x03 (MiscTools) +static inline void ClrHeartBeat(void) { + __asm__ volatile ( + "ldx #0x1403\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x2C03 set 0x03 (MiscTools) +static inline void SysBeep(void) { + __asm__ volatile ( + "ldx #0x2C03\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void SysFailMgr(unsigned short a0, void * a1); // 0x1503 +// tool 0x2003 set 0x03 (MiscTools) +static inline unsigned short GetNewID(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x2003\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x2103 set 0x03 (MiscTools) +static inline void DeleteID(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x2103\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x2203 set 0x03 (MiscTools) +static inline void StatusID(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x2203\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetVector(unsigned short a0, void * a1); // 0x1003 +extern void * GetVector(unsigned short a0); // 0x1103 +extern void AddToQueue(void * a0, void * a1); // 0x2E03 +extern void DeleteFromQueue(void * a0, void * a1); // 0x2F03 +extern void * GetCodeResConverter(void); // 0x3403 +extern void GetInterruptState(void * a0, unsigned short a1); // 0x3103 +// tool 0x3203 set 0x03 (MiscTools) +static inline unsigned short GetIntStateRecSize(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x3203\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void SetInterruptState(void * a0, unsigned short a1); // 0x3003 +extern unsigned long ConvSeconds(unsigned short a0, long a1, void * a2); // 0x3703 +// tool 0x3D03 set 0x03 (MiscTools) +static inline unsigned short ScanDevices(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x3D03\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void ShowBootInfo(void * a0, void * a1); // 0x3C03 +extern unsigned long StringToText(unsigned short a0, void * a1, unsigned short a2, void * a3); // 0x3B03 +// tool 0x3803 set 0x03 (MiscTools) +static inline void SysBeep2(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x3803\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void VersionString(unsigned short a0, long a1, void * a2); // 0x3903 +extern unsigned short WaitUntil(unsigned short a0, unsigned short a1); // 0x3A03 +extern unsigned short AlertMessage(void * a0, unsigned short a1, void * a2); // 0x3E03 +extern unsigned short DoSysPrefs(unsigned short a0, unsigned short a1); // 0x3F03 +// tool 0x011A set 0x1A (NoteSequencer) +static inline void SeqBootInit(void) { + __asm__ volatile ( + "ldx #0x011A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void SeqStartUp(unsigned short a0, unsigned short a1, unsigned short a2, unsigned short a3); // 0x021A +// tool 0x031A set 0x1A (NoteSequencer) +static inline void SeqShutDown(void) { + __asm__ volatile ( + "ldx #0x031A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x041A set 0x1A (NoteSequencer) +static inline unsigned short SeqVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x041A\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x051A set 0x1A (NoteSequencer) +static inline void SeqReset(void) { + __asm__ volatile ( + "ldx #0x051A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x061A set 0x1A (NoteSequencer) +static inline unsigned short SeqStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x061A\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0A1A set 0x1A (NoteSequencer) +static inline unsigned short ClearIncr(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0A1A\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0B1A set 0x1A (NoteSequencer) +static inline unsigned short GetTimer(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0B1A\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0D1A set 0x1A (NoteSequencer) +static inline void SeqAllNotesOff(void) { + __asm__ volatile ( + "ldx #0x0D1A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x091A set 0x1A (NoteSequencer) +static inline void SetIncr(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x091A\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetInstTable(void * a0); // 0x121A +extern void SetTrkInfo(unsigned short a0, unsigned short a1, unsigned short a2); // 0x0E1A +// tool 0x131A set 0x1A (NoteSequencer) +static inline void StartInts(void) { + __asm__ volatile ( + "ldx #0x131A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void StartSeq(void * a0, void * a1, void * a2); // 0x0F1A +extern void StartSeqRel(void * a0, void * a1, void * a2); // 0x151A +// tool 0x101A set 0x1A (NoteSequencer) +static inline void StepSeq(void) { + __asm__ volatile ( + "ldx #0x101A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x141A set 0x1A (NoteSequencer) +static inline void StopInts(void) { + __asm__ volatile ( + "ldx #0x141A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x111A set 0x1A (NoteSequencer) +static inline void StopSeq(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x111A\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x0119 set 0x19 (NoteSynth) +static inline void NSBootInit(void) { + __asm__ volatile ( + "ldx #0x0119\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void NSStartUp(unsigned short a0, void * a1); // 0x0219 +// tool 0x0319 set 0x19 (NoteSynth) +static inline void NSShutDown(void) { + __asm__ volatile ( + "ldx #0x0319\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0419 set 0x19 (NoteSynth) +static inline unsigned short NSVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0419\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0519 set 0x19 (NoteSynth) +static inline void NSReset(void) { + __asm__ volatile ( + "ldx #0x0519\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0619 set 0x19 (NoteSynth) +static inline unsigned short NSStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0619\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0D19 set 0x19 (NoteSynth) +static inline void AllNotesOff(void) { + __asm__ volatile ( + "ldx #0x0D19\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0919 set 0x19 (NoteSynth) +static inline unsigned short AllocGen(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x0919\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0A19 set 0x19 (NoteSynth) +static inline void DeallocGen(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0A19\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void NoteOff(unsigned short a0, unsigned short a1); // 0x0C19 +extern void NoteOn(unsigned short a0, unsigned short a1, unsigned short a2, void * a3); // 0x0B19 +// tool 0x0E19 set 0x19 (NoteSynth) +static inline unsigned short NSSetUpdateRate(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x0E19\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void * NSSetUserUpdateRtn(void * a0); // 0x0F19 +// tool 0x0113 set 0x13 (PrintManager) +static inline void PMBootInit(void) { + __asm__ volatile ( + "ldx #0x0113\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void PMStartUp(unsigned short a0, unsigned short a1); // 0x0213 +// tool 0x0313 set 0x13 (PrintManager) +static inline void PMShutDown(void) { + __asm__ volatile ( + "ldx #0x0313\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0413 set 0x13 (PrintManager) +static inline unsigned short PMVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0413\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0513 set 0x13 (PrintManager) +static inline void PMReset(void) { + __asm__ volatile ( + "ldx #0x0513\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0613 set 0x13 (PrintManager) +static inline unsigned short PMStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0613\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1613 set 0x13 (PrintManager) +static inline unsigned short PrChoosePrinter(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1613\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1613 set 0x13 (PrintManager) +static inline unsigned short PrChooser(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1613\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void PrCloseDoc(void * a0); // 0x0F13 +extern void PrClosePage(void * a0); // 0x1113 +extern void PrDefault(void * a0); // 0x0913 +// tool 0x2313 set 0x13 (PrintManager) +static inline unsigned short PrDriverVer(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x2313\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1413 set 0x13 (PrintManager) +static inline unsigned short PrError(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1413\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned short PrJobDialog(void * a0); // 0x0C13 +extern void * PrOpenDoc(void * a0, void * a1); // 0x0E13 +extern void PrOpenPage(void * a0, void * a1); // 0x1013 +extern void PrPicFile(void * a0, void * a1, void * a2); // 0x1213 +extern void PrPixelMap(void * a0, void * a1, unsigned short a2); // 0x0D13 +// tool 0x2413 set 0x13 (PrintManager) +static inline unsigned short PrPortVer(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x2413\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1513 set 0x13 (PrintManager) +static inline void PrSetError(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1513\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern unsigned short PrStlDialog(void * a0); // 0x0B13 +extern unsigned short PrValidate(void * a0); // 0x0A13 +// tool 0x3513 set 0x13 (PrintManager) +static inline void PMLoadDriver(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x3513\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x3413 set 0x13 (PrintManager) +static inline void PMUnloadDriver(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x3413\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void * PrGetDocName(void); // 0x3613 +extern unsigned short PrGetPgOrientation(void * a0); // 0x3813 +extern void * PrGetPrinterSpecs(void); // 0x1813 +extern void PrSetDocName(void * a0); // 0x3713 +extern void * PrGetNetworkName(void); // 0x2B13 +extern void * PrGetPortDvrName(void); // 0x2913 +extern void * PrGetPrinterDvrName(void); // 0x2813 +extern void * PrGetUserName(void); // 0x2A13 +extern void * PrGetZoneName(void); // 0x2513 +// tool 0x0112 set 0x12 (QDAuxiliary) +static inline void QDAuxBootInit(void) { + __asm__ volatile ( + "ldx #0x0112\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0212 set 0x12 (QDAuxiliary) +static inline void QDAuxStartUp(void) { + __asm__ volatile ( + "ldx #0x0212\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0312 set 0x12 (QDAuxiliary) +static inline void QDAuxShutDown(void) { + __asm__ volatile ( + "ldx #0x0312\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0412 set 0x12 (QDAuxiliary) +static inline unsigned short QDAuxVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0412\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0512 set 0x12 (QDAuxiliary) +static inline void QDAuxReset(void) { + __asm__ volatile ( + "ldx #0x0512\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0612 set 0x12 (QDAuxiliary) +static inline unsigned short QDAuxStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0612\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0xB904 set 0x04 (QuickDraw) +static inline void ClosePicture(void) { + __asm__ volatile ( + "ldx #0xB904\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void CopyPixels(void * a0, void * a1, void * a2, void * a3, unsigned short a4, void * a5); // 0x0912 +extern void DrawIcon(void * a0, unsigned short a1, unsigned short a2, unsigned short a3); // 0x0B12 +extern void DrawPicture(void * a0, void * a1); // 0xBA04 +extern void KillPicture(void * a0); // 0xBB04 +extern void * OpenPicture(void * a0); // 0xB704 +extern void PicComment(short a0, short a1, void * a2); // 0xB804 +// tool 0x0A12 set 0x12 (QDAuxiliary) +static inline void WaitCursor(void) { + __asm__ volatile ( + "ldx #0x0A12\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void CalcMask(void * a0, void * a1, void * a2, void * a3, unsigned short a4, void * a5, void * a6); // 0x0E12 +extern void SeedFill(void * a0, void * a1, void * a2, void * a3, unsigned short a4, unsigned short a5, unsigned short a6, void * a7, void * a8); // 0x0D12 +extern void SpecialRect(void * a0, unsigned short a1, unsigned short a2); // 0x0C12 +extern void * GetSysIcon(unsigned short a0, unsigned short a1, long a2); // 0x0F12 +// tool 0x1312 set 0x12 (QDAuxiliary) +static inline void IBeamCursor(void) { + __asm__ volatile ( + "ldx #0x1312\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void * PixelMap2Rgn(void * a0, unsigned short a1, unsigned short a2); // 0x1012 +extern void WhooshRect(long a0, void * a1, void * a2); // 0x1412 +extern void DrawStringWidth(unsigned short a0, void * a1, unsigned short a2); // 0x1512 +extern void * UseColorTable(unsigned short a0, void * a1, unsigned short a2); // 0x1612 +extern void RestoreColorTable(void * a0, unsigned short a1); // 0x1712 +// tool 0x0104 set 0x04 (QuickDraw) +static inline void QDBootInit(void) { + __asm__ volatile ( + "ldx #0x0104\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void QDStartUp(unsigned short a0, unsigned short a1, unsigned short a2, unsigned short a3); // 0x0204 +// tool 0x0304 set 0x04 (QuickDraw) +static inline void QDShutDown(void) { __asm__ volatile ( "ldx #0x0304\n" "jsl 0xe10000\n" @@ -160,69 +3797,25 @@ static inline void TBoxQDShutDown(void) { ); } -// MoveTo — move the pen to absolute (h, v). -extern void TBoxMoveTo(short h, short v); - -// DrawString — draw a Pascal-style length-prefixed string at the -// current pen position. First byte of `pstr` must be the length. -static inline void TBoxDrawString(const char *pstr) { +// tool 0x0404 set 0x04 (QuickDraw) +static inline unsigned short QDVersion(void) { + unsigned short _r; __asm__ volatile ( - "pha\n" - "ldx #0x2C04\n" + "pha\n" // result space + "ldx #0x0404\n" "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) : - : "a"(pstr) : "x", "y", "memory" ); + return _r; } -// PaintRect / FrameRect / EraseRect — rect is a 16-bit pointer to a -// 4-word Rect (top, left, bottom, right). -static inline void TBoxPaintRect(const short *rect) { +// tool 0x0504 set 0x04 (QuickDraw) +static inline void QDReset(void) { __asm__ volatile ( - "pha\n" - "ldx #0x5104\n" - "jsl 0xe10000\n" - : - : "a"(rect) - : "x", "y", "memory" - ); -} - -static inline void TBoxFrameRect(const short *rect) { - __asm__ volatile ( - "pha\n" - "ldx #0x4F04\n" - "jsl 0xe10000\n" - : - : "a"(rect) - : "x", "y", "memory" - ); -} - -static inline void TBoxEraseRect(const short *rect) { - __asm__ volatile ( - "pha\n" - "ldx #0x5004\n" - "jsl 0xe10000\n" - : - : "a"(rect) - : "x", "y", "memory" - ); -} - -// ===================================================================== -// Event Manager (Set $06) -// ===================================================================== - -// EMStartUp — initialises Event Manager with default queue and -// 640x200 mouse clamp. Args other than userId are hardcoded; if -// you need custom clamp, write your own wrapper. -extern void TBoxEMStartUp(unsigned short userId); - -static inline void TBoxEMShutDown(void) { - __asm__ volatile ( - "ldx #0x0306\n" + "ldx #0x0504\n" "jsl 0xe10000\n" : : @@ -230,11 +3823,56 @@ static inline void TBoxEMShutDown(void) { ); } -// SystemTask — gives time to background tasks. Call regularly in -// event loops. -static inline void TBoxSystemTask(void) { +// tool 0x0604 set 0x04 (QuickDraw) +static inline unsigned short QDStatus(void) { + unsigned short _r; __asm__ volatile ( - "ldx #0x0306\n" + "pha\n" // result space + "ldx #0x0604\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void AddPt(void * a0, void * a1); // 0x8004 +extern void CharBounds(unsigned short a0, void * a1); // 0xAC04 +// tool 0xA804 set 0x04 (QuickDraw) +static inline unsigned short CharWidth(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0xA804\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1504 set 0x04 (QuickDraw) +static inline void ClearScreen(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1504\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void ClipRect(void * a0); // 0x2604 +// tool 0xC204 set 0x04 (QuickDraw) +static inline void ClosePoly(void) { + __asm__ volatile ( + "ldx #0xC204\n" "jsl 0xe10000\n" : : @@ -242,76 +3880,2341 @@ static inline void TBoxSystemTask(void) { ); } -// GetNextEvent — fills the EventRecord pointed at by `theEvent` -// with the next event matching `eventMask`. Returns nonzero if an -// event was returned. -// -// EventRecord layout (16 bytes): what(2) message(4) when(4) where(4) -// modifiers(2). -extern unsigned short TBoxGetNextEvent(unsigned short eventMask, void *theEvent); - -// ===================================================================== -// Window Manager (Set $0E) -// ===================================================================== - -// NewWindow — allocate and display a new window. paramList points -// to a NewWindow parameter block (in-bank 16-bit pointer). Returns -// a 32-bit window pointer. -extern void *TBoxNewWindow(const void *paramList); - -// CloseWindow — tear down a window. Takes a 32-bit window pointer. -extern void TBoxCloseWindow(void *winPtr); - -// ===================================================================== -// GS/OS (dispatcher at $E100A8) -// ===================================================================== - -// Quit — clean program shutdown via GS/OS. pConditionTbl = 0 -// (no resume condition). Does not return. -static inline void TBoxQuit(void) { +extern void ClosePort(void * a0); // 0x1A04 +extern void CloseRgn(void * a0); // 0x6E04 +extern void CopyRgn(void * a0, void * a1); // 0x6904 +extern void CStringBounds(void * a0, void * a1); // 0xAE04 +extern unsigned short CStringWidth(void * a0); // 0xAA04 +extern void DiffRgn(void * a0, void * a1, void * a2); // 0x7304 +extern void DisposeRgn(void * a0); // 0x6804 +// tool 0xA404 set 0x04 (QuickDraw) +static inline void DrawChar(unsigned short a0) { __asm__ volatile ( - "pea 0\n" // pConditionTbl - "pea 0\n" // pParm - "ldx #0x2029\n" // GS/OS Quit - "jsl 0xe100a8\n" + "pha\n" // arg0 + "ldx #0xA404\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void DrawCString(void * a0); // 0xA604 +extern void DrawString(void * a0); // 0xA504 +extern void DrawText(void * a0, unsigned short a1); // 0xA704 +extern unsigned short EmptyRgn(void * a0); // 0x7804 +extern unsigned short EqualPt(void * a0, void * a1); // 0x8304 +extern unsigned short EqualRect(void * a0, void * a1); // 0x5104 +extern unsigned short EqualRgn(void * a0, void * a1); // 0x7704 +extern void EraseArc(void * a0, short a1, short a2); // 0x6404 +extern void EraseOval(void * a0); // 0x5A04 +extern void ErasePoly(void * a0); // 0xBE04 +extern void EraseRect(void * a0); // 0x5504 +extern void EraseRgn(void * a0); // 0x7B04 +extern void EraseRRect(void * a0, unsigned short a1, unsigned short a2); // 0x5F04 +extern void FillArc(void * a0, short a1, short a2, void * a3); // 0x6604 +extern void FillOval(void * a0, void * a1); // 0x5C04 +extern void FillPoly(void * a0, void * a1); // 0xC004 +extern void FillRect(void * a0, void * a1); // 0x5704 +extern void FillRgn(void * a0, void * a1); // 0x7D04 +extern void FillRRect(void * a0, unsigned short a1, unsigned short a2, void * a3); // 0x6104 +extern void ForceBufDims(unsigned short a0, unsigned short a1, unsigned short a2); // 0xCC04 +extern void FrameArc(void * a0, short a1, short a2); // 0x6204 +extern void FrameOval(void * a0); // 0x5804 +extern void FramePoly(void * a0); // 0xBC04 +extern void FrameRect(void * a0); // 0x5304 +extern void FrameRgn(void * a0); // 0x7904 +extern void FrameRRect(void * a0, unsigned short a1, unsigned short a2); // 0x5D04 +extern void * GetAddress(unsigned short a0); // 0x0904 +// tool 0xB104 set 0x04 (QuickDraw) +static inline unsigned short GetArcRot(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0xB104\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0xA304 set 0x04 (QuickDraw) +static inline unsigned short GetBackColor(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0xA304\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void GetBackPat(void * a0); // 0x3504 +extern void * GetCharExtra(void); // 0xD504 +extern void GetClip(void * a0); // 0x2504 +extern void * GetClipHandle(void); // 0xC704 +extern unsigned short GetColorEntry(unsigned short a0, unsigned short a1); // 0x1104 +extern void GetColorTable(unsigned short a0, void * a1); // 0x0F04 +extern void * GetCursorAdr(void); // 0x8F04 +// tool 0xCF04 set 0x04 (QuickDraw) +static inline unsigned short GetFGSize(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0xCF04\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetFont(void); // 0x9504 +// tool 0x9904 set 0x04 (QuickDraw) +static inline unsigned short GetFontFlags(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x9904\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void GetFontGlobals(void * a0); // 0x9704 +extern long GetFontID(void); // 0xD104 +extern void GetFontInfo(void * a0); // 0x9604 +extern unsigned short GetFontLore(void * a0, unsigned short a1); // 0xD904 +// tool 0xA104 set 0x04 (QuickDraw) +static inline unsigned short GetForeColor(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0xA104\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetGrafProcs(void); // 0x4504 +// tool 0x1704 set 0x04 (QuickDraw) +static inline unsigned short GetMasterSCB(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1704\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void GetPen(void * a0); // 0x2904 +extern void GetPenMask(void * a0); // 0x3304 +// tool 0x2F04 set 0x04 (QuickDraw) +static inline unsigned short GetPenMode(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x2F04\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void GetPenPat(void * a0); // 0x3104 +extern void GetPenSize(void * a0); // 0x2D04 +extern void GetPenState(void * a0); // 0x2B04 +extern void * GetPicSave(void); // 0x3F04 +extern unsigned short GetPixel(short a0, short a1); // 0x8804 +extern unsigned long GetPolySave(void); // 0x4304 +extern void * GetPort(void); // 0x1C04 +extern void GetPortLoc(void * a0); // 0x1E04 +extern void GetPortRect(void * a0); // 0x2004 +extern unsigned long GetRgnSave(void); // 0x4104 +extern void GetROMFont(void * a0); // 0xD804 +extern void GetRomFont(void * a0); // 0xD804 +// tool 0x1304 set 0x04 (QuickDraw) +static inline unsigned short GetSCB(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1304\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetSpaceExtra(void); // 0x9F04 +// tool 0x0C04 set 0x04 (QuickDraw) +static inline unsigned short GetStandardSCB(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0C04\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetSysField(void); // 0x4904 +extern void * GetSysFont(void); // 0xB304 +extern void * GetTextFace(void); // 0x9B04 +// tool 0x9D04 set 0x04 (QuickDraw) +static inline unsigned short GetTextMode(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x9D04\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0xD304 set 0x04 (QuickDraw) +static inline unsigned short GetTextSize(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0xD304\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetUserField(void); // 0x4704 +extern void * GetVisHandle(void); // 0xC904 +extern void GetVisRgn(void * a0); // 0xB504 +extern void GlobalToLocal(void * a0); // 0x8504 +// tool 0x0B04 set 0x04 (QuickDraw) +static inline void GrafOff(void) { + __asm__ volatile ( + "ldx #0x0B04\n" + "jsl 0xe10000\n" : : : "a", "x", "y", "memory" ); - while (1) {} // unreachable } -// ===================================================================== -// Helpers — direct hardware polling (no toolbox) -// ===================================================================== - -// ReadKey — poll the IIgs keyboard latch at $C000 directly. -// Returns the ASCII byte (0 if no key ready). Strobes $C010 to -// clear the latch. Does NOT use Event Manager — for a real GS -// app, use TBoxGetNextEvent and pull from the queue instead. -static inline char TBoxReadKey(void) { - char r = 0; +// tool 0x0A04 set 0x04 (QuickDraw) +static inline void GrafOn(void) { __asm__ volatile ( - "sep #0x20\n" // 8-bit A - "lda 0xc000\n" - "bpl 1f\n" - "sta 0xc010\n" // strobe - "and #0x7f\n" - "bra 2f\n" - "1:\n" - "lda #0\n" - "2:\n" - "rep #0x20\n" - "and #0x00ff\n" - : "=a"(r) + "ldx #0x0A04\n" + "jsl 0xe10000\n" : - : "memory" + : + : "a", "x", "y", "memory" ); - return r; } +// tool 0x9004 set 0x04 (QuickDraw) +static inline void HideCursor(void) { + __asm__ volatile ( + "ldx #0x9004\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x2704 set 0x04 (QuickDraw) +static inline void HidePen(void) { + __asm__ volatile ( + "ldx #0x2704\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void InflateTextBuffer(unsigned short a0, unsigned short a1); // 0xD704 +extern void InitColorTable(void * a0); // 0x0D04 +// tool 0xCA04 set 0x04 (QuickDraw) +static inline void InitCursor(void) { + __asm__ volatile ( + "ldx #0xCA04\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void InitPort(void * a0); // 0x1904 +extern void InsetRect(void * a0, short a1, short a2); // 0x4C04 +extern void InsetRgn(void * a0, short a1, short a2); // 0x7004 +extern void InvertArc(void * a0, short a1, short a2); // 0x6504 +extern void InvertOval(void * a0); // 0x5B04 +extern void InvertPoly(void * a0); // 0xBF04 +extern void InvertRect(void * a0); // 0x5604 +extern void InvertRgn(void * a0); // 0x7C04 +extern void InvertRRect(void * a0, unsigned short a1, unsigned short a2); // 0x6004 +extern void KillPoly(void * a0); // 0xC304 +extern void Line(short a0, short a1); // 0x3D04 +extern void LineTo(short a0, short a1); // 0x3C04 +extern void LocalToGlobal(void * a0); // 0x8404 +extern void MapPoly(void * a0, void * a1, void * a2); // 0xC504 +extern void MapPt(void * a0, void * a1, void * a2); // 0x8A04 +extern void MapRect(void * a0, void * a1, void * a2); // 0x8B04 +extern void MapRgn(void * a0, void * a1, void * a2); // 0x8C04 +extern void Move(short a0, short a1); // 0x3B04 +extern void MovePortTo(short a0, short a1); // 0x2204 +extern void MoveTo(short a0, short a1); // 0x3A04 +extern void * NewRgn(void); // 0x6704 +extern unsigned short NotEmptyRect(void * a0); // 0x5204 +// tool 0x9204 set 0x04 (QuickDraw) +static inline void ObscureCursor(void) { + __asm__ volatile ( + "ldx #0x9204\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void OffsetPoly(void * a0, short a1, short a2); // 0xC404 +extern void OffsetRect(void * a0, short a1, short a2); // 0x4B04 +extern void OffsetRgn(void * a0, short a1, short a2); // 0x6F04 +extern void * OpenPoly(void); // 0xC104 +extern void OpenPort(void * a0); // 0x1804 +// tool 0x6D04 set 0x04 (QuickDraw) +static inline void OpenRgn(void) { + __asm__ volatile ( + "ldx #0x6D04\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void PaintArc(void * a0, short a1, short a2); // 0x6304 +extern void PaintOval(void * a0); // 0x5904 +extern void PaintPixels(void * a0); // 0x7F04 +extern void PaintPoly(void * a0); // 0xBD04 +extern void PaintRect(void * a0); // 0x5404 +extern void PaintRgn(void * a0); // 0x7A04 +extern void PaintRRect(void * a0, unsigned short a1, unsigned short a2); // 0x5E04 +// tool 0x3604 set 0x04 (QuickDraw) +static inline void PenNormal(void) { + __asm__ volatile ( + "ldx #0x3604\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void PPToPort(void * a0, void * a1, short a2, short a3, unsigned short a4); // 0xD604 +extern void Pt2Rect(void * a0, void * a1, void * a2); // 0x5004 +extern unsigned short PtInRect(void * a0, void * a1); // 0x4F04 +extern unsigned short PtInRgn(void * a0, void * a1); // 0x7504 +// tool 0x8604 set 0x04 (QuickDraw) +static inline unsigned short Random(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x8604\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned short RectInRgn(void * a0, void * a1); // 0x7604 +extern void RectRgn(void * a0, void * a1); // 0x6C04 +extern void RestoreBufDims(void * a0); // 0xCE04 +extern void SaveBufDims(void * a0); // 0xCD04 +extern void ScalePt(void * a0, void * a1, void * a2); // 0x8904 +extern void ScrollRect(void * a0, short a1, short a2, void * a3); // 0x7E04 +extern unsigned short SectRect(void * a0, void * a1, void * a2); // 0x4D04 +extern void SectRgn(void * a0, void * a1, void * a2); // 0x7104 +// tool 0x1404 set 0x04 (QuickDraw) +static inline void SetAllSCBs(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1404\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0xB004 set 0x04 (QuickDraw) +static inline void SetArcRot(short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0xB004\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0xA204 set 0x04 (QuickDraw) +static inline void SetBackColor(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0xA204\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetBackPat(void * a0); // 0x3404 +extern void SetBufDims(unsigned short a0, unsigned short a1, unsigned short a2); // 0xCB04 +extern void SetCharExtra(void * a0); // 0xD404 +extern void SetClip(void * a0); // 0x2404 +extern void SetClipHandle(void * a0); // 0xC604 +extern void SetColorEntry(unsigned short a0, unsigned short a1, void * a2); // 0x1004 +extern void SetColorTable(unsigned short a0, void * a1); // 0x0E04 +extern void SetCursor(void * a0); // 0x8E04 +extern void SetEmptyRgn(void * a0); // 0x6A04 +extern void SetFont(void * a0); // 0x9404 +// tool 0x9804 set 0x04 (QuickDraw) +static inline void SetFontFlags(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x9804\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetFontID(void * a0); // 0xD004 +// tool 0xA004 set 0x04 (QuickDraw) +static inline void SetForeColor(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0xA004\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetGrafProcs(void * a0); // 0x4404 +// tool 0xB604 set 0x04 (QuickDraw) +static inline void SetIntUse(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0xB604\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x1604 set 0x04 (QuickDraw) +static inline void SetMasterSCB(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1604\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetOrigin(short a0, short a1); // 0x2304 +extern void SetPenMask(void * a0); // 0x3204 +// tool 0x2E04 set 0x04 (QuickDraw) +static inline void SetPenMode(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x2E04\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetPenPat(void * a0); // 0x3004 +extern void SetPenSize(unsigned short a0, unsigned short a1); // 0x2C04 +extern void SetPenState(void * a0); // 0x2A04 +extern void SetPicSave(void * a0); // 0x3E04 +extern void SetPolySave(void * a0); // 0x4204 +extern void SetPort(void * a0); // 0x1B04 +extern void SetPortLoc(void * a0); // 0x1D04 +extern void SetPortRect(void * a0); // 0x1F04 +extern void SetPortSize(unsigned short a0, unsigned short a1); // 0x2104 +extern void SetPt(void * a0, short a1, short a2); // 0x8204 +extern void SetRandSeed(void * a0); // 0x8704 +extern void SetRect(void * a0, short a1, short a2, short a3, short a4); // 0x4A04 +extern void SetRectRgn(void * a0, short a1, short a2, short a3, short a4); // 0x6B04 +extern void SetRgnSave(void * a0); // 0x4004 +extern void SetSCB(unsigned short a0, unsigned short a1); // 0x1204 +// tool 0x3804 set 0x04 (QuickDraw) +static inline void SetSolidBackPat(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x3804\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x3704 set 0x04 (QuickDraw) +static inline void SetSolidPenPat(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x3704\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetSpaceExtra(void * a0); // 0x9E04 +extern void SetStdProcs(void * a0); // 0x8D04 +extern void SetSysField(void * a0); // 0x4804 +extern void SetSysFont(void * a0); // 0xB204 +extern void SetTextFace(void * a0); // 0x9A04 +// tool 0x9C04 set 0x04 (QuickDraw) +static inline void SetTextMode(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x9C04\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0xD204 set 0x04 (QuickDraw) +static inline void SetTextSize(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0xD204\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetUserField(void * a0); // 0x4604 +extern void SetVisHandle(void * a0); // 0xC804 +extern void SetVisRgn(void * a0); // 0xB404 +// tool 0x9104 set 0x04 (QuickDraw) +static inline void ShowCursor(void) { + __asm__ volatile ( + "ldx #0x9104\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x2804 set 0x04 (QuickDraw) +static inline void ShowPen(void) { + __asm__ volatile ( + "ldx #0x2804\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void SolidPattern(unsigned short a0, void * a1); // 0x3904 +extern void StringBounds(void * a0, void * a1); // 0xAD04 +extern unsigned short StringWidth(void * a0); // 0xA904 +extern void SubPt(void * a0, void * a1); // 0x8104 +extern void TextBounds(void * a0, unsigned short a1, void * a2); // 0xAF04 +extern unsigned short TextWidth(void * a0, unsigned short a1); // 0xAB04 +extern void UnionRect(void * a0, void * a1, void * a2); // 0x4E04 +extern void UnionRgn(void * a0, void * a1, void * a2); // 0x7204 +extern void XorRgn(void * a0, void * a1, void * a2); // 0x7404 +extern void * Get640Colors(void); // 0xDA04 +// tool 0xDB04 set 0x04 (QuickDraw) +static inline void Set640Color(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0xDB04\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x011E set 0x1E (ResourceManager) +static inline void ResourceBootInit(void) { + __asm__ volatile ( + "ldx #0x011E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x021E set 0x1E (ResourceManager) +static inline void ResourceStartUp(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x021E\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x031E set 0x1E (ResourceManager) +static inline void ResourceShutDown(void) { + __asm__ volatile ( + "ldx #0x031E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x041E set 0x1E (ResourceManager) +static inline unsigned short ResourceVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x041E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x051E set 0x1E (ResourceManager) +static inline void ResourceReset(void) { + __asm__ volatile ( + "ldx #0x051E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x061E set 0x1E (ResourceManager) +static inline unsigned short ResourceStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x061E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void AddResource(void * a0, unsigned short a1, unsigned short a2, long a3); // 0x0C1E +// tool 0x0B1E set 0x1E (ResourceManager) +static inline void CloseResourceFile(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0B1E\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern unsigned long CountResources(unsigned short a0); // 0x221E +// tool 0x201E set 0x1E (ResourceManager) +static inline unsigned short CountTypes(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x201E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void CreateResourceFile(long a0, unsigned short a1, unsigned short a2, void * a3); // 0x091E +extern void DetachResource(unsigned short a0, long a1); // 0x181E +// tool 0x141E set 0x1E (ResourceManager) +static inline unsigned short GetCurResourceApp(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x141E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x121E set 0x1E (ResourceManager) +static inline unsigned short GetCurResourceFile(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x121E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetIndResource(unsigned short a0, long a1); // 0x231E +extern unsigned long GetIndType(unsigned short a0); // 0x211E +extern void * GetMapHandle(unsigned short a0); // 0x261E +// tool 0x1F1E set 0x1E (ResourceManager) +static inline unsigned short GetOpenFileRefNum(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1F1E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetResourceAttr(unsigned short a0, long a1); // 0x1B1E +extern unsigned long GetResourceSize(unsigned short a0, long a1); // 0x1D1E +extern unsigned short HomeResourceFile(unsigned short a0, long a1); // 0x151E +extern unsigned long LoadAbsResource(void * a0, long a1, unsigned short a2, long a3); // 0x271E +extern void * LoadResource(unsigned short a0, long a1); // 0x0E1E +extern void MarkResourceChange(unsigned short a0, unsigned short a1, long a2); // 0x101E +extern void MatchResourceHandle(void * a0, void * a1); // 0x1E1E +extern unsigned short OpenResourceFile(unsigned short a0, void * a1, void * a2); // 0x0A1E +extern void ReleaseResource(unsigned short a0, unsigned short a1, long a2); // 0x171E +extern void RemoveResource(unsigned short a0, long a1); // 0x0F1E +extern void ResourceConverter(void * a0, unsigned short a1, unsigned short a2); // 0x281E +// tool 0x131E set 0x1E (ResourceManager) +static inline void SetCurResourceApp(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x131E\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x111E set 0x1E (ResourceManager) +static inline void SetCurResourceFile(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x111E\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SetResourceAttr(unsigned short a0, unsigned short a1, long a2); // 0x1C1E +// tool 0x251E set 0x1E (ResourceManager) +static inline unsigned short SetResourceFileDepth(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x251E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void SetResourceID(long a0, unsigned short a1, long a2); // 0x1A1E +// tool 0x241E set 0x1E (ResourceManager) +static inline unsigned short SetResourceLoad(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x241E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void * UniqueResourceID(unsigned short a0, unsigned short a1); // 0x191E +// tool 0x0D1E set 0x1E (ResourceManager) +static inline void UpdateResourceFile(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0D1E\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void WriteResource(unsigned short a0, long a1); // 0x161E +extern void * LoadResource2(unsigned short a0, void * a1, unsigned short a2, long a3); // 0x291E +extern unsigned long RMFindNamedResource(unsigned short a0, void * a1, unsigned short a2); // 0x2A1E +extern void RMGetResourceName(unsigned short a0, long a1, void * a2); // 0x2B1E +extern void * RMLoadNamedResource(unsigned short a0, void * a1); // 0x2C1E +extern void RMSetResourceName(unsigned short a0, long a1, void * a2); // 0x2D1E +extern unsigned short OpenResourceFileByID(unsigned short a0, unsigned short a1); // 0x2E1E +extern void CompactResourceFile(unsigned short a0, unsigned short a1); // 0x2F1E +// tool 0x010A set 0x0A (SANE) +static inline void SANEBootInit(void) { + __asm__ volatile ( + "ldx #0x010A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x020A set 0x0A (SANE) +static inline void SANEStartUp(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x020A\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x030A set 0x0A (SANE) +static inline void SANEShutDown(void) { + __asm__ volatile ( + "ldx #0x030A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x040A set 0x0A (SANE) +static inline unsigned short SANEVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x040A\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x050A set 0x0A (SANE) +static inline void SANEReset(void) { + __asm__ volatile ( + "ldx #0x050A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x060A set 0x0A (SANE) +static inline unsigned short SANEStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x060A\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x090A set 0x0A (SANE) +static inline void SANEFP816(void) { + __asm__ volatile ( + "ldx #0x090A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0A0A set 0x0A (SANE) +static inline void SANEDecStr816(void) { + __asm__ volatile ( + "ldx #0x0A0A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0B0A set 0x0A (SANE) +static inline void SANEElems816(void) { + __asm__ volatile ( + "ldx #0x0B0A\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0107 set 0x07 (Scheduler) +static inline void SchBootInit(void) { + __asm__ volatile ( + "ldx #0x0107\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0207 set 0x07 (Scheduler) +static inline void SchStartUp(void) { + __asm__ volatile ( + "ldx #0x0207\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0307 set 0x07 (Scheduler) +static inline void SchShutDown(void) { + __asm__ volatile ( + "ldx #0x0307\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0407 set 0x07 (Scheduler) +static inline unsigned short SchVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0407\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0507 set 0x07 (Scheduler) +static inline void SchReset(void) { + __asm__ volatile ( + "ldx #0x0507\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0607 set 0x07 (Scheduler) +static inline unsigned short SchStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0607\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned short SchAddTask(void * a0); // 0x0907 +// tool 0x0A07 set 0x07 (Scheduler) +static inline void SchFlush(void) { + __asm__ volatile ( + "ldx #0x0A07\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0116 set 0x16 (ScrapManager) +static inline void ScrapBootInit(void) { + __asm__ volatile ( + "ldx #0x0116\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0216 set 0x16 (ScrapManager) +static inline void ScrapStartUp(void) { + __asm__ volatile ( + "ldx #0x0216\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0316 set 0x16 (ScrapManager) +static inline void ScrapShutDown(void) { + __asm__ volatile ( + "ldx #0x0316\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0416 set 0x16 (ScrapManager) +static inline unsigned short ScrapVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0416\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0516 set 0x16 (ScrapManager) +static inline void ScrapReset(void) { + __asm__ volatile ( + "ldx #0x0516\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0616 set 0x16 (ScrapManager) +static inline unsigned short ScrapStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0616\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void GetScrap(void * a0, unsigned short a1); // 0x0D16 +// tool 0x1216 set 0x16 (ScrapManager) +static inline unsigned short GetScrapCount(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1216\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetScrapHandle(unsigned short a0); // 0x0E16 +extern void * GetScrapPath(void); // 0x1016 +extern unsigned long GetScrapSize(unsigned short a0); // 0x0F16 +// tool 0x1316 set 0x16 (ScrapManager) +static inline unsigned short GetScrapState(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1316\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0A16 set 0x16 (ScrapManager) +static inline void LoadScrap(void) { + __asm__ volatile ( + "ldx #0x0A16\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void PutScrap(unsigned long a0, unsigned short a1, void * a2); // 0x0C16 +extern void SetScrapPath(void * a0); // 0x1116 +// tool 0x0916 set 0x16 (ScrapManager) +static inline void UnloadScrap(void) { + __asm__ volatile ( + "ldx #0x0916\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0B16 set 0x16 (ScrapManager) +static inline void ZeroScrap(void) { + __asm__ volatile ( + "ldx #0x0B16\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void GetIndScrap(unsigned short a0, void * a1); // 0x1416 +extern void * ShowClipboard(unsigned short a0, void * a1); // 0x1516 +// tool 0x0108 set 0x08 (SoundManager) +static inline void SoundBootInit(void) { + __asm__ volatile ( + "ldx #0x0108\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0208 set 0x08 (SoundManager) +static inline void SoundStartUp(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0208\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x0308 set 0x08 (SoundManager) +static inline void SoundShutDown(void) { + __asm__ volatile ( + "ldx #0x0308\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0408 set 0x08 (SoundManager) +static inline unsigned short SoundVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0408\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0508 set 0x08 (SoundManager) +static inline void SoundReset(void) { + __asm__ volatile ( + "ldx #0x0508\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0608 set 0x08 (SoundManager) +static inline unsigned short SoundToolStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0608\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1108 set 0x08 (SoundManager) +static inline unsigned short FFGeneratorStatus(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1108\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1408 set 0x08 (SoundManager) +static inline unsigned short FFSoundDoneStatus(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1408\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1008 set 0x08 (SoundManager) +static inline unsigned short FFSoundStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1008\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void FFStartSound(unsigned short a0, void * a1); // 0x0E08 +// tool 0x0F08 set 0x08 (SoundManager) +static inline void FFStopSound(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0F08\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x0C08 set 0x08 (SoundManager) +static inline unsigned short GetSoundVolume(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x0C08\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void * GetTableAddress(void); // 0x0B08 +extern void ReadRamBlock(void * a0, unsigned short a1, unsigned short a2); // 0x0A08 +extern void SetSoundMIRQV(void * a0); // 0x1208 +extern void SetSoundVolume(unsigned short a0, unsigned short a1); // 0x0D08 +extern void * SetUserSoundIRQV(void * a0); // 0x1308 +extern void WriteRamBlock(void * a0, unsigned short a1, unsigned short a2); // 0x0908 +extern void FFSetUpSound(unsigned short a0, void * a1); // 0x1508 +// tool 0x1608 set 0x08 (SoundManager) +static inline void FFStartPlaying(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1608\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void ReadDOCReg(void * a0); // 0x1808 +extern void SetDOCReg(void * a0); // 0x1708 +// tool 0x0117 set 0x17 (StandardFile) +static inline void SFBootInit(void) { + __asm__ volatile ( + "ldx #0x0117\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void SFStartUp(unsigned short a0, unsigned short a1); // 0x0217 +// tool 0x0317 set 0x17 (StandardFile) +static inline void SFShutDown(void) { + __asm__ volatile ( + "ldx #0x0317\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0417 set 0x17 (StandardFile) +static inline unsigned short SFVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0417\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0517 set 0x17 (StandardFile) +static inline void SFReset(void) { + __asm__ volatile ( + "ldx #0x0517\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0617 set 0x17 (StandardFile) +static inline unsigned short SFStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0617\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0D17 set 0x17 (StandardFile) +static inline void SFAllCaps(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0D17\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void SFGetFile(short a0, short a1, void * a2, void * a3, void * a4, void * a5); // 0x0917 +extern void SFPGetFile(short a0, short a1, void * a2, void * a3, void * a4, void * a5, void * a6, void * a7); // 0x0B17 +extern void SFPPutFile(short a0, short a1, void * a2, void * a3, unsigned short a4, void * a5, void * a6, void * a7); // 0x0C17 +extern void SFPutFile(short a0, short a1, void * a2, void * a3, unsigned short a4, void * a5); // 0x0A17 +extern void SFGetFile2(short a0, short a1, unsigned short a2, void * a3, void * a4, void * a5, void * a6); // 0x0E17 +extern void SFMultiGet2(short a0, short a1, unsigned short a2, void * a3, void * a4, void * a5, void * a6); // 0x1417 +extern void SFPGetFile2(short a0, short a1, void * a2, unsigned short a3, void * a4, void * a5, void * a6, void * a7, void * a8, void * a9); // 0x1017 +extern void SFPMultiGet2(short a0, short a1, void * a2, unsigned short a3, void * a4, void * a5, void * a6, void * a7, void * a8, void * a9); // 0x1517 +extern void SFPPutFile2(short a0, short a1, void * a2, unsigned short a3, void * a4, unsigned short a5, void * a6, void * a7, void * a8, void * a9); // 0x1117 +extern void SFPutFile2(short a0, short a1, unsigned short a2, void * a3, unsigned short a4, void * a5, void * a6); // 0x0F17 +extern void SFReScan(void * a0, void * a1); // 0x1317 +// tool 0x1217 set 0x17 (StandardFile) +static inline unsigned short SFShowInvisible(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1217\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0122 set 0x22 (TextEdit) +static inline void TEBootInit(void) { + __asm__ volatile ( + "ldx #0x0122\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void TEStartUp(unsigned short a0, unsigned short a1); // 0x0222 +// tool 0x0322 set 0x22 (TextEdit) +static inline void TEShutDown(void) { + __asm__ volatile ( + "ldx #0x0322\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0422 set 0x22 (TextEdit) +static inline unsigned short TEVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0422\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0522 set 0x22 (TextEdit) +static inline void TEReset(void) { + __asm__ volatile ( + "ldx #0x0522\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0622 set 0x22 (TextEdit) +static inline unsigned short TEStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0622\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void TEActivate(void * a0); // 0x0F22 +extern void TEClear(void * a0); // 0x1922 +extern void TEClick(void * a0, void * a1); // 0x1122 +extern void TECompactRecord(void * a0); // 0x2822 +extern void TECopy(void * a0); // 0x1722 +extern void TECut(void * a0); // 0x1622 +extern void TEDeactivate(void * a0); // 0x1022 +extern void * TEGetDefProc(void); // 0x2222 +extern void * TEGetInternalProc(void); // 0x2622 +extern unsigned short TEGetLastError(unsigned short a0, void * a1); // 0x2722 +extern void TEGetRuler(unsigned short a0, void * a1, void * a2); // 0x2322 +extern void TEGetSelection(void * a0, void * a1, void * a2); // 0x1C22 +extern unsigned short TEGetSelectionStyle(void * a0, void * a1, void * a2); // 0x1E22 +extern unsigned long TEGetText(unsigned short a0, void * a1, long a2, unsigned short a3, void * a4, void * a5); // 0x0C22 +extern void TEGetTextInfo(void * a0, unsigned short a1, void * a2); // 0x0D22 +extern void TEIdle(void * a0); // 0x0E22 +extern void TEInsert(unsigned short a0, void * a1, long a2, unsigned short a3, void * a4, void * a5); // 0x1A22 +extern void TEKey(void * a0, void * a1); // 0x1422 +extern void TEKill(void * a0); // 0x0A22 +extern void * TENew(void * a0); // 0x0922 +extern void TEOffsetToPoint(long a0, long a1, long a2, void * a3); // 0x2022 +extern unsigned long TEPaintText(void * a0, long a1, void * a2, unsigned short a3, void * a4); // 0x1322 +extern void TEPaste(void * a0); // 0x1822 +extern unsigned long TEPointToOffset(long a0, long a1, void * a2); // 0x2122 +extern void TEReplace(unsigned short a0, void * a1, long a2, unsigned short a3, void * a4, void * a5); // 0x1B22 +extern void TEScroll(unsigned short a0, long a1, long a2, void * a3); // 0x2522 +extern void TESetRuler(unsigned short a0, void * a1, void * a2); // 0x2422 +extern void TESetSelection(void * a0, void * a1, void * a2); // 0x1D22 +extern void TESetText(unsigned short a0, void * a1, long a2, unsigned short a3, void * a4, void * a5); // 0x0B22 +extern void TEStyleChange(unsigned short a0, void * a1, void * a2); // 0x1F22 +extern void TEUpdate(void * a0); // 0x1222 +// tool 0x1522 set 0x22 (TextEdit) +static inline void TEInsertPageBreak(void) { + __asm__ volatile ( + "ldx #0x1522\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x010C set 0x0C (TextTools) +static inline void TextBootInit(void) { + __asm__ volatile ( + "ldx #0x010C\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x020C set 0x0C (TextTools) +static inline void TextStartUp(void) { + __asm__ volatile ( + "ldx #0x020C\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x030C set 0x0C (TextTools) +static inline void TextShutDown(void) { + __asm__ volatile ( + "ldx #0x030C\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x040C set 0x0C (TextTools) +static inline unsigned short TextVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x040C\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x050C set 0x0C (TextTools) +static inline void TextReset(void) { + __asm__ volatile ( + "ldx #0x050C\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x060C set 0x0C (TextTools) +static inline unsigned short TextStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x060C\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void CtlTextDev(unsigned short a0, unsigned short a1); // 0x160C +extern void ErrWriteBlock(void * a0, unsigned short a1, unsigned short a2); // 0x1F0C +// tool 0x190C set 0x0C (TextTools) +static inline void ErrWriteChar(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x190C\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void ErrWriteCString(void * a0); // 0x210C +extern void ErrWriteLine(void * a0); // 0x1B0C +extern void ErrWriteString(void * a0); // 0x1D0C +extern long GetErrGlobals(void); // 0x0E0C +extern long GetInGlobals(void); // 0x0C0C +extern long GetOutGlobals(void); // 0x0D0C +// tool 0x150C set 0x0C (TextTools) +static inline void InitTextDev(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x150C\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x220C set 0x0C (TextTools) +static inline unsigned short ReadChar(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x220C\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern unsigned short ReadLine(void * a0, unsigned short a1, unsigned short a2, unsigned short a3); // 0x240C +extern void SetErrGlobals(unsigned short a0, unsigned short a1); // 0x0B0C +extern void SetErrorDevice(unsigned short a0, unsigned long a1); // 0x110C +extern void SetInGlobals(unsigned short a0, unsigned short a1); // 0x090C +extern void SetInputDevice(unsigned short a0, unsigned long a1); // 0x0F0C +extern void SetOutGlobals(unsigned short a0, unsigned short a1); // 0x0A0C +extern void SetOutputDevice(unsigned short a0, unsigned long a1); // 0x100C +extern void StatusTextDev(unsigned short a0, unsigned short a1); // 0x170C +extern void TextReadBlock(void * a0, unsigned short a1, unsigned short a2, unsigned short a3); // 0x230C +extern void TextWriteBlock(void * a0, unsigned short a1, unsigned short a2); // 0x1E0C +// tool 0x180C set 0x0C (TextTools) +static inline void WriteChar(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x180C\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +extern void WriteCString(void * a0); // 0x200C +extern void WriteLine(void * a0); // 0x1A0C +extern void WriteString(void * a0); // 0x1C0C +// tool 0x0121 set 0x21 (Teletext) +static inline void VDBootInit(void) { + __asm__ volatile ( + "ldx #0x0121\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0221 set 0x21 (Teletext) +static inline void VDStartUp(void) { + __asm__ volatile ( + "ldx #0x0221\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0321 set 0x21 (Teletext) +static inline void VDShutDown(void) { + __asm__ volatile ( + "ldx #0x0321\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0421 set 0x21 (Teletext) +static inline unsigned short VDVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0421\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0521 set 0x21 (Teletext) +static inline void VDReset(void) { + __asm__ volatile ( + "ldx #0x0521\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x0621 set 0x21 (Teletext) +static inline unsigned short VDStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0621\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1B21 set 0x21 (Teletext) +static inline unsigned short VDGetFeatures(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1B21\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void VDGGControl(unsigned short a0, unsigned short a1); // 0x1D21 +// tool 0x1E21 set 0x21 (Teletext) +static inline unsigned short VDGGStatus(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1E21\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void VDInControl(unsigned short a0, unsigned short a1); // 0x1C21 +extern void VDInConvAdj(unsigned short a0, unsigned short a1); // 0x0C21 +// tool 0x0B21 set 0x21 (Teletext) +static inline unsigned short VDInGetStd(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x0B21\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x0A21 set 0x21 (Teletext) +static inline void VDInSetStd(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x0A21\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x0921 set 0x21 (Teletext) +static inline unsigned short VDInStatus(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x0921\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void VDKeyControl(unsigned short a0, unsigned short a1); // 0x0D21 +// tool 0x1221 set 0x21 (Teletext) +static inline unsigned short VDKeyGetKBCol(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1221\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1421 set 0x21 (Teletext) +static inline unsigned short VDKeyGetKDiss(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1421\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1121 set 0x21 (Teletext) +static inline unsigned short VDKeyGetKGCol(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1121\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1021 set 0x21 (Teletext) +static inline unsigned short VDKeyGetKRCol(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1021\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1621 set 0x21 (Teletext) +static inline unsigned short VDKeyGetNKDiss(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1621\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void VDKeySetKCol(unsigned short a0, unsigned short a1, unsigned short a2); // 0x0F21 +// tool 0x1321 set 0x21 (Teletext) +static inline void VDKeySetKDiss(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1321\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x1521 set 0x21 (Teletext) +static inline void VDKeySetNKDiss(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1521\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x0E21 set 0x21 (Teletext) +static inline unsigned short VDKeyStatus(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x0E21\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void VDOutControl(unsigned short a0, unsigned short a1); // 0x1921 +// tool 0x1821 set 0x21 (Teletext) +static inline unsigned short VDOutGetStd(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x1821\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x1721 set 0x21 (Teletext) +static inline void VDOutSetStd(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x1721\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x1A21 set 0x21 (Teletext) +static inline unsigned short VDOutStatus(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x1A21\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x010E set 0x0E (WindowManager) +static inline void WindBootInit(void) { + __asm__ volatile ( + "ldx #0x010E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x020E set 0x0E (WindowManager) +static inline void WindStartUp(unsigned short a0) { + __asm__ volatile ( + "pha\n" // arg0 + "ldx #0x020E\n" + "jsl 0xe10000\n" + : + : "a"(a0) + : "x", "y", "memory" + ); +} + +// tool 0x030E set 0x0E (WindowManager) +static inline void WindShutDown(void) { + __asm__ volatile ( + "ldx #0x030E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x040E set 0x0E (WindowManager) +static inline unsigned short WindVersion(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x040E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +// tool 0x050E set 0x0E (WindowManager) +static inline void WindReset(void) { + __asm__ volatile ( + "ldx #0x050E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x060E set 0x0E (WindowManager) +static inline unsigned short WindStatus(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x060E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void BeginUpdate(void * a0); // 0x1E0E +extern void BringToFront(void * a0); // 0x240E +extern unsigned short CheckUpdate(void * a0); // 0x0A0E +extern void CloseWindow(void * a0); // 0x0B0E +extern void * Desktop(unsigned short a0, unsigned long a1); // 0x0C0E +extern void DragWindow(unsigned short a0, short a1, short a2, unsigned short a3, void * a4, void * a5); // 0x1A0E +// tool 0x510E set 0x0E (WindowManager) +static inline void EndInfoDrawing(void) { + __asm__ volatile ( + "ldx #0x510E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void EndUpdate(void * a0); // 0x1F0E +extern unsigned short FindWindow(void * a0, short a1, short a2); // 0x170E +extern void * FrontWindow(void); // 0x150E +extern void * GetContentDraw(void * a0); // 0x480E +extern long GetContentOrigin(void * a0); // 0x3E0E +extern void * GetContentRgn(void * a0); // 0x2F0E +extern unsigned long GetDataSize(void * a0); // 0x400E +extern void * GetDefProc(void * a0); // 0x310E +extern void * GetFirstWindow(void); // 0x520E +extern void GetFrameColor(void * a0, void * a1); // 0x100E +extern void * GetInfoDraw(void * a0); // 0x4A0E +extern unsigned long GetInfoRefCon(void * a0); // 0x350E +extern unsigned long GetMaxGrow(void * a0); // 0x420E +extern void * GetNextWindow(void * a0); // 0x2A0E +extern unsigned long GetPage(void * a0); // 0x460E +extern void GetRectInfo(void * a0, void * a1); // 0x4F0E +extern unsigned long GetScroll(void * a0); // 0x440E +extern void * GetStructRgn(void * a0); // 0x2E0E +extern unsigned short GetSysWFlag(void * a0); // 0x4C0E +extern void * GetUpdateRgn(void * a0); // 0x300E +extern void * GetWControls(void * a0); // 0x330E +extern unsigned short GetWFrame(void * a0); // 0x2C0E +extern unsigned short GetWKind(void * a0); // 0x2B0E +extern void * GetWMgrPort(void); // 0x200E +extern unsigned long GetWRefCon(void * a0); // 0x290E +extern void * GetWTitle(void * a0); // 0x0E0E +extern unsigned long GrowWindow(unsigned short a0, unsigned short a1, short a2, short a3, void * a4); // 0x1B0E +extern void HideWindow(void * a0); // 0x120E +extern void HiliteWindow(unsigned short a0, void * a1); // 0x220E +extern void InvalRect(void * a0); // 0x3A0E +extern void InvalRgn(void * a0); // 0x3B0E +extern void MoveWindow(short a0, short a1, void * a2); // 0x190E +extern void * NewWindow(void * a0); // 0x090E +extern void * PinRect(short a0, short a1, void * a2); // 0x210E +extern void RefreshDesktop(void * a0); // 0x390E +extern void SelectWindow(void * a0); // 0x110E +extern void SendBehind(void * a0, void * a1); // 0x140E +extern void SetContentDraw(void * a0, void * a1); // 0x490E +extern void SetContentOrigin(unsigned short a0, unsigned short a1, void * a2); // 0x3F0E +extern void SetContentOrigin2(unsigned short a0, unsigned short a1, unsigned short a2, void * a3); // 0x570E +extern void SetDataSize(unsigned short a0, unsigned short a1, void * a2); // 0x410E +extern void SetDefProc(void * a0, void * a1); // 0x320E +extern void SetFrameColor(void * a0, void * a1); // 0x0F0E +extern void SetInfoDraw(void * a0, void * a1); // 0x160E +extern void SetInfoRefCon(unsigned long a0, void * a1); // 0x360E +extern void SetMaxGrow(unsigned short a0, unsigned short a1, void * a2); // 0x430E +extern void SetOriginMask(unsigned short a0, void * a1); // 0x340E +extern void SetPage(unsigned short a0, unsigned short a1, void * a2); // 0x470E +extern void SetScroll(unsigned short a0, unsigned short a1, void * a2); // 0x450E +extern void SetSysWindow(void * a0); // 0x4B0E +extern void SetWFrame(unsigned short a0, void * a1); // 0x2D0E +extern void * SetWindowIcons(void * a0); // 0x4E0E +extern void SetWRefCon(void * a0, void * a1); // 0x280E +extern void SetWTitle(void * a0, void * a1); // 0x0D0E +extern void SetZoomRect(void * a0, void * a1); // 0x380E +extern void ShowHide(unsigned short a0, void * a1); // 0x230E +extern void ShowWindow(void * a0); // 0x130E +extern void SizeWindow(unsigned short a0, unsigned short a1, void * a2); // 0x1C0E +extern void StartDrawing(void * a0); // 0x4D0E +extern void StartInfoDrawing(void * a0, void * a1); // 0x500E +extern unsigned short TaskMaster(unsigned short a0, void * a1); // 0x1D0E +extern unsigned short TrackGoAway(short a0, short a1, void * a2); // 0x180E +extern unsigned short TrackZoom(short a0, short a1, void * a2); // 0x260E +extern void ValidRect(void * a0); // 0x3C0E +extern void ValidRgn(void * a0); // 0x3D0E +extern unsigned long WindDragRect(void * a0, void * a1, short a2, short a3, void * a4, void * a5, void * a6, unsigned short a7); // 0x530E +// tool 0x250E set 0x0E (WindowManager) +static inline void WindNewRes(void) { + __asm__ volatile ( + "ldx #0x250E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x560E set 0x0E (WindowManager) +static inline unsigned short WindowGlobal(unsigned short a0) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "pha\n" // arg0 + "ldx #0x560E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : "a"(a0) + : "x", "y", "memory" + ); + return _r; +} + +extern void ZoomWindow(void * a0); // 0x270E +extern unsigned short AlertWindow(unsigned short a0, void * a1, void * a2); // 0x590E +extern void * CompileText(unsigned short a0, void * a1, void * a2, unsigned short a3); // 0x600E +extern void DrawInfoBar(void * a0); // 0x550E +// tool 0x5B0E set 0x0E (WindowManager) +static inline void EndFrameDrawing(void) { + __asm__ volatile ( + "ldx #0x5B0E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern unsigned short ErrorWindow(unsigned short a0, void * a1, unsigned short a2); // 0x620E +extern void * GetWindowMgrGlobals(void); // 0x580E +extern void * NewWindow2(void * a0, long a1, void * a2, void * a3, unsigned short a4, void * a5, unsigned short a6); // 0x610E +extern void ResizeWindow(unsigned short a0, void * a1, void * a2); // 0x5C0E +extern void StartFrameDrawing(void * a0); // 0x5A0E +extern unsigned short TaskMasterDA(unsigned short a0, void * a1); // 0x5F0E +extern unsigned long DoModalWindow(void * a0, void * a1, void * a2, void * a3, unsigned short a4); // 0x640E +extern unsigned short FindCursorCtl(void * a0, short a1, short a2, void * a3); // 0x690E +extern void * GetAuxWindInfo(void * a0); // 0x630E +extern unsigned long HandleDiskInsert(unsigned short a0, unsigned short a1); // 0x6B0E +// tool 0x650E set 0x0E (WindowManager) +static inline unsigned short MWGetCtlPart(void) { + unsigned short _r; + __asm__ volatile ( + "pha\n" // result space + "ldx #0x650E\n" + "jsl 0xe10000\n" + "pla\n" + : "=a"(_r) + : + : "x", "y", "memory" + ); + return _r; +} + +extern void * MWSetMenuProc(void * a0); // 0x660E +extern void * SetMenuProc(void * a0); // 0x660E +// tool 0x680E set 0x0E (WindowManager) +static inline void MWSetUpEditMenu(void) { + __asm__ volatile ( + "ldx #0x680E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x670E set 0x0E (WindowManager) +static inline void MWStdDrawProc(void) { + __asm__ volatile ( + "ldx #0x670E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +extern void ResizeInfoBar(unsigned short a0, unsigned short a1, void * a2); // 0x6A0E +extern void UpdateWindow(unsigned short a0, void * a1); // 0x6C0E +// tool 0x540E set 0x0E (WindowManager) +static inline void GDRPrivate(void) { + __asm__ volatile ( + "ldx #0x540E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x5D0E set 0x0E (WindowManager) +static inline void TaskMasterContent(void) { + __asm__ volatile ( + "ldx #0x5D0E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + +// tool 0x5E0E set 0x0E (WindowManager) +static inline void TaskMasterKey(void) { + __asm__ volatile ( + "ldx #0x5E0E\n" + "jsl 0xe10000\n" + : + : + : "a", "x", "y", "memory" + ); +} + + #ifdef __cplusplus } #endif -#endif // IIGS_TOOLBOX_H +#endif // IIGS_TOOLBOX_H \ No newline at end of file diff --git a/runtime/include/stdio.h b/runtime/include/stdio.h index 95b8c9f..d9d0ed9 100644 --- a/runtime/include/stdio.h +++ b/runtime/include/stdio.h @@ -41,12 +41,19 @@ void clearerr(FILE *stream); #define EOF (-1) -// Input stubs. Real implementations would route through GS/OS -// console I/O; current impl in libc.c returns EOF / 0. int getchar(void); int fgetc(FILE *stream); char *fgets(char *buf, int n, FILE *stream); int ungetc(int c, FILE *stream); #define getc(s) fgetc(s) +// Memory-backed FS: register a memory region as a named file so +// fopen can open it. `cap` should be >= size; use cap > size for +// files that may grow on write. `writable` controls whether +// fopen("...", "w") / "a" / "r+" succeeds. Returns 0 on success, +// -1 on duplicate name or table full. +int mfsRegister(const char *path, void *buf, size_t size, size_t cap, + int writable); +int mfsUnregister(const char *path); + #endif diff --git a/runtime/include/wchar.h b/runtime/include/wchar.h new file mode 100644 index 0000000..ad056c6 --- /dev/null +++ b/runtime/include/wchar.h @@ -0,0 +1,38 @@ +// Minimal wchar.h for the W65816 runtime. +// +// wchar_t is 16-bit (matches `int` on this target). No real +// multi-byte / locale support — mbtowc/wctomb assume a one-byte = +// one-wchar mapping (essentially Latin-1). The wcs* functions +// mirror the str* family. + +#ifndef _WCHAR_H +#define _WCHAR_H + +typedef unsigned short wchar_t; +typedef unsigned int size_t; +typedef long wint_t; + +#define WEOF ((wint_t)-1) + +#ifndef NULL +#define NULL ((void *)0) +#endif + +size_t wcslen (const wchar_t *s); +int wcscmp (const wchar_t *a, const wchar_t *b); +int wcsncmp(const wchar_t *a, const wchar_t *b, size_t n); +wchar_t *wcscpy (wchar_t *dst, const wchar_t *src); +wchar_t *wcsncpy(wchar_t *dst, const wchar_t *src, size_t n); +wchar_t *wcscat (wchar_t *dst, const wchar_t *src); +wchar_t *wcschr (const wchar_t *s, wchar_t c); +wchar_t *wcsrchr(const wchar_t *s, wchar_t c); + +// Multi-byte conversion. Trivial 1:1 in our impl: each byte maps +// to the wide char with the same numeric value (zero-extended). +int mbtowc (wchar_t *pwc, const char *s, size_t n); +int wctomb (char *s, wchar_t wc); +size_t mbstowcs(wchar_t *pwcs, const char *s, size_t n); +size_t wcstombs(char *s, const wchar_t *pwcs, size_t n); +int mblen (const char *s, size_t n); + +#endif diff --git a/runtime/src/extras.c b/runtime/src/extras.c index eabbb90..df7afc5 100644 --- a/runtime/src/extras.c +++ b/runtime/src/extras.c @@ -176,3 +176,107 @@ size_t strcspn(const char *s, const char *reject) { // strtok / strtok_r are in runtime/src/strtok.c. + +// ---- wchar.h ---- +// wchar_t is 16-bit on this target. The wcs* functions mirror the +// str* family. mbtowc / wctomb use the trivial 1:1 byte<->wide-char +// mapping (essentially Latin-1) — no real multi-byte / locale support. + +typedef unsigned short wchar_t; + +size_t wcslen(const wchar_t *s) { + size_t n = 0; + while (*s++) n++; + return n; +} + +int wcscmp(const wchar_t *a, const wchar_t *b) { + while (*a && *a == *b) { a++; b++; } + return (int)((short)*a - (short)*b); +} + +int wcsncmp(const wchar_t *a, const wchar_t *b, size_t n) { + while (n && *a && *a == *b) { a++; b++; n--; } + if (!n) return 0; + return (int)((short)*a - (short)*b); +} + +wchar_t *wcscpy(wchar_t *dst, const wchar_t *src) { + wchar_t *d = dst; + while ((*d++ = *src++)) {} + return dst; +} + +wchar_t *wcsncpy(wchar_t *dst, const wchar_t *src, size_t n) { + wchar_t *d = dst; + while (n && (*d = *src)) { d++; src++; n--; } + while (n--) *d++ = 0; + return dst; +} + +wchar_t *wcscat(wchar_t *dst, const wchar_t *src) { + wchar_t *d = dst; + while (*d) d++; + while ((*d++ = *src++)) {} + return dst; +} + +wchar_t *wcschr(const wchar_t *s, wchar_t c) { + while (*s) { + if (*s == c) return (wchar_t *)s; + s++; + } + return (c == 0) ? (wchar_t *)s : (wchar_t *)0; +} + +wchar_t *wcsrchr(const wchar_t *s, wchar_t c) { + const wchar_t *last = (const wchar_t *)0; + while (*s) { + if (*s == c) last = s; + s++; + } + if (c == 0) return (wchar_t *)s; + return (wchar_t *)last; +} + +int mbtowc(wchar_t *pwc, const char *s, size_t n) { + if (!s) return 0; // no shift state + if (n == 0) return -1; + unsigned char c = (unsigned char)*s; + if (pwc) *pwc = (wchar_t)c; + return c ? 1 : 0; +} + +int wctomb(char *s, wchar_t wc) { + if (!s) return 0; // no shift state + if (wc > 0xFF) return -1; + *s = (char)wc; + return 1; +} + +size_t mbstowcs(wchar_t *pwcs, const char *s, size_t n) { + size_t i = 0; + while (i < n && s[i]) { + if (pwcs) pwcs[i] = (wchar_t)(unsigned char)s[i]; + i++; + } + if (pwcs && i < n) pwcs[i] = 0; + return i; +} + +size_t wcstombs(char *s, const wchar_t *pwcs, size_t n) { + size_t i = 0; + while (i < n && pwcs[i]) { + if (pwcs[i] > 0xFF) return (size_t)-1; + if (s) s[i] = (char)pwcs[i]; + i++; + } + if (s && i < n) s[i] = 0; + return i; +} + +int mblen(const char *s, size_t n) { + if (!s) return 0; + if (n == 0) return -1; + return *s ? 1 : 0; +} diff --git a/runtime/src/iigsToolbox.s b/runtime/src/iigsToolbox.s index 90a1305..32d0c28 100644 --- a/runtime/src/iigsToolbox.s +++ b/runtime/src/iigsToolbox.s @@ -1,223 +1,18613 @@ -; iigsToolbox.s — multi-arg toolbox wrappers that can't be done as -; inline asm because the W65816 backend's inline-asm constraints -; can't take memory operands. +; AUTOGENERATED by scripts/genToolbox.py from ORCA-C ORCACDefs/. +; DO NOT EDIT by hand — regenerate to update. ; -; C ABI on this target: -; - Arg 0 (i16): in A -; - Arg 0 (i32): low half in A, high half in X -; - Arg N>0 (i16):in stack at (4 + 2*(N-1)), S — args pushed -; rightmost-first, JSL adds 3 bytes of retaddr -; (4,S = arg1 lo) -; - i16 return: A -; - i32 return: A (low) + X (high) +; IIgs toolbox multi-arg wrappers. ; -; Toolbox calls expect: -; - Args on stack in toolbox order (rightmost pushed first), then -; a result slot of appropriate width pushed BEFORE the args (so -; the result ends up at the highest stack address after pushes). -; - Tool number in X. -; - JSL $E10000. -; - After JSL, pop result then args in reverse. +; C ABI: arg0 (i16) in A, arg0 (i32) in A:X, arg1+ on stack (4,S etc.). +; Each wrapper re-pushes args in toolbox (Pascal-style L-to-R) order, +; preceded by result space if non-void return, then JSL $E10000 +; (or $E100A8 for GS/OS). Pops result if non-void. ; -; All wrappers preserve nothing (toolbox clobbers A, X, Y, P). +; Tool number: high byte = function, low byte = tool set. .text - .globl TBoxNewHandle - .globl TBoxDisposeHandle - .globl TBoxQDStartUp - .globl TBoxMoveTo - .globl TBoxEMStartUp - .globl TBoxGetNextEvent - .globl TBoxNewWindow - .globl TBoxCloseWindow -; ===================================================================== -; unsigned long TBoxNewHandle(u32 size, u16 userId, u16 attr, u32 addr) -; Entry: A = size lo, X = size hi -; 4,S = userId, 6,S = attr, 8,S = addr lo, 10,S = addr hi -; Tool layout (push order, leftmost=outermost on stack): -; [result lo][result hi][size lo][size hi][userId][attr][addr lo][addr hi] -; Wait: NewHandle args per Apple GS docs are -; (Long blockSize, Word userId, Word attributes, Long memAttr) -; pushed leftmost-first, so: -; PEA result hi, PEA result lo -; PUSH blockSize hi, PUSH blockSize lo (long, lo first then hi? no — let me check) -; -; Actually GS toolbox push order: each parameter is pushed in -; declaration order, low word first then high word for longs. -; Result space is pushed FIRST (and is read LAST after the pop -; sequence reverses everything). So: -; PEA 0 ; result hi -; PEA 0 ; result lo -; PHA size lo -; PHB? no: -; per https://www.brutaldeluxe.fr/products/crossdevtools/cadius/ -; Push order: parameters in order, longs as lo then hi. -; For NewHandle(blockSize=Long, userId=Word, attr=Word, memLoc=Long): -; pea 0 ; result lo -; pea 0 ; result hi -; pha ; blockSize lo -; phx ; blockSize hi (since size hi is in X) -; pha userId -; pha attr -; pha addrLo -; pha addrHi -; ldx #$0902 ; jsl $E10000 -; ; result is now on stack: pop hi then lo into A:X return -; -; Note: the IIgs toolbox actually expects result space to be HIGHER -; on stack (pushed first) so that pops in reverse give result last. -; ===================================================================== -TBoxNewHandle: - ; Stash size lo (in A) and size hi (in X) before we use the - ; stack — both must be pushed AFTER the result slot. - sta 0xe0 ; size lo to scratch - stx 0xe2 ; size hi to scratch - - ; Push 4-byte result space (will be popped at end). - pea 0 ; result lo - pea 0 ; result hi - - ; Push blockSize: lo first then hi. - lda 0xe0 ; size lo +; ACEInfo(Word) -> LongWord +; tool 0x071D, set 0x1D (ACETools) + .globl ACEInfo +ACEInfo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 pha - lda 0xe2 ; size hi - pha - - ; Push userId (was at 4,S originally; pushes since added: 4 result + 4 size = 8; +4 for JSL retaddr offset baseline) - ; Original 4,S; we've pha'd 8 bytes (result+size) on top of retaddr - ; So userId is now at 4 + 8 = 12,S. - lda 12, s ; userId - pha - - ; attr was at 6,S originally; now at 6 + 8 + 2 (one more pha) = 16,S. - lda 16, s ; attr - pha - - ; addr lo was at 8,S originally; with all our pushes (4 result + 4 - ; size + 2 user + 2 attr = 12), now at 8 + 12 = 20,S. - lda 20, s ; addr lo - pha - - ; addr hi was at 10,S originally; +14 = 24,S. - lda 24, s ; addr hi - pha - - ldx #0x0902 + ldx #0x071D jsl 0xe10000 - - ; Pop result: hi then lo. Returns u32 in A:X (low in A, hi in X). - pla ; result hi - tax - pla ; result lo → A + pla ; result lo -> A + plx ; result hi -> X rtl +; ACECompress(Handle, Long, Handle, Long, Word, Word) -> void +; tool 0x091D, set 0x1D (ACETools) + .globl ACECompress +ACECompress: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Handle, 4B) --- + lda 16, s + pha + lda 18, s + pha + ; --- arg3 (Long, 4B) --- + lda 24, s + pha + lda 26, s + pha + ; --- arg4 (Word, 2B) --- + lda 32, s + pha + ; --- arg5 (Word, 2B) --- + lda 36, s + pha + ldx #0x091D + jsl 0xe10000 + rtl -; ===================================================================== -; void TBoxDisposeHandle(unsigned long handle) -; Entry: A = handle lo, X = handle hi -; ===================================================================== -TBoxDisposeHandle: - pha ; handle lo - phx ; handle hi +; ACEExpand(Handle, Long, Handle, Long, Word, Word) -> void +; tool 0x0A1D, set 0x1D (ACETools) + .globl ACEExpand +ACEExpand: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Handle, 4B) --- + lda 16, s + pha + lda 18, s + pha + ; --- arg3 (Long, 4B) --- + lda 24, s + pha + lda 26, s + pha + ; --- arg4 (Word, 2B) --- + lda 32, s + pha + ; --- arg5 (Word, 2B) --- + lda 36, s + pha + ldx #0x0A1D + jsl 0xe10000 + rtl + +; GetACEExpState(Ptr) -> void +; tool 0x0D1D, set 0x1D (ACETools) + .globl GetACEExpState +GetACEExpState: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0D1D + jsl 0xe10000 + rtl + +; SetACEExpState(Ptr) -> void +; tool 0x0E1D, set 0x1D (ACETools) + .globl SetACEExpState +SetACEExpState: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0E1D + jsl 0xe10000 + rtl + +; AsyncADBReceive(Pointer, Word) -> void +; tool 0x0D09, set 0x09 (AppleDeskBus) + .globl AsyncADBReceive +AsyncADBReceive: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x0D09 + jsl 0xe10000 + rtl + +; GetAbsScale(ScaleRecPtr) -> void +; tool 0x1309, set 0x09 (AppleDeskBus) + .globl GetAbsScale +GetAbsScale: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1309 + jsl 0xe10000 + rtl + +; ReadKeyMicroData(Word, Pointer, Word) -> void +; tool 0x0A09, set 0x09 (AppleDeskBus) + .globl ReadKeyMicroData +ReadKeyMicroData: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x0A09 + jsl 0xe10000 + rtl + +; ReadKeyMicroMemory(Pointer, Pointer, Word) -> void +; tool 0x0B09, set 0x09 (AppleDeskBus) + .globl ReadKeyMicroMemory +ReadKeyMicroMemory: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Word, 2B) --- + lda 16, s + pha + ldx #0x0B09 + jsl 0xe10000 + rtl + +; SendInfo(Word, Pointer, Word) -> void +; tool 0x0909, set 0x09 (AppleDeskBus) + .globl SendInfo +SendInfo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x0909 + jsl 0xe10000 + rtl + +; SetAbsScale(ScaleRecPtr) -> void +; tool 0x1209, set 0x09 (AppleDeskBus) + .globl SetAbsScale +SetAbsScale: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1209 + jsl 0xe10000 + rtl + +; SRQPoll(Pointer, Word) -> void +; tool 0x1409, set 0x09 (AppleDeskBus) + .globl SRQPoll +SRQPoll: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x1409 + jsl 0xe10000 + rtl + +; SyncADBReceive(Word, Pointer, Word) -> void +; tool 0x0E09, set 0x09 (AppleDeskBus) + .globl SyncADBReceive +SyncADBReceive: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x0E09 + jsl 0xe10000 + rtl + +; CtlStartUp(Word, Word) -> void +; tool 0x0210, set 0x10 (ControlManager) + .globl CtlStartUp +CtlStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0210 + jsl 0xe10000 + rtl + +; DisposeControl(CtlRecHndl) -> void +; tool 0x0A10, set 0x10 (ControlManager) + .globl DisposeControl +DisposeControl: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0A10 + jsl 0xe10000 + rtl + +; DragControl(Integer, Integer, Rect, Rect, Word, CtlRecHndl) -> void +; tool 0x1710, set 0x10 (ControlManager) + .globl DragControl +DragControl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (Rect, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg3 (Rect, 4B) --- + lda 18, s + pha + lda 20, s + pha + ; --- arg4 (Word, 2B) --- + lda 26, s + pha + ; --- arg5 (CtlRecHndl, 4B) --- + lda 30, s + pha + lda 32, s + pha + ldx #0x1710 + jsl 0xe10000 + rtl + +; DragRect(VoidProcPtr, Pattern, Integer, Integer, Rect, Rect, Rect, Word) -> Point +; tool 0x1D10, set 0x10 (ControlManager) + .globl DragRect +DragRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pattern, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg2 (Integer, 2B) --- + lda 20, s + pha + ; --- arg3 (Integer, 2B) --- + lda 24, s + pha + ; --- arg4 (Rect, 4B) --- + lda 28, s + pha + lda 30, s + pha + ; --- arg5 (Rect, 4B) --- + lda 36, s + pha + lda 38, s + pha + ; --- arg6 (Rect, 4B) --- + lda 44, s + pha + lda 46, s + pha + ; --- arg7 (Word, 2B) --- + lda 52, s + pha + ldx #0x1D10 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; DrawControls(GrafPortPtr) -> void +; tool 0x1010, set 0x10 (ControlManager) + .globl DrawControls +DrawControls: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1010 + jsl 0xe10000 + rtl + +; DrawOneCtl(CtlRecHndl) -> void +; tool 0x2510, set 0x10 (ControlManager) + .globl DrawOneCtl +DrawOneCtl: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2510 + jsl 0xe10000 + rtl + +; EraseControl(CtlRecHndl) -> void +; tool 0x2410, set 0x10 (ControlManager) + .globl EraseControl +EraseControl: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2410 + jsl 0xe10000 + rtl + +; FindControl(CtlRecHndl, Integer, Integer, GrafPortPtr) -> Word +; tool 0x1310, set 0x10 (ControlManager) + .globl FindControl +FindControl: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 10, s + pha + ; --- arg2 (Integer, 2B) --- + lda 14, s + pha + ; --- arg3 (GrafPortPtr, 4B) --- + lda 18, s + pha + lda 20, s + pha + ldx #0x1310 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetCtlAction(CtlRecHndl) -> LongProcPtr +; tool 0x2110, set 0x10 (ControlManager) + .globl GetCtlAction +GetCtlAction: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2110 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetCtlParams(CtlRecHndl) -> LongWord +; tool 0x1C10, set 0x10 (ControlManager) + .globl GetCtlParams +GetCtlParams: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1C10 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetCtlRefCon(CtlRecHndl) -> LongWord +; tool 0x2310, set 0x10 (ControlManager) + .globl GetCtlRefCon +GetCtlRefCon: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2310 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetCtlTitle(CtlRecHndl) -> Pointer +; tool 0x0D10, set 0x10 (ControlManager) + .globl GetCtlTitle +GetCtlTitle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0D10 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetCtlValue(CtlRecHndl) -> Word +; tool 0x1A10, set 0x10 (ControlManager) + .globl GetCtlValue +GetCtlValue: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1A10 + jsl 0xe10000 + pla ; result -> A + rtl + +; GrowSize(void) -> LongWord +; tool 0x1E10, set 0x10 (ControlManager) + .globl GrowSize +GrowSize: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1E10 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; HideControl(CtlRecHndl) -> void +; tool 0x0E10, set 0x10 (ControlManager) + .globl HideControl +HideControl: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0E10 + jsl 0xe10000 + rtl + +; HiliteControl(Word, CtlRecHndl) -> void +; tool 0x1110, set 0x10 (ControlManager) + .globl HiliteControl +HiliteControl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (CtlRecHndl, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x1110 + jsl 0xe10000 + rtl + +; KillControls(GrafPortPtr) -> void +; tool 0x0B10, set 0x10 (ControlManager) + .globl KillControls +KillControls: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0B10 + jsl 0xe10000 + rtl + +; MoveControl(Integer, Integer, CtlRecHndl) -> void +; tool 0x1610, set 0x10 (ControlManager) + .globl MoveControl +MoveControl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (CtlRecHndl, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1610 + jsl 0xe10000 + rtl + +; NewControl(GrafPortPtr, Rect, Pointer, Word, Word, Word, Word, LongProcPtr, Longint, Pointer) -> CtlRecHndl +; tool 0x0910, set 0x10 (ControlManager) + .globl NewControl +NewControl: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 20, s + pha + lda 22, s + pha + ; --- arg3 (Word, 2B) --- + lda 28, s + pha + ; --- arg4 (Word, 2B) --- + lda 32, s + pha + ; --- arg5 (Word, 2B) --- + lda 36, s + pha + ; --- arg6 (Word, 2B) --- + lda 40, s + pha + ; --- arg7 (LongProcPtr, 4B) --- + lda 44, s + pha + lda 46, s + pha + ; --- arg8 (Longint, 4B) --- + lda 52, s + pha + lda 54, s + pha + ; --- arg9 (Pointer, 4B) --- + lda 60, s + pha + lda 62, s + pha + ldx #0x0910 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SetCtlAction(LongProcPtr, CtlRecHndl) -> void +; tool 0x2010, set 0x10 (ControlManager) + .globl SetCtlAction +SetCtlAction: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (CtlRecHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x2010 + jsl 0xe10000 + rtl + +; SetCtlIcons(FontHndl) -> FontHndl +; tool 0x1810, set 0x10 (ControlManager) + .globl SetCtlIcons +SetCtlIcons: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1810 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SetCtlParams(Word, Word, CtlRecHndl) -> void +; tool 0x1B10, set 0x10 (ControlManager) + .globl SetCtlParams +SetCtlParams: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (CtlRecHndl, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1B10 + jsl 0xe10000 + rtl + +; SetCtlRefCon(Longint, CtlRecHndl) -> void +; tool 0x2210, set 0x10 (ControlManager) + .globl SetCtlRefCon +SetCtlRefCon: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (CtlRecHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x2210 + jsl 0xe10000 + rtl + +; SetCtlTitle(Pointer, Handle) -> void +; tool 0x0C10, set 0x10 (ControlManager) + .globl SetCtlTitle +SetCtlTitle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0C10 + jsl 0xe10000 + rtl + +; SetCtlValue(Word, CtlRecHndl) -> void +; tool 0x1910, set 0x10 (ControlManager) + .globl SetCtlValue +SetCtlValue: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (CtlRecHndl, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x1910 + jsl 0xe10000 + rtl + +; ShowControl(CtlRecHndl) -> void +; tool 0x0F10, set 0x10 (ControlManager) + .globl ShowControl +ShowControl: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0F10 + jsl 0xe10000 + rtl + +; TestControl(Integer, Integer, CtlRecHndl) -> Word +; tool 0x1410, set 0x10 (ControlManager) + .globl TestControl +TestControl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (CtlRecHndl, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x1410 + jsl 0xe10000 + pla ; result -> A + rtl + +; TrackControl(Integer, Integer, LongProcPtr, CtlRecHndl) -> Word +; tool 0x1510, set 0x10 (ControlManager) + .globl TrackControl +TrackControl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (LongProcPtr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg3 (CtlRecHndl, 4B) --- + lda 20, s + pha + lda 22, s + pha + ldx #0x1510 + jsl 0xe10000 + pla ; result -> A + rtl + +; CallCtlDefProc(CtlRecHndl, Word, Long) -> LongWord +; tool 0x2C10, set 0x10 (ControlManager) + .globl CallCtlDefProc +CallCtlDefProc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 12, s + pha + ; --- arg2 (Long, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x2C10 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; CMLoadResource(Word, Long) -> Handle +; tool 0x3210, set 0x10 (ControlManager) + .globl CMLoadResource +CMLoadResource: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x3210 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; CMReleaseResource(Word, Long) -> void +; tool 0x3310, set 0x10 (ControlManager) + .globl CMReleaseResource +CMReleaseResource: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x3310 + jsl 0xe10000 + rtl + +; FindTargetCtl(void) -> CtlRecHndl +; tool 0x2610, set 0x10 (ControlManager) + .globl FindTargetCtl +FindTargetCtl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2610 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetCtlHandleFromID(WindowPtr, Long) -> CtlRecHndl +; tool 0x3010, set 0x10 (ControlManager) + .globl GetCtlHandleFromID +GetCtlHandleFromID: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x3010 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetCtlID(CtlRecHndl) -> LongWord +; tool 0x2A10, set 0x10 (ControlManager) + .globl GetCtlID +GetCtlID: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2A10 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetCtlMoreFlags(CtlRecHndl) -> Word +; tool 0x2E10, set 0x10 (ControlManager) + .globl GetCtlMoreFlags +GetCtlMoreFlags: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2E10 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetCtlParamPtr(void) -> Pointer +; tool 0x3510, set 0x10 (ControlManager) + .globl GetCtlParamPtr +GetCtlParamPtr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x3510 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; InvalCtls(WindowPtr) -> void +; tool 0x3710, set 0x10 (ControlManager) + .globl InvalCtls +InvalCtls: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3710 + jsl 0xe10000 + rtl + +; MakeNextCtlTarget(void) -> CtlRecHndl +; tool 0x2710, set 0x10 (ControlManager) + .globl MakeNextCtlTarget +MakeNextCtlTarget: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2710 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MakeThisCtlTarget(CtlRecHndl) -> void +; tool 0x2810, set 0x10 (ControlManager) + .globl MakeThisCtlTarget +MakeThisCtlTarget: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2810 + jsl 0xe10000 + rtl + +; NewControl2(WindowPtr, Word, Ref) -> CtlRecHndl +; tool 0x3110, set 0x10 (ControlManager) + .globl NewControl2 +NewControl2: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 12, s + pha + ; --- arg2 (Ref, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x3110 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; NotifyControls(Word, Word, Long, WindowPtr) -> void +; tool 0x2D10, set 0x10 (ControlManager) + .globl NotifyControls +NotifyControls: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg3 (WindowPtr, 4B) --- + lda 18, s + pha + lda 20, s + pha + ldx #0x2D10 + jsl 0xe10000 + rtl + +; NotifyCtls(Word, Word, Long, WindowPtr) -> void +; tool 0x2D10, set 0x10 (ControlManager) + .globl NotifyCtls +NotifyCtls: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg3 (WindowPtr, 4B) --- + lda 18, s + pha + lda 20, s + pha + ldx #0x2D10 + jsl 0xe10000 + rtl + +; SendEventToCtl(Boolean, WindowPtr, EventRecordPtr) -> Boolean +; tool 0x2910, set 0x10 (ControlManager) + .globl SendEventToCtl +SendEventToCtl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (WindowPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (EventRecordPtr, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x2910 + jsl 0xe10000 + pla ; result -> A + rtl + +; SetCtlID(Long, CtlRecHndl) -> void +; tool 0x2B10, set 0x10 (ControlManager) + .globl SetCtlID +SetCtlID: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (CtlRecHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x2B10 + jsl 0xe10000 + rtl + +; SetCtlMoreFlags(Word, CtlRecHndl) -> void +; tool 0x2F10, set 0x10 (ControlManager) + .globl SetCtlMoreFlags +SetCtlMoreFlags: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (CtlRecHndl, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x2F10 + jsl 0xe10000 + rtl + +; SetCtlParamPtr(Pointer) -> void +; tool 0x3410, set 0x10 (ControlManager) + .globl SetCtlParamPtr +SetCtlParamPtr: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3410 + jsl 0xe10000 + rtl + +; FindRadioButton(WindowPtr, Word) -> Word +; tool 0x3910, set 0x10 (ControlManager) + .globl FindRadioButton +FindRadioButton: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x3910 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetLETextByID(WindowPtr, Long, StringPtr) -> void +; tool 0x3B10, set 0x10 (ControlManager) + .globl GetLETextByID +GetLETextByID: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (StringPtr, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x3B10 + jsl 0xe10000 + rtl + +; SetLETextByID(WindowPtr, Long, StringPtr) -> void +; tool 0x3A10, set 0x10 (ControlManager) + .globl SetLETextByID +SetLETextByID: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (StringPtr, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x3A10 + jsl 0xe10000 + rtl + +; SetCtlValueByID(Word, GrafPortPtr, Long) -> void +; tool 0x3C10, set 0x10 (ControlManager) + .globl SetCtlValueByID +SetCtlValueByID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Long, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x3C10 + jsl 0xe10000 + rtl + +; GetCtlValueByID(GrafPortPtr, Long) -> Word +; tool 0x3D10, set 0x10 (ControlManager) + .globl GetCtlValueByID +GetCtlValueByID: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x3D10 + jsl 0xe10000 + pla ; result -> A + rtl + +; InvalOneCtlByID(GrafPortPtr, Long) -> void +; tool 0x3E10, set 0x10 (ControlManager) + .globl InvalOneCtlByID +InvalOneCtlByID: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x3E10 + jsl 0xe10000 + rtl + +; HiliteCtlByID(Word, GrafPortPtr, Long) -> void +; tool 0x3F10, set 0x10 (ControlManager) + .globl HiliteCtlByID +HiliteCtlByID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Long, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x3F10 + jsl 0xe10000 + rtl + +; CloseNDAbyWinPtr(GrafPortPtr) -> void +; tool 0x1C05, set 0x05 (DeskManager) + .globl CloseNDAbyWinPtr +CloseNDAbyWinPtr: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1C05 + jsl 0xe10000 + rtl + +; CloseNDAByWinPtr(GrafPortPtr) -> void +; tool 0x1C05, set 0x05 (DeskManager) + .globl CloseNDAByWinPtr +CloseNDAByWinPtr: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1C05 + jsl 0xe10000 + rtl + +; GetDAStrPtr(void) -> Pointer +; tool 0x1405, set 0x05 (DeskManager) + .globl GetDAStrPtr +GetDAStrPtr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1405 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; InstallCDA(Handle) -> void +; tool 0x0F05, set 0x05 (DeskManager) + .globl InstallCDA +InstallCDA: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0F05 + jsl 0xe10000 + rtl + +; InstallNDA(Handle) -> void +; tool 0x0E05, set 0x05 (DeskManager) + .globl InstallNDA +InstallNDA: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0E05 + jsl 0xe10000 + rtl + +; SetDAStrPtr(Handle, Pointer) -> void +; tool 0x1305, set 0x05 (DeskManager) + .globl SetDAStrPtr +SetDAStrPtr: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1305 + jsl 0xe10000 + rtl + +; SystemClick(EventRecordPtr, GrafPortPtr, Word) -> void +; tool 0x1705, set 0x05 (DeskManager) + .globl SystemClick +SystemClick: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Word, 2B) --- + lda 16, s + pha + ldx #0x1705 + jsl 0xe10000 + rtl + +; SystemEvent(Word, Long, Long, Point, Word) -> Boolean +; tool 0x1A05, set 0x05 (DeskManager) + .globl SystemEvent +SystemEvent: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Long, 4B) --- + lda 16, s + pha + lda 18, s + pha + ; --- arg3 (Point, 4B) --- + lda 24, s + pha + lda 26, s + pha + ; --- arg4 (Word, 2B) --- + lda 32, s + pha + ldx #0x1A05 + jsl 0xe10000 + pla ; result -> A + rtl + +; AddToRunQ(Pointer) -> void +; tool 0x1F05, set 0x05 (DeskManager) + .globl AddToRunQ +AddToRunQ: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1F05 + jsl 0xe10000 + rtl + +; RemoveCDA(Handle) -> void +; tool 0x2105, set 0x05 (DeskManager) + .globl RemoveCDA +RemoveCDA: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2105 + jsl 0xe10000 + rtl + +; RemoveFromRunQ(Pointer) -> void +; tool 0x2005, set 0x05 (DeskManager) + .globl RemoveFromRunQ +RemoveFromRunQ: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2005 + jsl 0xe10000 + rtl + +; RemoveNDA(Handle) -> void +; tool 0x2205, set 0x05 (DeskManager) + .globl RemoveNDA +RemoveNDA: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2205 + jsl 0xe10000 + rtl + +; CallDeskAcc(Word, Long, Word, Long) -> Word +; tool 0x2405, set 0x05 (DeskManager) + .globl CallDeskAcc +CallDeskAcc: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Word, 2B) --- + lda 16, s + pha + ; --- arg3 (Long, 4B) --- + lda 20, s + pha + lda 22, s + pha + ldx #0x2405 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetDeskAccInfo(Word, Long, Word, Ptr) -> void +; tool 0x2305, set 0x05 (DeskManager) + .globl GetDeskAccInfo +GetDeskAccInfo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ; --- arg3 (Ptr, 4B) --- + lda 18, s + pha + lda 20, s + pha + ldx #0x2305 + jsl 0xe10000 + rtl + +; GetDeskGlobal(Word) -> LongWord +; tool 0x2505, set 0x05 (DeskManager) + .globl GetDeskGlobal +GetDeskGlobal: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2505 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; Alert(AlertTempPtr, WordProcPtr) -> Word +; tool 0x1715, set 0x15 (DialogManager) + .globl Alert +Alert: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (WordProcPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1715 + jsl 0xe10000 + pla ; result -> A + rtl + +; CautionAlert(AlertTempPtr, WordProcPtr) -> Word +; tool 0x1A15, set 0x15 (DialogManager) + .globl CautionAlert +CautionAlert: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (WordProcPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1A15 + jsl 0xe10000 + pla ; result -> A + rtl + +; CloseDialog(GrafPortPtr) -> void +; tool 0x0C15, set 0x15 (DialogManager) + .globl CloseDialog +CloseDialog: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0C15 + jsl 0xe10000 + rtl + +; DefaultFilter(GrafPortPtr, EventRecordPtr, Word) -> Boolean +; tool 0x3615, set 0x15 (DialogManager) + .globl DefaultFilter +DefaultFilter: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (EventRecordPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Word, 2B) --- + lda 18, s + pha + ldx #0x3615 + jsl 0xe10000 + pla ; result -> A + rtl + +; DialogSelect(EventRecordPtr, GrafPortPtr, Word) -> Boolean +; tool 0x1115, set 0x15 (DialogManager) + .globl DialogSelect +DialogSelect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Word, 2B) --- + lda 18, s + pha + ldx #0x1115 + jsl 0xe10000 + pla ; result -> A + rtl + +; DisableDItem(GrafPortPtr, Word) -> void +; tool 0x3915, set 0x15 (DialogManager) + .globl DisableDItem +DisableDItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x3915 + jsl 0xe10000 + rtl + +; DlgCopy(GrafPortPtr) -> void +; tool 0x1315, set 0x15 (DialogManager) + .globl DlgCopy +DlgCopy: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1315 + jsl 0xe10000 + rtl + +; DlgCut(GrafPortPtr) -> void +; tool 0x1215, set 0x15 (DialogManager) + .globl DlgCut +DlgCut: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1215 + jsl 0xe10000 + rtl + +; DlgDelete(GrafPortPtr) -> void +; tool 0x1515, set 0x15 (DialogManager) + .globl DlgDelete +DlgDelete: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1515 + jsl 0xe10000 + rtl + +; DlgPaste(GrafPortPtr) -> void +; tool 0x1415, set 0x15 (DialogManager) + .globl DlgPaste +DlgPaste: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1415 + jsl 0xe10000 + rtl + +; DrawDialog(GrafPortPtr) -> void +; tool 0x1615, set 0x15 (DialogManager) + .globl DrawDialog +DrawDialog: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1615 + jsl 0xe10000 + rtl + +; EnableDItem(GrafPortPtr, Word) -> void +; tool 0x3A15, set 0x15 (DialogManager) + .globl EnableDItem +EnableDItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x3A15 + jsl 0xe10000 + rtl + +; ErrorSound(VoidProcPtr) -> void +; tool 0x0915, set 0x15 (DialogManager) + .globl ErrorSound +ErrorSound: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0915 + jsl 0xe10000 + rtl + +; FindDItem(GrafPortPtr, Point) -> Word +; tool 0x2415, set 0x15 (DialogManager) + .globl FindDItem +FindDItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Point, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x2415 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetControlDItem(GrafPortPtr, Word) -> CtlRecHndl +; tool 0x1E15, set 0x15 (DialogManager) + .globl GetControlDItem +GetControlDItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 12, s + pha + ldx #0x1E15 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetDefButton(GrafPortPtr) -> Word +; tool 0x3715, set 0x15 (DialogManager) + .globl GetDefButton +GetDefButton: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3715 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetDItemBox(GrafPortPtr, Word, Rect) -> void +; tool 0x2815, set 0x15 (DialogManager) + .globl GetDItemBox +GetDItemBox: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Rect, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x2815 + jsl 0xe10000 + rtl + +; GetDItemType(GrafPortPtr, Word) -> Word +; tool 0x2615, set 0x15 (DialogManager) + .globl GetDItemType +GetDItemType: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x2615 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetDItemValue(GrafPortPtr, Word) -> Word +; tool 0x2E15, set 0x15 (DialogManager) + .globl GetDItemValue +GetDItemValue: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x2E15 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetFirstDItem(GrafPortPtr) -> Word +; tool 0x2A15, set 0x15 (DialogManager) + .globl GetFirstDItem +GetFirstDItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2A15 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetIText(GrafPortPtr, Word, Pointer) -> void +; tool 0x1F15, set 0x15 (DialogManager) + .globl GetIText +GetIText: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x1F15 + jsl 0xe10000 + rtl + +; GetNewDItem(GrafPortPtr, ItemTempPtr) -> void +; tool 0x3315, set 0x15 (DialogManager) + .globl GetNewDItem +GetNewDItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (ItemTempPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x3315 + jsl 0xe10000 + rtl + +; GetNewModalDialog(DlgTempPtr) -> DialogPtr +; tool 0x3215, set 0x15 (DialogManager) + .globl GetNewModalDialog +GetNewModalDialog: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3215 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetNextDItem(GrafPortPtr, Word) -> Word +; tool 0x2B15, set 0x15 (DialogManager) + .globl GetNextDItem +GetNextDItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x2B15 + jsl 0xe10000 + pla ; result -> A + rtl + +; HideDItem(GrafPortPtr, Word) -> void +; tool 0x2215, set 0x15 (DialogManager) + .globl HideDItem +HideDItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x2215 + jsl 0xe10000 + rtl + +; IsDialogEvent(EventRecordPtr) -> Boolean +; tool 0x1015, set 0x15 (DialogManager) + .globl IsDialogEvent +IsDialogEvent: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1015 + jsl 0xe10000 + pla ; result -> A + rtl + +; ModalDialog(WordProcPtr) -> Word +; tool 0x0F15, set 0x15 (DialogManager) + .globl ModalDialog +ModalDialog: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0F15 + jsl 0xe10000 + pla ; result -> A + rtl + +; ModalDialog2(WordProcPtr) -> LongWord +; tool 0x2C15, set 0x15 (DialogManager) + .globl ModalDialog2 +ModalDialog2: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2C15 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; NewDItem(GrafPortPtr, Word, Rect, Word, Pointer, Word, Word, Pointer) -> void +; tool 0x0D15, set 0x15 (DialogManager) + .globl NewDItem +NewDItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Rect, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg3 (Word, 2B) --- + lda 20, s + pha + ; --- arg4 (Pointer, 4B) --- + lda 24, s + pha + lda 26, s + pha + ; --- arg5 (Word, 2B) --- + lda 32, s + pha + ; --- arg6 (Word, 2B) --- + lda 36, s + pha + ; --- arg7 (Pointer, 4B) --- + lda 40, s + pha + lda 42, s + pha + ldx #0x0D15 + jsl 0xe10000 + rtl + +; NewModalDialog(Rect, Boolean, LongWord) -> DialogPtr +; tool 0x0A15, set 0x15 (DialogManager) + .globl NewModalDialog +NewModalDialog: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Boolean, 2B) --- + lda 12, s + pha + ; --- arg2 (LongWord, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x0A15 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; NewModelessDialog(Rect, Pointer, GrafPortPtr, Word, LongWord, Rect) -> DialogPtr +; tool 0x0B15, set 0x15 (DialogManager) + .globl NewModelessDialog +NewModelessDialog: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 20, s + pha + lda 22, s + pha + ; --- arg3 (Word, 2B) --- + lda 28, s + pha + ; --- arg4 (LongWord, 4B) --- + lda 32, s + pha + lda 34, s + pha + ; --- arg5 (Rect, 4B) --- + lda 40, s + pha + lda 42, s + pha + ldx #0x0B15 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; NoteAlert(AlertTempPtr, WordProcPtr) -> Word +; tool 0x1915, set 0x15 (DialogManager) + .globl NoteAlert +NoteAlert: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (WordProcPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1915 + jsl 0xe10000 + pla ; result -> A + rtl + +; ParamText(Pointer, Pointer, Pointer, Pointer) -> void +; tool 0x1B15, set 0x15 (DialogManager) + .globl ParamText +ParamText: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 16, s + pha + lda 18, s + pha + ; --- arg3 (Pointer, 4B) --- + lda 24, s + pha + lda 26, s + pha + ldx #0x1B15 + jsl 0xe10000 + rtl + +; RemoveDItem(GrafPortPtr, Word) -> void +; tool 0x0E15, set 0x15 (DialogManager) + .globl RemoveDItem +RemoveDItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x0E15 + jsl 0xe10000 + rtl + +; SelectIText(GrafPortPtr, Word, Word, Word) -> void +; tool 0x2115, set 0x15 (DialogManager) + .globl SelectIText +SelectIText: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ; --- arg3 (Word, 2B) --- + lda 16, s + pha + ldx #0x2115 + jsl 0xe10000 + rtl + +; SelIText(GrafPortPtr, Word, Word, Word) -> void +; tool 0x2115, set 0x15 (DialogManager) + .globl SelIText +SelIText: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ; --- arg3 (Word, 2B) --- + lda 16, s + pha + ldx #0x2115 + jsl 0xe10000 + rtl + +; SetDAFont(FontHndl) -> void +; tool 0x1C15, set 0x15 (DialogManager) + .globl SetDAFont +SetDAFont: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1C15 + jsl 0xe10000 + rtl + +; SetDefButton(Word, GrafPortPtr) -> void +; tool 0x3815, set 0x15 (DialogManager) + .globl SetDefButton +SetDefButton: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x3815 + jsl 0xe10000 + rtl + +; SetDItemBox(GrafPortPtr, Word, Rect) -> void +; tool 0x2915, set 0x15 (DialogManager) + .globl SetDItemBox +SetDItemBox: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Rect, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x2915 + jsl 0xe10000 + rtl + +; SetDItemType(Word, GrafPortPtr, Word) -> void +; tool 0x2715, set 0x15 (DialogManager) + .globl SetDItemType +SetDItemType: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x2715 + jsl 0xe10000 + rtl + +; SetDItemValue(Word, GrafPortPtr, Word) -> void +; tool 0x2F15, set 0x15 (DialogManager) + .globl SetDItemValue +SetDItemValue: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x2F15 + jsl 0xe10000 + rtl + +; SetIText(GrafPortPtr, Word, Pointer) -> void +; tool 0x2015, set 0x15 (DialogManager) + .globl SetIText +SetIText: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x2015 + jsl 0xe10000 + rtl + +; ShowDItem(GrafPortPtr, Word) -> void +; tool 0x2315, set 0x15 (DialogManager) + .globl ShowDItem +ShowDItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x2315 + jsl 0xe10000 + rtl + +; StopAlert(AlertTempPtr, WordProcPtr) -> Word +; tool 0x1815, set 0x15 (DialogManager) + .globl StopAlert +StopAlert: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (WordProcPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1815 + jsl 0xe10000 + pla ; result -> A + rtl + +; UpdateDialog(GrafPortPtr, Handle) -> void +; tool 0x2515, set 0x15 (DialogManager) + .globl UpdateDialog +UpdateDialog: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x2515 + jsl 0xe10000 + rtl + +; EMStartUp(Word, Word, Integer, Integer, Integer, Integer, Word) -> void +; tool 0x0206, set 0x06 (EventManager) + .globl EMStartUp +EMStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Integer, 2B) --- + lda 10, s + pha + ; --- arg3 (Integer, 2B) --- + lda 14, s + pha + ; --- arg4 (Integer, 2B) --- + lda 18, s + pha + ; --- arg5 (Integer, 2B) --- + lda 22, s + pha + ; --- arg6 (Word, 2B) --- + lda 26, s + pha + ldx #0x0206 + jsl 0xe10000 + rtl + +; EventAvail(Word, EventRecordPtr) -> Boolean +; tool 0x0B06, set 0x06 (EventManager) + .globl EventAvail +EventAvail: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (EventRecordPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0B06 + jsl 0xe10000 + pla ; result -> A + rtl + +; FakeMouse(Word, Word, Integer, Integer, Word) -> void +; tool 0x1906, set 0x06 (EventManager) + .globl FakeMouse +FakeMouse: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Integer, 2B) --- + lda 10, s + pha + ; --- arg3 (Integer, 2B) --- + lda 14, s + pha + ; --- arg4 (Word, 2B) --- + lda 18, s + pha + ldx #0x1906 + jsl 0xe10000 + rtl + +; FlushEvents(Word, Word) -> Word +; tool 0x1506, set 0x06 (EventManager) + .globl FlushEvents +FlushEvents: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x1506 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetCaretTime(void) -> LongWord +; tool 0x1206, set 0x06 (EventManager) + .globl GetCaretTime +GetCaretTime: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1206 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetDblTime(void) -> LongWord +; tool 0x1106, set 0x06 (EventManager) + .globl GetDblTime +GetDblTime: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1106 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetMouse(Point) -> void +; tool 0x0C06, set 0x06 (EventManager) + .globl GetMouse +GetMouse: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0C06 + jsl 0xe10000 + rtl + +; GetNextEvent(Word, EventRecordPtr) -> Boolean +; tool 0x0A06, set 0x06 (EventManager) + .globl GetNextEvent +GetNextEvent: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (EventRecordPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0A06 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetOSEvent(Word, EventRecordPtr) -> Boolean +; tool 0x1606, set 0x06 (EventManager) + .globl GetOSEvent +GetOSEvent: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (EventRecordPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1606 + jsl 0xe10000 + pla ; result -> A + rtl + +; OSEventAvail(Word, EventRecordPtr) -> Boolean +; tool 0x1706, set 0x06 (EventManager) + .globl OSEventAvail +OSEventAvail: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (EventRecordPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1706 + jsl 0xe10000 + pla ; result -> A + rtl + +; PostEvent(Word, LongWord) -> Word +; tool 0x1406, set 0x06 (EventManager) + .globl PostEvent +PostEvent: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (LongWord, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1406 + jsl 0xe10000 + pla ; result -> A + rtl + +; TickCount(void) -> LongWord +; tool 0x1006, set 0x06 (EventManager) + .globl TickCount +TickCount: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1006 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FMStartUp(Word, Word) -> void +; tool 0x021B, set 0x1B (FontManager) + .globl FMStartUp +FMStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x021B + jsl 0xe10000 + rtl + +; AddFamily(Word, Pointer) -> void +; tool 0x0D1B, set 0x1B (FontManager) + .globl AddFamily +AddFamily: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x0D1B + jsl 0xe10000 + rtl + +; AddFontVar(FontHndl, Word) -> void +; tool 0x141B, set 0x1B (FontManager) + .globl AddFontVar +AddFontVar: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x141B + jsl 0xe10000 + rtl + +; ChooseFont(FontID, Word) -> LongWord +; tool 0x161B, set 0x1B (FontManager) + .globl ChooseFont +ChooseFont: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 12, s + pha + ldx #0x161B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; CountFonts(FontID, Word) -> Word +; tool 0x101B, set 0x1B (FontManager) + .globl CountFonts +CountFonts: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x101B + jsl 0xe10000 + pla ; result -> A + rtl + +; FindFamily(Word, Word, Pointer) -> Word +; tool 0x0A1B, set 0x1B (FontManager) + .globl FindFamily +FindFamily: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0A1B + jsl 0xe10000 + pla ; result -> A + rtl + +; FindFontStats(FontID, Word, Word, FontStatRecPtr) -> void +; tool 0x111B, set 0x1B (FontManager) + .globl FindFontStats +FindFontStats: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ; --- arg3 (FontStatRecPtr, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x111B + jsl 0xe10000 + rtl + +; FixFontMenu(Word, Word, Word) -> void +; tool 0x151B, set 0x1B (FontManager) + .globl FixFontMenu +FixFontMenu: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ldx #0x151B + jsl 0xe10000 + rtl + +; FMGetCurFID(void) -> LongWord +; tool 0x1A1B, set 0x1B (FontManager) + .globl FMGetCurFID +FMGetCurFID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1A1B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FMGetSysFID(void) -> LongWord +; tool 0x191B, set 0x1B (FontManager) + .globl FMGetSysFID +FMGetSysFID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x191B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FMSetSysFont(FontID) -> void +; tool 0x181B, set 0x1B (FontManager) + .globl FMSetSysFont +FMSetSysFont: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x181B + jsl 0xe10000 + rtl + +; GetFamInfo(Word, Pointer) -> Word +; tool 0x0B1B, set 0x1B (FontManager) + .globl GetFamInfo +GetFamInfo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0B1B + jsl 0xe10000 + pla ; result -> A + rtl + +; GetFamNum(Pointer) -> Word +; tool 0x0C1B, set 0x1B (FontManager) + .globl GetFamNum +GetFamNum: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0C1B + jsl 0xe10000 + pla ; result -> A + rtl + +; InstallFont(FontID, Word) -> void +; tool 0x0E1B, set 0x1B (FontManager) + .globl InstallFont +InstallFont: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x0E1B + jsl 0xe10000 + rtl + +; LoadFont(FontID, Word, Word, FontStatRecPtr) -> void +; tool 0x121B, set 0x1B (FontManager) + .globl LoadFont +LoadFont: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ; --- arg3 (FontStatRecPtr, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x121B + jsl 0xe10000 + rtl + +; SetPurgeStat(FontID, Word) -> void +; tool 0x0F1B, set 0x1B (FontManager) + .globl SetPurgeStat +SetPurgeStat: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x0F1B + jsl 0xe10000 + rtl + +; InstallWithStats(FontID, Word, Pointer) -> void +; tool 0x1C1B, set 0x1B (FontManager) + .globl InstallWithStats +InstallWithStats: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x1C1B + jsl 0xe10000 + rtl + +; DebugStr(Pointer) -> void +; tool 0x09FF, set 0xFF (?) + .globl DebugStr +DebugStr: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x09FF + jsl 0xe10000 + rtl + +; SetMileStone(Pointer) -> void +; tool 0x0AFF, set 0xFF (?) + .globl SetMileStone +SetMileStone: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0AFF + jsl 0xe10000 + rtl + +; DebugSetHook(VoidProcPtr) -> void +; tool 0x0BFF, set 0xFF (?) + .globl DebugSetHook +DebugSetHook: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0BFF + jsl 0xe10000 + rtl + +; DebugGetInfo(Word) -> LongWord +; tool 0x0CFF, set 0xFF (?) + .globl DebugGetInfo +DebugGetInfo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0CFF + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; EvalExpr(Str255) -> Handle +; tool 0x0002, set 0x02 (MemoryManager) + .globl EvalExpr +EvalExpr: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0002 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SendCardMessage(Str255) -> void +; tool 0x0001, set 0x01 (ToolLocator) + .globl SendCardMessage +SendCardMessage: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0001 + jsl 0xe100a8 + rtl + +; SendHCMessage(Str255) -> void +; tool 0x0005, set 0x05 (DeskManager) + .globl SendHCMessage +SendHCMessage: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0005 + jsl 0xe100a8 + rtl + +; GetGlobal(Str255) -> Handle +; tool 0x0012, set 0x12 (QDAuxiliary) + .globl GetGlobal +GetGlobal: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0012 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SetGlobal(Str255, Handle) -> void +; tool 0x0013, set 0x13 (PrintManager) + .globl SetGlobal +SetGlobal: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0013 + jsl 0xe100a8 + rtl + +; ZeroBytes(Ptr, long) -> void +; tool 0x0006, set 0x06 (EventManager) + .globl ZeroBytes +ZeroBytes: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0006 + jsl 0xe100a8 + rtl + +; GSStringEqual(GSString255Hndl, GSString255Hndl) -> Boolean +; tool 0x0022, set 0x22 (TextEdit) + .globl GSStringEqual +GSStringEqual: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GSString255Hndl, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x0022 + jsl 0xe100a8 + pla ; result -> A + rtl + +; ScanToReturn(Ptr) -> void +; tool 0x001C, set 0x1C (ListManager) + .globl ScanToReturn +ScanToReturn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x001C + jsl 0xe100a8 + rtl + +; ScanToZero(Ptr) -> void +; tool 0x001D, set 0x1D (ACETools) + .globl ScanToZero +ScanToZero: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x001D + jsl 0xe100a8 + rtl + +; StringEqual(Str255, Str255) -> Boolean +; tool 0x001A, set 0x1A (NoteSequencer) + .globl StringEqual +StringEqual: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Str255, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x001A + jsl 0xe100a8 + pla ; result -> A + rtl + +; StringLength(Ptr) -> Longint +; tool 0x0003, set 0x03 (MiscTools) + .globl StringLength +StringLength: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0003 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; StringMatch(Str255, Ptr) -> Ptr +; tool 0x0004, set 0x04 (QuickDraw) + .globl StringMatch +StringMatch: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Ptr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0004 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; BoolToStr(Boolean) -> Str31 +; tool 0x0010, set 0x10 (ControlManager) + .globl BoolToStr +BoolToStr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0010 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; CopyGSString(GSString255Hndl) -> GSString255Hndl +; tool 0x0020, set 0x20 (VideoOverlay) + .globl CopyGSString +CopyGSString: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0020 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ExtToStr(Extended) -> Str31 +; tool 0x0011, set 0x11 (Loader) + .globl ExtToStr +ExtToStr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0011 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GSConcat(GSString255Hndl, GSString255Hndl) -> GSString255Hndl +; tool 0x0021, set 0x21 (Teletext) + .globl GSConcat +GSConcat: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GSString255Hndl, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0021 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GSToPString(GSString255Hndl) -> Str255 +; tool 0x001E, set 0x1E (ResourceManager) + .globl GSToPString +GSToPString: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x001E + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GSToZero(GSString255Hndl) -> Handle +; tool 0x0023, set 0x23 (MediaControl) + .globl GSToZero +GSToZero: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0023 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LongToStr(Longint) -> Str31 +; tool 0x000D, set 0x0D (?) + .globl LongToStr +LongToStr: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x000D + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; NumToHex(Longint, word) -> Str19 +; tool 0x000F, set 0x0F (MenuManager) + .globl NumToHex +NumToHex: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (word, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x000F + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; NumToStr(Longint) -> Str31 +; tool 0x000E, set 0x0E (WindowManager) + .globl NumToStr +NumToStr: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x000E + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PointToStr(Point, Str255) -> void +; tool 0x002D, set 0x2D (?) + .globl PointToStr +PointToStr: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Str255, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x002D + jsl 0xe100a8 + rtl + +; PasToZero(Str255) -> Handle +; tool 0x0007, set 0x07 (Scheduler) + .globl PasToZero +PasToZero: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0007 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PToGSString(Str255) -> GSString255Hndl +; tool 0x001F, set 0x1F (MIDITools) + .globl PToGSString +PToGSString: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x001F + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; RectToStr(Rect, Str255) -> void +; tool 0x002E, set 0x2E (?) + .globl RectToStr +RectToStr: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Str255, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x002E + jsl 0xe100a8 + rtl + +; ReturnToPas(Ptr, Str255) -> void +; tool 0x001B, set 0x1B (FontManager) + .globl ReturnToPas +ReturnToPas: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Str255, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x001B + jsl 0xe100a8 + rtl + +; StrToBool(Str31) -> Boolean +; tool 0x000B, set 0x0B (IntegerMath) + .globl StrToBool +StrToBool: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x000B + jsl 0xe100a8 + pla ; result -> A + rtl + +; StrToExt(Str31) -> extended +; tool 0x000C, set 0x0C (TextTools) + .globl StrToExt +StrToExt: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x000C + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; StrToLong(Str31) -> Longint +; tool 0x0009, set 0x09 (AppleDeskBus) + .globl StrToLong +StrToLong: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0009 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; StrToNum(Str31) -> Longint +; tool 0x000A, set 0x0A (SANE) + .globl StrToNum +StrToNum: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x000A + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; StrToPoint(Str255, Point) -> void +; tool 0x002F, set 0x2F (?) + .globl StrToPoint +StrToPoint: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Point, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x002F + jsl 0xe100a8 + rtl + +; StrToRect(Str255, Rect) -> void +; tool 0x0030, set 0x30 (?) + .globl StrToRect +StrToRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0030 + jsl 0xe100a8 + rtl + +; ZeroToGS(Handle) -> GSString255Hndl +; tool 0x0024, set 0x24 (?) + .globl ZeroToGS +ZeroToGS: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0024 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ZeroToPas(Ptr, Str255) -> void +; tool 0x0008, set 0x08 (SoundManager) + .globl ZeroToPas +ZeroToPas: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Str255, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0008 + jsl 0xe100a8 + rtl + +; GetFieldByID(Boolean, word) -> Handle +; tool 0x0016, set 0x16 (ScrapManager) + .globl GetFieldByID +GetFieldByID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (word, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x0016 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetFieldByName(Boolean, Str255) -> Handle +; tool 0x0014, set 0x14 (LineEdit) + .globl GetFieldByName +GetFieldByName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Str255, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x0014 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetFieldByNum(Boolean, word) -> Handle +; tool 0x0015, set 0x15 (DialogManager) + .globl GetFieldByNum +GetFieldByNum: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (word, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x0015 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SetFieldByID(Boolean, word, Handle) -> void +; tool 0x0019, set 0x19 (NoteSynth) + .globl SetFieldByID +SetFieldByID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (word, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Handle, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x0019 + jsl 0xe100a8 + rtl + +; SetFieldByName(Boolean, Str255, Handle) -> void +; tool 0x0017, set 0x17 (StandardFile) + .globl SetFieldByName +SetFieldByName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Str255, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Handle, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x0017 + jsl 0xe100a8 + rtl + +; SetFieldByNum(Boolean, word, Handle) -> void +; tool 0x0018, set 0x18 (DiskUtil) + .globl SetFieldByNum +SetFieldByNum: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (word, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Handle, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x0018 + jsl 0xe100a8 + rtl + +; ChangedMaskAndData(word) -> void +; tool 0x002C, set 0x2C (?) + .globl ChangedMaskAndData +ChangedMaskAndData: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x002C + jsl 0xe100a8 + rtl + +; GetMaskAndData(LocInfoPtr, LocInfoPtr) -> void +; tool 0x002B, set 0x2B (?) + .globl GetMaskAndData +GetMaskAndData: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (LocInfoPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x002B + jsl 0xe100a8 + rtl + +; FindNamedResource(word, Str255, word, long) -> Boolean +; tool 0x0026, set 0x26 (?) + .globl FindNamedResource +FindNamedResource: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Str255, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (word, 4B) --- + lda 18, s + pha + lda 20, s + pha + ; --- arg3 (long, 4B) --- + lda 26, s + pha + lda 28, s + pha + ldx #0x0026 + jsl 0xe100a8 + pla ; result -> A + rtl + +; GetResourceName(word, long) -> Str255 +; tool 0x0028, set 0x28 (?) + .globl GetResourceName +GetResourceName: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (long, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0028 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LoadNamedResource(word, Str255) -> Handle +; tool 0x0025, set 0x25 (?) + .globl LoadNamedResource +LoadNamedResource: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Str255, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0025 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SetResourceName(word, long, Str255) -> void +; tool 0x0027, set 0x27 (?) + .globl SetResourceName +SetResourceName: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Str255, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x0027 + jsl 0xe100a8 + rtl + +; NewXWindow(Rect, Str31, Boolean, word) -> WindowPtr +; tool 0x0031, set 0x31 (?) + .globl NewXWindow +NewXWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Str31, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg2 (Boolean, 2B) --- + lda 20, s + pha + ; --- arg3 (word, 4B) --- + lda 24, s + pha + lda 26, s + pha + ldx #0x0031 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; CloseXWindow(WindowPtr) -> void +; tool 0x0033, set 0x33 (?) + .globl CloseXWindow +CloseXWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0033 + jsl 0xe100a8 + rtl + +; GetXWindowValue(WindowPtr) -> Longint +; tool 0x0037, set 0x37 (?) + .globl GetXWindowValue +GetXWindowValue: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0037 + jsl 0xe100a8 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SetXWIdleTime(WindowPtr, Longint) -> void +; tool 0x0032, set 0x32 (MediaControl2) + .globl SetXWIdleTime +SetXWIdleTime: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Longint, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0032 + jsl 0xe100a8 + rtl + +; SetXWindowValue(WindowPtr, Longint) -> void +; tool 0x0036, set 0x36 (?) + .globl SetXWindowValue +SetXWindowValue: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Longint, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0036 + jsl 0xe100a8 + rtl + +; XWAllowReEntrancy(WindowPtr, Boolean, Boolean) -> void +; tool 0x0038, set 0x38 (?) + .globl XWAllowReEntrancy +XWAllowReEntrancy: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Boolean, 2B) --- + lda 8, s + pha + ; --- arg2 (Boolean, 2B) --- + lda 12, s + pha + ldx #0x0038 + jsl 0xe100a8 + rtl + +; Dec2Int(Pointer, Word, Boolean) -> Integer +; tool 0x280B, set 0x0B (IntegerMath) + .globl Dec2Int +Dec2Int: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ; --- arg2 (Boolean, 2B) --- + lda 14, s + pha + ldx #0x280B + jsl 0xe10000 + pla ; result -> A + rtl + +; Dec2Long(Pointer, Word, Boolean) -> Longint +; tool 0x290B, set 0x0B (IntegerMath) + .globl Dec2Long +Dec2Long: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 12, s + pha + ; --- arg2 (Boolean, 2B) --- + lda 16, s + pha + ldx #0x290B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; Fix2Frac(Fixed) -> Frac +; tool 0x1C0B, set 0x0B (IntegerMath) + .globl Fix2Frac +Fix2Frac: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1C0B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; Fix2Long(Fixed) -> Longint +; tool 0x1B0B, set 0x0B (IntegerMath) + .globl Fix2Long +Fix2Long: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1B0B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; Fix2X(Fixed, ExtendedPtr) -> void +; tool 0x1E0B, set 0x0B (IntegerMath) + .globl Fix2X +Fix2X: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (ExtendedPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1E0B + jsl 0xe10000 + rtl + +; FixATan2(Longint, Longint) -> Fixed +; tool 0x170B, set 0x0B (IntegerMath) + .globl FixATan2 +FixATan2: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Longint, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x170B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FixDiv(Longint, Longint) -> Fixed +; tool 0x110B, set 0x0B (IntegerMath) + .globl FixDiv +FixDiv: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Longint, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x110B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FixMul(Fixed, Fixed) -> Fixed +; tool 0x0F0B, set 0x0B (IntegerMath) + .globl FixMul +FixMul: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Fixed, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0F0B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FixRatio(Integer, Integer) -> Fixed +; tool 0x0E0B, set 0x0B (IntegerMath) + .globl FixRatio +FixRatio: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 10, s + pha + ldx #0x0E0B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FixRound(Fixed) -> Integer +; tool 0x130B, set 0x0B (IntegerMath) + .globl FixRound +FixRound: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x130B + jsl 0xe10000 + pla ; result -> A + rtl + +; Frac2Fix(Frac) -> Fixed +; tool 0x1D0B, set 0x0B (IntegerMath) + .globl Frac2Fix +Frac2Fix: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1D0B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; Frac2X(Frac, ExtendedPtr) -> void +; tool 0x1F0B, set 0x0B (IntegerMath) + .globl Frac2X +Frac2X: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (ExtendedPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1F0B + jsl 0xe10000 + rtl + +; FracCos(Fixed) -> Frac +; tool 0x150B, set 0x0B (IntegerMath) + .globl FracCos +FracCos: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x150B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FracDiv(Longint, Longint) -> Frac +; tool 0x120B, set 0x0B (IntegerMath) + .globl FracDiv +FracDiv: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Longint, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x120B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FracMul(Frac, Frac) -> Frac +; tool 0x100B, set 0x0B (IntegerMath) + .globl FracMul +FracMul: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Frac, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x100B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FracSin(Fixed) -> Frac +; tool 0x160B, set 0x0B (IntegerMath) + .globl FracSin +FracSin: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x160B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FracSqrt(Frac) -> Frac +; tool 0x140B, set 0x0B (IntegerMath) + .globl FracSqrt +FracSqrt: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x140B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; Hex2Int(Pointer, Word) -> Word +; tool 0x240B, set 0x0B (IntegerMath) + .globl Hex2Int +Hex2Int: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x240B + jsl 0xe10000 + pla ; result -> A + rtl + +; Hex2Long(Pointer, Word) -> LongWord +; tool 0x250B, set 0x0B (IntegerMath) + .globl Hex2Long +Hex2Long: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 12, s + pha + ldx #0x250B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; HexIt(Word) -> LongWord +; tool 0x2A0B, set 0x0B (IntegerMath) + .globl HexIt +HexIt: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2A0B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; HiWord(LongWord) -> Word +; tool 0x180B, set 0x0B (IntegerMath) + .globl HiWord +HiWord: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x180B + jsl 0xe10000 + pla ; result -> A + rtl + +; Int2Dec(Integer, Pointer, Word, Boolean) -> void +; tool 0x260B, set 0x0B (IntegerMath) + .globl Int2Dec +Int2Dec: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ; --- arg3 (Boolean, 2B) --- + lda 18, s + pha + ldx #0x260B + jsl 0xe10000 + rtl + +; Int2Hex(Word, Pointer, Word) -> void +; tool 0x220B, set 0x0B (IntegerMath) + .globl Int2Hex +Int2Hex: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x220B + jsl 0xe10000 + rtl + +; Long2Dec(Longint, Pointer, Word, Boolean) -> void +; tool 0x270B, set 0x0B (IntegerMath) + .globl Long2Dec +Long2Dec: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Word, 2B) --- + lda 16, s + pha + ; --- arg3 (Boolean, 2B) --- + lda 20, s + pha + ldx #0x270B + jsl 0xe10000 + rtl + +; Long2Fix(Longint) -> Fixed +; tool 0x1A0B, set 0x0B (IntegerMath) + .globl Long2Fix +Long2Fix: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1A0B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; Long2Hex(LongWord, Pointer, Word) -> void +; tool 0x230B, set 0x0B (IntegerMath) + .globl Long2Hex +Long2Hex: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Word, 2B) --- + lda 16, s + pha + ldx #0x230B + jsl 0xe10000 + rtl + +; LoWord(LongWord) -> Word +; tool 0x190B, set 0x0B (IntegerMath) + .globl LoWord +LoWord: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x190B + jsl 0xe10000 + pla ; result -> A + rtl + +; Multiply(Integer, Integer) -> Longint +; tool 0x090B, set 0x0B (IntegerMath) + .globl Multiply +Multiply: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 10, s + pha + ldx #0x090B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; X2Fix(ExtendedPtr) -> Fixed +; tool 0x200B, set 0x0B (IntegerMath) + .globl X2Fix +X2Fix: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x200B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; X2Frac(ExtendedPtr) -> Frac +; tool 0x210B, set 0x0B (IntegerMath) + .globl X2Frac +X2Frac: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x210B + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LEStartUp(Word, Word) -> void +; tool 0x0214, set 0x14 (LineEdit) + .globl LEStartUp +LEStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0214 + jsl 0xe10000 + rtl + +; LEActivate(LERecHndl) -> void +; tool 0x0F14, set 0x14 (LineEdit) + .globl LEActivate +LEActivate: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0F14 + jsl 0xe10000 + rtl + +; LEClick(EventRecordPtr, LERecHndl) -> void +; tool 0x0D14, set 0x14 (LineEdit) + .globl LEClick +LEClick: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (LERecHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0D14 + jsl 0xe10000 + rtl + +; LECopy(LERecHndl) -> void +; tool 0x1314, set 0x14 (LineEdit) + .globl LECopy +LECopy: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1314 + jsl 0xe10000 + rtl + +; LECut(LERecHndl) -> void +; tool 0x1214, set 0x14 (LineEdit) + .globl LECut +LECut: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1214 + jsl 0xe10000 + rtl + +; LEDeactivate(LERecHndl) -> void +; tool 0x1014, set 0x14 (LineEdit) + .globl LEDeactivate +LEDeactivate: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1014 + jsl 0xe10000 + rtl + +; LEDelete(LERecHndl) -> void +; tool 0x1514, set 0x14 (LineEdit) + .globl LEDelete +LEDelete: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1514 + jsl 0xe10000 + rtl + +; LEDispose(LERecHndl) -> void +; tool 0x0A14, set 0x14 (LineEdit) + .globl LEDispose +LEDispose: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0A14 + jsl 0xe10000 + rtl + +; LEGetTextHand(LERecHndl) -> Handle +; tool 0x2214, set 0x14 (LineEdit) + .globl LEGetTextHand +LEGetTextHand: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2214 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LEGetTextLen(LERecHndl) -> Word +; tool 0x2314, set 0x14 (LineEdit) + .globl LEGetTextLen +LEGetTextLen: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2314 + jsl 0xe10000 + pla ; result -> A + rtl + +; LEIdle(LERecHndl) -> void +; tool 0x0C14, set 0x14 (LineEdit) + .globl LEIdle +LEIdle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0C14 + jsl 0xe10000 + rtl + +; LEInsert(Pointer, Word, LERecHndl) -> void +; tool 0x1614, set 0x14 (LineEdit) + .globl LEInsert +LEInsert: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (LERecHndl, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x1614 + jsl 0xe10000 + rtl + +; LEKey(Word, Word, LERecHndl) -> void +; tool 0x1114, set 0x14 (LineEdit) + .globl LEKey +LEKey: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (LERecHndl, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1114 + jsl 0xe10000 + rtl + +; LENew(Rect, Rect, Word) -> LERecHndl +; tool 0x0914, set 0x14 (LineEdit) + .globl LENew +LENew: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg2 (Word, 2B) --- + lda 20, s + pha + ldx #0x0914 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LEPaste(LERecHndl) -> void +; tool 0x1414, set 0x14 (LineEdit) + .globl LEPaste +LEPaste: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1414 + jsl 0xe10000 + rtl + +; LEScrapHandle(void) -> Handle +; tool 0x1B14, set 0x14 (LineEdit) + .globl LEScrapHandle +LEScrapHandle: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1B14 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LESetCaret(VoidProcPtr, LERecHndl) -> void +; tool 0x1F14, set 0x14 (LineEdit) + .globl LESetCaret +LESetCaret: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (LERecHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1F14 + jsl 0xe10000 + rtl + +; LESetHilite(VoidProcPtr, LERecHndl) -> void +; tool 0x1E14, set 0x14 (LineEdit) + .globl LESetHilite +LESetHilite: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (LERecHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1E14 + jsl 0xe10000 + rtl + +; LESetJust(Word, LERecHndl) -> void +; tool 0x2114, set 0x14 (LineEdit) + .globl LESetJust +LESetJust: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (LERecHndl, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x2114 + jsl 0xe10000 + rtl + +; LESetSelect(Word, Word, LERecHndl) -> void +; tool 0x0E14, set 0x14 (LineEdit) + .globl LESetSelect +LESetSelect: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (LERecHndl, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x0E14 + jsl 0xe10000 + rtl + +; LESetText(Pointer, Word, LERecHndl) -> void +; tool 0x0B14, set 0x14 (LineEdit) + .globl LESetText +LESetText: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (LERecHndl, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0B14 + jsl 0xe10000 + rtl + +; LETextBox(Pointer, Word, Rect, Word) -> void +; tool 0x1814, set 0x14 (LineEdit) + .globl LETextBox +LETextBox: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Rect, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg3 (Word, 2B) --- + lda 20, s + pha + ldx #0x1814 + jsl 0xe10000 + rtl + +; LETextBox2(Pointer, Word, Rect, Word) -> void +; tool 0x2014, set 0x14 (LineEdit) + .globl LETextBox2 +LETextBox2: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Rect, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg3 (Word, 2B) --- + lda 20, s + pha + ldx #0x2014 + jsl 0xe10000 + rtl + +; LEUpdate(LERecHndl) -> void +; tool 0x1714, set 0x14 (LineEdit) + .globl LEUpdate +LEUpdate: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1714 + jsl 0xe10000 + rtl + +; GetLEDefProc(void) -> Pointer +; tool 0x2414, set 0x14 (LineEdit) + .globl GetLEDefProc +GetLEDefProc: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2414 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LEClassifyKey(EventRecordPtr) -> Word +; tool 0x2514, set 0x14 (LineEdit) + .globl LEClassifyKey +LEClassifyKey: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2514 + jsl 0xe10000 + pla ; result -> A + rtl + +; CreateList(GrafPortPtr, ListRecPtr) -> ListCtlRecHndl +; tool 0x091C, set 0x1C (ListManager) + .globl CreateList +CreateList: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (ListRecPtr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x091C + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; DrawMember(MemRecPtr, ListRecPtr) -> void +; tool 0x0C1C, set 0x1C (ListManager) + .globl DrawMember +DrawMember: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (ListRecPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0C1C + jsl 0xe10000 + rtl + +; GetListDefProc(void) -> LongProcPtr +; tool 0x0E1C, set 0x1C (ListManager) + .globl GetListDefProc +GetListDefProc: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0E1C + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; NewList(MemRecPtr, ListRecPtr) -> void +; tool 0x101C, set 0x1C (ListManager) + .globl NewList +NewList: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (ListRecPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x101C + jsl 0xe10000 + rtl + +; NextMember(MemRecPtr, ListRecPtr) -> MemRecPtr +; tool 0x0B1C, set 0x1C (ListManager) + .globl NextMember +NextMember: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (ListRecPtr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0B1C + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ResetMember(ListRecPtr) -> MemRecPtr +; tool 0x0F1C, set 0x1C (ListManager) + .globl ResetMember +ResetMember: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0F1C + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SelectMember(MemRecPtr, ListRecPtr) -> void +; tool 0x0D1C, set 0x1C (ListManager) + .globl SelectMember +SelectMember: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (ListRecPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0D1C + jsl 0xe10000 + rtl + +; SortList(VoidProcPtr, ListRecPtr) -> void +; tool 0x0A1C, set 0x1C (ListManager) + .globl SortList +SortList: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (ListRecPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0A1C + jsl 0xe10000 + rtl + +; DrawMember2(Word, Handle) -> void +; tool 0x111C, set 0x1C (ListManager) + .globl DrawMember2 +DrawMember2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Handle, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x111C + jsl 0xe10000 + rtl + +; NewList2(Pointer, Word, Ref, Word, Word, Handle) -> void +; tool 0x161C, set 0x1C (ListManager) + .globl NewList2 +NewList2: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Ref, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg3 (Word, 2B) --- + lda 20, s + pha + ; --- arg4 (Word, 2B) --- + lda 24, s + pha + ; --- arg5 (Handle, 4B) --- + lda 28, s + pha + lda 30, s + pha + ldx #0x161C + jsl 0xe10000 + rtl + +; NextMember2(Word, Handle) -> Word +; tool 0x121C, set 0x1C (ListManager) + .globl NextMember2 +NextMember2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x121C + jsl 0xe10000 + pla ; result -> A + rtl + +; ResetMember2(Handle) -> Word +; tool 0x131C, set 0x1C (ListManager) + .globl ResetMember2 +ResetMember2: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x131C + jsl 0xe10000 + pla ; result -> A + rtl + +; SelectMember2(Word, Handle) -> void +; tool 0x141C, set 0x1C (ListManager) + .globl SelectMember2 +SelectMember2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Handle, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x141C + jsl 0xe10000 + rtl + +; SortList2(Pointer, Handle) -> void +; tool 0x151C, set 0x1C (ListManager) + .globl SortList2 +SortList2: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x151C + jsl 0xe10000 + rtl + +; CompareStrings(Word, Ptr, Ptr) -> Word +; tool 0x181C, set 0x1C (ListManager) + .globl CompareStrings +CompareStrings: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Ptr, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x181C + jsl 0xe10000 + pla ; result -> A + rtl + +; ListKey(Word, EventRecordPtr, CtlRecHndl) -> void +; tool 0x171C, set 0x1C (ListManager) + .globl ListKey +ListKey: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (EventRecordPtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (CtlRecHndl, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x171C + jsl 0xe10000 + rtl + +; GetLoadSegInfo(Word, Word, Word, Pointer) -> void +; tool 0x0F11, set 0x11 (Loader) + .globl GetLoadSegInfo +GetLoadSegInfo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ; --- arg3 (Pointer, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x0F11 + jsl 0xe10000 + rtl + +; GetUserID(Pointer) -> Word +; tool 0x1011, set 0x11 (Loader) + .globl GetUserID +GetUserID: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1011 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetUserID2(Pointer) -> Word +; tool 0x2111, set 0x11 (Loader) + .globl GetUserID2 +GetUserID2: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2111 + jsl 0xe10000 + pla ; result -> A + rtl + +; LGetPathname(Word, Word) -> Pointer +; tool 0x1111, set 0x11 (Loader) + .globl LGetPathname +LGetPathname: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x1111 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LGetPathname2(Word, Word) -> Pointer +; tool 0x2211, set 0x11 (Loader) + .globl LGetPathname2 +LGetPathname2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x2211 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LoadSegNum(Word, Word, Word) -> Pointer +; tool 0x0B11, set 0x11 (Loader) + .globl LoadSegNum +LoadSegNum: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x0B11 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; RenamePathname(Pointer, Pointer) -> void +; tool 0x1311, set 0x11 (Loader) + .globl RenamePathname +RenamePathname: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1311 + jsl 0xe10000 + rtl + +; UnloadSegNum(Word, Word, Word) -> void +; tool 0x0C11, set 0x11 (Loader) + .globl UnloadSegNum +UnloadSegNum: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ldx #0x0C11 + jsl 0xe10000 + rtl + +; UserShutDown(Word, Word) -> Word +; tool 0x1211, set 0x11 (Loader) + .globl UserShutDown +UserShutDown: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x1211 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetPathname(void) -> Pointer +; tool 0x1111, set 0x11 (Loader) + .globl GetPathname +GetPathname: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1111 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetPathname2(void) -> Pointer +; tool 0x2211, set 0x11 (Loader) + .globl GetPathname2 +GetPathname2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2211 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetFuncPtr(Word, Word) -> Pointer +; tool 0x0B01, set 0x01 (ToolLocator) + .globl GetFuncPtr +GetFuncPtr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x0B01 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetTSPtr(Word, Word) -> Pointer +; tool 0x0901, set 0x01 (ToolLocator) + .globl GetTSPtr +GetTSPtr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x0901 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetWAP(Word, Word) -> Pointer +; tool 0x0C01, set 0x01 (ToolLocator) + .globl GetWAP +GetWAP: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x0C01 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LoadOneTool(Word, Word) -> void +; tool 0x0F01, set 0x01 (ToolLocator) + .globl LoadOneTool +LoadOneTool: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0F01 + jsl 0xe10000 + rtl + +; LoadTools(Pointer) -> void +; tool 0x0E01, set 0x01 (ToolLocator) + .globl LoadTools +LoadTools: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0E01 + jsl 0xe10000 + rtl + +; MessageCenter(Word, Word, Handle) -> void +; tool 0x1501, set 0x01 (ToolLocator) + .globl MessageCenter +MessageCenter: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Handle, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1501 + jsl 0xe10000 + rtl + +; RestoreTextState(Handle) -> void +; tool 0x1401, set 0x01 (ToolLocator) + .globl RestoreTextState +RestoreTextState: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1401 + jsl 0xe10000 + rtl + +; SaveTextState(void) -> Handle +; tool 0x1301, set 0x01 (ToolLocator) + .globl SaveTextState +SaveTextState: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1301 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SetTSPtr(Word, Word, Pointer) -> void +; tool 0x0A01, set 0x01 (ToolLocator) + .globl SetTSPtr +SetTSPtr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x0A01 + jsl 0xe10000 + rtl + +; SetWAP(Word, Word, Pointer) -> void +; tool 0x0D01, set 0x01 (ToolLocator) + .globl SetWAP +SetWAP: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x0D01 + jsl 0xe10000 + rtl + +; TLMountVolume(Integer, Integer, Pointer, Pointer, Pointer, Pointer) -> Word +; tool 0x1101, set 0x01 (ToolLocator) + .globl TLMountVolume +TLMountVolume: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg3 (Pointer, 4B) --- + lda 20, s + pha + lda 22, s + pha + ; --- arg4 (Pointer, 4B) --- + lda 28, s + pha + lda 30, s + pha + ; --- arg5 (Pointer, 4B) --- + lda 36, s + pha + lda 38, s + pha + ldx #0x1101 + jsl 0xe10000 + pla ; result -> A + rtl + +; TLTextMountVolume(Pointer, Pointer, Pointer, Pointer) -> Word +; tool 0x1201, set 0x01 (ToolLocator) + .globl TLTextMountVolume +TLTextMountVolume: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 18, s + pha + lda 20, s + pha + ; --- arg3 (Pointer, 4B) --- + lda 26, s + pha + lda 28, s + pha + ldx #0x1201 + jsl 0xe10000 + pla ; result -> A + rtl + +; MessageByName(Boolean, Pointer) -> ResponseRecord +; tool 0x1701, set 0x01 (ToolLocator) + .globl MessageByName +MessageByName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1701 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ShutDownTools(Word, Ref) -> void +; tool 0x1901, set 0x01 (ToolLocator) + .globl ShutDownTools +ShutDownTools: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x1901 + jsl 0xe10000 + rtl + +; StartUpTools(Word, Word, Ref) -> Ref +; tool 0x1801, set 0x01 (ToolLocator) + .globl StartUpTools +StartUpTools: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ; --- arg2 (Ref, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x1801 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; AcceptRequests(Pointer, Word, WordProcPtr) -> void +; tool 0x1B01, set 0x01 (ToolLocator) + .globl AcceptRequests +AcceptRequests: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (WordProcPtr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x1B01 + jsl 0xe10000 + rtl + +; GetMsgHandle(Word, Long) -> Handle +; tool 0x1A01, set 0x01 (ToolLocator) + .globl GetMsgHandle +GetMsgHandle: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1A01 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SendRequest(Word, Word, Long, Long, Ptr) -> void +; tool 0x1C01, set 0x01 (ToolLocator) + .globl SendRequest +SendRequest: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg3 (Long, 4B) --- + lda 18, s + pha + lda 20, s + pha + ; --- arg4 (Ptr, 4B) --- + lda 26, s + pha + lda 28, s + pha + ldx #0x1C01 + jsl 0xe10000 + rtl + +; MCBinToTime(Long) -> Long +; tool 0x0D26, set 0x26 (?) + .globl MCBinToTime +MCBinToTime: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0D26 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MCControl(Word, Word) -> void +; tool 0x1B26, set 0x26 (?) + .globl MCControl +MCControl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x1B26 + jsl 0xe10000 + rtl + +; MCDStartUp(Word, Ptr, Word) -> void +; tool 0x1426, set 0x26 (?) + .globl MCDStartUp +MCDStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x1426 + jsl 0xe10000 + rtl + +; MCGetDiscID(Word) -> Long +; tool 0x2826, set 0x26 (?) + .globl MCGetDiscID +MCGetDiscID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2826 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MCGetDiscTitle(Long, Ptr) -> void +; tool 0x1226, set 0x26 (?) + .globl MCGetDiscTitle +MCGetDiscTitle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Ptr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1226 + jsl 0xe10000 + rtl + +; MCGetDiscTOC(Word, Word) -> Long +; tool 0x2726, set 0x26 (?) + .globl MCGetDiscTOC +MCGetDiscTOC: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x2726 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MCGetErrorMsg(Word, Ptr) -> void +; tool 0x0926, set 0x26 (?) + .globl MCGetErrorMsg +MCGetErrorMsg: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x0926 + jsl 0xe10000 + rtl + +; MCGetFeatures(Word, Word) -> Long +; tool 0x1626, set 0x26 (?) + .globl MCGetFeatures +MCGetFeatures: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x1626 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MCGetName(Word, Ptr) -> void +; tool 0x2D26, set 0x26 (?) + .globl MCGetName +MCGetName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x2D26 + jsl 0xe10000 + rtl + +; MCGetPosition(Word, Word) -> Long +; tool 0x2426, set 0x26 (?) + .globl MCGetPosition +MCGetPosition: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x2426 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MCGetProgram(Long, Ptr) -> void +; tool 0x1026, set 0x26 (?) + .globl MCGetProgram +MCGetProgram: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Ptr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1026 + jsl 0xe10000 + rtl + +; MCGetSpeeds(Word, Ptr) -> void +; tool 0x1D26, set 0x26 (?) + .globl MCGetSpeeds +MCGetSpeeds: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x1D26 + jsl 0xe10000 + rtl + +; MCGetStatus(Word, Word) -> Word +; tool 0x1A26, set 0x26 (?) + .globl MCGetStatus +MCGetStatus: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x1A26 + jsl 0xe10000 + pla ; result -> A + rtl + +; MCGetTimes(Word, Word) -> Long +; tool 0x2626, set 0x26 (?) + .globl MCGetTimes +MCGetTimes: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x2626 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MCGetTrackTitle(Long, Word, Ptr) -> void +; tool 0x0E26, set 0x26 (?) + .globl MCGetTrackTitle +MCGetTrackTitle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Ptr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0E26 + jsl 0xe10000 + rtl + +; MCJog(Word, Long, Word) -> void +; tool 0x2026, set 0x26 (?) + .globl MCJog +MCJog: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x2026 + jsl 0xe10000 + rtl + +; MCScan(Word, Word) -> void +; tool 0x1C26, set 0x26 (?) + .globl MCScan +MCScan: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x1C26 + jsl 0xe10000 + rtl + +; MCSearchTo(Word, Word, Long) -> void +; tool 0x2126, set 0x26 (?) + .globl MCSearchTo +MCSearchTo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x2126 + jsl 0xe10000 + rtl + +; MCSendRawData(Word, Long) -> void +; tool 0x1926, set 0x26 (?) + .globl MCSendRawData +MCSendRawData: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x1926 + jsl 0xe10000 + rtl + +; MCSetAudio(Word, Word) -> void +; tool 0x2526, set 0x26 (?) + .globl MCSetAudio +MCSetAudio: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x2526 + jsl 0xe10000 + rtl + +; MCSetDiscTitle(Long, Long) -> void +; tool 0x1326, set 0x26 (?) + .globl MCSetDiscTitle +MCSetDiscTitle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1326 + jsl 0xe10000 + rtl + +; MCSetProgram(Long, Long) -> void +; tool 0x1126, set 0x26 (?) + .globl MCSetProgram +MCSetProgram: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1126 + jsl 0xe10000 + rtl + +; MCSetTrackTitle(Long, Word, Ptr) -> void +; tool 0x0F26, set 0x26 (?) + .globl MCSetTrackTitle +MCSetTrackTitle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Ptr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0F26 + jsl 0xe10000 + rtl + +; MCSetVolume(Word, Word, Word) -> void +; tool 0x2E26, set 0x26 (?) + .globl MCSetVolume +MCSetVolume: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ldx #0x2E26 + jsl 0xe10000 + rtl + +; MCSpeed(Word, Word) -> void +; tool 0x1E26, set 0x26 (?) + .globl MCSpeed +MCSpeed: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x1E26 + jsl 0xe10000 + rtl + +; MCStopAt(Word, Word, Long) -> void +; tool 0x1F26, set 0x26 (?) + .globl MCStopAt +MCStopAt: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1F26 + jsl 0xe10000 + rtl + +; MCTimeToBin(Long) -> Long +; tool 0x0C26, set 0x26 (?) + .globl MCTimeToBin +MCTimeToBin: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0C26 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MCWaitRawData(Word, Ptr, Word, Word) -> void +; tool 0x2C26, set 0x26 (?) + .globl MCWaitRawData +MCWaitRawData: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ; --- arg3 (Word, 2B) --- + lda 18, s + pha + ldx #0x2C26 + jsl 0xe10000 + rtl + +; BlockMove(Pointer, Pointer, LongWord) -> void +; tool 0x2B02, set 0x02 (MemoryManager) + .globl BlockMove +BlockMove: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (LongWord, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x2B02 + jsl 0xe10000 + rtl + +; CheckHandle(Handle) -> void +; tool 0x1E02, set 0x02 (MemoryManager) + .globl CheckHandle +CheckHandle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1E02 + jsl 0xe10000 + rtl + +; DisposeHandle(Handle) -> void +; tool 0x1002, set 0x02 (MemoryManager) + .globl DisposeHandle +DisposeHandle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha ldx #0x1002 jsl 0xe10000 rtl - -; ===================================================================== -; void TBoxQDStartUp(u16 masterSCB, u16 pageSize, u16 userId) -; Entry: A = masterSCB, 4,S = pageSize, 6,S = userId -; Tool: PEA userId, PEA pageSize, PHA masterSCB, JSL X=$0204 -; ===================================================================== -TBoxQDStartUp: - sta 0xe0 ; stash masterSCB - lda 6, s ; userId (originally 6,S, no pushes yet) - pha ; userId pushed; subsequent loads need +2 - lda 6, s ; pageSize was at 4,S; +2 = 6,S +; FindHandle(Pointer) -> Handle +; tool 0x1A02, set 0x02 (MemoryManager) + .globl FindHandle +FindHandle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 pha - lda 0xe0 ; masterSCB + lda 0xE2 + pha + ldx #0x1A02 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FreeMem(void) -> LongWord +; tool 0x1B02, set 0x02 (MemoryManager) + .globl FreeMem +FreeMem: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1B02 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetHandleSize(Handle) -> LongWord +; tool 0x1802, set 0x02 (MemoryManager) + .globl GetHandleSize +GetHandleSize: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1802 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; HandToHand(Handle, Handle, LongWord) -> void +; tool 0x2A02, set 0x02 (MemoryManager) + .globl HandToHand +HandToHand: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (LongWord, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x2A02 + jsl 0xe10000 + rtl + +; HandToPtr(Handle, Pointer, LongWord) -> void +; tool 0x2902, set 0x02 (MemoryManager) + .globl HandToPtr +HandToPtr: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (LongWord, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x2902 + jsl 0xe10000 + rtl + +; HLock(Handle) -> void +; tool 0x2002, set 0x02 (MemoryManager) + .globl HLock +HLock: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2002 + jsl 0xe10000 + rtl + +; HUnlock(Handle) -> void +; tool 0x2202, set 0x02 (MemoryManager) + .globl HUnlock +HUnlock: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2202 + jsl 0xe10000 + rtl + +; MaxBlock(void) -> LongWord +; tool 0x1C02, set 0x02 (MemoryManager) + .globl MaxBlock +MaxBlock: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1C02 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; NewHandle(LongWord, Word, Word, Pointer) -> Handle +; tool 0x0902, set 0x02 (MemoryManager) + .globl NewHandle +NewHandle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 12, s + pha + ; --- arg2 (Word, 2B) --- + lda 16, s + pha + ; --- arg3 (Pointer, 4B) --- + lda 20, s + pha + lda 22, s + pha + ldx #0x0902 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PtrToHand(Pointer, Handle, LongWord) -> void +; tool 0x2802, set 0x02 (MemoryManager) + .globl PtrToHand +PtrToHand: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (LongWord, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x2802 + jsl 0xe10000 + rtl + +; PurgeHandle(Handle) -> void +; tool 0x1202, set 0x02 (MemoryManager) + .globl PurgeHandle +PurgeHandle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1202 + jsl 0xe10000 + rtl + +; ReAllocHandle(LongWord, Word, Word, Pointer, Handle) -> void +; tool 0x0A02, set 0x02 (MemoryManager) + .globl ReAllocHandle +ReAllocHandle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ; --- arg3 (Pointer, 4B) --- + lda 16, s + pha + lda 18, s + pha + ; --- arg4 (Handle, 4B) --- + lda 24, s + pha + lda 26, s + pha + ldx #0x0A02 + jsl 0xe10000 + rtl + +; RestoreHandle(Handle) -> void +; tool 0x0B02, set 0x02 (MemoryManager) + .globl RestoreHandle +RestoreHandle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0B02 + jsl 0xe10000 + rtl + +; SetHandleSize(LongWord, Handle) -> void +; tool 0x1902, set 0x02 (MemoryManager) + .globl SetHandleSize +SetHandleSize: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1902 + jsl 0xe10000 + rtl + +; SetPurge(Word, Handle) -> void +; tool 0x2402, set 0x02 (MemoryManager) + .globl SetPurge +SetPurge: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Handle, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x2402 + jsl 0xe10000 + rtl + +; SetPurgeAll(Word, Word) -> void +; tool 0x2502, set 0x02 (MemoryManager) + .globl SetPurgeAll +SetPurgeAll: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x2502 + jsl 0xe10000 + rtl + +; TotalMem(void) -> LongWord +; tool 0x1D02, set 0x02 (MemoryManager) + .globl TotalMem +TotalMem: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1D02 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; AddToOOMQueue(Pointer) -> void +; tool 0x0C02, set 0x02 (MemoryManager) + .globl AddToOOMQueue +AddToOOMQueue: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0C02 + jsl 0xe10000 + rtl + +; RealFreeMem(void) -> LongWord +; tool 0x2F02, set 0x02 (MemoryManager) + .globl RealFreeMem +RealFreeMem: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2F02 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; RemoveFromOOMQueue(Pointer) -> void +; tool 0x0D02, set 0x02 (MemoryManager) + .globl RemoveFromOOMQueue +RemoveFromOOMQueue: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0D02 + jsl 0xe10000 + rtl + +; SetHandleID(Word, Handle) -> Word +; tool 0x3002, set 0x02 (MemoryManager) + .globl SetHandleID +SetHandleID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x3002 + jsl 0xe10000 + pla ; result -> A + rtl + +; MenuStartUp(Word, Word) -> void +; tool 0x020F, set 0x0F (MenuManager) + .globl MenuStartUp +MenuStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x020F + jsl 0xe10000 + rtl + +; CalcMenuSize(Word, Word, Word) -> void +; tool 0x1C0F, set 0x0F (MenuManager) + .globl CalcMenuSize +CalcMenuSize: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ldx #0x1C0F + jsl 0xe10000 + rtl + +; CheckMItem(Boolean, Word) -> void +; tool 0x320F, set 0x0F (MenuManager) + .globl CheckMItem +CheckMItem: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x320F + jsl 0xe10000 + rtl + +; DisposeMenu(MenuRecHndl) -> void +; tool 0x2E0F, set 0x0F (MenuManager) + .globl DisposeMenu +DisposeMenu: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2E0F + jsl 0xe10000 + rtl + +; GetBarColors(void) -> LongWord +; tool 0x180F, set 0x0F (MenuManager) + .globl GetBarColors +GetBarColors: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x180F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetMenuBar(void) -> MenuBarRecHndl +; tool 0x0A0F, set 0x0F (MenuManager) + .globl GetMenuBar +GetMenuBar: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0A0F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetMenuMgrPort(void) -> GrafPortPtr +; tool 0x1B0F, set 0x0F (MenuManager) + .globl GetMenuMgrPort +GetMenuMgrPort: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1B0F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetMenuTitle(Word) -> Pointer +; tool 0x220F, set 0x0F (MenuManager) + .globl GetMenuTitle +GetMenuTitle: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x220F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetMHandle(Word) -> MenuRecHndl +; tool 0x160F, set 0x0F (MenuManager) + .globl GetMHandle +GetMHandle: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x160F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetMItem(Word) -> StringPtr +; tool 0x250F, set 0x0F (MenuManager) + .globl GetMItem +GetMItem: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x250F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetMItemStyle(Word) -> TextStyle +; tool 0x360F, set 0x0F (MenuManager) + .globl GetMItemStyle +GetMItemStyle: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x360F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetSysBar(void) -> MenuBarRecHndl +; tool 0x110F, set 0x0F (MenuManager) + .globl GetSysBar +GetSysBar: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x110F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; HiliteMenu(Boolean, Word) -> void +; tool 0x2C0F, set 0x0F (MenuManager) + .globl HiliteMenu +HiliteMenu: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x2C0F + jsl 0xe10000 + rtl + +; InsertMenu(MenuRecHndl, Word) -> void +; tool 0x0D0F, set 0x0F (MenuManager) + .globl InsertMenu +InsertMenu: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x0D0F + jsl 0xe10000 + rtl + +; InsertMItem(Pointer, Word, Word) -> void +; tool 0x0F0F, set 0x0F (MenuManager) + .globl InsertMItem +InsertMItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ldx #0x0F0F + jsl 0xe10000 + rtl + +; MenuKey(WmTaskRecPtr, MenuRecHndl) -> void +; tool 0x090F, set 0x0F (MenuManager) + .globl MenuKey +MenuKey: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (MenuRecHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x090F + jsl 0xe10000 + rtl + +; MenuRefresh(VoidProcPtr) -> void +; tool 0x0B0F, set 0x0F (MenuManager) + .globl MenuRefresh +MenuRefresh: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0B0F + jsl 0xe10000 + rtl + +; MenuSelect(WmTaskRecPtr, MenuRecHndl) -> void +; tool 0x2B0F, set 0x0F (MenuManager) + .globl MenuSelect +MenuSelect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (MenuRecHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x2B0F + jsl 0xe10000 + rtl + +; NewMenu(Pointer) -> MenuRecHndl +; tool 0x2D0F, set 0x0F (MenuManager) + .globl NewMenu +NewMenu: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2D0F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; NewMenuBar(GrafPortPtr) -> MenuBarRecHndl +; tool 0x150F, set 0x0F (MenuManager) + .globl NewMenuBar +NewMenuBar: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x150F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SetBarColors(Word, Word, Word) -> void +; tool 0x170F, set 0x0F (MenuManager) + .globl SetBarColors +SetBarColors: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ldx #0x170F + jsl 0xe10000 + rtl + +; SetMenuBar(MenuBarRecHndl) -> void +; tool 0x390F, set 0x0F (MenuManager) + .globl SetMenuBar +SetMenuBar: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x390F + jsl 0xe10000 + rtl + +; SetMenuFlag(Word, Word) -> void +; tool 0x1F0F, set 0x0F (MenuManager) + .globl SetMenuFlag +SetMenuFlag: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x1F0F + jsl 0xe10000 + rtl + +; SetMenuID(Word, Word) -> void +; tool 0x370F, set 0x0F (MenuManager) + .globl SetMenuID +SetMenuID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x370F + jsl 0xe10000 + rtl + +; SetMenuTitle(Pointer, Word) -> void +; tool 0x210F, set 0x0F (MenuManager) + .globl SetMenuTitle +SetMenuTitle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x210F + jsl 0xe10000 + rtl + +; SetMItem(Pointer, Word) -> void +; tool 0x240F, set 0x0F (MenuManager) + .globl SetMItem +SetMItem: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x240F + jsl 0xe10000 + rtl + +; SetMItemFlag(Word, Word) -> void +; tool 0x260F, set 0x0F (MenuManager) + .globl SetMItemFlag +SetMItemFlag: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x260F + jsl 0xe10000 + rtl + +; SetMItemID(Word, Word) -> void +; tool 0x380F, set 0x0F (MenuManager) + .globl SetMItemID +SetMItemID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x380F + jsl 0xe10000 + rtl + +; SetMItemMark(Word, Word) -> void +; tool 0x330F, set 0x0F (MenuManager) + .globl SetMItemMark +SetMItemMark: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x330F + jsl 0xe10000 + rtl + +; SetMItemName(Pointer, Word) -> void +; tool 0x3A0F, set 0x0F (MenuManager) + .globl SetMItemName +SetMItemName: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x3A0F + jsl 0xe10000 + rtl + +; SetMItemStyle(TextStyle, Word) -> void +; tool 0x350F, set 0x0F (MenuManager) + .globl SetMItemStyle +SetMItemStyle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x350F + jsl 0xe10000 + rtl + +; SetMTitleWidth(Word, Word) -> void +; tool 0x1D0F, set 0x0F (MenuManager) + .globl SetMTitleWidth +SetMTitleWidth: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x1D0F + jsl 0xe10000 + rtl + +; SetSysBar(MenuBarRecHndl) -> void +; tool 0x120F, set 0x0F (MenuManager) + .globl SetSysBar +SetSysBar: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x120F + jsl 0xe10000 + rtl + +; GetPopUpDefProc(void) -> Pointer +; tool 0x3B0F, set 0x0F (MenuManager) + .globl GetPopUpDefProc +GetPopUpDefProc: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x3B0F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; InsertMItem2(Word, Ref, Word, Word) -> void +; tool 0x3F0F, set 0x0F (MenuManager) + .globl InsertMItem2 +InsertMItem2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ; --- arg3 (Word, 2B) --- + lda 18, s + pha + ldx #0x3F0F + jsl 0xe10000 + rtl + +; NewMenu2(Word, Ref) -> MenuRecHndl +; tool 0x3E0F, set 0x0F (MenuManager) + .globl NewMenu2 +NewMenu2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x3E0F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; NewMenuBar2(Word, Ref, Pointer) -> MenuBarRecHndl +; tool 0x430F, set 0x0F (MenuManager) + .globl NewMenuBar2 +NewMenuBar2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 18, s + pha + lda 20, s + pha + ldx #0x430F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PopUpMenuSelect(Word, Word, Word, Word, MenuRecHndl) -> Word +; tool 0x3C0F, set 0x0F (MenuManager) + .globl PopUpMenuSelect +PopUpMenuSelect: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ; --- arg3 (Word, 2B) --- + lda 16, s + pha + ; --- arg4 (MenuRecHndl, 4B) --- + lda 20, s + pha + lda 22, s + pha + ldx #0x3C0F + jsl 0xe10000 + pla ; result -> A + rtl + +; SetMenuTitle2(Word, Ref, Word) -> void +; tool 0x400F, set 0x0F (MenuManager) + .globl SetMenuTitle2 +SetMenuTitle2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x400F + jsl 0xe10000 + rtl + +; SetMItem2(Word, Ref, Word) -> void +; tool 0x410F, set 0x0F (MenuManager) + .globl SetMItem2 +SetMItem2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x410F + jsl 0xe10000 + rtl + +; SetMItemName2(Word, Ref, Word) -> void +; tool 0x420F, set 0x0F (MenuManager) + .globl SetMItemName2 +SetMItemName2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x420F + jsl 0xe10000 + rtl + +; GetMItemIcon(Word) -> Ref +; tool 0x480F, set 0x0F (MenuManager) + .globl GetMItemIcon +GetMItemIcon: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x480F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetMItemStruct(Word) -> Ref +; tool 0x4A0F, set 0x0F (MenuManager) + .globl GetMItemStruct +GetMItemStruct: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x4A0F + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; InsertPathMItems(Word, Pointer, Word, Word, Word, Word, Ptr) -> void +; tool 0x500F, set 0x0F (MenuManager) + .globl InsertPathMItems +InsertPathMItems: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ; --- arg3 (Word, 2B) --- + lda 18, s + pha + ; --- arg4 (Word, 2B) --- + lda 22, s + pha + ; --- arg5 (Word, 2B) --- + lda 26, s + pha + ; --- arg6 (Ptr, 4B) --- + lda 30, s + pha + lda 32, s + pha + ldx #0x500F + jsl 0xe10000 + rtl + +; SetMItemFlag2(Word, Word) -> void +; tool 0x4D0F, set 0x0F (MenuManager) + .globl SetMItemFlag2 +SetMItemFlag2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x4D0F + jsl 0xe10000 + rtl + +; SetMItemIcon(Word, Ref, Word) -> void +; tool 0x470F, set 0x0F (MenuManager) + .globl SetMItemIcon +SetMItemIcon: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x470F + jsl 0xe10000 + rtl + +; SetMItemStruct(Word, Ref, Word) -> void +; tool 0x490F, set 0x0F (MenuManager) + .globl SetMItemStruct +SetMItemStruct: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x490F + jsl 0xe10000 + rtl + +; MidiStartUp(Word, Word) -> void +; tool 0x0220, set 0x20 (VideoOverlay) + .globl MidiStartUp +MidiStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0220 + jsl 0xe10000 + rtl + +; MidiClock(Word, Long) -> void +; tool 0x0B20, set 0x20 (VideoOverlay) + .globl MidiClock +MidiClock: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x0B20 + jsl 0xe10000 + rtl + +; MidiControl(Word, Long) -> void +; tool 0x0920, set 0x20 (VideoOverlay) + .globl MidiControl +MidiControl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x0920 + jsl 0xe10000 + rtl + +; MidiDevice(Word, Pointer) -> void +; tool 0x0A20, set 0x20 (VideoOverlay) + .globl MidiDevice +MidiDevice: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x0A20 + jsl 0xe10000 + rtl + +; MidiInfo(Word) -> LongWord +; tool 0x0C20, set 0x20 (VideoOverlay) + .globl MidiInfo +MidiInfo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0C20 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MidiReadPacket(Pointer, Word) -> Word +; tool 0x0D20, set 0x20 (VideoOverlay) + .globl MidiReadPacket +MidiReadPacket: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x0D20 + jsl 0xe10000 + pla ; result -> A + rtl + +; MidiWritePacket(Pointer) -> Word +; tool 0x0E20, set 0x20 (VideoOverlay) + .globl MidiWritePacket +MidiWritePacket: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0E20 + jsl 0xe10000 + pla ; result -> A + rtl + +; MSVersion(void) -> word +; tool 0x0423, set 0x23 (MediaControl) + .globl MSVersion +MSVersion: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0423 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MSStatus(void) -> word +; tool 0x0623, set 0x23 (MediaControl) + .globl MSStatus +MSStatus: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0623 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ConvertToTime(Word, Word, Word, Word) -> long +; tool 0x2023, set 0x23 (MediaControl) + .globl ConvertToTime +ConvertToTime: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ; --- arg3 (Word, 2B) --- + lda 18, s + pha + ldx #0x2023 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; DeleteTrack(Word, Ptr) -> void +; tool 0x1D23, set 0x23 (MediaControl) + .globl DeleteTrack +DeleteTrack: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x1D23 + jsl 0xe10000 + rtl + +; GetTuningTable(Ptr) -> void +; tool 0x2523, set 0x23 (MediaControl) + .globl GetTuningTable +GetTuningTable: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2523 + jsl 0xe10000 + rtl + +; InitMIDIDriver(Word, Word, Word, ProcPtr) -> void +; tool 0x2723, set 0x23 (MediaControl) + .globl InitMIDIDriver +InitMIDIDriver: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ; --- arg3 (ProcPtr, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x2723 + jsl 0xe10000 + rtl + +; Locate(Long, Ptr) -> SeqItemRecPtr +; tool 0x1123, set 0x23 (MediaControl) + .globl Locate +Locate: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Ptr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x1123 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LocateEnd(Ptr) -> pointer +; tool 0x1B23, set 0x23 (MediaControl) + .globl LocateEnd +LocateEnd: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1B23 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; Merge(Ptr, Ptr) -> void +; tool 0x1C23, set 0x23 (MediaControl) + .globl Merge +Merge: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Ptr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1C23 + jsl 0xe10000 + rtl + +; MIDIMessage(Word, Word, Word, Word, Word) -> void +; tool 0x1A23, set 0x23 (MediaControl) + .globl MIDIMessage +MIDIMessage: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ; --- arg3 (Word, 2B) --- + lda 14, s + pha + ; --- arg4 (Word, 2B) --- + lda 18, s + pha + ldx #0x1A23 + jsl 0xe10000 + rtl + +; PlayNote(Word, Word, Word) -> void +; tool 0x0B23, set 0x23 (MediaControl) + .globl PlayNote +PlayNote: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ldx #0x0B23 + jsl 0xe10000 + rtl + +; SeqPlayer(SeqPlayRecPtr) -> void +; tool 0x1523, set 0x23 (MediaControl) + .globl SeqPlayer +SeqPlayer: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1523 + jsl 0xe10000 + rtl + +; SetCallBack(CallBackRecPtr) -> void +; tool 0x1723, set 0x23 (MediaControl) + .globl SetCallBack +SetCallBack: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1723 + jsl 0xe10000 + rtl + +; SetInstrument(InstrumentRecPtr, Word) -> void +; tool 0x1423, set 0x23 (MediaControl) + .globl SetInstrument +SetInstrument: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x1423 + jsl 0xe10000 + rtl + +; SetMetro(Word, Word, Ptr) -> void +; tool 0x1E23, set 0x23 (MediaControl) + .globl SetMetro +SetMetro: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Ptr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1E23 + jsl 0xe10000 + rtl + +; SetMIDIPort(Boolean, Boolean) -> void +; tool 0x1323, set 0x23 (MediaControl) + .globl SetMIDIPort +SetMIDIPort: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Boolean, 2B) --- + lda 6, s + pha + ldx #0x1323 + jsl 0xe10000 + rtl + +; SetPlayTrack(Word, Boolean) -> void +; tool 0x0F23, set 0x23 (MediaControl) + .globl SetPlayTrack +SetPlayTrack: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Boolean, 2B) --- + lda 6, s + pha + ldx #0x0F23 + jsl 0xe10000 + rtl + +; SetTrackOut(Word, Word) -> void +; tool 0x2623, set 0x23 (MediaControl) + .globl SetTrackOut +SetTrackOut: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x2623 + jsl 0xe10000 + rtl + +; SetTuningTable(Ptr) -> void +; tool 0x2423, set 0x23 (MediaControl) + .globl SetTuningTable +SetTuningTable: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2423 + jsl 0xe10000 + rtl + +; StopNote(Word, Word) -> void +; tool 0x0C23, set 0x23 (MediaControl) + .globl StopNote +StopNote: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0C23 + jsl 0xe10000 + rtl + +; SysExOut(Ptr, Word, ProcPtr) -> void +; tool 0x1823, set 0x23 (MediaControl) + .globl SysExOut +SysExOut: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (ProcPtr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x1823 + jsl 0xe10000 + rtl + +; TrackToChannel(Word, Word) -> void +; tool 0x1023, set 0x23 (MediaControl) + .globl TrackToChannel +TrackToChannel: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x1023 + jsl 0xe10000 + rtl + +; WriteBRam(Pointer) -> void +; tool 0x0903, set 0x03 (MiscTools) + .globl WriteBRam +WriteBRam: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0903 + jsl 0xe10000 + rtl + +; ReadBRam(Pointer) -> void +; tool 0x0A03, set 0x03 (MiscTools) + .globl ReadBRam +ReadBRam: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0A03 + jsl 0xe10000 + rtl + +; WriteBParam(Word, Word) -> void +; tool 0x0B03, set 0x03 (MiscTools) + .globl WriteBParam +WriteBParam: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0B03 + jsl 0xe10000 + rtl + +; WriteTimeHex(HexTime) -> void +; tool 0x0E03, set 0x03 (MiscTools) + .globl WriteTimeHex +WriteTimeHex: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0E03 + jsl 0xe10000 + rtl + +; ReadAsciiTime(Pointer) -> void +; tool 0x0F03, set 0x03 (MiscTools) + .globl ReadAsciiTime +ReadAsciiTime: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0F03 + jsl 0xe10000 + rtl + +; GetAddr(Word) -> Pointer +; tool 0x1603, set 0x03 (MiscTools) + .globl GetAddr +GetAddr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1603 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetTick(void) -> LongWord +; tool 0x2503, set 0x03 (MiscTools) + .globl GetTick +GetTick: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2503 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ClampMouse(Word, Word, Word, Word) -> void +; tool 0x1C03, set 0x03 (MiscTools) + .globl ClampMouse +ClampMouse: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ; --- arg3 (Word, 2B) --- + lda 14, s + pha + ldx #0x1C03 + jsl 0xe10000 + rtl + +; PosMouse(Integer, Integer) -> void +; tool 0x1E03, set 0x03 (MiscTools) + .globl PosMouse +PosMouse: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ldx #0x1E03 + jsl 0xe10000 + rtl + +; PackBytes(Handle, Word, Pointer, Word) -> Word +; tool 0x2603, set 0x03 (MiscTools) + .globl PackBytes +PackBytes: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 14, s + pha + lda 16, s + pha + ; --- arg3 (Word, 2B) --- + lda 22, s + pha + ldx #0x2603 + jsl 0xe10000 + pla ; result -> A + rtl + +; UnPackBytes(Pointer, Word, Handle, Word) -> Word +; tool 0x2703, set 0x03 (MiscTools) + .globl UnPackBytes +UnPackBytes: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ; --- arg2 (Handle, 4B) --- + lda 14, s + pha + lda 16, s + pha + ; --- arg3 (Word, 2B) --- + lda 22, s + pha + ldx #0x2703 + jsl 0xe10000 + pla ; result -> A + rtl + +; Munger(Handle, Word, Pointer, Word, Pointer, Word, Pointer) -> Word +; tool 0x2803, set 0x03 (MiscTools) + .globl Munger +Munger: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 14, s + pha + lda 16, s + pha + ; --- arg3 (Word, 2B) --- + lda 22, s + pha + ; --- arg4 (Pointer, 4B) --- + lda 26, s + pha + lda 28, s + pha + ; --- arg5 (Word, 2B) --- + lda 34, s + pha + ; --- arg6 (Pointer, 4B) --- + lda 38, s + pha + lda 40, s + pha + ldx #0x2803 + jsl 0xe10000 + pla ; result -> A + rtl + +; SetHeartBeat(Pointer) -> void +; tool 0x1203, set 0x03 (MiscTools) + .globl SetHeartBeat +SetHeartBeat: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1203 + jsl 0xe10000 + rtl + +; DelHeartBeat(Pointer) -> void +; tool 0x1303, set 0x03 (MiscTools) + .globl DelHeartBeat +DelHeartBeat: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1303 + jsl 0xe10000 + rtl + +; SysFailMgr(Word, Pointer) -> void +; tool 0x1503, set 0x03 (MiscTools) + .globl SysFailMgr +SysFailMgr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x1503 + jsl 0xe10000 + rtl + +; SetVector(Word, Pointer) -> void +; tool 0x1003, set 0x03 (MiscTools) + .globl SetVector +SetVector: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x1003 + jsl 0xe10000 + rtl + +; GetVector(Word) -> Pointer +; tool 0x1103, set 0x03 (MiscTools) + .globl GetVector +GetVector: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1103 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; AddToQueue(Pointer, Pointer) -> void +; tool 0x2E03, set 0x03 (MiscTools) + .globl AddToQueue +AddToQueue: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x2E03 + jsl 0xe10000 + rtl + +; DeleteFromQueue(Pointer, Pointer) -> void +; tool 0x2F03, set 0x03 (MiscTools) + .globl DeleteFromQueue +DeleteFromQueue: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x2F03 + jsl 0xe10000 + rtl + +; GetCodeResConverter(void) -> ProcPtr +; tool 0x3403, set 0x03 (MiscTools) + .globl GetCodeResConverter +GetCodeResConverter: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x3403 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetInterruptState(Pointer, Word) -> void +; tool 0x3103, set 0x03 (MiscTools) + .globl GetInterruptState +GetInterruptState: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x3103 + jsl 0xe10000 + rtl + +; SetInterruptState(Pointer, Word) -> void +; tool 0x3003, set 0x03 (MiscTools) + .globl SetInterruptState +SetInterruptState: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x3003 + jsl 0xe10000 + rtl + +; ConvSeconds(Word, Long, Pointer) -> LongWord +; tool 0x3703, set 0x03 (MiscTools) + .globl ConvSeconds +ConvSeconds: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 18, s + pha + lda 20, s + pha + ldx #0x3703 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ShowBootInfo(Pointer, Pointer) -> void +; tool 0x3C03, set 0x03 (MiscTools) + .globl ShowBootInfo +ShowBootInfo: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x3C03 + jsl 0xe10000 + rtl + +; StringToText(Word, Ptr, Word, Ptr) -> LongWord +; tool 0x3B03, set 0x03 (MiscTools) + .globl StringToText +StringToText: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Word, 2B) --- + lda 18, s + pha + ; --- arg3 (Ptr, 4B) --- + lda 22, s + pha + lda 24, s + pha + ldx #0x3B03 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; VersionString(Word, Long, Ptr) -> void +; tool 0x3903, set 0x03 (MiscTools) + .globl VersionString +VersionString: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Ptr, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x3903 + jsl 0xe10000 + rtl + +; WaitUntil(Word, Word) -> Word +; tool 0x3A03, set 0x03 (MiscTools) + .globl WaitUntil +WaitUntil: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x3A03 + jsl 0xe10000 + pla ; result -> A + rtl + +; AlertMessage(Ptr, Word, Ptr) -> Word +; tool 0x3E03, set 0x03 (MiscTools) + .globl AlertMessage +AlertMessage: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ; --- arg2 (Ptr, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x3E03 + jsl 0xe10000 + pla ; result -> A + rtl + +; DoSysPrefs(Word, Word) -> Word +; tool 0x3F03, set 0x03 (MiscTools) + .globl DoSysPrefs +DoSysPrefs: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x3F03 + jsl 0xe10000 + pla ; result -> A + rtl + +; SeqStartUp(Word, Word, Word, Word) -> void +; tool 0x021A, set 0x1A (NoteSequencer) + .globl SeqStartUp +SeqStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ; --- arg3 (Word, 2B) --- + lda 14, s + pha + ldx #0x021A + jsl 0xe10000 + rtl + +; SetInstTable(Handle) -> void +; tool 0x121A, set 0x1A (NoteSequencer) + .globl SetInstTable +SetInstTable: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x121A + jsl 0xe10000 + rtl + +; SetTrkInfo(Word, Word, Word) -> void +; tool 0x0E1A, set 0x1A (NoteSequencer) + .globl SetTrkInfo +SetTrkInfo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ldx #0x0E1A + jsl 0xe10000 + rtl + +; StartSeq(Pointer, Pointer, Handle) -> void +; tool 0x0F1A, set 0x1A (NoteSequencer) + .globl StartSeq +StartSeq: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Handle, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x0F1A + jsl 0xe10000 + rtl + +; StartSeqRel(Pointer, Pointer, Handle) -> void +; tool 0x151A, set 0x1A (NoteSequencer) + .globl StartSeqRel +StartSeqRel: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Handle, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x151A + jsl 0xe10000 + rtl + +; NSStartUp(Word, Pointer) -> void +; tool 0x0219, set 0x19 (NoteSynth) + .globl NSStartUp +NSStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x0219 + jsl 0xe10000 + rtl + +; NoteOff(Word, Word) -> void +; tool 0x0C19, set 0x19 (NoteSynth) + .globl NoteOff +NoteOff: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0C19 + jsl 0xe10000 + rtl + +; NoteOn(Word, Word, Word, Pointer) -> void +; tool 0x0B19, set 0x19 (NoteSynth) + .globl NoteOn +NoteOn: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ; --- arg3 (Pointer, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x0B19 + jsl 0xe10000 + rtl + +; NSSetUserUpdateRtn(Pointer) -> VoidProcPtr +; tool 0x0F19, set 0x19 (NoteSynth) + .globl NSSetUserUpdateRtn +NSSetUserUpdateRtn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0F19 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PMStartUp(Word, Word) -> void +; tool 0x0213, set 0x13 (PrintManager) + .globl PMStartUp +PMStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0213 + jsl 0xe10000 + rtl + +; PrCloseDoc(GrafPortPtr) -> void +; tool 0x0F13, set 0x13 (PrintManager) + .globl PrCloseDoc +PrCloseDoc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0F13 + jsl 0xe10000 + rtl + +; PrClosePage(GrafPortPtr) -> void +; tool 0x1113, set 0x13 (PrintManager) + .globl PrClosePage +PrClosePage: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1113 + jsl 0xe10000 + rtl + +; PrDefault(PrRecHndl) -> void +; tool 0x0913, set 0x13 (PrintManager) + .globl PrDefault +PrDefault: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0913 + jsl 0xe10000 + rtl + +; PrJobDialog(PrRecHndl) -> Boolean +; tool 0x0C13, set 0x13 (PrintManager) + .globl PrJobDialog +PrJobDialog: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0C13 + jsl 0xe10000 + pla ; result -> A + rtl + +; PrOpenDoc(PrRecHndl, GrafPortPtr) -> GrafPortPtr +; tool 0x0E13, set 0x13 (PrintManager) + .globl PrOpenDoc +PrOpenDoc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0E13 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PrOpenPage(GrafPortPtr, Rect) -> void +; tool 0x1013, set 0x13 (PrintManager) + .globl PrOpenPage +PrOpenPage: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1013 + jsl 0xe10000 + rtl + +; PrPicFile(PrRecHndl, GrafPortPtr, PrStatusRecPtr) -> void +; tool 0x1213, set 0x13 (PrintManager) + .globl PrPicFile +PrPicFile: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (PrStatusRecPtr, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x1213 + jsl 0xe10000 + rtl + +; PrPixelMap(LocInfoPtr, RectPtr, Boolean) -> void +; tool 0x0D13, set 0x13 (PrintManager) + .globl PrPixelMap +PrPixelMap: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (RectPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Boolean, 2B) --- + lda 16, s + pha + ldx #0x0D13 + jsl 0xe10000 + rtl + +; PrStlDialog(PrRecHndl) -> Boolean +; tool 0x0B13, set 0x13 (PrintManager) + .globl PrStlDialog +PrStlDialog: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0B13 + jsl 0xe10000 + pla ; result -> A + rtl + +; PrValidate(PrRecHndl) -> Boolean +; tool 0x0A13, set 0x13 (PrintManager) + .globl PrValidate +PrValidate: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0A13 + jsl 0xe10000 + pla ; result -> A + rtl + +; PrGetDocName(void) -> StringPtr +; tool 0x3613, set 0x13 (PrintManager) + .globl PrGetDocName +PrGetDocName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x3613 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PrGetPgOrientation(PrRecHndl) -> Word +; tool 0x3813, set 0x13 (PrintManager) + .globl PrGetPgOrientation +PrGetPgOrientation: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3813 + jsl 0xe10000 + pla ; result -> A + rtl + +; PrGetPrinterSpecs(void) -> long +; tool 0x1813, set 0x13 (PrintManager) + .globl PrGetPrinterSpecs +PrGetPrinterSpecs: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1813 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PrSetDocName(Pointer) -> void +; tool 0x3713, set 0x13 (PrintManager) + .globl PrSetDocName +PrSetDocName: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3713 + jsl 0xe10000 + rtl + +; PrGetNetworkName(void) -> StringPtr +; tool 0x2B13, set 0x13 (PrintManager) + .globl PrGetNetworkName +PrGetNetworkName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2B13 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PrGetPortDvrName(void) -> StringPtr +; tool 0x2913, set 0x13 (PrintManager) + .globl PrGetPortDvrName +PrGetPortDvrName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2913 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PrGetPrinterDvrName(void) -> StringPtr +; tool 0x2813, set 0x13 (PrintManager) + .globl PrGetPrinterDvrName +PrGetPrinterDvrName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2813 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PrGetUserName(void) -> StringPtr +; tool 0x2A13, set 0x13 (PrintManager) + .globl PrGetUserName +PrGetUserName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2A13 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PrGetZoneName(void) -> StringPtr +; tool 0x2513, set 0x13 (PrintManager) + .globl PrGetZoneName +PrGetZoneName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2513 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; CopyPixels(LocInfoPtr, LocInfoPtr, Rect, Rect, Word, RegionHndl) -> void +; tool 0x0912, set 0x12 (QDAuxiliary) + .globl CopyPixels +CopyPixels: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (LocInfoPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Rect, 4B) --- + lda 16, s + pha + lda 18, s + pha + ; --- arg3 (Rect, 4B) --- + lda 24, s + pha + lda 26, s + pha + ; --- arg4 (Word, 2B) --- + lda 32, s + pha + ; --- arg5 (RegionHndl, 4B) --- + lda 36, s + pha + lda 38, s + pha + ldx #0x0912 + jsl 0xe10000 + rtl + +; DrawIcon(Pointer, Word, Word, Word) -> void +; tool 0x0B12, set 0x12 (QDAuxiliary) + .globl DrawIcon +DrawIcon: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ; --- arg3 (Word, 2B) --- + lda 16, s + pha + ldx #0x0B12 + jsl 0xe10000 + rtl + +; DrawPicture(Handle, Rect) -> void +; tool 0xBA04, set 0x04 (QuickDraw) + .globl DrawPicture +DrawPicture: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0xBA04 + jsl 0xe10000 + rtl + +; KillPicture(Handle) -> void +; tool 0xBB04, set 0x04 (QuickDraw) + .globl KillPicture +KillPicture: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xBB04 + jsl 0xe10000 + rtl + +; OpenPicture(Pointer) -> PicHndl +; tool 0xB704, set 0x04 (QuickDraw) + .globl OpenPicture +OpenPicture: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xB704 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PicComment(Integer, Integer, Handle) -> void +; tool 0xB804, set 0x04 (QuickDraw) + .globl PicComment +PicComment: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (Handle, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0xB804 + jsl 0xe10000 + rtl + +; CalcMask(LocInfoPtr, Rect, LocInfoPtr, Rect, Word, PatternPtr, Pointer) -> void +; tool 0x0E12, set 0x12 (QDAuxiliary) + .globl CalcMask +CalcMask: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (LocInfoPtr, 4B) --- + lda 16, s + pha + lda 18, s + pha + ; --- arg3 (Rect, 4B) --- + lda 24, s + pha + lda 26, s + pha + ; --- arg4 (Word, 2B) --- + lda 32, s + pha + ; --- arg5 (PatternPtr, 4B) --- + lda 36, s + pha + lda 38, s + pha + ; --- arg6 (Pointer, 4B) --- + lda 44, s + pha + lda 46, s + pha + ldx #0x0E12 + jsl 0xe10000 + rtl + +; SeedFill(LocInfoPtr, Rect, LocInfoPtr, Rect, Word, Word, Word, PatternPtr, Pointer) -> void +; tool 0x0D12, set 0x12 (QDAuxiliary) + .globl SeedFill +SeedFill: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (LocInfoPtr, 4B) --- + lda 16, s + pha + lda 18, s + pha + ; --- arg3 (Rect, 4B) --- + lda 24, s + pha + lda 26, s + pha + ; --- arg4 (Word, 2B) --- + lda 32, s + pha + ; --- arg5 (Word, 2B) --- + lda 36, s + pha + ; --- arg6 (Word, 2B) --- + lda 40, s + pha + ; --- arg7 (PatternPtr, 4B) --- + lda 44, s + pha + lda 46, s + pha + ; --- arg8 (Pointer, 4B) --- + lda 52, s + pha + lda 54, s + pha + ldx #0x0D12 + jsl 0xe10000 + rtl + +; SpecialRect(Rect, Word, Word) -> void +; tool 0x0C12, set 0x12 (QDAuxiliary) + .globl SpecialRect +SpecialRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ldx #0x0C12 + jsl 0xe10000 + rtl + +; GetSysIcon(Word, Word, Long) -> QDIconRecordPtr +; tool 0x0F12, set 0x12 (QDAuxiliary) + .globl GetSysIcon +GetSysIcon: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ; --- arg2 (Long, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x0F12 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PixelMap2Rgn(LocInfoPtr, Word, Word) -> RegionHndl +; tool 0x1012, set 0x12 (QDAuxiliary) + .globl PixelMap2Rgn +PixelMap2Rgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 12, s + pha + ; --- arg2 (Word, 2B) --- + lda 16, s + pha + ldx #0x1012 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; WhooshRect(Long, Rect, Rect) -> void +; tool 0x1412, set 0x12 (QDAuxiliary) + .globl WhooshRect +WhooshRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Rect, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x1412 + jsl 0xe10000 + rtl + +; DrawStringWidth(Word, Ref, Word) -> void +; tool 0x1512, set 0x12 (QDAuxiliary) + .globl DrawStringWidth +DrawStringWidth: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ldx #0x1512 + jsl 0xe10000 + rtl + +; UseColorTable(Word, ColorTablePtr, Word) -> Handle +; tool 0x1612, set 0x12 (QDAuxiliary) + .globl UseColorTable +UseColorTable: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (ColorTablePtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Word, 2B) --- + lda 18, s + pha + ldx #0x1612 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; RestoreColorTable(Handle, Word) -> void +; tool 0x1712, set 0x12 (QDAuxiliary) + .globl RestoreColorTable +RestoreColorTable: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x1712 + jsl 0xe10000 + rtl + +; QDStartUp(Word, Word, Word, Word) -> void +; tool 0x0204, set 0x04 (QuickDraw) + .globl QDStartUp +QDStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ; --- arg3 (Word, 2B) --- + lda 14, s pha ldx #0x0204 jsl 0xe10000 rtl +; AddPt(Point, Point) -> void +; tool 0x8004, set 0x04 (QuickDraw) + .globl AddPt +AddPt: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Point, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x8004 + jsl 0xe10000 + rtl -; ===================================================================== -; void TBoxMoveTo(short h, short v) -; Entry: A = h, 4,S = v -; ===================================================================== -TBoxMoveTo: - pha ; h - lda 6, s ; v (originally 4,S; +2 after pha) +; CharBounds(Word, Rect) -> void +; tool 0xAC04, set 0x04 (QuickDraw) + .globl CharBounds +CharBounds: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Rect, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0xAC04 + jsl 0xe10000 + rtl + +; ClipRect(Rect) -> void +; tool 0x2604, set 0x04 (QuickDraw) + .globl ClipRect +ClipRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2604 + jsl 0xe10000 + rtl + +; ClosePort(GrafPortPtr) -> void +; tool 0x1A04, set 0x04 (QuickDraw) + .globl ClosePort +ClosePort: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1A04 + jsl 0xe10000 + rtl + +; CloseRgn(RegionHndl) -> void +; tool 0x6E04, set 0x04 (QuickDraw) + .globl CloseRgn +CloseRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x6E04 + jsl 0xe10000 + rtl + +; CopyRgn(RegionHndl, RegionHndl) -> void +; tool 0x6904, set 0x04 (QuickDraw) + .globl CopyRgn +CopyRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (RegionHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x6904 + jsl 0xe10000 + rtl + +; CStringBounds(Pointer, Rect) -> void +; tool 0xAE04, set 0x04 (QuickDraw) + .globl CStringBounds +CStringBounds: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0xAE04 + jsl 0xe10000 + rtl + +; CStringWidth(Pointer) -> Word +; tool 0xAA04, set 0x04 (QuickDraw) + .globl CStringWidth +CStringWidth: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xAA04 + jsl 0xe10000 + pla ; result -> A + rtl + +; DiffRgn(RegionHndl, RegionHndl, RegionHndl) -> void +; tool 0x7304, set 0x04 (QuickDraw) + .globl DiffRgn +DiffRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (RegionHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (RegionHndl, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x7304 + jsl 0xe10000 + rtl + +; DisposeRgn(RegionHndl) -> void +; tool 0x6804, set 0x04 (QuickDraw) + .globl DisposeRgn +DisposeRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x6804 + jsl 0xe10000 + rtl + +; DrawCString(Pointer) -> void +; tool 0xA604, set 0x04 (QuickDraw) + .globl DrawCString +DrawCString: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xA604 + jsl 0xe10000 + rtl + +; DrawString(Pointer) -> void +; tool 0xA504, set 0x04 (QuickDraw) + .globl DrawString +DrawString: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xA504 + jsl 0xe10000 + rtl + +; DrawText(Pointer, Word) -> void +; tool 0xA704, set 0x04 (QuickDraw) + .globl DrawText +DrawText: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0xA704 + jsl 0xe10000 + rtl + +; EmptyRgn(RegionHndl) -> Boolean +; tool 0x7804, set 0x04 (QuickDraw) + .globl EmptyRgn +EmptyRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x7804 + jsl 0xe10000 + pla ; result -> A + rtl + +; EqualPt(Point, Point) -> Boolean +; tool 0x8304, set 0x04 (QuickDraw) + .globl EqualPt +EqualPt: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Point, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x8304 + jsl 0xe10000 + pla ; result -> A + rtl + +; EqualRect(Rect, Rect) -> Boolean +; tool 0x5104, set 0x04 (QuickDraw) + .globl EqualRect +EqualRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x5104 + jsl 0xe10000 + pla ; result -> A + rtl + +; EqualRgn(RegionHndl, RegionHndl) -> Boolean +; tool 0x7704, set 0x04 (QuickDraw) + .globl EqualRgn +EqualRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (RegionHndl, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x7704 + jsl 0xe10000 + pla ; result -> A + rtl + +; EraseArc(Rect, Integer, Integer) -> void +; tool 0x6404, set 0x04 (QuickDraw) + .globl EraseArc +EraseArc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ldx #0x6404 + jsl 0xe10000 + rtl + +; EraseOval(Rect) -> void +; tool 0x5A04, set 0x04 (QuickDraw) + .globl EraseOval +EraseOval: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x5A04 + jsl 0xe10000 + rtl + +; ErasePoly(Handle) -> void +; tool 0xBE04, set 0x04 (QuickDraw) + .globl ErasePoly +ErasePoly: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xBE04 + jsl 0xe10000 + rtl + +; EraseRect(Rect) -> void +; tool 0x5504, set 0x04 (QuickDraw) + .globl EraseRect +EraseRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x5504 + jsl 0xe10000 + rtl + +; EraseRgn(RegionHndl) -> void +; tool 0x7B04, set 0x04 (QuickDraw) + .globl EraseRgn +EraseRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x7B04 + jsl 0xe10000 + rtl + +; EraseRRect(Rect, Word, Word) -> void +; tool 0x5F04, set 0x04 (QuickDraw) + .globl EraseRRect +EraseRRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ldx #0x5F04 + jsl 0xe10000 + rtl + +; FillArc(Rect, Integer, Integer, Pattern) -> void +; tool 0x6604, set 0x04 (QuickDraw) + .globl FillArc +FillArc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ; --- arg3 (Pattern, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x6604 + jsl 0xe10000 + rtl + +; FillOval(Rect, Pattern) -> void +; tool 0x5C04, set 0x04 (QuickDraw) + .globl FillOval +FillOval: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pattern, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x5C04 + jsl 0xe10000 + rtl + +; FillPoly(Handle, Pattern) -> void +; tool 0xC004, set 0x04 (QuickDraw) + .globl FillPoly +FillPoly: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pattern, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0xC004 + jsl 0xe10000 + rtl + +; FillRect(Rect, Pattern) -> void +; tool 0x5704, set 0x04 (QuickDraw) + .globl FillRect +FillRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pattern, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x5704 + jsl 0xe10000 + rtl + +; FillRgn(RegionHndl, Pattern) -> void +; tool 0x7D04, set 0x04 (QuickDraw) + .globl FillRgn +FillRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pattern, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x7D04 + jsl 0xe10000 + rtl + +; FillRRect(Rect, Word, Word, Pattern) -> void +; tool 0x6104, set 0x04 (QuickDraw) + .globl FillRRect +FillRRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ; --- arg3 (Pattern, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x6104 + jsl 0xe10000 + rtl + +; ForceBufDims(Word, Word, Word) -> void +; tool 0xCC04, set 0x04 (QuickDraw) + .globl ForceBufDims +ForceBufDims: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ldx #0xCC04 + jsl 0xe10000 + rtl + +; FrameArc(Rect, Integer, Integer) -> void +; tool 0x6204, set 0x04 (QuickDraw) + .globl FrameArc +FrameArc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ldx #0x6204 + jsl 0xe10000 + rtl + +; FrameOval(Rect) -> void +; tool 0x5804, set 0x04 (QuickDraw) + .globl FrameOval +FrameOval: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x5804 + jsl 0xe10000 + rtl + +; FramePoly(Handle) -> void +; tool 0xBC04, set 0x04 (QuickDraw) + .globl FramePoly +FramePoly: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xBC04 + jsl 0xe10000 + rtl + +; FrameRect(Rect) -> void +; tool 0x5304, set 0x04 (QuickDraw) + .globl FrameRect +FrameRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x5304 + jsl 0xe10000 + rtl + +; FrameRgn(RegionHndl) -> void +; tool 0x7904, set 0x04 (QuickDraw) + .globl FrameRgn +FrameRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x7904 + jsl 0xe10000 + rtl + +; FrameRRect(Rect, Word, Word) -> void +; tool 0x5D04, set 0x04 (QuickDraw) + .globl FrameRRect +FrameRRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ldx #0x5D04 + jsl 0xe10000 + rtl + +; GetAddress(Word) -> Pointer +; tool 0x0904, set 0x04 (QuickDraw) + .globl GetAddress +GetAddress: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0904 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetBackPat(Pattern) -> void +; tool 0x3504, set 0x04 (QuickDraw) + .globl GetBackPat +GetBackPat: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3504 + jsl 0xe10000 + rtl + +; GetCharExtra(void) -> Fixed +; tool 0xD504, set 0x04 (QuickDraw) + .globl GetCharExtra +GetCharExtra: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0xD504 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetClip(RegionHndl) -> void +; tool 0x2504, set 0x04 (QuickDraw) + .globl GetClip +GetClip: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2504 + jsl 0xe10000 + rtl + +; GetClipHandle(void) -> RegionHndl +; tool 0xC704, set 0x04 (QuickDraw) + .globl GetClipHandle +GetClipHandle: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0xC704 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetColorEntry(Word, Word) -> Word +; tool 0x1104, set 0x04 (QuickDraw) + .globl GetColorEntry +GetColorEntry: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x1104 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetColorTable(Word, ColorTable) -> void +; tool 0x0F04, set 0x04 (QuickDraw) + .globl GetColorTable +GetColorTable: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (ColorTable, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x0F04 + jsl 0xe10000 + rtl + +; GetCursorAdr(void) -> Pointer +; tool 0x8F04, set 0x04 (QuickDraw) + .globl GetCursorAdr +GetCursorAdr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x8F04 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetFont(void) -> FontHndl +; tool 0x9504, set 0x04 (QuickDraw) + .globl GetFont +GetFont: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x9504 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetFontGlobals(FontGlobalsRecPtr) -> void +; tool 0x9704, set 0x04 (QuickDraw) + .globl GetFontGlobals +GetFontGlobals: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x9704 + jsl 0xe10000 + rtl + +; GetFontID(void) -> Long +; tool 0xD104, set 0x04 (QuickDraw) + .globl GetFontID +GetFontID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0xD104 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetFontInfo(FontInfoRecPtr) -> void +; tool 0x9604, set 0x04 (QuickDraw) + .globl GetFontInfo +GetFontInfo: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x9604 + jsl 0xe10000 + rtl + +; GetFontLore(FontGlobalsRecPtr, Word) -> Word +; tool 0xD904, set 0x04 (QuickDraw) + .globl GetFontLore +GetFontLore: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0xD904 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetGrafProcs(void) -> QDProcsPtr +; tool 0x4504, set 0x04 (QuickDraw) + .globl GetGrafProcs +GetGrafProcs: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x4504 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetPen(Point) -> void +; tool 0x2904, set 0x04 (QuickDraw) + .globl GetPen +GetPen: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2904 + jsl 0xe10000 + rtl + +; GetPenMask(Mask) -> void +; tool 0x3304, set 0x04 (QuickDraw) + .globl GetPenMask +GetPenMask: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3304 + jsl 0xe10000 + rtl + +; GetPenPat(Pattern) -> void +; tool 0x3104, set 0x04 (QuickDraw) + .globl GetPenPat +GetPenPat: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3104 + jsl 0xe10000 + rtl + +; GetPenSize(Point) -> void +; tool 0x2D04, set 0x04 (QuickDraw) + .globl GetPenSize +GetPenSize: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2D04 + jsl 0xe10000 + rtl + +; GetPenState(PenStatePtr) -> void +; tool 0x2B04, set 0x04 (QuickDraw) + .globl GetPenState +GetPenState: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2B04 + jsl 0xe10000 + rtl + +; GetPicSave(void) -> Longint +; tool 0x3F04, set 0x04 (QuickDraw) + .globl GetPicSave +GetPicSave: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x3F04 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetPixel(Integer, Integer) -> Word +; tool 0x8804, set 0x04 (QuickDraw) + .globl GetPixel +GetPixel: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ldx #0x8804 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetPolySave(void) -> LongWord +; tool 0x4304, set 0x04 (QuickDraw) + .globl GetPolySave +GetPolySave: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x4304 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetPort(void) -> GrafPortPtr +; tool 0x1C04, set 0x04 (QuickDraw) + .globl GetPort +GetPort: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1C04 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetPortLoc(LocInfoPtr) -> void +; tool 0x1E04, set 0x04 (QuickDraw) + .globl GetPortLoc +GetPortLoc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1E04 + jsl 0xe10000 + rtl + +; GetPortRect(Rect) -> void +; tool 0x2004, set 0x04 (QuickDraw) + .globl GetPortRect +GetPortRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2004 + jsl 0xe10000 + rtl + +; GetRgnSave(void) -> LongWord +; tool 0x4104, set 0x04 (QuickDraw) + .globl GetRgnSave +GetRgnSave: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x4104 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetROMFont(RomFontRecPtr) -> void +; tool 0xD804, set 0x04 (QuickDraw) + .globl GetROMFont +GetROMFont: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xD804 + jsl 0xe10000 + rtl + +; GetRomFont(RomFontRecPtr) -> void +; tool 0xD804, set 0x04 (QuickDraw) + .globl GetRomFont +GetRomFont: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xD804 + jsl 0xe10000 + rtl + +; GetSpaceExtra(void) -> Fixed +; tool 0x9F04, set 0x04 (QuickDraw) + .globl GetSpaceExtra +GetSpaceExtra: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x9F04 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetSysField(void) -> Longint +; tool 0x4904, set 0x04 (QuickDraw) + .globl GetSysField +GetSysField: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x4904 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetSysFont(void) -> FontHndl +; tool 0xB304, set 0x04 (QuickDraw) + .globl GetSysFont +GetSysFont: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0xB304 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetTextFace(void) -> TextStyle +; tool 0x9B04, set 0x04 (QuickDraw) + .globl GetTextFace +GetTextFace: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x9B04 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetUserField(void) -> Longint +; tool 0x4704, set 0x04 (QuickDraw) + .globl GetUserField +GetUserField: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x4704 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetVisHandle(void) -> RegionHndl +; tool 0xC904, set 0x04 (QuickDraw) + .globl GetVisHandle +GetVisHandle: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0xC904 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetVisRgn(RegionHndl) -> void +; tool 0xB504, set 0x04 (QuickDraw) + .globl GetVisRgn +GetVisRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xB504 + jsl 0xe10000 + rtl + +; GlobalToLocal(Point) -> void +; tool 0x8504, set 0x04 (QuickDraw) + .globl GlobalToLocal +GlobalToLocal: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x8504 + jsl 0xe10000 + rtl + +; InflateTextBuffer(Word, Word) -> void +; tool 0xD704, set 0x04 (QuickDraw) + .globl InflateTextBuffer +InflateTextBuffer: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0xD704 + jsl 0xe10000 + rtl + +; InitColorTable(ColorTable) -> void +; tool 0x0D04, set 0x04 (QuickDraw) + .globl InitColorTable +InitColorTable: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0D04 + jsl 0xe10000 + rtl + +; InitPort(GrafPortPtr) -> void +; tool 0x1904, set 0x04 (QuickDraw) + .globl InitPort +InitPort: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1904 + jsl 0xe10000 + rtl + +; InsetRect(Rect, Integer, Integer) -> void +; tool 0x4C04, set 0x04 (QuickDraw) + .globl InsetRect +InsetRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ldx #0x4C04 + jsl 0xe10000 + rtl + +; InsetRgn(RegionHndl, Integer, Integer) -> void +; tool 0x7004, set 0x04 (QuickDraw) + .globl InsetRgn +InsetRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ldx #0x7004 + jsl 0xe10000 + rtl + +; InvertArc(Rect, Integer, Integer) -> void +; tool 0x6504, set 0x04 (QuickDraw) + .globl InvertArc +InvertArc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ldx #0x6504 + jsl 0xe10000 + rtl + +; InvertOval(Rect) -> void +; tool 0x5B04, set 0x04 (QuickDraw) + .globl InvertOval +InvertOval: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x5B04 + jsl 0xe10000 + rtl + +; InvertPoly(Handle) -> void +; tool 0xBF04, set 0x04 (QuickDraw) + .globl InvertPoly +InvertPoly: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xBF04 + jsl 0xe10000 + rtl + +; InvertRect(Rect) -> void +; tool 0x5604, set 0x04 (QuickDraw) + .globl InvertRect +InvertRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x5604 + jsl 0xe10000 + rtl + +; InvertRgn(RegionHndl) -> void +; tool 0x7C04, set 0x04 (QuickDraw) + .globl InvertRgn +InvertRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x7C04 + jsl 0xe10000 + rtl + +; InvertRRect(Rect, Word, Word) -> void +; tool 0x6004, set 0x04 (QuickDraw) + .globl InvertRRect +InvertRRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ldx #0x6004 + jsl 0xe10000 + rtl + +; KillPoly(Handle) -> void +; tool 0xC304, set 0x04 (QuickDraw) + .globl KillPoly +KillPoly: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xC304 + jsl 0xe10000 + rtl + +; Line(Integer, Integer) -> void +; tool 0x3D04, set 0x04 (QuickDraw) + .globl Line +Line: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ldx #0x3D04 + jsl 0xe10000 + rtl + +; LineTo(Integer, Integer) -> void +; tool 0x3C04, set 0x04 (QuickDraw) + .globl LineTo +LineTo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ldx #0x3C04 + jsl 0xe10000 + rtl + +; LocalToGlobal(Point) -> void +; tool 0x8404, set 0x04 (QuickDraw) + .globl LocalToGlobal +LocalToGlobal: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x8404 + jsl 0xe10000 + rtl + +; MapPoly(Handle, Rect, Rect) -> void +; tool 0xC504, set 0x04 (QuickDraw) + .globl MapPoly +MapPoly: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Rect, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0xC504 + jsl 0xe10000 + rtl + +; MapPt(Point, Rect, Rect) -> void +; tool 0x8A04, set 0x04 (QuickDraw) + .globl MapPt +MapPt: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Rect, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x8A04 + jsl 0xe10000 + rtl + +; MapRect(Rect, Rect, Rect) -> void +; tool 0x8B04, set 0x04 (QuickDraw) + .globl MapRect +MapRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Rect, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x8B04 + jsl 0xe10000 + rtl + +; MapRgn(RegionHndl, Rect, Rect) -> void +; tool 0x8C04, set 0x04 (QuickDraw) + .globl MapRgn +MapRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Rect, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x8C04 + jsl 0xe10000 + rtl + +; Move(Integer, Integer) -> void +; tool 0x3B04, set 0x04 (QuickDraw) + .globl Move +Move: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ldx #0x3B04 + jsl 0xe10000 + rtl + +; MovePortTo(Integer, Integer) -> void +; tool 0x2204, set 0x04 (QuickDraw) + .globl MovePortTo +MovePortTo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ldx #0x2204 + jsl 0xe10000 + rtl + +; MoveTo(Integer, Integer) -> void +; tool 0x3A04, set 0x04 (QuickDraw) + .globl MoveTo +MoveTo: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s pha ldx #0x3A04 jsl 0xe10000 rtl +; NewRgn(void) -> RegionHndl +; tool 0x6704, set 0x04 (QuickDraw) + .globl NewRgn +NewRgn: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x6704 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl -; ===================================================================== -; void TBoxEMStartUp(u16 userId) -; Entry: A = userId -; Default queueSize=0, mouse clamp 0..639 / 0..199 -; Tool: PEA queueSize, PEA xMin, PEA xMax, PEA yMin, PEA yMax, PHA userId -; ===================================================================== -TBoxEMStartUp: - pea 0 ; queueSize = use default - pea 0 ; xMin - pea 0x27F ; xMax = 639 - pea 0 ; yMin - pea 0xC7 ; yMax = 199 - pha ; userId (still in A from entry) - ldx #0x0206 +; NotEmptyRect(Rect) -> Boolean +; tool 0x5204, set 0x04 (QuickDraw) + .globl NotEmptyRect +NotEmptyRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x5204 + jsl 0xe10000 + pla ; result -> A + rtl + +; OffsetPoly(Handle, Integer, Integer) -> void +; tool 0xC404, set 0x04 (QuickDraw) + .globl OffsetPoly +OffsetPoly: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ldx #0xC404 jsl 0xe10000 rtl - -; ===================================================================== -; unsigned short TBoxGetNextEvent(u16 eventMask, void *theEvent) -; Entry: A = eventMask, 4,S = theEvent -; Tool: PHA result(word), PHA eventMask, PHA theEvent, JSL X=$0A06 -; ===================================================================== -TBoxGetNextEvent: - sta 0xe0 ; stash eventMask - pea 0 ; result space (16-bit) - lda 0xe0 ; eventMask +; OffsetRect(Rect, Integer, Integer) -> void +; tool 0x4B04, set 0x04 (QuickDraw) + .globl OffsetRect +OffsetRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 pha - lda 8, s ; theEvent (originally 4,S; +4 after pea+pha) + lda 0xE2 pha - ldx #0x0A06 + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ldx #0x4B04 jsl 0xe10000 - pla ; result → A rtl - -; ===================================================================== -; void *TBoxNewWindow(const void *paramList) -; Entry: A = paramList -; Tool: PEA result hi, PEA result lo, PHA paramList, JSL X=$090E -; Returns 32-bit window ptr in A:X (low in A, hi in X). -; ===================================================================== -TBoxNewWindow: - sta 0xe0 ; stash paramList - pea 0 ; result hi - pea 0 ; result lo - lda 0xe0 ; paramList +; OffsetRgn(RegionHndl, Integer, Integer) -> void +; tool 0x6F04, set 0x04 (QuickDraw) + .globl OffsetRgn +OffsetRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 pha - ldx #0x090E + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ldx #0x6F04 jsl 0xe10000 - pla ; result lo → A - plx ; result hi → X rtl +; OpenPoly(void) -> handle +; tool 0xC104, set 0x04 (QuickDraw) + .globl OpenPoly +OpenPoly: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0xC104 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl -; ===================================================================== -; void TBoxCloseWindow(void *winPtr) -; Entry: A = winPtr lo, X = winPtr hi -; ===================================================================== -TBoxCloseWindow: - pha ; winPtr lo - phx ; winPtr hi +; OpenPort(GrafPortPtr) -> void +; tool 0x1804, set 0x04 (QuickDraw) + .globl OpenPort +OpenPort: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1804 + jsl 0xe10000 + rtl + +; PaintArc(Rect, Integer, Integer) -> void +; tool 0x6304, set 0x04 (QuickDraw) + .globl PaintArc +PaintArc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ldx #0x6304 + jsl 0xe10000 + rtl + +; PaintOval(Rect) -> void +; tool 0x5904, set 0x04 (QuickDraw) + .globl PaintOval +PaintOval: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x5904 + jsl 0xe10000 + rtl + +; PaintPixels(PaintParamPtr) -> void +; tool 0x7F04, set 0x04 (QuickDraw) + .globl PaintPixels +PaintPixels: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x7F04 + jsl 0xe10000 + rtl + +; PaintPoly(Handle) -> void +; tool 0xBD04, set 0x04 (QuickDraw) + .globl PaintPoly +PaintPoly: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xBD04 + jsl 0xe10000 + rtl + +; PaintRect(Rect) -> void +; tool 0x5404, set 0x04 (QuickDraw) + .globl PaintRect +PaintRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x5404 + jsl 0xe10000 + rtl + +; PaintRgn(RegionHndl) -> void +; tool 0x7A04, set 0x04 (QuickDraw) + .globl PaintRgn +PaintRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x7A04 + jsl 0xe10000 + rtl + +; PaintRRect(Rect, Word, Word) -> void +; tool 0x5E04, set 0x04 (QuickDraw) + .globl PaintRRect +PaintRRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ldx #0x5E04 + jsl 0xe10000 + rtl + +; PPToPort(LocInfoPtr, Rect, Integer, Integer, Word) -> void +; tool 0xD604, set 0x04 (QuickDraw) + .globl PPToPort +PPToPort: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Integer, 2B) --- + lda 16, s + pha + ; --- arg3 (Integer, 2B) --- + lda 20, s + pha + ; --- arg4 (Word, 2B) --- + lda 24, s + pha + ldx #0xD604 + jsl 0xe10000 + rtl + +; Pt2Rect(Point, Point, Rect) -> void +; tool 0x5004, set 0x04 (QuickDraw) + .globl Pt2Rect +Pt2Rect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Point, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Rect, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x5004 + jsl 0xe10000 + rtl + +; PtInRect(Point, Rect) -> Boolean +; tool 0x4F04, set 0x04 (QuickDraw) + .globl PtInRect +PtInRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x4F04 + jsl 0xe10000 + pla ; result -> A + rtl + +; PtInRgn(Point, RegionHndl) -> Boolean +; tool 0x7504, set 0x04 (QuickDraw) + .globl PtInRgn +PtInRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (RegionHndl, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x7504 + jsl 0xe10000 + pla ; result -> A + rtl + +; RectInRgn(Rect, RegionHndl) -> Boolean +; tool 0x7604, set 0x04 (QuickDraw) + .globl RectInRgn +RectInRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (RegionHndl, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x7604 + jsl 0xe10000 + pla ; result -> A + rtl + +; RectRgn(RegionHndl, Rect) -> void +; tool 0x6C04, set 0x04 (QuickDraw) + .globl RectRgn +RectRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x6C04 + jsl 0xe10000 + rtl + +; RestoreBufDims(BufDimRecPtr) -> void +; tool 0xCE04, set 0x04 (QuickDraw) + .globl RestoreBufDims +RestoreBufDims: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xCE04 + jsl 0xe10000 + rtl + +; SaveBufDims(BufDimRecPtr) -> void +; tool 0xCD04, set 0x04 (QuickDraw) + .globl SaveBufDims +SaveBufDims: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xCD04 + jsl 0xe10000 + rtl + +; ScalePt(Point, Rect, Rect) -> void +; tool 0x8904, set 0x04 (QuickDraw) + .globl ScalePt +ScalePt: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Rect, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x8904 + jsl 0xe10000 + rtl + +; ScrollRect(Rect, Integer, Integer, RegionHndl) -> void +; tool 0x7E04, set 0x04 (QuickDraw) + .globl ScrollRect +ScrollRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ; --- arg3 (RegionHndl, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x7E04 + jsl 0xe10000 + rtl + +; SectRect(Rect, Rect, Rect) -> Boolean +; tool 0x4D04, set 0x04 (QuickDraw) + .globl SectRect +SectRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Rect, 4B) --- + lda 18, s + pha + lda 20, s + pha + ldx #0x4D04 + jsl 0xe10000 + pla ; result -> A + rtl + +; SectRgn(RegionHndl, RegionHndl, RegionHndl) -> void +; tool 0x7104, set 0x04 (QuickDraw) + .globl SectRgn +SectRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (RegionHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (RegionHndl, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x7104 + jsl 0xe10000 + rtl + +; SetBackPat(Pattern) -> void +; tool 0x3404, set 0x04 (QuickDraw) + .globl SetBackPat +SetBackPat: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3404 + jsl 0xe10000 + rtl + +; SetBufDims(Word, Word, Word) -> void +; tool 0xCB04, set 0x04 (QuickDraw) + .globl SetBufDims +SetBufDims: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ldx #0xCB04 + jsl 0xe10000 + rtl + +; SetCharExtra(Fixed) -> void +; tool 0xD404, set 0x04 (QuickDraw) + .globl SetCharExtra +SetCharExtra: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xD404 + jsl 0xe10000 + rtl + +; SetClip(RegionHndl) -> void +; tool 0x2404, set 0x04 (QuickDraw) + .globl SetClip +SetClip: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2404 + jsl 0xe10000 + rtl + +; SetClipHandle(RegionHndl) -> void +; tool 0xC604, set 0x04 (QuickDraw) + .globl SetClipHandle +SetClipHandle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xC604 + jsl 0xe10000 + rtl + +; SetColorEntry(Word, Word, ColorValue) -> void +; tool 0x1004, set 0x04 (QuickDraw) + .globl SetColorEntry +SetColorEntry: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (ColorValue, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1004 + jsl 0xe10000 + rtl + +; SetColorTable(Word, ColorTable) -> void +; tool 0x0E04, set 0x04 (QuickDraw) + .globl SetColorTable +SetColorTable: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (ColorTable, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x0E04 + jsl 0xe10000 + rtl + +; SetCursor(Pointer) -> void +; tool 0x8E04, set 0x04 (QuickDraw) + .globl SetCursor +SetCursor: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x8E04 + jsl 0xe10000 + rtl + +; SetEmptyRgn(RegionHndl) -> void +; tool 0x6A04, set 0x04 (QuickDraw) + .globl SetEmptyRgn +SetEmptyRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x6A04 + jsl 0xe10000 + rtl + +; SetFont(FontHndl) -> void +; tool 0x9404, set 0x04 (QuickDraw) + .globl SetFont +SetFont: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x9404 + jsl 0xe10000 + rtl + +; SetFontID(FontID) -> void +; tool 0xD004, set 0x04 (QuickDraw) + .globl SetFontID +SetFontID: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xD004 + jsl 0xe10000 + rtl + +; SetGrafProcs(QDProcsPtr) -> void +; tool 0x4404, set 0x04 (QuickDraw) + .globl SetGrafProcs +SetGrafProcs: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x4404 + jsl 0xe10000 + rtl + +; SetOrigin(Integer, Integer) -> void +; tool 0x2304, set 0x04 (QuickDraw) + .globl SetOrigin +SetOrigin: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ldx #0x2304 + jsl 0xe10000 + rtl + +; SetPenMask(Mask) -> void +; tool 0x3204, set 0x04 (QuickDraw) + .globl SetPenMask +SetPenMask: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3204 + jsl 0xe10000 + rtl + +; SetPenPat(Pattern) -> void +; tool 0x3004, set 0x04 (QuickDraw) + .globl SetPenPat +SetPenPat: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3004 + jsl 0xe10000 + rtl + +; SetPenSize(Word, Word) -> void +; tool 0x2C04, set 0x04 (QuickDraw) + .globl SetPenSize +SetPenSize: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x2C04 + jsl 0xe10000 + rtl + +; SetPenState(PenStatePtr) -> void +; tool 0x2A04, set 0x04 (QuickDraw) + .globl SetPenState +SetPenState: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2A04 + jsl 0xe10000 + rtl + +; SetPicSave(Longint) -> void +; tool 0x3E04, set 0x04 (QuickDraw) + .globl SetPicSave +SetPicSave: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3E04 + jsl 0xe10000 + rtl + +; SetPolySave(Longint) -> void +; tool 0x4204, set 0x04 (QuickDraw) + .globl SetPolySave +SetPolySave: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x4204 + jsl 0xe10000 + rtl + +; SetPort(GrafPortPtr) -> void +; tool 0x1B04, set 0x04 (QuickDraw) + .globl SetPort +SetPort: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1B04 + jsl 0xe10000 + rtl + +; SetPortLoc(LocInfoPtr) -> void +; tool 0x1D04, set 0x04 (QuickDraw) + .globl SetPortLoc +SetPortLoc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1D04 + jsl 0xe10000 + rtl + +; SetPortRect(Rect) -> void +; tool 0x1F04, set 0x04 (QuickDraw) + .globl SetPortRect +SetPortRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1F04 + jsl 0xe10000 + rtl + +; SetPortSize(Word, Word) -> void +; tool 0x2104, set 0x04 (QuickDraw) + .globl SetPortSize +SetPortSize: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x2104 + jsl 0xe10000 + rtl + +; SetPt(Point, Integer, Integer) -> void +; tool 0x8204, set 0x04 (QuickDraw) + .globl SetPt +SetPt: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ldx #0x8204 + jsl 0xe10000 + rtl + +; SetRandSeed(Longint) -> void +; tool 0x8704, set 0x04 (QuickDraw) + .globl SetRandSeed +SetRandSeed: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x8704 + jsl 0xe10000 + rtl + +; SetRect(Rect, Integer, Integer, Integer, Integer) -> void +; tool 0x4A04, set 0x04 (QuickDraw) + .globl SetRect +SetRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ; --- arg3 (Integer, 2B) --- + lda 16, s + pha + ; --- arg4 (Integer, 2B) --- + lda 20, s + pha + ldx #0x4A04 + jsl 0xe10000 + rtl + +; SetRectRgn(RegionHndl, Integer, Integer, Integer, Integer) -> void +; tool 0x6B04, set 0x04 (QuickDraw) + .globl SetRectRgn +SetRectRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (Integer, 2B) --- + lda 12, s + pha + ; --- arg3 (Integer, 2B) --- + lda 16, s + pha + ; --- arg4 (Integer, 2B) --- + lda 20, s + pha + ldx #0x6B04 + jsl 0xe10000 + rtl + +; SetRgnSave(Handle) -> void +; tool 0x4004, set 0x04 (QuickDraw) + .globl SetRgnSave +SetRgnSave: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x4004 + jsl 0xe10000 + rtl + +; SetSCB(Word, Word) -> void +; tool 0x1204, set 0x04 (QuickDraw) + .globl SetSCB +SetSCB: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x1204 + jsl 0xe10000 + rtl + +; SetSpaceExtra(Fixed) -> void +; tool 0x9E04, set 0x04 (QuickDraw) + .globl SetSpaceExtra +SetSpaceExtra: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x9E04 + jsl 0xe10000 + rtl + +; SetStdProcs(QDProcsPtr) -> void +; tool 0x8D04, set 0x04 (QuickDraw) + .globl SetStdProcs +SetStdProcs: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x8D04 + jsl 0xe10000 + rtl + +; SetSysField(Longint) -> void +; tool 0x4804, set 0x04 (QuickDraw) + .globl SetSysField +SetSysField: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x4804 + jsl 0xe10000 + rtl + +; SetSysFont(FontHndl) -> void +; tool 0xB204, set 0x04 (QuickDraw) + .globl SetSysFont +SetSysFont: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xB204 + jsl 0xe10000 + rtl + +; SetTextFace(TextStyle) -> void +; tool 0x9A04, set 0x04 (QuickDraw) + .globl SetTextFace +SetTextFace: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x9A04 + jsl 0xe10000 + rtl + +; SetUserField(Longint) -> void +; tool 0x4604, set 0x04 (QuickDraw) + .globl SetUserField +SetUserField: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x4604 + jsl 0xe10000 + rtl + +; SetVisHandle(RegionHndl) -> void +; tool 0xC804, set 0x04 (QuickDraw) + .globl SetVisHandle +SetVisHandle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xC804 + jsl 0xe10000 + rtl + +; SetVisRgn(RegionHndl) -> void +; tool 0xB404, set 0x04 (QuickDraw) + .globl SetVisRgn +SetVisRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xB404 + jsl 0xe10000 + rtl + +; SolidPattern(Word, Pattern) -> void +; tool 0x3904, set 0x04 (QuickDraw) + .globl SolidPattern +SolidPattern: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pattern, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x3904 + jsl 0xe10000 + rtl + +; StringBounds(Pointer, Rect) -> void +; tool 0xAD04, set 0x04 (QuickDraw) + .globl StringBounds +StringBounds: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0xAD04 + jsl 0xe10000 + rtl + +; StringWidth(Pointer) -> Word +; tool 0xA904, set 0x04 (QuickDraw) + .globl StringWidth +StringWidth: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0xA904 + jsl 0xe10000 + pla ; result -> A + rtl + +; SubPt(Point, Point) -> void +; tool 0x8104, set 0x04 (QuickDraw) + .globl SubPt +SubPt: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Point, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x8104 + jsl 0xe10000 + rtl + +; TextBounds(Pointer, Word, Rect) -> void +; tool 0xAF04, set 0x04 (QuickDraw) + .globl TextBounds +TextBounds: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Rect, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0xAF04 + jsl 0xe10000 + rtl + +; TextWidth(Pointer, Word) -> Word +; tool 0xAB04, set 0x04 (QuickDraw) + .globl TextWidth +TextWidth: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0xAB04 + jsl 0xe10000 + pla ; result -> A + rtl + +; UnionRect(Rect, Rect, Rect) -> void +; tool 0x4E04, set 0x04 (QuickDraw) + .globl UnionRect +UnionRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Rect, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Rect, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x4E04 + jsl 0xe10000 + rtl + +; UnionRgn(RegionHndl, RegionHndl, RegionHndl) -> void +; tool 0x7204, set 0x04 (QuickDraw) + .globl UnionRgn +UnionRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (RegionHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (RegionHndl, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x7204 + jsl 0xe10000 + rtl + +; XorRgn(RegionHndl, RegionHndl, RegionHndl) -> void +; tool 0x7404, set 0x04 (QuickDraw) + .globl XorRgn +XorRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (RegionHndl, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (RegionHndl, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x7404 + jsl 0xe10000 + rtl + +; Get640Colors(void) -> PatternPtr +; tool 0xDA04, set 0x04 (QuickDraw) + .globl Get640Colors +Get640Colors: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0xDA04 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; AddResource(Handle, Word, Word, Long) -> void +; tool 0x0C1E, set 0x1E (ResourceManager) + .globl AddResource +AddResource: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ; --- arg3 (Long, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x0C1E + jsl 0xe10000 + rtl + +; CountResources(Word) -> LongWord +; tool 0x221E, set 0x1E (ResourceManager) + .globl CountResources +CountResources: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x221E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; CreateResourceFile(Long, Word, Word, Pointer) -> void +; tool 0x091E, set 0x1E (ResourceManager) + .globl CreateResourceFile +CreateResourceFile: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ; --- arg3 (Pointer, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x091E + jsl 0xe10000 + rtl + +; DetachResource(Word, Long) -> void +; tool 0x181E, set 0x1E (ResourceManager) + .globl DetachResource +DetachResource: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x181E + jsl 0xe10000 + rtl + +; GetIndResource(Word, Long) -> ResID +; tool 0x231E, set 0x1E (ResourceManager) + .globl GetIndResource +GetIndResource: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x231E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetIndType(Word) -> ResType +; tool 0x211E, set 0x1E (ResourceManager) + .globl GetIndType +GetIndType: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x211E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetMapHandle(Word) -> ResMapHndl +; tool 0x261E, set 0x1E (ResourceManager) + .globl GetMapHandle +GetMapHandle: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x261E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetResourceAttr(Word, Long) -> ResAttr +; tool 0x1B1E, set 0x1E (ResourceManager) + .globl GetResourceAttr +GetResourceAttr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1B1E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetResourceSize(Word, Long) -> LongWord +; tool 0x1D1E, set 0x1E (ResourceManager) + .globl GetResourceSize +GetResourceSize: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1D1E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; HomeResourceFile(Word, Long) -> Word +; tool 0x151E, set 0x1E (ResourceManager) + .globl HomeResourceFile +HomeResourceFile: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x151E + jsl 0xe10000 + pla ; result -> A + rtl + +; LoadAbsResource(Pointer, Long, Word, Long) -> LongWord +; tool 0x271E, set 0x1E (ResourceManager) + .globl LoadAbsResource +LoadAbsResource: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg2 (Word, 2B) --- + lda 20, s + pha + ; --- arg3 (Long, 4B) --- + lda 24, s + pha + lda 26, s + pha + ldx #0x271E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; LoadResource(Word, Long) -> Handle +; tool 0x0E1E, set 0x1E (ResourceManager) + .globl LoadResource +LoadResource: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x0E1E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MarkResourceChange(Word, Word, Long) -> void +; tool 0x101E, set 0x1E (ResourceManager) + .globl MarkResourceChange +MarkResourceChange: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x101E + jsl 0xe10000 + rtl + +; MatchResourceHandle(Pointer, Handle) -> void +; tool 0x1E1E, set 0x1E (ResourceManager) + .globl MatchResourceHandle +MatchResourceHandle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1E1E + jsl 0xe10000 + rtl + +; OpenResourceFile(Word, Pointer, Pointer) -> Word +; tool 0x0A1E, set 0x1E (ResourceManager) + .globl OpenResourceFile +OpenResourceFile: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x0A1E + jsl 0xe10000 + pla ; result -> A + rtl + +; ReleaseResource(Word, Word, Long) -> void +; tool 0x171E, set 0x1E (ResourceManager) + .globl ReleaseResource +ReleaseResource: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x171E + jsl 0xe10000 + rtl + +; RemoveResource(Word, Long) -> void +; tool 0x0F1E, set 0x1E (ResourceManager) + .globl RemoveResource +RemoveResource: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x0F1E + jsl 0xe10000 + rtl + +; ResourceConverter(Pointer, Word, Word) -> void +; tool 0x281E, set 0x1E (ResourceManager) + .globl ResourceConverter +ResourceConverter: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ldx #0x281E + jsl 0xe10000 + rtl + +; SetResourceAttr(Word, Word, Long) -> void +; tool 0x1C1E, set 0x1E (ResourceManager) + .globl SetResourceAttr +SetResourceAttr: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Long, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1C1E + jsl 0xe10000 + rtl + +; SetResourceID(Long, Word, Long) -> void +; tool 0x1A1E, set 0x1E (ResourceManager) + .globl SetResourceID +SetResourceID: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Long, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x1A1E + jsl 0xe10000 + rtl + +; UniqueResourceID(Word, Word) -> ResID +; tool 0x191E, set 0x1E (ResourceManager) + .globl UniqueResourceID +UniqueResourceID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x191E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; WriteResource(Word, Long) -> void +; tool 0x161E, set 0x1E (ResourceManager) + .globl WriteResource +WriteResource: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x161E + jsl 0xe10000 + rtl + +; LoadResource2(Word, Ptr, Word, Long) -> Handle +; tool 0x291E, set 0x1E (ResourceManager) + .globl LoadResource2 +LoadResource2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Word, 2B) --- + lda 18, s + pha + ; --- arg3 (Long, 4B) --- + lda 22, s + pha + lda 24, s + pha + ldx #0x291E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; RMFindNamedResource(Word, Ptr, Word) -> LongWord +; tool 0x2A1E, set 0x1E (ResourceManager) + .globl RMFindNamedResource +RMFindNamedResource: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Word, 2B) --- + lda 18, s + pha + ldx #0x2A1E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; RMGetResourceName(Word, Long, Ptr) -> void +; tool 0x2B1E, set 0x1E (ResourceManager) + .globl RMGetResourceName +RMGetResourceName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Ptr, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x2B1E + jsl 0xe10000 + rtl + +; RMLoadNamedResource(Word, Ptr) -> Handle +; tool 0x2C1E, set 0x1E (ResourceManager) + .globl RMLoadNamedResource +RMLoadNamedResource: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x2C1E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; RMSetResourceName(Word, Long, Ptr) -> void +; tool 0x2D1E, set 0x1E (ResourceManager) + .globl RMSetResourceName +RMSetResourceName: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Ptr, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x2D1E + jsl 0xe10000 + rtl + +; OpenResourceFileByID(Word, Word) -> Word +; tool 0x2E1E, set 0x1E (ResourceManager) + .globl OpenResourceFileByID +OpenResourceFileByID: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x2E1E + jsl 0xe10000 + pla ; result -> A + rtl + +; CompactResourceFile(Word, Word) -> void +; tool 0x2F1E, set 0x1E (ResourceManager) + .globl CompactResourceFile +CompactResourceFile: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x2F1E + jsl 0xe10000 + rtl + +; SchAddTask(VoidProcPtr) -> Boolean +; tool 0x0907, set 0x07 (Scheduler) + .globl SchAddTask +SchAddTask: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0907 + jsl 0xe10000 + pla ; result -> A + rtl + +; GetScrap(Handle, Word) -> void +; tool 0x0D16, set 0x16 (ScrapManager) + .globl GetScrap +GetScrap: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ldx #0x0D16 + jsl 0xe10000 + rtl + +; GetScrapHandle(Word) -> handle +; tool 0x0E16, set 0x16 (ScrapManager) + .globl GetScrapHandle +GetScrapHandle: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0E16 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetScrapPath(void) -> Pointer +; tool 0x1016, set 0x16 (ScrapManager) + .globl GetScrapPath +GetScrapPath: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x1016 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetScrapSize(Word) -> LongWord +; tool 0x0F16, set 0x16 (ScrapManager) + .globl GetScrapSize +GetScrapSize: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0F16 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PutScrap(LongWord, Word, Pointer) -> void +; tool 0x0C16, set 0x16 (ScrapManager) + .globl PutScrap +PutScrap: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0C16 + jsl 0xe10000 + rtl + +; SetScrapPath(Pointer) -> void +; tool 0x1116, set 0x16 (ScrapManager) + .globl SetScrapPath +SetScrapPath: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1116 + jsl 0xe10000 + rtl + +; GetIndScrap(Word, Ptr) -> void +; tool 0x1416, set 0x16 (ScrapManager) + .globl GetIndScrap +GetIndScrap: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ptr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x1416 + jsl 0xe10000 + rtl + +; ShowClipboard(Word, Rect) -> GrafPortPtr +; tool 0x1516, set 0x16 (ScrapManager) + .globl ShowClipboard +ShowClipboard: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Rect, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1516 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FFStartSound(Word, Pointer) -> void +; tool 0x0E08, set 0x08 (SoundManager) + .globl FFStartSound +FFStartSound: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x0E08 + jsl 0xe10000 + rtl + +; GetTableAddress(void) -> Pointer +; tool 0x0B08, set 0x08 (SoundManager) + .globl GetTableAddress +GetTableAddress: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0B08 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ReadRamBlock(Pointer, Word, Word) -> void +; tool 0x0A08, set 0x08 (SoundManager) + .globl ReadRamBlock +ReadRamBlock: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ldx #0x0A08 + jsl 0xe10000 + rtl + +; SetSoundMIRQV(VoidProcPtr) -> void +; tool 0x1208, set 0x08 (SoundManager) + .globl SetSoundMIRQV +SetSoundMIRQV: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1208 + jsl 0xe10000 + rtl + +; SetSoundVolume(Word, Word) -> void +; tool 0x0D08, set 0x08 (SoundManager) + .globl SetSoundVolume +SetSoundVolume: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0D08 + jsl 0xe10000 + rtl + +; SetUserSoundIRQV(VoidProcPtr) -> ProcPtr +; tool 0x1308, set 0x08 (SoundManager) + .globl SetUserSoundIRQV +SetUserSoundIRQV: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1308 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; WriteRamBlock(Pointer, Word, Word) -> void +; tool 0x0908, set 0x08 (SoundManager) + .globl WriteRamBlock +WriteRamBlock: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ldx #0x0908 + jsl 0xe10000 + rtl + +; FFSetUpSound(Word, Pointer) -> void +; tool 0x1508, set 0x08 (SoundManager) + .globl FFSetUpSound +FFSetUpSound: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x1508 + jsl 0xe10000 + rtl + +; ReadDOCReg(Pointer) -> void +; tool 0x1808, set 0x08 (SoundManager) + .globl ReadDOCReg +ReadDOCReg: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1808 + jsl 0xe10000 + rtl + +; SetDOCReg(Pointer) -> void +; tool 0x1708, set 0x08 (SoundManager) + .globl SetDOCReg +SetDOCReg: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1708 + jsl 0xe10000 + rtl + +; SFStartUp(Word, Word) -> void +; tool 0x0217, set 0x17 (StandardFile) + .globl SFStartUp +SFStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0217 + jsl 0xe10000 + rtl + +; SFGetFile(Integer, Integer, Pointer, WordProcPtr, Pointer, SFReplyRecPtr) -> void +; tool 0x0917, set 0x17 (StandardFile) + .globl SFGetFile +SFGetFile: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg3 (WordProcPtr, 4B) --- + lda 18, s + pha + lda 20, s + pha + ; --- arg4 (Pointer, 4B) --- + lda 26, s + pha + lda 28, s + pha + ; --- arg5 (SFReplyRecPtr, 4B) --- + lda 34, s + pha + lda 36, s + pha + ldx #0x0917 + jsl 0xe10000 + rtl + +; SFPGetFile(Integer, Integer, Pointer, WordProcPtr, Pointer, Pointer, VoidProcPtr, SFReplyRecPtr) -> void +; tool 0x0B17, set 0x17 (StandardFile) + .globl SFPGetFile +SFPGetFile: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg3 (WordProcPtr, 4B) --- + lda 18, s + pha + lda 20, s + pha + ; --- arg4 (Pointer, 4B) --- + lda 26, s + pha + lda 28, s + pha + ; --- arg5 (Pointer, 4B) --- + lda 34, s + pha + lda 36, s + pha + ; --- arg6 (VoidProcPtr, 4B) --- + lda 42, s + pha + lda 44, s + pha + ; --- arg7 (SFReplyRecPtr, 4B) --- + lda 50, s + pha + lda 52, s + pha + ldx #0x0B17 + jsl 0xe10000 + rtl + +; SFPPutFile(Integer, Integer, Pointer, Pointer, Word, Pointer, VoidProcPtr, SFReplyRecPtr) -> void +; tool 0x0C17, set 0x17 (StandardFile) + .globl SFPPutFile +SFPPutFile: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg3 (Pointer, 4B) --- + lda 18, s + pha + lda 20, s + pha + ; --- arg4 (Word, 2B) --- + lda 26, s + pha + ; --- arg5 (Pointer, 4B) --- + lda 30, s + pha + lda 32, s + pha + ; --- arg6 (VoidProcPtr, 4B) --- + lda 38, s + pha + lda 40, s + pha + ; --- arg7 (SFReplyRecPtr, 4B) --- + lda 46, s + pha + lda 48, s + pha + ldx #0x0C17 + jsl 0xe10000 + rtl + +; SFPutFile(Integer, Integer, Pointer, Pointer, Word, SFReplyRecPtr) -> void +; tool 0x0A17, set 0x17 (StandardFile) + .globl SFPutFile +SFPutFile: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg3 (Pointer, 4B) --- + lda 18, s + pha + lda 20, s + pha + ; --- arg4 (Word, 2B) --- + lda 26, s + pha + ; --- arg5 (SFReplyRecPtr, 4B) --- + lda 30, s + pha + lda 32, s + pha + ldx #0x0A17 + jsl 0xe10000 + rtl + +; SFGetFile2(Integer, Integer, Word, Ref, WordProcPtr, SFTypeList2Ptr, SFReplyRec2Ptr) -> void +; tool 0x0E17, set 0x17 (StandardFile) + .globl SFGetFile2 +SFGetFile2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ; --- arg3 (Ref, 4B) --- + lda 14, s + pha + lda 16, s + pha + ; --- arg4 (WordProcPtr, 4B) --- + lda 22, s + pha + lda 24, s + pha + ; --- arg5 (SFTypeList2Ptr, 4B) --- + lda 30, s + pha + lda 32, s + pha + ; --- arg6 (SFReplyRec2Ptr, 4B) --- + lda 38, s + pha + lda 40, s + pha + ldx #0x0E17 + jsl 0xe10000 + rtl + +; SFMultiGet2(Integer, Integer, Word, Ref, WordProcPtr, SFTypeList2Ptr, MultiReplyPtr) -> void +; tool 0x1417, set 0x17 (StandardFile) + .globl SFMultiGet2 +SFMultiGet2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ; --- arg3 (Ref, 4B) --- + lda 14, s + pha + lda 16, s + pha + ; --- arg4 (WordProcPtr, 4B) --- + lda 22, s + pha + lda 24, s + pha + ; --- arg5 (SFTypeList2Ptr, 4B) --- + lda 30, s + pha + lda 32, s + pha + ; --- arg6 (MultiReplyPtr, 4B) --- + lda 38, s + pha + lda 40, s + pha + ldx #0x1417 + jsl 0xe10000 + rtl + +; SFPGetFile2(Integer, Integer, VoidProcPtr, Word, Ref, WordProcPtr, SFTypeList2Ptr, Pointer, VoidProcPtr, SFReplyRec2Ptr) -> void +; tool 0x1017, set 0x17 (StandardFile) + .globl SFPGetFile2 +SFPGetFile2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (VoidProcPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg3 (Word, 2B) --- + lda 18, s + pha + ; --- arg4 (Ref, 4B) --- + lda 22, s + pha + lda 24, s + pha + ; --- arg5 (WordProcPtr, 4B) --- + lda 30, s + pha + lda 32, s + pha + ; --- arg6 (SFTypeList2Ptr, 4B) --- + lda 38, s + pha + lda 40, s + pha + ; --- arg7 (Pointer, 4B) --- + lda 46, s + pha + lda 48, s + pha + ; --- arg8 (VoidProcPtr, 4B) --- + lda 54, s + pha + lda 56, s + pha + ; --- arg9 (SFReplyRec2Ptr, 4B) --- + lda 62, s + pha + lda 64, s + pha + ldx #0x1017 + jsl 0xe10000 + rtl + +; SFPMultiGet2(Integer, Integer, VoidProcPtr, Word, Ref, WordProcPtr, SFTypeList2Ptr, Pointer, VoidProcPtr, MultiReplyPtr) -> void +; tool 0x1517, set 0x17 (StandardFile) + .globl SFPMultiGet2 +SFPMultiGet2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (VoidProcPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg3 (Word, 2B) --- + lda 18, s + pha + ; --- arg4 (Ref, 4B) --- + lda 22, s + pha + lda 24, s + pha + ; --- arg5 (WordProcPtr, 4B) --- + lda 30, s + pha + lda 32, s + pha + ; --- arg6 (SFTypeList2Ptr, 4B) --- + lda 38, s + pha + lda 40, s + pha + ; --- arg7 (Pointer, 4B) --- + lda 46, s + pha + lda 48, s + pha + ; --- arg8 (VoidProcPtr, 4B) --- + lda 54, s + pha + lda 56, s + pha + ; --- arg9 (MultiReplyPtr, 4B) --- + lda 62, s + pha + lda 64, s + pha + ldx #0x1517 + jsl 0xe10000 + rtl + +; SFPPutFile2(Integer, Integer, VoidProcPtr, Word, Ref, Word, Ref, Pointer, VoidProcPtr, SFReplyRec2Ptr) -> void +; tool 0x1117, set 0x17 (StandardFile) + .globl SFPPutFile2 +SFPPutFile2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (VoidProcPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg3 (Word, 2B) --- + lda 18, s + pha + ; --- arg4 (Ref, 4B) --- + lda 22, s + pha + lda 24, s + pha + ; --- arg5 (Word, 2B) --- + lda 30, s + pha + ; --- arg6 (Ref, 4B) --- + lda 34, s + pha + lda 36, s + pha + ; --- arg7 (Pointer, 4B) --- + lda 42, s + pha + lda 44, s + pha + ; --- arg8 (VoidProcPtr, 4B) --- + lda 50, s + pha + lda 52, s + pha + ; --- arg9 (SFReplyRec2Ptr, 4B) --- + lda 58, s + pha + lda 60, s + pha + ldx #0x1117 + jsl 0xe10000 + rtl + +; SFPutFile2(Integer, Integer, Word, Ref, Word, Ref, SFReplyRec2Ptr) -> void +; tool 0x0F17, set 0x17 (StandardFile) + .globl SFPutFile2 +SFPutFile2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ; --- arg3 (Ref, 4B) --- + lda 14, s + pha + lda 16, s + pha + ; --- arg4 (Word, 2B) --- + lda 22, s + pha + ; --- arg5 (Ref, 4B) --- + lda 26, s + pha + lda 28, s + pha + ; --- arg6 (SFReplyRec2Ptr, 4B) --- + lda 34, s + pha + lda 36, s + pha + ldx #0x0F17 + jsl 0xe10000 + rtl + +; SFReScan(WordProcPtr, SFTypeList2Ptr) -> void +; tool 0x1317, set 0x17 (StandardFile) + .globl SFReScan +SFReScan: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (SFTypeList2Ptr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1317 + jsl 0xe10000 + rtl + +; TEStartUp(Word, Word) -> void +; tool 0x0222, set 0x22 (TextEdit) + .globl TEStartUp +TEStartUp: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0222 + jsl 0xe10000 + rtl + +; TEActivate(Handle) -> void +; tool 0x0F22, set 0x22 (TextEdit) + .globl TEActivate +TEActivate: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0F22 + jsl 0xe10000 + rtl + +; TEClear(Handle) -> void +; tool 0x1922, set 0x22 (TextEdit) + .globl TEClear +TEClear: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1922 + jsl 0xe10000 + rtl + +; TEClick(EventRecordPtr, Handle) -> void +; tool 0x1122, set 0x22 (TextEdit) + .globl TEClick +TEClick: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1122 + jsl 0xe10000 + rtl + +; TECompactRecord(Handle) -> void +; tool 0x2822, set 0x22 (TextEdit) + .globl TECompactRecord +TECompactRecord: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2822 + jsl 0xe10000 + rtl + +; TECopy(Handle) -> void +; tool 0x1722, set 0x22 (TextEdit) + .globl TECopy +TECopy: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1722 + jsl 0xe10000 + rtl + +; TECut(Handle) -> void +; tool 0x1622, set 0x22 (TextEdit) + .globl TECut +TECut: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1622 + jsl 0xe10000 + rtl + +; TEDeactivate(Handle) -> void +; tool 0x1022, set 0x22 (TextEdit) + .globl TEDeactivate +TEDeactivate: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1022 + jsl 0xe10000 + rtl + +; TEGetDefProc(void) -> ProcPtr +; tool 0x2222, set 0x22 (TextEdit) + .globl TEGetDefProc +TEGetDefProc: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2222 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; TEGetInternalProc(void) -> ProcPtr +; tool 0x2622, set 0x22 (TextEdit) + .globl TEGetInternalProc +TEGetInternalProc: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x2622 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; TEGetLastError(Word, Handle) -> Word +; tool 0x2722, set 0x22 (TextEdit) + .globl TEGetLastError +TEGetLastError: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x2722 + jsl 0xe10000 + pla ; result -> A + rtl + +; TEGetRuler(Word, Ref, Handle) -> void +; tool 0x2322, set 0x22 (TextEdit) + .globl TEGetRuler +TEGetRuler: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Handle, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x2322 + jsl 0xe10000 + rtl + +; TEGetSelection(Pointer, Pointer, Handle) -> void +; tool 0x1C22, set 0x22 (TextEdit) + .globl TEGetSelection +TEGetSelection: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Handle, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x1C22 + jsl 0xe10000 + rtl + +; TEGetSelectionStyle(TEStylePtr, Handle, Handle) -> Word +; tool 0x1E22, set 0x22 (TextEdit) + .globl TEGetSelectionStyle +TEGetSelectionStyle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Handle, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Handle, 4B) --- + lda 18, s + pha + lda 20, s + pha + ldx #0x1E22 + jsl 0xe10000 + pla ; result -> A + rtl + +; TEGetText(Word, Ref, Long, Word, Ref, Handle) -> LongWord +; tool 0x0C22, set 0x22 (TextEdit) + .globl TEGetText +TEGetText: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Long, 4B) --- + lda 18, s + pha + lda 20, s + pha + ; --- arg3 (Word, 2B) --- + lda 26, s + pha + ; --- arg4 (Ref, 4B) --- + lda 30, s + pha + lda 32, s + pha + ; --- arg5 (Handle, 4B) --- + lda 38, s + pha + lda 40, s + pha + ldx #0x0C22 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; TEGetTextInfo(Pointer, Word, Handle) -> void +; tool 0x0D22, set 0x22 (TextEdit) + .globl TEGetTextInfo +TEGetTextInfo: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Handle, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x0D22 + jsl 0xe10000 + rtl + +; TEIdle(Handle) -> void +; tool 0x0E22, set 0x22 (TextEdit) + .globl TEIdle +TEIdle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0E22 + jsl 0xe10000 + rtl + +; TEInsert(Word, Ref, Long, Word, Ref, Handle) -> void +; tool 0x1A22, set 0x22 (TextEdit) + .globl TEInsert +TEInsert: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Long, 4B) --- + lda 14, s + pha + lda 16, s + pha + ; --- arg3 (Word, 2B) --- + lda 22, s + pha + ; --- arg4 (Ref, 4B) --- + lda 26, s + pha + lda 28, s + pha + ; --- arg5 (Handle, 4B) --- + lda 34, s + pha + lda 36, s + pha + ldx #0x1A22 + jsl 0xe10000 + rtl + +; TEKey(EventRecordPtr, Handle) -> void +; tool 0x1422, set 0x22 (TextEdit) + .globl TEKey +TEKey: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Handle, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1422 + jsl 0xe10000 + rtl + +; TEKill(Handle) -> void +; tool 0x0A22, set 0x22 (TextEdit) + .globl TEKill +TEKill: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0A22 + jsl 0xe10000 + rtl + +; TENew(TEParamBlockPtr) -> TERecordHndl +; tool 0x0922, set 0x22 (TextEdit) + .globl TENew +TENew: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0922 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; TEOffsetToPoint(Long, Long, Long, Handle) -> void +; tool 0x2022, set 0x22 (TextEdit) + .globl TEOffsetToPoint +TEOffsetToPoint: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Long, 4B) --- + lda 16, s + pha + lda 18, s + pha + ; --- arg3 (Handle, 4B) --- + lda 24, s + pha + lda 26, s + pha + ldx #0x2022 + jsl 0xe10000 + rtl + +; TEPaintText(GrafPortPtr, Long, Rect, Word, Handle) -> LongWord +; tool 0x1322, set 0x22 (TextEdit) + .globl TEPaintText +TEPaintText: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg2 (Rect, 4B) --- + lda 20, s + pha + lda 22, s + pha + ; --- arg3 (Word, 2B) --- + lda 28, s + pha + ; --- arg4 (Handle, 4B) --- + lda 32, s + pha + lda 34, s + pha + ldx #0x1322 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; TEPaste(Handle) -> void +; tool 0x1822, set 0x22 (TextEdit) + .globl TEPaste +TEPaste: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1822 + jsl 0xe10000 + rtl + +; TEPointToOffset(Long, Long, Handle) -> LongWord +; tool 0x2122, set 0x22 (TextEdit) + .globl TEPointToOffset +TEPointToOffset: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg2 (Handle, 4B) --- + lda 20, s + pha + lda 22, s + pha + ldx #0x2122 + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; TEReplace(Word, Ref, Long, Word, Ref, Handle) -> void +; tool 0x1B22, set 0x22 (TextEdit) + .globl TEReplace +TEReplace: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Long, 4B) --- + lda 14, s + pha + lda 16, s + pha + ; --- arg3 (Word, 2B) --- + lda 22, s + pha + ; --- arg4 (Ref, 4B) --- + lda 26, s + pha + lda 28, s + pha + ; --- arg5 (Handle, 4B) --- + lda 34, s + pha + lda 36, s + pha + ldx #0x1B22 + jsl 0xe10000 + rtl + +; TEScroll(Word, Long, Long, Handle) -> void +; tool 0x2522, set 0x22 (TextEdit) + .globl TEScroll +TEScroll: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Long, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Long, 4B) --- + lda 14, s + pha + lda 16, s + pha + ; --- arg3 (Handle, 4B) --- + lda 22, s + pha + lda 24, s + pha + ldx #0x2522 + jsl 0xe10000 + rtl + +; TESetRuler(Word, Ref, Handle) -> void +; tool 0x2422, set 0x22 (TextEdit) + .globl TESetRuler +TESetRuler: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Handle, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x2422 + jsl 0xe10000 + rtl + +; TESetSelection(Pointer, Pointer, Handle) -> void +; tool 0x1D22, set 0x22 (TextEdit) + .globl TESetSelection +TESetSelection: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Handle, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x1D22 + jsl 0xe10000 + rtl + +; TESetText(Word, Ref, Long, Word, Ref, Handle) -> void +; tool 0x0B22, set 0x22 (TextEdit) + .globl TESetText +TESetText: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Ref, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Long, 4B) --- + lda 14, s + pha + lda 16, s + pha + ; --- arg3 (Word, 2B) --- + lda 22, s + pha + ; --- arg4 (Ref, 4B) --- + lda 26, s + pha + lda 28, s + pha + ; --- arg5 (Handle, 4B) --- + lda 34, s + pha + lda 36, s + pha + ldx #0x0B22 + jsl 0xe10000 + rtl + +; TEStyleChange(Word, TEStylePtr, Handle) -> void +; tool 0x1F22, set 0x22 (TextEdit) + .globl TEStyleChange +TEStyleChange: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (TEStylePtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (Handle, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x1F22 + jsl 0xe10000 + rtl + +; TEUpdate(Handle) -> void +; tool 0x1222, set 0x22 (TextEdit) + .globl TEUpdate +TEUpdate: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1222 + jsl 0xe10000 + rtl + +; CtlTextDev(Word, Word) -> void +; tool 0x160C, set 0x0C (TextTools) + .globl CtlTextDev +CtlTextDev: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x160C + jsl 0xe10000 + rtl + +; ErrWriteBlock(Pointer, Word, Word) -> void +; tool 0x1F0C, set 0x0C (TextTools) + .globl ErrWriteBlock +ErrWriteBlock: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ldx #0x1F0C + jsl 0xe10000 + rtl + +; ErrWriteCString(Pointer) -> void +; tool 0x210C, set 0x0C (TextTools) + .globl ErrWriteCString +ErrWriteCString: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x210C + jsl 0xe10000 + rtl + +; ErrWriteLine(Pointer) -> void +; tool 0x1B0C, set 0x0C (TextTools) + .globl ErrWriteLine +ErrWriteLine: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1B0C + jsl 0xe10000 + rtl + +; ErrWriteString(Pointer) -> void +; tool 0x1D0C, set 0x0C (TextTools) + .globl ErrWriteString +ErrWriteString: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1D0C + jsl 0xe10000 + rtl + +; GetErrGlobals(void) -> Long +; tool 0x0E0C, set 0x0C (TextTools) + .globl GetErrGlobals +GetErrGlobals: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0E0C + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetInGlobals(void) -> Long +; tool 0x0C0C, set 0x0C (TextTools) + .globl GetInGlobals +GetInGlobals: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0C0C + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetOutGlobals(void) -> Long +; tool 0x0D0C, set 0x0C (TextTools) + .globl GetOutGlobals +GetOutGlobals: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x0D0C + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ReadLine(Pointer, Word, Word, Word) -> Word +; tool 0x240C, set 0x0C (TextTools) + .globl ReadLine +ReadLine: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ; --- arg2 (Word, 2B) --- + lda 14, s + pha + ; --- arg3 (Word, 2B) --- + lda 18, s + pha + ldx #0x240C + jsl 0xe10000 + pla ; result -> A + rtl + +; SetErrGlobals(Word, Word) -> void +; tool 0x0B0C, set 0x0C (TextTools) + .globl SetErrGlobals +SetErrGlobals: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0B0C + jsl 0xe10000 + rtl + +; SetErrorDevice(Word, LongWord) -> void +; tool 0x110C, set 0x0C (TextTools) + .globl SetErrorDevice +SetErrorDevice: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (LongWord, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x110C + jsl 0xe10000 + rtl + +; SetInGlobals(Word, Word) -> void +; tool 0x090C, set 0x0C (TextTools) + .globl SetInGlobals +SetInGlobals: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x090C + jsl 0xe10000 + rtl + +; SetInputDevice(Word, LongWord) -> void +; tool 0x0F0C, set 0x0C (TextTools) + .globl SetInputDevice +SetInputDevice: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (LongWord, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x0F0C + jsl 0xe10000 + rtl + +; SetOutGlobals(Word, Word) -> void +; tool 0x0A0C, set 0x0C (TextTools) + .globl SetOutGlobals +SetOutGlobals: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0A0C + jsl 0xe10000 + rtl + +; SetOutputDevice(Word, LongWord) -> void +; tool 0x100C, set 0x0C (TextTools) + .globl SetOutputDevice +SetOutputDevice: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (LongWord, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x100C + jsl 0xe10000 + rtl + +; StatusTextDev(Word, Word) -> void +; tool 0x170C, set 0x0C (TextTools) + .globl StatusTextDev +StatusTextDev: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x170C + jsl 0xe10000 + rtl + +; TextReadBlock(Pointer, Word, Word, Word) -> void +; tool 0x230C, set 0x0C (TextTools) + .globl TextReadBlock +TextReadBlock: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ; --- arg3 (Word, 2B) --- + lda 16, s + pha + ldx #0x230C + jsl 0xe10000 + rtl + +; TextWriteBlock(Pointer, Word, Word) -> void +; tool 0x1E0C, set 0x0C (TextTools) + .globl TextWriteBlock +TextWriteBlock: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Word, 2B) --- + lda 8, s + pha + ; --- arg2 (Word, 2B) --- + lda 12, s + pha + ldx #0x1E0C + jsl 0xe10000 + rtl + +; WriteCString(Pointer) -> void +; tool 0x200C, set 0x0C (TextTools) + .globl WriteCString +WriteCString: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x200C + jsl 0xe10000 + rtl + +; WriteLine(Pointer) -> void +; tool 0x1A0C, set 0x0C (TextTools) + .globl WriteLine +WriteLine: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1A0C + jsl 0xe10000 + rtl + +; WriteString(Pointer) -> void +; tool 0x1C0C, set 0x0C (TextTools) + .globl WriteString +WriteString: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1C0C + jsl 0xe10000 + rtl + +; VDGGControl(Word, Word) -> void +; tool 0x1D21, set 0x21 (Teletext) + .globl VDGGControl +VDGGControl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x1D21 + jsl 0xe10000 + rtl + +; VDInControl(Word, Word) -> void +; tool 0x1C21, set 0x21 (Teletext) + .globl VDInControl +VDInControl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x1C21 + jsl 0xe10000 + rtl + +; VDInConvAdj(Word, Word) -> void +; tool 0x0C21, set 0x21 (Teletext) + .globl VDInConvAdj +VDInConvAdj: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0C21 + jsl 0xe10000 + rtl + +; VDKeyControl(Word, Word) -> void +; tool 0x0D21, set 0x21 (Teletext) + .globl VDKeyControl +VDKeyControl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x0D21 + jsl 0xe10000 + rtl + +; VDKeySetKCol(Word, Word, Word) -> void +; tool 0x0F21, set 0x21 (Teletext) + .globl VDKeySetKCol +VDKeySetKCol: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ldx #0x0F21 + jsl 0xe10000 + rtl + +; VDOutControl(Word, Word) -> void +; tool 0x1921, set 0x21 (Teletext) + .globl VDOutControl +VDOutControl: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ldx #0x1921 + jsl 0xe10000 + rtl + +; BeginUpdate(GrafPortPtr) -> void +; tool 0x1E0E, set 0x0E (WindowManager) + .globl BeginUpdate +BeginUpdate: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1E0E + jsl 0xe10000 + rtl + +; BringToFront(GrafPortPtr) -> void +; tool 0x240E, set 0x0E (WindowManager) + .globl BringToFront +BringToFront: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x240E + jsl 0xe10000 + rtl + +; CheckUpdate(EventRecordPtr) -> Boolean +; tool 0x0A0E, set 0x0E (WindowManager) + .globl CheckUpdate +CheckUpdate: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0A0E + jsl 0xe10000 + pla ; result -> A + rtl + +; CloseWindow(GrafPortPtr) -> void +; tool 0x0B0E, set 0x0E (WindowManager) + .globl CloseWindow +CloseWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha ldx #0x0B0E jsl 0xe10000 rtl + +; Desktop(Word, LongWord) -> Pointer +; tool 0x0C0E, set 0x0E (WindowManager) + .globl Desktop +Desktop: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (LongWord, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x0C0E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; DragWindow(Word, Integer, Integer, Word, Rect, GrafPortPtr) -> void +; tool 0x1A0E, set 0x0E (WindowManager) + .globl DragWindow +DragWindow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (Integer, 2B) --- + lda 10, s + pha + ; --- arg3 (Word, 2B) --- + lda 14, s + pha + ; --- arg4 (Rect, 4B) --- + lda 18, s + pha + lda 20, s + pha + ; --- arg5 (GrafPortPtr, 4B) --- + lda 26, s + pha + lda 28, s + pha + ldx #0x1A0E + jsl 0xe10000 + rtl + +; EndUpdate(GrafPortPtr) -> void +; tool 0x1F0E, set 0x0E (WindowManager) + .globl EndUpdate +EndUpdate: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x1F0E + jsl 0xe10000 + rtl + +; FindWindow(GrafPortPtr, Integer, Integer) -> Word +; tool 0x170E, set 0x0E (WindowManager) + .globl FindWindow +FindWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 10, s + pha + ; --- arg2 (Integer, 2B) --- + lda 14, s + pha + ldx #0x170E + jsl 0xe10000 + pla ; result -> A + rtl + +; FrontWindow(void) -> WindowPtr +; tool 0x150E, set 0x0E (WindowManager) + .globl FrontWindow +FrontWindow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x150E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetContentDraw(GrafPortPtr) -> VoidProcPtr +; tool 0x480E, set 0x0E (WindowManager) + .globl GetContentDraw +GetContentDraw: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x480E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetContentOrigin(GrafPortPtr) -> Long +; tool 0x3E0E, set 0x0E (WindowManager) + .globl GetContentOrigin +GetContentOrigin: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3E0E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetContentRgn(GrafPortPtr) -> RegionHndl +; tool 0x2F0E, set 0x0E (WindowManager) + .globl GetContentRgn +GetContentRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2F0E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetDataSize(GrafPortPtr) -> LongWord +; tool 0x400E, set 0x0E (WindowManager) + .globl GetDataSize +GetDataSize: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x400E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetDefProc(GrafPortPtr) -> LongProcPtr +; tool 0x310E, set 0x0E (WindowManager) + .globl GetDefProc +GetDefProc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x310E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetFirstWindow(void) -> WindowPtr +; tool 0x520E, set 0x0E (WindowManager) + .globl GetFirstWindow +GetFirstWindow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x520E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetFrameColor(WindColorPtr, GrafPortPtr) -> void +; tool 0x100E, set 0x0E (WindowManager) + .globl GetFrameColor +GetFrameColor: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x100E + jsl 0xe10000 + rtl + +; GetInfoDraw(GrafPortPtr) -> VoidProcPtr +; tool 0x4A0E, set 0x0E (WindowManager) + .globl GetInfoDraw +GetInfoDraw: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x4A0E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetInfoRefCon(GrafPortPtr) -> LongWord +; tool 0x350E, set 0x0E (WindowManager) + .globl GetInfoRefCon +GetInfoRefCon: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x350E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetMaxGrow(GrafPortPtr) -> LongWord +; tool 0x420E, set 0x0E (WindowManager) + .globl GetMaxGrow +GetMaxGrow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x420E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetNextWindow(GrafPortPtr) -> WindowPtr +; tool 0x2A0E, set 0x0E (WindowManager) + .globl GetNextWindow +GetNextWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2A0E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetPage(GrafPortPtr) -> LongWord +; tool 0x460E, set 0x0E (WindowManager) + .globl GetPage +GetPage: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x460E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetRectInfo(Rect, GrafPortPtr) -> void +; tool 0x4F0E, set 0x0E (WindowManager) + .globl GetRectInfo +GetRectInfo: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x4F0E + jsl 0xe10000 + rtl + +; GetScroll(GrafPortPtr) -> LongWord +; tool 0x440E, set 0x0E (WindowManager) + .globl GetScroll +GetScroll: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x440E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetStructRgn(GrafPortPtr) -> RegionHndl +; tool 0x2E0E, set 0x0E (WindowManager) + .globl GetStructRgn +GetStructRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2E0E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetSysWFlag(GrafPortPtr) -> Boolean +; tool 0x4C0E, set 0x0E (WindowManager) + .globl GetSysWFlag +GetSysWFlag: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x4C0E + jsl 0xe10000 + pla ; result -> A + rtl + +; GetUpdateRgn(GrafPortPtr) -> RegionHndl +; tool 0x300E, set 0x0E (WindowManager) + .globl GetUpdateRgn +GetUpdateRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x300E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetWControls(GrafPortPtr) -> CtlRecHndl +; tool 0x330E, set 0x0E (WindowManager) + .globl GetWControls +GetWControls: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x330E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetWFrame(GrafPortPtr) -> Word +; tool 0x2C0E, set 0x0E (WindowManager) + .globl GetWFrame +GetWFrame: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2C0E + jsl 0xe10000 + pla ; result -> A + rtl + +; GetWKind(GrafPortPtr) -> Word +; tool 0x2B0E, set 0x0E (WindowManager) + .globl GetWKind +GetWKind: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x2B0E + jsl 0xe10000 + pla ; result -> A + rtl + +; GetWMgrPort(void) -> WindowPtr +; tool 0x200E, set 0x0E (WindowManager) + .globl GetWMgrPort +GetWMgrPort: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x200E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetWRefCon(GrafPortPtr) -> LongWord +; tool 0x290E, set 0x0E (WindowManager) + .globl GetWRefCon +GetWRefCon: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x290E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GetWTitle(GrafPortPtr) -> Pointer +; tool 0x0E0E, set 0x0E (WindowManager) + .globl GetWTitle +GetWTitle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x0E0E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; GrowWindow(Word, Word, Integer, Integer, GrafPortPtr) -> LongWord +; tool 0x1B0E, set 0x0E (WindowManager) + .globl GrowWindow +GrowWindow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ; --- arg2 (Integer, 2B) --- + lda 14, s + pha + ; --- arg3 (Integer, 2B) --- + lda 18, s + pha + ; --- arg4 (GrafPortPtr, 4B) --- + lda 22, s + pha + lda 24, s + pha + ldx #0x1B0E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; HideWindow(GrafPortPtr) -> void +; tool 0x120E, set 0x0E (WindowManager) + .globl HideWindow +HideWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x120E + jsl 0xe10000 + rtl + +; HiliteWindow(Boolean, GrafPortPtr) -> void +; tool 0x220E, set 0x0E (WindowManager) + .globl HiliteWindow +HiliteWindow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x220E + jsl 0xe10000 + rtl + +; InvalRect(Rect) -> void +; tool 0x3A0E, set 0x0E (WindowManager) + .globl InvalRect +InvalRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3A0E + jsl 0xe10000 + rtl + +; InvalRgn(Handle) -> void +; tool 0x3B0E, set 0x0E (WindowManager) + .globl InvalRgn +InvalRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3B0E + jsl 0xe10000 + rtl + +; MoveWindow(Integer, Integer, GrafPortPtr) -> void +; tool 0x190E, set 0x0E (WindowManager) + .globl MoveWindow +MoveWindow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 6, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x190E + jsl 0xe10000 + rtl + +; NewWindow(ParamListPtr) -> WindowPtr +; tool 0x090E, set 0x0E (WindowManager) + .globl NewWindow +NewWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x090E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; PinRect(Integer, Integer, Rect) -> Point +; tool 0x210E, set 0x0E (WindowManager) + .globl PinRect +PinRect: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 10, s + pha + ; --- arg2 (Rect, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x210E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; RefreshDesktop(Rect) -> void +; tool 0x390E, set 0x0E (WindowManager) + .globl RefreshDesktop +RefreshDesktop: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x390E + jsl 0xe10000 + rtl + +; SelectWindow(GrafPortPtr) -> void +; tool 0x110E, set 0x0E (WindowManager) + .globl SelectWindow +SelectWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x110E + jsl 0xe10000 + rtl + +; SendBehind(GrafPortPtr, GrafPortPtr) -> void +; tool 0x140E, set 0x0E (WindowManager) + .globl SendBehind +SendBehind: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x140E + jsl 0xe10000 + rtl + +; SetContentDraw(VoidProcPtr, GrafPortPtr) -> void +; tool 0x490E, set 0x0E (WindowManager) + .globl SetContentDraw +SetContentDraw: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x490E + jsl 0xe10000 + rtl + +; SetContentOrigin(Word, Word, GrafPortPtr) -> void +; tool 0x3F0E, set 0x0E (WindowManager) + .globl SetContentOrigin +SetContentOrigin: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x3F0E + jsl 0xe10000 + rtl + +; SetContentOrigin2(Word, Word, Word, GrafPortPtr) -> void +; tool 0x570E, set 0x0E (WindowManager) + .globl SetContentOrigin2 +SetContentOrigin2: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (Word, 2B) --- + lda 10, s + pha + ; --- arg3 (GrafPortPtr, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x570E + jsl 0xe10000 + rtl + +; SetDataSize(Word, Word, GrafPortPtr) -> void +; tool 0x410E, set 0x0E (WindowManager) + .globl SetDataSize +SetDataSize: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x410E + jsl 0xe10000 + rtl + +; SetDefProc(LongProcPtr, GrafPortPtr) -> void +; tool 0x320E, set 0x0E (WindowManager) + .globl SetDefProc +SetDefProc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x320E + jsl 0xe10000 + rtl + +; SetFrameColor(WindColorPtr, GrafPortPtr) -> void +; tool 0x0F0E, set 0x0E (WindowManager) + .globl SetFrameColor +SetFrameColor: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0F0E + jsl 0xe10000 + rtl + +; SetInfoDraw(VoidProcPtr, GrafPortPtr) -> void +; tool 0x160E, set 0x0E (WindowManager) + .globl SetInfoDraw +SetInfoDraw: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x160E + jsl 0xe10000 + rtl + +; SetInfoRefCon(LongWord, GrafPortPtr) -> void +; tool 0x360E, set 0x0E (WindowManager) + .globl SetInfoRefCon +SetInfoRefCon: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x360E + jsl 0xe10000 + rtl + +; SetMaxGrow(Word, Word, GrafPortPtr) -> void +; tool 0x430E, set 0x0E (WindowManager) + .globl SetMaxGrow +SetMaxGrow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x430E + jsl 0xe10000 + rtl + +; SetOriginMask(Word, GrafPortPtr) -> void +; tool 0x340E, set 0x0E (WindowManager) + .globl SetOriginMask +SetOriginMask: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x340E + jsl 0xe10000 + rtl + +; SetPage(Word, Word, GrafPortPtr) -> void +; tool 0x470E, set 0x0E (WindowManager) + .globl SetPage +SetPage: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x470E + jsl 0xe10000 + rtl + +; SetScroll(Word, Word, GrafPortPtr) -> void +; tool 0x450E, set 0x0E (WindowManager) + .globl SetScroll +SetScroll: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x450E + jsl 0xe10000 + rtl + +; SetSysWindow(GrafPortPtr) -> void +; tool 0x4B0E, set 0x0E (WindowManager) + .globl SetSysWindow +SetSysWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x4B0E + jsl 0xe10000 + rtl + +; SetWFrame(Word, GrafPortPtr) -> void +; tool 0x2D0E, set 0x0E (WindowManager) + .globl SetWFrame +SetWFrame: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x2D0E + jsl 0xe10000 + rtl + +; SetWindowIcons(FontHndl) -> FontHndl +; tool 0x4E0E, set 0x0E (WindowManager) + .globl SetWindowIcons +SetWindowIcons: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x4E0E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SetWRefCon(Longint, GrafPortPtr) -> void +; tool 0x280E, set 0x0E (WindowManager) + .globl SetWRefCon +SetWRefCon: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x280E + jsl 0xe10000 + rtl + +; SetWTitle(Pointer, GrafPortPtr) -> void +; tool 0x0D0E, set 0x0E (WindowManager) + .globl SetWTitle +SetWTitle: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x0D0E + jsl 0xe10000 + rtl + +; SetZoomRect(Rect, GrafPortPtr) -> void +; tool 0x380E, set 0x0E (WindowManager) + .globl SetZoomRect +SetZoomRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x380E + jsl 0xe10000 + rtl + +; ShowHide(Boolean, GrafPortPtr) -> void +; tool 0x230E, set 0x0E (WindowManager) + .globl ShowHide +ShowHide: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x230E + jsl 0xe10000 + rtl + +; ShowWindow(GrafPortPtr) -> void +; tool 0x130E, set 0x0E (WindowManager) + .globl ShowWindow +ShowWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x130E + jsl 0xe10000 + rtl + +; SizeWindow(Word, Word, GrafPortPtr) -> void +; tool 0x1C0E, set 0x0E (WindowManager) + .globl SizeWindow +SizeWindow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x1C0E + jsl 0xe10000 + rtl + +; StartDrawing(GrafPortPtr) -> void +; tool 0x4D0E, set 0x0E (WindowManager) + .globl StartDrawing +StartDrawing: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x4D0E + jsl 0xe10000 + rtl + +; StartInfoDrawing(Rect, GrafPortPtr) -> void +; tool 0x500E, set 0x0E (WindowManager) + .globl StartInfoDrawing +StartInfoDrawing: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x500E + jsl 0xe10000 + rtl + +; TaskMaster(Word, WmTaskRecPtr) -> Word +; tool 0x1D0E, set 0x0E (WindowManager) + .globl TaskMaster +TaskMaster: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (WmTaskRecPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x1D0E + jsl 0xe10000 + pla ; result -> A + rtl + +; TrackGoAway(Integer, Integer, GrafPortPtr) -> Boolean +; tool 0x180E, set 0x0E (WindowManager) + .globl TrackGoAway +TrackGoAway: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x180E + jsl 0xe10000 + pla ; result -> A + rtl + +; TrackZoom(Integer, Integer, GrafPortPtr) -> Boolean +; tool 0x260E, set 0x0E (WindowManager) + .globl TrackZoom +TrackZoom: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Integer, 2B) --- + lda 8, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ldx #0x260E + jsl 0xe10000 + pla ; result -> A + rtl + +; ValidRect(Rect) -> void +; tool 0x3C0E, set 0x0E (WindowManager) + .globl ValidRect +ValidRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3C0E + jsl 0xe10000 + rtl + +; ValidRgn(Handle) -> void +; tool 0x3D0E, set 0x0E (WindowManager) + .globl ValidRgn +ValidRgn: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x3D0E + jsl 0xe10000 + rtl + +; WindDragRect(VoidProcPtr, Pattern, Integer, Integer, Rect, Rect, Rect, Word) -> LongWord +; tool 0x530E, set 0x0E (WindowManager) + .globl WindDragRect +WindDragRect: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Pattern, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg2 (Integer, 2B) --- + lda 20, s + pha + ; --- arg3 (Integer, 2B) --- + lda 24, s + pha + ; --- arg4 (Rect, 4B) --- + lda 28, s + pha + lda 30, s + pha + ; --- arg5 (Rect, 4B) --- + lda 36, s + pha + lda 38, s + pha + ; --- arg6 (Rect, 4B) --- + lda 44, s + pha + lda 46, s + pha + ; --- arg7 (Word, 2B) --- + lda 52, s + pha + ldx #0x530E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ZoomWindow(GrafPortPtr) -> void +; tool 0x270E, set 0x0E (WindowManager) + .globl ZoomWindow +ZoomWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x270E + jsl 0xe10000 + rtl + +; AlertWindow(Word, Pointer, Ref) -> Word +; tool 0x590E, set 0x0E (WindowManager) + .globl AlertWindow +AlertWindow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Ref, 4B) --- + lda 16, s + pha + lda 18, s + pha + ldx #0x590E + jsl 0xe10000 + pla ; result -> A + rtl + +; CompileText(Word, Pointer, Pointer, Word) -> Handle +; tool 0x600E, set 0x0E (WindowManager) + .globl CompileText +CompileText: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 10, s + pha + lda 12, s + pha + ; --- arg2 (Pointer, 4B) --- + lda 18, s + pha + lda 20, s + pha + ; --- arg3 (Word, 2B) --- + lda 26, s + pha + ldx #0x600E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; DrawInfoBar(GrafPortPtr) -> void +; tool 0x550E, set 0x0E (WindowManager) + .globl DrawInfoBar +DrawInfoBar: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x550E + jsl 0xe10000 + rtl + +; ErrorWindow(Word, Pointer, Word) -> Word +; tool 0x620E, set 0x0E (WindowManager) + .globl ErrorWindow +ErrorWindow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Pointer, 4B) --- + lda 8, s + pha + lda 10, s + pha + ; --- arg2 (Word, 2B) --- + lda 16, s + pha + ldx #0x620E + jsl 0xe10000 + pla ; result -> A + rtl + +; GetWindowMgrGlobals(void) -> Ptr +; tool 0x580E, set 0x0E (WindowManager) + .globl GetWindowMgrGlobals +GetWindowMgrGlobals: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ldx #0x580E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; NewWindow2(Pointer, Long, VoidProcPtr, LongProcPtr, Word, Ref, Word) -> WindowPtr +; tool 0x610E, set 0x0E (WindowManager) + .globl NewWindow2 +NewWindow2: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Long, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg2 (VoidProcPtr, 4B) --- + lda 20, s + pha + lda 22, s + pha + ; --- arg3 (LongProcPtr, 4B) --- + lda 28, s + pha + lda 30, s + pha + ; --- arg4 (Word, 2B) --- + lda 36, s + pha + ; --- arg5 (Ref, 4B) --- + lda 40, s + pha + lda 42, s + pha + ; --- arg6 (Word, 2B) --- + lda 48, s + pha + ldx #0x610E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ResizeWindow(Boolean, Rect, GrafPortPtr) -> void +; tool 0x5C0E, set 0x0E (WindowManager) + .globl ResizeWindow +ResizeWindow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Rect, 4B) --- + lda 6, s + pha + lda 8, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 14, s + pha + lda 16, s + pha + ldx #0x5C0E + jsl 0xe10000 + rtl + +; StartFrameDrawing(GrafPortPtr) -> void +; tool 0x5A0E, set 0x0E (WindowManager) + .globl StartFrameDrawing +StartFrameDrawing: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x5A0E + jsl 0xe10000 + rtl + +; TaskMasterDA(Word, WmTaskRecPtr) -> Word +; tool 0x5F0E, set 0x0E (WindowManager) + .globl TaskMasterDA +TaskMasterDA: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (WmTaskRecPtr, 4B) --- + lda 8, s + pha + lda 10, s + pha + ldx #0x5F0E + jsl 0xe10000 + pla ; result -> A + rtl + +; DoModalWindow(EventRecordPtr, VoidProcPtr, VoidProcPtr, VoidProcPtr, Word) -> LongWord +; tool 0x640E, set 0x0E (WindowManager) + .globl DoModalWindow +DoModalWindow: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (VoidProcPtr, 4B) --- + lda 12, s + pha + lda 14, s + pha + ; --- arg2 (VoidProcPtr, 4B) --- + lda 20, s + pha + lda 22, s + pha + ; --- arg3 (VoidProcPtr, 4B) --- + lda 28, s + pha + lda 30, s + pha + ; --- arg4 (Word, 2B) --- + lda 36, s + pha + ldx #0x640E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; FindCursorCtl(CtlRecHndlPtr, Integer, Integer, GrafPortPtr) -> Word +; tool 0x690E, set 0x0E (WindowManager) + .globl FindCursorCtl +FindCursorCtl: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (2 bytes) --- + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ; --- arg1 (Integer, 2B) --- + lda 10, s + pha + ; --- arg2 (Integer, 2B) --- + lda 14, s + pha + ; --- arg3 (GrafPortPtr, 4B) --- + lda 18, s + pha + lda 20, s + pha + ldx #0x690E + jsl 0xe10000 + pla ; result -> A + rtl + +; GetAuxWindInfo(GrafPortPtr) -> AuxWindInfoPtr +; tool 0x630E, set 0x0E (WindowManager) + .globl GetAuxWindInfo +GetAuxWindInfo: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x630E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; HandleDiskInsert(Word, Word) -> LongWord +; tool 0x6B0E, set 0x0E (WindowManager) + .globl HandleDiskInsert +HandleDiskInsert: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 10, s + pha + ldx #0x6B0E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; MWSetMenuProc(VoidProcPtr) -> VoidProcPtr +; tool 0x660E, set 0x0E (WindowManager) + .globl MWSetMenuProc +MWSetMenuProc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x660E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; SetMenuProc(VoidProcPtr) -> VoidProcPtr +; tool 0x660E, set 0x0E (WindowManager) + .globl SetMenuProc +SetMenuProc: + ; --- stash arg0 (in A/X) --- + sta 0xE0 + stx 0xE2 + ; --- result space (4 bytes) --- + pea 0 + pea 0 + ; --- arg0 --- + lda 0xE0 + pha + lda 0xE2 + pha + ldx #0x660E + jsl 0xe10000 + pla ; result lo -> A + plx ; result hi -> X + rtl + +; ResizeInfoBar(Word, Word, GrafPortPtr) -> void +; tool 0x6A0E, set 0x0E (WindowManager) + .globl ResizeInfoBar +ResizeInfoBar: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (Word, 2B) --- + lda 6, s + pha + ; --- arg2 (GrafPortPtr, 4B) --- + lda 10, s + pha + lda 12, s + pha + ldx #0x6A0E + jsl 0xe10000 + rtl + +; UpdateWindow(Word, GrafPortPtr) -> void +; tool 0x6C0E, set 0x0E (WindowManager) + .globl UpdateWindow +UpdateWindow: + ; --- stash arg0 (in A) --- + sta 0xE0 + ; --- arg0 --- + lda 0xE0 + pha + ; --- arg1 (GrafPortPtr, 4B) --- + lda 6, s + pha + lda 8, s + pha + ldx #0x6C0E + jsl 0xe10000 + rtl diff --git a/runtime/src/libc.c b/runtime/src/libc.c index 9c73117..ef8b909 100644 --- a/runtime/src/libc.c +++ b/runtime/src/libc.c @@ -167,18 +167,11 @@ int puts(const char *s) { // ---- input stubs ---- // -// Real input would route through GS/OS console / event handling. -// These return EOF / NULL so user code that calls them links and -// gets predictable end-of-input behaviour. FILE struct is defined -// further down (alongside fopen etc.) — forward-declare for the -// signatures. -struct __sFILE; -int getchar(void) { return -1; /* EOF */ } -int fgetc(struct __sFILE *s) { (void)s; return -1; } -char *fgets(char *b, int n, struct __sFILE *s) { - (void)b; (void)n; (void)s; return (char *)0; -} -int ungetc(int c, struct __sFILE *s) { (void)c; (void)s; return -1; } +// getchar reads from the keyboard; real input would route through +// the IIgs Event Manager. Returns -1 (EOF) for now. fgetc/fgets/ +// ungetc are defined further down alongside the FILE-table-backed +// fopen/fread/etc. +int getchar(void) { return -1; /* EOF */ } // ---- minimal printf ---- @@ -621,47 +614,191 @@ clock_t clock(void) { return (clock_t)0; } -// ---- FILE* abstraction (minimal) ---- +// ---- FILE* abstraction (memory-backed FS) ---- // -// stdin / stdout / stderr exist as opaque non-NULL pointers. fputs / -// fputc forward to puts/putchar (which currently no-op or hit a debug -// hook). fprintf forwards to printf, ignoring the stream. fflush is -// a no-op. Real file I/O via GS/OS toolbox is a separate feature -// (would need open/read/write/close + a file-descriptor table). +// stdin / stdout / stderr are tagged as kind=STDIO and route through +// putchar / fgetc-from-keyboard; opening a regular file allocates a +// FILE slot and keeps a (buf, size, pos, writable) record. Programs +// stage files into the FS at startup via mfsRegister(name, ptr, size, +// writable) and then use the standard fopen/fread/fwrite/fseek API. +// +// Why in-memory rather than GS/OS-backed: the smoke harness doesn't +// boot ProDOS, so toolbox-FS calls would crash MAME. An in-RAM FS +// covers the common need (parser/printer that wants a FILE*) without +// pulling in GS/OS init. A future GS/OS backend can replace +// fopenImpl/etc. without touching callers. +// +// FILE-table layout: 8 entries. Slot 0..2 are stdin/stdout/stderr +// (immutable); 3..7 are user-allocated by fopen. Each entry has: +// kind (0=stdio in/out/err, 1=memory) +// buf (memory buffer base) +// size (logical size in bytes) +// cap (allocated capacity — for write-grow) +// pos (current seek position) +// eof, err flags +// writable (1 if opened for "w" or "r+" or "a") +// ungetc holding cell (-1 = empty) -typedef struct __sFILE { unsigned int magic; } FILE; +#define FILE_KIND_STDIN 0 +#define FILE_KIND_STDOUT 1 +#define FILE_KIND_STDERR 2 +#define FILE_KIND_MEM 3 -static FILE __stdin_obj = { 1 }; -static FILE __stdout_obj = { 2 }; -static FILE __stderr_obj = { 3 }; -FILE *stdin = &__stdin_obj; -FILE *stdout = &__stdout_obj; -FILE *stderr = &__stderr_obj; +typedef struct __sFILE { + u8 kind; + u8 writable; + u8 eof; + u8 err; + char *buf; + size_t size; + size_t cap; + size_t pos; + int unget; // -1 if no pushed-back char + const char *path; // borrowed from caller, NULL for stdio +} FILE; + +#define MFS_MAX_FILES 8 +static FILE __mfs[MFS_MAX_FILES] = { + { FILE_KIND_STDIN, 0, 0, 0, 0, 0, 0, 0, -1, 0 }, + { FILE_KIND_STDOUT, 1, 0, 0, 0, 0, 0, 0, -1, 0 }, + { FILE_KIND_STDERR, 1, 0, 0, 0, 0, 0, 0, -1, 0 }, +}; + +FILE *stdin = &__mfs[0]; +FILE *stdout = &__mfs[1]; +FILE *stderr = &__mfs[2]; + +// Registered "files" available to fopen. Each registration is +// (path, buf, size, writable). Order doesn't matter — fopen scans +// linearly. +typedef struct { + const char *path; + char *buf; + size_t size; + size_t cap; + u8 writable; + u8 inUse; +} MfsEntry; + +#define MFS_MAX_REG 16 +static MfsEntry __mfsReg[MFS_MAX_REG]; + +// Register a memory region as a named file. Returns 0 on success, +// -1 if the table is full or a duplicate name exists. `cap` may be +// larger than `size` to allow appends without reallocation; pass +// cap=size if writes must not grow the file. +int mfsRegister(const char *path, void *buf, size_t size, size_t cap, + int writable) { + if (cap < size) cap = size; + for (int i = 0; i < MFS_MAX_REG; i++) { + if (__mfsReg[i].inUse && strcmp(__mfsReg[i].path, path) == 0) + return -1; + } + for (int i = 0; i < MFS_MAX_REG; i++) { + if (!__mfsReg[i].inUse) { + __mfsReg[i].path = path; + __mfsReg[i].buf = (char *)buf; + __mfsReg[i].size = size; + __mfsReg[i].cap = cap; + __mfsReg[i].writable = (u8)(writable != 0); + __mfsReg[i].inUse = 1; + return 0; + } + } + return -1; +} + +// Drop a registration. Returns 0 on success, -1 if not found. +int mfsUnregister(const char *path) { + for (int i = 0; i < MFS_MAX_REG; i++) { + if (__mfsReg[i].inUse && strcmp(__mfsReg[i].path, path) == 0) { + __mfsReg[i].inUse = 0; + __mfsReg[i].path = (const char *)0; + return 0; + } + } + return -1; +} + +int fputc(int c, FILE *stream) { + if (!stream) return -1; + if (stream->kind == FILE_KIND_STDOUT || stream->kind == FILE_KIND_STDERR) + return putchar(c); + if (stream->kind == FILE_KIND_MEM) { + if (!stream->writable) { stream->err = 1; return -1; } + if (stream->pos >= stream->cap) { stream->err = 1; return -1; } + stream->buf[stream->pos++] = (char)c; + if (stream->pos > stream->size) stream->size = stream->pos; + return (int)(unsigned char)c; + } + return -1; +} -int fputc(int c, FILE *stream) { (void)stream; return putchar(c); } -// fputs writes the string WITHOUT appending a newline (puts does append). -// Forwarding to puts() was a real bug — `fputs("hi", stdout)` was -// printing "hi\n" instead of "hi". int fputs(const char *s, FILE *stream) { - (void)stream; - while (*s) { putchar(*s); s++; } + if (!stream || !s) return -1; + if (stream->kind == FILE_KIND_STDOUT || stream->kind == FILE_KIND_STDERR) { + while (*s) { putchar(*s); s++; } + return 0; + } + if (stream->kind == FILE_KIND_MEM) { + while (*s) { + if (fputc(*s, stream) == -1) return -1; + s++; + } + return 0; + } + return -1; +} + +int fflush(FILE *stream) { (void)stream; return 0; } + +int fclose(FILE *stream) { + if (!stream) return -1; + // Don't close stdin/stdout/stderr — they're long-lived statics. + if (stream->kind != FILE_KIND_MEM) return 0; + stream->kind = 0; + stream->buf = (char *)0; + stream->size = 0; + stream->cap = 0; + stream->pos = 0; + stream->path = (const char *)0; return 0; } -int fflush(FILE *stream) { (void)stream; return 0; } -int fclose(FILE *stream) { (void)stream; return 0; } + +// Forward decls for routines that live in snprintf.c. +extern int vsnprintf(char *buf, size_t n, const char *fmt, va_list ap); + +// Forward decl for vfprintf so fprintf can call it. +int vfprintf(FILE *stream, const char *fmt, va_list ap); int fprintf(FILE *stream, const char *fmt, ...) { - (void)stream; va_list ap; __builtin_va_start(ap, fmt); - int r = vprintf(fmt, ap); + int r = vfprintf(stream, fmt, ap); __builtin_va_end(ap); return r; } int vfprintf(FILE *stream, const char *fmt, va_list ap) { - (void)stream; - return vprintf(fmt, ap); + if (!stream) return -1; + if (stream->kind == FILE_KIND_STDOUT || stream->kind == FILE_KIND_STDERR) + return vprintf(fmt, ap); + if (stream->kind == FILE_KIND_MEM) { + // Format into the file's tail. Use the memory buffer that + // remains as a snprintf target. Caller is responsible for + // sizing the file's buffer. + if (!stream->writable) { stream->err = 1; return -1; } + size_t remain = (stream->cap > stream->pos) + ? stream->cap - stream->pos : 0; + if (remain == 0) { stream->err = 1; return -1; } + int n = vsnprintf(stream->buf + stream->pos, remain, fmt, ap); + if (n < 0) { stream->err = 1; return -1; } + size_t written = ((size_t)n < remain) ? (size_t)n : remain - 1; + stream->pos += written; + if (stream->pos > stream->size) stream->size = stream->pos; + return n; + } + return -1; } // ---- assert ---- @@ -688,56 +825,204 @@ int atexit(AtexitFn fn) { return 0; } -// ---- File I/O stubs ---- +// ---- File I/O (memory-backed) ---- // -// A real implementation would route through the GS/OS dispatcher at -// $E100A8 (build a class-1 parm block, push its pointer, JSL with X -// = callNum, copy the refNum out). fopen would maintain a small -// FD table mapping FILE* magic values back to GS/OS refNums. -// Until that lands, every call returns failure so code that links -// against stdio degrades gracefully instead of trapping. +// Backed by mfsRegister'd entries. Mode strings: +// "r" read only +// "w" write, truncate to zero on open +// "a" write, position at end on open +// "r+" read+write +// "w+" read+write, truncate +// Plus optional "b" (no-op since we're memory-backed). +// +// Returns NULL if no registration matches `path` (or the requested +// mode isn't compatible with the registration's writable flag). FILE *fopen(const char *path, const char *mode) { - (void)path; (void)mode; - return (FILE *)0; + if (!path || !mode) return (FILE *)0; + int wantWrite = 0; + int wantRead = 1; + int truncate = 0; + int append = 0; + if (mode[0] == 'r') { wantRead = 1; wantWrite = (mode[1] == '+' || (mode[1] == 'b' && mode[2] == '+')); } + else if (mode[0] == 'w') { wantWrite = 1; truncate = 1; wantRead = (mode[1] == '+' || (mode[1] == 'b' && mode[2] == '+')); } + else if (mode[0] == 'a') { wantWrite = 1; append = 1; wantRead = (mode[1] == '+' || (mode[1] == 'b' && mode[2] == '+')); } + else return (FILE *)0; + + // Locate registration. + MfsEntry *reg = (MfsEntry *)0; + for (int i = 0; i < MFS_MAX_REG; i++) { + if (__mfsReg[i].inUse && strcmp(__mfsReg[i].path, path) == 0) { + reg = &__mfsReg[i]; + break; + } + } + if (!reg) return (FILE *)0; + if (wantWrite && !reg->writable) return (FILE *)0; + + // Allocate a FILE slot (3..MAX-1 — 0..2 are stdin/out/err). + FILE *f = (FILE *)0; + for (int i = 3; i < MFS_MAX_FILES; i++) { + if (__mfs[i].kind == 0) { + f = &__mfs[i]; + break; + } + } + if (!f) return (FILE *)0; + + f->kind = FILE_KIND_MEM; + f->writable = (u8)(wantWrite ? 1 : 0); + f->eof = 0; + f->err = 0; + f->buf = reg->buf; + f->size = reg->size; + f->cap = reg->cap; + f->pos = 0; + f->unget = -1; + f->path = reg->path; + (void)wantRead; + + if (truncate) f->size = 0; + if (append) f->pos = f->size; + return f; } size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream) { - (void)ptr; (void)size; (void)nmemb; (void)stream; - return 0; + if (!stream || stream->kind != FILE_KIND_MEM) return 0; + if (size == 0 || nmemb == 0) return 0; + // Avoid 32-bit overflow on size * nmemb: cap nmemb so each item + // (size bytes) fits in remaining 16-bit address space. + if (nmemb > (size_t)0xFFFE / size) nmemb = (size_t)0xFFFE / size; + char *out = (char *)ptr; + size_t items = 0; + while (items < nmemb) { + size_t b; + // Each item: size bytes. + for (b = 0; b < size; b++) { + if (stream->unget >= 0) { + *out++ = (char)stream->unget; + stream->unget = -1; + continue; + } + if (stream->pos >= stream->size) { + stream->eof = 1; + return items; + } + *out++ = stream->buf[stream->pos++]; + } + items++; + } + return items; } size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) { - // For stdout/stderr, route through putchar so programs that use - // fwrite for binary output ("write %d bytes to stdout") actually - // produce output instead of silently dropping it. For other - // streams (real file handles), still a stub returning 0. - if (stream == stdout || stream == stderr) { - // size * nmemb can overflow size_t (16-bit on this target); - // bail rather than silently truncate the byte count. - if (size != 0 && nmemb > (size_t)0xFFFF / size) return 0; - const u8 *p = (const u8 *)ptr; - size_t total = size * nmemb; - for (size_t i = 0; i < total; i++) putchar(p[i]); - return nmemb; + if (!stream) return 0; + if (size == 0 || nmemb == 0) return 0; + // Cap nmemb so each item (size bytes) fits in the address space + // — avoids 32-bit `size * nmemb` that the i32 multiply path triggers. + if (nmemb > (size_t)0xFFFE / size) nmemb = (size_t)0xFFFE / size; + const char *in = (const char *)ptr; + if (stream->kind == FILE_KIND_STDOUT || stream->kind == FILE_KIND_STDERR) { + size_t items = 0; + while (items < nmemb) { + for (size_t b = 0; b < size; b++) putchar(*in++); + items++; + } + return items; } - (void)ptr; (void)size; (void)nmemb; + if (stream->kind != FILE_KIND_MEM) return 0; + if (!stream->writable) { stream->err = 1; return 0; } + size_t items = 0; + while (items < nmemb) { + size_t b; + for (b = 0; b < size; b++) { + if (stream->pos >= stream->cap) { + stream->err = 1; + if (stream->pos > stream->size) stream->size = stream->pos; + return items; + } + stream->buf[stream->pos++] = *in++; + } + items++; + } + if (stream->pos > stream->size) stream->size = stream->pos; + return items; +} + +#define SEEK_SET 0 +#define SEEK_CUR 1 +#define SEEK_END 2 + +int fseek(FILE *stream, long offset, int whence) { + if (!stream || stream->kind != FILE_KIND_MEM) return -1; + long base; + if (whence == SEEK_SET) base = 0; + else if (whence == SEEK_CUR) base = (long)stream->pos; + else if (whence == SEEK_END) base = (long)stream->size; + else return -1; + long target = base + offset; + if (target < 0 || target > (long)stream->size) return -1; + stream->pos = (size_t)target; + stream->eof = 0; + stream->unget = -1; return 0; } -int fseek(FILE *stream, long offset, int whence) { - (void)stream; (void)offset; (void)whence; +long ftell(FILE *stream) { + if (!stream || stream->kind != FILE_KIND_MEM) return -1L; + return (long)stream->pos; +} + +int fgetc(FILE *stream) { + if (!stream) return -1; + if (stream->unget >= 0) { + int c = stream->unget; + stream->unget = -1; + return c; + } + if (stream->kind == FILE_KIND_MEM) { + if (stream->pos >= stream->size) { stream->eof = 1; return -1; } + return (int)(unsigned char)stream->buf[stream->pos++]; + } + if (stream->kind == FILE_KIND_STDIN) return getchar(); return -1; } -long ftell(FILE *stream) { - (void)stream; - return -1L; +char *fgets(char *buf, int n, FILE *stream) { + if (!buf || n <= 0 || !stream) return (char *)0; + int i = 0; + while (i < n - 1) { + int c = fgetc(stream); + if (c < 0) { + if (i == 0) return (char *)0; + break; + } + buf[i++] = (char)c; + if (c == '\n') break; + } + buf[i] = 0; + return buf; } -int feof(FILE *stream) { (void)stream; return 1; } -int ferror(FILE *stream) { (void)stream; return 0; } -void clearerr(FILE *stream) { (void)stream; } +int ungetc(int c, FILE *stream) { + if (!stream || c < 0) return -1; + if (stream->unget >= 0) return -1; // only one slot + stream->unget = c & 0xFF; + stream->eof = 0; + return c & 0xFF; +} + +int feof(FILE *stream) { + return stream ? (int)stream->eof : 1; +} + +int ferror(FILE *stream) { + return stream ? (int)stream->err : 0; +} + +void clearerr(FILE *stream) { + if (stream) { stream->eof = 0; stream->err = 0; } +} // ---- locale.h stubs ---- // @@ -792,22 +1077,46 @@ struct lconv *localeconv(void) { return &__c_lconv; } -// ---- signal.h stubs ---- +// ---- signal.h ---- // -// IIgs has no POSIX-style signal model. signal() always fails (returns -// SIG_ERR); raise() returns -1. Code that uses these for diagnostic -// fall-through (e.g. abort -> raise(SIGABRT) -> stub) compiles and -// behaves as "signals disabled". +// IIgs has no POSIX-style signal source (no kernel-delivered signals +// from external events), but a small in-process signal table makes +// signal()/raise() work for synchronous diagnostic use: a program +// can install SIGABRT/SIGINT/etc. handlers and abort()-equivalent +// code can raise(SIGABRT) to invoke them. No async signal delivery. +// +// Table indexed by signal number 0..15; raise() looks up the +// installed handler and calls it. SIG_DFL falls through to a +// per-signal default (SIGABRT calls abort(); others ignore). typedef void (*__sighandler_t)(int); +#define _SIG_DFL ((__sighandler_t)0) +#define _SIG_IGN ((__sighandler_t)1) #define _SIG_ERR ((__sighandler_t)-1) +#define _NSIG 16 +static __sighandler_t __sigHandlers[_NSIG]; + __sighandler_t signal(int sig, __sighandler_t handler) { - (void)sig; (void)handler; - return _SIG_ERR; + if (sig < 0 || sig >= _NSIG) return _SIG_ERR; + __sighandler_t prev = __sigHandlers[sig]; + if (!prev) prev = _SIG_DFL; + __sigHandlers[sig] = handler; + return prev; } int raise(int sig) { - (void)sig; - return -1; + if (sig < 0 || sig >= _NSIG) return -1; + __sighandler_t h = __sigHandlers[sig]; + if (h == _SIG_IGN) return 0; + if (!h || h == _SIG_DFL) { + // Default action: SIGABRT -> abort(); SIGTERM/SIGINT -> exit; + // others -> ignore. + if (sig == 6) abort(); // SIGABRT + if (sig == 2 || sig == 15) // SIGINT, SIGTERM + exit(128 + sig); + return 0; + } + h(sig); + return 0; } diff --git a/scripts/bench.sh b/scripts/bench.sh new file mode 100755 index 0000000..226b298 --- /dev/null +++ b/scripts/bench.sh @@ -0,0 +1,106 @@ +#!/usr/bin/env bash +# bench.sh — compile a benchmark suite with both clang (this toolchain) +# and Calypsi cc65816, compare emitted code size. +# +# Each benchmark is a self-contained .c file under benchmarks/. We +# compile each with both toolchains (-O2 / --speed), then count +# bytes in the .text + .data sections of the resulting object. +# Output is a markdown table on stdout. +# +# Cycle-time comparison would require running each benchmark in MAME +# under both toolchains' produced code, with a wrapper function that +# instruments the cycle counter. That's a separate, more involved +# tool — left for future work. + +set -euo pipefail +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)" +BENCH_DIR="$PROJECT_ROOT/benchmarks" + +CLANG="$PROJECT_ROOT/tools/llvm-mos-build/bin/clang" +CALYPSI="$PROJECT_ROOT/tools/calypsi/usr/local/lib/calypsi-65816-5.16/bin/cc65816" + +[ -x "$CLANG" ] || { echo "ERROR: clang not built" >&2; exit 1; } +[ -x "$CALYPSI" ] || { echo "ERROR: Calypsi not installed" >&2; exit 1; } +[ -d "$BENCH_DIR" ] || { echo "ERROR: $BENCH_DIR not found" >&2; exit 1; } + +# Object-size measurement. Different object formats — for clang it's +# ELF (use llvm-readobj), for Calypsi it's its own format (use the +# binary file size as a proxy, minus header overhead). ELF .text + +# .rodata + .data covers code + constants; we report code-only as the +# primary metric. +clangSize() { + local o="$1" + "$PROJECT_ROOT/tools/llvm-mos-build/bin/llvm-readobj" --section-headers "$o" \ + 2>/dev/null | awk ' + /Name: .text/ { intext=1; inrodata=0; indata=0; next } + /Name: .rodata/ { intext=0; inrodata=1; indata=0; next } + /Name: .data/ { intext=0; inrodata=0; indata=1; next } + /Name: / { intext=0; inrodata=0; indata=0; next } + /Size:/ { + if (intext) text += strtonum($2) + if (inrodata) rodata += strtonum($2) + if (indata) data += strtonum($2) + } + END { print text " " rodata " " data } + ' +} + +# Calypsi text size: extract the highest farcode offset from the +# assembler listing. cc65816 -> .s, then as65816 --list-file +# emits "OFFSET hexbytes" columns; we pick the max offset and add +# the byte width of the final instruction (1-3 bytes typically). +# Approximation but within a byte or two of true text size. +calypsiTextSize() { + local src="$1" + local s lst tmp + s=$(mktemp --suffix=.s) + lst=$(mktemp --suffix=.lst) + tmp=$(mktemp --suffix=.o) + "$CALYPSI" -O 2 --speed --assembly-source "$s" -c "$src" -o "$tmp" 2>/dev/null \ + || { echo 0; rm -f "$s" "$lst" "$tmp"; return; } + "$CALYPSI" -O 2 --speed -c "$src" -o "$tmp" 2>/dev/null + "$PROJECT_ROOT/tools/calypsi/usr/local/lib/calypsi-65816-5.16/bin/as65816" \ + --list-file "$lst" -o "$tmp" "$s" 2>/dev/null + # Highest farcode offset. We skip the +instruction-bytes detail + # (rough estimate is fine for relative comparison). + local maxOff + maxOff=$(grep -oE "^[0-9]+ [0-9a-f]{6}" "$lst" 2>/dev/null \ + | awk '{print strtonum("0x"$2)}' | sort -n | tail -1) + echo "${maxOff:-0}" + rm -f "$s" "$lst" "$tmp" +} + +# Print markdown header. +printf '| Benchmark | clang (B) | Calypsi (B) | clang vs Calypsi |\n' +printf '|-----------|----------:|------------:|-----------------:|\n' + +totalClang=0 +totalCalypsi=0 +for src in "$BENCH_DIR"/*.c; do + name=$(basename "$src" .c) + cObj=$(mktemp --suffix=.clang.o) + + "$CLANG" --target=w65816 -O2 -ffunction-sections \ + -c "$src" -o "$cObj" 2>/dev/null || { echo "clang failed on $name" >&2; rm -f "$cObj"; continue; } + + read clangText _ _ < <(clangSize "$cObj") + clangText=${clangText:-0} + + calText=$(calypsiTextSize "$src") + + if [ "$calText" -gt 0 ]; then + ratio=$(awk -v a="$clangText" -v b="$calText" 'BEGIN{printf "%.2fx", a/b}') + else + ratio="—" + fi + printf '| %s | %d | %d | %s |\n' "$name" "$clangText" "$calText" "$ratio" + totalClang=$((totalClang + clangText)) + totalCalypsi=$((totalCalypsi + calText)) + rm -f "$cObj" +done + +if [ "$totalCalypsi" -gt 0 ]; then + totalRatio=$(awk -v a="$totalClang" -v b="$totalCalypsi" 'BEGIN{printf "%.2fx", a/b}') + printf '| **total** | **%d** | **%d** | **%s** |\n' "$totalClang" "$totalCalypsi" "$totalRatio" +fi diff --git a/scripts/genToolbox.py b/scripts/genToolbox.py new file mode 100644 index 0000000..033b970 --- /dev/null +++ b/scripts/genToolbox.py @@ -0,0 +1,425 @@ +#!/usr/bin/env python3 +# genToolbox.py — generate IIgs toolbox wrappers from ORCA-C headers. +# +# Reads ORCA's extern declarations of the form: +# extern pascal RetType FuncName(ArgType, ArgType) inline(0xNNTT, dispatcher); +# and emits two outputs: +# - C header with `static inline` wrappers using clang inline-asm +# - .s file with extern wrapper bodies for multi-arg routines that +# can't fit in inline asm (our backend's constraints don't take +# memory operands). +# +# Tool number convention: 0xNNTT high byte = function, low byte = tool set +# Dispatcher: JSL $E10000 for normal toolbox; JSL $E100A8 for GS/OS +# (only the ProDOS-16 / GS/OS calls use _CallBackVector). +# +# Calling convention conversion: ORCA uses Pascal (args pushed L-to-R), +# our C ABI passes arg0 in A and arg1+ on stack RTL. Each generated +# wrapper re-pushes args in toolbox order. +# +# Type widths (matching ORCA): +# Word, Boolean, Integer, Char, Byte = 2 bytes (16-bit) +# LongWord, Long, Handle, Pointer = 4 bytes (32-bit) +# Ptr, Ref, ResType = 4 bytes +# (Pointer is 4 bytes in ORCA -- it's a far/24-bit pointer. Our backend +# uses 16-bit pointers, but the toolbox expects 32-bit on the stack; +# we extend with a zero high word.) +# +# Output files are written to the runtime tree. + +import re +import sys +from pathlib import Path + +ORCA_DIR = Path("/tmp/orca-headers") +OUT_HEADER = Path("/home/scott/claude/llvm816/runtime/include/iigs/toolbox.h") +OUT_ASM = Path("/home/scott/claude/llvm816/runtime/src/iigsToolbox.s") + +# Type table: (size in bytes, c-type) +TYPE_MAP = { + "void": (0, "void"), + "Word": (2, "unsigned short"), + "Boolean": (2, "unsigned short"), + "Integer": (2, "short"), + "Char": (2, "char"), # widened on stack + "Byte": (2, "unsigned char"), + "LongWord": (4, "unsigned long"), + "Long": (4, "long"), + "Handle": (4, "void *"), # 4-byte handle + "Pointer": (4, "void *"), # 4-byte pointer (toolbox semantics) + "Ref": (4, "void *"), + "Ptr": (4, "void *"), + "ResType": (4, "unsigned long"), + "Real": (4, "float"), + "Double": (8, "double"), + "Comp": (8, "long long"), + "Extended": (10, "long double"), + "GrafPortPtr":(4, "void *"), + "WindowPtr": (4, "void *"), + "MenuHandle": (4, "void *"), + "CtlRecHndl": (4, "void *"), + "DialogPtr": (4, "void *"), + "RgnHandle": (4, "void *"), + "PrPort": (4, "void *"), + "PrRecHndl": (4, "void *"), + "PicHandle": (4, "void *"), + "WindRecHndl":(4, "void *"), +} + +# Tool number → tool-set name mapping (low byte of toolNumber) +TOOLSET_NAME = { + 0x01: "ToolLocator", + 0x02: "MemoryManager", + 0x03: "MiscTools", + 0x04: "QuickDraw", + 0x05: "DeskManager", + 0x06: "EventManager", + 0x07: "Scheduler", + 0x08: "SoundManager", + 0x09: "AppleDeskBus", + 0x0A: "SANE", + 0x0B: "IntegerMath", + 0x0C: "TextTools", + 0x0E: "WindowManager", + 0x0F: "MenuManager", + 0x10: "ControlManager", + 0x11: "Loader", + 0x12: "QDAuxiliary", + 0x13: "PrintManager", + 0x14: "LineEdit", + 0x15: "DialogManager", + 0x16: "ScrapManager", + 0x17: "StandardFile", + 0x18: "DiskUtil", + 0x19: "NoteSynth", + 0x1A: "NoteSequencer", + 0x1B: "FontManager", + 0x1C: "ListManager", + 0x1D: "ACETools", + 0x1E: "ResourceManager", + 0x1F: "MIDITools", + 0x20: "VideoOverlay", + 0x21: "Teletext", + 0x22: "TextEdit", + 0x23: "MediaControl", + 0x32: "MediaControl2", +} + + +def parseLine(line): + """Parse `extern pascal RetType Name(args) inline(0xNNTT, dispatcher);` + Returns dict or None if not a toolbox decl. + """ + m = re.match( + r'^\s*extern\s+pascal\s+(\w+)\s+(\w+)\s*\((.*?)\)\s+inline\(0x([0-9A-Fa-f]+)\s*,\s*(\w+)\)\s*;', + line, + ) + if not m: + return None + retType, name, args, toolHex, dispatcher = m.group(1, 2, 3, 4, 5) + toolNum = int(toolHex, 16) + + # Parse arg types (just the types, no names since ORCA omits them). + args = args.strip() + argTypes = [] + if args and args != "void": + for a in args.split(","): + a = a.strip() + # ORCA may have type-only or "type name"; take the first word. + t = a.split()[0] + argTypes.append(t) + return { + "ret": retType, + "name": name, + "args": argTypes, + "tool": toolNum, + "dispatcher": dispatcher, + } + + +def typeInfo(t): + """Return (size_bytes, c_type) for ORCA type, or None if unsupported.""" + if t in TYPE_MAP: + return TYPE_MAP[t] + # Default: assume 4 bytes / void* (pointer-like) + return (4, "void *") + + +def emit(decls): + """Generate C header and .s file from parsed decls.""" + + cLines = [ + "// AUTOGENERATED by scripts/genToolbox.py from ORCA-C ORCACDefs/.", + "// DO NOT EDIT by hand — regenerate to update.", + "//", + "// Complete IIgs toolbox: ~1300 routines across 35 tool sets.", + "// Names match Apple's IIgs Toolbox Reference (TLStartUp,", + "// MMStartUp, NewWindow, SysBeep, etc.). Multi-arg wrappers", + "// (those whose stub body uses memory operands) live in", + "// runtime/src/iigsToolbox.s; zero-arg / single-arg simple", + "// ones are inlined here.", + "", + "#ifndef IIGS_TOOLBOX_H", + "#define IIGS_TOOLBOX_H", + "", + "#ifdef __cplusplus", + 'extern "C" {', + "#endif", + "", + ] + + sLines = [ + "; AUTOGENERATED by scripts/genToolbox.py from ORCA-C ORCACDefs/.", + "; DO NOT EDIT by hand — regenerate to update.", + ";", + "; IIgs toolbox multi-arg wrappers.", + ";", + "; C ABI: arg0 (i16) in A, arg0 (i32) in A:X, arg1+ on stack (4,S etc.).", + "; Each wrapper re-pushes args in toolbox (Pascal-style L-to-R) order,", + "; preceded by result space if non-void return, then JSL $E10000", + "; (or $E100A8 for GS/OS). Pops result if non-void.", + ";", + "; Tool number: high byte = function, low byte = tool set.", + "", + "\t.text", + "", + ] + + seenNames = set() + inlineCount = 0 + asmCount = 0 + skipped = [] + + for d in decls: + name = d["name"] + if name in seenNames: + continue # duplicate from header re-include, etc. + seenNames.add(name) + + retType = d["ret"] + argTypes = d["args"] + tool = d["tool"] + dispatcher = d["dispatcher"] + + # Check if all types are known. + retSize, retC = typeInfo(retType) + argInfo = [typeInfo(a) for a in argTypes] + if any(ai is None for ai in argInfo): + skipped.append((name, "unknown arg type")) + continue + + # Build C-style arg list. + cArgs = ", ".join(f"{ai[1]} a{i}" for i, ai in enumerate(argInfo)) + if not cArgs: + cArgs = "void" + cDecl = f"{retC} {name}({cArgs});" + + # Decide inline vs asm. + # Simple cases that can be inlined: no args (with or without 16-bit + # return), or single 16-bit arg with void return / 16-bit return. + canInline = False + if not argInfo and retSize in (0, 2): + canInline = True + elif ( + len(argInfo) == 1 + and argInfo[0][0] == 2 + and retSize in (0, 2) + ): + canInline = True + + dispAddr = "0xe10000" if dispatcher == "dispatcher" else "0xe100a8" + + if canInline: + # Generate inline asm body. + if not argInfo: + if retSize == 0: + body = ( + f' __asm__ volatile (\n' + f' "ldx #0x{tool:04X}\\n"\n' + f' "jsl {dispAddr}\\n"\n' + f' :\n' + f' :\n' + f' : "a", "x", "y", "memory"\n' + f' );\n' + ) + else: # 16-bit return + body = ( + f' {retC} _r;\n' + f' __asm__ volatile (\n' + f' "pha\\n" // result space\n' + f' "ldx #0x{tool:04X}\\n"\n' + f' "jsl {dispAddr}\\n"\n' + f' "pla\\n"\n' + f' : "=a"(_r)\n' + f' :\n' + f' : "x", "y", "memory"\n' + f' );\n' + f' return _r;\n' + ) + else: # 1-arg + if retSize == 0: + body = ( + f' __asm__ volatile (\n' + f' "pha\\n" // arg0\n' + f' "ldx #0x{tool:04X}\\n"\n' + f' "jsl {dispAddr}\\n"\n' + f' :\n' + f' : "a"(a0)\n' + f' : "x", "y", "memory"\n' + f' );\n' + ) + else: + body = ( + f' {retC} _r;\n' + f' __asm__ volatile (\n' + f' "pha\\n" // result space\n' + f' "pha\\n" // arg0\n' + f' "ldx #0x{tool:04X}\\n"\n' + f' "jsl {dispAddr}\\n"\n' + f' "pla\\n"\n' + f' : "=a"(_r)\n' + f' : "a"(a0)\n' + f' : "x", "y", "memory"\n' + f' );\n' + f' return _r;\n' + ) + + cLines.append(f"// tool 0x{tool:04X} set 0x{tool & 0xFF:02X} ({TOOLSET_NAME.get(tool & 0xFF, '?')})") + cLines.append(f"static inline {retC} {name}({cArgs}) {{") + cLines.append(body.rstrip()) + cLines.append("}") + cLines.append("") + inlineCount += 1 + else: + # Extern decl in header, asm body in .s file. + cLines.append(f"extern {retC} {name}({cArgs}); // 0x{tool:04X}") + + # Generate asm body. + sLines.append(f"; {name}({', '.join(argTypes) or 'void'}) -> {retType}") + sLines.append(f"; tool 0x{tool:04X}, set 0x{tool & 0xFF:02X} ({TOOLSET_NAME.get(tool & 0xFF, '?')})") + sLines.append(f"\t.globl {name}") + sLines.append(f"{name}:") + + # Compute total stack arg bytes (excluding arg0 which is in regs). + # Determine where each arg starts on the caller's stack. + # arg0 is in A (or A:X for i32-first-arg). + firstArgIs32 = argInfo and argInfo[0][0] == 4 + stackArgStart = 4 # offset to first stack-passed arg after JSL retaddr + + # Stash arg0. i16: 'sta scratch'. i32: 'sta scratch; stx scratch+2'. + scratchDP = 0xE0 # libcall scratch zone + sLines.append(f"\t; --- stash arg0 (in A{'/X' if firstArgIs32 else ''}) ---") + sLines.append(f"\tsta 0x{scratchDP:02X}") + if firstArgIs32: + sLines.append(f"\tstx 0x{scratchDP + 2:02X}") + + # Push result space (toolbox order: result is highest on stack). + if retSize > 0: + sLines.append(f"\t; --- result space ({retSize} bytes) ---") + for _ in range((retSize + 1) // 2): + sLines.append(f"\tpea 0") + + # Push args in Pascal order (L-to-R, but each multi-byte value + # pushed lo-word first then hi-word per ORCA convention). + # Tracker: how many bytes have we pushed beyond the original + # caller-stack so all stack-arg loads need to add (pushed) to + # their original offset. + pushedBytes = (retSize + 1) // 2 * 2 # result space rounded up to word + # arg0 first. + sLines.append(f"\t; --- arg0 ---") + sLines.append(f"\tlda 0x{scratchDP:02X}") + sLines.append(f"\tpha") + pushedBytes += 2 + if firstArgIs32: + sLines.append(f"\tlda 0x{scratchDP + 2:02X}") + sLines.append(f"\tpha") + pushedBytes += 2 + + # arg1, arg2, ... — each loaded from caller stack at original + # offset + pushedBytes. + stackArgOffset = stackArgStart # original offset of next arg + for i, ai in enumerate(argInfo[1:], start=1): + size = ai[0] + sLines.append(f"\t; --- arg{i} ({argTypes[i]}, {size}B) ---") + # i16 / 16-bit-on-stack args: 1 word, push lo + # i32 / 32-bit-on-stack: 2 words, push lo then hi + # We're loading from caller's pre-push stack. Original + # offsets: arg1 at 4, arg2 at 4+size(arg1), ... + # But each load from `(orig+pushed),s` accounts for pushes. + if size <= 2: + sLines.append(f"\tlda {stackArgOffset + pushedBytes}, s") + sLines.append(f"\tpha") + pushedBytes += 2 + stackArgOffset += 2 + elif size == 4: + # Load lo, push; load hi, push. + sLines.append(f"\tlda {stackArgOffset + pushedBytes}, s") + sLines.append(f"\tpha") + pushedBytes += 2 + sLines.append(f"\tlda {stackArgOffset + pushedBytes}, s") + sLines.append(f"\tpha") + pushedBytes += 2 + stackArgOffset += 4 + else: + # Bigger types (8-byte Comp, 10-byte Extended) — push word by word. + nWords = (size + 1) // 2 + for _ in range(nWords): + sLines.append(f"\tlda {stackArgOffset + pushedBytes}, s") + sLines.append(f"\tpha") + pushedBytes += 2 + stackArgOffset += size + + # Dispatch. + sLines.append(f"\tldx #0x{tool:04X}") + sLines.append(f"\tjsl {dispAddr}") + + # Pop result. + if retSize == 2: + sLines.append(f"\tpla ; result -> A") + elif retSize == 4: + sLines.append(f"\tpla ; result lo -> A") + sLines.append(f"\tplx ; result hi -> X") + elif retSize > 4: + # Larger results: pop into scratch then load A/X for return. + # Treat as "best effort" — caller should not expect a real + # return value beyond what fits in A:X. + nWords = (retSize + 1) // 2 + for _ in range(nWords): + sLines.append(f"\tpla") + + sLines.append(f"\trtl") + sLines.append("") + + asmCount += 1 + + cLines.append("") + cLines.append("#ifdef __cplusplus") + cLines.append("}") + cLines.append("#endif") + cLines.append("") + cLines.append("#endif // IIGS_TOOLBOX_H") + + OUT_HEADER.write_text("\n".join(cLines)) + OUT_ASM.write_text("\n".join(sLines)) + + print(f"wrote {OUT_HEADER}: {inlineCount} inline + {asmCount} extern decls") + print(f"wrote {OUT_ASM}: {asmCount} bodies") + if skipped: + print(f"skipped {len(skipped)} routines (unhandled types):") + for n, why in skipped[:5]: + print(f" {n}: {why}") + + +def main(): + decls = [] + for h in sorted(ORCA_DIR.glob("*.h")): + for line in h.read_text().splitlines(): + d = parseLine(line) + if d: + decls.append(d) + print(f"parsed {len(decls)} declarations from {ORCA_DIR}") + emit(decls) + + +if __name__ == "__main__": + main() diff --git a/scripts/smokeTest.sh b/scripts/smokeTest.sh index 10daf1c..c4c5762 100755 --- a/scripts/smokeTest.sh +++ b/scripts/smokeTest.sh @@ -3601,6 +3601,345 @@ EOF fi rm -f "$cDpFile" "$oDpFile" "$binDpFile" + # Memory-backed file I/O. mfsRegister stages a buffer as a + # named file, then fopen/fread/fwrite/fseek/ftell/fclose + # operate on it. Verifies fopen returns a non-NULL FILE, + # fread copies bytes into the caller's buffer, ftell advances, + # fseek rewinds, fclose succeeds, fprintf into a writable + # in-memory file produces the expected formatted bytes. + log "check: MAME runs memory-backed stdio (fopen/fread/fseek/fprintf)" + cFioFile="$(mktemp --suffix=.c)" + oFioFile="$(mktemp --suffix=.o)" + binFioFile="$(mktemp --suffix=.bin)" + cat > "$cFioFile" <<'EOF' +extern int mfsRegister(const char *path, void *buf, unsigned int size, unsigned int cap, int writable); +extern struct __sFILE *fopen(const char *path, const char *mode); +extern unsigned int fread(void *p, unsigned int s, unsigned int n, struct __sFILE *f); +extern int fseek(struct __sFILE *f, long off, int whence); +extern long ftell(struct __sFILE *f); +extern int fclose(struct __sFILE *f); +extern int fgetc(struct __sFILE *f); +extern int fprintf(struct __sFILE *f, const char *fmt, ...); +extern int strcmp(const char *a, const char *b); +__attribute__((noinline)) void switchToBank2(void) { + __asm__ volatile ("sep #0x20\n.byte 0xa9,0x02\npha\nplb\nrep #0x20\n"); +} +static char data[14] = "Hello, world!"; +static char wbuf[64]; +static char rbuf[32]; +int main(void) { + unsigned short ok = 0; + if (mfsRegister("greet", data, 13, 13, 0) == 0) ok |= 0x01; + struct __sFILE *f = fopen("greet", "r"); + if (f) ok |= 0x02; + unsigned int n = fread(rbuf, 1, 13, f); + rbuf[13] = 0; + if (n == 13 && strcmp(rbuf, "Hello, world!") == 0) ok |= 0x04; + if (ftell(f) == 13L) ok |= 0x08; + fseek(f, 0L, 0); + if (fgetc(f) == 'H') ok |= 0x10; + if (fclose(f) == 0) ok |= 0x20; + if (mfsRegister("out", wbuf, 0, 64, 1) == 0) ok |= 0x40; + f = fopen("out", "w"); + int wlen = fprintf(f, "n=%d", 42); + if (wlen == 4 && wbuf[0] == 'n' && wbuf[1] == '=' && wbuf[2] == '4' && wbuf[3] == '2') + ok |= 0x80; + switchToBank2(); + *(volatile unsigned short *)0x5000 = ok; + while (1) {} +} +EOF + "$CLANG" --target=w65816 -O2 -ffunction-sections -c \ + "$cFioFile" -o "$oFioFile" + "$PROJECT_ROOT/tools/link816" -o "$binFioFile" --text-base 0x1000 \ + "$oCrt0F" "$oLibcF" "$oExtrasF" "$oSnprintfF" \ + "$oSfF" "$oSdF" "$oLibgccFile" "$oFioFile" \ + >/dev/null 2>&1 + if ! bash "$PROJECT_ROOT/scripts/runInMame.sh" "$binFioFile" --check \ + 0x025000=00ff >/dev/null 2>&1; then + die "MAME: memory-backed file I/O bitmap != 0xFF (mfsRegister/fopen/fread/fwrite/fseek regression)" + fi + rm -f "$cFioFile" "$oFioFile" "$binFioFile" + + # wchar.h + signal.h. wcslen/wcscmp/wcscpy/wcschr cover the + # core wide-char family; mbtowc/wctomb verify the trivial 1:1 + # Latin-1 mapping. signal()/raise() are exercised by + # installing a handler, raising, and verifying the handler ran. + log "check: MAME runs wchar.h + signal.h core API" + cWsFile="$(mktemp --suffix=.c)" + oWsFile="$(mktemp --suffix=.o)" + binWsFile="$(mktemp --suffix=.bin)" + cat > "$cWsFile" <<'EOF' +#include +#include +__attribute__((noinline)) void switchToBank2(void) { + __asm__ volatile ("sep #0x20\n.byte 0xa9,0x02\npha\nplb\nrep #0x20\n"); +} +static volatile int sigSeen = 0; +static void onSig(int s) { sigSeen = s; } +int main(void) { + unsigned short ok = 0; + static const wchar_t hello[] = { 'h','e','l','l','o',0 }; + static const wchar_t hellp[] = { 'h','e','l','l','p',0 }; + wchar_t buf[16]; + if (wcslen(hello) == 5) ok |= 0x01; + if (wcscmp(hello, hello) == 0) ok |= 0x02; + if (wcscmp(hello, hellp) < 0) ok |= 0x04; + wcscpy(buf, hello); + if (wcscmp(buf, hello) == 0) ok |= 0x08; + if (wcschr(hello, 'l') == hello + 2) ok |= 0x10; + char mb[8]; wchar_t wc; + int n = mbtowc(&wc, "A", 1); + if (n == 1 && wc == 'A') ok |= 0x20; + if (wctomb(mb, 'Z') == 1 && mb[0] == 'Z') ok |= 0x40; + // signal: install handler, raise, verify it fired. + signal(SIGABRT, onSig); // would normally abort; we override + signal(SIGFPE, onSig); + raise(SIGFPE); + if (sigSeen == SIGFPE) ok |= 0x80; + switchToBank2(); + *(volatile unsigned short *)0x5000 = ok; + while (1) {} +} +EOF + "$CLANG" --target=w65816 -O2 -ffunction-sections -I"$PROJECT_ROOT/runtime/include" -c \ + "$cWsFile" -o "$oWsFile" + "$PROJECT_ROOT/tools/link816" -o "$binWsFile" --text-base 0x1000 \ + "$oCrt0F" "$oLibcF" "$oExtrasF" "$oLibgccFile" "$oWsFile" \ + >/dev/null 2>&1 + if ! bash "$PROJECT_ROOT/scripts/runInMame.sh" "$binWsFile" --check \ + 0x025000=00ff >/dev/null 2>&1; then + die "MAME: wchar/signal core != 0xFF (wcs* / mbtowc / signal/raise regression)" + fi + rm -f "$cWsFile" "$oWsFile" "$binWsFile" + + # C++ subset: classes, single inheritance, virtual functions, + # polymorphism via base-class pointer arrays, virtual dtors. + # Compiled with -fno-exceptions -fno-rtti (the supported subset + # — full RTTI / exceptions / multi-inheritance with virtual + # bases are not supported). + log "check: MAME runs C++ polymorphism (virtuals + single inheritance)" + cppFile="$(mktemp --suffix=.cpp)" + oCppFile="$(mktemp --suffix=.o)" + binCppFile="$(mktemp --suffix=.bin)" + cat > "$cppFile" <<'EOF' +extern "C" __attribute__((noinline)) void switchToBank2(void) { + __asm__ volatile ("sep #0x20\n.byte 0xa9,0x02\npha\nplb\nrep #0x20\n"); +} +class Shape { +public: + virtual int area() const = 0; + virtual int perimeter() const = 0; + virtual ~Shape() {} +}; +class Rect : public Shape { + int w, h; +public: + Rect(int w, int h) : w(w), h(h) {} + int area() const override { return w * h; } + int perimeter() const override { return 2 * (w + h); } +}; +class Square : public Rect { +public: + Square(int s) : Rect(s, s) {} +}; +class Circle : public Shape { + int r; +public: + Circle(int r) : r(r) {} + int area() const override { return (314 * r * r) / 100; } + int perimeter() const override { return (628 * r) / 100; } +}; +static int sumAreas(Shape **shapes, int n) { + int total = 0; + for (int i = 0; i < n; i++) total += shapes[i]->area(); + return total; +} +extern "C" int main(void) { + Rect r(3, 4); Square s(5); Circle c(2); + Shape *arr[3] = { &r, &s, &c }; + int total = sumAreas(arr, 3); + int ok = 0; + if (r.area() == 12) ok |= 1; + if (r.perimeter() == 14) ok |= 2; + if (s.area() == 25) ok |= 4; + if (c.area() == 12) ok |= 8; + if (total == 49) ok |= 0x10; + switchToBank2(); + *(volatile unsigned short *)0x5000 = (unsigned short)ok; + while (1) {} +} +EOF + "$PROJECT_ROOT/tools/llvm-mos-build/bin/clang++" --target=w65816 -O2 \ + -ffunction-sections -fno-exceptions -fno-rtti \ + -c "$cppFile" -o "$oCppFile" + "$PROJECT_ROOT/tools/link816" -o "$binCppFile" --text-base 0x1000 \ + "$oCrt0F" "$oLibgccFile" "$oCppFile" \ + >/dev/null 2>&1 + if ! bash "$PROJECT_ROOT/scripts/runInMame.sh" "$binCppFile" --check \ + 0x025000=001f >/dev/null 2>&1; then + die "MAME: C++ polymorphism != 0x1F (vtable / virtual call regression)" + fi + rm -f "$cppFile" "$oCppFile" "$binCppFile" + + # Real-world: hex dumper using memory-backed file I/O. Reads + # 16 bytes from a registered "in" file, writes a hex+ASCII + # dump to a registered "out" file via fprintf. Verifies the + # output via strstr lookups (clang DCE's static-buffer + # byte-reads after extern fn calls — strstr defeats that). + log "check: MAME runs hex dumper (file I/O + fprintf real-world)" + cHdFile="$(mktemp --suffix=.c)" + oHdFile="$(mktemp --suffix=.o)" + binHdFile="$(mktemp --suffix=.bin)" + cat > "$cHdFile" <<'EOF' +extern int mfsRegister(const char *path, void *buf, unsigned int size, unsigned int cap, int writable); +extern struct __sFILE *fopen(const char *path, const char *mode); +extern int fclose(struct __sFILE *f); +extern int fgetc(struct __sFILE *f); +extern int fprintf(struct __sFILE *f, const char *fmt, ...); +extern char *strstr(const char *h, const char *n); +__attribute__((noinline)) void switchToBank2(void) { + __asm__ volatile ("sep #0x20\n.byte 0xa9,0x02\npha\nplb\nrep #0x20\n"); +} +__attribute__((noinline)) void hexdump(struct __sFILE *in, struct __sFILE *out) { + unsigned int offset = 0; + unsigned char line[16]; + int linelen; + while (1) { + linelen = 0; + while (linelen < 16) { + int c = fgetc(in); + if (c < 0) break; + line[linelen++] = (unsigned char)c; + } + if (linelen == 0) break; + fprintf(out, "%04x: ", offset); + for (int i = 0; i < 16; i++) { + if (i < linelen) fprintf(out, "%02x ", line[i]); + else fprintf(out, " "); + } + fprintf(out, " |"); + for (int i = 0; i < linelen; i++) { + unsigned char c = line[i]; + int p = (c >= 0x20 && c < 0x7F) ? c : '.'; + fprintf(out, "%c", p); + } + fprintf(out, "|\n"); + offset += linelen; + if (linelen < 16) break; + } +} +static char input[16] = { 'H','e','l','l','o','!','\n','A','B','C',0,1,2,3,4,5 }; +static char output[300]; +int main(void) { + mfsRegister("in", input, 16, 16, 0); + mfsRegister("out", output, 0, 300, 1); + struct __sFILE *in = fopen("in", "r"); + struct __sFILE *out = fopen("out", "w"); + hexdump(in, out); + fclose(in); fclose(out); + int ok = 0; + if (strstr(output, "0000:")) ok |= 1; + if (strstr(output, "48 65 6c 6c 6f 21")) ok |= 2; + if (strstr(output, "|Hello!.ABC......|")) ok |= 4; + switchToBank2(); + *(volatile unsigned short *)0x5000 = (unsigned short)ok; + while (1) {} +} +EOF + "$CLANG" --target=w65816 -O2 -ffunction-sections -c \ + "$cHdFile" -o "$oHdFile" + "$PROJECT_ROOT/tools/link816" -o "$binHdFile" --text-base 0x1000 \ + "$oCrt0F" "$oLibcF" "$oExtrasF" "$oSnprintfF" \ + "$oSfF" "$oSdF" "$oLibgccFile" "$oHdFile" \ + >/dev/null 2>&1 + if ! bash "$PROJECT_ROOT/scripts/runInMame.sh" "$binHdFile" --check \ + 0x025000=0007 >/dev/null 2>&1; then + die "MAME: hex dumper output strstr lookups failed" + fi + rm -f "$cHdFile" "$oHdFile" "$binHdFile" + + # Real-world: JSON tokenizer. Walks a literal JSON string, + # producing token-type counts. Exercises a state machine + # over char-by-char input, mixed string/number/keyword + # parsing, strncmp on keywords, and 16-bit globals. ~50 + # lines of code, ~10 distinct token types. + log "check: MAME runs JSON tokenizer (state machine + strncmp)" + cJsFile="$(mktemp --suffix=.c)" + oJsFile="$(mktemp --suffix=.o)" + binJsFile="$(mktemp --suffix=.bin)" + cat > "$cJsFile" <<'EOF' +extern int strncmp(const char *a, const char *b, unsigned int n); +__attribute__((noinline)) void switchToBank2(void) { + __asm__ volatile ("sep #0x20\n.byte 0xa9,0x02\npha\nplb\nrep #0x20\n"); +} +enum { TOK_LBRACE, TOK_RBRACE, TOK_LBRACK, TOK_RBRACK, TOK_COMMA, TOK_COLON, + TOK_STRING, TOK_NUMBER, TOK_TRUE, TOK_FALSE, TOK_NULL, TOK_EOF, TOK_ERR }; +static const char *p; +static int counts[16]; +__attribute__((noinline)) static int nextToken(void) { + while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r') p++; + if (*p == 0) return TOK_EOF; + if (*p == '{') { p++; return TOK_LBRACE; } + if (*p == '}') { p++; return TOK_RBRACE; } + if (*p == '[') { p++; return TOK_LBRACK; } + if (*p == ']') { p++; return TOK_RBRACK; } + if (*p == ',') { p++; return TOK_COMMA; } + if (*p == ':') { p++; return TOK_COLON; } + if (*p == '"') { + p++; + while (*p && *p != '"') p++; + if (*p == '"') p++; + return TOK_STRING; + } + if (*p == '-' || (*p >= '0' && *p <= '9')) { + if (*p == '-') p++; + while (*p >= '0' && *p <= '9') p++; + return TOK_NUMBER; + } + if (strncmp(p, "true", 4) == 0) { p += 4; return TOK_TRUE; } + if (strncmp(p, "false", 5) == 0) { p += 5; return TOK_FALSE; } + if (strncmp(p, "null", 4) == 0) { p += 4; return TOK_NULL; } + return TOK_ERR; +} +__attribute__((noinline)) static void tokenize(const char *src) { + p = src; + int t; + while ((t = nextToken()) != TOK_EOF && t != TOK_ERR) { + if (t < 16) counts[t]++; + } +} +int main(void) { + static const char input[] = + "{\"name\": \"alice\", \"age\": 30, \"isCool\": true, \"things\": [1, 2, null]}"; + tokenize(input); + int ok = 0; + if (counts[TOK_LBRACE] == 1) ok |= 0x01; + if (counts[TOK_RBRACE] == 1) ok |= 0x02; + if (counts[TOK_LBRACK] == 1) ok |= 0x04; + if (counts[TOK_RBRACK] == 1) ok |= 0x08; + if (counts[TOK_COMMA] == 5) ok |= 0x10; + if (counts[TOK_COLON] == 4) ok |= 0x20; + if (counts[TOK_STRING] == 5) ok |= 0x40; + if (counts[TOK_NUMBER] == 3) ok |= 0x80; + if (counts[TOK_TRUE] == 1) ok |= 0x100; + if (counts[TOK_NULL] == 1) ok |= 0x200; + switchToBank2(); + *(volatile unsigned short *)0x5000 = (unsigned short)ok; + while (1) {} +} +EOF + "$CLANG" --target=w65816 -O2 -ffunction-sections -c \ + "$cJsFile" -o "$oJsFile" + "$PROJECT_ROOT/tools/link816" -o "$binJsFile" --text-base 0x1000 \ + "$oCrt0F" "$oLibcF" "$oLibgccFile" "$oJsFile" \ + >/dev/null 2>&1 + if ! bash "$PROJECT_ROOT/scripts/runInMame.sh" "$binJsFile" --check \ + 0x025000=03ff >/dev/null 2>&1; then + die "MAME: JSON tokenizer count bitmap != 0x3ff" + fi + rm -f "$cJsFile" "$oJsFile" "$binJsFile" + rm -f "$oLibcF" "$oStrtolF" "$oSnprintfF" "$oQsortF" \ "$oExtrasF" "$oStrtokF" "$oMathF" "$oSfF" "$oSdF" "$oCrt0F" else @@ -3628,54 +3967,68 @@ EOF die "inline asm: 'inc a' missing from output" fi + # bench.sh runs the size-comparison harness against Calypsi. + # Smoke just verifies it produces a non-empty markdown table — + # actual ratios are reported in STATUS. + log "check: scripts/bench.sh runs (size vs Calypsi)" + benchOut="$(mktemp)" + bash "$PROJECT_ROOT/scripts/bench.sh" >"$benchOut" 2>/dev/null + if ! grep -q '^| \*\*total\*\*' "$benchOut"; then + die "bench.sh did not produce a totals row" + fi + rm -f "$benchOut" + # iigs/toolbox.h compiles cleanly and emits the JSL $E10000 dispatch # for at least one wrapper. Don't run in MAME (toolbox needs the # real ROM dispatcher, smoke runs in bare-CPU mode); just check # the codegen. - log "check: iigs/toolbox.h wrappers compile and emit JSL E10000" + # iigs/toolbox.h — autogenerated wrappers for the entire IIgs + # toolbox (~1300 routines from 35 tool sets, sourced from ORCA-C + # ORCACDefs/ via scripts/genToolbox.py). Names match Apple's + # IIgs Toolbox Reference (TLStartUp, MMStartUp, NewWindow, + # SysBeep, ...). Verify the header compiles, the multi-arg + # asm bodies in iigsToolbox.s assemble, and that linking + # together produces a binary that emits the JSL $E10000 (Tool + # Locator) and JSL $E100A8 (GS/OS) dispatchers. Don't run in + # MAME (toolbox needs the real ROM dispatcher). + log "check: iigs/toolbox.h (autogenerated, ~1300 routines, Apple names)" cToolFile="$(mktemp --suffix=.c)" sToolFile="$(mktemp --suffix=.s)" trap 'rm -f "$irFile" "$sFile" "$irCallFile" "$sCallFile" "$irMaFile" "$sMaFile" "$irI8File" "$sI8File" "$cFile" "$oFile2" "$cI32File" "$oI32File" "$cFibFile" "$sFibFile" "$cMulFile" "$sMulFile" "$cAllocaFile" "$sAllocaFile" "$cStrFile" "$sStrFile" "$cIndFile" "$sIndFile" "$irCoalesceFile" "$sCoalesceFile" "$cMixFile" "$sMixFile" "$cLinkFile" "$oLinkFile" "$oLibgccFile" "$binLinkFile" "$mapLinkFile" "$cFltFile" "$oFltFile" "$oSfFile" "$binFltFile" "$mapFltFile" "$cAsmFile" "$sAsmFile" "$cToolFile" "$sToolFile"' EXIT cat > "$cToolFile" <<'EOF' #include -void greet(void) { - TBoxWriteCString("Hello"); - TBoxBeep(); +// Cover wrappers across multiple tool sets to verify the header +// compiles and the multi-arg asm bodies in iigsToolbox.s link. +void useToolLocator(void) { + TLStartUp(); TLShutDown(); TLBootInit(); TLReset(); + unsigned short v = TLVersion(); (void)v; } -// Cover all wrappers: ensures the multi-arg ones (declared extern in -// the header, implemented in iigsToolbox.s) at least link. -void everything(void) { +void useMM(void) { + unsigned short id = MMStartUp(); + MMShutDown(id); + void *h = NewHandle(1024UL, id, 0, 0UL); + DisposeHandle(h); +} +void useEvent(void) { + unsigned short b = Button(0); (void)b; + unsigned long t = TickCount(); (void)t; +} +void useQD(void) { short rect[4] = {0, 0, 100, 100}; - char buf[20]; - char buf2[16]; - TBoxTLStartUp(); TBoxTLShutDown(); - unsigned short id = TBoxMMStartUp(); - unsigned long h = TBoxNewHandle(1024UL, id, 0, 0UL); - TBoxDisposeHandle(h); - TBoxMMShutDown(id); - TBoxReadAsciiTime(buf); - TBoxMoveTo(10, 20); - TBoxFrameRect(rect); TBoxPaintRect(rect); TBoxEraseRect(rect); - TBoxDrawString("\005hello"); - TBoxQDStartUp(0x80, 0x1A00, id); TBoxQDShutDown(); - TBoxEMStartUp(id); TBoxEMShutDown(); TBoxSystemTask(); - TBoxGetNextEvent(0xFFFF, buf2); - void *win = TBoxNewWindow((const void *)0x5000); - TBoxCloseWindow(win); - char k = TBoxReadKey(); - (void)k; + PaintRect(rect); FrameRect(rect); MoveTo(50, 50); } +void useMisc(void) { SysBeep(); } EOF "$CLANG" --target=w65816 -O2 -I"$PROJECT_ROOT/runtime/include" \ -S "$cToolFile" -o "$sToolFile" if ! grep -qE '\bjsl\s+0xe10000\b' "$sToolFile"; then die "iigs/toolbox.h: JSL \$E10000 (Tool Locator) not emitted" fi - if ! grep -qE '\bldx\s+#0x290[Bb]\b' "$sToolFile"; then - die "iigs/toolbox.h: WriteCString tool number 0x290B not in output" + # SysBeep tool number $2C03 per ORCA (function $2C of Misc Tools $03). + # Match case-insensitively — clang lowercases hex constants. + if ! grep -qiE '\bldx\s+#0x2c03\b' "$sToolFile"; then + die "iigs/toolbox.h: SysBeep tool number 0x2C03 not in output" fi - # Make sure the multi-arg wrappers in iigsToolbox.s assemble and - # linking the test object against them succeeds. oToolFile="$(mktemp --suffix=.o)" oToolboxAsm="$(mktemp --suffix=.o)" "$CLANG" --target=w65816 -O2 -I"$PROJECT_ROOT/runtime/include" \ diff --git a/src/llvm/lib/Target/W65816/W65816AsmPrinter.cpp b/src/llvm/lib/Target/W65816/W65816AsmPrinter.cpp index 9b8412c..d8463e6 100644 --- a/src/llvm/lib/Target/W65816/W65816AsmPrinter.cpp +++ b/src/llvm/lib/Target/W65816/W65816AsmPrinter.cpp @@ -107,8 +107,11 @@ void W65816AsmPrinter::emitInstruction(const MachineInstr *MI) { getSubtargetInfo().getFeatureBits()); // Drop a SEP that the previous LDAi8imm expansion marked redundant. - // The LDAi8imm peephole leaves M=8 set when its successor is a SEP - // #$20 — that SEP would re-set the same flag, so we elide it. + // The LDAi8imm peephole leaves M=8 set when its successor (or the + // next non-mode-neutral MI) is a SEP #$20 — that SEP would re-set + // the same flag, so we elide it. Mode-neutral MIs (X-flag-only + // index ops, branches, transfers that don't touch A) pass through + // freely without invalidating the skip. if (SkipNextSepImm >= 0 && !MI->isDebugInstr()) { if (MI->getOpcode() == W65816::SEP && MI->getNumOperands() >= 1 && MI->getOperand(0).isImm() && @@ -116,10 +119,29 @@ void W65816AsmPrinter::emitInstruction(const MachineInstr *MI) { SkipNextSepImm = -1; return; // consume the SEP, don't emit } - // Conservative: any non-debug, non-matching MI between LDAi8imm - // and the expected SEP invalidates the elision (it might re-clear - // M, observe P, etc.). Reset and proceed normally. - SkipNextSepImm = -1; + // Check if MI is mode-neutral; if so, pass through and KEEP the skip. + bool isMNeutral = false; + if (MI->isBranch() || MI->isReturn()) isMNeutral = true; + else switch (MI->getOpcode()) { + case W65816::LDX_Imm16: case W65816::LDX_DP: case W65816::LDX_Abs: + case W65816::LDX_DPY: case W65816::LDX_AbsY: + case W65816::LDY_Imm16: case W65816::LDY_DP: case W65816::LDY_Abs: + case W65816::LDY_DPX: case W65816::LDY_AbsX: + case W65816::STX_DP: case W65816::STX_Abs: case W65816::STX_DPY: + case W65816::STY_DP: case W65816::STY_Abs: case W65816::STY_DPX: + case W65816::INX: case W65816::DEX: + case W65816::INY: case W65816::DEY: + case W65816::CPX_Imm16: case W65816::CPX_DP: case W65816::CPX_Abs: + case W65816::CPY_Imm16: case W65816::CPY_DP: case W65816::CPY_Abs: + case W65816::PHX: case W65816::PHY: + case W65816::PLX: case W65816::PLY: + case W65816::NOP: + isMNeutral = true; break; + default: break; + } + // Anything else invalidates the elision (might re-clear M, push/pop + // 8-bit P that observes mode, call out, etc.). + if (!isMNeutral) SkipNextSepImm = -1; } // Drop the STAabs that the LDAi16imm-0 peephole replaced with STZ. @@ -318,8 +340,37 @@ void W65816AsmPrinter::emitInstruction(const MachineInstr *MI) { Lda.addOperand(MCOperand::createImm(Val)); EmitToStreamer(*OutStreamer, Lda); bool SkipRep = false; + // Walk past mode-neutral MIs (X-flag-only ops, branches, transfers + // that don't touch A) to find the next SEP/REP — same idea as the + // pre-emit REP/SEP scheduler, but applied to LDAi8imm's closing + // REP. If a SEP #$20 sits there, we can elide the REP+SEP pair. + auto isMNeutralMI = [](const MachineInstr &MI) -> bool { + if (MI.isDebugInstr()) return true; + if (MI.isBranch() || MI.isReturn()) return true; + unsigned O = MI.getOpcode(); + switch (O) { + case W65816::LDX_Imm16: case W65816::LDX_DP: case W65816::LDX_Abs: + case W65816::LDX_DPY: case W65816::LDX_AbsY: + case W65816::LDY_Imm16: case W65816::LDY_DP: case W65816::LDY_Abs: + case W65816::LDY_DPX: case W65816::LDY_AbsX: + case W65816::STX_DP: case W65816::STX_Abs: case W65816::STX_DPY: + case W65816::STY_DP: case W65816::STY_Abs: case W65816::STY_DPX: + case W65816::INX: case W65816::DEX: + case W65816::INY: case W65816::DEY: + case W65816::CPX_Imm16: case W65816::CPX_DP: case W65816::CPX_Abs: + case W65816::CPY_Imm16: case W65816::CPY_DP: case W65816::CPY_Abs: + case W65816::PHX: case W65816::PHY: + case W65816::PLX: case W65816::PLY: + case W65816::CLC: case W65816::SEC: + case W65816::PHP: case W65816::PLP: + case W65816::NOP: + return true; + default: + return false; + } + }; auto It = std::next(MI->getIterator()); - while (It != MI->getParent()->end() && It->isDebugInstr()) ++It; + while (It != MI->getParent()->end() && isMNeutralMI(*It)) ++It; if (It != MI->getParent()->end() && It->getOpcode() == W65816::SEP && It->getNumOperands() >= 1 && It->getOperand(0).isImm() && diff --git a/src/llvm/lib/Target/W65816/W65816SepRepCleanup.cpp b/src/llvm/lib/Target/W65816/W65816SepRepCleanup.cpp index 9b9e780..420df02 100644 --- a/src/llvm/lib/Target/W65816/W65816SepRepCleanup.cpp +++ b/src/llvm/lib/Target/W65816/W65816SepRepCleanup.cpp @@ -307,6 +307,93 @@ bool W65816SepRepCleanup::runOnMachineFunction(MachineFunction &MF) { Changed = true; } + // Extended toggle coalesce — REP/SEP scheduling. + // + // Walk the MBB looking for `T1 ; ...neutral... ; T2` where T1 and + // T2 are opposite-polarity SEP/REP toggles (T1=REP T2=SEP, or + // vice versa) with the same imm, and the gap contains only + // M-mode-neutral instructions (transfers/branches/X-flag-only + // index ops). In that case T1+T2 form a no-op pair around code + // that doesn't care about M, so both can be dropped. Equivalent + // to "moving the SEP/REP wrap inward to skip the neutral region". + // + // Saves 4 bytes / 12 cycles per gap collapsed. The common + // trigger is two STA8 stores separated by an LDY for the second + // store's address — STA8fi each emit SEP/STA/REP, the existing + // adjacent coalesce can't see across the LDY, this pass can. + { + // Mode-neutral instruction set: don't touch the M-bit and + // don't depend on A's width. X-flag dependent ops (LDX/LDY/ + // STX/STY/INX/DEX/INY/DEY/CPX/CPY/PHX/PHY/PLX/PLY) are + // independent of M. So are all branches, JMP/JSR/JSL/RTL/RTS, + // CLC/SEC/CLI/SEI/CLD/SED/CLV, NOP, and PHP/PLP (they push + // 8-bit P regardless of M). + auto isMNeutral = [](const MachineInstr &MI) -> bool { + if (MI.isDebugInstr()) return true; + if (MI.isBranch() || MI.isReturn()) return true; + unsigned O = MI.getOpcode(); + switch (O) { + case W65816::LDX_Imm16: case W65816::LDX_DP: case W65816::LDX_Abs: + case W65816::LDX_DPY: case W65816::LDX_AbsY: + case W65816::LDY_Imm16: case W65816::LDY_DP: case W65816::LDY_Abs: + case W65816::LDY_DPX: case W65816::LDY_AbsX: + case W65816::STX_DP: case W65816::STX_Abs: case W65816::STX_DPY: + case W65816::STY_DP: case W65816::STY_Abs: case W65816::STY_DPX: + case W65816::INX: case W65816::DEX: + case W65816::INY: case W65816::DEY: + case W65816::CPX_Imm16: case W65816::CPX_DP: case W65816::CPX_Abs: + case W65816::CPY_Imm16: case W65816::CPY_DP: case W65816::CPY_Abs: + case W65816::PHX: case W65816::PHY: + case W65816::PLX: case W65816::PLY: + case W65816::CLC: case W65816::SEC: + case W65816::PHP: case W65816::PLP: + case W65816::NOP: + return true; + default: + return false; + } + }; + + bool again = true; + while (again) { + again = false; + for (auto It = MBB.begin(); It != MBB.end(); ++It) { + unsigned Op1 = It->getOpcode(); + if (Op1 != W65816::REP && Op1 != W65816::SEP) continue; + if (It->getNumOperands() < 1 || !It->getOperand(0).isImm()) continue; + int Imm1 = It->getOperand(0).getImm(); + if (Imm1 != 0x20) continue; // M-bit only + // Walk forward across mode-neutral ops looking for the matching + // opposite toggle. Bail at calls, asm, ALU ops on A, etc. + unsigned WantOp = (Op1 == W65816::REP) ? W65816::SEP : W65816::REP; + auto Walker = std::next(It); + MachineInstr *Match = nullptr; + while (Walker != MBB.end()) { + if (Walker->isDebugInstr()) { ++Walker; continue; } + unsigned WO = Walker->getOpcode(); + if (WO == WantOp && Walker->getNumOperands() >= 1 && + Walker->getOperand(0).isImm() && + Walker->getOperand(0).getImm() == Imm1) { + Match = &*Walker; + break; + } + // Bail on anything that touches A or otherwise cares about M. + if (Walker->isCall() || Walker->isInlineAsm()) break; + if (!isMNeutral(*Walker)) break; + ++Walker; + } + if (!Match) continue; + // Drop both toggles. Erasing changes iterator stability; restart. + MachineInstr *T1 = &*It; + T1->eraseFromParent(); + Match->eraseFromParent(); + Changed = true; + again = true; + break; + } + } + } + // Second peephole: collapse `ADCi16imm src, ±1/±2` (and SBCi16imm) // into INA/DEA chains when the carry flag they would set is unused. // ADCi16imm is a pseudo (expands to CLC+ADC_Imm16); we rewrite it