rk86 2.0.29 → 2.0.31

package/README.md

@@ -31,6 +31,8 @@ bunx rk86 --online CHESS.GAM       # открыть файл в онлайн-э
   --memory-to <адрес>      конец области дампа памяти включительно (по умолчанию: 0xFFFF)
   --screen <файл>          сохранить экран 78x30 как текст при выходе
   --input <seq>            инъекция клавиш (через запятую): KeyA,Digit1,Enter,...
+  --color <0|1|2|3>        режим цвета: 0=ч/б (по умолчанию), 1=Толкалин,
+                           2=Акименко, 3=Апогей
   --online                 открыть в онлайн-эмуляторе rk86.ru
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rk86",
-    "version": "2.0.29",
+    "version": "2.0.31",
     "description": "Эмулятор Радио-86РК (Intel 8080) для терминала",
     "bin": {
         "rk86": "rk86.js"
@@ -18,6 +18,6 @@
     "license": "MIT",
     "repository": {
         "type": "git",
-        "url": "https://github.com/begoon/rk86-js-web"
+        "url": "https://github.com/begoon/rk86-js"
     }
 }

package/rk86.js

@@ -165,6 +165,7 @@ function preprocess(source) {
   const out = [];
   const stack = [];
   let counter = 0;
+  let procCounter = 0;
   let proc = null;
   for (let i = 0;i < lines.length; i++) {
     const line = lines[i];
@@ -223,7 +224,14 @@ function preprocess(source) {
           regs.push(up);
         }
       }
-      proc = { regs, line: orig, source: line };
+      const id = procCounter++;
+      proc = {
+        regs,
+        line: orig,
+        source: line,
+        exitLabel: `__proc_${id}_exit`,
+        returnUsed: false
+      };
       out.push({ text: `${name}:`, orig });
       for (const r of regs) {
         out.push({ text: `	PUSH ${r}`, orig });
@@ -237,6 +245,9 @@ function preprocess(source) {
       if (!proc) {
         throw new AsmError(".endp without .proc", orig, line, firstNonSpaceCol(line));
       }
+      if (proc.returnUsed) {
+        out.push({ text: `${proc.exitLabel}:`, orig });
+      }
       out.push(...popsAndRet(proc.regs, orig));
       proc = null;
       continue;
@@ -245,7 +256,12 @@ function preprocess(source) {
       if (!proc) {
         throw new AsmError(".return outside .proc", orig, line, firstNonSpaceCol(line));
       }
-      out.push(...popsAndRet(proc.regs, orig));
+      if (proc.regs.length === 0) {
+        out.push({ text: `	RET`, orig });
+      } else {
+        proc.returnUsed = true;
+        out.push({ text: `	JMP ${proc.exitLabel}`, orig });
+      }
       continue;
     }
     out.push({ text: line, orig });
@@ -742,6 +758,7 @@ function countDb(operands) {
 function asm(source) {
   const pp = preprocess(source);
   const symbols = new Map;
+  const pending = [];
   let pc = 0;
   let lastLabel = "";
   let ended = false;
@@ -760,7 +777,7 @@ function asm(source) {
             lastLabel = parts.label;
           }
           if (parts.isEqu) {
-            symbols.set(labelName.toUpperCase(), evalExpr(parts.operands[0], symbols, pc, lastLabel));
+            tryDefineEqu(symbols, pending, labelName, parts.operands[0], pc, lastLabel, orig, line);
             continue;
           }
           symbols.set(labelName.toUpperCase(), pc);
@@ -800,6 +817,7 @@ function asm(source) {
       throw new AsmError(e.message, orig, line, firstNonSpaceCol(line));
     }
   }
+  resolvePendingEqus(symbols, pending);
   const sections = [];
   let current = null;
   const sectionNames = new Set;
@@ -861,6 +879,50 @@ function asm(source) {
   }
   return sections;
 }
+function isUnknownSymbolErr(e) {
+  return e instanceof Error && /^unknown symbol:/.test(e.message);
+}
+function tryDefineEqu(symbols, pending, name, expr, pc, lastLabel, orig, line) {
+  try {
+    symbols.set(name.toUpperCase(), evalExpr(expr, symbols, pc, lastLabel));
+  } catch (e) {
+    if (isUnknownSymbolErr(e)) {
+      pending.push({ name, expr, pc, lastLabel, orig, line });
+    } else {
+      throw e;
+    }
+  }
+}
+function resolvePendingEqus(symbols, pending) {
+  while (pending.length > 0) {
+    let progress = false;
+    const next = [];
+    for (const p of pending) {
+      try {
+        symbols.set(p.name.toUpperCase(), evalExpr(p.expr, symbols, p.pc, p.lastLabel));
+        progress = true;
+      } catch (e) {
+        if (isUnknownSymbolErr(e)) {
+          next.push(p);
+        } else {
+          throw new AsmError(e.message, p.orig, p.line, firstNonSpaceCol(p.line));
+        }
+      }
+    }
+    if (!progress) {
+      const p = next[0];
+      try {
+        evalExpr(p.expr, symbols, p.pc, p.lastLabel);
+      } catch (e) {
+        throw new AsmError(e.message, p.orig, p.line, firstNonSpaceCol(p.line));
+      }
+      return;
+    }
+    pending.length = 0;
+    pending.push(...next);
+  }
+}
+var DATA_DIRECTIVES = new Set(["DB", "DW", "DS"]);
 if (false) {}
 
 // src/lib/terminal/rk86_terminal.ts
@@ -871,7 +933,7 @@ import { basename } from "path";
 // packages/rk86/package.json
 var package_default = {
   name: "rk86",
-  version: "2.0.28",
+  version: "2.0.30",
   description: "\u042D\u043C\u0443\u043B\u044F\u0442\u043E\u0440 \u0420\u0430\u0434\u0438\u043E-86\u0420\u041A (Intel 8080) \u0434\u043B\u044F \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B\u0430",
   bin: {
     rk86: "rk86.js"
@@ -889,10 +951,63 @@ var package_default = {
   license: "MIT",
   repository: {
     type: "git",
-    url: "https://github.com/begoon/rk86-js-web"
+    url: "https://github.com/begoon/rk86-js"
   }
 };
 
+// src/lib/core/rk86_colors.ts
+var COLOR_MODES = ["mono", "color1", "color2", "color3"];
+var DEFAULT_COLOR_MODE = "color1";
+function attrToRgb(mode, attrs) {
+  const hglt = (attrs & 1) !== 0;
+  const gpa0 = (attrs & 4) !== 0;
+  const gpa1 = (attrs & 8) !== 0;
+  switch (mode) {
+    case "color1": {
+      const rgb = (gpa1 ? 255 : 0) | (gpa0 ? 65280 : 0) | (hglt ? 16711680 : 0);
+      return rgb === 0 ? 12632256 : rgb;
+    }
+    case "color2":
+      return (gpa0 ? 0 : 16711680) | (gpa1 ? 0 : 65280) | (hglt ? 0 : 255);
+    case "color3":
+      return (gpa0 ? 0 : 255) | (gpa1 ? 0 : 65280) | (hglt ? 0 : 16711680);
+    case "mono":
+    default:
+      return 12632256;
+  }
+}
+function hasCellOffset(mode) {
+  return mode !== "color3";
+}
+function rgbToAnsiBaseFg(rgb) {
+  const r = rgb >> 16 & 255;
+  const g = rgb >> 8 & 255;
+  const b = rgb & 255;
+  const palette = [
+    [30, 0, 0, 0],
+    [31, 255, 0, 0],
+    [32, 0, 255, 0],
+    [33, 255, 255, 0],
+    [34, 0, 0, 255],
+    [35, 255, 0, 255],
+    [36, 0, 255, 255],
+    [37, 255, 255, 255]
+  ];
+  let best = 37;
+  let bestDist = Infinity;
+  for (const [code, pr, pg, pb] of palette) {
+    const dr = r - pr;
+    const dg = g - pg;
+    const db = b - pb;
+    const dist = dr * dr + dg * dg + db * db;
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = code;
+    }
+  }
+  return best;
+}
+
 // src/lib/core/hex.ts
 function hex(v, prefix) {
   return v.toString(16).toUpperCase();
@@ -2208,6 +2323,8 @@ class Memory {
       return;
     }
     if (vg75_reg === 49152 && this.vg75_c001_00_cmd === 3) {
+      this.machine.screen.set_char_height((byte & 15) + 1);
+      this.machine.screen.underline_scanline = byte >> 4 & 15;
       this.vg75_c001_00_cmd += 1;
       return;
     }
@@ -2301,6 +2418,9 @@ class Memory {
 // src/lib/core/rk86_runner.ts
 class Runner {
   paused = false;
+  turbo = false;
+  hardware_id_enabled = false;
+  stc_streak = 0;
   tracer = null;
   last_instructions = [];
   previous_batch_time = 0;
@@ -2322,7 +2442,7 @@ class Runner {
     this.machine.cpu.jump(63488);
   }
   interrupt(iff) {
-    if (!this.sound)
+    if (!this.sound || this.turbo)
       return;
     if (this.last_iff == iff)
       return;
@@ -2347,8 +2467,11 @@ class Runner {
     }
   }
   execute(options = {}) {
-    const { terminate_address, on_terminate, exit_on_halt, on_batch_complete, turbo } = options;
+    const { terminate_address, on_terminate, exit_on_halt, on_halt, on_batch_complete } = options;
+    if (options.turbo !== undefined)
+      this.turbo = options.turbo;
     clearTimeout(this.execute_timer);
+    const turbo = this.turbo;
     const bursts = turbo ? 100 : 1;
     for (let burst = 0;burst < bursts; burst++) {
       if (this.paused)
@@ -2365,10 +2488,21 @@ class Runner {
         if (this.last_instructions.length > 5) {
           this.last_instructions.shift();
         }
+        const opcode_pc = this.machine.cpu.pc;
         this.machine.memory.invalidate_access_variables();
         const instruction_ticks = this.machine.cpu.instruction();
         batch_ticks += instruction_ticks;
         this.total_ticks += instruction_ticks;
+        if (this.hardware_id_enabled) {
+          if (this.machine.memory.read_raw(opcode_pc) === 55) {
+            if (++this.stc_streak >= 4) {
+              this.stc_streak = 0;
+              this.fire_hardware_id();
+            }
+          } else {
+            this.stc_streak = 0;
+          }
+        }
         if (this.tracer) {
           this.tracer("after");
           if (this.paused)
@@ -2382,9 +2516,13 @@ class Runner {
           on_terminate?.();
           return;
         }
-        if (exit_on_halt && this.machine.memory.read_raw(this.machine.cpu.pc) === 118) {
-          on_terminate?.();
-          return;
+        if (this.machine.memory.read_raw(this.machine.cpu.pc) === 118) {
+          if (exit_on_halt) {
+            on_terminate?.();
+            return;
+          }
+          if (on_halt && on_halt())
+            return;
         }
       }
       const now = performance.now();
@@ -2407,6 +2545,13 @@ class Runner {
     this.machine.cpu.jump(63488);
     this.machine.keyboard.reset();
   }
+  fire_hardware_id() {
+    const colorIdx = COLOR_MODES.indexOf(this.machine.screen.color_mode);
+    this.machine.cpu.set_a(1);
+    this.machine.cpu.set_b(colorIdx < 0 ? 0 : colorIdx);
+    this.machine.cpu.set_c(this.turbo ? 1 : 0);
+    this.machine.cpu.cf = 0;
+  }
 }
 
 // src/lib/core/rk86_screen.ts
@@ -2427,6 +2572,9 @@ class Screen {
   video_memory_base = 0;
   video_memory_size = 0;
   transparent_attr = false;
+  char_height = 10;
+  underline_scanline = 7;
+  color_mode = DEFAULT_COLOR_MODE;
   ready = false;
   renderer;
   constructor(machine) {
@@ -2486,6 +2634,11 @@ class Screen {
   }
   last_flip_ticks = 0;
   tick_cursor(total_ticks, ticks_per_flip) {
+    if (this.machine.runner.turbo) {
+      this.cursor_state = true;
+      this.last_flip_ticks = total_ticks;
+      return;
+    }
     while (total_ticks - this.last_flip_ticks >= ticks_per_flip) {
       this.cursor_state = !this.cursor_state;
       this.last_flip_ticks += ticks_per_flip;
@@ -2502,7 +2655,7 @@ class Screen {
     this.width = width;
     this.height = height;
     this.video_memory_size = width * height;
-    this.machine.ui.update_screen_geometry(this.width, this.height);
+    this.machine.ui.update_screen_geometry(this.width, this.height, this.char_height);
     if (this.last_width === this.width && this.last_height === this.height)
       return;
     this.machine.log(`\u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D \u0440\u0430\u0437\u043C\u0435\u0440 \u044D\u043A\u0440\u0430\u043D\u0430: ${width} x ${height}`);
@@ -2511,6 +2664,12 @@ class Screen {
     if (this.last_video_memory_base !== -1)
       this.ready = true;
   }
+  set_char_height(char_height) {
+    if (this.char_height === char_height)
+      return;
+    this.char_height = char_height;
+    this.machine.ui.update_screen_geometry(this.width, this.height, this.char_height);
+  }
   last_video_memory_base = -1;
   set_video_memory(base) {
     this.video_memory_base = base;
@@ -2848,16 +3007,17 @@ class TerminalRenderer {
     const dim = "\x1B[2m";
     const reset = "\x1B[0m";
     const w = screen.width;
-    const ANSI_FG = ["37", "33", "35", "31", "36", "32", "34", "30"];
+    const mode = screen.color_mode;
     let output = "\x1B[H";
     output += `${dim}\u250C${"\u2500".repeat(w)}\u2510${reset}
 `;
     const transparent = screen.transparent_attr;
+    const offset = hasCellOffset(mode) && !transparent;
     const blinkOff = Math.floor(Date.now() / 320) % 2 === 1;
     const FA_PENDING = -1;
     let addr = screen.video_memory_base;
     let frameStopped = false;
-    let color = 0;
+    let latchedAttrs = 0;
     let blink = false;
     for (let y = 0;y < screen.height; y++) {
       let line = `${dim}\u2502${reset}`;
@@ -2877,23 +3037,23 @@ class TerminalRenderer {
             continue;
           }
           if (raw >= 240) {
-            cells[cellCount++] = { ch: 0, color, blink };
+            cells[cellCount++] = { ch: 0, attrs: latchedAttrs, blink, isFA: false };
             rowStopped = true;
             if (raw >= 248)
               frameStopped = true;
           } else if (raw >= 192) {
-            cells[cellCount++] = { ch: 0, color, blink };
+            cells[cellCount++] = { ch: 0, attrs: latchedAttrs, blink, isFA: false };
           } else if (raw >= 128) {
-            color = (raw & 1) << 2 | (raw & 12) >> 2;
+            latchedAttrs = raw;
             blink = (raw & 2) !== 0;
-            cells[cellCount++] = { ch: FA_PENDING, color, blink };
+            cells[cellCount++] = { ch: FA_PENDING, attrs: latchedAttrs, blink, isFA: true };
             fifoFlag = true;
           } else {
-            cells[cellCount++] = { ch: raw, color, blink };
+            cells[cellCount++] = { ch: raw, attrs: latchedAttrs, blink, isFA: false };
           }
         }
         while (cellCount < w)
-          cells[cellCount++] = { ch: 0, color, blink };
+          cells[cellCount++] = { ch: 0, attrs: latchedAttrs, blink, isFA: false };
         let fifoIdx = 0;
         for (let x = 0;x < w; ++x) {
           if (cells[x].ch === FA_PENDING) {
@@ -2910,6 +3070,7 @@ class TerminalRenderer {
         for (let x = 0;x < w; x++) {
           const raw = memory.read(addr + x);
           let ch;
+          let isFA = false;
           if (rowStopped) {
             ch = 0;
           } else if (raw >= 240) {
@@ -2920,27 +3081,46 @@ class TerminalRenderer {
           } else if (raw >= 192) {
             ch = 0;
           } else if (raw >= 128) {
-            color = (raw & 1) << 2 | (raw & 12) >> 2;
+            latchedAttrs = raw;
             blink = (raw & 2) !== 0;
             ch = 0;
+            isFA = true;
           } else {
             ch = raw;
           }
-          cells[x] = { ch, color, blink };
+          cells[x] = { ch, attrs: latchedAttrs, blink, isFA };
         }
         addr += w;
       }
-      let prevColor = -1;
+      let prevAnsi = -1;
+      let prevReverse = false;
+      let prevUnderline = false;
       for (let x = 0;x < w; x++) {
         const cell = cells[x];
         const ch = cell.blink && blinkOff ? 0 : cell.ch;
         const glyph = rk86char(ch);
-        if (cell.color !== prevColor) {
-          line += `\x1B[${ANSI_FG[cell.color]}m`;
-          prevColor = cell.color;
+        let colorAttrs = cell.attrs;
+        if (offset && x + 1 < w && cells[x + 1].isFA) {
+          colorAttrs = cells[x + 1].attrs;
+        }
+        const ansi = rgbToAnsiBaseFg(attrToRgb(mode, colorAttrs));
+        const reverse = !cell.isFA && (cell.attrs & 16) !== 0;
+        const underline = !cell.isFA && (cell.attrs & 32) !== 0;
+        if (ansi !== prevAnsi) {
+          line += `\x1B[${ansi}m`;
+          prevAnsi = ansi;
+        }
+        if (reverse !== prevReverse) {
+          line += reverse ? `\x1B[7m` : `\x1B[27m`;
+          prevReverse = reverse;
+        }
+        if (underline !== prevUnderline) {
+          line += underline ? `\x1B[4m` : `\x1B[24m`;
+          prevUnderline = underline;
         }
         if (x === screen.cursor_x && y === screen.cursor_y) {
           line += `\x1B[4m${glyph}\x1B[24m`;
+          prevUnderline = false;
         } else {
           line += glyph;
         }
@@ -3106,6 +3286,8 @@ function printHelp() {
   --snapshot <\u0444\u0430\u0439\u043B>        \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u0441\u043D\u0438\u043C\u043E\u043A \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F (JSON) \u043F\u0440\u0438 \u0432\u044B\u0445\u043E\u0434\u0435
   --input <seq>            \u0438\u043D\u044A\u0435\u043A\u0446\u0438\u044F \u043A\u043B\u0430\u0432\u0438\u0448 (\u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043F\u044F\u0442\u0443\u044E): KeyA,Digit1,Enter,...
                            \u0442\u043E\u043A\u0435\u043D *N \u0437\u0430\u0434\u0430\u0451\u0442 \u043F\u0430\u0443\u0437\u0443 N \u043C\u0441 (\u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440 *200)
+  --color <0|1|2|3>        \u0440\u0435\u0436\u0438\u043C \u0446\u0432\u0435\u0442\u0430: 0=\u0447/\u0431 (\u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E), 1=\u0422\u043E\u043B\u043A\u0430\u043B\u0438\u043D,
+                           2=\u0410\u043A\u0438\u043C\u0435\u043D\u043A\u043E, 3=\u0410\u043F\u043E\u0433\u0435\u0439
   --online                 \u043E\u0442\u043A\u0440\u044B\u0442\u044C \u0432 \u043E\u043D\u043B\u0430\u0439\u043D-\u044D\u043C\u0443\u043B\u044F\u0442\u043E\u0440\u0435 rk86.ru
 
 \u041F\u0440\u0438\u043C\u0435\u0440\u044B:
@@ -3210,6 +3392,8 @@ async function main() {
   const screenFile = arg(args, "--screen");
   const snapshotFile = arg(args, "--snapshot");
   const goViaMonitor = arg(args, "-G", undefined, addrRe, parseAddr);
+  const colorIdx = arg(args, "--color", "0", /^[0-3]$/, (v) => parseInt(v, 10)) ?? 0;
+  const colorMode = COLOR_MODES[colorIdx];
   let inputSeq = arg(args, "--input");
   if (goViaMonitor !== undefined) {
     const hex2 = goViaMonitor.toString(16).toUpperCase();
@@ -3229,8 +3413,11 @@ async function main() {
   const machine = machineBuilder;
   machine.ui = new TerminalUI;
   machine.memory = new Memory(machine);
+  io.input = (port) => machine.memory.read(port | port << 8);
+  io.output = (port, w8) => machine.memory.write(port | port << 8, w8);
   machine.cpu = new I8080(machine);
   machine.screen = new Screen(machine);
+  machine.screen.color_mode = colorMode;
   machine.tape = new Tape(machine);
   machine.runner = new Runner(machine);
   machine.memory.update_ruslat = machine.ui.update_ruslat;