forterp 0.1.0__py3-none-any.whl

forterp/__init__.py

@@ -0,0 +1,142 @@
+"""forterp -- a configurable FORTRAN-66 / DEC FORTRAN-10 interpreter in Python.
+
+A configurable FORTRAN-66 interpreter: the machine value model (`Target`) and the
+front-end dialect (`Dialect`) are both pluggable. The default target is NATIVE (a
+portable 64-bit host); PDP10 (36-bit, packed ASCII, .TRUE.=-1) is the faithful DEC
+FORTRAN-10 target, selected with `Engine(..., target=PDP10)`.
+
+Quick start::
+
+    import forterp
+    eng = forterp.run_source('''      PROGRAM HI
+          WRITE(6,10)
+     10   FORMAT(' HELLO, WORLD')
+          END
+    ''', printer=print)
+
+Public API (see ``__all__``):
+    run_source(text, ...)       -- parse + run a source string; returns the Engine
+    parse_source(text, ...)     -- parse source -> {name: ProgramUnit} (raises ParseError)
+    f66, fortran10              -- prebuilt, ready-to-run interpreters (the easy path:
+                                   forterp.fortran10.run_source(src) / .parse_dir(dir) /
+                                   .build_engine(units)); Interpreter to roll your own
+    F66, FORTRAN10, Dialect     -- the front-end dialect (F66 is the default; FORTRAN10 the
+                                   DEC superset: octal / tab-format / '!' / free-form input)
+    NATIVE, PDP10, VAX, Target  -- the machine value model (NATIVE 64-bit is the default;
+                                   PDP10 the 36-bit DEC target; VAX provisional)
+    ParseError, SourceOptions   -- the parse error, and source-recovery options (orthogonal
+                                   to the dialect; default: no recovery)
+
+Expert surfaces live behind explicit namespaces (the package root exposes only the names in
+``__all__`` above -- there are no back-compat aliases):
+    forterp.frontend  -- lexer + parser stages (scan_file, parse_units, tokenize, ...)
+    forterp.format    -- the FORMAT engine (parse_format, render, read_values, ...)
+    forterp.runtime   -- the Engine and engine builders (Engine, Frame, make_engine, ...)
+    forterp.hostlib   -- declarative marshalling for host-defined builtins
+    forterp.ast       -- the AST node classes the parser produces
+    forterp.debug     -- OOB-access census + the interactive tracer / profiler
+"""
+
+# The package root exposes ONLY the focused public surface (see __all__). Everything else --
+# the Engine and builders, the lexer/parser stages, the FORMAT engine, the AST nodes -- lives
+# in the expert namespaces (forterp.frontend / .format / .runtime / .ast / .hostlib), imported
+# at the bottom of this module. There are no back-compat root aliases.
+from forterp.dialect import F66, FORTRAN10, Dialect
+from forterp.interpreter import Interpreter, f66, fortran10
+from forterp.parser import ParseError
+from forterp.source import SourceOptions
+from forterp.target import NATIVE, PDP10, VAX, Target
+from forterp.uuolib import UnmodeledMonitorTable
+
+# The one place the version is written. pyproject.toml reads it via
+# [tool.setuptools.dynamic] (attr = "forterp.__version__"), so the package metadata and
+# this attribute can never drift apart.
+__version__ = "0.1.0"
+
+# The complete public surface: the package root exposes exactly these names. Everything else
+# lives in the expert namespaces (forterp.frontend / .format / .runtime / .ast / .hostlib).
+__all__ = [
+    # parse + run
+    "run_source",
+    "parse_source",
+    # prebuilt interpreters and the class behind them
+    "f66",
+    "fortran10",
+    "Interpreter",
+    # dialects
+    "F66",
+    "FORTRAN10",
+    "Dialect",
+    # machine value models
+    "NATIVE",
+    "PDP10",
+    "VAX",
+    "Target",
+    # commonly-needed types
+    "ParseError",
+    "SourceOptions",
+    "UnmodeledMonitorTable",
+]
+
+
+def parse_source(text, dialect=F66, on_error=None, options=None, include_dir="."):
+    """Parse FORTRAN source text into a {name: ProgramUnit} dict.
+
+    `dialect` selects the language (F66 default / FORTRAN10 superset). `options` is a
+    `SourceOptions` for source-recovery handling (orthogonal to the dialect; default is
+    no recovery). `include_dir` is the base directory INCLUDE targets resolve
+    against (default the current directory; the CLI passes the source file's directory).
+
+    Raises ``ParseError`` on malformed source, with every diagnostic in the message --
+    invalid statements are NOT silently dropped. Pass ``on_error(statement, message)``
+    to instead receive each diagnostic yourself and keep the (partial) result.
+    """
+    from forterp.parser import parse_units
+    from forterp.source import DEFAULT_OPTIONS, expand_includes, scan_text
+
+    errs = []
+    cb = on_error if on_error is not None else (lambda st, m: errs.append((st.line, m)))
+    opts = options if options is not None else DEFAULT_OPTIONS
+    stmts = expand_includes(
+        scan_text(text, dialect=dialect, options=opts).statements, include_dir, dialect=dialect
+    )
+    units = {u.name: u for u in parse_units(stmts, dialect=dialect, on_error=cb)}
+    if on_error is None and errs:
+        raise ParseError("parse error(s):\n" + "\n".join(f"  line {ln}: {m}" for ln, m in errs))
+    return units
+
+
+def run_source(
+    text, program=None, dialect=F66, options=None, include_dir=".", setup=None, **kwargs
+):
+    """Parse + run a FORTRAN source string; return the Engine to inspect its state.
+    `program` selects the main PROGRAM (defaults to the first program unit). `options`
+    is an optional `SourceOptions` for source-recovery handling. `include_dir` is the
+    base directory for INCLUDE resolution (default the current directory). `setup` is an
+    optional `fn(eng)` called after the engine is built and the runtime/builtins installed,
+    but before the program runs -- the place to register OPEN devices, prime COMMON, or do
+    any host-side engine setup the program needs."""
+    from forterp.runtime import default_terminal_echo, make_engine
+
+    units = parse_source(text, dialect=dialect, options=options, include_dir=include_dir)
+    eng = make_engine(units, dialect=dialect, **kwargs)
+    # Default terminal-echo control: unless the caller wired its own `set_echo`, honor the
+    # program's ECHOON/ECHOFF on an interactive tty (no-op off a terminal), restored after.
+    restore = None
+    if "set_echo" not in kwargs:
+        set_echo, restore = default_terminal_echo()
+        if set_echo is not None:
+            eng._set_echo = set_echo
+    if setup is not None:
+        setup(eng)
+    try:
+        return eng.run_program(program)
+    finally:
+        if restore is not None:
+            restore()
+
+
+# Expert namespaces -- the organized API beyond the focused public names above:
+# forterp.frontend (lexer/parser), .format (FORMAT engine), .runtime (Engine + builders),
+# .ast (AST nodes), .hostlib (host-builtin marshalling), .debug (OOB census + tracer).
+from forterp import ast, debug, format, frontend, hostlib, runtime  # noqa: E402,F401

