Files
pplus-web/src/core/inputnote.ts
T
alexm e092cb029c
Build, test, deploy / site (push) Failing after 15m13s
Initial commit
2026-11-12 22:24:02 -05:00

77 lines
4.5 KiB
TypeScript

// SPDX-FileCopyrightText: 2026 Scientific Computing Studio, LLC
// SPDX-License-Identifier: Apache-2.0
/**
* Mojo 1.1.0 and 1.2.0 give every `input()` call a buffered reader of its own. When the input arrives all at once
* (a pipe, as on godbolt, where Compile & run sends the input box as the program's stdin), the first call reads
* every line into its buffer and keeps the rest, so the second call finds nothing left and raises EOF. Programming+'s
* Run view hands out one line per call, as a terminal does (core/docs/trust.md). The Compiler view says so when it
* matters: when a program that may call `input()` more than once was sent with input.
*
* "May call more than once" is decided from the text alone, erring toward saying it: more than one call site, a
* call inside a loop (or a comprehension), or a call inside any function other than `main`, which can be called
* any number of times. Strings and comments are not calls (core's Mojo lexer reads them). DOM-free.
*/
import { lex, type Tok } from '#core/mojo/lex.js';
export interface InputReads {
/** The lines with an `input(` call, in order. */
lines: number[];
/** Why the program may read input more than once, or null when it reads it at most once. */
why: 'several' | 'loop' | 'function' | null;
}
const LOOPS = new Set(['for', 'while']);
export function inputReads(source: string): InputReads {
let toks: Tok[];
try { toks = lex(source).tokens; } catch { return { lines: [], why: null }; }
const lines: number[] = [];
let inLoop = false, inHelper = false;
// one entry per open block: whether it is a loop body, and whether it is a function other than main
const blocks: Array<{ loop: boolean; helper: boolean }> = [];
let lineLoop = false, lineHelper = false; // what the logical line now being read opens
let atStart = true;
const depthLoop = () => blocks.some((b) => b.loop);
const depthHelper = () => blocks.some((b) => b.helper);
let pending = 0; // calls on the logical line being read, settled at its end
const endLine = () => {
if (pending && (lineLoop || depthLoop())) inLoop = true;
if (pending && (lineHelper || depthHelper())) inHelper = true;
pending = 0;
};
for (let i = 0; i < toks.length; i++) {
const t = toks[i];
if (t.kind === 'newline' || t.kind === 'eof') { endLine(); atStart = true; continue; }
if (t.kind === 'indent') { endLine(); blocks.push({ loop: lineLoop, helper: lineHelper }); lineLoop = false; lineHelper = false; atStart = true; continue; }
if (t.kind === 'dedent') { endLine(); blocks.pop(); atStart = true; continue; }
if (atStart) { lineLoop = false; lineHelper = false; atStart = false; }
if (t.kind !== 'name') continue;
if (LOOPS.has(t.text)) lineLoop = true; // a loop statement, or a comprehension on this line
if (t.text === 'def' && toks[i + 1]?.kind === 'name' && toks[i + 1].text !== 'main') lineHelper = true;
if (t.text === 'input' && toks[i + 1]?.text === '(' && toks[i - 1]?.text !== '.' && toks[i - 1]?.text !== 'def') { lines.push(t.line); pending++; }
}
endLine();
const why = lines.length > 1 ? 'several' : inLoop ? 'loop' : inHelper ? 'function' : null;
return { lines, why };
}
/**
* The note the Compiler view shows for a program sent with `stdin`, or null when none is needed: no input was
* sent, or the program reads it at most once.
*/
export function inputNote(source: string, stdin: string): string | null {
if (!stdin.trim()) return null;
const r = inputReads(source);
if (!r.why) return null;
const where = r.why === 'several' ? `calls input() on lines ${listLines(r.lines)}` : r.why === 'loop' ? `calls input() in a loop (line ${r.lines[0]})` : `calls input() in a function that can run more than once (line ${r.lines[0]})`;
return `This program ${where}. In Mojo 1.2.0 each input() call reads through a buffer of its own, and here the input arrives all at once: the first call takes every line, and the next one stops with EOF. That is the compiler's run, not a mistake in your input. The Run view hands out one line per call, as typing at a terminal does.`;
}
function listLines(ns: number[]): string {
const u = [...new Set(ns)];
if (u.length <= 1) return String(u[0] ?? '');
const shown = u.slice(0, 4).map(String);
if (u.length > 4) return `${shown.join(', ')} and ${u.length - 4} more`;
return `${shown.slice(0, -1).join(', ')} and ${shown[shown.length - 1]}`;
}