@8bitscript/pet 0.1.0

package/src/text.8bs

@@ -0,0 +1,165 @@
+// @8bitscript/pet/text — the PET's implementation of @8bitscript/text.
+//
+// Named by "8bitscript".exports["./text"] in this package's package.json,
+// and what
+//
+//     import { text } from "@8bitscript/text";
+//
+// resolves to when the build is for the PET. Built on the register
+// @8bitscript/pet exports. Every machine's text.8bs exports this same
+// namespace — the same names, the same shapes, ASCII codes, and a cell 0
+// at the top-left corner of the screen — so a program that imports it from
+// @8bitscript/text draws the same thing on every target.
+import { viaPeripheralControl } from "./index.8bs";
+import { Video } from "./geometry.8bs";
+
+// PET screen memory is at $8000 on every model: 1000 cells for the 40x25
+// display of the 2001/3xxx/4xxx machines, 2000 for the 80x25 of the 8032 —
+// which is the build's `--profile` to say (PET_PROFILES in
+// packages/backend-6502), and reaches this file as ./geometry.8bs's
+// `Video` namespace, whose 8032 version the profile selects. There is no
+// colour RAM to go with it — a character's screen code alone decides how it
+// looks — so `putColor` exists only so portable code written against every
+// machine's `text` namespace still compiles; it does nothing, the same way
+// this package's `screen.setColors()` does nothing.
+//
+// `text.putChar` takes ASCII on every machine — space (32), '0'-'9'
+// (48-57), 'A'-'Z' (65-90) and the punctuation `! , - . : ?` — upper case
+// only: that is the portable set, the characters every target's character
+// set has (the NES ships its own font, and that is what it has). The PET
+// wants screen codes: codes 32-63 are those same ASCII values, and 'A'-'Z'
+// are 1-26, so asciiToScreenCode() moves 64-95 down by 64 and leaves 32-63
+// alone. Whether 1-26 then LOOK like 'A'-'Z' or 'a'-'z' is the character
+// set's choice, and on the PET that is the editor ROM's boot state: the
+// graphics-keyboard 3032/4032 boot in the upper-case ("graphics") set, the
+// business-keyboard 8032 (xpet's default model) in the lower-case ("text")
+// set. So putChar() selects the graphics set itself, every call, through
+// the VIA's peripheral control register (see @8bitscript/pet): one register
+// write, and "TICK" reads as TICK here on every model the way it does on
+// every other target. (LLVM-MOS's libc used to flip every Commodore machine
+// to lower-case before main() with a hidden CHR$(14) through the KERNAL;
+// packages/backend-6502's commodoreCharsetGuard() keeps that out of the
+// link. See packages/pet/AGENTS.md.)
+namespace CharacterSet {
+    const GRAPHICS: utinyint = 0x0C;
+}
+
+function asciiToScreenCode(code: utinyint): utinyint {
+    if (code >= 64 && code < 96) {
+        return code - 64;
+    }
+    return code;
+}
+
+// ---- print: strings and number fields ------------------------------------
+//
+// `text.print(cell, s)` writes a string's characters into consecutive
+// cells from `cell`, and `text.printNumber(cell, value, width)` writes
+// `value` as exactly `width` decimal digits, zero-padded and right-aligned,
+// so a field on a HUD never shifts columns. Both draw in the current colour —
+// white until `text.setColor(TextColor.CYAN)` changes it, and that one
+// call then colours everything printed after it, on the machines that have
+// per-cell colour. They are also the two
+// functions the compiler's template layout targets: `text.print(0,
+// \`TICK ${ticks:1}\`)` is laid out at compile time into these same calls
+// (see packages/compiler/src/ir).
+//
+// Under them: `place()` puts one character at one cell in the current
+// colour, and is all a run of text costs per character, with `prepare()` selecting the
+// graphics set once for the run.
+// `text.putChar` and `text.putColor` stay the one-cell pokes a caller can
+// build anything from.
+let currentColor: utinyint = 1; // white, until text.setColor() says otherwise
+let currentReverse: bool = false; // until text.setReverse() says otherwise
+
+// Reverse video is bit 7 of the screen code: 128-255 are the ROM's
+// inverted copies of 0-127. A reverse space is a solid block.
+function toScreen(code: utinyint): utinyint {
+    let screen: utinyint = asciiToScreenCode(code);
+    if (currentReverse) {
+        screen = screen + 128;
+    }
+    return screen;
+}
+
+// What a run of text needs once, before its first character.
+function prepare(): void {
+    viaPeripheralControl = CharacterSet.GRAPHICS;
+}
+
+function place(cell: usmallint, code: utinyint): void {
+    memory.write(0x8000 + cell, toScreen(code));
+}
+
+// ---- digits -------------------------------------------------------------
+//
+// A number is written one place at a time, high to low, by subtracting the
+// place value until it no longer fits: the 6502 has no divide instruction,
+// and `value / 10` would link a 250-byte routine to do it. Places above the
+// field are still taken off, so a field narrower than its number shows the
+// low digits; places the number does not reach print as zeros.
+const DIGIT_PLACES: array<usmallint, 5> = [10000, 1000, 100, 10, 1];
+
+export namespace text {
+    const CELL_COUNT: usmallint = Video.CELL_COUNT; // 40 x 25, or 80 x 25 on the 8032 profile
+    const COLUMNS: utinyint = Video.COLUMNS; // cells per row, so cell = y * text.COLUMNS + x
+
+    function putChar(cell: usmallint, code: utinyint): void {
+        prepare();
+        memory.write(0x8000 + cell, toScreen(code));
+    }
+
+    function putColor(cell: usmallint, color: utinyint): void {
+        // Deliberately empty — the PET has no colour RAM.
+    }
+
+    function setColor(color: utinyint): void {
+        currentColor = color;
+    }
+
+    function setReverse(on: bool): void {
+        currentReverse = on;
+    }
+
+    function print(cell: usmallint, s: string): void {
+        prepare();
+        for (let i: utinyint = 0; i < s.length; i++) {
+            place(cell + i, s[i]);
+        }
+    }
+
+    function printNumber(cell: usmallint, value: usmallint, width: utinyint): void {
+        prepare();
+        let k: utinyint = width;
+        if (k < DIGIT_PLACES.length) {
+            k = DIGIT_PLACES.length;
+        }
+        while (k > 0) {
+            let digit: utinyint = 48; // '0'
+            if (k <= DIGIT_PLACES.length) {
+                while (value >= DIGIT_PLACES[DIGIT_PLACES.length - k]) {
+                    value = value - DIGIT_PLACES[DIGIT_PLACES.length - k];
+                    digit++;
+                }
+            }
+            if (k <= width) {
+                place(cell + width - k, digit);
+            }
+            k--;
+        }
+    }
+}
+
+// The colours `text.setColor()` takes. The PET has no colour RAM, so the
+// names are here for a program that compiles everywhere and their values
+// go nowhere.
+export namespace TextColor {
+    const BLACK: utinyint = 0;
+    const WHITE: utinyint = 1;
+    const RED: utinyint = 2;
+    const CYAN: utinyint = 3;
+    const PURPLE: utinyint = 4;
+    const GREEN: utinyint = 5;
+    const BLUE: utinyint = 6;
+    const YELLOW: utinyint = 7;
+}