forterp/__main__.py

@@ -0,0 +1,7 @@
+"""`python -m forterp ...` -> the general CLI driver (forterp.cli:main)."""
+
+import sys
+
+from forterp.cli import main
+
+sys.exit(main())

forterp/ast.py

@@ -0,0 +1,7 @@
+"""The AST node types produced by the parser (expert API).
+
+A namespace alias for `forterp.ast_nodes`: the node classes the front end builds and the
+engine walks. Useful for tooling that inspects or transforms parsed programs.
+"""
+
+from forterp.ast_nodes import *  # noqa: F403  (re-export the node classes)

forterp/ast_nodes.py

@@ -0,0 +1,259 @@
+"""AST node definitions for FORTRAN-66 / DEC FORTRAN-10.
+
+Expressions and executable statements are dataclasses.  Program-unit-level
+declaration information (types, arrays, commons, parameters, data, formats)
+lives on ProgramUnit rather than as statement nodes, because the executor runs
+a flat statement list with a label table + DO-stack (FORTRAN's arbitrary GOTOs
+into/out of "blocks" make a nested-block AST counterproductive).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+# --- type aliases: the contracts the parser produces and the engine consumes ------
+# `from __future__ import annotations` keeps field annotations lazy (strings), so these
+# document intent for readers/tooling at no import-time cost. There is no static checker
+# in the build; they are precise documentation, not enforced types.
+Expr = Union[
+    "IntLit",
+    "RealLit",
+    "OctalLit",
+    "Complex",
+    "StrLit",
+    "LogicalLit",
+    "Var",
+    "Ref",
+    "Unary",
+    "Binary",
+]
+IoItem = Union[Expr, "ImpliedDo"]  # an I/O list element: an expression or an implied-DO
+FormatRef = Union[int, str, None]  # FORMAT label, '*' (list-directed), or None (unformatted)
+Dims = list[tuple[int, int]]  # array bounds: [(lo, hi), ...]
+
+
+# ---------------------------------------------------------------- expressions
+@dataclass
+class IntLit:
+    value: int
+
+
+@dataclass
+class RealLit:
+    value: float
+
+
+@dataclass
+class OctalLit:
+    value: int
+
+
+@dataclass
+class Complex:  # complex constant (re, im) -- V5 Ch4
+    re: Expr
+    im: Expr
+
+
+@dataclass
+class StrLit:
+    value: str  # raw characters; packed to a word at eval time
+
+
+@dataclass
+class LogicalLit:
+    value: bool
+
+
+@dataclass
+class Var:
+    name: str  # scalar variable / bare function name
+
+
+@dataclass
+class Ref:
+    name: str  # NAME(args): array element OR function call
+    args: list[Expr]
+
+
+@dataclass
+class Unary:
+    op: str  # 'NOT' | '-' | '+'
+    operand: Expr
+
+
+@dataclass
+class Binary:
+    op: str  # OR AND EQ NE LT LE GT GE + - * / ^
+    left: Expr
+    right: Expr
+
+
+# ----------------------------------------------------------------- statements
+@dataclass
+class Stmt:
+    label: Optional[int] = None
+    file: str = ""
+    line: int = 0
+
+
+@dataclass
+class Assign(Stmt):
+    target: Optional[Expr] = None  # Var or Ref
+    expr: Optional[Expr] = None
+
+
+@dataclass
+class Goto(Stmt):
+    target: int = 0
+
+
+@dataclass
+class CompGoto(Stmt):
+    labels: list[int] = field(default_factory=list)
+    index: Optional[Expr] = None
+
+
+@dataclass
+class AssignLabel(Stmt):  # ASSIGN <label> TO <var>  (tgt avoids Stmt.label)
+    tgt: int = 0
+    var: str = ""
+
+
+@dataclass
+class AssignedGoto(Stmt):  # GO TO <var> [,(label-list)]
+    var: str = ""
+    labels: list[int] = field(default_factory=list)
+
+
+@dataclass
+class IfLogical(Stmt):
+    cond: Optional[Expr] = None
+    stmt: Optional[Stmt] = None  # embedded statement
+
+
+@dataclass
+class IfBranch(Stmt):
+    """Arithmetic IF (3 labels) or logical two-way IF (2 labels)."""
+
+    cond: Optional[Expr] = None
+    labels: list[int] = field(default_factory=list)
+
+
+@dataclass
+class Do(Stmt):
+    var: str = ""
+    start: Optional[Expr] = None
+    stop: Optional[Expr] = None
+    step: Optional[Expr] = None  # may be None -> 1
+    term_label: int = 0
+
+
+@dataclass
+class Continue(Stmt):
+    pass
+
+
+@dataclass
+class EntryStmt(Stmt):  # ENTRY name(args) -- alternate subprogram entry point
+    name: str = ""
+    params: list[str] = field(default_factory=list)
+
+
+@dataclass
+class EncDec(Stmt):  # ENCODE/DECODE(count, fmt, buf) iolist -- internal fmt I/O
+    decode: bool = False
+    count: Optional[Expr] = None
+    fmt: FormatRef = None
+    buf: Optional[Expr] = None
+    items: list[IoItem] = field(default_factory=list)
+
+
+@dataclass
+class Call(Stmt):
+    name: str = ""
+    args: list[Expr] = field(default_factory=list)
+
+
+@dataclass
+class Return(Stmt):
+    expr: Optional[Expr] = None  # RETURN e  -> alternate (multiple) return
+
+
+@dataclass
+class LabelArg:  # $nnn / *nnn actual arg = alternate-return target
+    label: int = 0
+
+
+@dataclass
+class StopStmt(Stmt):
+    code: Optional[Expr] = None
+
+
+@dataclass
+class PauseStmt(Stmt):  # PAUSE [n] -- print and continue (batch behavior)
+    code: Optional[Expr] = None
+
+
+@dataclass
+class TypeStmt(Stmt):  # TYPE fmt, iolist  (terminal output)
+    fmt: FormatRef = None  # label int, or '*'
+    items: list[IoItem] = field(default_factory=list)
+
+
+@dataclass
+class AcceptStmt(Stmt):  # ACCEPT fmt, iolist  (terminal input)
+    fmt: FormatRef = None
+    items: list[IoItem] = field(default_factory=list)
+    reread: bool = False  # REREAD: re-parse the last input record
+
+
+@dataclass
+class IoStmt(Stmt):  # READ/WRITE (unit[,fmt][,specs]) iolist
+    mode: str = ""  # 'READ' | 'WRITE'
+    unit: Optional[Expr] = None
+    fmt: FormatRef = None  # label int, '*', or None (unformatted)
+    specs: dict[str, object] = field(default_factory=dict)  # e.g. {'END': 450}
+    items: list[IoItem] = field(default_factory=list)
+
+
+@dataclass
+class FileCtl(Stmt):  # OPEN/CLOSE/REWIND (specs...)
+    verb: str = ""
+    specs: dict[str, object] = field(default_factory=dict)
+
+
+@dataclass
+class DefineFile(Stmt):  # DEFINE FILE u(m,n,U,v) [,...] (V5 10.3.5)
+    defs: list[dict] = field(default_factory=list)  # [{unit,maxrec,recsize,assoc}, ...]
+
+
+@dataclass
+class ImpliedDo:  # io-list element: ( items, var=e1,e2[,e3] )
+    items: list[IoItem]
+    var: str
+    start: Expr
+    stop: Expr
+    step: Optional[Expr]
+
+
+# --------------------------------------------------------------- program unit
+@dataclass
+class ProgramUnit:
+    kind: str  # 'program' | 'subroutine' | 'function'
+    name: str
+    params: list[str] = field(default_factory=list)
+    ret_type: Optional[str] = None  # for typed functions
+    implicit: dict[str, str] = field(default_factory=dict)  # letter -> type
+    types: dict[str, str] = field(default_factory=dict)  # name -> type
+    arrays: dict[str, Dims] = field(default_factory=dict)  # name -> [(lo,hi), ...]
+    consts: dict[str, object] = field(default_factory=dict)  # PARAMETER name -> value
+    commons: list[tuple[str, list]] = field(default_factory=list)  # (block, [(name, dims)])
+    data: list[tuple] = field(default_factory=list)  # (targets, values)
+    externals: set[str] = field(default_factory=set)
+    formats: dict[int, str] = field(default_factory=dict)  # label -> raw format text
+    code: list[Stmt] = field(default_factory=list)  # executable Stmt list
+    labels: dict[int, int] = field(default_factory=dict)  # label -> index into code
+    stmt_funcs: dict[str, tuple] = field(default_factory=dict)  # name -> ([param, ...], expr)
+    namelists: dict[str, list] = field(default_factory=dict)  # group -> [item nodes] (V5 Ch11)
+    equivs: list[list] = field(default_factory=list)  # EQUIVALENCE groups [[(name,[subs]),...],...]

forterp/cli.py

@@ -0,0 +1,219 @@
+"""Command-line front-ends over the forterp engine.
+
+Three console entry points (declared in pyproject [project.scripts]):
+  pyf66        run a source file as strict ANSI FORTRAN-66 (dialect F66)
+  pyfortran10  run it as DEC FORTRAN-10 (dialect FORTRAN10 -- the DEC superset)
+  forterp      general driver; --std selects the dialect (default f66)
+
+Each reads a .FOR file, runs its main program, and wires the program's terminal and
+line-printer output to stdout and READ/ACCEPT to stdin. The dialect-named commands are
+thin presets over `forterp` itself -- like g77/gfortran over gcc.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import os
+import sys
+
+import forterp
+from forterp.forbin import Dec10FloatError
+
+_TARGETS = forterp.target.TARGETS
+_DIALECTS = forterp.dialect.DIALECTS
+
+
+def _load_builtins(paths):
+    """Import each ``.py`` path as a module and collect what it provides: the host routines it
+    declares (``{name: fn}``, via `forterp.hostlib.builtins_in`) and any module-level
+    ``register(eng)`` hook. The file's directory is put on ``sys.path`` so sibling modules can
+    import each other; the module executes on import (it is host code, like any plugin loader).
+
+    Returns ``(table, hooks)``. ``register(eng)`` lets a dropped-in module do engine setup the
+    auto-discovered builtins can't express -- register an OPEN device (``eng.register_device``),
+    prime COMMON, inject a monitor facade -- and is called after the engine is built.
+
+    The directory is on ``sys.path`` and the module is in ``sys.modules`` only for the duration
+    of loading (so sibling imports resolve by name); both are restored afterward, so loading a
+    file named like a stdlib module (``time.py``) doesn't leave it shadowing later imports in an
+    in-process caller. The loaded routines keep working -- they hold the module's namespace
+    directly, independent of ``sys.modules``."""
+    table, hooks = {}, []
+    inserted = []  # sys.path dirs we added (remove exactly these afterward)
+    saved = {}  # modname -> (was_present, prior) so sys.modules can be put back
+    try:
+        for path in paths:
+            directory = os.path.dirname(os.path.abspath(path)) or "."
+            if directory not in sys.path:
+                sys.path.insert(0, directory)
+                inserted.append(directory)
+            modname = os.path.splitext(os.path.basename(path))[0]
+            if modname not in saved:  # record the pre-existing entry once
+                saved[modname] = (modname in sys.modules, sys.modules.get(modname))
+            spec = importlib.util.spec_from_file_location(modname, path)
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[modname] = module  # so dataclasses / sibling imports resolve by name
+            spec.loader.exec_module(module)
+            table.update(forterp.hostlib.builtins_in(module))
+            hook = getattr(module, "register", None)
+            if callable(hook):
+                hooks.append(hook)
+        return table, hooks
+    finally:  # un-pollute the global import state (do not leak into an embedding process)
+        for directory in inserted:
+            try:
+                sys.path.remove(directory)
+            except ValueError:
+                pass
+        for modname, (was_present, prior) in saved.items():
+            if was_present:
+                sys.modules[modname] = prior
+            else:
+                sys.modules.pop(modname, None)
+
+
+def _run(argv, dialect, prog, *, allow_std, default_target="native"):
+    ap = argparse.ArgumentParser(prog=prog, description=__doc__.strip().splitlines()[0])
+    ap.add_argument("--version", action="version", version=f"%(prog)s {forterp.__version__}")
+    ap.add_argument(
+        "file",
+        nargs="*",
+        help="FORTRAN source file(s) to run (several are linked together by unit name into one "
+        "program); any *.py argument is imported and its @fcall/@uuo host routines "
+        "registered, and its optional register(eng) hook called for engine setup "
+        "(OPEN devices, COMMON priming); omit all for interactive mode",
+    )
+    ap.add_argument(
+        "--target",
+        choices=_TARGETS,
+        default=default_target,
+        help=f"machine value model (default: {default_target} for {prog})",
+    )
+    ap.add_argument(
+        "--program", metavar="NAME", help="main PROGRAM unit to run (default: the first)"
+    )
+    ap.add_argument(
+        "--check",
+        action="store_true",
+        help="parse and report all diagnostics; do not run (compile-check)",
+    )
+    ap.add_argument(
+        "--recover-shifted-cols",
+        action="store_true",
+        help="recover statement text reindented past column 72 (off by default -- a faithful "
+        "FORTRAN-10 compiler drops cols 73+); for a deck nudged a column or two to the right",
+    )
+    ap.add_argument(
+        "--no-wrap",
+        action="store_true",
+        help="disable the FORTRAN-10 terminal free-CR-LF wrap at column 80 (TOPS-10 .TONFC); "
+        "no effect under strict F66, which never wraps",
+    )
+    if allow_std:
+        ap.add_argument(
+            "--std",
+            choices=_DIALECTS,
+            default="f66",
+            help="language dialect (default: f66 = strict ANSI; fortran10 = DEC superset)",
+        )
+    args = ap.parse_args(argv)
+    std = args.std if allow_std else ("fortran10" if dialect is forterp.FORTRAN10 else "f66")
+    dialect = _DIALECTS[std]
+    options = forterp.SourceOptions(recover_shifted_cols=args.recover_shifted_cols)
+
+    # *.py args are Python host-routine modules; everything else is FORTRAN source.
+    py_files = [p for p in args.file if p.endswith(".py")]
+    src_files = [p for p in args.file if not p.endswith(".py")]
+
+    if not src_files:  # no FORTRAN to run
+        if py_files:
+            ap.error("Python builtin module(s) given but no FORTRAN source to run")
+        if args.check:
+            ap.error("--check requires a file")
+        from forterp.command import CommandProcessor
+
+        return CommandProcessor(std=std, target=args.target, program=args.program).run()
+
+    try:  # several FORTRAN files are concatenated, then linked together by unit name
+        text = "\n".join(open(p, "r", errors="replace").read() for p in src_files)
+    except OSError as e:
+        ap.error(str(e))
+    name = " + ".join(os.path.basename(p) for p in src_files)
+    # INCLUDE targets resolve against the (first) source file's directory, not the cwd.
+    include_dir = os.path.dirname(src_files[0]) or "."
+
+    if args.check:  # compile-check: list every %FTN diagnostic, don't run
+        diags = []
+        units = forterp.parse_source(
+            text,
+            dialect=dialect,
+            include_dir=include_dir,
+            options=options,
+            on_error=lambda st, m: diags.append(m),
+        )
+        if diags:
+            print(f"?{name}: {len(diags)} error(s)", file=sys.stderr)
+            for d in diags:
+                print(f"  {d}", file=sys.stderr)
+            return 1
+        print(f"[{name}: {len(units)} unit(s) OK]")
+        return 0
+
+    try:  # a bad builtins module is a clean ?-diagnostic, not a traceback
+        builtins, hooks = _load_builtins(py_files) if py_files else ({}, [])
+    except Exception as e:
+        print(f"?loading {', '.join(py_files)}: {e}", file=sys.stderr)
+        return 1
+
+    try:
+        forterp.run_source(
+            text,
+            program=args.program,
+            dialect=dialect,
+            options=options,
+            include_dir=include_dir,
+            target=_TARGETS[args.target],
+            builtins=builtins or None,  # host routines from the *.py args (after STDLIB)
+            setup=(lambda eng: [h(eng) for h in hooks]) if hooks else None,  # register(eng) hooks
+            emit=sys.stdout.write,  # TYPE / terminal output -> stdout
+            printer=sys.stdout.write,  # line-printer (units 3/6) -> stdout
+            readline=sys.stdin.readline,  # READ / ACCEPT <- stdin
+            tty_autowrap=not args.no_wrap,  # FORTRAN-10 free-CR-LF wrap at col 80 unless --no-wrap
+            # echo control (ECHOON/ECHOFF) -> run_source's default_terminal_echo on a real tty
+        )
+    except forterp.ParseError as e:
+        print(e, file=sys.stderr)
+        return 1
+    except (forterp.fmt.InputConversionError, Dec10FloatError) as e:
+        # bad numeric field / unrepresentable float in binary I/O, no ERR= -> clean halt
+        print(f"?{e}", file=sys.stderr)
+        return 1
+    except forterp.engine.StopExecution:
+        return 0  # explicit STOP: normal termination (run_program also swallows it)
+    except (RuntimeError, ValueError, ArithmeticError, RecursionError, OSError, ImportError) as e:
+        # any other runtime fault (undefined unit/label/routine, step budget, bad dimension,
+        # deep recursion, a file error, or a host .py module whose basename shadows a stdlib
+        # import) -> a clean ?-diagnostic, never a raw traceback
+        print(f"?{e}", file=sys.stderr)
+        return 1
+    return 0
+
+
+def f66_main(argv=None):
+    """`pyf66`: run a source file as strict ANSI FORTRAN-66."""
+    return _run(argv, forterp.F66, "pyf66", allow_std=False)
+
+
+def f10_main(argv=None):
+    """`pyfortran10`: run a source file as DEC FORTRAN-10 (the DEC superset) on the PDP-10 machine.
+
+    Defaults to the PDP10 target -- matching the prebuilt `forterp.fortran10` interpreter -- since
+    DEC FORTRAN-10 *is* the DECsystem-10 (36-bit words, packed ASCII, .TRUE.=-1); pass
+    `--target native` for the DEC language on the portable 64-bit machine instead."""
+    return _run(argv, forterp.FORTRAN10, "pyfortran10", allow_std=False, default_target="pdp10")
+
+
+def main(argv=None):
+    """`forterp`: general driver; `--std f66|fortran10` selects the dialect (default f66)."""
+    return _run(argv, forterp.F66, "forterp", allow_std=True)